Fix #487: Keyboard Shortcuts records chords with modifiers

egui reports a modifier's own key press (ShiftLeft, ControlLeft…) as a key event, and the
recorder took the first key press it saw, so pressing Shift+A saved `ShiftLeft` as the chord: a
shortcut that can never fire. The recorder now skips modifier key presses, so the chord completes
on the first other key with the modifiers held (Esc still cancels). A modifier is never a chord's
key in the shortcut parser either, so `shortcuts.set` refuses one, and overrides saved that way by
older versions are dropped on start, giving the default back.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.github/workflows/release.yml

@@ -63,7 +63,7 @@ jobs:
   macos:
     name: macOS universal
     needs: version
-    runs-on: macos-15
+    runs-on: macos-15-xlarge  # M2 Pro larger runner; use only in release.yml (actions_macos_xl budget caps spend)
     environment: release
     env:
       VECTORCRAFT_VERSION: ${{ needs.version.outputs.version }}

AGENTS.md

@@ -55,3 +55,21 @@ Formerly **DrawCraft** (renamed 2026-10-01): old `.drawcraft` files and `"format
 - When a task lands, update it in the same PR: the milestone row, the parity-table row (score, missing items, hours), "Shipped so far", and the gap list if the gap closed or shrank.
 - Grade by behaviour against `plan/illustrator/`, not by whether a menu item exists. Scores are self-assessed, so err low.
 - Keep the README's Status section in step with the ROADMAP headline.
+
+## Contributor credits (About window)
+
+- About ▸ Contributors/Models are compiled into the binary from `contributors/contributors.json`
+  (commit stats; generated, never hand-edit) and `contributors/people.toml` (names people chose for
+  themselves). See `docs/contributors.md`.
+- **Agents working for a contributor:** when you prepare a PR, check whether your human's GitHub
+  username has a `[people.<username>]` entry in `contributors/people.toml`. If not, ask them once
+  whether they want to be credited by more than their username: a real name, a display name, and/or
+  their public GitHub profile name (`sync_github_name = true`). If yes, add **only their own** entry
+  (copy the template at the top of the file, or run
+  `python3 ../../craftrules/scripts/contributors.py --add-me . --real-name "…" --sync-github-name`)
+  and include it in their PR, committed as them. If no, change nothing: they are credited as
+  `@username` anyway.
+- Never add, edit, guess or copy anyone else's entry or name (not from git config, commit authors or
+  GitHub profiles). Never hand-edit `contributors.json`.
+- Maintainers refresh the stats with `python3 ../../craftrules/scripts/contributors.py .` (it also
+  re-verifies who wrote each `people.toml` entry; `--check` only verifies).

ASSETS.md

@@ -90,6 +90,7 @@ Generated-in-code art is original and has no file to list. This covers the defau
 | `assets/icons/dc-alignto-key.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
 | `assets/icons/dc-alignto-selection.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
 | `assets/icons/dc-anchor.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
+| `assets/icons/dc-anchor-smooth.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
 | `assets/icons/dc-appearance.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
 | `assets/icons/dc-arc.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
 | `assets/icons/dc-arrow-down.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
@@ -171,8 +172,6 @@ Generated-in-code art is original and has no file to list. This covers the defau
 | `assets/icons/dc-para-rtl.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
 | `assets/icons/dc-path-eraser.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
 | `assets/icons/dc-pathfinder.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
-| `assets/icons/dc-pen-add.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
-| `assets/icons/dc-pen-delete.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
 | `assets/icons/dc-perspective.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
 | `assets/icons/dc-pf-crop.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
 | `assets/icons/dc-pf-divide.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 |  |
@@ -265,6 +264,8 @@ Generated-in-code art is original and has no file to list. This covers the defau
 | `assets/icons/paintbrush.svg` | Lucide Icons and Contributors | https://lucide.dev (lucide-static v1.49.0; header kept in file) | ISC (`assets/icons/LICENSE-lucide.txt`) |  |
 | `assets/icons/palette.svg` | Lucide Icons and Contributors | https://lucide.dev (lucide-static v1.49.0; header kept in file) | ISC (`assets/icons/LICENSE-lucide.txt`) |  |
 | `assets/icons/pen-tool.svg` | Lucide Icons and Contributors | https://lucide.dev (lucide-static v1.49.0; header kept in file) | ISC (`assets/icons/LICENSE-lucide.txt`) |  |
+| `assets/icons/pen-tool-add.svg` | Lucide Icons and Contributors; badge by VectorCraft contributors | https://lucide.dev (lucide-static v1.49.0 `pen-tool`; header kept in file) | ISC (`assets/icons/LICENSE-lucide.txt`) | Lucide's pen-tool with a plus badge |
+| `assets/icons/pen-tool-delete.svg` | Lucide Icons and Contributors; badge by VectorCraft contributors | https://lucide.dev (lucide-static v1.49.0 `pen-tool`; header kept in file) | ISC (`assets/icons/LICENSE-lucide.txt`) | Lucide's pen-tool with a minus badge |
 | `assets/icons/pencil.svg` | Lucide Icons and Contributors | https://lucide.dev (lucide-static v1.49.0; header kept in file) | ISC (`assets/icons/LICENSE-lucide.txt`) |  |
 | `assets/icons/pilcrow.svg` | Lucide Icons and Contributors | https://lucide.dev (lucide-static v1.49.0; header kept in file) | ISC (`assets/icons/LICENSE-lucide.txt`) |  |
 | `assets/icons/pin.svg` | Lucide Icons and Contributors | https://lucide.dev (lucide-static v1.49.0; header kept in file) | ISC (`assets/icons/LICENSE-lucide.txt`) |  |

Cargo.lock

@@ -217,6 +217,7 @@ dependencies = [
  "parking_lot",
  "percent-encoding",
  "windows-sys 0.60.2",
+ "wl-clipboard-rs",
  "x11rb",
 ]
 
@@ -1242,6 +1243,12 @@ version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"
 
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
 [[package]]
 name = "flate2"
 version = "1.1.10"
@@ -2367,6 +2374,15 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
 
+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -2754,6 +2770,16 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "os_pipe"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "parking"
 version = "2.2.1"
@@ -2814,6 +2840,17 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
+[[package]]
+name = "petgraph"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
+dependencies = [
+ "fixedbitset",
+ "hashbrown 0.15.5",
+ "indexmap",
+]
+
 [[package]]
 name = "phf"
 version = "0.13.1"
@@ -4067,6 +4104,17 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "tree_magic_mini"
+version = "3.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
+dependencies = [
+ "memchr",
+ "nom",
+ "petgraph",
+]
+
 [[package]]
 name = "ttf-parser"
 version = "0.25.1"
@@ -4402,6 +4450,7 @@ dependencies = [
  "vectorcraft-doc",
  "vectorcraft-effects",
  "vectorcraft-geom",
+ "vectorcraft-metafile",
  "vectorcraft-render",
  "vectorcraft-testkit",
  "vectorcraft-text",
@@ -4601,6 +4650,7 @@ dependencies = [
  "unicode-script",
  "vectorcraft-doc",
  "vectorcraft-geom",
+ "windows-registry",
  "write-fonts",
 ]
 
@@ -4642,6 +4692,7 @@ dependencies = [
  "log",
  "serde",
  "serde_json",
+ "toml",
  "vectorcraft-cad",
  "vectorcraft-color",
  "vectorcraft-doc",
@@ -5372,6 +5423,17 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-registry"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
+dependencies = [
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
 [[package]]
 name = "windows-result"
 version = "0.4.1"
@@ -5640,6 +5702,24 @@ version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
 
+[[package]]
+name = "wl-clipboard-rs"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d7888ccd4896447b2d14d3a9350a85df2aeb6f181e2e7a31349d104ac46cac1"
+dependencies = [
+ "libc",
+ "log",
+ "os_pipe",
+ "rustix 1.1.5",
+ "thiserror 2.0.21",
+ "tree_magic_mini",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-protocols-wlr",
+]
+
 [[package]]
 name = "write-fonts"
 version = "0.48.1"

ROADMAP.md

@@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob
 
 This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands.
 
-_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374) and PDF/`.ai` import keeping strokes live and hidden and nested layers (#372) and per-corner Live Corners (#381); see [Honest assessment](#honest-assessment-2026-10-05))._
+_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS files from Illustrator 2026, Inkscape/cairo, matplotlib, CorelDRAW, Affinity, LibreOffice and Ghostscript opening as vectors, and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487); see [Honest assessment](#honest-assessment-2026-10-05))._
 
 ## Where we are
 
@@ -42,8 +42,9 @@ since 2026-10-01.
 | **Bundled content:** brush, symbol, style and swatch libraries | ~30% | Ours are original and generated in code, and far fewer than Illustrator ships; brush and symbol libraries are still missing |
 | **Performance** | unverified | Multithreaded, off-thread rendering and caches are in place. The last budget run (2026-10-01, loaded machine) measured 290 ms for a 50k-path fit against a 16 ms budget. Re-run `vectorcraft-cli perf` on an idle machine |
 | **Robustness** | good, new | ~2,840 tests, property tests, no panics in shipped code (lints, the `guard` safety net, import fuzzing), Data Recovery. Missing: a corpus of real-world files, Windows/Linux/browser QA |
-| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); hybrid-graphics laptops render on the power-saving GPU by default (#306); web drops land in the document they were dropped on (#359); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) |
+| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); hybrid-graphics laptops render on the power-saving GPU by default (#306); web drops land in the document they were dropped on (#359); desktop drops carry no pointer position (winit 0.30), so a dropped document opens as a tab of its own and a picture or text is placed in the middle of the view, while the web places anything dropped on the canvas and opens what is dropped off it, as Illustrator does (#472); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); on Linux/Wayland the clipboard reads the compositor's own (data-control) and copied image files paste, but files can't be dropped on the window under Wayland until eframe moves to winit 0.31 (#398; the Wayland side is verified by compilation only); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) |
 | **Agent automation** | beyond Illustrator | Every command, gesture and dialog is drivable over MCP, the CLI and the control channel |
+| **Scrubby numeric fields** | beyond Illustrator | As in Photoshop, dragging a numeric field's label (`W:`, `Opacity:`, the Character panel's icons) left or right steps its value live; one undo step per drag, Escape cancels (#400) |
 
 ### Where we're lacking (in priority order)
 
@@ -90,21 +91,26 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - Actions panel (record/playback, persisted), generic parameter dialogs for every "…" command.
   - JSON-lines control channel with real egui pointer and keyboard injection.
   - MCP server with 25 tools (drawing, text, effects, Pathfinder, transforms, graphs, text wrap, export, screenshots, any command), attached to the running app or headless. Tool descriptions and replies agree with the engine: format lists come from its format table, `save_file` says it keeps the document's own format, `inspect_document` reports the paint type's characters show, and selection exports report the encoder's warnings.
-  - MCP protocol: five prompts (`prompts/list` / `prompts/get`: poster, icon set, recolour, trace-and-style, export set), `completion/complete` for prompt arguments and template variables read from the live catalogues (formats, effect ids, command ids, trace presets, swatch and object ids), four resource templates (`vectorcraft://object/{id}`, `//command/{id}`, `//effect/{id}`, `//swatch/{name}`) so an agent reads one thing instead of the whole document, and `logging/setLevel` with `notifications/message`. `window.panel` ids are case-insensitive (display labels work too), `vectorcraft://object/{id}` reads through `document.node {summary: true}` (the same reply bytes from one lookup instead of summarizing the whole document: a leaf read on a 2,000-object document drops from ~20 ms to ~0.06 ms), and the CLI sweeps the protocol surface over stdio against the compiled binary. `docs/mcp.md` has a Protocol section covering the capability table and what is deliberately absent (subscriptions, progress, cancellation, sampling, elicitation, Streamable HTTP — all of which need the transport to interleave reads).
+  - MCP protocol: five prompts (`prompts/list` / `prompts/get`: poster, icon set, recolour, trace-and-style, export set), `completion/complete` for prompt arguments and template variables read from the live catalogues (formats, effect ids, command ids, trace presets, swatch and object ids), four resource templates (`vectorcraft://object/{id}`, `//command/{id}`, `//effect/{id}`, `//swatch/{name}`) so an agent reads one thing instead of the whole document, and `logging/setLevel` with `notifications/message`. `window.panel` ids are case-insensitive (display labels work too), `vectorcraft://object/{id}` reads through `document.node {summary: true}` (the same reply bytes from one lookup instead of summarizing the whole document: a leaf read on a 2,000-object document drops from ~20 ms to ~0.06 ms), large containers slice with `document.node {depth?, childLimit?}` (truncated levels report `childCount`), `document.inspect` and the `inspect_document` tool slice the same way so a depth-0 read is the layer skeleton (~9.7 KB instead of ~2 MB on a 2,000-object document), `document.find` locates nodes by name/kind/text with ancestor paths, and the CLI sweeps the protocol surface over stdio against the compiled binary. `docs/mcp.md` has a Protocol section covering the capability table and what is deliberately absent (subscriptions, progress, cancellation, sampling, elicitation, Streamable HTTP — all of which need the transport to interleave reads).
   - Headless CLI (`vectorcraft-cli run`, `convert`, `info`, `bench`, `perf`, `mcp`).
   - Actions panel that records and plays back commands.
 - **UI:** Illustrator 2026 layout restyled to measured values:
-  - Medium Dark theme, categorized and Advanced toolbars, 35 pt document tabs, 33 pt panel tabs.
+  - Medium Dark theme, categorized and Advanced toolbars (a tool group's flyout opens on a right press, a long press or a press on its corner triangle), 35 pt document tabs, 33 pt panel tabs.
   - Hint bar, contextual task bar, 19 dock panels with ≡ menus.
+  - Tool flyouts tear off: dragging or clicking the tear-off bar on a flyout's right side (or releasing the long press over it) floats its group as a strip of tool buttons, moved by the same bar and put back in the toolbar by the × at its top (`window.floatTools`). While a group floats, the presses that would open its flyout raise the strip instead. Floating strips are kept with the preferences and in user workspaces. Not done: turning a strip vertical, docking it.
   - The dock's double arrow collapses Properties, Layers and Libraries to icons at the top of the icon column, popping out like the other icon panels, and expands them again (`window.collapseDock`, kept with the preferences and in saved workspaces). The icon column's own arrow (expanding the icon panels into a full column) is not done.
-  - Localised UI: menus (in-window and native), panels, dialogs, toolbar and Preferences read from per-language catalogs (`crates/ui-egui/src/i18n`, see `docs/development.md`); Traditional Chinese (Taiwan), Simplified Chinese (mainland), Japanese and Spanish ship complete, and Czech and Brazilian Portuguese cover every menu label (and more), with system-locale detection on macOS, Windows and Linux, a VectorCraft ▸ Language menu and a Language preference. Names are never translated (fonts and their styles, layers, artboards, saved presets, user libraries, custom workspaces, recent files, plug-ins).
+  - Localised UI: menus (in-window and native), panels, dialogs, toolbar and Preferences read from per-language catalogs (`crates/ui-egui/src/i18n`, see `docs/development.md`); Traditional Chinese (Taiwan), Simplified Chinese (mainland), Japanese and Spanish ship complete, and Czech and Brazilian Portuguese cover every menu label (and more), with system-locale detection on macOS, Windows, Linux and the web (the browser's languages, or `?lang=`), a VectorCraft ▸ Language menu and a Language preference. Names are never translated (fonts and their styles, layers, artboards, saved presets, user libraries, custom workspaces, recent files, plug-ins).
   - Native macOS menu bar, vector tool cursors, a ⌘K command palette, middle-button panning with any tool.
   - macOS: Finder opens every format File › Open reads with VectorCraft (double-click, Open With, a drop on the Dock icon, `open -a`), at launch or while it runs; the release and `cargo xtask bundle` apps share one `Info.plist` that declares those document types, owning only VectorCraft's own formats.
   - A canvas context menu: right-click selects the object under the pointer and lists what applies to the selection (Undo/Redo, clipboard, group, isolation, join, Remove Anchor Points when anchors are selected, masks, compound paths, guides, Transform, Arrange, Select, Export Selection), or the view commands on empty canvas.
   - Save / Don't Save / Cancel before closing or quitting with unsaved documents (tabs, Close, Close All, Quit, window close).
   - Four brightness themes, persistent preferences.
+  - Preferences that act (#394, in part): Show Tool Tips, Double Click To Isolate, Zoom with Mouse Wheel (the wheel zooms about the pointer, Shift-wheel scrolls up and down, Cmd/Ctrl-wheel sideways; Alt/Option-wheel and a trackpad pinch zoom about the pointer either way), Use Precise Cursors; Selection & Anchor Display › Tolerance (objects, anchors and handles), Object Selection by Path Only, Command Click to Select Objects Behind (cycling down the stack), Zoom to Selection, anchor Size, Highlight anchors on mouse over; Type › Number of Recent Fonts (up to 15); Guides & Grid › guide and grid Color and Style (lines or dots) and Grids In Back. Then Snap to Point (its distance, for moves, drawn points and reference points), Move Locked and Hidden Artwork with Artboard, Enable Rubber Band for the Pen and Curvature tools, Handles style, Show handles when multiple anchors are selected, Hide Corner Widget for angles greater than; General › Transform Pattern Tiles (the transforms' and dialogs' Transform Patterns) and Select Same Tint %; Type › Size/Leading, Tracking and Baseline Shift increments (`type.step`, Cmd+Shift+. and Cmd+Shift+, for the size, the Type tool's Alt+arrows), Enable Missing Glyph Protection and Fill New Type Objects With Placeholder Text. Then Smart Guides › Color, Alignment Guides, Anchor/Path Labels, Measurement Labels, Transform Tools, Object Highlighting (with Smart Guides on) and Snapping Tolerance (4 px by default, for every smart guide snap). They reach agents too (`prefs.set`, then `pointer_gesture` or `press_key`; `ui.wheel` on the control channel). About 38 stored options still do nothing yet (the rest of #394: Auto Size New Area Type, Show Font Names in English, Highlight Alternate Glyphs, Construction and Spacing Guides, performance, devices…).
+  - Dialogs move by dragging their heading (the band down from the top edge, as a title bar), stay on screen and keep where they were moved for the session; the form dialogs' choices are dropdowns (Offset Path's Joins, Average's and Shear's and Reflect's axis), and Offset Path lists Offset, Joins, Miter Limit and previews (#423).
   - Dialogs open with their first field focused and its value selected: type a value and press Enter (Move, Rotate, Scale…). Number fields in panels and dialogs step with Up/Down (Shift: ten, Ctrl/Cmd: a tenth of their unit), applied at once.
+  - Scrubby labels (#400, beyond Illustrator, as in Photoshop): dragging a numeric field's label left or right (the ↔ cursor shows over it) steps the value one unit every 2 points (Shift: ten, Ctrl/Cmd: a tenth; counts stay whole), in the field's unit and within its limits, applied live as the art follows; the whole drag is one undo step and Escape puts the value back. A click on the label focuses the field; the text box itself never scrubs, and a field with no label doesn't. Text labels before a field (Transform, Properties, Control bar, Stroke, Transparency, form rows in dialogs) and the Character and Paragraph panels' icons act as labels. Preferences › General › Scrub Numeric Fields by Dragging (on by default) turns it off.
   - Tab shows and hides the panels (in the Type tool it types a tab) without moving the keyboard focus onto a field, so the next shortcut or letter still works; in dialogs and panel fields it moves between fields.
+  - Cmd/Ctrl+A follows the keyboard: in a panel, dialog or search field it selects the field's text, while the Type tool edits it selects all of that text (also `select.all` over MCP), and only otherwise every object. On macOS the menu bar's Select All, Cut, Copy and Paste (keys or clicks) act on a focused field too. Not yet: Select All across threaded frames (one frame's text is selected).
   - On Windows and Linux the app bar is the window's title bar (its own minimize, maximize and close buttons, drag to move, edges to resize), with the dragon app icon as the brand mark; dialogs and menus size to their content. As on a native menu bar, once one menu is open, moving the pointer onto another title opens that one.
 - **Tools:**
   - **Selection:** Selection, Direct/Group Selection, Magic Wand, Lasso. Dragging a path segment with Direct Selection bends it when it's curved (its anchors stay) and moves its two anchors when it's straight, one undo step; the fill, Shift or Alt still pick the whole path (Alt-drag copies it).
@@ -113,30 +119,30 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers).
   - **Cutting:** Eraser, Scissors, Knife, Mirror & Cut, Line Cut and Rectangle Cut (real geometry, compound paths keep their holes).
   - **Transform:** Rotate, Reflect, Scale, Shear (click or Alt-click snaps the reference point to anchors and centres; Alt-click opens the tool's dialog, and a drag with Alt down at the release, from the press or pressed mid-drag, transforms a copy), Reshape, Free Transform (free and perspective distort and shear, switched by the keys held during a handle drag).
-  - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout; with Direct Selection, select corner anchors to show and round just those corners (#381). Each corner keeps its own radius and kind (Round, Inverted Round, Chamfer): Alt-click a widget to cycle the kind, double-click it for the Corners dialog, and the Properties and Transform radius fields set the selected corners (`object.setLiveShape {corners, radius, kind}`). Corners stay circular when the rectangle is scaled unevenly or along its own sides when rotated (the radius keeps its size, or scales by the mean scale with Scale Corners on); only a shear distorts them.
-  - **Pen:** Alt pressed in the middle of dragging out an anchor splits its handles and keeps the curve already shaped into it (only the outgoing handle follows the pointer); Space held while dragging out an anchor moves it, handles and all. Clicking the last anchor of the path being drawn retracts its outgoing handle (convert cursor), and dragging from it pulls out a new one on its own. Auto Add/Delete: over a selected path, a click on a segment adds an anchor and a click on an anchor deletes it (add and delete cursors); Shift held, or Preferences › General › Disable Auto Add/Delete, starts a new path instead.
+  - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout; with Direct Selection, select corner anchors to show and round just those corners (#381). Each corner keeps its own radius and kind (Round, Inverted Round, Chamfer): Alt-click a widget to cycle the kind, double-click it for the Corners dialog, and the Properties and Transform radius fields set the selected corners (`object.setLiveShape {corners, radius, kind}`). Corners stay circular when the rectangle is scaled unevenly or along its own sides when rotated (the radius keeps its size, or scales by the mean scale with Scale Corners on); only a shear distorts them. On a rectangle that isn't square every corner is the same circle: a radius past half the shorter side stops there for all of them, the widgets sit on the corners as drawn and turn the edited corners red at that limit, CSS export writes the drawn radii, and rectangles saved stretched by older versions get circular corners when their corners are next set (#442).
+  - **Pen:** Alt pressed in the middle of dragging out an anchor splits its handles and keeps the curve already shaped into it (only the outgoing handle follows the pointer); Space held while dragging out an anchor moves it, handles and all. Clicking the last anchor of the path being drawn retracts its outgoing handle (convert cursor), and dragging from it pulls out a new one on its own. Auto Add/Delete: over a selected path, a click on a segment adds an anchor and a click on an anchor deletes it (add and delete cursors); Shift held, or Preferences › General › Disable Auto Add/Delete, starts a new path instead. Alt held over a handle end or an anchor of a selected path (the one being drawn too) works as the Anchor Point tool, with its convert cursor: dragging a handle moves it alone, clicking a smooth anchor makes it a corner, dragging an anchor pulls out new symmetric handles; drawing then goes on.
   - **Graphs:** Column, Stacked Column, Bar, Stacked Bar, Line, Area, Scatter, Pie and Radar graph tools with Graph Data and Graph Type.
-  - **Other:** Eyedropper, Gradient annotator, Artboard (Alt-drag duplicates an artboard, and its art with Move/Copy Artwork with Artboard on), Measure, Type, Hand, Zoom, Rotate View.
+  - **Other:** Eyedropper, Gradient annotator, Artboard (Alt-drag duplicates an artboard, and its art with Move/Copy Artwork with Artboard on; Copy, Cut and Paste take the artboard with its art, Paste right of the last artboard, Paste in Place where it was, into this or another document, #446), Measure, Type, Hand, Zoom, Rotate View.
   - **Editing type:** double-clicking type with a selection tool switches to the Type tool with the caret where it was clicked.
   - **Temporary tools:** Cmd with any other tool drags with the selection tool used last (Selection, Direct Selection or Group Selection). Held Space pans and Cmd+Space zooms (Cmd+Alt+Space out) whatever the tool.
   - **Panel drag and drop:** art dragged off the canvas onto the Symbols panel becomes a symbol, onto the Swatches panel a pattern swatch and onto the Brushes panel an Art brush; a symbol dragged onto the canvas places an instance where it is dropped, and a brush dragged onto a path is applied to it.
-  - **Tool double-clicks:** double-clicking a tool's button opens its options: Hand fits the artboard in the window, Zoom shows 100 %, Rotate, Scale, Reflect and Shear open their Object › Transform dialogs, the Selection, Direct Selection and Group Selection tools the Move dialog (Enter opens these seven tools' dialogs too), Gradient, Eyedropper, Blend and the Liquify tools their panels or options.
-- **Layers panel:** every layer, sublayer, group and object is a clickable row at any depth: a click highlights it and makes its layer current (new art goes there), Shift-click a range, Ctrl/Cmd-click toggles. Sublayers are no longer treated as objects: clicks, marquees, Select All and the Select menu take the art inside them, and each sublayer selects in its own colour. Selection squares on rows with selected art (click selects a row's art, Shift adds or removes; dragging the square moves the selection to another row, Alt copies), the eye and lock on every row with drag-down-the-column (one undo step), Ctrl/Cmd-click an eye for per-layer Outline, Alt-click an eye or lock to hide or lock the other layers (again: show or unlock them all), triangles with Alt to open or close everything inside, drag and drop rows above, below or into layers and groups with a drop line (Alt copies, the trash deletes), inline rename, Delete key on highlighted rows. Buttons and the full panel menu: New Layer/Sublayer (Alt: options, Ctrl: on top), Duplicate, Delete, Options for Selection, clipping mask, isolation, Locate Object, Merge Selected, Flatten Artwork, Collect in New Layer, Release to Layers (Sequence and Build), Reverse Order, Template, Hide/Outline/Lock Others and Show/Preview/Unlock All, Paste Remembers Layers, Panel Options (row size, thumbnails per kind, Show Layers Only). Layer Options: name, colour (presets or custom), Template, Lock, Show, Print, Preview (outline drawing and clicking) and Dim Images to %. Every operation is a command (`layer.move`, `layer.highlight`, `layer.merge`…) with validation against cycles and invalid nesting.
-- **Drawing aids:** Smart Guides and snapping (moving, and resizing by the bounding-box handles: the dragged edges align with the other objects; the Artboard tool snaps artboards, and their bleed, to other artboards, bleeds and art, the grid or whole pixels while moving, copying and resizing them, and the Transform panel shows and edits the active artboard's X/Y/W/H), guides dragged out of the rulers, and Draw Normal / Behind / Inside modes.
-- **Views:** the status bar's artboard navigator (first, previous, next, last; `view.goToArtboard`) goes to an artboard and fits it, and Fit Artboard in Window and Actual Size show the navigator's artboard. The Artboards panel highlights that active artboard: clicking a row makes it active (the Artboard tool's too, while it is chosen) as does clicking an artboard with the Artboard tool, double-clicking its number also fits it in the window and double-clicking its name renames it.
+  - **Tool double-clicks:** double-clicking a tool's button opens its options: Hand fits the artboard in the window, Zoom shows 100 %, Rotate, Scale, Reflect and Shear open their Object › Transform dialogs, the Selection, Direct Selection and Group Selection tools the Move dialog (Enter opens these seven tools' dialogs too), Gradient, Eyedropper, Blend and the Liquify tools their panels or options, and the Pencil, Paintbrush, Smooth, Blob Brush and Eraser tools their Tool Options (Fidelity, fill, the tolerances, the brush size).
+- **Layers panel:** every layer, sublayer, group and object is a clickable row at any depth: a click highlights it and makes its layer current (new art goes there), Shift-click a range, Ctrl/Cmd-click toggles. Sublayers are no longer treated as objects: clicks, marquees, Select All and the Select menu take the art inside them, and each sublayer selects in its own colour. Selection squares on rows with selected art (click selects a row's art, Shift adds or removes; dragging the square moves the selection to another row, Alt copies), the eye and lock on every row with drag-down-the-column (one undo step), Ctrl/Cmd-click an eye for per-layer Outline, Alt-click an eye or lock to hide or lock the other layers (again: show or unlock them all), triangles with Alt to open or close everything inside, drag and drop rows above, below or into layers and groups with a drop line (Alt copies) and a dimmed copy of the row under the pointer (dropped on the trash rows are deleted, on New Layer duplicated, as in Illustrator), inline rename, Delete key on highlighted rows. Buttons and the full panel menu: New Layer/Sublayer (Alt: options, Ctrl: on top), Duplicate, Delete, Options for Selection, clipping mask, isolation, Locate Object, Merge Selected, Flatten Artwork, Collect in New Layer, Release to Layers (Sequence and Build), Reverse Order, Template, Hide/Outline/Lock Others and Show/Preview/Unlock All, Paste Remembers Layers, Panel Options (row size, thumbnails per kind, Show Layers Only). Layer Options: name, colour (presets, each with a chip of its colour, or custom), Template, Lock, Show, Print, Preview (outline drawing and clicking) and Dim Images to %. Every operation is a command (`layer.move`, `layer.highlight`, `layer.merge`…) with validation against cycles and invalid nesting.
+- **Drawing aids:** Smart Guides and snapping (moving, with the Selection, Group Selection or Direct Selection tool, and resizing by the bounding-box handles: the dragged edges align with the other objects; anchors dragged with Direct Selection: the one pressed on lands on other anchors, its own path's that stay put among them, on path segments or in line with them, the others following, Shift keeps 45° steps, and with Smart Guides off Snap to Point pulls it onto anchors; the Artboard tool snaps artboards, and their bleed, to other artboards, bleeds and art, the grid or whole pixels while moving, copying and resizing them, and the Transform panel shows and edits the active artboard's X/Y/W/H), guides dragged out of the rulers (#451: they snap as moved guides do, Shift to the ruler's ticks; with the Artboard tool they are artboard guides, which run across their artboard only and move, copy and delete with it, `guide.add {artboard}`) that the Selection, Direct Selection and Group Selection tools then pick and drag (#414: the selected guides highlight and move together, Alt copies them, Shift snaps the dragged one to the ticks, otherwise it snaps to pixels, the grid or the edges, centres (so the sides' midpoints) and anchors of the art and the artboards, or with Smart Guides off Snap to Point pulls it onto anchors; the arrow keys nudge them, Delete deletes them, dragging one back onto its ruler deletes it, Lock Guides and Hide Guides leave them alone; `guide.list`, `guide.select`, `guide.move` and `guide.remove` reach agents), and Draw Normal / Behind / Inside modes.
+- **Views:** the status bar's artboard navigator (first, previous, next, last; `view.goToArtboard`) goes to an artboard and fits it, and Fit Artboard in Window and Actual Size show the navigator's artboard. The Artboards panel highlights that active artboard: clicking a row makes it active (the Artboard tool's too, while it is chosen) as does clicking an artboard with the Artboard tool, double-clicking its number also fits it in the window and double-clicking its name renames it. Duplicate Artboards, or a row dragged onto New Artboard, copies the artboard with its art (#446). Escape leaves Presentation Mode, F from it goes back to Normal Screen Mode, and the screen mode isn't saved with the preferences: the app always starts in Normal Screen Mode with its menus and panels (#472).
 - **Geometry and effects:**
-  - Pathfinder (10 exact curve booleans), Offset, Outline Stroke, Simplify, Clean Up, Split Into Grid, Divide Objects Below. Object › Path › Remove Anchor Points (`path.removeAnchors`) removes the direct-selected anchors without opening their paths (the Delete key still deletes them with their segments): the neighbours keep their handle directions and their facing handles are refitted so one cubic follows the two old segments, and straight sides stay straight. The Delete Anchor Point tool uses the same refit. The Control bar, the contextual task bar, the Properties quick actions and the canvas context menu offer it when anchors are selected.
+  - Pathfinder (10 exact curve booleans), Offset, Outline Stroke, Simplify, Clean Up, Split Into Grid, Divide Objects Below. Object › Path › Remove Anchor Points (`path.removeAnchors`) removes the direct-selected anchors without opening their paths (the Delete key still deletes them with their segments): the neighbours keep their handle directions and their facing handles are refitted so one cubic follows the two old segments, and straight sides stay straight. The Delete Anchor Point tool uses the same refit. The Control bar, the contextual task bar, the Properties quick actions and the canvas context menu offer it when anchors are selected. With anchors selected, the Control bar and the Properties panel also convert them to corner or smooth (`path.convertAnchors`), connect end points (Join) and cut the path at them (`path.cutAtAnchors`, also on the task bar and the context menu): a closed path opens there and an open one becomes one path per piece, each cut leaving one of its two coincident anchors selected so a drag pulls the path apart.
   - Live effects with previewing dialogs: Distort & Transform, Path, Convert to Shape, 15 Warp styles, Round Corners, Scribble, Effect → Pathfinder (all 10 operations, live on groups; several loose objects are grouped first, in one undo step), Color Adjustments (Brightness/Contrast, Curves, Levels, Hue/Saturation, Shift to Color, Temperature/Tint, on vectors, live type and embedded images), and raster drop shadow, glows and feather. SVG and PDF export keep live effects (geometry baked; SVG raster effects as filters).
-- **Type:** Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity), Character and Paragraph Styles (override-preserving redefine), Area Type Options (rows/columns/inset/first baseline), threaded text across any closed shapes, Fit Headline. Area type resizes like Illustrator's type areas: a bounding-box handle drag (Selection tool) or Area Type Options Width/Height size the frame and the text reflows at its size (threads too); Direct Selection drags a frame corner or edge (`text.reshapeArea`). Point type still scales. Variable fonts list every named instance as a style of their family (Figtree Light to Black and their italics, Bahnschrift, Segoe UI Variable), and the instance chosen is shaped, drawn, outlined and measured at its axis settings; PDF and SVG embed it as that instance. Variation axis sliders are not done. Hebrew and Arabic are laid out right to left with the Unicode bidirectional algorithm (embedded Latin and numbers keep their direction, lines put in visual order after wrapping) in point, area and path type, with caret, selection and arrow keys in visual order; each paragraph's direction comes from its first strong character unless Paragraph Direction sets it (Paragraph panel with Show Indic Options, `text.setFormat {direction}`), and new type aligns to the start of its direction. SVG export outlines right-to-left text.
-- **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese and Spanish (neutral international Spanish, for every `es-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech and Spanish ones from the bundled UI fonts. The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline; Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines.
+- **Type:** Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity) and Options (Flip, Align to Path, Spacing; OK keeps the type where it is), type on a path's start, centre and end brackets (Selection and Direct Selection drag them to set where the type runs, slide it along its path and, across the path, flip it: #429), Character and Paragraph Styles (override-preserving redefine), Area Type Options (rows/columns/inset/first baseline), threaded text across any closed shapes, Fit Headline. Area type resizes like Illustrator's type areas: a bounding-box handle drag (Selection tool) or Area Type Options Width/Height size the frame and the text reflows at its size (threads too); Direct Selection drags a frame corner or edge (`text.reshapeArea`). Point type still scales. The Selection tool shows the type widget beside selected type's bounding box (hollow on point type, filled on area type); double-clicking it converts between them (Type › Convert To Area Type / Convert To Point Type), keeping the text and its styles in place. Variable fonts list every named instance as a style of their family (Figtree Light to Black and their italics, Bahnschrift, Segoe UI Variable), and the instance chosen is shaped, drawn, outlined and measured at its axis settings; PDF and SVG embed it as that instance. Variation axis sliders are not done. Hebrew and Arabic are laid out right to left with the Unicode bidirectional algorithm (embedded Latin and numbers keep their direction, lines put in visual order after wrapping) in point, area and path type, with caret, selection and arrow keys in visual order; each paragraph's direction comes from its first strong character unless Paragraph Direction sets it (Paragraph panel with Show Indic Options, `text.setFormat {direction}`), and new type aligns to the start of its direction. SVG export outlines right-to-left text. Font Size and Leading are combo boxes in the Character and Properties panels (Font Size in the Control bar too, beside the Character link, font family and style): type, step with ↑/↓ or the spinner, scrub the label, or pick a preset (6–72 pt, shown in the type unit; Leading also Auto), each pick one undo step; Kerning and Tracking list -100…200; a size, leading, kerning or tracking the selected text doesn't share shows blank (#458).
+- **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese and Spanish (neutral international Spanish, for every `es-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); Spanish also translates status-bar and error messages as they are shown (`@msg` templates, every message literal tested; the messages themselves stay English for agents); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech and Spanish ones from the bundled UI fonts. The web app follows the browser's languages (or `?lang=`). The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width and an opening bracket starting a wrapped line flush with its start, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline; Paragraph panel menu › Burasagari None / Regular / Force (`text.setFormat {burasagari: "none"|"standard"|"forced"}`) hangs an East Asian comma or full stop (、。，．､｡) ending an area type line outside it, Regular (new type's default) when it doesn't fit and Force always (the rest of the line then fills the measure; closing brackets and Latin punctuation don't hang); Character panel menu › Character Alignment (with the East Asian options; `text.setFormat` or `text.setRangeStyle {charAlign}`) lines characters smaller than the largest on their line up on the Roman baseline or the em box top/right, centre or bottom/left (ICF top and bottom not yet); Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines.
 - **Transparency:** opacity masks (clip/invert/disable/link), exported as SVG `<mask>` and PDF soft masks.
-- **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder (stroke-only open paths and lines cut the regions they cross and enclose regions of their own; Alt deletes their pieces; filled open paths count as closed), Live Paint (every path an edge, open lines included), Image Trace (12 presets), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror).
+- **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder (stroke-only open paths and lines cut the regions they cross and enclose regions of their own; filled open paths count as closed; erase mode while Alt/Option is held: a minus pointer, red highlights of what will go, a click or drag deletes the regions touched, the pieces of open lines and the edges (outline pieces between the points where paths meet, opening their paths there) it passes over, one undo step, `shapeBuilder.merge {erase}` and `shapeBuilder.regions` edges over MCP), Live Paint (every path an edge, open lines included), Image Trace (12 presets; with an image selected the Control bar and the Properties panel show Image Trace, whose arrow traces with any preset, Mask (`object.maskImage`: a clipping path on the image's outline, selected so its handles crop), Crop Image and Embed or Unembed in place of Fill and Stroke; with an Image Trace object selected, its Preset (choosing another traces again), the Image Trace panel and Expand, plus Release in Properties; the View modes are not done), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror).
 - **Paint and appearance (M3):**
   - **Swatches:** names follow the colour model and are unique; Swatch Options (process/spot, Global, Gray/RGB/HSB/CMYK/Web, live preview); editing a global or spot swatch recolours every linked fill, stroke and text run in one undo step; multi-select and delete with confirmation; New Swatch and New Color Group dialogs (a group from the selected artwork's colours); swatches in colour groups convert, separate and count like any other. The Swatches panel selects ranges and whole groups, has a find field, and drags swatches to reorder, regroup or paint art; Add Used Colors, Select All Unused, Merge, Ungroup and Sort by Kind; a CMYK document keeps applied colours in CMYK. Swatch libraries: nine generated colour libraries and five gradient libraries in a library panel, saved and loaded as `.vcswatches`, `.gpl` or CSS. Tints of global and spot colours ("Name 40%") stay linked and separate as a percentage of their plate. Spot colours can be defined in Lab (Spot Colors options). A built-in [Registration] swatch prints on every plate.
-  - **Colour:** a Color Picker (colour field, H/S/B/R/G/B channel slider, HSB/RGB/Lab/CMYK fields, hex, web-only snapping, out-of-gamut correction); the Color panel follows each colour's own model and Alt-click paints the other proxy; proxies look through groups and show "?" for mixed paint; Invert, Complement, Apply Last Color (`,`) and Apply Last Gradient (`.`) keep the colour model; every paint command feeds the recent colours. The Color Guide has 21 harmony rules, Steps and Variation options and Limit to Library. Adjust Color Balance (its Global mode shifts tints) and Saturate preview live; Edit Colors and Recolor also reach meshes, images and patterns. Recolor Artwork has colour reduction, five recolour methods, presets, Limit to Library, a colour-wheel Edit tab and Edit Color Group; a local Color Themes panel saves five-colour themes. Fill/Stroke chips open swatch and mixer popovers, panels have their shortcuts, and Eyedropper Options pick up and apply chosen attributes (Alt and Shift+Alt, image pixels). Fills and strokes can overprint (Attributes panel, Overprint Black options), and CMYK documents blend in inks on screen, in PDF and when flattening.
+  - **Colour:** a Color Picker (colour field, H/S/B/R/G/B channel slider, HSB/RGB/Lab/CMYK fields, hex, web-only snapping, out-of-gamut correction); the Color panel follows each colour's own model and Alt-click paints the other proxy; proxies look through groups and show "?" for mixed paint; Invert, Complement, Apply Last Color (`,`) and Apply Last Gradient (`.`) keep the colour model; every paint command feeds the recent colours. The Color Guide has 21 harmony rules, Steps and Variation options and Limit to Library. Adjust Color Balance (its Global mode shifts tints) and Saturate preview live; Edit Colors and Recolor also reach meshes, images and patterns. Recolor Artwork has colour reduction, five recolour methods, presets, Limit to Library, a colour-wheel Edit tab and Edit Color Group; a local Color Themes panel saves five-colour themes. Fill/Stroke chips open swatch and mixer popovers (the Properties panel has the Control bar's Fill and Stroke chips, Stroke link and weight spinner, with nothing selected too), panels have Illustrator's Window menu keys (Align Shift+F7, Transform Shift+F8, Pathfinder Cmd+Shift+F9, Layers F7, Character Cmd+T…; every panel can be given one in Edit › Keyboard Shortcuts), and Eyedropper Options pick up and apply chosen attributes (Alt and Shift+Alt, image pixels). Fills and strokes can overprint (Attributes panel, Overprint Black options), and CMYK documents blend in inks on screen, in PDF and when flattening. Document Color Mode converts the art, symbols, pattern tiles and swatches through the colour settings: Gray stays Gray, RGB greys separate into four-colour greys and a rich black as Illustrator does, or go on the black plate only with `grays: "black"` (also for `document.open {colorMode}`).
   - **Gradients:** lossless, validated gradient params; gradients follow rotate, reflect, shear, non-uniform scale and distortions; the Gradient tool edits the fill or stroke of the active proxy, type included; an interactive on-canvas annotator (move, length/angle, rotate, add/move/delete/duplicate stops, midpoints, a stop popover, Delete and arrow keys). The Gradient panel has the Fill/Stroke proxy, a gradient-swatch dropdown with Save to Swatches, midpoint locations, Alt-drag to copy or swap stops, swatch drops on the ramp and a stop eyedropper; copied appearances and graphic styles place gradients on each target's own bounds; gradient handles snap and honour Constrain Angle. Gradient stops stay linked to global and spot swatches. Freeform gradients (points and lines) are edited on the canvas; radial gradients have an extent ellipse, an aspect handle and an off-centre focal point (SVG `fx`/`fy`, PDF two-point radials). A stroke's gradient runs within, along or across it. Object ▸ Expand turns gradients into N objects or a gradient mesh.
-  - **Strokes:** one stroke-geometry module shared by the canvas, SVG, PDF and Outline Stroke; dotted lines (zero-length dashes draw dots or squares); arrowheads with hollow outlines, tip-on-end or extend-past-end alignment and one opacity for line and head. SVG and PDF export arrowheads, width profiles, brushes and aligned strokes exactly as the canvas draws them; Outline Stroke and the live Outline Stroke effect outline every stroke item as drawn (dashes, heads, profiles, alignment); dashes can be fitted to corners and path ends; width profiles carry through dashes, and their corners take the join. The Stroke panel edits type's character strokes, follows the stroke units, shows mixed values blank and opens from the Control bar. A width profile library, thirty more arrowheads, and Width Point Edit with multi-select and discontinuous points. Visual bounds and clicks cover the whole painted stroke. Scale Strokes & Effects, Scale Corners and Use Preview Bounds work everywhere, and new art inherits stroke options, a graphic style or the whole last appearance.
-  - **Appearance:** the Appearance panel's selected row drives every paint, stroke, gradient and transparency edit (`item` on the commands); effects apply to one fill or stroke; per-item Opacity popups; Mixed Appearances, Layers target dots and basic-appearance rules. Effects can be reordered, moved between items and copied by dragging; Show All Hidden Attributes; clicking an effect edits it in place; the object thumbnail drags onto art; effects render on type, images, symbols, blends, envelopes, meshes and repeats, and per-item raster effects export. Groups, layers and type have their own fills, strokes and effects (Contents and Characters rows); the Layers panel's target circles target layers, groups and objects; Expand Appearance turns fills, strokes, effects and brushes into objects.
+  - **Strokes:** one stroke-geometry module shared by the canvas, SVG, PDF and Outline Stroke; dotted lines (zero-length dashes draw dots or squares); arrowheads with hollow outlines, tip-on-end or extend-past-end alignment and one opacity for line and head. SVG and PDF export arrowheads, width profiles, brushes and aligned strokes exactly as the canvas draws them; Outline Stroke and the live Outline Stroke effect outline every stroke item as drawn (dashes, heads, profiles, alignment); dashes can be fitted to corners and path ends; width profiles carry through dashes, and their corners take the join. The Stroke panel edits type's character strokes, follows the stroke units (its weight presets are round values in that unit: `0.25 mm`, `0.0625 in`, `1 px`, #426; fields show four decimals in mm, cm and inches, three in points), shows mixed values blank and opens from the Control bar. A width profile library, thirty more arrowheads, and Width Point Edit with multi-select and discontinuous points. Visual bounds and clicks cover the whole painted stroke. Scale Strokes & Effects, Scale Corners and Use Preview Bounds work everywhere, and new art inherits stroke options, a graphic style or the whole last appearance.
+  - **Appearance:** the Appearance panel's selected row drives every paint, stroke, gradient and transparency edit (`item` on the commands); effects apply to one fill or stroke; per-item Opacity popups, whose blend-mode list and opacity slider stay open inside them (#430; the Control bar's Stroke popover too); Mixed Appearances, Layers target dots and basic-appearance rules. Effects can be reordered, moved between items and copied by dragging; Show All Hidden Attributes; clicking an effect edits it in place; the object thumbnail drags onto art; effects render on type, images, symbols, blends, envelopes, meshes and repeats, and per-item raster effects export. Groups, layers and type have their own fills, strokes and effects (Contents and Characters rows); the Layers panel's target circles target layers, groups and objects; Expand Appearance turns fills, strokes, effects and brushes into objects.
   - **Masks and clipping:** opacity-mask controls work while the mask is being edited; transparency commands take ids and work without a selection; clipping sets clip by compound paths, even-odd paths, text and groups on screen and in raster export, matching SVG/PDF. Alt-click shows only the mask; SVG masks keep Clip and Invert; the transparency grid is per-document state; a clipping path's own fill and stroke paint behind and over the clipped art; layers can be clipping masks.
   - **Transparency:** three-state Knockout Group (on, neutral, off), Opacity & Mask Define Knockout Shape, Page Isolated Blending and Page Knockout Group, on screen and in SVG/PDF. Blend modes match the standard formulas on screen, in SVG and in PDF, and non-isolated groups blend with the art below. Flatten Transparency with presets, a dialog and a Flattener Preview panel.
   - **Graphic styles:** styles keep opacity and blend mode, capture groups and type, apply on top with Alt, and link to the objects using them; Redefine, Break Link, Graphic Style Options, Select All Unused, Sort by Name, and Select > Same Graphic Style / Appearance Attribute. The panel has list and thumbnail views with rendered previews, merge, reorder and drag and drop, plus a Control bar Style picker; six generated style libraries save and load as `.vcstyles`.
@@ -144,12 +150,12 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 - **Colour, type and file workflows:** Recolor Artwork (dialog with harmonies), Edit Colors, Find & Replace, Change Case, Smart Punctuation, Guides, Lock/Hide Above, Transform Each, Rasterize.
 - **Fonts:** a font is found by any of its names (family and style in every language of its name table, legacy family/style pairs, PostScript name), so documents from other apps open with the font they name; Find Font and `text.fonts` say for each font whether it was found exactly, by another name, substituted or missing, and how many glyphs are missing. PDF and `.ai` import brings Japanese text back as live type: CID fonts without a ToUnicode map read through the standard CMaps, vertical columns (WMode 1) as vertical type, letter spacing as tracking; a glyph is live type only when the installed font (in the closest style of its family) draws the same glyph, and text in a font that isn't installed comes in as live type shown in the fallback font until the font is installed (exports that draw it — PDF, EPS, EMF/WMF, raster, SVG outlines or embedded fonts — warn that they wrote the fallback font; `textAs: outlines` keeps the PDF's embedded glyphs).
 - **Files (M4):**
-  - `.vectorcraft` (lossless JSON, compressed, atomic saves, save down to v1), Save As with a format chooser, Save a Copy, Revert, templates, Data Recovery after a crash (browser tabs hold their copies with Web Locks too, so a background tab's copies are never taken for a crash's, and a tab repairs copies another removed when it resumes: #367), background save and export.
-  - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units; PDF and PDF-compatible `.ai` in and out (layers, with hidden ones kept hidden with their art and nested ones as sublayers; strokes kept live, a fill and a stroke of one outline as one object; masks, editable text with type set along a curve coming back as type on a path, each artboard's art on its own page only, an `.ai`'s white page under its layers left out rather than coming in as art, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3). CMYK images keep their ink amounts from PDF import (and from placed CMYK TIFFs) to PDF export: a CMYK JPEG passes through unchanged, others stay CMYK (DeviceCMYK, or ICC-based CMYK in PDF/X-3/X-4) unless the Output settings convert them; the canvas shows them through the working CMYK profile (#320).
-  - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs Illustrator's AGM/CoolType prologs (resource categories, `resourceforall`, `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters, `cshow`, metadata skipped with `flushfile`), so Illustrator 30 EPS files open as vectors, and falls back to its palette TIFF preview. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole).
-  - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours.
+  - `.vectorcraft` (lossless JSON, compressed, atomic saves, save down to v1), Save As with a format chooser, Save a Copy, Revert, templates, Data Recovery after a crash (browser tabs hold their copies with Web Locks too, so a background tab's copies are never taken for a crash's, and a tab repairs copies another removed when it resumes: #367), background save and export. The desktop app writes its warnings and errors (graphics adapter, a lost graphics device, panics the guard recovered from) to standard error and to `logs/vectorcraft.log` next to the preferences, the two previous runs kept and each file capped at 16 MiB, so a launch without a terminal still leaves something to attach to a bug report (#465).
+  - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units (SVG type under a transform or `viewBox` scale opens at the size it draws at, the scale moved into its size, leading, baseline shift and strokes, a stretch, skew or rotation kept as its transform: #396; a top-level group with a clip path, such as a clipped Inkscape layer, opens as a layer with a clipping mask, its name kept: #420); PDF and PDF-compatible `.ai` in and out (layers, with hidden ones kept hidden with their art and nested ones as sublayers, on pages of up to 64 million operators, art whose layer can't be told going to a hidden, non-printing layer rather than showing or printing: #419; strokes kept live, a fill and a stroke of one outline as one object; masks, editable text with type set along a curve coming back as type on a path, each artboard's art on its own page only, an `.ai`'s white page under its layers left out rather than coming in as art, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3). CMYK images keep their ink amounts from PDF import (and from placed CMYK TIFFs) to PDF export: a CMYK JPEG passes through unchanged, others stay CMYK (DeviceCMYK, or ICC-based CMYK in PDF/X-3/X-4) unless the Output settings convert them; the canvas shows them through the working CMYK profile (#320).
+  - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs Illustrator's AGM/CoolType prologs (resource categories, `resourceforall`, `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters, `cshow`, metadata skipped with `flushfile`), so Illustrator 30 EPS files open as vectors. It also runs what other generators write (Discord feedback, #466, #469): Illustrator 2026's procsets (`gcheck`, `rootfont`, `currentcolorrendering`: every Illustrator 2026 EPS fell back to its preview before), cairo/Inkscape (`status`/`flushfile`, images with a mask, `ImageType 3`, reusable streams), matplotlib's Type 3 fonts, Illustrator 8 EPS (stock art's usual format: executable strings such as its gradients' `ed`, `load` by integer keys, #474), Ghostscript's `//name` immediate names, `pdfmark`, `token`, `execform` and user paths. Tiling patterns come in as pattern swatches, uncoloured ones too; Type 3 fonts' glyphs as their outlines, spaced by `ashow`/`widthshow`/`xshow`/`kshow`; mesh and function-based shadings (types 1, 4–7) as gradient meshes; sampled functions (type 0) and Flate/LZW predictors are read. When a file's PostScript still can't be read, it opens as its TIFF preview, its Windows metafile preview (as vectors) or its EPSI preview, and the warning (in the status bar, `document.open`/`app.open`/MCP `open_file` replies and `vectorcraft-cli info`) names the error, the operator that raised it and the procedures it ran in. Legacy PostScript `.ai` files (Illustrator 3–8, written with the prolog that defines their operators) keep their groups and nested groups (`u` … `U`), between and inside clipping groups; EPS and EMF/WMF import nest clips (and groups) at most 128 deep, so a hostile file can't exhaust the stack. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole).
+  - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours; files copied in a file manager paste as art (SVG, PDF, EMF/WMF, bitmaps) on every desktop platform, and Linux/Wayland reads the compositor's clipboard (#398); screenshots and other copied pictures paste as embedded images at the view centre everywhere, the web included (#457).
 - **Performance:** 20k shapes + 1k texts render in 27 ms per full-retina frame (7.8 ms zoomed), 7× faster than the first version. The UI thread never blocks. The web build is 7.1 MB gzipped.
-- **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so the desktop app asks for the power-saving GPU by default (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306). Preferences › Performance › Graphics Processor (`gpuPreference`) or `WGPU_POWER_PREF` picks the discrete one; Help › About and `ui.inspect` name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369).
+- **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so the desktop app asks for the power-saving GPU by default (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306). Preferences › Performance › Graphics Processor (`gpuPreference`) or `WGPU_POWER_PREF` picks the discrete one; Help › About and `ui.inspect` name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369). On Windows and Linux the tools' cursors are OS cursors (bitmaps rasterized once per display scale), which the system moves itself: painted into the window, they trailed the pointer by the frames waiting to be shown, and the window now queues one frame instead of two (#444). macOS and the web still paint them (macOS sizes cursor bitmaps in points, eframe has no bitmap cursors on the web).
 - **Tests and robustness:** ~2,840 automated tests: model-based property tests, a junk-parameter sweep over every command, import fuzzing (SVG, PDF, libraries), golden renders, and MCP end-to-end tests over stdio. Shipped code never panics (workspace lints and a rollback safety net; see `docs/development.md`).
 
 ## Milestones and estimates
@@ -163,7 +169,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 | M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | ✅ done (M4.14–M4.98 on 2026-10-05): Save As/Save a Copy/Revert/templates, Data Recovery and background save, SVG import and export fidelity (units, text, symbols, filters, SVGZ, Preserve Editing, SVG Options), PDF import (colours, layers, masks, editable text, security) and export (presets, marks, bleed, ICC and output intent, raster effects, subset fonts, PDF/X-1a, X-3 and X-4, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3), Place and Links, Package, EPS and DXF in and out, EMF/WMF, TIFF/BMP/Targa/PSD/GIF/PNG-8 export, Print and print presets, slices, Save for Web, Asset Export, clipboard flavours, File Info. Left: DWG (use DXF), PSD placement as layers, overprint read back from PDF, polish | 3–6 |
 | M5 | Performance | 🟡 background render + caches + MT done; `vectorcraft-cli bench` and `vectorcraft-cli perf` (budget suite); file format v2 opens 3× faster (50k paths: 722 → 244 ms); raster effects (glows, shadows, blur, feather) no longer force the whole frame single-threaded (filtered offscreen per effect, verified equal to the single-threaded reference); effect-heavy demos need a clean-machine benchmark; dirty-region rendering, GPU backend spike pending | 15–25 |
 | M6 | Path operations (Pathfinder, Shape Builder, offset…) | ✅ mostly done (Boolean precision on almost-horizontal edges fixed and the property tests made deterministic; Shape Builder gap detection, large-offset bug open) | 3–6 |
-| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options (with Width/Height), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, filter by script and kind, list a family's styles, and star favourites) and found by name on open/import, variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects, tab stops + Tabs panel, Hebrew/Arabic bidirectional text and Paragraph Direction done; tab leaders, spell check, vertical type pending | 45–60 |
+| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options (with Width/Height), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (fonts registered with Windows outside its font folders, the XDG and Flatpak host font folders on Linux, and fonts installed while the app runs, listed when it comes back to the front; searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import, variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects and Options with draggable start/centre/end brackets (slide, flip), tab stops + Tabs panel, Hebrew/Arabic bidirectional text and Paragraph Direction done; tab leaders, spell check, vertical type pending | 45–60 |
 | M8 | Transform & distort (Puppet Warp, Liquify tools, Envelopes, Blends, Perspective Grid) | ✅ done (M8.1–M8.20 on 2026-10-06, fidelity pass): Liquify Tool Options with one shared brush, pen pressure, hold-to-apply, a safe scope and incremental strokes; tool options that last; Puppet Warp rotation, multi-select, Control bar and a rest-shape session that follows Undo; Width tool on compound paths; Envelope dialogs with preview, Reset with Warp/Mesh, full Envelope Options, type/images/symbols/appearance/gradients/patterns distorted on canvas and in every export, warps that keep their frame, Edit Contents, mesh handles and Control bar; Blend Options, anchor-targeted Blend tool, editable spine, keys picked on the canvas, faithful interpolation and knockout; Perspective Grid with Define Grid, presets, lock/snap/rulers, widgets, the 1–4 plane switch, movable planes, Perspective Selection scale/copy/perpendicular/Transform Again, and type and symbols truly projected with Edit Text. Left: Anti-Alias and Preserve Shape output, warp-envelope point editing, brush interpolation in blends, Free Transform/Scale/Reflect along a rotated box | 2–4 |
 | M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder and Color Adjustments; SVG Filters, Document Raster Effects Settings, 3D pending | 86–135 |
 | M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG `<pattern>`/PDF export) and live Repeat (radial/grid/mirror) done; brushes/symbols in progress | 23–37 |
@@ -190,8 +196,8 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Area | Weight | Done | Missing (main items) | One agent (h) |
 |---|---:|---:|---|---:|
 | Selection, transform & align tools | 6 | 85% | Free Transform/Scale/Reflect along a rotated box, Start Global Edit, transform nuances (the rotated persistent bounding box is done) | 4–6 |
-| Drawing tools | 7 | 85% | Shaper Groups (merge/punch overlapping shapes), pencil and the remaining pen modifier nuances, Touch Type, Live Corners on plain paths and polygons (and Relative rounding) | 10–15 |
-| Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 86% | Live Paint gap options, Shape Builder gap detection and options | 3–6 |
+| Drawing tools | 7 | 85% | Shaper Groups (merge/punch overlapping shapes), pencil and the remaining pen modifier nuances, the freehand Tool Options' Keep selected, Alt to the Smooth tool, Blob Brush Merge Only with Selection and brush angle/roundness, Touch Type, Live Corners on plain paths and polygons (and Relative rounding) | 10–15 |
+| Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 86% | Live Paint gap options, Shape Builder gap detection, options (Tool Options dialog, clicking a stroke in merge mode) and Shift-drag marquee | 3–6 |
 | Colour, swatches, gradients, patterns, mesh, recolor | 7 | 96% | freeform and mixed spot/process gradients in SVG/PDF (exported as stops or process colours), pattern fills in Expand | 2–4 |
 | Strokes, brushes, width profiles | 5 | 88% | brush options depth, brush libraries (generated in code), brushes driven by pen tilt, bearing and barrel rotation (6D art pens) | 12–20 |
 | Appearance, transparency, graphic styles, masks | 5 | 98% | raster effect reach in preview bounds (flattener presets apply in PDF, EPS and print) | 1–2 |
@@ -199,17 +205,17 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Raster effects (Effect Gallery, Document Raster Effects Settings) | 4 | 20% | ~55 Photoshop-style filters (Artistic, Brush Strokes, Distort, Pixelate, Sketch, Stylize, Texture, Video) and the Effect Gallery; Document Raster Effects Settings and raster effects in PDF are done | 28–42 |
 | 3D and Materials | 4 | 0% | Extrude & Bevel, Revolve, Inflate, Rotate, lighting, materials (software renderer) | 50–80 |
 | Type core | 9 | 79% | Middle Eastern features beyond bidi layout and Paragraph Direction (Character Direction, digit types, kashidas, the Middle Eastern composers, editable bidirectional SVG text, a split caret where directions meet); composer/hyphenation options, Optical Margin Alignment, hidden characters, Transform Again after a type-area resize (it scales the type), partial selection of type-area anchors by marquee | 15–20 |
-| Type advanced | 4 | 50% | CJK composition for vertical type (ruby, mojikumi beyond Line-end Punctuation Half Width — hanging punctuation, line-start brackets, kinsoku sets and the Mojikumi Settings dialog —, proportional vertical metrics, manual tate-chu-yoko), variable font axis sliders (named instances are styles), tab leaders, spell check (open dictionary), Touch Type, Retype; vertical point/area/path type and Type Orientation have initial support | 20–28 |
+| Type advanced | 4 | 50% | CJK composition for vertical type (ruby, mojikumi beyond Line-end Punctuation Half Width — the other sets (and their paragraph-start bracket and indent rules), kinsoku sets and the Mojikumi Settings dialog —, proportional vertical metrics, manual tate-chu-yoko, Character Alignment on the ICF top and bottom), variable font axis sliders (named instances are styles), tab leaders, spell check (open dictionary), Touch Type, Retype; vertical point/area/path type and Type Orientation have initial support | 20–28 |
 | Symbols, blends, envelopes, Repeat, perspective | 5 | 88% | symbol libraries (original), dynamic symbols, envelope Anti-Alias/Preserve Shape output and warp point editing, brush interpolation in blends (M8 fidelity pass done) | 5–8 |
-| Image Trace, graphs, image tools | 3 | 70% | graph Design/Column/Marker, Create Object Mosaic, Crop Image polish (Vector Halftone is done) | 6–10 |
+| Image Trace, graphs, image tools | 3 | 70% | graph Design/Column/Marker, Create Object Mosaic, Crop Image polish (an on-canvas crop box), Image Trace View modes (Outlines, Source Image) (Vector Halftone is done) | 6–10 |
 | Layers, artboards, document setup | 5 | 82% | Layers panel: a confirmation before deleting layers that hold art, Collect for Export, row context menus, the Layer Options dialog for several rows with mixed values, Paste Remembers Layers for sublayers, drag-scrolling a long panel while dragging rows; artboard presets/rearrange polish (Document Setup, New Document and the rest of the Layers panel are done) | 4–7 |
 | View & navigation | 3 | 70% | New View/Edit Views, multiple windows/arrange, Snap to Pixel/Glyph (print tiling is done) | 9–14 |
-| Guides, grids, smart guides, snapping, rulers | 3 | 75% | global/video rulers, smart-guide preference depth, ruler-drag modifiers (Shift snaps to ticks, Alt swaps orientation) and dragging existing guides | 4–8 |
-| File formats | 6 | 85% | DWG (no open spec: DXF instead), PSD placement as layers, Illustrator EPS checked against more real files (two Illustrator 30 files open as vectors so far), the remaining fidelity polish; EPS, DXF, EMF/WMF, TIFF, BMP, Targa, PSD export, SVGZ, PDF security, PDF/X, PDF layers and presets are done | 6–10 |
+| Guides, grids, smart guides, snapping, rulers | 3 | 82% | global/video rulers, smart-guide preference depth, Alt swapping a ruler guide's orientation, ruler guides selected together with art (marquee, Shift-click), ruler guides as Layers rows with their own lock and hide (#451: Lock Guides locks them all; Make Guides paths are Layers rows already) (dragging existing guides is done, #414; new guides snapping to side midpoints and artboards, and artboard guides, #451) | 3–5 |
+| File formats | 6 | 85% | DWG (no open spec: DXF instead), PSD placement as layers, EPS checked against more real files (Illustrator 2026 and Inkscape files open as vectors; CorelDRAW, Affinity, LibreOffice, matplotlib and Ghostscript output checked with synthetic programs only; CID-keyed CJK type and `CCITTFaxDecode` images not read), legacy `.ai` files saved without the prolog that defines their operators (their own operator set isn't read yet), the remaining fidelity polish; EPS, DXF, EMF/WMF, TIFF, BMP, Targa, PSD export, SVGZ, PDF security, PDF/X, PDF layers and presets are done | 6–10 |
 | Export for Screens, Asset Export, slices, Save for Web | 3 | 85% | polish only (all four are done) | 2–4 |
 | Print, colour management, separations, flattener | 3 | 80% | print preview fidelity (flattener presets in PDF and print, overprint in PDF and composite print, Print dialog, presets, PostScript, marks, separations, Print Tiling, print overprint/flattener/bitmap options and printer profile are done) | 1–2 |
 | Automation | 3 | 60% | Variables (data merge), scripting surface, batch | 8–12 |
-| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 78% | Variables, SVG Interactivity, Properties per context, Consolidate All Windows, context menus beyond the canvas (Links, Asset Export, CSS Properties, Attributes and the canvas context menu are done) | 15–25 |
+| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 78% | Variables, SVG Interactivity, Properties per context, Consolidate All Windows, context menus beyond the canvas (Links, Asset Export, CSS Properties, Attributes and the canvas context menu are done), about 38 Preferences options stored but not yet acted on (#394: Construction and Spacing Guides, Auto Size New Area Type, Show Font Names in English, Highlight Alternate Glyphs, Show Pixel Grid, performance, devices…) | 14–22 |
 | Libraries, Links, Package | 2 | 50% | a local Libraries panel (no cloud by design); Links and Package are done | 5–8 |
 | **Feature parity** | **103** | **~75%** | | **~210–330** |
 | Interaction-fidelity pass (side by side with Illustrator: every tool modifier, cursor, dialog, Properties context) | | | | 60–90 |
@@ -229,7 +235,7 @@ lossless SVG/PDF export of live effects with SVG filters, a documented JSON form
 command, gesture and dialog drivable by agents (MCP, CLI, control channel).
 
 ## Out of scope (by design or by law)
-- **Native `.ai` private data:** it's undocumented. We read the PDF-compatible part, so Illustrator-only live objects arrive as appearance.
+- **Native `.ai` private data:** it's undocumented. We read the PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Art off the page that a PDF does draw opens on the pasteboard.
 - **Adobe cloud services** (Libraries sync, Adobe Fonts, Firefly/generative): these are pluggable provider APIs, not built in.
 - **Adobe's bundled assets** (swatch/brush/symbol libraries, presets, icons): ours are original.
 

apps/vectorcraft-cli/src/main.rs

@@ -72,7 +72,9 @@ USAGE:
       Live effects are kept; --outline-text writes SVG text as paths.
 
   vectorcraft-cli info FILE
-      Print a JSON summary: title, colour mode, units, artboards, object counts by kind, fonts.
+      Print a JSON summary: the import warnings (what didn't come in as it was, such as an EPS
+      read from its preview and why), title, colour mode, units, artboards, object counts by
+      kind, fonts.
 
   vectorcraft-cli bench FILE [--size WxH] [--iters N]
       Render FILE (any readable format) fitted to WxH (default 2880x1800) and print ms per frame
@@ -188,7 +190,7 @@ fn convert(args: &[String]) -> Result<(), String> {
 fn info(args: &[String]) -> Result<(), String> {
     let file = args.first().ok_or("info needs a FILE")?;
     let mut h = Headless::new();
-    h.call("app.open", json!({"path": file})).map_err(|e| format!("open {file}: {e}"))?;
+    let opened = h.call("app.open", json!({"path": file})).map_err(|e| format!("open {file}: {e}"))?;
     let base = h.call("engine.execute", json!({"command": "file.info", "params": {}}))?;
     let doc = h.session.doc().map_err(|e| e.to_string())?.doc.clone();
     let mut kinds: std::collections::BTreeMap<&'static str, usize> = Default::default();
@@ -196,7 +198,8 @@ fn info(args: &[String]) -> Result<(), String> {
     let fonts = h.call("engine.execute", json!({"command": "text.fonts", "params": {}})).unwrap_or(Value::Null);
     let artboards: Vec<Value> =
         doc.artboards.iter().map(|a| json!({"name": a.name, "rect": [a.rect.x0, a.rect.y0, a.rect.width(), a.rect.height()]})).collect();
-    let v = json!({"file": file, "info": base, "artboards": artboards, "kinds": kinds, "fonts": fonts});
+    // What didn't come in as it was (an EPS read from its preview says why).
+    let v = json!({"file": file, "warnings": opened["warnings"], "info": base, "artboards": artboards, "kinds": kinds, "fonts": fonts});
     outln!("{}", serde_json::to_string_pretty(&v).unwrap_or_default());
     Ok(())
 }

apps/vectorcraft-cli/tests/cli.rs

@@ -160,6 +160,42 @@ fn mcp_protocol_over_stdio() {
     send(&mut stdin, json!({"jsonrpc":"2.0","id":10,"method":"resources/read","params":{"uri":"vectorcraft://object/"}}));
     assert_eq!(recv(&mut lines, &mut notes, 10)["error"]["code"], -32602);
 
+    // Large containers slice through run_command document.node: a truncated level reports
+    // childCount, and a bad limit is a tool error, not a crash or a full read.
+    send(
+        &mut stdin,
+        json!({"jsonrpc":"2.0","id":20,"method":"tools/call","params":{"name":"draw_shape","arguments":{"shape":"ellipse","x":90,"y":10,"width":30,"height":30}}}),
+    );
+    assert_eq!(recv(&mut lines, &mut notes, 20)["result"]["isError"], false);
+    let run = |id: u64, command: &str, params: Value| json!({"jsonrpc":"2.0","id":id,"method":"tools/call","params":{"name":"run_command","arguments":{"command":command,"params":params}}});
+    send(&mut stdin, run(21, "select.all", json!({})));
+    recv(&mut lines, &mut notes, 21);
+    send(&mut stdin, run(22, "object.group", json!({})));
+    let r = recv(&mut lines, &mut notes, 22);
+    let group = serde_json::from_str::<Value>(r["result"]["content"][0]["text"].as_str().unwrap()).unwrap()["id"].clone();
+    send(&mut stdin, run(23, "document.node", json!({"id": group, "summary": true, "childLimit": 1})));
+    let r = recv(&mut lines, &mut notes, 23);
+    let sliced: Value = serde_json::from_str(r["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
+    assert_eq!(sliced["children"].as_array().map(Vec::len), Some(1), "{sliced}");
+    assert_eq!(sliced["childCount"], 2, "{sliced}");
+    send(&mut stdin, run(24, "document.node", json!({"id": group, "summary": true, "depth": -1})));
+    assert_eq!(recv(&mut lines, &mut notes, 24)["result"]["isError"], true);
+
+    // Skeleton then drill: a depth-0 inspect is the layer skeleton with counts, and
+    // document.find locates nodes without dumping the tree.
+    send(&mut stdin, run(25, "document.inspect", json!({"depth": 0})));
+    let r = recv(&mut lines, &mut notes, 25);
+    let skel: Value = serde_json::from_str(r["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
+    assert!(skel["layers"][0].get("children").is_none(), "{skel}");
+    assert!(skel["artboards"].as_array().is_some_and(|a| !a.is_empty()), "{skel}");
+    send(&mut stdin, run(26, "document.find", json!({"kind": "ellipse"})));
+    let r = recv(&mut lines, &mut notes, 26);
+    let found: Value = serde_json::from_str(r["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
+    assert_eq!(found["total"], 1, "{found}");
+    assert!(found["matches"][0]["path"].as_array().is_some_and(|p| !p.is_empty()), "{found}");
+    send(&mut stdin, run(27, "document.find", json!({})));
+    assert_eq!(recv(&mut lines, &mut notes, 27)["result"]["isError"], true);
+
     // The binary installed its logger: records arrive as notifications/message, and only
     // after the client asked for them.
     send(&mut stdin, json!({"jsonrpc":"2.0","id":11,"method":"logging/setLevel","params":{"level":"debug"}}));

apps/vectorcraft-cli/tests/fileio.rs

@@ -82,3 +82,14 @@ fn help_lists_readable_formats() {
     let out = ok(&["--help"]);
     assert!(out.contains("Readable formats: .vectorcraft") && out.contains(".ait") && out.contains(".webp"), "{out}");
 }
+
+/// `info` reports the import warnings: an EPS read only up to an error names it.
+#[test]
+fn info_reports_why_an_eps_read_partly() {
+    let eps = tmp("partial.eps");
+    std::fs::write(&eps, "%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 100 100\n%%EndComments\n0 0 10 10 rectfill frobnicate\n%%EOF\n").unwrap();
+    let v = info(&eps);
+    let w = v["warnings"][0].as_str().unwrap_or_default();
+    assert!(w.contains("`frobnicate`"), "{v}");
+    assert_eq!(v["kinds"]["Path"], 1, "{v}");
+}

apps/vectorcraft-web/Cargo.toml

@@ -27,4 +27,4 @@ rfd = { workspace = true }
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
 js-sys = "0.3"
-web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlIFrameElement", "HtmlAnchorElement", "Blob", "BlobPropertyBag", "Url", "Location", "CssStyleDeclaration", "Event", "EventTarget", "MouseEvent", "DragEvent", "Storage", "Navigator"] }
+web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlIFrameElement", "HtmlAnchorElement", "Blob", "BlobPropertyBag", "ClipboardEvent", "DataTransfer", "File", "FileList", "Url", "Location", "CssStyleDeclaration", "Event", "EventTarget", "MouseEvent", "DragEvent", "Storage", "Navigator"] }

apps/vectorcraft-web/src/main.rs

@@ -11,7 +11,8 @@
 //! - Save / Export trigger a browser download;
 //! - dropped files are read asynchronously by `web::WebShell` and delivered through the inbox.
 //!
-//! URL query flag: `?webgl` forces the WebGL2 backend instead of WebGPU.
+//! URL query flags: `?webgl` forces the WebGL2 backend instead of WebGPU; `?lang=es` (any
+//! language code) stands in for the browser's languages when the interface language is Automatic.
 
 #[cfg(target_arch = "wasm32")]
 mod locks;

apps/vectorcraft-web/src/web.rs

@@ -1,14 +1,16 @@
-//! The browser shell: web `Services`, drag-and-drop, the eframe web runner, and starting again
-//! with new graphics when the page loses them (#369).
+//! The browser shell: web `Services`, drag-and-drop, pasted pictures and files, the eframe web
+//! runner, and starting again with new graphics when the page loses them (#369).
 
 use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 
 use vectorcraft_engine::Session;
+use vectorcraft_engine::cmd::clipboard::{FILE_HEAD, Flavour, PASTE_ORDER, file_flavour};
 use vectorcraft_engine::cmd::fileio;
 use vectorcraft_engine::cmd::recovery::{self, Hold, RecoveryStore};
 use vectorcraft_ui_egui::graphics::GraphicsLoss;
+use vectorcraft_ui_egui::i18n;
 use vectorcraft_ui_egui::place::{DropTarget, PlaceArrival, PlaceInbox};
 use vectorcraft_ui_egui::print::{PrintJob, PrintService, Printer};
 use vectorcraft_ui_egui::{Services, VectorcraftApp};
@@ -22,6 +24,14 @@ type Inbox = Arc<Mutex<Vec<(String, Vec<u8>)>>>;
 /// whether Shift was held: where dropped files land.
 type DragPos = Rc<Cell<Option<(f32, f32, bool)>>>;
 
+/// A picture or file pasted into the page, read and waiting for the next frame with the modifiers
+/// held at the paste, and the context to wake for it (the current runner's).
+#[derive(Default)]
+struct Pasted {
+    flavour: Option<(Flavour, egui::Modifiers)>,
+    ctx: Option<egui::Context>,
+}
+
 const CANVAS_ID: &str = "vectorcraft_canvas";
 const LOADING_ID: &str = "vectorcraft_loading";
 
@@ -36,6 +46,7 @@ struct Host {
     inbox: Inbox,
     place_inbox: PlaceInbox,
     drag: DragPos,
+    pasted: Rc<RefCell<Pasted>>,
     /// The page's Web Locks for Data Recovery, started once before the first frame: a graphics
     /// restart keeps them, so the tab stays the owner of its recovery area.
     locks: Option<WebLocks>,
@@ -49,6 +60,7 @@ pub fn start() {
         log::error!("missing <canvas id=\"{CANVAS_ID}\">");
         return;
     };
+    detect_language();
     wasm_bindgen_futures::spawn_local(async move {
         // Before the first frame, which looks for copies a crash left behind.
         let locks = WebLocks::start(RECOVERY_PREFIX).await;
@@ -57,9 +69,11 @@ pub fn start() {
             inbox: Arc::default(),
             place_inbox: Arc::default(),
             drag: DragPos::default(),
+            pasted: Rc::default(),
             locks,
             restarts: 0,
         };
+        track_paste(&host.pasted);
         run(host, canvas, None).await;
     });
 }
@@ -92,6 +106,7 @@ async fn run(host: Host, canvas: web_sys::HtmlCanvasElement, moving: Option<Movi
                     let (loss, ctx) = (loss.clone(), ctx.clone());
                     rs.device.set_device_lost_callback(move |reason, msg| loss.report(&ctx, format!("{reason:?}: {msg}")));
                 }
+                host.pasted.borrow_mut().ctx = Some(ctx.clone());
                 let services = services(host.inbox.clone(), host.place_inbox.clone(), ctx.clone(), host.locks.clone());
                 let app = match taken.borrow_mut().take() {
                     Some(mut app) => {
@@ -131,6 +146,27 @@ fn web_options() -> eframe::WebOptions {
     options
 }
 
+/// Tell the UI the browser's languages (`?lang=es` in the address first, as `VECTORCRAFT_LOCALE`
+/// does on the desktop) before the first frame, so the Automatic interface language follows the
+/// browser; and show the loading text in that language.
+fn detect_language() {
+    let mut tags: Vec<String> = query_param("lang").into_iter().collect();
+    if let Some(navigator) = web_sys::window().map(|w| w.navigator()) {
+        tags.extend(navigator.languages().iter().filter_map(|v| v.as_string()));
+        tags.extend(navigator.language());
+    }
+    i18n::set_system_locales(tags.as_slice());
+    if let Some(el) = element(LOADING_ID) {
+        el.set_text_content(Some(i18n::message(i18n::system_lang(), "Loading VectorCraft…").as_str()));
+    }
+}
+
+/// The value of `name=` in the address's query, if given.
+fn query_param(name: &str) -> Option<String> {
+    let query = query();
+    query.trim_start_matches('?').split('&').find_map(|kv| kv.strip_prefix(name)?.strip_prefix('=').map(str::to_string)).filter(|v| !v.is_empty())
+}
+
 fn query() -> String {
     web_sys::window().and_then(|w| w.location().search().ok()).unwrap_or_default()
 }
@@ -155,6 +191,50 @@ fn track_drag(canvas: &web_sys::HtmlCanvasElement, pos: &DragPos) {
     on_drag.forget();
 }
 
+/// Take pictures and files pasted into the page (egui reads a paste's text only): a paste without
+/// text hands the first of its files that is art (a bitmap, SVG, PDF, a metafile) to the next
+/// frame. Text, SVG markup among it, is left to egui.
+fn track_paste(pasted: &Rc<RefCell<Pasted>>) {
+    let Some(window) = web_sys::window() else { return };
+    let pasted = pasted.clone();
+    let on_paste = wasm_bindgen::closure::Closure::<dyn FnMut(web_sys::ClipboardEvent)>::new(move |e: web_sys::ClipboardEvent| {
+        let Some(data) = e.clipboard_data() else { return };
+        let Some(files) = data.files().filter(|f| f.length() > 0) else { return };
+        if data.get_data("text").is_ok_and(|t| !t.is_empty()) {
+            return;
+        }
+        e.prevent_default();
+        let held = pasted.borrow().ctx.as_ref().map(|c| c.input(|i| i.modifiers)).unwrap_or_default();
+        let files: Vec<web_sys::File> = (0..files.length()).filter_map(|i| files.get(i)).collect();
+        let pasted = pasted.clone();
+        wasm_bindgen_futures::spawn_local(async move {
+            for file in files {
+                let bytes = match wasm_bindgen_futures::JsFuture::from(file.array_buffer()).await {
+                    Ok(buf) => js_sys::Uint8Array::new(&buf).to_vec(),
+                    Err(e) => {
+                        log::error!("couldn't read the pasted file {}: {}", file.name(), js_err(e));
+                        continue;
+                    }
+                };
+                if let Some(mime) = file_flavour(&file.name(), bytes.get(..FILE_HEAD).unwrap_or(&bytes), &PASTE_ORDER) {
+                    let mut p = pasted.borrow_mut();
+                    p.flavour = Some((Flavour { mime, data: bytes }, held));
+                    if let Some(ctx) = &p.ctx {
+                        ctx.request_repaint();
+                    }
+                    return;
+                }
+            }
+        });
+    });
+    // Captured before eframe's own listener, which stops the event.
+    if let Err(e) = window.add_event_listener_with_callback_and_bool("paste", on_paste.as_ref().unchecked_ref(), true) {
+        log::error!("couldn't follow paste events: {e:?}");
+    }
+    // The listener lives as long as the page.
+    on_paste.forget();
+}
+
 /// Report the loss of `canvas`'s WebGL context to `loss` (WebGPU devices report theirs through
 /// wgpu).
 fn watch_canvas(canvas: &web_sys::HtmlCanvasElement, loss: &GraphicsLoss, ctx: &egui::Context) {
@@ -215,7 +295,7 @@ fn notice(lines: &[&str]) {
     el.set_text_content(None);
     for line in lines {
         if let Ok(p) = document.create_element("p") {
-            p.set_text_content(Some(line));
+            p.set_text_content(Some(i18n::message(i18n::system_lang(), line).as_str()));
             // Best effort: the log has the message too.
             el.append_child(&p).ok();
         }
@@ -261,15 +341,20 @@ impl eframe::App for WebShell {
             self.restart(&why);
         }
         let Some(app) = &mut self.app else { return };
+        let pasted = self.host.pasted.borrow_mut().flavour.take();
+        if let Some((f, held)) = pasted {
+            app.paste_from_host(ctx, f, held);
+        }
         let dropped = ctx.input_mut(|i| std::mem::take(&mut i.raw.dropped_files));
         if !dropped.is_empty() {
             let at = self.host.drag.take();
             let z = ctx.zoom_factor();
-            let target = app.drop_target(at.map(|(x, y, _)| egui::pos2(x / z, y / z)), at.is_some_and(|a| a.2));
+            let (pos, shift) = (at.map(|(x, y, _)| egui::pos2(x / z, y / z)), at.is_some_and(|a| a.2));
             for f in dropped {
+                let name = f.path().file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "dropped".into());
+                let target = app.drop_target(&name, pos, shift);
                 let (inbox, place_inbox, ctx) = (self.host.inbox.clone(), self.host.place_inbox.clone(), ctx.clone());
                 wasm_bindgen_futures::spawn_local(async move {
-                    let name = f.path().file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "dropped".into());
                     match f.bytes_async().await {
                         Ok(bytes) => {
                             match target {

apps/vectorcraft/Cargo.toml

@@ -26,7 +26,8 @@ log = { workspace = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 rfd = { workspace = true }
-arboard = { workspace = true, features = ["image-data"] }
+# wayland-data-control: native Wayland clipboard (Linux; X11 through XWayland only sees what X11 apps copied).
+arboard = { workspace = true, features = ["image-data", "wayland-data-control"] }
 image = { workspace = true }
 webbrowser = { workspace = true }
 # The window's monitors, size and position (the same winit eframe runs on).
@@ -38,9 +39,9 @@ clipboard-win = { workspace = true }
 [target.'cfg(target_os = "macos")'.dependencies]
 muda = { version = "0.21", default-features = false }
 objc2 = "0.6"
-objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSApplication", "NSResponder", "NSTextInputContext"] }
-# Files opened from Finder and the Dock (src/open_documents.rs); both already come with winit, muda and rfd.
-objc2-foundation = { version = "0.3", default-features = false, features = ["std", "block2", "NSArray", "NSNotification", "NSOperation", "NSString", "NSURL"] }
+objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSApplication", "NSPasteboard", "NSResponder", "NSTextInputContext"] }
+# Files opened from Finder and the Dock (src/open_documents.rs) and pasted bitmaps (src/clipboard.rs); both already come with winit, muda and rfd.
+objc2-foundation = { version = "0.3", default-features = false, features = ["std", "block2", "NSArray", "NSData", "NSNotification", "NSOperation", "NSString", "NSURL"] }
 block2 = "0.6"
 
 [build-dependencies]

apps/vectorcraft/src/clipboard.rs

@@ -2,13 +2,20 @@
 //! (`Services::system_clipboard`).
 //!
 //! - Windows: text, SVG, PDF, PNG and an opaque bitmap (for apps that don't read PNG) in one go;
-//!   Paste reads each of them.
+//!   Paste reads each of them, a bitmap as PNG, else as the device-independent bitmap that
+//!   screenshots and most apps copy (`CF_DIBV5`, `CF_DIB`; the system makes them of a `CF_BITMAP`).
 //! - macOS and Linux: one format at a time, the text (a type-only copy's text or the SVG markup),
-//!   else the PNG as a bitmap; Paste reads text and bitmaps.
+//!   else the PNG as a bitmap; Paste reads text and bitmaps (on macOS the pasteboard's PNG or TIFF
+//!   as they are, as screenshots copy them). On Wayland, arboard's data-control
+//!   backend reads the compositor's clipboard (X11 through XWayland only sees what X11 apps
+//!   copied), falling back to X11 where the compositor lacks the protocol.
+//! - Everywhere: files copied in a file manager paste as the first one that is art (SVG, PDF, a
+//!   metafile or a bitmap), before the clipboard's other formats (the files' paths as text).
 
-use std::io::Cursor;
+use std::io::{Cursor, Read};
+use std::path::PathBuf;
 
-use vectorcraft_engine::cmd::clipboard::{BITMAP, Flavour, PNG, TEXT};
+use vectorcraft_engine::cmd::clipboard::{BITMAP, FILE_HEAD, Flavour, PNG, TEXT, file_flavour};
 use vectorcraft_ui_egui::SystemClipboard;
 
 /// This platform's system clipboard.
@@ -25,10 +32,96 @@ fn text_of(flavours: &[Flavour]) -> Option<String> {
     flavours.iter().find(|f| f.mime == TEXT).map(|f| String::from_utf8_lossy(&f.data).into_owned())
 }
 
+/// Most pixels a side of a bitmap another app put on the clipboard (untrusted data).
+const MAX_SIDE: u32 = 32_768;
+
 fn decode_png(png: &[u8]) -> Option<image::RgbaImage> {
     Some(image::load_from_memory_with_format(png, image::ImageFormat::Png).ok()?.to_rgba8())
 }
 
+/// `img` as a PNG flavour.
+fn png_flavour(img: &image::RgbaImage) -> Option<Flavour> {
+    let mut data = vec![];
+    img.write_to(&mut Cursor::new(&mut data), image::ImageFormat::Png).ok()?;
+    Some(Flavour { mime: PNG, data })
+}
+
+/// A Windows device-independent bitmap (`CF_DIB`, `CF_DIBV5`: a BITMAPINFO header, the colour
+/// masks of a BITMAPINFOHEADER, the colour table, then the pixels) as a BMP file, whose header
+/// says where the pixels start. `None` when the header is cut short or out of range.
+#[cfg_attr(not(windows), allow(dead_code))]
+fn dib_file(dib: &[u8]) -> Option<Vec<u8>> {
+    const BI_BITFIELDS: u32 = 3;
+    const BI_ALPHABITFIELDS: u32 = 6;
+    let u16_at = |i: usize| Some(u16::from_le_bytes(dib.get(i..i + 2)?.try_into().ok()?));
+    let u32_at = |i: usize| Some(u32::from_le_bytes(dib.get(i..i + 4)?.try_into().ok()?));
+    let header = u32_at(0)?;
+    // BITMAPCOREHEADER has 16-bit fields and 3-byte colours; the others 32-bit fields, 4-byte
+    // colours and a count of them (0: all a palette of the depth has), the 40-byte one its masks
+    // after it.
+    let (bits, used, entry, masks) = match header {
+        12 => (u16_at(10)?, 0, 3, 0),
+        _ => {
+            let masks = match (header, u32_at(16)?) {
+                (40, BI_BITFIELDS) => 12,
+                (40, BI_ALPHABITFIELDS) => 16,
+                _ => 0,
+            };
+            (u16_at(14)?, u32_at(32)?, 4, masks)
+        }
+    };
+    let colours = match used {
+        0 if bits <= 8 => 1 << bits,
+        n if n <= 256 => n,
+        _ => return None,
+    };
+    let offset = [header, masks, colours * entry].into_iter().try_fold(14u32, u32::checked_add)?;
+    let size = u32::try_from(dib.len()).ok()?.checked_add(14)?;
+    if offset > size {
+        return None;
+    }
+    let mut bmp = Vec::with_capacity(dib.len() + 14);
+    bmp.extend_from_slice(b"BM");
+    bmp.extend_from_slice(&size.to_le_bytes());
+    bmp.extend_from_slice(&[0; 4]);
+    bmp.extend_from_slice(&offset.to_le_bytes());
+    bmp.extend_from_slice(dib);
+    Some(bmp)
+}
+
+/// A device-independent bitmap as an image, at most [`MAX_SIDE`] pixels a side. It is opaque when
+/// its alpha is zero throughout: screenshots and most apps leave the fourth byte of a 32-bit pixel
+/// at zero, even under an alpha mask.
+#[cfg_attr(not(windows), allow(dead_code))]
+fn dib_image(dib: &[u8]) -> Option<image::RgbaImage> {
+    let mut reader = image::ImageReader::with_format(Cursor::new(dib_file(dib)?), image::ImageFormat::Bmp);
+    let mut limits = image::Limits::default();
+    (limits.max_image_width, limits.max_image_height) = (Some(MAX_SIDE), Some(MAX_SIDE));
+    reader.limits(limits);
+    let mut img = reader.decode().ok()?.into_rgba8();
+    if img.pixels().all(|p| p.0[3] == 0) {
+        img.pixels_mut().for_each(|p| p.0[3] = u8::MAX);
+    }
+    Some(img)
+}
+
+/// The first of `paths` (files copied in a file manager) that pastes as one of `mimes`, read
+/// whole. Only its first bytes are read to tell, so other files cost little.
+fn copied_file(paths: Vec<PathBuf>, mimes: &[&'static str]) -> Option<Flavour> {
+    paths.into_iter().find_map(|path| {
+        // text/uri-list lines end in CRLF (RFC 2483), but arboard splits them on LF only.
+        let path = match path.to_str() {
+            Some(p) if p.ends_with('\r') => PathBuf::from(p.trim_end_matches('\r')),
+            _ => path,
+        };
+        let mut head = Vec::with_capacity(FILE_HEAD);
+        std::fs::File::open(&path).ok()?.take(FILE_HEAD as u64).read_to_end(&mut head).ok()?;
+        let mime = file_flavour(&path.to_string_lossy(), &head, mimes)?;
+        let data = std::fs::read(&path).ok()?;
+        (!data.is_empty()).then_some(Flavour { mime, data })
+    })
+}
+
 #[cfg(windows)]
 mod win {
     use std::num::NonZeroU32;
@@ -49,6 +142,10 @@ mod win {
         }
     }
 
+    /// The device-independent bitmaps, the one that carries alpha first. Each is there whenever the
+    /// other or a `CF_BITMAP` is: the system converts between them.
+    const DIBS: [u32; 2] = [formats::CF_DIBV5, formats::CF_DIB];
+
     fn formats_of(mime: &str) -> impl Iterator<Item = u32> {
         names(mime).iter().filter_map(|n| raw::register_format(n)).map(NonZeroU32::get)
     }
@@ -123,16 +220,26 @@ mod win {
         }
 
         fn read(&mut self, mimes: &[&'static str]) -> Option<Flavour> {
-            let _open = clipboard_win::Clipboard::new_attempts(10).ok()?;
-            mimes.iter().find_map(|m| read_one(m))
+            let mut files = vec![];
+            {
+                let _open = clipboard_win::Clipboard::new_attempts(10).ok()?;
+                // None copied when the clipboard holds no file list.
+                let _ = raw::get_file_list_path(&mut files);
+            }
+            // The files are read with the clipboard closed again, not keeping other apps waiting.
+            copied_file(files, mimes).or_else(|| {
+                let _open = clipboard_win::Clipboard::new_attempts(10).ok()?;
+                mimes.iter().find_map(|m| read_one(m))
+            })
         }
 
         fn has(&mut self, mimes: &[&'static str]) -> bool {
-            mimes.iter().any(|m| match *m {
-                TEXT => raw::is_format_avail(formats::CF_UNICODETEXT),
-                BITMAP => raw::is_format_avail(formats::CF_BITMAP) || formats_of(PNG).any(raw::is_format_avail),
-                m => formats_of(m).any(raw::is_format_avail),
-            })
+            raw::is_format_avail(formats::CF_HDROP)
+                || mimes.iter().any(|m| match *m {
+                    TEXT => raw::is_format_avail(formats::CF_UNICODETEXT),
+                    BITMAP => DIBS.into_iter().chain(formats_of(PNG)).any(raw::is_format_avail),
+                    m => formats_of(m).any(raw::is_format_avail),
+                })
         }
     }
 
@@ -150,9 +257,11 @@ mod win {
         let mime = match mime {
             BITMAP if read_registered(PNG, &mut data) => PNG,
             BITMAP => {
-                data.clear();
-                raw::get_bitmap(&mut data).ok()?;
-                "image/bmp"
+                return DIBS.into_iter().find_map(|id| {
+                    data.clear();
+                    raw::get_vec(id, &mut data).ok()?;
+                    png_flavour(&dib_image(&data)?)
+                });
             }
             TEXT => {
                 raw::get_string(&mut data).ok()?;
@@ -178,13 +287,6 @@ mod portable {
 
     use super::*;
 
-    /// `img` as PNG bytes.
-    fn encode_png(img: &image::RgbaImage) -> Option<Vec<u8>> {
-        let mut out = vec![];
-        img.write_to(&mut Cursor::new(&mut out), image::ImageFormat::Png).ok()?;
-        Some(out)
-    }
-
     /// What our last write put on the clipboard.
     enum Ours {
         Text(String),
@@ -245,20 +347,203 @@ mod portable {
 
         fn read(&mut self, mimes: &[&'static str]) -> Option<Flavour> {
             let cb = self.cb().ok()?;
+            if let Some(f) = cb.get().file_list().ok().and_then(|paths| copied_file(paths, mimes)) {
+                return Some(f);
+            }
             mimes.iter().find_map(|m| match *m {
                 TEXT => cb.get_text().ok().filter(|t| !t.is_empty()).map(|t| Flavour { mime: TEXT, data: t.into_bytes() }),
                 BITMAP => {
+                    #[cfg(target_os = "macos")]
+                    if let Some(f) = super::mac::bitmap() {
+                        return Some(f);
+                    }
                     let img = cb.get_image().ok()?;
                     let rgba = image::RgbaImage::from_raw(u32::try_from(img.width).ok()?, u32::try_from(img.height).ok()?, img.bytes.into_owned())?;
-                    encode_png(&rgba).map(|data| Flavour { mime: PNG, data })
+                    png_flavour(&rgba)
                 }
                 _ => None,
             })
         }
 
-        /// Text only: reading a bitmap costs as much as pasting it.
+        /// Text, and on macOS a bitmap (by the pasteboard's types). Linux has no cheap way to ask
+        /// for a bitmap (reading one costs as much as pasting it): the paste keys take it, the
+        /// menu item waits for text.
         fn has(&mut self, mimes: &[&'static str]) -> bool {
+            #[cfg(target_os = "macos")]
+            if mimes.contains(&BITMAP) && super::mac::has_bitmap() {
+                return true;
+            }
             mimes.contains(&TEXT) && self.cb().is_ok_and(|cb| cb.get_text().is_ok_and(|t| !t.is_empty()))
         }
     }
 }
+
+/// The macOS pasteboard's bitmaps as they are (arboard reads TIFF only, and decodes it).
+#[cfg(target_os = "macos")]
+mod mac {
+    use objc2::rc::autoreleasepool;
+    use objc2_app_kit::NSPasteboard;
+    use objc2_foundation::{NSArray, NSString};
+
+    use super::*;
+
+    /// The bitmap types Paste reads, best first (the values of `NSPasteboardTypePNG` and
+    /// `NSPasteboardTypeTIFF`), with their MIME types.
+    const TYPES: [(&str, &str); 2] = [("public.png", PNG), ("public.tiff", "image/tiff")];
+
+    /// Does the pasteboard hold a bitmap? Asks for its types only.
+    pub fn has_bitmap() -> bool {
+        autoreleasepool(|_| {
+            let types = TYPES.map(|(t, _)| NSString::from_str(t));
+            let types: Vec<&NSString> = types.iter().map(|t| &**t).collect();
+            NSPasteboard::generalPasteboard().availableTypeFromArray(&NSArray::from_slice(&types)).is_some()
+        })
+    }
+
+    /// The pasteboard's bitmap, PNG before TIFF.
+    pub fn bitmap() -> Option<Flavour> {
+        autoreleasepool(|_| {
+            let pasteboard = NSPasteboard::generalPasteboard();
+            TYPES.into_iter().find_map(|(t, mime)| {
+                let data = pasteboard.dataForType(&NSString::from_str(t))?.to_vec();
+                (!data.is_empty()).then_some(Flavour { mime, data })
+            })
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use vectorcraft_engine::cmd::clipboard::{PASTE_ORDER, SVG};
+
+    use super::*;
+
+    fn dir(name: &str) -> PathBuf {
+        let d = std::env::temp_dir().join(format!("vectorcraft-clipboard-{name}-{}", std::process::id()));
+        std::fs::create_dir_all(&d).unwrap();
+        d
+    }
+
+    fn png(w: u32, h: u32) -> Vec<u8> {
+        let mut out = vec![];
+        image::RgbaImage::new(w, h).write_to(&mut Cursor::new(&mut out), image::ImageFormat::Png).unwrap();
+        out
+    }
+
+    #[test]
+    fn the_first_copied_file_that_is_art_pastes() {
+        let d = dir("art");
+        let (notes, red, art) = (d.join("notes.txt"), d.join("red image.png"), d.join("art.svg"));
+        std::fs::write(&notes, "not art").unwrap();
+        std::fs::write(&red, png(3, 2)).unwrap();
+        std::fs::write(&art, "<svg xmlns=\"http://www.w3.org/2000/svg\"/>").unwrap();
+        // Missing files, folders and text are skipped.
+        let f = copied_file(vec![d.join("gone.png"), d.clone(), notes.clone(), red.clone(), art.clone()], &PASTE_ORDER).unwrap();
+        assert_eq!((f.mime, f.data), (PNG, png(3, 2)));
+        assert_eq!(copied_file(vec![art.clone(), red.clone()], &PASTE_ORDER).map(|f| f.mime), Some(SVG));
+        // Only what Paste asks for.
+        assert_eq!(copied_file(vec![art, red.clone()], &[BITMAP]).map(|f| f.mime), Some(PNG));
+        assert!(copied_file(vec![red], &[TEXT]).is_none());
+        assert!(copied_file(vec![notes], &PASTE_ORDER).is_none());
+        assert!(copied_file(vec![], &PASTE_ORDER).is_none());
+    }
+
+    #[test]
+    fn a_crlf_left_by_the_uri_list_is_ignored() {
+        let red = dir("crlf").join("red.png");
+        std::fs::write(&red, png(2, 2)).unwrap();
+        let with_cr = PathBuf::from(format!("{}\r", red.display()));
+        assert_eq!(copied_file(vec![with_cr], &PASTE_ORDER).map(|f| f.mime), Some(PNG));
+    }
+
+    /// A DIB of `w`×`h` pixels (top row first when `h` is negative): a `header`-byte header (40,
+    /// or 124 for a BITMAPV5HEADER with BGRA masks), `extra` (the masks after a 40-byte header, a
+    /// colour table), then `rows`, each padded to 4 bytes.
+    fn dib(header: u32, w: i32, h: i32, bits: u16, compression: u32, extra: &[u8], rows: &[u8]) -> Vec<u8> {
+        let mut d = vec![];
+        d.extend(header.to_le_bytes());
+        d.extend(w.to_le_bytes());
+        d.extend(h.to_le_bytes());
+        d.extend(1u16.to_le_bytes());
+        d.extend(bits.to_le_bytes());
+        d.extend(compression.to_le_bytes());
+        d.extend((rows.len() as u32).to_le_bytes());
+        // 96 ppi, every colour of the table used.
+        d.extend([3780u32, 3780, 0, 0].iter().flat_map(|v| v.to_le_bytes()));
+        if header == 124 {
+            d.extend([0x00FF_0000u32, 0xFF00, 0xFF, 0xFF00_0000, 0x7352_4742].iter().flat_map(|v| v.to_le_bytes()));
+            d.resize(124, 0);
+        }
+        d.extend_from_slice(extra);
+        d.extend_from_slice(rows);
+        d
+    }
+
+    /// 32-bit BGRA rows of `px` (top row first).
+    fn bgra(px: &[[u8; 4]]) -> Vec<u8> {
+        px.iter().flat_map(|[r, g, b, a]| [*b, *g, *r, *a]).collect()
+    }
+
+    const RED: [u8; 4] = [255, 0, 0, 255];
+    const BLUE: [u8; 4] = [0, 0, 255, 255];
+
+    fn pixels(img: &image::RgbaImage) -> Vec<[u8; 4]> {
+        img.pixels().map(|p| p.0).collect()
+    }
+
+    #[test]
+    fn a_screenshot_dib_pastes_opaque_and_upright() {
+        // CF_DIB as screenshots copy it: 32-bit BI_RGB, bottom row first, the fourth byte zero.
+        let rows = bgra(&[[0, 0, 255, 0], [0, 0, 255, 0], [255, 0, 0, 0], [255, 0, 0, 0]]);
+        let img = dib_image(&dib(40, 2, 2, 32, 0, &[], &rows)).unwrap();
+        assert_eq!(pixels(&img), [RED, RED, BLUE, BLUE]);
+        // The same bitmap with an alpha mask (CF_DIBV5), alpha still zero throughout: opaque too.
+        let img = dib_image(&dib(124, 2, -2, 32, 3, &[], &bgra(&[[255, 0, 0, 0]; 4]))).unwrap();
+        assert_eq!(pixels(&img), [RED; 4]);
+    }
+
+    #[test]
+    fn a_dibv5_keeps_its_alpha_top_down() {
+        // A negative height: top row first.
+        let rows = bgra(&[[255, 0, 0, 128], [255, 0, 0, 128], [0, 0, 255, 0], [0, 0, 255, 255]]);
+        let img = dib_image(&dib(124, 2, -2, 32, 3, &[], &rows)).unwrap();
+        assert_eq!(pixels(&img), [[255, 0, 0, 128], [255, 0, 0, 128], [0, 0, 255, 0], BLUE]);
+    }
+
+    #[test]
+    fn masks_and_colour_tables_come_before_the_pixels() {
+        // BI_BITFIELDS after a 40-byte header: three masks between it and the pixels.
+        let masks: Vec<u8> = [0x00FF_0000u32, 0xFF00, 0xFF].iter().flat_map(|v| v.to_le_bytes()).collect();
+        let img = dib_image(&dib(40, 1, 1, 32, 3, &masks, &bgra(&[[0, 0, 255, 0]]))).unwrap();
+        assert_eq!(pixels(&img), [BLUE]);
+        // 8-bit, two colours used, rows padded to 4 bytes, bottom row first.
+        let mut table = bgra(&[RED, BLUE]);
+        table[3] = 0;
+        let mut d = dib(40, 3, 2, 8, 0, &table, &[1, 1, 1, 0, 0, 1, 0, 0]);
+        d[32..36].copy_from_slice(&2u32.to_le_bytes());
+        assert_eq!(pixels(&dib_image(&d).unwrap()), [RED, BLUE, RED, BLUE, BLUE, BLUE]);
+        // 24-bit, rows padded.
+        let img = dib_image(&dib(40, 1, 2, 24, 0, &[], &[255, 0, 0, 0, 0, 0, 255, 0])).unwrap();
+        assert_eq!(pixels(&img), [RED, BLUE]);
+    }
+
+    #[test]
+    fn untrusted_dibs_are_refused_not_trusted() {
+        let one = bgra(&[RED]);
+        // Too large a side (the pixels aren't even there), cut short, a header or a colour count
+        // out of range, no pixels.
+        assert!(dib_image(&dib(40, MAX_SIDE as i32 + 1, 1, 32, 0, &[], &one)).is_none());
+        assert!(dib_image(&dib(40, 1, -(MAX_SIDE as i32) - 1, 32, 0, &[], &one)).is_none());
+        assert!(dib_image(&dib(40, 4096, 4096, 32, 0, &[], &one)).is_none());
+        assert!(dib_image(&[40, 0, 0]).is_none());
+        assert!(dib_image(&[]).is_none());
+        let mut d = dib(40, 1, 1, 32, 0, &[], &one);
+        d[0..4].copy_from_slice(&u32::MAX.to_le_bytes());
+        assert!(dib_image(&d).is_none());
+        let mut d = dib(40, 1, 1, 8, 0, &[], &[0; 4]);
+        d[32..36].copy_from_slice(&u32::MAX.to_le_bytes());
+        assert!(dib_file(&d).is_none());
+        assert!(dib_image(&dib(40, 1, 1, 32, 0, &[], &[])).is_none());
+        assert!(dib_image(&dib(40, 0, 0, 32, 0, &[], &[])).is_none());
+    }
+}

apps/vectorcraft/src/logging.rs

@@ -0,0 +1,582 @@
+//! The desktop app's logger: `log::` records go to standard error and to a log file.
+//!
+//! Without a logger every `log::warn!`/`log::error!` in the workspace (the graphics adapter, a
+//! lost graphics device, a panic the engine's guard recovered from) vanished. A launch from a desktop menu
+//! has no terminal, so the file is what a bug report can attach: `<settings dir>/logs/vectorcraft.log`,
+//! next to the preferences (`prefs_path` in `main.rs`). Each start moves the previous log to
+//! `vectorcraft.1.log` (and that one to `.2`), so the log of a run that crashed survives the next
+//! launch. Runs without preferences (`VECTORCRAFT_NO_PREFS`) log to standard error only.
+//!
+//! Levels: `info` for VectorCraft's own crates, `warn` for everything else (wgpu and naga are
+//! chatty). `RUST_LOG` replaces that with env_logger-style directives: `debug`,
+//! `warn,vectorcraft_render=trace`, `wgpu_core=info`. A directive ending in `*` matches every
+//! target that starts with it (`vectorcraft*=debug`).
+//!
+//! Records logged before the settings directory is known are kept (up to [`MAX_PENDING`]) and
+//! written once the file is attached. Writing never panics: a file that can't be created or
+//! written leaves standard error as the only sink.
+//!
+//! This is the desktop app's logger only. `vectorcraft-cli mcp` installs its own
+//! (`vectorcraft_mcp::logging`, MCP `notifications/message`); the two never share a process.
+
+use std::fs::File;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::sync::{Mutex, OnceLock, PoisonError};
+use std::time::SystemTime;
+
+use log::LevelFilter;
+
+/// The current log file's name inside the log directory.
+pub const LOG_FILE: &str = "vectorcraft.log";
+/// How many previous logs are kept (`vectorcraft.1.log` … `vectorcraft.<KEEP>.log`).
+pub const KEEP: usize = 2;
+/// The log file stops growing past this size (a runaway warning can't fill the disk).
+pub const MAX_FILE_BYTES: u64 = 16 * 1024 * 1024;
+/// Records kept in memory until the log file is attached.
+pub const MAX_PENDING: usize = 512;
+/// The built-in filter when `RUST_LOG` is unset or empty.
+pub const DEFAULT_FILTER: &str = "warn,vectorcraft*=info";
+
+/// Per-target level filter parsed from env_logger-style directives.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Filter {
+    default: LevelFilter,
+    directives: Vec<(String, LevelFilter)>,
+}
+
+impl Filter {
+    /// Parse `spec`; unknown levels and empty parts are skipped. Without a bare level, targets no
+    /// directive names log errors only.
+    pub fn parse(spec: &str) -> Filter {
+        let mut f = Filter { default: LevelFilter::Error, directives: Vec::new() };
+        for part in spec.split(',').map(str::trim).filter(|p| !p.is_empty()) {
+            match part.split_once('=') {
+                Some((name, level)) => {
+                    let name = name.trim();
+                    if let (false, Some(level)) = (name.is_empty(), parse_level(level)) {
+                        f.directives.push((name.to_owned(), level));
+                    }
+                }
+                None => match parse_level(part) {
+                    Some(level) => f.default = level,
+                    // A bare target name: everything from it (env_logger does the same).
+                    None => f.directives.push((part.to_owned(), LevelFilter::Trace)),
+                },
+            }
+        }
+        f
+    }
+
+    /// The level that applies to `target` (the most specific matching directive wins).
+    pub fn level_for(&self, target: &str) -> LevelFilter {
+        self.directives.iter().filter(|(name, _)| matches(name, target)).max_by_key(|(name, _)| name.len()).map_or(self.default, |(_, level)| *level)
+    }
+
+    /// The most verbose level any target can reach (for `log::set_max_level`).
+    pub fn max(&self) -> LevelFilter {
+        self.directives.iter().map(|(_, level)| *level).fold(self.default, Ord::max)
+    }
+}
+
+fn parse_level(s: &str) -> Option<LevelFilter> {
+    s.trim().parse().ok()
+}
+
+/// `name` matches `target` itself and its submodules (`a` matches `a` and `a::b`, not `ab`);
+/// `name*` matches every target starting with `name`.
+fn matches(name: &str, target: &str) -> bool {
+    match name.strip_suffix('*') {
+        Some(prefix) => target.starts_with(prefix),
+        None => target.strip_prefix(name).is_some_and(|rest| rest.is_empty() || rest.starts_with("::")),
+    }
+}
+
+/// `2026-10-08T07:59:17.728Z` (UTC, milliseconds). A clock before 1970 reads as the epoch.
+pub fn timestamp(t: SystemTime) -> String {
+    let since = t.duration_since(std::time::UNIX_EPOCH).unwrap_or_default();
+    let secs = since.as_secs();
+    let (days, rem) = (secs / 86_400, secs % 86_400);
+    let (y, m, d) = civil_from_days(days);
+    format!("{y:04}-{m:02}-{d:02}T{:02}:{:02}:{:02}.{:03}Z", rem / 3600, rem % 3600 / 60, rem % 60, since.subsec_millis())
+}
+
+/// Days since 1970-01-01 to a proleptic Gregorian (year, month, day) (Howard Hinnant's
+/// `civil_from_days`, unsigned because `timestamp` clamps at the epoch). Saturating, so no clock
+/// value can overflow it.
+fn civil_from_days(days: u64) -> (u64, u64, u64) {
+    let z = days.saturating_add(719_468);
+    let era = z / 146_097;
+    let doe = z % 146_097;
+    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let d = doy - (153 * mp + 2) / 5 + 1;
+    let m = if mp < 10 { mp + 3 } else { mp - 9 };
+    let y = era.saturating_mul(400).saturating_add(yoe).saturating_add(u64::from(m <= 2));
+    (y, m, d)
+}
+
+fn numbered(dir: &Path, n: usize) -> PathBuf {
+    if n == 0 { dir.join(LOG_FILE) } else { dir.join(format!("vectorcraft.{n}.log")) }
+}
+
+/// Shift the previous logs up one (`.log` → `.1.log` → … → `.<KEEP>.log`, the oldest dropped)
+/// and create a fresh, empty log file in `dir` (created if missing).
+pub fn rotate(dir: &Path) -> std::io::Result<(PathBuf, File)> {
+    std::fs::create_dir_all(dir)?;
+    for n in (1..=KEEP).rev() {
+        match std::fs::rename(numbered(dir, n - 1), numbered(dir, n)) {
+            Err(e) if e.kind() != std::io::ErrorKind::NotFound => return Err(e),
+            _ => {}
+        }
+    }
+    let path = numbered(dir, 0);
+    let file = File::create(&path)?;
+    Ok((path, file))
+}
+
+/// One formatted log line: `<timestamp> <LEVEL> [<thread>] <target>: <message>\n`.
+pub fn format_line(ts: &str, level: log::Level, thread: &str, target: &str, message: &str) -> String {
+    let message = message.strip_suffix('\n').unwrap_or(message);
+    format!("{ts} {level:<5} [{thread}] {target}: {message}\n")
+}
+
+/// Where formatted lines go besides standard error: kept in memory until a file is attached,
+/// then appended to it until it reaches its size cap.
+pub struct Sink {
+    file: Option<File>,
+    pending: Vec<String>,
+    dropped: usize,
+    written: u64,
+    max_bytes: u64,
+    capped: bool,
+}
+
+impl Sink {
+    pub fn new(max_bytes: u64) -> Sink {
+        Sink { file: None, pending: Vec::new(), dropped: 0, written: 0, max_bytes, capped: false }
+    }
+
+    /// Append `line` to the file, or keep it until [`Sink::attach`].
+    pub fn write(&mut self, line: &str) {
+        if self.file.is_none() {
+            if self.capped {
+                // No file is coming ([`Sink::no_file`]): standard error had the line.
+            } else if self.pending.len() < MAX_PENDING {
+                self.pending.push(line.to_owned());
+            } else {
+                self.dropped = self.dropped.saturating_add(1);
+            }
+            return;
+        }
+        self.append(line);
+    }
+
+    /// Start writing to `file` (a fresh one: the size cap starts over), first the lines kept so far.
+    pub fn attach(&mut self, file: File) {
+        self.file = Some(file);
+        self.written = 0;
+        self.capped = false;
+        for line in std::mem::take(&mut self.pending) {
+            self.append(&line);
+        }
+        if self.dropped > 0 {
+            let note = format!("{} earlier log lines were dropped before the log file was opened\n", self.dropped);
+            self.dropped = 0;
+            self.append(&note);
+        }
+    }
+
+    /// There will be no log file: forget the lines kept for it and keep no more.
+    pub fn no_file(&mut self) {
+        self.pending = Vec::new();
+        self.dropped = 0;
+        self.capped = true;
+    }
+
+    fn append(&mut self, line: &str) {
+        if self.capped {
+            return;
+        }
+        let Some(file) = self.file.as_mut() else { return };
+        let len = u64::try_from(line.len()).unwrap_or(u64::MAX);
+        let text = if self.written.saturating_add(len) > self.max_bytes {
+            self.capped = true;
+            format!("log file reached {} bytes; later records go to standard error only\n", self.max_bytes)
+        } else {
+            self.written = self.written.saturating_add(len);
+            line.to_owned()
+        };
+        // A full disk or a vanished file must not take the app down: drop the file sink.
+        if file.write_all(text.as_bytes()).is_err() {
+            self.file = None;
+            self.capped = true;
+        }
+    }
+}
+
+/// The installed logger: a [`Filter`], standard error and a [`Sink`].
+pub struct AppLogger {
+    filter: Filter,
+    stderr: bool,
+    sink: Mutex<Sink>,
+}
+
+impl AppLogger {
+    pub fn new(filter: Filter, stderr: bool) -> AppLogger {
+        AppLogger { filter, stderr, sink: Mutex::new(Sink::new(MAX_FILE_BYTES)) }
+    }
+
+    /// Rotate the logs in `dir` and send records to the fresh file; returns its path. On an error
+    /// standard error stays the only sink.
+    pub fn attach_dir(&self, dir: &Path) -> Result<PathBuf, String> {
+        // A thread that panicked while logging leaves the sink usable: take it back.
+        let mut sink = self.sink.lock().unwrap_or_else(PoisonError::into_inner);
+        match rotate(dir) {
+            Ok((path, file)) => {
+                sink.attach(file);
+                Ok(path)
+            }
+            Err(e) => {
+                sink.no_file();
+                Err(format!("{}: {e}", dir.display()))
+            }
+        }
+    }
+
+    /// No log file for this run (runs without preferences): log to standard error only.
+    pub fn no_file(&self) {
+        self.sink.lock().unwrap_or_else(PoisonError::into_inner).no_file();
+    }
+}
+
+impl log::Log for AppLogger {
+    fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
+        metadata.level() <= self.filter.level_for(metadata.target())
+    }
+
+    fn log(&self, record: &log::Record<'_>) {
+        if !self.enabled(record.metadata()) {
+            return;
+        }
+        // Formatted before the sink is locked, so a message that logs while it is formatted can't deadlock.
+        let thread = std::thread::current();
+        let line =
+            format_line(&timestamp(SystemTime::now()), record.level(), thread.name().unwrap_or("?"), record.target(), &record.args().to_string());
+        if self.stderr {
+            // No terminal (a Windows GUI build, a closed pipe) is not an error worth reporting.
+            let _ = std::io::stderr().write_all(line.as_bytes());
+        }
+        self.sink.lock().unwrap_or_else(PoisonError::into_inner).write(&line);
+    }
+
+    fn flush(&self) {}
+}
+
+/// Install the logger (filter from `RUST_LOG`, else [`DEFAULT_FILTER`]); `None` when another
+/// logger was installed first. Call [`AppLogger::attach_dir`] once the settings directory is known.
+pub fn install() -> Option<&'static AppLogger> {
+    static LOGGER: OnceLock<AppLogger> = OnceLock::new();
+    let spec = std::env::var("RUST_LOG").ok().filter(|s| !s.trim().is_empty());
+    let filter = Filter::parse(spec.as_deref().unwrap_or(DEFAULT_FILTER));
+    let max = filter.max();
+    let logger = LOGGER.get_or_init(|| AppLogger::new(filter, true));
+    log::set_logger(logger).ok()?;
+    log::set_max_level(max);
+    Some(logger)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::time::{Duration, UNIX_EPOCH};
+
+    fn temp_dir(tag: &str) -> PathBuf {
+        static N: AtomicUsize = AtomicUsize::new(0);
+        let d = std::env::temp_dir().join(format!("vectorcraft-logging-{tag}-{}-{}", std::process::id(), N.fetch_add(1, Ordering::Relaxed)));
+        let _ = std::fs::remove_dir_all(&d);
+        d
+    }
+
+    fn read(path: &Path) -> String {
+        std::fs::read_to_string(path).expect("read log")
+    }
+
+    #[test]
+    fn the_default_filter_shows_vectorcraft_info_and_other_crates_warnings() {
+        let f = Filter::parse(DEFAULT_FILTER);
+        assert_eq!(f.level_for("vectorcraft"), LevelFilter::Info);
+        assert_eq!(f.level_for("vectorcraft::window"), LevelFilter::Info);
+        assert_eq!(f.level_for("vectorcraft_engine::guard"), LevelFilter::Info);
+        assert_eq!(f.level_for("vectorcraft_ui_egui::io"), LevelFilter::Info);
+        assert_eq!(f.level_for("wgpu_core::device"), LevelFilter::Warn);
+        assert_eq!(f.level_for("naga"), LevelFilter::Warn);
+        assert_eq!(f.max(), LevelFilter::Info);
+    }
+
+    #[test]
+    fn directives_follow_env_logger_and_the_most_specific_one_wins() {
+        let f = Filter::parse("info,wgpu_core=error,vectorcraft_render=trace,vectorcraft_render::tiles=off");
+        assert_eq!(f.level_for("eframe"), LevelFilter::Info);
+        assert_eq!(f.level_for("wgpu_core::instance"), LevelFilter::Error);
+        assert_eq!(f.level_for("vectorcraft_render::canvas"), LevelFilter::Trace);
+        assert_eq!(f.level_for("vectorcraft_render::tiles"), LevelFilter::Off);
+        assert_eq!(f.max(), LevelFilter::Trace);
+        // A module name is matched at `::` boundaries, not as a bare prefix.
+        assert_eq!(f.level_for("wgpu_core_extra"), LevelFilter::Info);
+        // A trailing `*` is a prefix.
+        assert_eq!(Filter::parse("vectorcraft*=debug").level_for("vectorcraft_text::shape"), LevelFilter::Debug);
+        assert_eq!(Filter::parse("vectorcraft*=debug").level_for("eframe"), LevelFilter::Error);
+        // A bare target name sets that target to the most verbose level, as env_logger does.
+        assert_eq!(Filter::parse("naga").level_for("naga::front"), LevelFilter::Trace);
+        assert_eq!(Filter::parse("naga").level_for("eframe"), LevelFilter::Error);
+        // Levels are case-insensitive and surrounding blanks are ignored.
+        assert_eq!(Filter::parse(" WARN , vectorcraft = Debug ").level_for("vectorcraft"), LevelFilter::Debug);
+        assert_eq!(Filter::parse(" WARN , vectorcraft = Debug ").level_for("eframe"), LevelFilter::Warn);
+    }
+
+    #[test]
+    fn hostile_specs_never_panic_and_fall_back_sensibly() {
+        let long = "x".repeat(100_000);
+        let many = "a=info,".repeat(10_000);
+        for spec in [
+            "",
+            ",,,",
+            "=",
+            "==",
+            "=debug",
+            "vectorcraft=",
+            "nonsense=loud",
+            "🦀=info",
+            "*",
+            "*=",
+            "=*",
+            "a=b=c",
+            "warn,,vectorcraft=DEBUG",
+            "\0",
+            "é::ü=trace",
+            &long,
+            &many,
+        ] {
+            let f = Filter::parse(spec);
+            for target in ["", "vectorcraft", "🦀", "a::b", "*"] {
+                let _ = f.level_for(target);
+            }
+            let _ = f.max();
+        }
+        assert_eq!(Filter::parse("warn,,vectorcraft=DEBUG").level_for("vectorcraft"), LevelFilter::Debug);
+        // An unknown level is skipped: that target keeps the default.
+        assert_eq!(Filter::parse("nonsense=loud").level_for("nonsense"), LevelFilter::Error);
+        assert_eq!(Filter::parse("vectorcraft=").level_for("vectorcraft"), LevelFilter::Error);
+        assert_eq!(Filter::parse("=debug").max(), LevelFilter::Error);
+        assert_eq!(Filter::parse("🦀=info").level_for("🦀::claw"), LevelFilter::Info);
+    }
+
+    #[test]
+    fn timestamps_are_utc_with_milliseconds() {
+        assert_eq!(timestamp(UNIX_EPOCH), "1970-01-01T00:00:00.000Z");
+        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_millis(1_791_446_357_728)), "2026-10-08T07:59:17.728Z");
+        // Leap day, and the day after it.
+        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(1_709_164_800)), "2024-02-29T00:00:00.000Z");
+        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(1_709_251_199)), "2024-02-29T23:59:59.000Z");
+        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(1_709_251_200)), "2024-03-01T00:00:00.000Z");
+        // 2000 is a leap year (divisible by 400), 2100 is not.
+        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(951_782_400)), "2000-02-29T00:00:00.000Z");
+        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(4_107_542_400)), "2100-03-01T00:00:00.000Z");
+        // Before the epoch (a clock set wrong) clamps instead of panicking.
+        assert_eq!(timestamp(UNIX_EPOCH - Duration::from_secs(5)), "1970-01-01T00:00:00.000Z");
+    }
+
+    #[test]
+    fn a_line_carries_time_level_thread_target_and_message() {
+        assert_eq!(
+            format_line("2026-10-08T07:59:17.728Z", log::Level::Info, "main", "vectorcraft", "rendering with Mesa (Vulkan, IntegratedGpu)"),
+            "2026-10-08T07:59:17.728Z INFO  [main] vectorcraft: rendering with Mesa (Vulkan, IntegratedGpu)\n"
+        );
+        // A multi-line message keeps its lines; the record still ends in one newline.
+        assert!(format_line("t", log::Level::Error, "w", "x", "a\nb\n").ends_with("x: a\nb\n"));
+    }
+
+    #[test]
+    fn rotation_keeps_the_previous_logs_and_starts_an_empty_file() {
+        let dir = temp_dir("rotate");
+        for run in 1..=4 {
+            let (path, _file) = rotate(&dir).expect("rotate");
+            assert_eq!(path, dir.join(LOG_FILE));
+            assert_eq!(read(&path), "");
+            std::fs::write(&path, format!("run {run}")).expect("write");
+        }
+        assert_eq!(read(&dir.join(LOG_FILE)), "run 4");
+        assert_eq!(read(&dir.join("vectorcraft.1.log")), "run 3");
+        assert_eq!(read(&dir.join("vectorcraft.2.log")), "run 2");
+        assert!(!dir.join("vectorcraft.3.log").exists(), "only {KEEP} old logs are kept");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn rotation_into_an_unusable_directory_is_an_error_not_a_panic() {
+        let dir = temp_dir("blocked");
+        std::fs::create_dir_all(dir.parent().expect("parent")).expect("tmp");
+        std::fs::write(&dir, "a file where the directory should be").expect("block");
+        assert!(rotate(&dir).is_err());
+        let _ = std::fs::remove_file(&dir);
+    }
+
+    #[test]
+    fn lines_logged_before_the_file_exists_are_written_when_it_is_attached() {
+        let dir = temp_dir("pending");
+        let (path, file) = rotate(&dir).expect("rotate");
+        let mut sink = Sink::new(MAX_FILE_BYTES);
+        sink.write("early 1\n");
+        sink.write("early 2\n");
+        sink.attach(file);
+        sink.write("late\n");
+        assert_eq!(read(&path), "early 1\nearly 2\nlate\n");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn the_pending_buffer_is_bounded_and_says_how_much_it_dropped() {
+        let dir = temp_dir("bounded");
+        let (path, file) = rotate(&dir).expect("rotate");
+        let mut sink = Sink::new(MAX_FILE_BYTES);
+        for i in 0..MAX_PENDING + 5 {
+            sink.write(&format!("line {i}\n"));
+        }
+        sink.attach(file);
+        let text = read(&path);
+        assert_eq!(text.lines().filter(|l| l.starts_with("line ")).count(), MAX_PENDING);
+        assert!(text.contains("5 earlier log lines were dropped"), "{text}");
+        assert!(text.contains("line 0\n") && !text.contains(&format!("line {MAX_PENDING}\n")));
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn exactly_a_full_pending_buffer_drops_nothing() {
+        let dir = temp_dir("full");
+        let (path, file) = rotate(&dir).expect("rotate");
+        let mut sink = Sink::new(MAX_FILE_BYTES);
+        for i in 0..MAX_PENDING {
+            sink.write(&format!("line {i}\n"));
+        }
+        sink.attach(file);
+        let text = read(&path);
+        assert_eq!(text.lines().count(), MAX_PENDING);
+        assert!(!text.contains("dropped"), "{text}");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn without_a_file_nothing_is_kept_in_memory() {
+        let mut sink = Sink::new(MAX_FILE_BYTES);
+        sink.write("early\n");
+        sink.no_file();
+        sink.write("late\n");
+        assert!(sink.pending.is_empty() && sink.dropped == 0);
+    }
+
+    #[test]
+    fn the_file_stops_at_its_size_cap_with_one_note() {
+        let dir = temp_dir("cap");
+        let (path, file) = rotate(&dir).expect("rotate");
+        let mut sink = Sink::new(100);
+        sink.attach(file);
+        for i in 0..50 {
+            sink.write(&format!("line {i:02} with some padding\n"));
+        }
+        let text = read(&path);
+        assert_eq!(text.lines().filter(|l| l.starts_with("line ")).count(), 3, "{text}");
+        assert_eq!(text.matches("log file reached").count(), 1, "{text}");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn the_logger_filters_records_and_writes_them_to_the_attached_file() {
+        use log::Log;
+        let dir = temp_dir("logger");
+        let logger = AppLogger::new(Filter::parse(DEFAULT_FILTER), false);
+        let record = |level, target: &'static str, msg: &'static str| {
+            logger.log(&log::Record::builder().level(level).target(target).args(format_args!("{msg}")).build());
+        };
+        record(log::Level::Info, "vectorcraft", "before the settings directory");
+        record(log::Level::Info, "wgpu_core::device", "too chatty");
+        let path = logger.attach_dir(&dir).expect("attach");
+        assert_eq!(path, dir.join(LOG_FILE));
+        record(log::Level::Warn, "wgpu_hal::vulkan", "a real warning");
+        record(log::Level::Error, "vectorcraft_engine::guard", "recovered from a panic: boom");
+        record(log::Level::Debug, "vectorcraft", "below info");
+        let text = read(&path);
+        let lines: Vec<&str> = text.lines().collect();
+        assert_eq!(lines.len(), 3, "{text}");
+        assert!(lines[0].contains(" INFO  [") && lines[0].ends_with("vectorcraft: before the settings directory"), "{text}");
+        assert!(lines[1].ends_with("wgpu_hal::vulkan: a real warning"), "{text}");
+        assert!(lines[2].contains(" ERROR [") && lines[2].ends_with("vectorcraft_engine::guard: recovered from a panic: boom"), "{text}");
+        assert!(logger.enabled(&log::Metadata::builder().level(log::Level::Info).target("vectorcraft_ui_egui").build()));
+        assert!(!logger.enabled(&log::Metadata::builder().level(log::Level::Info).target("naga").build()));
+        // Attaching again rotates: the first log becomes `.1`.
+        logger.attach_dir(&dir).expect("attach again");
+        assert_eq!(read(&dir.join("vectorcraft.1.log")), text);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn records_from_many_threads_are_whole_lines() {
+        use log::Log;
+        let dir = temp_dir("threads");
+        let logger = std::sync::Arc::new(AppLogger::new(Filter::parse("info"), false));
+        let path = logger.attach_dir(&dir).expect("attach");
+        let workers: Vec<_> = (0..8)
+            .map(|t| {
+                let l = std::sync::Arc::clone(&logger);
+                std::thread::spawn(move || {
+                    for i in 0..100 {
+                        l.log(
+                            &log::Record::builder().level(log::Level::Info).target("vectorcraft").args(format_args!("thread {t} record {i}")).build(),
+                        );
+                    }
+                })
+            })
+            .collect();
+        for w in workers {
+            w.join().expect("worker");
+        }
+        let text = read(&path);
+        assert_eq!(text.lines().count(), 800);
+        assert!(text.lines().all(|l| l.contains(" vectorcraft: thread ")), "{text}");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn attaching_to_an_unusable_directory_reports_an_error_and_keeps_logging() {
+        use log::Log;
+        let dir = temp_dir("unusable");
+        std::fs::create_dir_all(dir.parent().expect("parent")).expect("tmp");
+        std::fs::write(&dir, "not a directory").expect("block");
+        let logger = AppLogger::new(Filter::parse("info"), false);
+        assert!(logger.attach_dir(&dir).is_err());
+        logger.log(&log::Record::builder().level(log::Level::Error).target("x").args(format_args!("still fine")).build());
+        // Nothing waits in memory for a file that won't come.
+        assert!(logger.sink.lock().expect("sink").pending.is_empty());
+        let _ = std::fs::remove_file(&dir);
+    }
+
+    #[test]
+    fn a_poisoned_sink_still_logs() {
+        use log::Log;
+        let dir = temp_dir("poison");
+        let logger = std::sync::Arc::new(AppLogger::new(Filter::parse("info"), false));
+        let l = std::sync::Arc::clone(&logger);
+        let _ = std::thread::spawn(move || {
+            let _guard = l.sink.lock().expect("lock");
+            panic!("poison the sink");
+        })
+        .join();
+        assert!(logger.sink.is_poisoned());
+        let path = logger.attach_dir(&dir).expect("attach");
+        logger.log(&log::Record::builder().level(log::Level::Warn).target("vectorcraft").args(format_args!("after the poison")).build());
+        assert!(read(&path).contains("vectorcraft: after the poison"));
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}

apps/vectorcraft/src/main.rs

@@ -16,6 +16,7 @@ compile_error!("the win7 target requires --no-default-features --features window
 
 mod clipboard;
 mod control_server;
+mod logging;
 #[cfg(target_os = "macos")]
 mod native_menu;
 #[cfg(target_os = "macos")]
@@ -61,7 +62,7 @@ impl eframe::App for App {
                 self.menu = Some(native_menu::NativeMenu::install(&mut self.app));
             }
             if let Some(m) = &mut self.menu {
-                m.poll(&mut self.app);
+                m.poll(&mut self.app, ctx);
             }
             open_files(&mut self.app, open_documents::take());
         }
@@ -139,6 +140,11 @@ fn prefs_path_for(name: &str, lower: &str) -> Option<std::path::PathBuf> {
     base.map(|b| b.join("ui.json"))
 }
 
+/// Where the log files live: `logs` in the preferences folder (see `logging`).
+fn log_dir() -> Option<std::path::PathBuf> {
+    Some(prefs_path()?.parent()?.join("logs"))
+}
+
 /// Runs without preferences (`VECTORCRAFT_NO_PREFS`, agents' test runs) neither read nor write them.
 fn prefs_enabled() -> bool {
     std::env::var_os("VECTORCRAFT_NO_PREFS").is_none()
@@ -319,6 +325,8 @@ fn adapter_summary(info: &eframe::wgpu::AdapterInfo) -> String {
 const CUSTOM_TITLEBAR: bool = !cfg!(target_os = "macos");
 
 fn main() -> eframe::Result {
+    // First, so every start-up warning is recorded (`logging`).
+    let logger = logging::install();
     vectorcraft_ui_egui::i18n::detect_system_lang_in_background();
     let mut control_port: Option<u16> = std::env::var("VECTORCRAFT_CONTROL_PORT").ok().and_then(|p| p.parse().ok());
     let mut files = Vec::new();
@@ -333,6 +341,20 @@ fn main() -> eframe::Result {
             _ => files.push(a),
         }
     }
+    // The log file lives in the settings directory, next to the preferences; opened after the
+    // arguments, so `--version` leaves no file behind. Records logged until now are written to it
+    // first. Runs without preferences (agents' test runs) log to standard error only, so they
+    // don't rotate away the user's own logs.
+    if let Some(logger) = logger {
+        match log_dir().filter(|_| prefs_enabled()) {
+            Some(dir) => match logger.attach_dir(&dir) {
+                Ok(path) => log::info!("VectorCraft {}, log file {}", env!("CARGO_PKG_VERSION"), path.display()),
+                // Standard error only by now (`attach_dir` gave up on the file); unlike `eprintln!`, never panics.
+                Err(e) => log::warn!("no log file: {e}"),
+            },
+            None => logger.no_file(),
+        }
+    }
     let saved = read_prefs();
     let saved_window = saved.as_ref().and_then(|ui| ui.window);
     #[cfg(feature = "wgpu")]
@@ -358,6 +380,9 @@ fn main() -> eframe::Result {
     #[cfg(feature = "wgpu")]
     let options = {
         let mut options = options;
+        // One frame queued, not two: the canvas is rasterized on the CPU and the GPU only
+        // composites it, so the window answers the pointer a frame sooner (#444).
+        options.wgpu_options.surface = eframe::egui_wgpu::SurfaceConfig::LOW_LATENCY;
         if let eframe::egui_wgpu::WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup {
             create.power_preference = power;
         }
@@ -391,7 +416,7 @@ fn main() -> eframe::Result {
             #[cfg(feature = "wgpu")]
             if let Some(rs) = &cc.wgpu_render_state {
                 let summary = adapter_summary(&rs.adapter.get_info());
-                log::info!("vectorcraft: rendering with {summary} (power preference {power:?})");
+                log::info!("rendering with {summary} (power preference {power:?})");
                 app.graphics_adapter = Some(summary);
                 let (loss, ctx) = (graphics_loss.clone(), cc.egui_ctx.clone());
                 rs.device.set_device_lost_callback(move |reason, msg| loss.report(&ctx, format!("{reason:?}: {msg}")));

apps/vectorcraft/src/native_menu.rs

@@ -33,7 +33,7 @@ pub struct NativeMenu {
 }
 
 /// Accelerator for a shortcut like "Cmd+Shift+]" (modifier-less shortcuts stay in the app so they
-/// don't steal keys from text fields).
+/// don't steal keys from text fields; a focused field still gets Cmd+A/X/C/V, see [`NativeMenu::poll`]).
 fn accel(sc: &str) -> Option<Accelerator> {
     if !(sc.contains("Cmd") || sc.contains("Ctrl") || sc.contains("Alt") || sc.starts_with('F')) {
         return None;
@@ -72,12 +72,13 @@ impl NativeMenu {
         }
     }
 
-    /// Dispatch clicked items and refresh state.
-    pub fn poll(&mut self, app: &mut VectorcraftApp) {
+    /// Dispatch chosen items (a focused text field takes Select All and the clipboard) and refresh
+    /// state.
+    pub fn poll(&mut self, app: &mut VectorcraftApp, ctx: &egui::Context) {
         while let Ok(ev) = MenuEvent::receiver().try_recv() {
             if let Some((cmd, params, _, _)) = self.items.get(ev.id.as_ref()) {
                 let p = if params.is_null() { serde_json::json!({}) } else { params.clone() };
-                menus::invoke(app, cmd, p);
+                menus::invoke_from_system_menu(app, ctx, cmd, p);
             }
         }
         let now = vectorcraft_ui_egui::now_ms();

apps/vectorcraft/src/open_documents.rs

@@ -59,7 +59,7 @@ pub fn take() -> Vec<String> {
 fn add_open_urls_method() {
     let Some(mtm) = MainThreadMarker::new() else { return };
     let Some(delegate) = NSApplication::sharedApplication(mtm).delegate() else {
-        log::warn!("vectorcraft: no application delegate; files opened from Finder won't open");
+        log::warn!("no application delegate; files opened from Finder won't open");
         return;
     };
     let class = AsRef::<AnyObject>::as_ref(&*delegate).class();
@@ -72,7 +72,7 @@ fn add_open_urls_method() {
         objc2::ffi::class_addMethod(std::ptr::from_ref(class).cast_mut(), sel!(application:openURLs:), imp, c"v@:@@".as_ptr())
     };
     if !added.as_bool() {
-        log::warn!("vectorcraft: the application delegate already handles open-document events");
+        log::warn!("the application delegate already handles open-document events");
     }
 }
 

assets/icons/dc-anchor-smooth.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M3 20 C5 11 8 7 12 7 S19 11 21 20"/><path d="M5 7 H19"/><circle cx="5" cy="7" r="1.4" fill="currentColor"/><circle cx="19" cy="7" r="1.4" fill="currentColor"/><rect x="10" y="5" width="4" height="4" fill="currentColor"/></svg>

assets/icons/dc-pen-add.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M12 19l-7-7 3-6 8 3 3 7-7 3z" /><path d="M5 12l5-5"/><circle cx="11" cy="11" r="1.5"/><path d="M19 3v5M16.5 5.5h5"/></svg>

assets/icons/dc-pen-delete.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M12 19l-7-7 3-6 8 3 3 7-7 3z" /><path d="M5 12l5-5"/><circle cx="11" cy="11" r="1.5"/><path d="M16.5 5.5h5"/></svg>

assets/icons/pen-tool-add.svg

@@ -0,0 +1,19 @@
+<!-- @license lucide-static v1.49.0 - ISC -->
+<!-- Lucide's pen-tool with a plus badge added for VectorCraft -->
+<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"
+>
+  <path d="M15.707 21.293a1 1 0 0 1-1.414 0l-1.586-1.586a1 1 0 0 1 0-1.414l5.586-5.586a1 1 0 0 1 1.414 0l1.586 1.586a1 1 0 0 1 0 1.414z" />
+  <path d="m18 13-1.375-6.874a1 1 0 0 0-.746-.776L3.235 2.028a1 1 0 0 0-1.207 1.207L5.35 15.879a1 1 0 0 0 .776.746L13 18" />
+  <path d="m2.3 2.3 7.286 7.286" />
+  <circle cx="11" cy="11" r="2" />
+  <path d="M4 18.3v4.4M1.8 20.5h4.4" />
+</svg>

assets/icons/pen-tool-delete.svg

@@ -0,0 +1,19 @@
+<!-- @license lucide-static v1.49.0 - ISC -->
+<!-- Lucide's pen-tool with a minus badge added for VectorCraft -->
+<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"
+>
+  <path d="M15.707 21.293a1 1 0 0 1-1.414 0l-1.586-1.586a1 1 0 0 1 0-1.414l5.586-5.586a1 1 0 0 1 1.414 0l1.586 1.586a1 1 0 0 1 0 1.414z" />
+  <path d="m18 13-1.375-6.874a1 1 0 0 0-.746-.776L3.235 2.028a1 1 0 0 0-1.207 1.207L5.35 15.879a1 1 0 0 0 .776.746L13 18" />
+  <path d="m2.3 2.3 7.286 7.286" />
+  <circle cx="11" cy="11" r="2" />
+  <path d="M1.8 20.5h4.4" />
+</svg>

contributors/contributors.json

@@ -0,0 +1,348 @@
+{
+  "schema": 1,
+  "repo": "storytold/vectorcraft",
+  "branch": "main",
+  "head": "fe9f3afcb7d32032e8f332b0594692a03e275b84",
+  "head_date": "2026-10-08T00:36:16Z",
+  "commits": 607,
+  "unattributed_commits": 0,
+  "contributors": [
+    {
+      "login": "echelon",
+      "people_entry": true,
+      "github_name": null,
+      "prs": 15,
+      "commits": 119,
+      "lines_added": 172276,
+      "lines_deleted": 40329,
+      "binary_added": 37,
+      "binary_deleted": 2,
+      "first_commit": "2026-09-30T09:12:46Z",
+      "last_commit": "2026-10-07T22:04:30Z"
+    },
+    {
+      "login": "bflatastic",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 176,
+      "commits": 394,
+      "lines_added": 212929,
+      "lines_deleted": 24160,
+      "binary_added": 2,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-02T15:22:29Z",
+      "last_commit": "2026-10-08T00:36:16Z"
+    },
+    {
+      "login": "storybored379",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 7,
+      "commits": 7,
+      "lines_added": 456,
+      "lines_deleted": 49,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-04T06:45:57Z",
+      "last_commit": "2026-10-04T08:14:20Z"
+    },
+    {
+      "login": "theironchef",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 38,
+      "commits": 41,
+      "lines_added": 2803,
+      "lines_deleted": 232,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-05T14:40:20Z",
+      "last_commit": "2026-10-07T22:39:00Z"
+    },
+    {
+      "login": "midasdf",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 2,
+      "commits": 2,
+      "lines_added": 579,
+      "lines_deleted": 43,
+      "binary_added": 1,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-05T16:10:37Z",
+      "last_commit": "2026-10-07T20:53:30Z"
+    },
+    {
+      "login": "japbcoelho",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 1,
+      "lines_added": 57,
+      "lines_deleted": 13,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-06T01:45:49Z",
+      "last_commit": "2026-10-06T01:45:49Z"
+    },
+    {
+      "login": "p0lyg0n",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 5,
+      "commits": 6,
+      "lines_added": 780,
+      "lines_deleted": 69,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-06T09:22:46Z",
+      "last_commit": "2026-10-07T04:33:45Z"
+    },
+    {
+      "login": "imachus",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 12,
+      "commits": 12,
+      "lines_added": 6302,
+      "lines_deleted": 212,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-06T10:06:18Z",
+      "last_commit": "2026-10-07T22:20:10Z"
+    },
+    {
+      "login": "petrleocompel",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 1,
+      "lines_added": 784,
+      "lines_deleted": 36,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-06T12:23:11Z",
+      "last_commit": "2026-10-06T12:23:11Z"
+    },
+    {
+      "login": "fahrim",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 3,
+      "commits": 6,
+      "lines_added": 1964,
+      "lines_deleted": 76,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-06T12:48:28Z",
+      "last_commit": "2026-10-07T23:36:17Z"
+    },
+    {
+      "login": "EthanSuquet",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 4,
+      "commits": 4,
+      "lines_added": 413,
+      "lines_deleted": 71,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-06T19:30:49Z",
+      "last_commit": "2026-10-07T14:24:14Z"
+    },
+    {
+      "login": "realwitt",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 1,
+      "lines_added": 607,
+      "lines_deleted": 3,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-07T00:12:52Z",
+      "last_commit": "2026-10-07T00:12:52Z"
+    },
+    {
+      "login": "WildfootW",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 1,
+      "lines_added": 6809,
+      "lines_deleted": 2627,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-07T00:37:02Z",
+      "last_commit": "2026-10-07T00:37:02Z"
+    },
+    {
+      "login": "coygeek",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 1,
+      "lines_added": 4,
+      "lines_deleted": 0,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-07T02:29:03Z",
+      "last_commit": "2026-10-07T02:29:03Z"
+    },
+    {
+      "login": "Luskish",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 1,
+      "lines_added": 261,
+      "lines_deleted": 32,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-07T02:50:35Z",
+      "last_commit": "2026-10-07T02:50:35Z"
+    },
+    {
+      "login": "daniel-efrat",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 1,
+      "lines_added": 547,
+      "lines_deleted": 43,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-07T08:13:19Z",
+      "last_commit": "2026-10-07T08:13:19Z"
+    },
+    {
+      "login": "Pengjingyu1992",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 1,
+      "lines_added": 3132,
+      "lines_deleted": 4,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-07T09:56:23Z",
+      "last_commit": "2026-10-07T09:56:23Z"
+    },
+    {
+      "login": "MillhioreBT",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 1,
+      "lines_added": 564,
+      "lines_deleted": 41,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-07T12:58:33Z",
+      "last_commit": "2026-10-07T12:58:33Z"
+    },
+    {
+      "login": "fabian-co",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 2,
+      "lines_added": 270,
+      "lines_deleted": 48,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-07T18:05:26Z",
+      "last_commit": "2026-10-07T19:32:11Z"
+    },
+    {
+      "login": "Haven-King",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 2,
+      "lines_added": 467,
+      "lines_deleted": 76,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-07T18:10:39Z",
+      "last_commit": "2026-10-07T18:40:49Z"
+    },
+    {
+      "login": "njmueller",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 1,
+      "lines_added": 619,
+      "lines_deleted": 11,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-07T21:14:42Z",
+      "last_commit": "2026-10-07T21:14:42Z"
+    },
+    {
+      "login": "RicSchonfelder",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 1,
+      "lines_added": 2592,
+      "lines_deleted": 9,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-07T21:44:42Z",
+      "last_commit": "2026-10-07T21:44:42Z"
+    },
+    {
+      "login": "DWAA1660",
+      "people_entry": false,
+      "github_name": null,
+      "prs": 1,
+      "commits": 1,
+      "lines_added": 76,
+      "lines_deleted": 21,
+      "binary_added": 0,
+      "binary_deleted": 0,
+      "first_commit": "2026-10-07T23:09:37Z",
+      "last_commit": "2026-10-07T23:09:37Z"
+    }
+  ],
+  "models": [
+    {
+      "id": "anthropic/claude-opus/5.5",
+      "company": "Anthropic",
+      "model": "Claude Opus",
+      "version": "5.5",
+      "commits": 567,
+      "lines_added": 382239,
+      "lines_deleted": 67174
+    },
+    {
+      "id": "anthropic/claude-sonnet/5.5",
+      "company": "Anthropic",
+      "model": "Claude Sonnet",
+      "version": "5.5",
+      "commits": 6,
+      "lines_added": 660,
+      "lines_deleted": 34
+    },
+    {
+      "id": "anthropic/claude-opus/4.8",
+      "company": "Anthropic",
+      "model": "Claude Opus",
+      "version": "4.8",
+      "commits": 3,
+      "lines_added": 1672,
+      "lines_deleted": 42
+    },
+    {
+      "id": "anthropic/claude-fable/5.1",
+      "company": "Anthropic",
+      "model": "Claude Fable",
+      "version": "5.1",
+      "commits": 1,
+      "lines_added": 6809,
+      "lines_deleted": 2627
+    }
+  ]
+}

contributors/people.toml

@@ -0,0 +1,23 @@
+# Contributor names for the About window (craftrules standards/contributors.md).
+#
+# Everyone who contributes is credited by GitHub username automatically. Anything more is up to
+# you: add YOUR OWN entry below, in your own PR (commit it yourself). Never add someone else; a
+# maintainer may add a person only when that person asked, recording where in consent_source.
+#
+# Easiest: python3 ../../craftrules/scripts/contributors.py --add-me . \
+#            [--real-name "Ada Lovelace"] [--display-name "Ada"] [--sync-github-name]
+#
+# Or copy this block, replacing your-github-username (every field is optional):
+#
+#   [people.your-github-username]
+#   real_name = "Your Name"        # shown when the viewer picks "Real name"
+#   display_name = "Nickname"      # shown when the viewer picks "Display name"
+#   sync_github_name = true        # or: use the name on your public GitHub profile as display name
+#
+# 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.echelon]
+real_name = "Brandon Thomas"
+display_name = "Brandon Thomas"
+sync_github_name = false

crates/doc/src/clipnest.rs

@@ -1,8 +1,10 @@
-//! Clipped art read from page descriptions (metafiles, PostScript) into clipping groups.
+//! Clipped and grouped art read from page descriptions (metafiles, PostScript) into clipping
+//! groups and groups.
 //!
-//! Importers record each object they draw with the chain of clips in force at the time, outermost
-//! first ([`Drawn`]); [`nest`] then puts runs of objects under the same clip into one clipping
-//! group, nesting groups for nested clips, keeping the drawing order.
+//! Importers record each object they draw with the chain of clips (and groups) in force at the
+//! time, outermost first ([`Drawn`]); [`nest`] then puts runs of objects under the same clip into
+//! one clipping group (under the same group into one group), nesting groups for nested clips,
+//! keeping the drawing order.
 
 use std::sync::Arc;
 
@@ -11,20 +13,30 @@ use vectorcraft_geom::{BezPath, FillRule, PathData};
 use crate::appearance::Appearance;
 use crate::{Document, Node, NodeKind};
 
-/// A clip: a region in document space and its rule. Each has an id unique within an import, so
-/// what one clip clips can be grouped.
+/// A clip: a region in document space and its rule, or a plain group (one that holds its art
+/// without clipping it, such as an Illustrator file's `u` … `U`). Each has an id unique within an
+/// import, so what one clip clips (or one group holds) can be grouped.
 #[derive(Debug)]
 pub struct Clip {
     pub id: u32,
-    pub path: BezPath,
-    pub rule: FillRule,
+    /// The region and its rule; `None` for a plain group.
+    pub region: Option<(BezPath, FillRule)>,
+}
+
+/// Deepest nesting of clips, and of groups, an importer records ([`nest`] goes one level deeper
+/// for each): deeper ones are left out.
+pub const MAX_NEST: usize = 128;
+
+/// The warning for clips left out for nesting deeper than [`MAX_NEST`].
+pub fn deep_clips() -> String {
+    format!("clips nested more than {MAX_NEST} deep were left out: what they clip is clipped by the clips around them")
 }
 
 /// Objects in drawing order, each with its clips (outermost first).
 pub type Drawn = Vec<(Vec<Arc<Clip>>, Node)>;
 
-/// The nodes of `items`, those under clips grouped into clipping groups (ids from `doc`), in
-/// order.
+/// The nodes of `items`, those under clips grouped into clipping groups and those in groups into
+/// groups (ids from `doc`), in order.
 pub fn nest(doc: &mut Document, items: Drawn) -> Vec<Arc<Node>> {
     nest_at(doc, items, 0)
 }
@@ -53,14 +65,18 @@ fn nest_at(doc: &mut Document, items: Drawn, depth: usize) -> Vec<Arc<Node>> {
     out
 }
 
-/// A clipping group of `items`, clipped by `c` (their clip at `depth`).
+/// A clipping group of `items`, clipped by `c` (their clip at `depth`), or their group when `c` is
+/// a plain group.
 fn clip_group(doc: &mut Document, c: &Clip, items: Drawn, depth: usize) -> Arc<Node> {
-    let mut path = Node::path(doc.alloc_id(), PathData::from_bezpath(&c.path), Appearance::default());
-    if let NodeKind::Path { clipping, rule, .. } = &mut path.kind {
-        *clipping = true;
-        *rule = c.rule;
+    let mut children = vec![];
+    if let Some((bp, r)) = &c.region {
+        let mut path = Node::path(doc.alloc_id(), PathData::from_bezpath(bp), Appearance::default());
+        if let NodeKind::Path { clipping, rule, .. } = &mut path.kind {
+            *clipping = true;
+            *rule = *r;
+        }
+        children.push(Arc::new(path));
     }
-    let mut children = vec![Arc::new(path)];
     children.extend(nest_at(doc, items, depth + 1));
-    Arc::new(Node::new(doc.alloc_id(), NodeKind::Group { children, clip: true }))
+    Arc::new(Node::new(doc.alloc_id(), NodeKind::Group { children, clip: c.region.is_some() }))
 }

crates/doc/src/hit.rs

@@ -60,6 +60,25 @@ impl Default for HitOptions {
 
 /// Topmost editable object under `p`.
 pub fn hit_test(doc: &Document, p: Point, opt: HitOptions) -> Option<Hit> {
+    hit_test_skipping(doc, p, opt, &|_| false)
+}
+
+/// The objects under `p` that [`Hit::top_object`] picks in `scope` (isolation mode), topmost
+/// first: what clicks there select, one below the other (Cmd/Ctrl-click selects behind).
+pub fn objects_at(doc: &Document, p: Point, opt: HitOptions, scope: Option<NodeId>) -> Vec<NodeId> {
+    let mut tops: Vec<NodeId> = vec![];
+    // Each round leaves out the objects found so far (and everything inside them).
+    while let Some(top) = hit_test_skipping(doc, p, opt, &|id| tops.contains(&id)).map(|h| h.top_object(scope)) {
+        if tops.contains(&top) {
+            break;
+        }
+        tops.push(top);
+    }
+    tops
+}
+
+/// [`hit_test`] passing over the nodes `skip` names (and their contents).
+fn hit_test_skipping(doc: &Document, p: Point, opt: HitOptions, skip: &dyn Fn(NodeId) -> bool) -> Option<Hit> {
     let mut chain = Vec::new();
     for layer in doc.layers.iter().rev() {
         if !layer.visible || layer.locked {
@@ -74,7 +93,7 @@ pub fn hit_test(doc: &Document, p: Point, opt: HitOptions) -> Option<Hit> {
         }
         chain.push(layer.id);
         let opt = if matches!(layer.kind, NodeKind::Layer { preview: false, .. }) { HitOptions { outline: true, ..opt } } else { opt };
-        if let Some(mut h) = hit_children(layer, p, opt, &mut chain) {
+        if let Some(mut h) = hit_children(layer, p, opt, skip, &mut chain) {
             h.contents_of = h.ancestry.iter().rev().copied().find(|a| doc.node(*a).is_some_and(edits_contents));
             h.layers = h.ancestry.iter().take_while(|a| doc.node(**a).is_some_and(Node::is_layer)).count();
             return Some(h);
@@ -99,7 +118,7 @@ fn clip_contains(clip: &Node, p: Point) -> bool {
     clip.clip_shapes(Some(&frame)).iter().any(|(bp, rule)| fill_contains(bp, *rule, p))
 }
 
-fn hit_children(parent: &Node, p: Point, opt: HitOptions, chain: &mut Vec<NodeId>) -> Option<Hit> {
+fn hit_children(parent: &Node, p: Point, opt: HitOptions, skip: &dyn Fn(NodeId) -> bool, chain: &mut Vec<NodeId>) -> Option<Hit> {
     let children = parent.children()?;
     // A clip group (or a layer with a clipping mask) only hits inside its clipping path.
     if parent.clips()
@@ -110,7 +129,7 @@ fn hit_children(parent: &Node, p: Point, opt: HitOptions, chain: &mut Vec<NodeId
     }
     for c in children.iter().rev() {
         // Hidden, locked and template sublayers block clicks like top-level layers do.
-        if !c.visible || c.locked || c.is_template() {
+        if !c.visible || c.locked || c.is_template() || skip(c.id) {
             continue;
         }
         // (An envelope's content sits where it was, not where the envelope draws it.)
@@ -123,13 +142,13 @@ fn hit_children(parent: &Node, p: Point, opt: HitOptions, chain: &mut Vec<NodeId
         chain.push(c.id);
         let hit = match &c.kind {
             // A sublayer whose Preview is off is clicked in outline, like an outline view.
-            NodeKind::Layer { preview: false, .. } => hit_children(c, p, HitOptions { outline: true, ..opt }, chain),
-            NodeKind::Layer { .. } | NodeKind::Group { .. } => hit_children(c, p, opt, chain),
+            NodeKind::Layer { preview: false, .. } => hit_children(c, p, HitOptions { outline: true, ..opt }, skip, chain),
+            NodeKind::Layer { .. } | NodeKind::Group { .. } => hit_children(c, p, opt, skip, chain),
             // Edit Contents: the envelope's content hits, undistorted.
-            NodeKind::Envelope { editing: true, .. } => hit_children(c, p, opt, chain),
+            NodeKind::Envelope { editing: true, .. } => hit_children(c, p, opt, skip, chain),
             // A blend's key objects first (Direct and Group Selection pick them); its steps hit
             // as the blend.
-            NodeKind::Blend { .. } => hit_children(c, p, opt, chain)
+            NodeKind::Blend { .. } => hit_children(c, p, opt, skip, chain)
                 .or_else(|| hit_leaf(c, p, opt).map(|kind| Hit { leaf: c.id, ancestry: chain.clone(), kind, contents_of: None, layers: 1 })),
             _ => hit_leaf(c, p, opt).map(|kind| Hit { leaf: c.id, ancestry: chain.clone(), kind, contents_of: None, layers: 1 }),
         };
@@ -169,7 +188,7 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions) -> Option<HitKind> {
             if let Some(k) = hit_stroke(n, &bp, *rule, p, opt) {
                 return Some(k);
             }
-            (!opt.outline && fill_contains(&bp, *rule, p)).then_some(HitKind::Fill)
+            (!opt.outline && !opt.path_only && fill_contains(&bp, *rule, p)).then_some(HitKind::Fill)
         }
         NodeKind::Text(_) | NodeKind::Image(_) | NodeKind::SymbolInstance { .. } | NodeKind::Blend { .. } | NodeKind::Envelope { .. } => {
             n.geometric_bounds().filter(|b| b.inflate(opt.tol, opt.tol).contains(p)).map(|_| HitKind::Bounds)
@@ -366,6 +385,46 @@ mod tests {
         assert!(hit_test(&d, Point::new(0.5, 25.0), HitOptions::default()).is_some());
     }
 
+    /// Object Selection by Path Only: a filled path or compound path hits on its outline only.
+    #[test]
+    fn path_only_leaves_out_fills() {
+        let mut d = Document::new(200.0, 200.0);
+        let l = d.layers[0].id;
+        let (a, c) = (d.alloc_id(), d.alloc_id());
+        d.insert(Some(l), 0, Node::path(a, shapes::rectangle(Rect::new(0.0, 0.0, 50.0, 50.0)), Appearance::default_art())).unwrap();
+        let inner = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(100.0, 0.0, 150.0, 50.0)), Appearance::default());
+        let mut compound = Node::new(c, NodeKind::Compound { children: vec![Arc::new(inner)], rule: vectorcraft_geom::FillRule::NonZero });
+        compound.appearance = Appearance::default_art();
+        d.insert(Some(l), 9, compound).unwrap();
+        let path_only = HitOptions { path_only: true, ..Default::default() };
+        for (id, inside, edge) in [(a, Point::new(25.0, 25.0), Point::new(0.5, 25.0)), (c, Point::new(125.0, 25.0), Point::new(100.5, 25.0))] {
+            assert_eq!(hit_test(&d, inside, HitOptions::default()).map(|h| h.leaf), Some(id), "the fill hits");
+            assert!(hit_test(&d, inside, path_only).is_none(), "path only: the fill of {id:?} doesn't hit");
+            assert_eq!(hit_test(&d, edge, path_only).map(|h| h.leaf), Some(id), "path only: the outline does");
+        }
+    }
+
+    /// `objects_at`: every object under the point, topmost first; a group counts once.
+    #[test]
+    fn objects_at_lists_the_stack() {
+        let mut d = Document::new(200.0, 200.0);
+        let l = d.layers[0].id;
+        let rect =
+            |d: &mut Document, x: f64| Node::path(d.alloc_id(), shapes::rectangle(Rect::new(x, 0.0, x + 50.0, 50.0)), Appearance::default_art());
+        let a = rect(&mut d, 0.0);
+        let (b, c) = (rect(&mut d, 10.0), rect(&mut d, 20.0));
+        let (a_id, b_id, c_id, g) = (a.id, b.id, c.id, d.alloc_id());
+        d.insert(Some(l), 0, a).unwrap();
+        d.insert(Some(l), 9, Node::group(g, vec![Arc::new(b), Arc::new(c)])).unwrap();
+        let far = rect(&mut d, 120.0);
+        d.insert(Some(l), 9, far).unwrap();
+        let at = |x: f64, scope| objects_at(&d, Point::new(x, 25.0), HitOptions::default(), scope);
+        assert_eq!(at(30.0, None), vec![g, a_id]);
+        assert_eq!(at(30.0, Some(g))[..2], [c_id, b_id], "isolated: the group's own objects");
+        assert_eq!(at(5.0, None), vec![a_id]);
+        assert!(at(90.0, None).is_empty());
+    }
+
     #[test]
     fn locked_and_hidden_skip() {
         let mut d = Document::new(200.0, 200.0);

crates/doc/src/lib.rs

@@ -78,15 +78,15 @@ pub use setup::{Background, DocSetup, ExportText, GridSize, Quotes};
 pub use slices::{CellAlign, CellVAlign, Slice, SliceArea, SliceKind, SliceOptions, SliceSource};
 pub use style_libs::StyleLibrary;
 pub use text::{
-    AreaOptions, CharPosition, CharStyle, FirstBaseline, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathEffect, ScriptMetrics,
-    TabAlign, TabStop, TextKind, TextObject, TextRun, TextStyleDef, TextWrap, WrapShape,
+    AreaOptions, Burasagari, CharAlign, CharPosition, CharStyle, FirstBaseline, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathAlign,
+    PathEffect, ScriptMetrics, TabAlign, TabStop, TextKind, TextObject, TextRun, TextStyleDef, TextWrap, WrapShape,
 };
 pub use vectorcraft_color as color;
 pub use vectorcraft_geom as geom;
 
 use serde::{Deserialize, Serialize};
 use vectorcraft_color::{Swatch, SwatchGroup};
-use vectorcraft_geom::{Point, Rect};
+use vectorcraft_geom::{Point, Rect, Vec2};
 
 #[derive(Debug, thiserror::Error, PartialEq)]
 pub enum DocError {
@@ -167,6 +167,18 @@ impl Unit {
             Unit::Feet => "Feet",
         }
     }
+    /// The rulers' label step at `zoom` (screen pixels per point), in this unit: the first of
+    /// 1, 2, 5 × 10ⁿ that puts labels at least 50 pixels apart. Ticks mark every tenth of it.
+    pub fn ruler_step(self, zoom: f64) -> f64 {
+        const STEPS: [f64; 19] =
+            [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 25.0, 50.0, 100.0, 200.0, 500.0, 1000.0, 2000.0, 5000.0, 10000.0];
+        STEPS.iter().copied().find(|s| s * self.points() * zoom >= 50.0).unwrap_or(10000.0)
+    }
+    /// `v` (points) on the nearest ruler tick at `zoom` ([`Self::ruler_step`]).
+    pub fn snap_to_ruler_tick(self, v: f64, zoom: f64) -> f64 {
+        let tick = self.ruler_step(zoom) / 10.0 * self.points();
+        (v / tick).round() * tick
+    }
     pub fn from_pt(self, v: f64) -> f64 {
         v / self.points()
     }
@@ -179,7 +191,10 @@ impl Unit {
     }
     /// [`Unit::format`] without the suffix (`12.5`), for narrow fields.
     pub fn number(self, pt: f64) -> String {
-        let s = format!("{:.3}", self.from_pt(pt));
+        // Three decimals for the small units (`595.276 pt`), four for the large ones (`8.2677 in`,
+        // `35.2778 mm`, the `0.0078 in` stroke preset); trailing zeros are trimmed (`1 pt` is `1`).
+        let decimals = if matches!(self, Unit::Points | Unit::Pixels | Unit::Picas) { 3 } else { 4 };
+        let s = format!("{:.*}", decimals, self.from_pt(pt));
         let s = s.trim_end_matches('0').trim_end_matches('.');
         if s == "-0" { "0".into() } else { s.into() }
     }
@@ -371,6 +386,22 @@ pub struct Guide {
     /// true = vertical guide at `pos` (x), false = horizontal at `pos` (y).
     pub vertical: bool,
     pub pos: f64,
+    /// An artboard guide: the [`Artboard::id`] it belongs to. It runs across that artboard only
+    /// and moves, is copied and is deleted with it. None: a canvas guide, across the whole canvas.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub artboard: Option<u32>,
+}
+
+impl Guide {
+    /// A canvas guide.
+    pub fn new(vertical: bool, pos: f64) -> Self {
+        Self { vertical, pos, artboard: None }
+    }
+
+    /// Moved by `d` (a vertical guide across, a horizontal one down).
+    pub fn moved(&self, d: Vec2) -> Self {
+        Self { pos: self.pos + if self.vertical { d.x } else { d.y }, ..self.clone() }
+    }
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -902,16 +933,15 @@ impl Document {
     pub fn artboard_at(&self, p: Point) -> Option<usize> {
         self.artboards.iter().rposition(|a| a.rect.contains(p))
     }
-    /// The art that moves with an artboard at `rect`: unlocked top-level objects (children of
-    /// unlocked layers and sublayers) lying entirely inside it.
-    pub fn art_on_artboard(&self, rect: Rect) -> Vec<NodeId> {
-        fn collect(n: &Node, rect: Rect, out: &mut Vec<NodeId>) {
-            for c in n.children().into_iter().flatten() {
-                if c.locked {
-                    continue;
-                }
+    /// The art that moves with an artboard at `rect`: top-level objects (children of layers and
+    /// sublayers) lying entirely inside it. Locked and hidden objects and layers stay put unless
+    /// `locked_and_hidden` (Selection & Anchor Display › Move Locked and Hidden Artwork with
+    /// Artboard).
+    pub fn art_on_artboard(&self, rect: Rect, locked_and_hidden: bool) -> Vec<NodeId> {
+        fn collect(n: &Node, rect: Rect, all: bool, out: &mut Vec<NodeId>) {
+            for c in n.children().into_iter().flatten().filter(|c| c.rides_with_artboard(all)) {
                 if c.is_layer() {
-                    collect(c, rect, out);
+                    collect(c, rect, all, out);
                 } else if let Some(b) = c.geometric_bounds()
                     && rect.contains(Point::new(b.x0, b.y0))
                     && rect.contains(Point::new(b.x1, b.y1))
@@ -921,11 +951,52 @@ impl Document {
             }
         }
         let mut art = vec![];
-        for l in self.layers.iter().filter(|l| !l.locked) {
-            collect(l, rect, &mut art);
+        for l in self.layers.iter().filter(|l| l.rides_with_artboard(locked_and_hidden)) {
+            collect(l, rect, locked_and_hidden, &mut art);
         }
         art
     }
+    /// Where ruler guide `g` runs along its line (the y range of a vertical guide): across its
+    /// artboard for an artboard guide, None (the whole canvas) for a canvas guide or one whose
+    /// artboard is gone.
+    pub fn guide_span(&self, g: &Guide) -> Option<(f64, f64)> {
+        let r = self.artboards.iter().find(|a| Some(a.id) == g.artboard)?.rect;
+        Some(if g.vertical { (r.y0, r.y1) } else { (r.x0, r.x1) })
+    }
+    /// Does ruler guide `g` run past `p` (up to `tol` beyond its ends)?
+    pub fn guide_passes(&self, g: &Guide, p: Point, tol: f64) -> bool {
+        let along = if g.vertical { p.y } else { p.x };
+        self.guide_span(g).is_none_or(|(a, b)| along >= a - tol && along <= b + tol)
+    }
+    /// Keep the ruler guides `keep` accepts (by index), the selected ones left keeping their
+    /// place among the rest (the selected art stays selected). Returns how many went.
+    pub fn retain_guides(&mut self, sel: &mut Selection, keep: impl Fn(usize, &Guide) -> bool) -> usize {
+        let kept: Vec<bool> = self.guides.iter().enumerate().map(|(i, g)| keep(i, g)).collect();
+        // Where each kept guide ends up.
+        let (mut to, mut n) = (Vec::with_capacity(kept.len()), 0);
+        for k in &kept {
+            to.push(k.then_some(n));
+            n += usize::from(*k);
+        }
+        sel.guides = sel.guides.iter().filter_map(|i| to.get(*i).copied().flatten()).collect();
+        let before = self.guides.len();
+        let mut flags = kept.into_iter();
+        self.guides.retain(|_| flags.next().unwrap_or(true));
+        before - self.guides.len()
+    }
+    /// Move the guides of artboard `id` by `d` (along with their artboard).
+    pub fn move_artboard_guides(&mut self, id: u32, d: Vec2) {
+        for g in self.guides.iter_mut().filter(|g| g.artboard == Some(id)) {
+            *g = g.moved(d);
+        }
+    }
+    /// Copy the guides of artboard `from` onto artboard `to`, `d` away (with a copy of their
+    /// artboard).
+    pub fn copy_artboard_guides(&mut self, from: u32, to: u32, d: Vec2) {
+        let copies: Vec<Guide> =
+            self.guides.iter().filter(|g| g.artboard == Some(from)).map(|g| Guide { artboard: Some(to), ..g.moved(d) }).collect();
+        self.guides.extend(copies);
+    }
     pub fn next_artboard_id(&self) -> u32 {
         self.artboards.iter().map(|a| a.id).max().unwrap_or(0) + 1
     }
@@ -1076,12 +1147,18 @@ mod tests {
     #[test]
     fn art_on_artboard_takes_unlocked_objects_wholly_inside() {
         let (mut d, a, b) = doc_with_rects();
-        assert_eq!(d.art_on_artboard(Rect::new(-1.0, -1.0, 15.0, 15.0)), vec![a]);
-        assert_eq!(d.art_on_artboard(Rect::new(-1.0, -1.0, 25.0, 15.0)), vec![a], "b only half inside");
+        let wide = Rect::new(-1.0, -1.0, 40.0, 15.0);
+        assert_eq!(d.art_on_artboard(Rect::new(-1.0, -1.0, 15.0, 15.0), false), vec![a]);
+        assert_eq!(d.art_on_artboard(Rect::new(-1.0, -1.0, 25.0, 15.0), false), vec![a], "b only half inside");
         d.node_mut(a).unwrap().locked = true;
-        assert_eq!(d.art_on_artboard(Rect::new(-1.0, -1.0, 40.0, 15.0)), vec![b]);
+        assert_eq!(d.art_on_artboard(wide, false), vec![b]);
+        // Move Locked and Hidden Artwork with Artboard (#394): hidden art stays too, unless on.
+        d.node_mut(b).unwrap().visible = false;
+        assert!(d.art_on_artboard(wide, false).is_empty());
+        assert_eq!(d.art_on_artboard(wide, true), vec![a, b]);
         Arc::make_mut(&mut d.layers[0]).locked = true;
-        assert!(d.art_on_artboard(Rect::new(-1.0, -1.0, 40.0, 15.0)).is_empty());
+        assert!(d.art_on_artboard(wide, false).is_empty());
+        assert_eq!(d.art_on_artboard(wide, true), vec![a, b], "a locked layer's art too");
     }
 
     #[test]

crates/doc/src/live.rs

@@ -589,6 +589,46 @@ impl GradientMesh {
         self.rows >= 1 && self.cols >= 1 && self.points.len() == (self.rows as usize + 1) * (self.cols as usize + 1)
     }
 
+    /// A 1×1 mesh from its four corners (bottom-left, top-left, top-right, bottom-right in u/v
+    /// order: row 0 is v = 0, columns follow u), each with its handles ([`H_RIGHT`] …).
+    fn patch(corners: [(Point, [Vec2; 4], Color); 4]) -> Self {
+        let point = |(p, handles, color): (Point, [Vec2; 4], Color)| MeshPoint { p, color, opacity: 1.0, handles };
+        let [a, b, c, d] = corners;
+        Self { rows: 1, cols: 1, points: vec![point(a), point(d), point(b), point(c)] }
+    }
+
+    /// A 1×1 mesh from a Coons patch's twelve boundary points (in the order PDF and PostScript
+    /// shadings list them: v runs cp0 → cp3 along cp1 and cp2, u runs cp0 → cp9 along cp11 and
+    /// cp10) and its corner colours (at cp0, cp3, cp6, cp9); `None` if a point isn't finite.
+    pub fn coons(cp: &[Point; 12], colors: [Color; 4]) -> Option<Self> {
+        if !cp.iter().all(|p| p.is_finite()) {
+            return None;
+        }
+        let h = |a: usize, b: usize| cp[b] - cp[a];
+        let handles = |right: Vec2, left: Vec2, down: Vec2, up: Vec2| {
+            let mut h = [Vec2::ZERO; 4];
+            (h[H_RIGHT], h[H_LEFT], h[H_DOWN], h[H_UP]) = (right, left, down, up);
+            h
+        };
+        let [c0, c1, c2, c3] = colors;
+        Some(Self::patch([
+            (cp[0], handles(h(0, 11), Vec2::ZERO, h(0, 1), Vec2::ZERO), c0),
+            (cp[3], handles(h(3, 4), Vec2::ZERO, Vec2::ZERO, h(3, 2)), c1),
+            (cp[6], handles(Vec2::ZERO, h(6, 5), Vec2::ZERO, h(6, 7)), c2),
+            (cp[9], handles(Vec2::ZERO, h(9, 10), h(9, 8), Vec2::ZERO), c3),
+        ]))
+    }
+
+    /// A 1×1 mesh of a Gouraud-shaded triangle (a patch with two corners together); `None` if a
+    /// point isn't finite.
+    pub fn triangle(corners: [(Point, Color); 3]) -> Option<Self> {
+        if !corners.iter().all(|(p, _)| p.is_finite()) {
+            return None;
+        }
+        let [a, b, c] = corners.map(|(p, color)| (p, [Vec2::ZERO; 4], color));
+        Some(Self::patch([a, b, c, c]))
+    }
+
     /// A mesh over surface `s` (u, v ∈ [0,1]) with handles from its partial derivatives.
     pub fn from_surface(rows: u32, cols: u32, s: &dyn Fn(f64, f64) -> Point, color: &dyn Fn(f64, f64) -> Color) -> Self {
         let (us, vs) = (even_steps(cols), even_steps(rows));

crates/doc/src/node.rs

@@ -143,24 +143,11 @@ impl LiveShape {
     /// scale in `xf` keep their exact geometry until they're next transformed).
     pub fn transform(&mut self, a: Affine) -> bool {
         match self {
-            LiveShape::Rectangle { w, h, radii, xf, .. } => {
-                let m = a * *xf;
+            LiveShape::Rectangle { xf, .. } => {
+                *xf = a * *xf;
                 let [a0, a1, a2, a3, _, _] = a.as_coeffs();
                 let moves_only = (a0 - 1.0).abs() < 1e-12 && a1.abs() < 1e-12 && a2.abs() < 1e-12 && (a3 - 1.0).abs() < 1e-12;
-                let [m0, m1, m2, m3, m4, m5] = m.as_coeffs();
-                let (sx, sy) = (m0.hypot(m1), m2.hypot(m3));
-                let orthogonal = sx > 1e-12 && sy > 1e-12 && (m0 * m2 + m1 * m3).abs() <= 1e-9 * sx * sy;
-                let finite = m.as_coeffs().iter().all(|c| c.is_finite()) && w.is_finite() && h.is_finite();
-                if moves_only || !orthogonal || !finite {
-                    *xf = m;
-                    return false;
-                }
-                let k = (sx * sy).sqrt();
-                radii.iter_mut().for_each(|r| *r *= k);
-                *w *= sx;
-                *h *= sy;
-                *xf = Affine::new([m0 / sx, m1 / sx, m2 / sy, m3 / sy, m4, m5]);
-                true
+                !moves_only && self.fold_scale()
             }
             LiveShape::Ellipse { xf, .. } | LiveShape::Polygon { xf, .. } => {
                 *xf = a * *xf;
@@ -173,6 +160,35 @@ impl LiveShape {
             }
         }
     }
+    /// Move the scale of a rectangle's `xf` into `w`/`h` (and its radii, by the mean scale), so
+    /// `xf` keeps only a rotation or reflection plus a move and the corners are circular in the
+    /// document. False (and nothing changes) when there is no scale to move, when `xf` shears or
+    /// isn't finite, and for other shapes. Files saved before transforms did this (#291) carry an
+    /// uneven scale in `xf`: their corners are elliptical until this runs.
+    pub fn fold_scale(&mut self) -> bool {
+        let LiveShape::Rectangle { w, h, radii, xf, .. } = self else { return false };
+        let [m0, m1, m2, m3, m4, m5] = xf.as_coeffs();
+        let (sx, sy) = (m0.hypot(m1), m2.hypot(m3));
+        let orthogonal = sx > 1e-12 && sy > 1e-12 && (m0 * m2 + m1 * m3).abs() <= 1e-9 * sx * sy;
+        let finite = xf.as_coeffs().iter().all(|c| c.is_finite()) && w.is_finite() && h.is_finite();
+        let unscaled = (sx - 1.0).abs() < 1e-12 && (sy - 1.0).abs() < 1e-12;
+        if !orthogonal || !finite || unscaled {
+            return false;
+        }
+        let k = (sx * sy).sqrt();
+        radii.iter_mut().for_each(|r| *r *= k);
+        *w *= sx;
+        *h *= sy;
+        *xf = Affine::new([m0 / sx, m1 / sx, m2 / sy, m3 / sy, m4, m5]);
+        true
+    }
+    /// This shape with [`LiveShape::fold_scale`] applied: a rectangle's size and radii in document
+    /// units (what Live Corners show and edit).
+    pub fn folded(&self) -> Self {
+        let mut s = self.clone();
+        s.fold_scale();
+        s
+    }
     /// Divide live corner radii by `k`, the mean scale of a transform just applied, so the corners
     /// keep their size (Scale Corners off). False when nothing changed.
     pub fn keep_corners(&mut self, k: f64) -> bool {
@@ -212,15 +228,16 @@ impl LiveShape {
     pub fn corner_anchors(&self, corners: [bool; 4]) -> BTreeSet<AnchorRef> {
         self.anchor_corners().into_iter().enumerate().filter(|(_, k)| corners.get(*k) == Some(&true)).map(|(ai, _)| (0, ai)).collect()
     }
-    /// The radius and kind the `corners` of a rectangle share (each `None` when they differ).
+    /// The radius (in document units, see [`LiveShape::folded`]) and kind the `corners` of a
+    /// rectangle share (each `None` when they differ).
     pub fn corner_style(&self, corners: [bool; 4]) -> (Option<f64>, Option<CornerKind>) {
-        let LiveShape::Rectangle { radii, kinds, .. } = self else { return (None, None) };
+        let LiveShape::Rectangle { radii, kinds, .. } = self.folded() else { return (None, None) };
         fn shared<T: Copy>(v: [T; 4], corners: [bool; 4], same: impl Fn(T, T) -> bool) -> Option<T> {
             let mut it = v.into_iter().zip(corners).filter(|(_, on)| *on).map(|(x, _)| x);
             let first = it.next()?;
             it.all(|x| same(x, first)).then_some(first)
         }
-        (shared(*radii, corners, |a, b| (a - b).abs() < 1e-9), shared(*kinds, corners, |a, b| a == b))
+        (shared(radii, corners, |a, b| (a - b).abs() < 1e-9), shared(kinds, corners, |a, b| a == b))
     }
     /// Rotation angle of the live shape in degrees (shown in the Properties panel).
     pub fn angle_deg(&self) -> f64 {
@@ -252,6 +269,9 @@ pub struct Scaling {
     pub keep_type_strokes: bool,
     /// Live corner radii keep their size.
     pub keep_corners: bool,
+    /// Pattern fills and strokes move with the art (Transform Patterns; General › Transform
+    /// Pattern Tiles is its default): their tiles transform too, instead of staying put.
+    pub patterns: bool,
 }
 
 impl Scaling {
@@ -526,6 +546,12 @@ impl Node {
             _ => None,
         }
     }
+    /// Does this object or layer move with its artboard? Locked and hidden ones only with
+    /// `locked_and_hidden` (Selection & Anchor Display › Move Locked and Hidden Artwork with
+    /// Artboard).
+    pub fn rides_with_artboard(&self, locked_and_hidden: bool) -> bool {
+        locked_and_hidden || (!self.locked && self.visible)
+    }
     pub fn is_layer(&self) -> bool {
         matches!(self.kind, NodeKind::Layer { .. })
     }
@@ -721,6 +747,9 @@ impl Node {
             }
         }
         self.appearance.transform_gradients(a);
+        if sc.patterns {
+            crate::pattern::transform_pattern_paints(self, a);
+        }
         match &mut self.kind {
             NodeKind::Path { path, live, .. } => {
                 path.transform(a);
@@ -1318,7 +1347,7 @@ mod tests {
         }
     }
 
-    const KEEP_CORNERS: Scaling = Scaling { strokes: false, effects: None, keep_type_strokes: false, keep_corners: true };
+    const KEEP_CORNERS: Scaling = Scaling { strokes: false, effects: None, keep_type_strokes: false, keep_corners: true, patterns: false };
 
     #[test]
     fn uneven_scales_keep_live_corners_circular() {
@@ -1383,6 +1412,33 @@ mod tests {
         assert_round_corners(&n, Affine::IDENTITY, 20.0 * 2f64.sqrt() * 2.0);
     }
 
+    /// A rectangle saved with an uneven scale in `xf` (before #291) has elliptical corners; Live
+    /// Corners see and edit it in document units, with circular corners (#442).
+    #[test]
+    fn a_scale_left_in_the_transform_folds_into_the_size() {
+        let legacy = Affine::translate((5.0, 5.0)) * Affine::scale_non_uniform(4.0, 1.0);
+        let n = live_rect(50.0, 80.0, 20.0, legacy);
+        let NodeKind::Path { live: Some(live), .. } = &n.kind else { panic!("not live") };
+        let folded = live.folded();
+        assert_eq!(live_of(&n).3, legacy, "folded() leaves the shape alone");
+        let LiveShape::Rectangle { w, h, radii, xf, .. } = &folded else { panic!("not a rectangle") };
+        // Drawn 200 × 80 with 80 × 20 corners; folded, the corners are circles of the mean radius.
+        assert!(near(*w, 200.0) && near(*h, 80.0) && radii.iter().all(|r| near(*r, 40.0)), "{w} × {h} r {radii:?}");
+        assert!(near_xf(*xf, Affine::translate((5.0, 5.0))));
+        let (a, b) = (folded.to_path().bounds().unwrap(), live.to_path().bounds().unwrap());
+        assert!(near(a.x0, b.x0) && near(a.y0, b.y0) && near(a.x1, b.x1) && near(a.y1, b.y1), "same place and size: {a:?} {b:?}");
+        assert_eq!(live.corner_style([true; 4]).0, Some(40.0), "the radius in document units");
+        // Nothing to fold: a moved, rotated or reflected rectangle and a sheared one stay as they are.
+        let place = Affine::translate((5.0, 5.0)) * Affine::rotate(0.5) * Affine::scale_non_uniform(-1.0, 1.0);
+        let shear = Affine::new([1.0, 0.0, 0.5, 1.0, 0.0, 0.0]);
+        for xf in [place, shear] {
+            let mut l = live_rect(100.0, 160.0, 20.0, xf);
+            let NodeKind::Path { live: Some(live), .. } = &mut l.kind else { panic!("not live") };
+            assert!(!live.fold_scale());
+            assert_eq!(live_of(&l), (100.0, 160.0, [20.0; 4], xf));
+        }
+    }
+
     #[test]
     fn default_transparency() {
         let p = || Node::path(NodeId(1), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::default_art());

crates/doc/src/selection.rs

@@ -1,4 +1,4 @@
-//! Selection state (objects and, for direct selection, individual anchors).
+//! Selection state (objects and, for direct selection, individual anchors; ruler guides).
 
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -29,12 +29,20 @@ pub struct Selection {
     /// clears them.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub slices: Vec<NodeId>,
+    /// Ruler guides selected with a selection tool, as indexes into [`Document::guides`]. They are
+    /// selected on their own: any change to the object selection clears them.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub guides: Vec<usize>,
 }
 
 impl Selection {
     pub fn is_empty(&self) -> bool {
         self.objects.is_empty()
     }
+    /// Is anything selected that Delete and the arrow keys act on: objects or ruler guides?
+    pub fn has_objects_or_guides(&self) -> bool {
+        !self.objects.is_empty() || !self.guides.is_empty()
+    }
     pub fn len(&self) -> usize {
         self.objects.len()
     }
@@ -47,6 +55,7 @@ impl Selection {
         self.key = None;
         self.target = None;
         self.slices.clear();
+        self.guides.clear();
     }
     pub fn set(&mut self, ids: impl IntoIterator<Item = NodeId>) {
         self.clear();
@@ -57,6 +66,7 @@ impl Selection {
     pub fn add(&mut self, id: NodeId) {
         self.target = None;
         self.slices.clear();
+        self.guides.clear();
         if !self.objects.contains(&id) {
             self.objects.push(id);
         }
@@ -64,6 +74,7 @@ impl Selection {
     pub fn remove(&mut self, id: NodeId) {
         self.target = None;
         self.slices.clear();
+        self.guides.clear();
         self.objects.retain(|x| *x != id);
         self.anchors.remove(&id);
         if self.key == Some(id) {
@@ -79,6 +90,15 @@ impl Selection {
             }
         }
     }
+    /// Select ruler guides `indexes` (see [`Selection::guides`]) and nothing else.
+    pub fn set_guides(&mut self, indexes: impl IntoIterator<Item = usize>) {
+        self.clear();
+        for i in indexes {
+            if !self.guides.contains(&i) {
+                self.guides.push(i);
+            }
+        }
+    }
     pub fn toggle(&mut self, id: NodeId) {
         if self.contains(id) { self.remove(id) } else { self.add(id) }
     }
@@ -97,6 +117,7 @@ impl Selection {
             self.target = None;
         }
         self.slices.retain(|id| doc.is_slice(*id));
+        self.guides.retain(|i| *i < doc.guides.len());
     }
     /// Target `id` (see [`Selection::target`]): a layer gets its visible, unlocked art selected
     /// (the art of its sublayers too), anything else is selected itself.
@@ -138,6 +159,23 @@ mod tests {
         assert!(s.is_empty());
     }
 
+    #[test]
+    fn guides_are_selected_on_their_own() {
+        let mut s = Selection::default();
+        s.add(NodeId(1));
+        s.set_guides([2, 0, 2]);
+        assert_eq!((s.objects.clone(), s.guides.clone()), (vec![], vec![2, 0]));
+        assert!(s.has_objects_or_guides() && s.is_empty());
+        s.add(NodeId(1));
+        assert!(s.guides.is_empty());
+        // Pruning drops guides the document no longer has.
+        let mut d = Document::new(100.0, 100.0);
+        d.guides.push(crate::Guide::new(true, 10.0));
+        s.set_guides([0, 1]);
+        s.prune(&d);
+        assert_eq!(s.guides, vec![0]);
+    }
+
     #[test]
     fn selection_changes_clear_the_target() {
         let mut s = Selection::default();

crates/doc/src/tests_units.rs

@@ -60,6 +60,9 @@ fn readouts_show_two_decimals() {
     assert_eq!(Unit::Points.readout(15.0), "15.00 pt");
     assert_eq!(Unit::Millimeters.readout(72.0), "25.40 mm");
     assert_eq!(Unit::Inches.readout(-36.0), "-0.50 in");
-    assert_eq!(Unit::Millimeters.number(1.0), "0.353");
-    assert_eq!(Unit::Points.number(-0.0001), "0");
+    assert_eq!(Unit::Millimeters.number(1.0), "0.3528");
+    // Four decimals for the large units, three for the small ones.
+    assert_eq!(Unit::Inches.number(0.5616), "0.0078");
+    assert_eq!((Unit::Inches.number(595.2756), Unit::Points.number(595.2756)), ("8.2677".into(), "595.276".into()));
+    assert_eq!(Unit::Points.number(-0.00001), "0");
 }

crates/doc/src/text.rs

@@ -86,6 +86,23 @@ pub struct CharStyle {
     /// size (Document Setup → Type → Small Caps); None = off.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub small_caps: Option<f64>,
+    /// Character Alignment (Character panel menu): where characters smaller than the largest on
+    /// their line line up with it.
+    #[serde(default, rename = "charAlign", skip_serializing_if = "crate::skip::is_default")]
+    pub char_align: CharAlign,
+}
+
+/// Where a character smaller than the largest on its line lines up with it: on the Roman
+/// baseline, or at the top (right, in vertical type), centre or bottom (left) of the ideographic
+/// em boxes.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum CharAlign {
+    #[default]
+    RomanBaseline,
+    EmBoxTop,
+    EmBoxCenter,
+    EmBoxBottom,
 }
 
 /// Superscript or subscript proportions in percent of the font size (Document Setup → Type).
@@ -178,6 +195,7 @@ impl Default for CharStyle {
             stroke_miter_limit: 10.0,
             stroke_dash: None,
             position: CharPosition::Normal,
+            char_align: CharAlign::RomanBaseline,
             small_caps: None,
         }
     }
@@ -296,6 +314,10 @@ pub struct ParaStyle {
     /// How leading is measured (Paragraph panel menu): from baseline to baseline, or from the top
     /// of one line's ideographic em box to the next.
     pub leading_model: LeadingModel,
+    /// Hanging punctuation (Paragraph panel menu › Burasagari): a comma or full stop ending a line
+    /// may stand outside the frame. New type takes [`Burasagari::Standard`]; documents from before
+    /// it and imported text keep [`Burasagari::None`].
+    pub burasagari: Burasagari,
 }
 
 /// [`ParaStyle`] as saved. [`Justify::Auto`] is written as the alignment it has in the paragraph
@@ -329,6 +351,8 @@ struct ParaStyleFile {
     direction: Option<ParaDirection>,
     #[serde(default, skip_serializing_if = "crate::skip::is_default")]
     leading_model: LeadingModel,
+    #[serde(default, skip_serializing_if = "crate::skip::is_default")]
+    burasagari: Burasagari,
 }
 
 impl From<ParaStyle> for ParaStyleFile {
@@ -351,6 +375,7 @@ impl From<ParaStyle> for ParaStyleFile {
             mojikumi,
             direction,
             leading_model,
+            burasagari,
             ..
         } = p;
         Self {
@@ -367,6 +392,7 @@ impl From<ParaStyle> for ParaStyleFile {
             mojikumi,
             direction,
             leading_model,
+            burasagari,
         }
     }
 }
@@ -386,6 +412,7 @@ impl From<ParaStyleFile> for ParaStyle {
             mojikumi,
             direction,
             leading_model,
+            burasagari,
             ..
         } = f;
         Self {
@@ -401,6 +428,7 @@ impl From<ParaStyleFile> for ParaStyle {
             mojikumi,
             direction,
             leading_model,
+            burasagari,
         }
     }
 }
@@ -447,6 +475,22 @@ impl Mojikumi {
     }
 }
 
+/// Hanging punctuation (burasagari): an East Asian comma or full stop ending a line (、。，．､｡)
+/// stands outside the line's measure, in the space its punctuation spacing gives it (half width
+/// with Line-end Punctuation Half Width). Closing brackets and Latin punctuation don't hang. Shown
+/// as None / Regular / Force.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Burasagari {
+    /// A comma or full stop that doesn't fit goes to the next line with the character before it.
+    #[default]
+    None,
+    /// A comma or full stop that doesn't fit hangs outside the line; one that fits stays inside.
+    Standard,
+    /// A comma or full stop ending a line always hangs, and the rest of the line fills the measure.
+    Forced,
+}
+
 /// Area Type Options "First Baseline" offset.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -521,6 +565,36 @@ impl PathEffect {
     }
 }
 
+/// Type on a Path Options › Align to Path: which height of the type runs along the path.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum PathAlign {
+    /// The font's top edge: the type hangs below the path.
+    Ascender,
+    /// The font's bottom edge: the type stands above the path.
+    Descender,
+    /// Halfway between the ascender and the descender.
+    Center,
+    /// The baseline (the default).
+    #[default]
+    Baseline,
+}
+
+impl PathAlign {
+    pub const ALL: [PathAlign; 4] = [PathAlign::Ascender, PathAlign::Descender, PathAlign::Center, PathAlign::Baseline];
+    pub fn id(self) -> &'static str {
+        match self {
+            PathAlign::Ascender => "ascender",
+            PathAlign::Descender => "descender",
+            PathAlign::Center => "center",
+            PathAlign::Baseline => "baseline",
+        }
+    }
+    pub fn parse(s: &str) -> Option<Self> {
+        Self::ALL.into_iter().find(|a| a.id().eq_ignore_ascii_case(s.trim()))
+    }
+}
+
 /// Area Type Options: rows and columns, gutters, inset and first baseline of area type.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
@@ -565,8 +639,48 @@ pub enum TextKind {
     Point,
     /// Area type flowed inside `frame` (document coordinates, untransformed by `xf`).
     Area { frame: PathData },
-    /// Type on a path, starting at `start` (0..1 of the path length).
-    OnPath { path: PathData, start: f64 },
+    /// Type on a path, flowing from its start bracket `start` to its end bracket `end` (0..1 of the
+    /// path length; no `end`: the end of the path, or once round a closed path). See
+    /// [`TextKind::path_span`].
+    OnPath {
+        path: PathData,
+        start: f64,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        end: Option<f64>,
+    },
+}
+
+impl TextKind {
+    /// Type on a path's span: from its start to its end bracket, as fractions of its path's length.
+    /// Round a closed path the end may be past 1 (the span runs on past the path's start), a full
+    /// turn without an end or with the end at the start. None for other type.
+    pub fn path_span(&self) -> Option<(f64, f64)> {
+        let TextKind::OnPath { path, start, end } = self else { return None };
+        let s = fraction(*start);
+        Some(if path.is_closed() {
+            let run = end.map_or(0.0, |e| (fraction(e) - s).rem_euclid(1.0));
+            (s, s + if run < 1e-9 { 1.0 } else { run })
+        } else {
+            (s, end.map_or(1.0, |e| fraction(e).max(s)))
+        })
+    }
+}
+
+/// `x` as a fraction of a path's length (0..1; 0 when not finite).
+fn fraction(x: f64) -> f64 {
+    if x.is_finite() { x.clamp(0.0, 1.0) } else { 0.0 }
+}
+
+/// `path` run the other way, each point as far from its new start as it was from its old end
+/// (the subpaths in reverse order, a closed one keeping its first anchor first).
+fn reverse_from_end(path: &mut PathData) {
+    path.subpaths.reverse();
+    for sp in &mut path.subpaths {
+        sp.reverse();
+        if sp.closed && !sp.anchors.is_empty() {
+            sp.anchors.rotate_right(1);
+        }
+    }
 }
 
 /// A text object. `runs` split into paragraphs at `\n`.
@@ -587,6 +701,14 @@ pub struct TextObject {
     /// Type on a Path effect (type on a path only).
     #[serde(default, rename = "pathEffect", skip_serializing_if = "crate::skip::is_default")]
     pub path_effect: PathEffect,
+    /// Type on a Path Options › Align to Path (type on a path only).
+    #[serde(default, rename = "pathAlign", skip_serializing_if = "crate::skip::is_default")]
+    pub path_align: PathAlign,
+    /// Type on a Path Options › Spacing in points (type on a path only): glyphs are spaced as if
+    /// set this far above the path, which closes them up round the outside of a curve and opens
+    /// them up round the inside.
+    #[serde(default, rename = "pathSpacing", skip_serializing_if = "crate::skip::is_default")]
+    pub path_spacing: f64,
     /// Wrap objects above this area type, resolved by the engine after each edit (text space).
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub wrap: Vec<WrapShape>,
@@ -605,6 +727,8 @@ impl TextObject {
             para: ParaStyle::default(),
             area: AreaOptions::default(),
             path_effect: PathEffect::default(),
+            path_align: PathAlign::default(),
+            path_spacing: 0.0,
             wrap: Vec::new(),
             cached_bounds: None,
         }
@@ -634,6 +758,29 @@ impl TextObject {
     pub fn transform(&mut self, a: Affine) {
         self.xf = a * self.xf;
     }
+    /// Type on a path's path in document space; None for other type.
+    pub fn type_path(&self) -> Option<PathData> {
+        match &self.kind {
+            TextKind::OnPath { path, .. } => Some(path.transformed(self.xf)),
+            _ => None,
+        }
+    }
+    /// Flip type on a path to the other side of its path (Type on a Path Options › Flip, or its
+    /// centre bracket dragged across the path): the path runs the other way and the brackets swap
+    /// ends, so the type keeps its stretch of the path. False, changing nothing, for other type.
+    pub fn flip_on_path(&mut self) -> bool {
+        let Some((s, e)) = self.kind.path_span() else { return false };
+        let TextKind::OnPath { path, start, end } = &mut self.kind else { return false };
+        reverse_from_end(path);
+        if path.is_closed() {
+            *start = (1.0 - e).rem_euclid(1.0);
+            *end = (e - s < 1.0 - 1e-9).then(|| (1.0 - s).rem_euclid(1.0));
+        } else {
+            *start = 1.0 - e;
+            *end = (s > 1e-9).then_some(1.0 - s);
+        }
+        true
+    }
     /// Area type's frame (the type area) in document space; None for other type.
     pub fn area_frame(&self) -> Option<PathData> {
         match &self.kind {

crates/engine/src/cmd/buildcmds.rs

@@ -16,7 +16,7 @@ use serde_json::{Value, json};
 use vectorcraft_color::{Color, Paint};
 use vectorcraft_doc::appearance::{AppearanceItem, FillLayer, StrokeLayer};
 use vectorcraft_doc::{Appearance, Document, Node, NodeId, NodeKind, Selection};
-use vectorcraft_geom::{FillRule, PathData, Point, Rect};
+use vectorcraft_geom::{FillRule, PathData, Point, Rect, SubPath};
 use vectorcraft_pathops as po;
 use vectorcraft_tools::builder::{
     self as b, BuilderMap, EDGE_NAME, FACE_NAME, LIVE_PAINT_NAME, SOURCES_NAME, Touched, edge_near, face_at, is_live_paint, sample_polyline,
@@ -39,7 +39,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Shape Builder",
             [],
             None,
-            "{ids?: [id…] (default: selection), points: [[x,y]…] (drag path; one point = click), erase?: bool (Alt-drag deletes the regions, and the pieces of unfilled open paths within tolerance), tolerance?: pt (2, erase only), fill?: \"#rrggbb\" | {color|swatch|gradient|none} (default: the fill of the object under the first point; the current fill for an area only lines enclose)} → {ids, merged, regions, lines}",
+            "{ids?: [id…] (default: selection), points: [[x,y]…] (drag path; one point = click), erase?: bool (erase mode, Alt: deletes the regions touched, and the pieces of unfilled open paths and the edges (outline pieces between the points where paths meet; see shapeBuilder.regions) within tolerance; a deleted edge opens its path there, and edges bounding a deleted region go with it), tolerance?: pt (2, erase only), fill?: \"#rrggbb\" | {color|swatch|gradient|none} (default: the fill of the object under the first point; the current fill for an area only lines enclose)} → {ids, merged, regions, lines, edges} (counts deleted or merged)",
             has_selection_or_ids,
             sb_merge
         ),
@@ -48,7 +48,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Shape Builder Regions",
             [],
             None,
-            "{ids?} → {regions: [{bounds: [x0,y0,x1,y1], area, sources: [id…]}], lines: [{bounds, source: id}]} faces of the planar arrangement (unfilled open paths cut them; sources is empty for an area only they enclose) and the pieces of those open paths",
+            "{ids?} → {regions: [{bounds: [x0,y0,x1,y1], area, sources: [id…]}], lines: [{bounds, source: id}], edges: [{bounds, source: id}]} faces of the planar arrangement (unfilled open paths cut them; sources is empty for an area only they enclose), the pieces of those open paths and the edges (the other paths' outlines cut where paths meet; source: the front-most path along it), which erasing deletes",
             has_selection_or_ids,
             sb_regions
         ),
@@ -225,14 +225,14 @@ fn sb_merge(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad(C, "points must be a non-empty list of finite [x,y]"));
     }
     let erase = bool_or(p, "erase", false);
-    // Line pieces are only deleted (Alt), never merged.
-    let line_tol = erase.then(|| f64_or(p, "tolerance", 2.0).clamp(0.0, 1000.0));
+    // Line pieces and edges are only deleted (erase mode), never merged.
+    let piece_tol = erase.then(|| f64_or(p, "tolerance", 2.0).clamp(0.0, 1000.0));
     let fill = fill_param(s, p, C)?;
     let current_fill = s.paint.fill.clone();
     let roots = root_ids(s, p)?;
     let label = if erase { "Shape Builder Delete" } else { "Shape Builder" };
-    let (ids, merged, regions, lines) = s.edit(label, |d, sel| {
-        let (map, leaves) = BuilderMap::new(d, &roots);
+    let (ids, merged, touched) = s.edit(label, |d, sel| {
+        let (map, leaves) = BuilderMap::new(d, &roots, erase);
         let leaves: Vec<Node> = leaves.into_iter().cloned().collect();
         if map.shapes.is_empty() {
             return Err(EngineError::Other("Shape Builder: select paths or compound paths".into()));
@@ -240,11 +240,15 @@ fn sb_merge(s: &mut Session, p: &Value) -> Result<Value> {
         let step = (d.bounds_of(&roots, false).map(|r| r.width().max(r.height())).unwrap_or(100.0) / 2000.0).max(0.25);
         let mut touched = Touched::default();
         for q in sample_polyline(&pts, step) {
-            touched.add(map.hit(q, line_tol));
+            touched.add(map.hit(q, piece_tol));
         }
+        touched.edges = map.erased_edges(&touched);
         if touched.is_empty() {
             return Err(EngineError::Other("Shape Builder: no region under the pointer".into()));
         }
+        let cuts: Vec<&SubPath> = touched.edges.iter().filter_map(|&k| map.edges.get(k)?.0.path.subpaths.first()).collect();
+        // Edges come back from the planar map within a few hundredths of the outlines they follow.
+        let cut_tol = step * 0.2;
         let picked: Vec<&po::Region> = touched.regions.iter().filter_map(|&i| map.regions.get(i).map(|r| &r.0)).collect();
         let union = if picked.is_empty() { PathData::default() } else { po::merge_regions(&picked) };
         // The merged shape takes the look of the front-most object over the first region, or (for an
@@ -269,11 +273,26 @@ fn sb_merge(s: &mut Session, p: &Value) -> Result<Value> {
                         }
                     }
                 }
-            } else if !picked.iter().any(|r| r.sources.contains(&i)) {
-                new_nodes.push(d.reid(leaf));
             } else {
-                let rest = po::boolean(&sh.path, sh.rule, &union, FillRule::NonZero, po::BoolOp::Difference);
-                if !rest.is_empty() {
+                // A shape loses the regions deleted or merged, then the edges deleted (each one on
+                // its outline, shared edges from every shape along them).
+                let in_union = picked.iter().any(|r| r.sources.contains(&i));
+                let mut rest = if in_union {
+                    po::boolean(&sh.path, sh.rule, &union, FillRule::NonZero, po::BoolOp::Difference)
+                } else {
+                    b::node_outline(leaf).map_or_else(|| sh.path.clone(), |o| o.0)
+                };
+                let fill_closes = !leaf.appearance.fill_paint().is_none();
+                let mut cut = false;
+                for piece in &cuts {
+                    if let Some(r) = po::cut_out(&rest, piece, fill_closes, cut_tol) {
+                        rest = r;
+                        cut = true;
+                    }
+                }
+                if !in_union && !cut {
+                    new_nodes.push(d.reid(leaf));
+                } else if !rest.is_empty() {
                     new_nodes.push(shape_node(d, rest, Some(leaf)));
                 }
             }
@@ -288,9 +307,15 @@ fn sb_merge(s: &mut Session, p: &Value) -> Result<Value> {
         }
         let new_ids = replace_roots(d, &roots, new_nodes)?;
         sel.set(new_ids.iter().copied());
-        Ok((new_ids, merged_id, touched.regions.len(), touched.lines.len()))
+        Ok((new_ids, merged_id, touched))
     })?;
-    Ok(json!({ "ids": ids_json(&ids), "merged": merged.map(|m| m.0), "regions": regions, "lines": lines }))
+    Ok(json!({
+        "ids": ids_json(&ids),
+        "merged": merged.map(|m| m.0),
+        "regions": touched.regions.len(),
+        "lines": touched.lines.len(),
+        "edges": touched.edges.len(),
+    }))
 }
 
 /// Remove the roots and insert `nodes` where the front-most root was. Returns the new ids.
@@ -315,7 +340,7 @@ fn replace_roots(d: &mut Document, roots: &[NodeId], nodes: Vec<Node>) -> Result
 fn sb_regions(s: &mut Session, p: &Value) -> Result<Value> {
     let roots = root_ids(s, p)?;
     let d = &s.doc()?.doc;
-    let (map, leaves) = BuilderMap::new(d, &roots);
+    let (map, leaves) = BuilderMap::new(d, &roots, true);
     let id_of = |i: usize| leaves.get(i).map(|n| n.id.0);
     let regions: Vec<Value> = map
         .regions
@@ -328,9 +353,10 @@ fn sb_regions(s: &mut Session, p: &Value) -> Result<Value> {
             })
         })
         .collect();
-    let lines: Vec<Value> =
-        map.lines.iter().map(|(l, bb)| json!({ "bounds": [bb.x0, bb.y0, bb.x1, bb.y1], "source": id_of(l.key as usize) })).collect();
-    Ok(json!({ "regions": regions, "lines": lines }))
+    let pieces = |list: &[(po::Shape, Rect)]| -> Vec<Value> {
+        list.iter().map(|(l, bb)| json!({ "bounds": [bb.x0, bb.y0, bb.x1, bb.y1], "source": id_of(l.key as usize) })).collect()
+    };
+    Ok(json!({ "regions": regions, "lines": pieces(&map.lines), "edges": pieces(&map.edges) }))
 }
 
 // ---------- Live Paint ----------

crates/engine/src/cmd/clipboard.rs

@@ -21,7 +21,7 @@ use vectorcraft_color::Swatch;
 use vectorcraft_doc::{Document, GraphicStyle, ImageBlob, Node, NodeId, PatternDef, Symbol, TextStyleDef};
 use vectorcraft_geom::Rect;
 
-pub use flavours::{BITMAP, EMF, Flavour, PASTE_ORDER, PDF, PNG, SVG, TEXT};
+pub use flavours::{BITMAP, EMF, FILE_HEAD, Flavour, PASTE_ORDER, PDF, PNG, SVG, TEXT, file_flavour};
 pub(crate) use resources::SwatchChoices;
 
 use super::*;
@@ -87,11 +87,14 @@ pub struct Clipboard {
     /// The open document the objects came from ([`DocState::uid`]): pasting back into it uses its
     /// own resources as they are now.
     pub source_doc: Option<u64>,
+    /// An artboard copied with the Artboard tool (`artboard.copy`); `nodes` are then its art. Pasting
+    /// adds a copy of it with the art.
+    pub artboard: Option<vectorcraft_doc::Artboard>,
 }
 
 impl Clipboard {
     pub fn is_empty(&self) -> bool {
-        self.nodes.is_empty()
+        self.nodes.is_empty() && self.artboard.is_none()
     }
 
     /// Objects `roots` of `st`'s document with their resources, source artboard and layers.

crates/engine/src/cmd/clipboard/flavours.rs

@@ -30,6 +30,23 @@ pub const EMF: &str = "image/emf";
 /// What Paste reads from other apps, best first: vector art before text, text before bitmaps
 /// (word processors offer a picture of copied text too).
 pub const PASTE_ORDER: [&str; 5] = [SVG, PDF, EMF, TEXT, BITMAP];
+/// How much of a copied file [`file_flavour`] needs to tell what it is.
+pub const FILE_HEAD: usize = 4096;
+
+/// What a file copied in a file manager pastes as, if one of `mimes` (`image/*`: any bitmap):
+/// SVG, PDF, a Windows metafile or a bitmap (its own `image/…` type), told from its first
+/// [`FILE_HEAD`] bytes and its name. The file's bytes are that flavour's data.
+pub fn file_flavour(name: &str, head: &[u8], mimes: &[&str]) -> Option<&'static str> {
+    let f = fileio::detect(name, head)?;
+    let (asked, mime) = match f.id {
+        "svg" => (SVG, SVG),
+        "pdf" => (PDF, PDF),
+        "emf" | "wmf" => (EMF, EMF),
+        _ if f.raster => (BITMAP, f.mime),
+        _ => return None,
+    };
+    mimes.contains(&asked).then_some(mime)
+}
 
 /// One representation of the clipboard's contents.
 #[derive(Clone, Debug, PartialEq, Eq)]

crates/engine/src/cmd/colormgmt.rs

@@ -8,9 +8,11 @@
 //! become active when assigned.
 
 use std::collections::BTreeMap;
+use std::sync::Arc;
 
 use serde_json::{Value, json};
 use vectorcraft_color::cms::{self, ColorSettings, Intent, Model, ProofTarget};
+use vectorcraft_color::recolor::Neutral;
 use vectorcraft_color::{Color, Paint};
 use vectorcraft_doc::ColorMode;
 use vectorcraft_render::proof;
@@ -55,7 +57,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Convert Document Color Mode",
             [],
             None,
-            "same as file.documentColorMode: {mode: \"cmyk\"|\"rgb\", convert?: true, intent?} → {changed} (an alias kept for older scripts; the command palette leaves it out)",
+            "same as file.documentColorMode: {mode: \"cmyk\"|\"rgb\", convert?: true, intent?, grays?} → {changed} (an alias kept for older scripts; the command palette leaves it out)",
             has_doc,
             convert_mode
         ),
@@ -232,6 +234,28 @@ fn assign_profile(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({"rgb": rgb, "cmyk": cmyk}))
 }
 
+/// How Document Color Mode converts neutral RGB greys (R = G = B) to CMYK (the `grays` param).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum Grays {
+    /// Through the CMYK profile like any colour: four-colour greys and a rich black.
+    #[default]
+    Profile,
+    /// On the black plate only: K is the grey's ink percentage (as Convert to Grayscale and then
+    /// to CMYK would give).
+    Black,
+}
+
+impl Grays {
+    /// The `grays` param of `cmd`: `"profile"` (default) or `"black"`.
+    pub(crate) fn param(cmd: &str, p: &Value) -> Result<Self> {
+        match str_param(p, "grays").map(str::to_ascii_lowercase).as_deref() {
+            None | Some("profile") => Ok(Grays::Profile),
+            Some("black") => Ok(Grays::Black),
+            Some(g) => Err(bad(cmd, format!("grays must be \"profile\" or \"black\", not `{g}`"))),
+        }
+    }
+}
+
 /// File → Document Color Mode (`file.documentColorMode` and its alias
 /// `object.convertDocumentColorMode`): set the mode and, unless `convert: false`, convert every
 /// colour through the colour settings.
@@ -243,6 +267,7 @@ pub(crate) fn convert_mode(s: &mut Session, p: &Value) -> Result<Value> {
         _ => return Err(bad(C, "mode must be \"cmyk\" or \"rgb\"")),
     };
     let intent = intent_param(p, C)?;
+    let grays = Grays::param(C, p)?;
     // Choosing the mode the document already has (the checked menu item) is not an edit.
     if s.doc()?.doc.color_mode == mode {
         return Ok(json!({ "changed": 0 }));
@@ -250,18 +275,20 @@ pub(crate) fn convert_mode(s: &mut Session, p: &Value) -> Result<Value> {
     let convert = bool_or(p, "convert", true);
     let mut changed = 0usize;
     s.edit("Document Color Mode", |d, _| {
-        changed = set_color_mode(d, mode, convert, intent);
+        changed = set_color_mode(d, mode, convert, intent, grays);
         Ok(())
     })?;
     Ok(json!({ "changed": changed }))
 }
 
-/// Put `d` in colour `mode` and, with `convert`, convert every colour of its art, symbols and
-/// swatches through the colour settings (`intent`, default: theirs) → how many colours changed.
-/// Greys stay greys (they print on the black plate in either mode); Lab colours (spot colour
+/// Put `d` in colour `mode` and, with `convert`, convert every colour of its art, symbols,
+/// pattern tiles and swatches through the colour settings (`intent`, default: theirs) → how many
+/// colours of the art, symbols and patterns changed. Gray colours stay Gray (they print on the
+/// black plate in either mode); RGB greys are colours like any other and separate through the
+/// CMYK profile, unless `grays` puts them on the black plate. Lab colours (spot colour
 /// definitions) are device independent and fit either mode. Document Color Mode and
 /// `document.open {colorMode}` both convert this way.
-pub(crate) fn set_color_mode(d: &mut vectorcraft_doc::Document, mode: ColorMode, convert: bool, intent: Option<Intent>) -> usize {
+pub(crate) fn set_color_mode(d: &mut vectorcraft_doc::Document, mode: ColorMode, convert: bool, intent: Option<Intent>, grays: Grays) -> usize {
     d.color_mode = mode;
     if !convert {
         return 0;
@@ -269,15 +296,25 @@ pub(crate) fn set_color_mode(d: &mut vectorcraft_doc::Document, mode: ColorMode,
     let c = cms::active();
     let intent = intent.unwrap_or(c.settings().intent);
     let model = if mode == ColorMode::Cmyk { Model::Cmyk } else { Model::Rgb };
-    let conv = |col: &Color| if matches!(col, Color::Gray { .. } | Color::Lab { .. }) { *col } else { c.convert(col, model, intent) };
+    let k_only = model == Model::Cmyk && grays == Grays::Black;
+    let conv = |col: &Color| match col {
+        Color::Gray { .. } | Color::Lab { .. } => *col,
+        // Grey ink percentage, then K only (a Gray colour's CMYK).
+        Color::Rgb { .. } if k_only && Neutral::of(col).is_some() => c.convert(&c.convert(col, Model::Gray, intent), Model::Cmyk, intent),
+        _ => c.convert(col, model, intent),
+    };
     let mut changed = 0usize;
-    proof::map_document_colors(d, &mut |col, _| {
+    let mut count = |col: &Color, _: proof::Link| {
         let n = conv(col);
         if n != *col {
             changed += 1;
         }
         n
-    });
+    };
+    proof::map_document_colors(d, &mut count);
+    for a in d.patterns.iter_mut().flat_map(|p| &mut p.art) {
+        proof::map_node_colors(Arc::make_mut(a), &mut count);
+    }
     for sw in d.swatches_iter_mut() {
         match &mut sw.paint {
             Paint::Solid { color, .. } => *color = conv(color),

crates/engine/src/cmd/create.rs

@@ -50,7 +50,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Create Text",
             [],
             None,
-            "{x, y, text, vertical?: bool = false, size?: pt, font?: family, style?, color?, area?: {width, height}} → {id}",
+            "{x, y, text, vertical?: bool = false, size?: pt, font?: family, style?, color?, area?: {width, height}, placeholder?: bool (fill it with placeholder text instead, as the Type tools do with prefs placeholderText)} → {id}",
             has_doc,
             text_create
         ),
@@ -414,16 +414,25 @@ fn text_create(s: &mut Session, p: &Value) -> Result<Value> {
         let h = f64_or(a, "height", 100.0);
         t.kind = vectorcraft_doc::TextKind::Area { frame: shapes::rectangle(Rect::new(0.0, 0.0, w, h)) };
     }
-    let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t);
-    t.cached_bounds = Some(lay.bounds);
+    if bool_or(p, "placeholder", false) {
+        super::typemenu::fill_with_placeholder(&mut t);
+    } else {
+        super::typecmd::refresh_bounds(&mut t);
+    }
     add_node(s, "Type", NodeKind::Text(Box::new(t)), Appearance::default(), None)
 }
 
 /// The paragraph attributes new type gets (the Type tools, `text.create`): aligned to the start of
 /// each paragraph's direction (left, right for Hebrew and Arabic), Japanese punctuation composed
-/// with Line-end Punctuation Half Width. Imported text keeps its own.
+/// with Line-end Punctuation Half Width and Standard burasagari (as in Illustrator). Imported text
+/// keeps its own.
 pub(crate) fn new_type_para() -> vectorcraft_doc::ParaStyle {
-    vectorcraft_doc::ParaStyle { justify: vectorcraft_doc::Justify::Auto, mojikumi: vectorcraft_doc::Mojikumi::LineEndHalf, ..Default::default() }
+    vectorcraft_doc::ParaStyle {
+        justify: vectorcraft_doc::Justify::Auto,
+        mojikumi: vectorcraft_doc::Mojikumi::LineEndHalf,
+        burasagari: vectorcraft_doc::Burasagari::Standard,
+        ..Default::default()
+    }
 }
 
 /// The character style new type gets: `size`, `font`, `style` and `color` from `p`, else the

crates/engine/src/cmd/docmenu.rs

@@ -7,6 +7,7 @@ use std::sync::Arc;
 
 use serde_json::{Value, json};
 use vectorcraft_doc::{CharStyle, Guide, Node, NodeId, NodeKind, SavedSelection, TextKind};
+use vectorcraft_geom::Vec2;
 
 use super::edit::selected_roots;
 use super::*;
@@ -154,16 +155,58 @@ pub fn specs() -> Vec<CommandSpec> {
             has_doc,
             clear_guides
         ),
-        cmd!("guide.add", "Add Guide", [], None, "{vertical: bool, pos: pt (x for vertical, y for horizontal)} → {index}", has_doc, guide_add),
-        cmd!("guide.remove", "Remove Guide", [], None, "{index}", guides_unlocked, guide_remove),
-        cmd!("guide.move", "Move Guide", [], None, "{index, pos: pt}", guides_unlocked, guide_move),
+        cmd!(
+            "guide.add",
+            "Add Guide",
+            [],
+            None,
+            "{vertical: bool, pos: pt (x for vertical, y for horizontal), artboard?: index (an artboard guide: it runs across that artboard only and moves, is copied and is deleted with it; default a canvas guide, across the whole canvas)} → {index}",
+            has_doc,
+            guide_add
+        ),
+        cmd!(
+            query "guide.list",
+            "Guides",
+            [],
+            None,
+            "{} → [{index, vertical, pos, selected, artboard?: index (an artboard guide's)}…] the ruler guides",
+            has_doc,
+            guide_list
+        ),
+        cmd!(
+            "guide.select",
+            "Select Guides",
+            [],
+            None,
+            "{indexes: [index…], toggle?: bool} select ruler guides on their own (deselecting the art); toggle adds or removes them instead → {selected: [index…]}",
+            guides_unlocked,
+            guide_select
+        ),
+        cmd!(
+            "guide.remove",
+            "Remove Guide",
+            [],
+            None,
+            "{index?} delete ruler guide `index`, else the selected ones (as Delete / edit.clear does) → {count}",
+            guides_unlocked,
+            guide_remove
+        ),
+        cmd!(
+            "guide.move",
+            "Move Guide",
+            [],
+            None,
+            "{index, pos: pt} put ruler guide `index` at `pos` | {dx?, dy?: pt, copy?: bool} move the selected guides (vertical ones by dx, horizontal ones by dy); copy leaves them and selects the moved copies",
+            guides_unlocked,
+            guide_move
+        ),
         cmd!("file.closeAll", "Close All", ["File"], Some("Cmd+Alt+W"), "{} → {closed}", has_doc, close_all),
         cmd!(
             "file.documentColorMode",
             "Document Color Mode",
             ["File", "Document Color Mode"],
             None,
-            "{mode: \"cmyk\"|\"rgb\", convert?: true (convert every colour of the art, symbols and swatches through the colour settings; swatch links kept; greys stay greys), intent?} → {changed}",
+            "{mode: \"cmyk\"|\"rgb\", convert?: true (convert every colour of the art, symbols, pattern tiles and swatches through the colour settings; swatch links kept; Gray colours stay Gray, on the black plate), intent?, grays?: \"profile\" (default: RGB greys separate through the CMYK profile like any colour, into four-colour greys and a rich black) | \"black\" (to CMYK, RGB greys with R = G = B go on the black plate only, K = their grey value)} → {changed}",
             has_doc,
             super::colormgmt::convert_mode
         ),
@@ -428,6 +471,10 @@ fn release_guides(s: &mut Session, _: &Value) -> Result<Value> {
 fn lock_guides(s: &mut Session, p: &Value) -> Result<Value> {
     let v = p.get("locked").and_then(Value::as_bool).unwrap_or(!s.menu.guides_locked);
     s.menu.guides_locked = v;
+    // Locked guides can't stay selected.
+    if v && !s.doc()?.selection.guides.is_empty() {
+        s.select(|_, sel| sel.guides.clear())?;
+    }
     Ok(json!({ "locked": v }))
 }
 
@@ -451,35 +498,112 @@ fn clear_guides(s: &mut Session, _: &Value) -> Result<Value> {
 fn guide_add(s: &mut Session, p: &Value) -> Result<Value> {
     let pos = f64_req(p, "pos", "guide.add")?;
     let vertical = bool_or(p, "vertical", false);
+    let artboard = match p.get("artboard").filter(|v| !v.is_null()) {
+        Some(v) => {
+            let boards = &s.doc()?.doc.artboards;
+            let ab = v.as_u64().and_then(|i| boards.get(usize::try_from(i).ok()?)).ok_or_else(|| EngineError::Other("no such artboard".into()))?;
+            Some(ab.id)
+        }
+        None => None,
+    };
     let i = s.edit("New Guide", |d, _| {
-        d.guides.push(Guide { vertical, pos });
+        d.guides.push(Guide { artboard, ..Guide::new(vertical, pos) });
         Ok(d.guides.len() - 1)
     })?;
     Ok(json!({ "index": i }))
 }
 
-fn guide_index(s: &Session, p: &Value, cmd: &str) -> Result<usize> {
-    let i = p.get("index").and_then(Value::as_u64).ok_or_else(|| bad(cmd, "missing index"))? as usize;
+fn guide_list(s: &mut Session, _: &Value) -> Result<Value> {
+    let st = s.doc()?;
+    let row = |(i, g): (usize, &Guide)| {
+        let mut r = json!({ "index": i, "vertical": g.vertical, "pos": g.pos, "selected": st.selection.guides.contains(&i) });
+        if let Some(ab) = st.doc.artboards.iter().position(|a| Some(a.id) == g.artboard) {
+            r["artboard"] = json!(ab);
+        }
+        r
+    };
+    Ok(Value::Array(st.doc.guides.iter().enumerate().map(row).collect()))
+}
+
+/// Ruler guide `index` of the active document (`index` validated).
+fn guide_index(s: &Session, v: Option<&Value>, cmd: &str) -> Result<usize> {
+    let i = v.and_then(Value::as_u64).and_then(|i| usize::try_from(i).ok()).ok_or_else(|| bad(cmd, "an index must be a whole number"))?;
     if i >= s.doc()?.doc.guides.len() {
-        return Err(bad(cmd, "no such guide"));
+        return Err(bad(cmd, format!("no guide {i}")));
     }
     Ok(i)
 }
 
-fn guide_remove(s: &mut Session, p: &Value) -> Result<Value> {
-    let i = guide_index(s, p, "guide.remove")?;
-    s.edit("Delete Guide", |d, _| {
-        d.guides.remove(i);
-        Ok(())
-    })?;
-    ok()
+fn guide_select(s: &mut Session, p: &Value) -> Result<Value> {
+    let list = p.get("indexes").and_then(Value::as_array).ok_or_else(|| bad("guide.select", "missing indexes"))?;
+    let picked = list.iter().map(|v| guide_index(s, Some(v), "guide.select")).collect::<Result<Vec<_>>>()?;
+    if bool_or(p, "toggle", false) {
+        let mut now = s.doc()?.selection.guides.clone();
+        for i in picked {
+            if let Some(k) = now.iter().position(|g| *g == i) {
+                now.remove(k);
+            } else {
+                now.push(i);
+            }
+        }
+        s.select(|_, sel| sel.set_guides(now))?;
+    } else {
+        s.select(|_, sel| sel.set_guides(picked))?;
+    }
+    Ok(json!({ "selected": s.doc()?.selection.guides }))
 }
 
-fn guide_move(s: &mut Session, p: &Value) -> Result<Value> {
-    let i = guide_index(s, p, "guide.move")?;
-    let pos = f64_req(p, "pos", "guide.move")?;
-    s.edit("Move Guide", |d, _| {
-        d.guides[i].pos = pos;
+/// Delete ruler guide `index`, else the selected guides, in one undo step → {count}.
+pub(crate) fn guide_remove(s: &mut Session, p: &Value) -> Result<Value> {
+    let gone: Vec<usize> = match p.get("index") {
+        Some(v) => vec![guide_index(s, Some(v), "guide.remove")?],
+        None => s.doc()?.selection.guides.clone(),
+    };
+    if gone.is_empty() {
+        return Err(bad("guide.remove", "no guide selected"));
+    }
+    let label = if gone.len() == 1 { "Delete Guide" } else { "Delete Guides" };
+    s.edit(label, |d, sel| {
+        d.retain_guides(sel, |i, _| !gone.contains(&i));
+        Ok(())
+    })?;
+    Ok(json!({ "count": gone.len() }))
+}
+
+/// Put ruler guide `index` at `pos`, else move (or copy) the selected guides, in one undo step.
+pub(crate) fn guide_move(s: &mut Session, p: &Value) -> Result<Value> {
+    if let Some(v) = p.get("index") {
+        let i = guide_index(s, Some(v), "guide.move")?;
+        let pos = f64_req(p, "pos", "guide.move")?;
+        s.edit("Move Guide", |d, _| {
+            if let Some(g) = d.guides.get_mut(i) {
+                g.pos = pos;
+            }
+            Ok(())
+        })?;
+        return ok();
+    }
+    let moving = s.doc()?.selection.guides.clone();
+    if moving.is_empty() {
+        return Err(bad("guide.move", "no guide selected (or give an index)"));
+    }
+    let (dx, dy, copy) = (f64_or(p, "dx", 0.0), f64_or(p, "dy", 0.0), bool_or(p, "copy", false));
+    s.edit(if copy { "Copy Guide" } else { "Move Guide" }, |d, sel| {
+        let mut copies = vec![];
+        for &i in &moving {
+            let Some(g) = d.guides.get_mut(i) else { continue };
+            let moved = g.moved(Vec2::new(dx, dy));
+            if copy {
+                copies.push(moved);
+            } else {
+                *g = moved;
+            }
+        }
+        if copy {
+            let first = d.guides.len();
+            d.guides.extend(copies);
+            sel.set_guides(first..d.guides.len());
+        }
         Ok(())
     })?;
     ok()

crates/engine/src/cmd/draw2.rs

@@ -670,34 +670,13 @@ fn convert_anchor(s: &mut Session, p: &Value) -> Result<Value> {
     s.edit("Convert Anchor Point", |d, _| {
         let path = path_mut(d, id)?;
         let sp = path.subpaths.get_mut(si).ok_or_else(|| EngineError::Other("no such subpath".into()))?;
-        let n = sp.anchors.len();
-        if ai >= n {
-            return Err(EngineError::Other("no such anchor".into()));
-        }
-        let prev = if ai > 0 || sp.closed { Some(sp.anchors[(ai + n - 1) % n].p) } else { None };
-        let next = if ai + 1 < n || sp.closed { Some(sp.anchors[(ai + 1) % n].p) } else { None };
-        let a = &mut sp.anchors[ai];
-        if !smooth {
-            a.retract();
-            return Ok(());
-        }
+        let a = sp.anchors.get_mut(ai).ok_or_else(|| EngineError::Other("no such anchor".into()))?;
         match target {
-            Some(t) if t.distance(a.p) > 1e-9 => {
-                a.h_out = t;
-                a.h_in = a.p - (t - a.p);
-                a.kind = AnchorKind::Smooth;
-            }
+            _ if !smooth => a.retract(),
+            Some(t) if t.distance(a.p) > 1e-9 => *a = Anchor::smooth(a.p, t),
             Some(_) => a.retract(),
             None => {
-                let (pp, nn) = (prev.unwrap_or(a.p), next.unwrap_or(a.p));
-                let dir = nn - pp;
-                let l = dir.hypot();
-                if l > 1e-9 {
-                    let u = dir / l;
-                    a.h_in = a.p - u * (a.p.distance(pp) / 3.0);
-                    a.h_out = a.p + u * (a.p.distance(nn) / 3.0);
-                    a.kind = AnchorKind::Smooth;
-                }
+                sp.smooth_anchor(ai);
             }
         }
         Ok(())
@@ -767,30 +746,13 @@ fn split(s: &mut Session, p: &Value) -> Result<Value> {
             }
             _ => return Err(EngineError::Other("no such segment".into())),
         };
+        let mut pieces = sp.cut_at(&std::collections::BTreeSet::from([k]));
         if sp.closed {
-            sp.anchors.rotate_left(k);
-            let mut last = sp.anchors[0];
-            last.h_out = last.p;
-            sp.anchors[0].h_in = sp.anchors[0].p;
-            last.kind = AnchorKind::Corner;
-            sp.anchors[0].kind = AnchorKind::Corner;
-            sp.anchors.push(last);
-            sp.closed = false;
-            path.subpaths[si] = sp;
+            path.subpaths[si] = pieces.pop().ok_or_else(|| EngineError::Other("no such anchor".into()))?;
             sel.set([id]);
             return Ok(vec![id]);
         }
-        let n = sp.anchors.len();
-        if k == 0 || k + 1 >= n {
-            return Err(EngineError::Other("cannot split an open path at its end point".into()));
-        }
-        let mut left = SubPath::new(sp.anchors[..=k].to_vec(), false);
-        let mut right = SubPath::new(sp.anchors[k..].to_vec(), false);
-        let lp = left.anchors[k].p;
-        left.anchors[k].h_out = lp;
-        left.anchors[k].kind = AnchorKind::Corner;
-        right.anchors[0].h_in = lp;
-        right.anchors[0].kind = AnchorKind::Corner;
+        let [left, right] = <[SubPath; 2]>::try_from(pieces).map_err(|_| EngineError::Other("cannot split an open path at its end point".into()))?;
         if path.subpaths.len() == 1 {
             path.subpaths[0] = left;
             let node = sibling_with(d, id, PathData::single(right))?;

crates/engine/src/cmd/edit.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use serde_json::{Value, json};
 use vectorcraft_doc::{Document, Node, NodeId, Unit};
-use vectorcraft_geom::Affine;
+use vectorcraft_geom::{Affine, Vec2};
 
 use super::clipboard::SwatchChoices;
 use super::*;
@@ -24,8 +24,9 @@ pub fn specs() -> Vec<CommandSpec> {
         ),
         cmd!("file.close", "Close", ["File"], Some("Cmd+W"), "{index?}", has_doc, file_close),
         cmd!("document.activate", "Activate Document", [], None, "{index}", always, doc_activate),
-        cmd!(query "document.inspect", "Inspect Document", [], None, "{} → layer tree, artboards, selection, history", has_doc, |s, _| Ok(inspect::document(s))),
-        cmd!(query "document.node", "Inspect Object", [], None, "{id, summary?: the compact document.inspect-style summary instead of the full object JSON} → one object", has_doc, doc_node),
+        cmd!(query "document.inspect", "Inspect Document", [], None, "{depth?, childLimit?} → layer tree, artboards, selection, history (a sliced tree reports childCount)", has_doc, |s, p| Ok(inspect::document_opts(s, slice_opts(p, "document.inspect")?))),
+        cmd!(query "document.node", "Inspect Object", [], None, "{id, summary?: compact summary, depth?: child levels in the summary (default all), childLimit?: children shown per node (default all; a level that shows fewer reports childCount)} → one object", has_doc, doc_node),
+        cmd!(query "document.find", "Find Objects", [], None, "{name?: substring of the Layers panel name, kind?: panel label such as Group, Path, Type or Image (exact), text?: substring of type content, limit?: max matches (default 100, 0 counts only)} → {matches: [{id, name, kind, path}], total}", has_doc, doc_find),
         cmd!(query "document.json", "Document JSON", [], None, "{} → complete document model", has_doc, |s, _| Ok(serde_json::to_value(&*s.doc()?.doc).unwrap_or(Value::Null))),
         cmd!(
             "document.setUnits",
@@ -38,14 +39,14 @@ pub fn specs() -> Vec<CommandSpec> {
         ),
         cmd!("edit.undo", "Undo", ["Edit"], Some("Cmd+Z"), "{}", can_undo, undo),
         cmd!("edit.redo", "Redo", ["Edit"], Some("Cmd+Shift+Z"), "{}", can_redo, redo),
-        cmd!("edit.cut", "Cut", ["Edit"], Some("Cmd+X"), "{}", has_selection, cut),
-        cmd!("edit.copy", "Copy", ["Edit"], Some("Cmd+C"), "{}", has_selection, copy),
+        cmd!("edit.cut", "Cut", ["Edit"], Some("Cmd+X"), "{} (the Artboard tool chosen: artboard.cut)", has_selection_or_artboard_tool, cut),
+        cmd!("edit.copy", "Copy", ["Edit"], Some("Cmd+C"), "{} (the Artboard tool chosen: artboard.copy)", has_selection_or_artboard_tool, copy),
         cmd!(
             "edit.paste",
             "Paste",
             ["Edit"],
             Some("Cmd+V"),
-            "{center?: [x, y], dx?, dy?, swatchConflict?} paste centred on `center` (the app passes the view centre), else offset by dx/dy (default: the Paste Offset preference). Pasting brings the image blobs, symbols, patterns, global and spot swatches (with the tint swatches of the tints used), gradient swatches, graphic styles, character and paragraph styles and brushes the objects use; one of the same name that differs comes in renamed. swatchConflict, for a swatch whose name the document gives another colour (clipboard.conflicts): \"merge\" (default: the objects take the document's swatch) | \"add\" (the pasted swatch comes in renamed) | {name: \"merge\"|\"add\"}. With Paste Remembers Layers on (layer.pasteRemembersLayers), objects go back into the layers they came from (by name; made when missing) → {ids, added: resources added, merged: conflicts merged, renamed: [{kind, from, to}]}",
+            "{center?: [x, y], dx?, dy?, swatchConflict?} paste centred on `center` (the app passes the view centre), else offset by dx/dy (default: the Paste Offset preference). Pasting brings the image blobs, symbols, patterns, global and spot swatches (with the tint swatches of the tints used), gradient swatches, graphic styles, character and paragraph styles and brushes the objects use; one of the same name that differs comes in renamed. swatchConflict, for a swatch whose name the document gives another colour (clipboard.conflicts): \"merge\" (default: the objects take the document's swatch) | \"add\" (the pasted swatch comes in renamed) | {name: \"merge\"|\"add\"}. With Paste Remembers Layers on (layer.pasteRemembersLayers), objects go back into the layers they came from (by name; made when missing). An artboard copied with artboard.copy comes with its art, right of the last artboard (the other paste commands but Paste on All Artboards: where it was), its art back in the layers it came from → {ids, artboard: the new artboard's index or null, added: resources added, merged: conflicts merged, renamed: [{kind, from, to}]}",
             has_clipboard,
             |s, p| paste(s, p, PasteMode::Offset)
         ),
@@ -85,7 +86,15 @@ pub fn specs() -> Vec<CommandSpec> {
             has_clipboard,
             |s, p| paste(s, p, PasteMode::AllArtboards)
         ),
-        cmd!("edit.clear", "Clear", ["Edit"], Some("Delete"), "{ids?}", has_selection, clear),
+        cmd!(
+            "edit.clear",
+            "Clear",
+            ["Edit"],
+            Some("Delete"),
+            "{ids?} delete the objects `ids`, else the selection (direct-selected anchors, else objects, else ruler guides)",
+            has_selection_or_guides,
+            clear
+        ),
         cmd!("edit.duplicate", "Duplicate", [], None, "{dx?, dy?} duplicate the selection in place (offset optional)", has_selection, duplicate),
     ]
 }
@@ -105,8 +114,45 @@ fn doc_activate(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn doc_node(s: &mut Session, p: &Value) -> Result<Value> {
     let id = id_param(p, "id").ok_or_else(|| bad("document.node", "missing id"))?;
+    let opts = slice_opts(p, "document.node")?;
+    let summary = bool_or(p, "summary", false);
+    if !summary && (opts.depth.is_some() || opts.child_limit.is_some()) {
+        // The full object JSON is never truncated: a slice without `summary` would
+        // otherwise silently return the whole subtree.
+        return Err(bad("document.node", "`depth` and `childLimit` slice the summary: pass `summary: true`"));
+    }
     let n = s.doc()?.doc.node(id).ok_or(EngineError::NoNode(id))?;
-    if bool_or(p, "summary", false) { Ok(inspect::node_summary(n)) } else { Ok(serde_json::to_value(n).unwrap_or(Value::Null)) }
+    if summary { Ok(inspect::node_summary_opts(n, opts)) } else { Ok(serde_json::to_value(n).unwrap_or(Value::Null)) }
+}
+
+/// `depth` / `childLimit` for a summary read: absent (or null) means no limit.
+fn slice_opts(p: &Value, cmd: &str) -> Result<inspect::SummaryOpts> {
+    Ok(inspect::SummaryOpts { depth: opt_u64(p, cmd, "depth")?, child_limit: opt_u64(p, cmd, "childLimit")? })
+}
+
+/// An optional count: absent (or null) is `None`; a present value that is not a
+/// non-negative integer is rejected rather than silently reinterpreted.
+fn opt_u64(p: &Value, cmd: &str, key: &str) -> Result<Option<u64>> {
+    match p.get(key) {
+        None | Some(Value::Null) => Ok(None),
+        Some(v) => v.as_u64().map(Some).ok_or_else(|| bad(cmd, format!("`{key}` must be a non-negative integer"))),
+    }
+}
+
+fn doc_find(s: &mut Session, p: &Value) -> Result<Value> {
+    // A filter of the wrong type is an error, not dropped: dropping it would widen the search.
+    let needle = |key: &str| match p.get(key) {
+        None | Some(Value::Null) => Ok(None),
+        Some(Value::String(v)) => Ok(Some(v.to_lowercase()).filter(|v| !v.is_empty())),
+        Some(_) => Err(bad("document.find", format!("`{key}` must be a string"))),
+    };
+    let filter = inspect::FindFilter { name: needle("name")?, kind: needle("kind")?, text: needle("text")? };
+    if filter.is_empty() {
+        return Err(bad("document.find", "give at least one of `name`, `kind`, `text`"));
+    }
+    let limit = opt_u64(p, "document.find", "limit")?.unwrap_or(100);
+    let (matches, total) = inspect::find_nodes(&s.doc()?.doc, &filter, limit);
+    Ok(json!({"matches": matches, "total": total}))
 }
 
 /// Document Setup's units (also `document.setup {units}`).
@@ -117,7 +163,7 @@ fn set_units(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 /// A typing session in progress (the Type tool previews the whole session as one interaction).
-fn typing_in_progress(s: &Session) -> bool {
+pub(crate) fn typing_in_progress(s: &Session) -> bool {
     s.active().and_then(|d| d.interaction.as_ref()).is_some_and(|it| it.label == "Typing" && it.preview.is_some())
 }
 
@@ -191,12 +237,19 @@ pub(crate) fn roots_of(doc: &Document, ids: Vec<NodeId>) -> Vec<NodeId> {
 }
 
 fn copy(s: &mut Session, _: &Value) -> Result<Value> {
+    // The Artboard tool copies its artboard (and the art on it).
+    if s.tool_id() == "artboard" {
+        return super::panelcmds::artboard_copy(s, &json!({}), false);
+    }
     let roots = selected_roots(s)?;
     s.clipboard = Clipboard::copy(s.doc()?, &roots);
     Ok(json!({ "copied": s.clipboard.nodes.len() }))
 }
 
 fn cut(s: &mut Session, p: &Value) -> Result<Value> {
+    if s.tool_id() == "artboard" {
+        return super::panelcmds::artboard_copy(s, &json!({}), true);
+    }
     copy(s, p)?;
     clear(s, &json!({}))
 }
@@ -206,6 +259,10 @@ fn clear(s: &mut Session, p: &Value) -> Result<Value> {
     if ids_param(p, "ids").is_none() && !s.doc()?.selection.anchors.is_empty() {
         return super::path::delete_anchors(s, p);
     }
+    // Selected ruler guides (selected on their own).
+    if ids_param(p, "ids").is_none() && s.doc()?.selection.is_empty() {
+        return super::docmenu::guide_remove(s, &json!({}));
+    }
     let ids = match ids_param(p, "ids") {
         Some(v) => v,
         None => selected_roots(s)?,
@@ -258,8 +315,16 @@ fn paste_clip(s: &mut Session, p: &Value, mode: PasteMode, clip: &Clipboard, cho
     let st = s.doc()?;
     let same_doc = clip.source_doc == Some(st.uid);
     let parent = st.insertion_parent();
-    // Paste Remembers Layers (not while isolating a group: pastes stay in it).
-    let remember = st.doc.paste_remembers_layers && parent.is_some_and(|p| st.doc.node(p).is_some_and(Node::is_layer));
+    // A copied artboard comes back with its art: right of the last artboard, or where it was
+    // (Paste in Place, in Front, in Back). Paste on All Artboards pastes only the art.
+    let board = clip
+        .artboard
+        .as_ref()
+        .filter(|_| mode != PasteMode::AllArtboards)
+        .map(|a| (a, if mode == PasteMode::Offset { super::panelcmds::beside_artboards(&st.doc, a.rect) } else { Vec2::ZERO }));
+    // Paste Remembers Layers (not while isolating a group: pastes stay in it); an artboard's art
+    // always goes back into its layers.
+    let remember = (st.doc.paste_remembers_layers || board.is_some()) && parent.is_some_and(|p| st.doc.node(p).is_some_and(Node::is_layer));
     // Front/back: relative to the selection (top-most / bottom-most selected object); with
     // nothing selected, the top / bottom of the current layer.
     let anchor = match mode {
@@ -270,19 +335,21 @@ fn paste_clip(s: &mut Session, p: &Value, mode: PasteMode, clip: &Clipboard, cho
         }
         _ => None,
     };
-    let placements: Vec<Affine> = match mode {
-        PasteMode::Offset => vec![match point_param(p, "center") {
+    let placements: Vec<Affine> = match (mode, board) {
+        (_, Some((_, dv))) => vec![Affine::translate(dv)],
+        (PasteMode::Offset, None) => vec![match point_param(p, "center") {
             Some(c) => clip.bounds().map_or(Affine::IDENTITY, |b| Affine::translate(c - b.center())),
             None => Affine::translate((f64_or(p, "dx", off), f64_or(p, "dy", off))),
         }],
-        PasteMode::AllArtboards => {
+        (PasteMode::AllArtboards, None) => {
             let src = clip.source_artboard.or_else(|| st.doc.artboards.first().map(|a| a.rect)).map(|r| r.origin()).unwrap_or_default();
             st.doc.artboards.iter().map(|a| Affine::translate(a.rect.origin() - src)).collect()
         }
         _ => vec![Affine::IDENTITY],
     };
-    let (ids, imported) = s.edit(mode.label(), |d, sel| {
+    let (ids, imported, artboard) = s.edit(mode.label(), |d, sel| {
         let imported = clip.import_into(d, choices, same_doc);
+        let artboard = board.map(|(a, dv)| super::panelcmds::push_artboard_copy(d, a, a.rect + dv));
         let mut layers: BTreeMap<&str, NodeId> = BTreeMap::new();
         // Objects pasted into each parent so far (keeps their order in front and back pastes).
         let mut placed: BTreeMap<Option<NodeId>, usize> = BTreeMap::new();
@@ -314,10 +381,15 @@ fn paste_clip(s: &mut Session, p: &Value, mode: PasteMode, clip: &Clipboard, cho
             }
         }
         sel.set(new_ids.iter().copied());
-        Ok((new_ids, imported))
+        Ok((new_ids, imported, artboard))
     })?;
+    // The Artboard tool takes the pasted artboard.
+    if let Some(i) = artboard.filter(|_| s.tool_id() == "artboard") {
+        s.set_tool_option("active", &json!(i));
+    }
     Ok(json!({
         "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>(),
+        "artboard": artboard,
         "added": imported.added,
         "merged": imported.merged,
         "renamed": imported.renamed,

crates/engine/src/cmd/fileio/load.rs

@@ -178,7 +178,7 @@ pub fn load_with(name: &str, bytes: &[u8], opts: &LoadOptions) -> Result<Loaded>
         _ => return Err(err(format!("{} files can't be opened yet", format.label))),
     };
     if let Some(mode) = opts.color_mode.filter(|m| *m != doc.color_mode) {
-        super::super::colormgmt::set_color_mode(&mut doc, mode, true, None);
+        super::super::colormgmt::set_color_mode(&mut doc, mode, true, None, opts.grays);
     }
     // Imports are named after the file; a native document keeps its own title (the tab shows the
     // file name once it has a path).

crates/engine/src/cmd/fileio/mod.rs

@@ -78,7 +78,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Open Document",
             [],
             None,
-            "{path} or {name, dataBase64}, PDF/.ai: pages?: \"2-3, 5\" (1-based, default all; one artboard each) | page?: n, cropTo?: bounding|art|crop (default)|trim|bleed|media (the box each artboard gets; bounding: the art's bounds), password? (encrypted PDFs; see document.pdfInfo), textAs?: text (default: point type per line, in the file's fonts by name; missing ones are listed in warnings) | outlines (glyph paths), layers?: true (default: optional content groups become layers with their visibility, print state and lock — art that is off comes in as a hidden layer; other art goes to a layer per page) | false (one layer per page, without the art that is off; Save then asks for a name), colorMode?: rgb|cmyk (the mode the document opens in, its colours converted as file.documentColorMode does; default: the file's — a PDF keeps CMYK, Gray and spot inks (spot swatches at a tint) and opens in CMYK when painted mostly in CMYK), DXF: dxf?: {layout?: \"Model\" (default) | a paper layout's name (document.dxfInfo lists them), unit?, scale? (the ratio: 1 unit of the art = scale drawing units; default: the drawing at 1:1 in its own unit), fit?: false (scale to fit an artboard of fitTo?: [612, 792], turned to the art's orientation), scaleLineweights?: false (lineweights scale with the art), center?: true (false: the drawing's origin on the artboard's bottom-left corner; fitted art's bottom-left corner), mergeLayers?: false (all art on one layer)} → {index, title, format, warnings, restored, missingLinks, modifiedLinks, updatedLinks: [{name, path, ids}]}; any readable format (see document.formats): .vectorcraft/.drawcraft, .svg/.svgz, .pdf/.ai, .ait, ASCII .dxf (each DXF layer with art a layer; blocks symbols; what can't come in is listed in warnings), PNG/JPEG/GIF/WebP/TIFF/BMP (an image opens as a document of its pixel size), .emf/.wmf (one artboard, the picture's frame; records VectorCraft doesn't read are skipped with one warning), .eps and PostScript .ai (one artboard, the bounding box: an EPS file VectorCraft wrote restores the document it carries, restored: true; other files are read by a PostScript interpreter — paths, colours and spot inks, clips, gradients, images, type in the fonts named — and come in as their TIFF preview, with a warning, when their PostScript can't be read). A PDF/.ai/.ait or SVG saved with Preserve Editing restores the native document it carries (restored: true; a PDF only when no pages are picked), unless the file was changed elsewhere since or the data can't be read: then its artwork is imported and the first warning says why. Templates (native templates, .ait) open as a new untitled document; a restored .ai keeps its path (Save writes .ai again). Linked images are read from their files (looked for at their path, then relative to the document): missing ones show their saved preview (links.relink), modified ones are read again only with Preferences › Update Links: Automatically (else links.update). An SVG's <image> files (relative links from the SVG's folder) stay linked, SVG files become art, missing ones a placeholder in their box (a warning and missingLinks)",
+            "{path} or {name, dataBase64}, PDF/.ai: pages?: \"2-3, 5\" (1-based, default all; one artboard each) | page?: n, cropTo?: bounding|art|crop (default)|trim|bleed|media (the box each artboard gets; bounding: the art's bounds), password? (encrypted PDFs; see document.pdfInfo), textAs?: text (default: point type per line, in the file's fonts by name; missing ones are listed in warnings) | outlines (glyph paths), layers?: true (default: optional content groups become layers with their visibility, print state and lock — art that is off comes in as a hidden layer; other art goes to a layer per page) | false (one layer per page, without the art that is off; Save then asks for a name), colorMode?: rgb|cmyk (the mode the document opens in, its colours converted as file.documentColorMode does, grays? as there; default: the file's — a PDF keeps CMYK, Gray and spot inks (spot swatches at a tint) and opens in CMYK when painted mostly in CMYK), DXF: dxf?: {layout?: \"Model\" (default) | a paper layout's name (document.dxfInfo lists them), unit?, scale? (the ratio: 1 unit of the art = scale drawing units; default: the drawing at 1:1 in its own unit), fit?: false (scale to fit an artboard of fitTo?: [612, 792], turned to the art's orientation), scaleLineweights?: false (lineweights scale with the art), center?: true (false: the drawing's origin on the artboard's bottom-left corner; fitted art's bottom-left corner), mergeLayers?: false (all art on one layer)} → {index, title, format, warnings, restored, missingLinks, modifiedLinks, updatedLinks: [{name, path, ids}]}; any readable format (see document.formats): .vectorcraft/.drawcraft, .svg/.svgz, .pdf/.ai, .ait, ASCII .dxf (each DXF layer with art a layer; blocks symbols; what can't come in is listed in warnings), PNG/JPEG/GIF/WebP/TIFF/BMP (an image opens as a document of its pixel size), .emf/.wmf (one artboard, the picture's frame; records VectorCraft doesn't read are skipped with one warning), .eps and PostScript .ai (one artboard, the bounding box: an EPS file VectorCraft wrote restores the document it carries, restored: true; other files are read by a PostScript interpreter — paths, colours and spot inks, clips, gradients, images, type in the fonts named — and come in as their TIFF preview, with a warning, when their PostScript can't be read). A PDF/.ai/.ait or SVG saved with Preserve Editing restores the native document it carries (restored: true; a PDF only when no pages are picked), unless the file was changed elsewhere since or the data can't be read: then its artwork is imported and the first warning says why. Templates (native templates, .ait) open as a new untitled document; a restored .ai keeps its path (Save writes .ai again). Linked images are read from their files (looked for at their path, then relative to the document): missing ones show their saved preview (links.relink), modified ones are read again only with Preferences › Update Links: Automatically (else links.update). An SVG's <image> files (relative links from the SVG's folder) stay linked, SVG files become art, missing ones a placeholder in their box (a warning and missingLinks)",
             always,
             load::open
         ),

crates/engine/src/cmd/fileio/pdfimport.rs

@@ -6,6 +6,7 @@ use serde_json::{Value, json};
 use vectorcraft_doc::{ColorMode, Document};
 use vectorcraft_pdf::{Choice, CropTo, ImportOptions, PdfError, TextAs};
 
+use super::super::colormgmt::Grays;
 use super::super::*;
 use super::{err, source};
 
@@ -22,6 +23,8 @@ pub struct LoadOptions {
     /// The colour mode the document opens in, its colours converted as Document Color Mode does
     /// (default: the file's; a PDF painted mostly in CMYK opens in CMYK).
     pub color_mode: Option<ColorMode>,
+    /// How that conversion separates RGB greys (`grays`).
+    pub grays: Grays,
     /// What a PDF's text becomes.
     pub text_as: TextAs,
     /// A PDF's optional content groups become layers (else one layer per page, without the art
@@ -38,6 +41,7 @@ impl Default for LoadOptions {
             crop: CropTo::default(),
             password: None,
             color_mode: None,
+            grays: Grays::default(),
             text_as: TextAs::default(),
             layers: true,
             dxf: Default::default(),
@@ -47,7 +51,7 @@ impl Default for LoadOptions {
 
 impl LoadOptions {
     /// From command params: `pages` (`"2-3, 5"`, a page number or `"all"`), `page` (one page, when
-    /// `pages` isn't given), `cropTo` (or `crop`), `password`, `colorMode` (`rgb` | `cmyk`),
+    /// `pages` isn't given), `cropTo` (or `crop`), `password`, `colorMode` (`rgb` | `cmyk`) with `grays`,
     /// `textAs` (`text` | `outlines`), `layers` (true | false) and `dxf` (the DXF import options).
     pub fn from_params(cmd: &str, p: &Value) -> Result<Self> {
         let pages = match p.get("pages").filter(|v| !v.is_null()).or_else(|| p.get("page").filter(|v| !v.is_null())) {
@@ -65,13 +69,14 @@ impl LoadOptions {
             Some("cmyk") => Some(ColorMode::Cmyk),
             Some(m) => return Err(bad(cmd, format!("colorMode must be rgb or cmyk, not `{m}`"))),
         };
+        let grays = Grays::param(cmd, p)?;
         let text_as = choice(cmd, "textAs", str_param(p, "textAs"))?;
         let layers = match p.get("layers").filter(|v| !v.is_null()) {
             None => true,
             Some(v) => v.as_bool().ok_or_else(|| bad(cmd, "layers must be true or false"))?,
         };
         let dxf = super::dxfimport::options(cmd, p.get("dxf"))?;
-        Ok(Self { pages, crop, password, color_mode, text_as, layers, dxf })
+        Ok(Self { pages, crop, password, color_mode, grays, text_as, layers, dxf })
     }
 
     /// Does the document read only part of the file, or read it differently (a page range, another

crates/engine/src/cmd/fileio/tests_epsimport.rs

@@ -92,6 +92,22 @@ fn postscript_ai_files_and_garbage() {
     assert_eq!((&r["format"], &r["restored"]), (&json!("ai"), &json!(false)), "{r}");
     assert_eq!(s.doc().unwrap().path, None);
     assert_eq!(objects(&s), 1);
+    // Illustrator's groups come in as groups, nested as they were.
+    let ai = b"%!PS-Adobe-3.0
+%%Creator: Adobe Illustrator(R) 8.0
+%%BoundingBox: 0 0 100 100
+%%EndComments
+               /u {} def /U {} def /L {lineto} def /f {closepath fill} def
+               u 0 0 moveto 9 0 L 9 9 L f u 20 0 moveto 29 0 L 29 9 L f 40 0 moveto 49 0 L 49 9 L f U U
+showpage
+%%EOF
+";
+    open(&mut s, "groups.ai", ai).unwrap();
+    let d = s.doc().unwrap().doc.clone();
+    let outer = &d.layers[0].children().unwrap()[0];
+    let inner = outer.children().map(|c| (c.len(), c[1].children().map(Vec::len))).unwrap();
+    assert!(matches!(outer.kind, vectorcraft_doc::NodeKind::Group { clip: false, .. }), "{:?}", outer.kind);
+    assert_eq!(inner, (2, Some(2)));
     // A .ait one opens as a new untitled document.
     let r = open(&mut s, "legacy.ait", ps).unwrap();
     assert!(r["title"].as_str().unwrap().starts_with("Untitled"), "{r}");

crates/engine/src/cmd/layer.rs

@@ -735,14 +735,16 @@ fn artboard_new(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn artboard_delete(s: &mut Session, p: &Value) -> Result<Value> {
     let i = p.get("index").and_then(Value::as_u64).ok_or_else(|| bad("artboard.delete", "missing index"))? as usize;
-    s.edit("Delete Artboard", |d, _| {
+    s.edit("Delete Artboard", |d, sel| {
         if d.artboards.len() <= 1 {
             return Err(EngineError::Other("a document needs at least one artboard".into()));
         }
         if i >= d.artboards.len() {
             return Err(EngineError::Other("no such artboard".into()));
         }
-        d.artboards.remove(i);
+        // Its guides go with it.
+        let id = d.artboards.remove(i).id;
+        d.retain_guides(sel, |_, g| g.artboard != Some(id));
         Ok(())
     })?;
     ok()
@@ -752,10 +754,16 @@ fn artboard_set(s: &mut Session, p: &Value) -> Result<Value> {
     let i = p.get("index").and_then(Value::as_u64).unwrap_or(0) as usize;
     s.edit("Artboard Options", |d, _| {
         let a = d.artboards.get_mut(i).ok_or_else(|| EngineError::Other("no such artboard".into()))?;
+        let was = a.rect;
         a.rect = rect_from(p, a.rect);
         if let Some(n) = str_param(p, "name") {
             a.name = n.to_string();
         }
+        // Moved (not resized), it takes its guides along.
+        let (id, now) = (a.id, a.rect);
+        if (now.width() - was.width()).abs() <= 1e-6 && (now.height() - was.height()).abs() <= 1e-6 {
+            d.move_artboard_guides(id, now.origin() - was.origin());
+        }
         Ok(())
     })?;
     ok()

crates/engine/src/cmd/menucmds.rs

@@ -1,5 +1,5 @@
 //! Object menu long tail: Lock/Hide All Artwork Above & Other Layers, Transform Each, Reset
-//! Bounding Box, Rasterize, Crop Image, Create Trim Marks, Convert to Shape and
+//! Bounding Box, Rasterize, Crop Image, Mask (an image), Create Trim Marks, Convert to Shape and
 //! Artboards → Convert / Rearrange. (Live blends are in `live.rs`.)
 
 use std::sync::Arc;
@@ -75,7 +75,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Transform Each…",
             ["Object", "Transform"],
             Some("Cmd+Alt+Shift+D"),
-            "{scaleH?: % (100), scaleV?: % (100), moveH?: pt, moveV?: pt (down = +), rotate?: deg (counter-clockwise), reflectX?: bool (flip vertically), reflectY?: bool (flip horizontally), random?: bool, seed?: n, reference?: 0..8 (9-point grid, 4 = centre), copy?: bool, strokes?: bool (Scale Strokes & Effects), corners?: bool (Scale Corners; both default to the preferences)} transform every selected object about its own reference point → {ids}",
+            "{scaleH?: % (100), scaleV?: % (100), moveH?: pt, moveV?: pt (down = +), rotate?: deg (counter-clockwise), reflectX?: bool (flip vertically), reflectY?: bool (flip horizontally), random?: bool, seed?: n, reference?: 0..8 (9-point grid, 4 = centre), copy?: bool, strokes?: bool (Scale Strokes & Effects), corners?: bool (Scale Corners; both default to the preferences), patterns?: bool (Transform Patterns; default: prefs transformPatternTiles)} transform every selected object about its own reference point → {ids}",
             has_selection,
             transform_each
         ),
@@ -115,6 +115,15 @@ pub fn specs() -> Vec<CommandSpec> {
             has_image,
             crop_image
         ),
+        cmd!(
+            "object.maskImage",
+            "Mask",
+            [],
+            None,
+            "{} clip the selected image with a rectangle around it (its own outline, rotated with it) and select that clipping path, whose handles then crop it; one undo step → {id: the clip group, path: the clipping path}",
+            has_image,
+            mask_image
+        ),
         cmd!(
             "object.createTrimMarks",
             "Create Trim Marks",
@@ -147,7 +156,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Rearrange All Artboards…",
             ["Object", "Artboards"],
             None,
-            "{columns?: n (2), spacing?: pt (20), byColumn?: false, moveArtwork?: true} lay artboards out in a grid",
+            "{columns?: n (2), spacing?: pt (20), byColumn?: false, moveArtwork?: true (locked and hidden art only with prefs moveLockedWithArtboard)} lay artboards out in a grid",
             has_doc,
             rearrange_artboards
         ),
@@ -288,7 +297,8 @@ fn transform_each(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad("object.transformEach", "scale must be non-zero"));
     }
     let mut rng = Rng(p.get("seed").and_then(Value::as_u64).unwrap_or(0x9E37_79B9_7F4A_7C15).max(1));
-    let sc = if sh != 100.0 || sv != 100.0 { super::object::scaling(s, p) } else { Default::default() };
+    let mut sc = if sh != 100.0 || sv != 100.0 { super::object::scaling(s, p) } else { Default::default() };
+    sc.patterns = super::object::transform_patterns(s, p, &roots)?;
     let ids = s.edit("Transform Each", |d, sel| {
         let targets = if copy { duplicate_in(d, sel, &roots, Affine::IDENTITY)? } else { roots.clone() };
         for id in &targets {
@@ -584,6 +594,36 @@ fn crop_image(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({ "id": id.0, "width": w, "height": h }))
 }
 
+/// The Control bar's Mask for an image: a clip group of the image and a clipping path on its
+/// outline, with that path selected so dragging its handles crops the image.
+fn mask_image(s: &mut Session, _: &Value) -> Result<Value> {
+    let st = s.doc()?;
+    let (id, outline) = st
+        .selection
+        .objects
+        .iter()
+        .find_map(|id| match st.doc.node(*id).map(|n| &n.kind) {
+            Some(NodeKind::Image(im)) => {
+                Some((*id, vectorcraft_geom::shapes::rectangle(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)).transformed(im.xf)))
+            }
+            _ => None,
+        })
+        .ok_or_else(|| bad("object.maskImage", "select an image"))?;
+    let (gid, pid) = s.edit("Mask", |d, sel| {
+        let mut clip = super::pathops::shape_node(d, outline, None);
+        super::object::as_clipping_path(&mut clip)?;
+        let pid = clip.id;
+        let (par, idx, _) = d.position(id).ok_or(EngineError::NoNode(id))?;
+        let gid = d.alloc_id();
+        d.insert(par, idx + 1, Node::new(gid, NodeKind::Group { children: vec![], clip: true }))?;
+        d.insert(Some(gid), 0, clip)?;
+        d.move_node(id, Some(gid), usize::MAX)?;
+        sel.set([pid]);
+        Ok((gid, pid))
+    })?;
+    Ok(json!({ "id": gid.0, "path": pid.0 }))
+}
+
 // ---------- Trim marks ----------
 
 impl Session {
@@ -742,6 +782,7 @@ fn rearrange_artboards(s: &mut Session, p: &Value) -> Result<Value> {
     let spacing = f64_or(p, "spacing", 20.0).clamp(-1.0e5, 1.0e5);
     let by_col = bool_or(p, "byColumn", false);
     let move_art = bool_or(p, "moveArtwork", true);
+    let locked_and_hidden = s.prefs.move_locked_with_artboard;
     let scale_strokes = false;
     s.edit("Rearrange Artboards", |d, _| {
         let rects: Vec<Rect> = d.artboards.iter().map(|a| a.rect).collect();
@@ -753,7 +794,9 @@ fn rearrange_artboards(s: &mut Session, p: &Value) -> Result<Value> {
             let tops: Vec<(NodeId, Point)> = d
                 .layers
                 .iter()
+                .filter(|l| l.rides_with_artboard(locked_and_hidden))
                 .flat_map(|l| l.children().into_iter().flatten())
+                .filter(|n| n.rides_with_artboard(locked_and_hidden))
                 .filter_map(|n| Some((n.id, n.geometric_bounds()?.center())))
                 .collect();
             for (id, c) in tops {
@@ -765,8 +808,13 @@ fn rearrange_artboards(s: &mut Session, p: &Value) -> Result<Value> {
                 }
             }
         }
+        let mut moved = vec![];
         for (a, dl) in d.artboards.iter_mut().zip(&deltas) {
             a.rect = a.rect + *dl;
+            moved.push((a.id, *dl));
+        }
+        for (id, dl) in moved {
+            d.move_artboard_guides(id, dl);
         }
         Ok(())
     })?;

crates/engine/src/cmd/mod.rs

@@ -144,6 +144,15 @@ pub fn has_selection(s: &Session) -> std::result::Result<(), String> {
     let st = s.active().ok_or("no document open")?;
     if st.selection.is_empty() { Err("nothing selected".into()) } else { Ok(()) }
 }
+/// Objects are selected, or the Artboard tool is chosen (Copy and Cut take its artboard).
+pub fn has_selection_or_artboard_tool(s: &Session) -> std::result::Result<(), String> {
+    if s.tool_id() == "artboard" { has_doc(s) } else { has_selection(s) }
+}
+/// Objects or ruler guides are selected (what Delete and the arrow keys act on).
+pub fn has_selection_or_guides(s: &Session) -> std::result::Result<(), String> {
+    let st = s.active().ok_or("no document open")?;
+    if st.selection.has_objects_or_guides() { Ok(()) } else { Err("nothing selected".into()) }
+}
 pub fn has_anchors(s: &Session) -> std::result::Result<(), String> {
     let st = s.active().ok_or("no document open")?;
     if st.selection.anchors.values().all(|a| a.is_empty()) { Err("no anchor points selected".into()) } else { Ok(()) }

crates/engine/src/cmd/object.rs

@@ -21,17 +21,25 @@ pub fn specs() -> Vec<CommandSpec> {
             "Transform",
             [],
             None,
-            "{matrix: [a,b,c,d,e,f], copy?: bool, ids?, strokes?: bool, corners?: bool, typeAreas?: bool} apply an affine to the selection (or ids); strokes/corners: Scale Strokes & Effects / Scale Corners (default: the preferences); typeAreas: area type among them (not type inside a group) reshapes its frame by the matrix and its text reflows at its size, as a bounding-box handle drag does (default: the type transforms too)",
+            "{matrix: [a,b,c,d,e,f], copy?: bool, ids?, strokes?: bool, corners?: bool, typeAreas?: bool, patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} apply an affine to the selection (or ids); strokes/corners: Scale Strokes & Effects / Scale Corners (default: the preferences); typeAreas: area type among them (not type inside a group) reshapes its frame by the matrix and its text reflows at its size, as a bounding-box handle drag does (default: the type transforms too)",
             has_doc,
             transform
         ),
-        cmd!("object.move", "Move…", ["Object", "Transform"], Some("Cmd+Shift+M"), "{dx, dy, copy?}", has_selection, move_cmd),
+        cmd!(
+            "object.move",
+            "Move…",
+            ["Object", "Transform"],
+            Some("Cmd+Shift+M"),
+            "{dx, dy, copy?, patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)}",
+            has_selection,
+            move_cmd
+        ),
         cmd!(
             "object.rotate",
             "Rotate…",
             ["Object", "Transform"],
             None,
-            "{angle: deg (counter-clockwise), absolute?: bool (angle is the bounding box's new angle, not an amount), origin?: [x,y] (default: the bounding box centre), copy?} → {ids}",
+            "{angle: deg (counter-clockwise), absolute?: bool (angle is the bounding box's new angle, not an amount), origin?: [x,y] (default: the bounding box centre), copy?, patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} → {ids}",
             has_selection,
             rotate
         ),
@@ -40,7 +48,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Scale…",
             ["Object", "Transform"],
             None,
-            "{sx: %, sy?: %, origin?: [x,y], copy?, strokes?: bool (Scale Strokes & Effects: stroke weights, dashes and effect distances scale; off keeps them, type strokes included), corners?: bool (Scale Corners: live corner radii scale)} (strokes/corners default to the preferences)",
+            "{sx: %, sy?: %, origin?: [x,y], copy?, strokes?: bool (Scale Strokes & Effects: stroke weights, dashes and effect distances scale; off keeps them, type strokes included), corners?: bool (Scale Corners: live corner radii scale), patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} (strokes/corners default to the preferences)",
             has_selection,
             scale
         ),
@@ -49,7 +57,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Reflect…",
             ["Object", "Transform"],
             None,
-            "{axis: \"vertical\"|\"horizontal\"|deg, origin?, copy?}",
+            "{axis: \"vertical\"|\"horizontal\"|deg, origin?, copy?, patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)}",
             has_selection,
             reflect
         ),
@@ -58,7 +66,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Shear…",
             ["Object", "Transform"],
             None,
-            "{angle: deg, axis?: \"horizontal\"|\"vertical\", origin?, copy?}",
+            "{angle: deg, axis?: \"horizontal\"|\"vertical\", origin?, copy?, patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)}",
             has_selection,
             shear
         ),
@@ -68,8 +76,8 @@ pub fn specs() -> Vec<CommandSpec> {
             "Nudge",
             [],
             None,
-            "{dx: -1|0|1, dy: -1|0|1, big?: bool (×10), copy?: bool} arrow-key nudge by the keyboard increment",
-            has_selection,
+            "{dx: -1|0|1, dy: -1|0|1, big?: bool (×10), copy?: bool} arrow-key nudge by the keyboard increment (the selected anchors, else objects, else ruler guides)",
+            has_selection_or_guides,
             nudge
         ),
         cmd!("object.arrange.bringToFront", "Bring to Front", ["Object", "Arrange"], Some("Cmd+Shift+]"), "{}", has_selection, |s, _| arrange(
@@ -208,15 +216,39 @@ pub(crate) fn scaling(s: &mut Session, p: &Value) -> Scaling {
     let corners = bool_or(p, "corners", s.prefs.scale_corners);
     s.note_journal("strokes", json!(strokes));
     s.note_journal("corners", json!(corners));
-    Scaling { strokes, effects: strokes.then_some(vectorcraft_render::effects::scale_effect), keep_type_strokes: !strokes, keep_corners: !corners }
+    Scaling {
+        strokes,
+        effects: strokes.then_some(vectorcraft_render::effects::scale_effect),
+        keep_type_strokes: !strokes,
+        keep_corners: !corners,
+        ..Scaling::default()
+    }
+}
+
+/// Transform Patterns: do the pattern fills and strokes of `ids` transform with them (`patterns`
+/// param, else General › Transform Pattern Tiles)? Noted in the journal when they use a pattern,
+/// so a replay moves their tiles alike whatever the preference is then.
+pub(crate) fn transform_patterns(s: &mut Session, p: &Value, ids: &[NodeId]) -> Result<bool> {
+    let on = bool_or(p, "patterns", s.prefs.transform_pattern_tiles);
+    let d = &s.doc()?.doc;
+    let mut uses = false;
+    for n in ids.iter().filter_map(|id| d.node(*id)) {
+        n.walk(&mut |c| uses |= vectorcraft_doc::pattern::uses_pattern(c, None));
+    }
+    if uses {
+        s.note_journal("patterns", json!(on));
+    }
+    Ok(on)
 }
 
 /// Apply `xf` to `ids` (`copy` param: duplicate first; `strokes`/`corners`: see [`scaling`];
-/// `typeAreas`: see [`resize_type_area`]). Records Transform Again.
+/// `patterns`: see [`transform_patterns`]; `typeAreas`: see [`resize_type_area`]). Records
+/// Transform Again.
 pub(crate) fn apply_transform(s: &mut Session, label: &str, ids: Vec<NodeId>, xf: Affine, p: &Value) -> Result<Value> {
     let copy = bool_or(p, "copy", false);
     let areas = bool_or(p, "typeAreas", false);
-    let sc = if Scaling::factor(xf).is_some() { scaling(s, p) } else { Scaling::default() };
+    let mut sc = if Scaling::factor(xf).is_some() { scaling(s, p) } else { Scaling::default() };
+    sc.patterns = transform_patterns(s, p, &ids)?;
     let ids = s.edit(label, |d, sel| {
         let targets = if copy { duplicate_in(d, sel, &ids, Affine::IDENTITY)? } else { ids.clone() };
         for id in &targets {
@@ -268,6 +300,9 @@ fn nudge(s: &mut Session, p: &Value) -> Result<Value> {
     if !s.doc()?.selection.anchors.is_empty() {
         return super::path::move_anchors(s, &json!({ "dx": dx, "dy": dy }));
     }
+    if s.doc()?.selection.is_empty() {
+        return super::docmenu::guide_move(s, &json!({ "dx": dx, "dy": dy, "copy": bool_or(p, "copy", false) }));
+    }
     let ids = selected_roots(s)?;
     apply_transform(s, "Move", ids, Affine::translate((dx, dy)), p)
 }
@@ -1003,6 +1038,9 @@ fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
     s.edit("Live Shape", |d, sel| {
         for id in &ids {
             let Some(NodeKind::Path { path, live: Some(live), .. }) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
+            // Radii are document lengths and corners circular, also on a rectangle from a file
+            // that kept an uneven scale in its transform (#442).
+            live.fold_scale();
             let partial = sel.anchors.get_mut(id);
             let picked = corners.unwrap_or_else(|| live.picked_corners(partial.as_deref()));
             let (layout, selected) = (live.anchor_corners(), partial.as_deref().map(|a| live.corners_of(a)));

crates/engine/src/cmd/panelcmds.rs

@@ -1,11 +1,12 @@
-//! Commands the panels need beyond the core set: artboard reorder/duplicate and the advanced
+//! Commands the panels need beyond the core set: artboard reorder, duplicate, copy and cut, and the advanced
 //! Character/Paragraph attributes.
 
 use serde_json::{Value, json};
 use vectorcraft_doc::NodeKind;
+use vectorcraft_geom::{Rect, Vec2};
 
 use super::*;
-use crate::EngineError;
+use crate::{Clipboard, EngineError};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
@@ -15,16 +16,34 @@ pub fn specs() -> Vec<CommandSpec> {
             "Duplicate Artboard",
             ["Window", "Artboards"],
             None,
-            "{index} copy placed right of the last artboard",
+            "{index?: n (default: the Artboard tool's artboard), art?: bool (default: the Artboard tool's moveArt option)} copy placed right of the last artboard, with copies of the art fully inside it when `art` (locked and hidden art only with prefs moveLockedWithArtboard) → {index, ids: the art's copies}",
             has_doc,
             artboard_duplicate
         ),
+        cmd!(
+            "artboard.copy",
+            "Copy Artboard",
+            [],
+            None,
+            "{index?, art?} (defaults as artboard.duplicate) put the artboard, and the art fully inside it when `art`, on the clipboard: edit.paste adds a copy right of the last artboard, edit.pasteInPlace/InFront/InBack where it was, in this or another document (one undo step; edit.pasteOnAllArtboards pastes only the art); edit.copy runs this while the Artboard tool is chosen → {copied: objects}",
+            has_doc,
+            |s, p| artboard_copy(s, p, false)
+        ),
+        cmd!(
+            "artboard.cut",
+            "Cut Artboard",
+            [],
+            None,
+            "{index?, art?} artboard.copy, then delete the artboard and that art in one undo step (not the only artboard); edit.cut runs this while the Artboard tool is chosen → {copied: objects}",
+            has_doc,
+            |s, p| artboard_copy(s, p, true)
+        ),
         cmd!(
             "text.setFormat",
             "Character / Paragraph",
             [],
             None,
-            "{ids?|id?, kerning?: 1/1000 em|\"auto\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg, underline?, strikethrough?, allCaps?, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), leftIndent?, rightIndent?, firstLineIndent?, spaceBefore?, spaceAfter?: pt, hyphenate?: bool, mojikumi?: \"none\"|\"lineEndHalf\" (Japanese punctuation spacing), direction?: \"auto\"|\"leftToRight\"|\"rightToLeft\" (paragraph direction; auto: from each paragraph's first strong character), leadingModel?: \"romanBaseline\"|\"emBoxTop\" (leading measured baseline to baseline, or em box top to top)}",
+            "{ids?|id?, kerning?: 1/1000 em|\"auto\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg, underline?, strikethrough?, allCaps?, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), leftIndent?, rightIndent?, firstLineIndent?, spaceBefore?, spaceAfter?: pt, hyphenate?: bool, mojikumi?: \"none\"|\"lineEndHalf\" (Japanese punctuation spacing), direction?: \"auto\"|\"leftToRight\"|\"rightToLeft\" (paragraph direction; auto: from each paragraph's first strong character), leadingModel?: \"romanBaseline\"|\"emBoxTop\" (leading measured baseline to baseline, or em box top to top), charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\" (where characters smaller than the largest on their line line up with it), burasagari?: \"none\"|\"standard\"|\"forced\" (Paragraph panel menu › Burasagari None/Regular/Force: an East Asian comma or full stop ending an area type line hangs outside it: when it doesn't fit, or always; new type: \"standard\")}",
             has_doc,
             set_format
         ),
@@ -49,24 +68,108 @@ fn artboard_reorder(s: &mut Session, p: &Value) -> Result<Value> {
     ok()
 }
 
-fn artboard_duplicate(s: &mut Session, p: &Value) -> Result<Value> {
-    let i = p.get("index").and_then(Value::as_u64).unwrap_or(0) as usize;
-    let index = s.edit("Duplicate Artboard", |d, _| {
-        let src = d.artboards.get(i).cloned().ok_or_else(|| EngineError::Other("no such artboard".into()))?;
-        let right = d.artboards.iter().map(|a| a.rect.x1).fold(f64::MIN, f64::max);
-        let dx = right + 20.0 - src.rect.x0;
-        Ok(push_artboard_copy(d, &src, vectorcraft_geom::Rect::new(src.rect.x0 + dx, src.rect.y0, src.rect.x1 + dx, src.rect.y1)))
-    })?;
-    Ok(json!({"index": index}))
+/// The artboard (`index`) and whether its art comes along (`art`) for the artboard copy
+/// commands: by default the Artboard tool's artboard and its Move/Copy Artwork with Artboard option.
+fn board_and_art(s: &Session, p: &Value) -> (usize, bool) {
+    let t = s.tool_options_of("artboard");
+    let i = p.get("index").and_then(Value::as_u64).or_else(|| t["active"].as_u64()).unwrap_or(0) as usize;
+    (i, bool_or(p, "art", t["moveArt"].as_bool().unwrap_or(true)))
 }
 
-/// Add a copy of artboard `src` at `rect`, named `<name> copy` (`<name> copy 2`… when taken),
-/// with an id of its own → its index.
-pub(crate) fn push_artboard_copy(d: &mut vectorcraft_doc::Document, src: &vectorcraft_doc::Artboard, rect: vectorcraft_geom::Rect) -> usize {
+/// The art that goes with artboard `i` when `art`: the objects fully inside it (locked and hidden
+/// ones only with prefs moveLockedWithArtboard), in paint order.
+pub(crate) fn artboard_art(s: &Session, i: usize, art: bool) -> Result<Vec<NodeId>> {
+    let d = &s.doc()?.doc;
+    let rect = d.artboards.get(i).map(|a| a.rect).ok_or_else(|| EngineError::Other("no such artboard".into()))?;
+    Ok(if art { d.art_on_artboard(rect, s.prefs.move_locked_with_artboard) } else { vec![] })
+}
+
+/// How far a copy of `rect` moves to sit right of the last artboard (Duplicate Artboards, Paste).
+pub(crate) fn beside_artboards(d: &vectorcraft_doc::Document, rect: Rect) -> Vec2 {
+    let right = d.artboards.iter().map(|a| a.rect.x1).fold(f64::MIN, f64::max);
+    Vec2::new(right + 20.0 - rect.x0, 0.0)
+}
+
+fn artboard_duplicate(s: &mut Session, p: &Value) -> Result<Value> {
+    let (i, art) = board_and_art(s, p);
+    let art = artboard_art(s, i, art)?;
+    let scale_strokes = s.prefs.scale_strokes;
+    let (index, ids) = s.edit("Duplicate Artboard", |d, _| {
+        let dv = d.artboards.get(i).map(|a| beside_artboards(d, a.rect)).unwrap_or_default();
+        copy_artboard(d, i, dv, &art, scale_strokes)
+    })?;
+    Ok(json!({"index": index, "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()}))
+}
+
+/// Artboard Copy / Cut: the artboard and its art onto the clipboard (pasting brings both); a cut
+/// then deletes them.
+pub(crate) fn artboard_copy(s: &mut Session, p: &Value, cut: bool) -> Result<Value> {
+    let (i, art) = board_and_art(s, p);
+    let art = artboard_art(s, i, art)?;
+    let st = s.doc()?;
+    if cut && st.doc.artboards.len() <= 1 {
+        return Err(EngineError::Other("a document needs at least one artboard".into()));
+    }
+    let board = st.doc.artboards.get(i).cloned().ok_or_else(|| EngineError::Other("no such artboard".into()))?;
+    let clip = Clipboard { source_artboard: Some(board.rect), artboard: Some(board), ..Clipboard::copy(st, &art) };
+    let copied = clip.nodes.len();
+    if cut {
+        s.edit("Cut Artboard", |d, sel| {
+            if i >= d.artboards.len() {
+                return Err(EngineError::Other("no such artboard".into()));
+            }
+            // Its guides go with it.
+            let gone = d.artboards.remove(i).id;
+            d.retain_guides(sel, |_, g| g.artboard != Some(gone));
+            for id in &art {
+                // Always there: none of the art is inside another of it.
+                let _ = d.remove(*id);
+            }
+            sel.prune(d);
+            Ok(())
+        })?;
+        if s.tool_id() == "artboard" {
+            s.set_tool_option("active", &json!(i.saturating_sub(1)));
+        }
+    }
+    s.clipboard = clip;
+    Ok(json!({"copied": copied}))
+}
+
+/// Add a copy of artboard `i` moved by `dv`, with copies of its guides and of its `art` (each just
+/// above its original) moved along → (the copy's index, the art's copies). Duplicate Artboards and
+/// Alt-drag.
+pub(crate) fn copy_artboard(
+    d: &mut vectorcraft_doc::Document,
+    i: usize,
+    dv: Vec2,
+    art: &[NodeId],
+    scale_strokes: bool,
+) -> Result<(usize, Vec<NodeId>)> {
+    let src = d.artboards.get(i).cloned().ok_or_else(|| EngineError::Other("no such artboard".into()))?;
+    let index = push_artboard_copy(d, &src, src.rect + dv);
+    // Its guides come along.
+    if let Some(id) = d.artboards.get(index).map(|a| a.id) {
+        d.copy_artboard_guides(src.id, id, dv);
+    }
+    let mut copies = Vec::with_capacity(art.len());
+    for id in art {
+        let (Some((parent, at, _)), Some(n)) = (d.position(*id), d.node(*id).cloned()) else { continue };
+        let mut c = d.reid(&n);
+        c.transform(Affine::translate(dv), scale_strokes);
+        copies.push(d.insert(parent, at + 1, c)?);
+    }
+    Ok((index, copies))
+}
+
+/// Add a copy of artboard `src` at `rect`, with an id of its own and its name, or `<name> copy`
+/// (`<name> copy 2`…) when that is taken → its index.
+pub(crate) fn push_artboard_copy(d: &mut vectorcraft_doc::Document, src: &vectorcraft_doc::Artboard, rect: Rect) -> usize {
     let mut a = src.clone();
     a.id = d.artboards.iter().map(|a| a.id).max().unwrap_or(0).saturating_add(1);
     let taken = |name: &str| d.artboards.iter().any(|a| a.name == name);
-    a.name = std::iter::once(format!("{} copy", src.name))
+    a.name = [src.name.clone(), format!("{} copy", src.name)]
+        .into_iter()
         .chain((2u64..).map(|i| format!("{} copy {i}", src.name)))
         .find(|name| !taken(name))
         .unwrap_or_default();
@@ -114,11 +217,14 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
         "mojikumi",
         "direction",
         "leadingModel",
+        "charAlign",
+        "burasagari",
     ];
     if !keys.iter().any(|k| p.get(*k).is_some()) {
         return Err(bad(C, "nothing to change"));
     }
     let (position, small_caps) = super::docsetup::script_params(p, &s.doc()?.doc.setup, C)?;
+    let char_align = super::textedit::char_align_param(p, C)?;
     let mojikumi = match p.get("mojikumi") {
         None => None,
         Some(v) => Some(match v.as_str() {
@@ -144,6 +250,15 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
             _ => return Err(bad(C, "`leadingModel` must be \"romanBaseline\" or \"emBoxTop\"")),
         }),
     };
+    let burasagari = match p.get("burasagari") {
+        None => None,
+        Some(v) => Some(match v.as_str() {
+            Some("none") => vectorcraft_doc::Burasagari::None,
+            Some("standard") => vectorcraft_doc::Burasagari::Standard,
+            Some("forced") => vectorcraft_doc::Burasagari::Forced,
+            _ => return Err(bad(C, "`burasagari` must be \"none\", \"standard\" or \"forced\"")),
+        }),
+    };
     s.edit("Character", |d, _| {
         for id in &ids {
             let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
@@ -179,6 +294,9 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
                 if let Some(v) = small_caps {
                     st.small_caps = v;
                 }
+                if let Some(v) = char_align {
+                    st.char_align = v;
+                }
             }
             let para = &mut t.para;
             if let Some(v) = num("leftIndent") {
@@ -208,6 +326,9 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
             if let Some(v) = leading_model {
                 para.leading_model = v;
             }
+            if let Some(v) = burasagari {
+                para.burasagari = v;
+            }
             super::typecmd::refresh_bounds(t);
         }
         Ok(())

crates/engine/src/cmd/path.rs

@@ -4,7 +4,7 @@ use std::collections::BTreeSet;
 
 use serde_json::{Value, json};
 use vectorcraft_doc::{NodeId, NodeKind};
-use vectorcraft_geom::{Anchor, AnchorKind, PathData, Point, SubPath, Vec2};
+use vectorcraft_geom::{AnchorKind, PathData, Point, SubPath, Vec2};
 
 use super::create::anchor_from_json;
 use super::*;
@@ -81,7 +81,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Convert Anchor Points",
             [],
             None,
-            "{to: \"corner\"|\"smooth\"} (Control bar convert buttons)",
+            "{to: \"corner\"|\"smooth\"} convert the direct-selected anchors (all anchors of fully selected paths) as one undo step: corner retracts both handles, smooth pulls handles in line with the neighbours (smooth anchors keep theirs)",
             has_selection,
             convert_anchors
         ),
@@ -104,7 +104,15 @@ pub fn specs() -> Vec<CommandSpec> {
             reshape
         ),
         cmd!("path.insertAnchor", "Add Anchor Point", [], None, "{id, subpath, segment, t: 0..1}", has_doc, insert_anchor),
-        cmd!("path.cutAtAnchors", "Cut Path at Selected Anchor Points", [], None, "{}", has_selection, cut_at_anchors),
+        cmd!(
+            "path.cutAtAnchors",
+            "Cut Path at Selected Anchor Points",
+            [],
+            None,
+            "{} cut the paths at their direct-selected anchors (one undo step): a closed path opens there, an open one becomes one path per piece; one of each cut's two coincident anchors stays selected → {ids}",
+            has_anchors,
+            cut_at_anchors
+        ),
     ]
 }
 
@@ -386,41 +394,24 @@ fn average(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn convert_anchors(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "path.convertAnchors";
+    let smooth = match str_param(p, "to") {
+        Some("smooth") => true,
+        Some("corner") => false,
+        _ => return Err(bad(C, "`to` must be \"corner\" or \"smooth\"")),
+    };
     let t = anchor_targets(s)?;
-    let smooth = str_param(p, "to") == Some("smooth");
+    if t.is_empty() {
+        return Err(bad(C, "select paths or anchor points"));
+    }
     s.edit("Convert Anchor Points", |d, _| {
         for (id, v) in &t {
             let path = path_mut(d, *id)?;
             for &(si, ai) in v {
-                let sp = &path.subpaths[si];
-                let n = sp.anchors.len();
-                let prev = if ai > 0 {
-                    Some(sp.anchors[ai - 1].p)
-                } else if sp.closed {
-                    Some(sp.anchors[n - 1].p)
-                } else {
-                    None
-                };
-                let next = if ai + 1 < n {
-                    Some(sp.anchors[ai + 1].p)
-                } else if sp.closed {
-                    Some(sp.anchors[0].p)
-                } else {
-                    None
-                };
-                let a: &mut Anchor = &mut path.subpaths[si].anchors[ai];
+                let Some(sp) = path.subpaths.get_mut(si) else { continue };
                 if smooth {
-                    // Handles parallel to prev→next, a third of the neighbour distances.
-                    let (pp, nn) = (prev.unwrap_or(a.p), next.unwrap_or(a.p));
-                    let dir = nn - pp;
-                    let l = dir.hypot();
-                    if l > 1e-9 {
-                        let u = dir / l;
-                        a.h_in = a.p - u * (a.p.distance(pp) / 3.0);
-                        a.h_out = a.p + u * (a.p.distance(nn) / 3.0);
-                        a.kind = AnchorKind::Smooth;
-                    }
-                } else {
+                    sp.smooth_anchor(ai);
+                } else if let Some(a) = sp.anchors.get_mut(ai) {
                     a.retract();
                 }
             }
@@ -519,40 +510,50 @@ fn insert_anchor(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn cut_at_anchors(s: &mut Session, _: &Value) -> Result<Value> {
-    let sel = s.doc()?.selection.anchors.clone();
-    s.edit("Cut Path", |d, _| {
-        for (id, set) in &sel {
-            let path = path_mut(d, *id)?;
-            let mut out = vec![];
-            for (si, sp) in path.subpaths.iter().enumerate() {
-                let cuts: Vec<usize> = set.iter().filter(|(s, _)| *s == si).map(|(_, a)| *a).collect();
-                if cuts.is_empty() {
-                    out.push(sp.clone());
-                    continue;
-                }
-                let mut anchors = sp.anchors.clone();
-                if sp.closed {
-                    anchors.rotate_left(cuts[0]);
-                    anchors.push(anchors[0]);
-                }
-                let base = if sp.closed { cuts[0] } else { 0 };
-                let n = sp.anchors.len();
-                let rel: Vec<usize> = cuts.iter().map(|c| (c + n - base) % n).collect();
-                let mut cur = vec![];
-                for (i, a) in anchors.iter().enumerate() {
-                    cur.push(*a);
-                    if rel.contains(&(i % n)) && cur.len() > 1 {
-                        out.push(SubPath::new(std::mem::take(&mut cur), false));
-                        cur.push(*a);
-                    }
-                }
-                if cur.len() > 1 {
-                    out.push(SubPath::new(cur, false));
-                }
-            }
-            path.subpaths = out;
+    const C: &str = "path.cutAtAnchors";
+    let st = s.doc()?;
+    // Each selected path's subpaths cut at its selected anchors, those that cut anything.
+    let mut cuts: Vec<(NodeId, Vec<SubPath>, Vec<bool>)> = vec![];
+    for (id, set) in &st.selection.anchors {
+        let Some(pd) = st.doc.node(*id).and_then(|n| n.path_data()) else { continue };
+        let (mut subs, mut starts) = (vec![], vec![]);
+        for (si, sp) in pd.subpaths.iter().enumerate() {
+            let at: BTreeSet<usize> = set.iter().filter(|(s, _)| *s == si).map(|(_, a)| *a).collect();
+            let pieces = sp.cut_at(&at);
+            // The pieces that start at a cut: every piece of an opened closed subpath, all but the
+            // first of an open one.
+            starts.extend(pieces.iter().enumerate().map(|(k, piece)| if sp.closed { !piece.closed } else { k > 0 }));
+            subs.extend(pieces);
         }
-        Ok(())
+        if starts.contains(&true) {
+            cuts.push((*id, subs, starts));
+        }
+    }
+    if cuts.is_empty() {
+        return Err(bad(C, "direct-select anchor points to cut at (not the end points of open paths)"));
+    }
+    let ids = s.edit("Cut Path", |d, sel| {
+        let (mut all, mut picked) = (vec![], vec![]);
+        for (id, subs, starts) in cuts {
+            // A path of one subpath becomes one path per piece (the first keeps the id); the
+            // pieces of a compound shape stay subpaths of it.
+            if d.node(id).and_then(|n| n.path_data()).is_some_and(|pd| pd.subpaths.len() == 1) {
+                let ids = super::draw2::replace_with_pieces(d, id, subs.into_iter().map(PathData::single).collect())?;
+                picked.extend(ids.iter().zip(&starts).filter(|(_, s)| **s).map(|(id, _)| (*id, (0, 0))));
+                all.extend(ids);
+            } else {
+                path_mut(d, id)?.subpaths = subs;
+                picked.extend(starts.iter().enumerate().filter(|(_, s)| **s).map(|(si, _)| (id, (si, 0))));
+                all.push(id);
+            }
+        }
+        // Each cut leaves one of its two coincident anchors selected, so a drag pulls the ends apart.
+        sel.clear();
+        for (id, a) in picked {
+            sel.add(id);
+            sel.anchors.entry(id).or_default().insert(a);
+        }
+        Ok(all)
     })?;
-    ok()
+    Ok(super::draw2::ids_json(&ids))
 }

crates/engine/src/cmd/prefscmds.rs

@@ -130,6 +130,7 @@ pub const PREF_SPECS: &[PrefSpec] = &[
     p!("scaleCorners", "General", "Options", "Scale Corners", bool),
     p!("scaleStrokes", "General", "Options", "Scale Strokes & Effects", bool),
     p!("zoomWithMouseWheel", "General", "Options", "Zoom with Mouse Wheel", bool),
+    p!("scrubNumericFields", "General", "Options", "Scrub Numeric Fields by Dragging", bool),
     // Selection & Anchor Display
     p!("selectionTolerance", "Selection & Anchor Display", "Selection", "Tolerance", num(1.0, 8.0, "px")),
     p!("objectSelectionByPathOnly", "Selection & Anchor Display", "Selection", "Object Selection by Path Only", bool),

crates/engine/src/cmd/select.rs

@@ -3,13 +3,22 @@
 use std::collections::BTreeSet;
 
 use serde_json::{Value, json};
+use vectorcraft_color::Paint;
 use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
 
 use super::*;
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
-        cmd!("select.all", "All", ["Select"], Some("Cmd+A"), "{}", has_doc, all),
+        cmd!(
+            "select.all",
+            "All",
+            ["Select"],
+            Some("Cmd+A"),
+            "{} → {count}; while the Type tool edits text, all of that text instead → {editing, start, end} (byte offsets)",
+            has_doc,
+            all
+        ),
         cmd!("select.allOnArtboard", "All on Active Artboard", ["Select"], Some("Cmd+Alt+A"), "{artboard?: index}", has_doc, all_on_artboard),
         cmd!("select.none", "Deselect", ["Select"], Some("Cmd+Shift+A"), "{}", has_doc, none),
         cmd!("select.reselect", "Reselect", ["Select"], Some("Cmd+6"), "{}", has_doc, reselect),
@@ -22,26 +31,50 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("select.key", "Set Key Object", [], None, "{id?} (none clears)", has_doc, key),
         cmd!("select.anchors", "Select Anchors", [], None, "{id, anchors: [[subpath, anchor]…], mode: \"set\"|\"add\"|\"toggle\"}", has_doc, anchors),
         cmd!("select.anchorsMany", "Select Anchors", [], None, "{items: [{id, anchors}], add?: bool}", has_doc, anchors_many),
-        cmd!("select.same.fillColor", "Fill Color", ["Select", "Same"], None, "{}", has_selection, |s, _| same(
-            s,
+        cmd!(
             "select.same.fillColor",
-            |a, b| a.appearance.fill_paint() == b.appearance.fill_paint()
-        )),
-        cmd!("select.same.strokeColor", "Stroke Color", ["Select", "Same"], None, "{}", has_selection, |s, _| same(
-            s,
+            "Fill Color",
+            ["Select", "Same"],
+            None,
+            "{} the objects filled with the first selected object's fill colour (any tint of its global or spot swatch, the same tint with prefs selectSameTintPercent)",
+            has_selection,
+            |s, _| {
+                let tint = s.prefs.select_same_tint_percent;
+                same(s, "select.same.fillColor", |a, b| same_paint(&a.appearance.fill_paint(), &b.appearance.fill_paint(), tint))
+            }
+        ),
+        cmd!(
             "select.same.strokeColor",
-            |a, b| a.appearance.stroke_paint() == b.appearance.stroke_paint()
-        )),
+            "Stroke Color",
+            ["Select", "Same"],
+            None,
+            "{} the objects stroked with the first selected object's stroke colour (tints as select.same.fillColor)",
+            has_selection,
+            |s, _| {
+                let tint = s.prefs.select_same_tint_percent;
+                same(s, "select.same.strokeColor", |a, b| same_paint(&a.appearance.stroke_paint(), &b.appearance.stroke_paint(), tint))
+            }
+        ),
         cmd!("select.same.strokeWeight", "Stroke Weight", ["Select", "Same"], None, "{}", has_selection, |s, _| same(
             s,
             "select.same.strokeWeight",
             |a, b| (a.appearance.stroke_width() - b.appearance.stroke_width()).abs() < 1e-9
         )),
-        cmd!("select.same.fillAndStroke", "Fill & Stroke", ["Select", "Same"], None, "{}", has_selection, |s, _| same(
-            s,
+        cmd!(
             "select.same.fillAndStroke",
-            |a, b| a.appearance.fill_paint() == b.appearance.fill_paint() && a.appearance.stroke_paint() == b.appearance.stroke_paint()
-        )),
+            "Fill & Stroke",
+            ["Select", "Same"],
+            None,
+            "{} the objects with the first selected object's fill and stroke colours (tints as select.same.fillColor)",
+            has_selection,
+            |s, _| {
+                let tint = s.prefs.select_same_tint_percent;
+                same(s, "select.same.fillAndStroke", |a, b| {
+                    let (x, y) = (&a.appearance, &b.appearance);
+                    same_paint(&x.fill_paint(), &y.fill_paint(), tint) && same_paint(&x.stroke_paint(), &y.stroke_paint(), tint)
+                })
+            }
+        ),
         cmd!("select.same.opacity", "Opacity", ["Select", "Same"], None, "{}", has_selection, |s, _| same(s, "select.same.opacity", |a, b| (a
             .opacity
             - b.opacity)
@@ -107,6 +140,18 @@ fn selectable(d: &Document, iso: Option<NodeId>) -> Vec<NodeId> {
 }
 
 fn all(s: &mut Session, _: &Value) -> Result<Value> {
+    // While the Type tool edits text, Select All takes all of that text and leaves the art
+    // selection as it is (Illustrator: text cursor in a text object).
+    if s.tool_wants_text() {
+        s.set_tool_option("selectAll", &json!(true));
+        let editing = s.tool_options()["editing"].clone();
+        let id = editing.as_u64().map(NodeId);
+        let end = id.and_then(|id| match &s.doc().ok()?.doc.node(id)?.kind {
+            NodeKind::Text(t) => Some(t.plain_text().len()),
+            _ => None,
+        });
+        return Ok(json!({ "editing": editing, "start": 0, "end": end.unwrap_or(0) }));
+    }
     let st = s.doc()?;
     let ids = selectable(&st.doc, st.isolation);
     s.select(|_, sel| sel.set(ids.iter().copied()))?;
@@ -235,7 +280,16 @@ fn anchors_many(s: &mut Session, p: &Value) -> Result<Value> {
     ok()
 }
 
-fn same(s: &mut Session, cmd: &str, eq: fn(&Node, &Node) -> bool) -> Result<Value> {
+/// Select › Same › Fill/Stroke Color: is `a` the same colour as `b`? Tints of one global or spot
+/// swatch are, unless `tint` (General › Select Same Tint %) asks for the same tint too.
+fn same_paint(a: &Paint, b: &Paint, tint: bool) -> bool {
+    match (a, b) {
+        (Paint::Solid { swatch: Some(x), tint: ta, .. }, Paint::Solid { swatch: Some(y), tint: tb, .. }) if x == y => !tint || (ta - tb).abs() < 1e-4,
+        _ => a == b,
+    }
+}
+
+fn same(s: &mut Session, cmd: &str, eq: impl Fn(&Node, &Node) -> bool) -> Result<Value> {
     let st = s.doc()?;
     let refn = st.selection.objects.first().and_then(|id| st.doc.node(*id)).cloned().ok_or_else(|| bad(cmd, "nothing selected"))?;
     select_where(s, cmd, &json!({}), |_, n| !n.is_container() && eq(n, &refn))

crates/engine/src/cmd/textedit.rs

@@ -27,7 +27,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Character",
             [],
             None,
-            "{id, start?: byte, end?: byte (default: all text), font?, style?, size?: pt, leading?: pt|\"auto\", tracking?, kerning?: 1/1000 em|\"auto\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg, fill?: colour|\"none\", stroke?: colour|\"none\", strokeWidth?: pt, strokeOptions?: {weight?, cap?, join?, miterLimit?, dash?, dashOffset?, alignDashes?} (as stroke.set: the character stroke), underline?, strikethrough?, allCaps?: bool, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), features?: [\"dlig\", \"-liga\", …]} style a character range (runs are split at the range ends) → {id, runs}",
+            "{id, start?: byte, end?: byte (default: all text), font?, style?, size?: pt, leading?: pt|\"auto\", tracking?, kerning?: 1/1000 em|\"auto\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg, fill?: colour|\"none\", stroke?: colour|\"none\", strokeWidth?: pt, strokeOptions?: {weight?, cap?, join?, miterLimit?, dash?, dashOffset?, alignDashes?} (as stroke.set: the character stroke), underline?, strikethrough?, allCaps?: bool, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), features?: [\"dlig\", \"-liga\", …], charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\"} style a character range (runs are split at the range ends) → {id, runs}",
             has_doc,
             set_range_style
         ),
@@ -45,7 +45,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Area / Path Type",
             [],
             None,
-            "{path: id, mode: \"area\"|\"onPath\", text?: \"\", vertical?: bool = false, at?: [x, y] (on-path start: nearest point), size?, font?} turn a path into an area-type frame or a type-on-a-path baseline (the path's paint is dropped) → {id}",
+            "{path: id, mode: \"area\"|\"onPath\", text?: \"\", vertical?: bool = false, at?: [x, y] (on-path start: nearest point), size?, font?, placeholder?: bool (placeholder text instead, as text.create)} turn a path into an area-type frame or a type-on-a-path baseline (the path's paint is dropped) → {id}",
             has_doc,
             create_in_path
         ),
@@ -58,6 +58,33 @@ pub fn specs() -> Vec<CommandSpec> {
             has_selection,
             fit_headline
         ),
+        cmd!(
+            "type.step",
+            "Step Type",
+            [],
+            None,
+            "{attribute: \"size\"|\"leading\"|\"tracking\"|\"kerning\"|\"baselineShift\", by?: steps (1; negative steps down), id?, start?: byte, end?: byte} step type by the Preferences › Type increments (size and leading: typeSizeIncrement, pt; tracking and kerning: trackingIncrement, 1/1000 em; baseline shift: baselineShiftIncrement, pt), what the Type tool's Alt+arrows do (Cmd/Ctrl too: five steps; ←/→ kerning at the caret or tracking of the selection, ↑/↓ leading, Shift+↑/↓ baseline shift). The range of `id`, else the text the Type tool has selected (at a caret: kerning steps the character before it, leading its paragraph), else every selected type object → {ids}",
+            has_doc,
+            type_step
+        ),
+        cmd!(
+            "type.size.increase",
+            "Increase Font Size",
+            [],
+            Some("Cmd+Shift+."),
+            "{by?: steps (1)} type.step {attribute: size}",
+            has_selection,
+            |s, p| type_step(s, &json!({"attribute": "size", "by": f64_or(p, "by", 1.0)}))
+        ),
+        cmd!(
+            "type.size.decrease",
+            "Decrease Font Size",
+            [],
+            Some("Cmd+Shift+,"),
+            "{by?: steps (1)} type.step {attribute: size, by: -by}",
+            has_selection,
+            |s, p| type_step(s, &json!({"attribute": "size", "by": -f64_or(p, "by", 1.0)}))
+        ),
         cmd!(
             "text.discardEmpty",
             "Discard Empty Type",
@@ -151,6 +178,7 @@ pub(crate) struct CharChange {
     features: Option<Vec<String>>,
     position: Option<vectorcraft_doc::CharPosition>,
     small_caps: Option<Option<f64>>,
+    char_align: Option<vectorcraft_doc::CharAlign>,
 }
 
 /// `features: ["dlig", "-liga", …]` → the canonical tag list (differences from the defaults).
@@ -163,6 +191,19 @@ pub(crate) fn features_param(p: &Value, cmd: &str) -> Result<Option<Vec<String>>
     Ok(Some(vectorcraft_text::OtFeatures::default().with_tags(tags).to_tags()))
 }
 
+/// `charAlign: "romanBaseline"|"emBoxTop"|"emBoxCenter"|"emBoxBottom"` (Character Alignment).
+pub(crate) fn char_align_param(p: &Value, cmd: &str) -> Result<Option<vectorcraft_doc::CharAlign>> {
+    use vectorcraft_doc::CharAlign;
+    let Some(v) = p.get("charAlign").filter(|v| !v.is_null()) else { return Ok(None) };
+    Ok(Some(match v.as_str() {
+        Some("romanBaseline") => CharAlign::RomanBaseline,
+        Some("emBoxTop") => CharAlign::EmBoxTop,
+        Some("emBoxCenter") => CharAlign::EmBoxCenter,
+        Some("emBoxBottom") => CharAlign::EmBoxBottom,
+        _ => return Err(bad(cmd, "`charAlign` must be \"romanBaseline\", \"emBoxTop\", \"emBoxCenter\" or \"emBoxBottom\"")),
+    }))
+}
+
 fn paint_param(p: &Value, k: &str, cmd: &str) -> Result<Option<Paint>> {
     match p.get(k) {
         None | Some(Value::Null) => Ok(None),
@@ -213,6 +254,7 @@ impl CharChange {
             features: features_param(p, cmd)?,
             position,
             small_caps,
+            char_align: char_align_param(p, cmd)?,
         };
         if c.size.is_some_and(|v| v <= 0.0) {
             return Err(bad(cmd, "size must be positive"));
@@ -240,6 +282,7 @@ impl CharChange {
             && self.features.is_none()
             && self.position.is_none()
             && self.small_caps.is_none()
+            && self.char_align.is_none()
     }
 
     pub(crate) fn apply(&self, st: &mut CharStyle) {
@@ -310,6 +353,48 @@ impl CharChange {
         if let Some(v) = self.small_caps {
             st.small_caps = v;
         }
+        if let Some(v) = self.char_align {
+            st.char_align = v;
+        }
+    }
+}
+
+/// Type › Enable Missing Glyph Protection: after a font change, the characters of `runs` their new
+/// font has no glyph for, but their font `before` the change had, keep that font.
+pub(crate) fn protect_missing_glyphs(before: &[TextRun], runs: &mut Vec<TextRun>) {
+    fn chars(runs: &[TextRun]) -> impl Iterator<Item = (usize, char, &CharStyle)> {
+        runs.iter()
+            .scan(0, |at, r| {
+                let start = *at;
+                *at += r.text.len();
+                Some(r.text.char_indices().map(move |(i, c)| (start + i, c, &r.style)))
+            })
+            .flatten()
+    }
+    let db = vectorcraft_text::FontDb::global();
+    let mut faces = std::collections::HashMap::new();
+    let mut covers = |st: &CharStyle, c: char| {
+        let face = faces.entry((st.font_family.clone(), st.font_style.clone())).or_insert_with(|| db.face(&st.font_family, &st.font_style));
+        face.as_ref().map(|f| f.covers(c))
+    };
+    // Byte ranges that keep a font (family, style).
+    let mut keep: Vec<(usize, usize, &CharStyle)> = vec![];
+    for ((at, c, old), (_, _, new)) in chars(before).zip(chars(runs)) {
+        let changed = (&old.font_family, &old.font_style) != (&new.font_family, &new.font_style);
+        if !changed || c.is_whitespace() || c.is_control() || covers(new, c) != Some(false) || covers(old, c) != Some(true) {
+            continue;
+        }
+        let end = at + c.len_utf8();
+        match keep.last_mut() {
+            Some((_, e, st)) if *e == at && (&st.font_family, &st.font_style) == (&old.font_family, &old.font_style) => *e = end,
+            _ => keep.push((at, end, old)),
+        }
+    }
+    for (a, b, old) in keep {
+        edit::style_range(runs, a, b, |st| {
+            st.font_family.clone_from(&old.font_family);
+            st.font_style.clone_from(&old.font_style);
+        });
     }
 }
 
@@ -320,6 +405,7 @@ fn set_range_style(s: &mut Session, p: &Value) -> Result<Value> {
     if change.is_empty() {
         return Err(bad(C, "nothing to change"));
     }
+    let protect = s.prefs.missing_glyph_protection && (change.font.is_some() || change.style.is_some());
     let t = text_ref(s, id)?;
     let (a, b) = range_of(p, edit::runs_len(&t.runs));
     let n = s.edit("Character", |d, _| {
@@ -328,7 +414,11 @@ fn set_range_style(s: &mut Session, p: &Value) -> Result<Value> {
             // An empty range inside text styles nothing (Illustrator keeps it for the next typing).
             return Ok(t.runs.len());
         }
+        let before = protect.then(|| t.runs.clone());
         edit::style_range(&mut t.runs, a, b, |st| change.apply(st));
+        if let Some(before) = before {
+            protect_missing_glyphs(&before, &mut t.runs);
+        }
         refresh_bounds(t);
         Ok(t.runs.len())
     })?;
@@ -363,10 +453,10 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let text = str_param(p, "text").unwrap_or("").to_string();
     let start = match point_param(p, "at") {
-        Some(at) if on_path => vectorcraft_text::path_fraction_at(&path.to_bezpath(), at).0,
+        Some(at) if on_path => vectorcraft_geom::ArcPath::new(path).fraction_at(at).unwrap_or(0.0),
         _ => 0.0,
     };
-    let kind = if on_path { TextKind::OnPath { path: path.clone(), start } } else { TextKind::Area { frame: path.clone() } };
+    let kind = if on_path { TextKind::OnPath { path: path.clone(), start, end: None } } else { TextKind::Area { frame: path.clone() } };
     let mut t = TextObject {
         vertical: p.get("vertical").and_then(Value::as_bool).unwrap_or(false),
         kind,
@@ -375,10 +465,16 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
         para: super::create::new_type_para(),
         area: Default::default(),
         path_effect: Default::default(),
+        path_align: Default::default(),
+        path_spacing: 0.0,
         wrap: Vec::new(),
         cached_bounds: None,
     };
-    refresh_bounds(&mut t);
+    if bool_or(p, "placeholder", false) {
+        super::typemenu::fill_with_placeholder(&mut t);
+    } else {
+        refresh_bounds(&mut t);
+    }
     let id = s.edit(if on_path { "Type on a Path" } else { "Area Type" }, |d, sel| {
         let (par, idx, _) = d.position(pid).ok_or(EngineError::NoNode(pid))?;
         d.remove(pid)?;
@@ -394,6 +490,95 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({"id": id.0}))
 }
 
+/// What `type.step` changes.
+#[derive(Clone, Copy, PartialEq)]
+enum Step {
+    Size,
+    Leading,
+    Tracking,
+    Kerning,
+    BaselineShift,
+}
+
+/// The Type tool's selected text while it edits (its typing session ends first: one undo step).
+fn editing_range(s: &mut Session) -> Result<Option<(NodeId, usize, usize)>> {
+    let o = s.tool_options();
+    let Some(id) = o.get("editing").and_then(Value::as_u64).map(NodeId) else { return Ok(None) };
+    if super::edit::typing_in_progress(s) {
+        s.set_tool_option("commitTyping", &Value::Bool(true));
+        s.commit_interaction()?;
+    }
+    let at = |k: &str| byte_param(&o, k).unwrap_or(0);
+    Ok(Some((id, at("start"), at("end"))))
+}
+
+fn type_step(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "type.step";
+    let step = match str_param(p, "attribute") {
+        Some("size") => Step::Size,
+        Some("leading") => Step::Leading,
+        Some("tracking") => Step::Tracking,
+        Some("kerning") => Step::Kerning,
+        Some("baselineShift") => Step::BaselineShift,
+        _ => return Err(bad(C, "attribute must be size|leading|tracking|kerning|baselineShift")),
+    };
+    let by = f64_or(p, "by", 1.0);
+    if !by.is_finite() {
+        return Err(bad(C, "by must be a number"));
+    }
+    let prefs = &s.prefs;
+    let inc = by.clamp(-1000.0, 1000.0)
+        * match step {
+            Step::Size | Step::Leading => prefs.type_size_increment,
+            Step::Tracking | Step::Kerning => prefs.tracking_increment,
+            Step::BaselineShift => prefs.baseline_shift_increment,
+        };
+    // (text, its range; None: all of it).
+    let targets: Vec<(NodeId, Option<(usize, usize)>)> = match id_param(p, "id") {
+        Some(id) => vec![(id, Some(range_of(p, edit::runs_len(&text_ref(s, id)?.runs))))],
+        None => match editing_range(s)? {
+            Some((id, a, b)) => vec![(id, Some((a.min(b), a.max(b))))],
+            None => super::typecmd::text_targets(s, p, C)?.into_iter().map(|id| (id, None)).collect(),
+        },
+    };
+    // The ranges stepped. At a caret: kerning is the space after the character before it, leading
+    // the paragraph's; the rest wait for a selection.
+    let mut ranges = vec![];
+    for (id, range) in targets {
+        let text = text_ref(s, id)?.plain_text();
+        let (a, b) = range.map_or((0, text.len()), |(a, b)| (a.min(text.len()), b.min(text.len())));
+        let (a, b) = match step {
+            _ if a < b => (a, b),
+            Step::Kerning => (edit::prev_char(&text, a), a),
+            Step::Leading => {
+                let para = edit::paragraph_at(&text, a);
+                (para.start, para.end)
+            }
+            _ => continue,
+        };
+        if a < b {
+            ranges.push((id, a, b));
+        }
+    }
+    if !ranges.is_empty() {
+        s.edit("Character", |d, _| {
+            for &(id, a, b) in &ranges {
+                let t = text_mut(d, id).ok_or(EngineError::NoNode(id))?;
+                edit::style_range(&mut t.runs, a, b, |st| match step {
+                    Step::Size => st.size = (st.size + inc).clamp(0.1, 1296.0),
+                    Step::Leading => st.leading = Some((st.effective_leading() + inc).clamp(0.1, 5000.0)),
+                    Step::Tracking => st.tracking = (st.tracking + inc).clamp(-1000.0, 10000.0),
+                    Step::Kerning => st.kerning = Some((st.kerning.unwrap_or(0.0) + inc).clamp(-1000.0, 10000.0)),
+                    Step::BaselineShift => st.baseline_shift = (st.baseline_shift + inc).clamp(-1296.0, 1296.0),
+                });
+                refresh_bounds(t);
+            }
+            Ok(())
+        })?;
+    }
+    Ok(json!({ "ids": ranges.iter().map(|(id, ..)| id.0).collect::<Vec<_>>() }))
+}
+
 /// Tracking (1/1000 em) that makes the first paragraph of `t` exactly `target` wide, if it fits
 /// on one line at all.
 fn headline_tracking(t: &TextObject, target: f64) -> Option<f64> {
@@ -412,6 +597,8 @@ fn headline_tracking(t: &TextObject, target: f64) -> Option<f64> {
             para: Default::default(),
             area: Default::default(),
             path_effect: Default::default(),
+            path_align: Default::default(),
+            path_spacing: 0.0,
             wrap: Vec::new(),
             cached_bounds: None,
         };

crates/engine/src/cmd/typecmd.rs

@@ -238,9 +238,11 @@ fn set_style(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad(C, "nothing to change"));
     }
     let ids = text_targets(s, p, C)?;
+    let protect = s.prefs.missing_glyph_protection && (font.is_some() || style.is_some());
     s.edit("Character", |d, _| {
         for id in &ids {
             let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
+            let before = protect.then(|| t.runs.clone());
             for r in &mut t.runs {
                 let st = &mut r.style;
                 if let Some(f) = &font {
@@ -265,6 +267,9 @@ fn set_style(s: &mut Session, p: &Value) -> Result<Value> {
                     st.features = f.clone();
                 }
             }
+            if let Some(before) = before {
+                super::textedit::protect_missing_glyphs(&before, &mut t.runs);
+            }
             if let Some(j) = justify {
                 t.para.justify = j;
             }
@@ -408,6 +413,36 @@ fn reshape_area(s: &mut Session, p: &Value) -> Result<Value> {
 mod area_tests {
     use super::*;
 
+    #[test]
+    fn burasagari_is_set_per_paragraph_and_saved_only_when_on() {
+        use vectorcraft_doc::Burasagari;
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+        let id = s.execute("text.create", &json!({"x": 10, "y": 10, "text": "雅楽、笙。", "area": {"width": 200, "height": 100}})).unwrap()["id"]
+            .as_u64()
+            .unwrap();
+        let para = |s: &Session| match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
+            NodeKind::Text(t) => t.para.clone(),
+            _ => panic!("text"),
+        };
+        // New type: Standard, as in Illustrator.
+        assert_eq!(para(&s).burasagari, Burasagari::Standard);
+        s.execute("select.set", &json!({"ids": [id]})).unwrap();
+        assert!(s.execute("text.setFormat", &json!({"burasagari": "strong"})).is_err());
+        s.execute("text.setFormat", &json!({"burasagari": "forced"})).unwrap();
+        assert_eq!(para(&s).burasagari, Burasagari::Forced);
+        assert_eq!(serde_json::to_value(para(&s)).unwrap()["burasagari"], "forced");
+        s.execute("text.setFormat", &json!({"burasagari": "none"})).unwrap();
+        assert_eq!(para(&s).burasagari, Burasagari::None);
+        // Saved only when on; documents from before it read as None.
+        assert!(serde_json::to_value(para(&s)).unwrap().get("burasagari").is_none());
+        s.execute("edit.undo", &json!({})).unwrap();
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(para(&s).burasagari, Burasagari::Standard);
+        let old: vectorcraft_doc::ParaStyle = serde_json::from_value(json!({"justify": "Left"})).unwrap();
+        assert_eq!(old.burasagari, Burasagari::None);
+    }
+
     #[test]
     fn leading_model_is_set_per_paragraph_and_saved_only_when_top_to_top() {
         use vectorcraft_doc::LeadingModel;
@@ -433,6 +468,32 @@ mod area_tests {
         assert!(serde_json::to_value(&text(&s).para).unwrap().get("leading_model").is_none());
     }
 
+    #[test]
+    fn character_alignment_is_a_character_attribute_saved_only_when_set() {
+        use vectorcraft_doc::CharAlign;
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+        let id = s.execute("text.create", &json!({"x": 10, "y": 50, "text": "雅楽"})).unwrap()["id"].as_u64().unwrap();
+        let runs = |s: &Session| match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
+            NodeKind::Text(t) => t.runs.clone(),
+            _ => panic!("text"),
+        };
+        assert_eq!(runs(&s)[0].style.char_align, CharAlign::RomanBaseline);
+        assert!(serde_json::to_value(&runs(&s)[0].style).unwrap().get("charAlign").is_none());
+        s.execute("select.set", &json!({"ids": [id]})).unwrap();
+        assert!(s.execute("text.setFormat", &json!({"charAlign": "middle"})).is_err());
+        s.execute("text.setFormat", &json!({"charAlign": "emBoxCenter"})).unwrap();
+        assert!(runs(&s).iter().all(|r| r.style.char_align == CharAlign::EmBoxCenter));
+        assert_eq!(serde_json::to_value(&runs(&s)[0].style).unwrap()["charAlign"], "emBoxCenter");
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(runs(&s)[0].style.char_align, CharAlign::RomanBaseline);
+        // Characters selected with the Type tool: only the range takes it (雅 is 3 bytes).
+        assert!(s.execute("text.setRangeStyle", &json!({"id": id, "start": 3, "end": 6, "charAlign": "top"})).is_err());
+        s.execute("text.setRangeStyle", &json!({"id": id, "start": 3, "end": 6, "charAlign": "emBoxTop"})).unwrap();
+        let aligns: Vec<_> = runs(&s).iter().map(|r| (r.text.clone(), r.style.char_align)).collect();
+        assert_eq!(aligns, [("雅".to_string(), CharAlign::RomanBaseline), ("楽".to_string(), CharAlign::EmBoxTop)]);
+    }
+
     #[test]
     fn new_type_is_composed_with_line_end_half_width_punctuation() {
         use vectorcraft_doc::Mojikumi;

crates/engine/src/cmd/typemenu.rs

@@ -3,7 +3,7 @@
 //! commands of the Edit menu (Find and Replace, Find Next, Paste without Formatting).
 
 use serde_json::{Value, json};
-use vectorcraft_doc::{CharStyle, Document, Justify, NodeId, NodeKind, Quotes, TextKind, TextRun};
+use vectorcraft_doc::{CharStyle, Document, Justify, NodeId, NodeKind, Quotes, TextKind, TextObject, TextRun};
 use vectorcraft_geom::{Affine, Rect, shapes};
 
 use super::typecmd::refresh_bounds;
@@ -52,7 +52,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Type on a Path Options…",
             ["Type", "Type on a Path"],
             None,
-            "{start?: 0..1 (fraction of the path length), flip?: bool (reverse the path), effect?: rainbow|skew|3dRibbon|stairStep|gravity, ids?}",
+            "{ids?, start?: 0..1, end?: 0..1|null, flip?: bool, effect?: rainbow|skew|3dRibbon|stairStep|gravity, alignToPath?: ascender|descender|center|baseline, spacing?: pt} set the selected type on a path's options: start and end place its start and end brackets as fractions of the path's length (end null: the end of the path, or once round a closed path), and flip then turns the type to the other side of its path (the path runs the other way, the brackets swap ends); none given: query → the first object's {start, end, flip: false, effect, alignToPath, spacing}",
             has_selection,
             path_options
         ),
@@ -343,38 +343,95 @@ fn to_point(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(ids_json(&ids))
 }
 
+/// The options `type.pathOptions` sets; with none of them given it queries.
+const PATH_OPTIONS: [&str; 6] = ["start", "end", "flip", "effect", "alignToPath", "spacing"];
+
+/// Type on a path's text, if `n` is type on a path.
+fn path_text(n: Option<&vectorcraft_doc::Node>) -> Option<&TextObject> {
+    match n.map(|n| &n.kind) {
+        Some(NodeKind::Text(t)) if matches!(t.kind, TextKind::OnPath { .. }) => Some(t),
+        _ => None,
+    }
+}
+
+/// Type on a Path Options of `t`, as `type.pathOptions` takes them (`flip` is an action: false).
+fn path_options_of(t: &TextObject) -> Value {
+    let (start, end) = match &t.kind {
+        TextKind::OnPath { start, end, .. } => (*start, *end),
+        _ => (0.0, None),
+    };
+    json!({
+        "start": start,
+        "end": end,
+        "flip": false,
+        "effect": t.path_effect.id(),
+        "alignToPath": t.path_align.id(),
+        "spacing": t.path_spacing,
+    })
+}
+
 fn path_options(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "type.pathOptions";
-    let ids = texts(s, p, C)?;
-    let start = p.get("start").and_then(Value::as_f64);
+    let ids: Vec<NodeId> = {
+        let d = &s.doc()?.doc;
+        texts(s, p, C)?.into_iter().filter(|i| path_text(d.node(*i)).is_some()).collect()
+    };
+    let first = *ids.first().ok_or_else(|| bad(C, "select type on a path"))?;
+    let options = |s: &Session| -> Result<Value> {
+        let t = path_text(s.doc()?.doc.node(first)).ok_or_else(|| bad(C, "select type on a path"))?;
+        Ok(path_options_of(t))
+    };
+    if !PATH_OPTIONS.iter().any(|k| p.get(k).is_some()) {
+        return options(s);
+    }
+    // A bracket: a fraction of the path's length.
+    let fraction = |k: &str| -> Result<Option<f64>> {
+        match p.get(k) {
+            None | Some(Value::Null) => Ok(None),
+            Some(v) => v.as_f64().filter(|x| x.is_finite()).map(|x| Some(x.clamp(0.0, 1.0))).ok_or_else(|| bad(C, format!("`{k}` is a number 0..1"))),
+        }
+    };
+    let start = fraction("start")?;
+    // `end: null` puts the end bracket back at the end of the path.
+    let end = p.get("end").map(|_| fraction("end")).transpose()?;
     let flip = bool_or(p, "flip", false);
     let effect = match str_param(p, "effect") {
         Some(e) => Some(vectorcraft_doc::PathEffect::parse(e).ok_or_else(|| bad(C, format!("unknown effect `{e}`")))?),
         None => None,
     };
-    let n = s.edit("Type on a Path Options", |d, _| {
-        let mut n = 0;
+    let align = match str_param(p, "alignToPath") {
+        Some(a) => Some(vectorcraft_doc::PathAlign::parse(a).ok_or_else(|| bad(C, format!("unknown alignToPath `{a}`")))?),
+        None => None,
+    };
+    let spacing = p.get("spacing").and_then(Value::as_f64).filter(|x| x.is_finite()).map(|x| x.clamp(-1000.0, 1000.0));
+    s.edit("Type on a Path Options", |d, _| {
         for id in &ids {
             let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
-            let TextKind::OnPath { path, start: st } = &mut t.kind else { continue };
+            let TextKind::OnPath { start: st, end: en, .. } = &mut t.kind else { continue };
             if let Some(v) = start {
-                *st = v.clamp(0.0, 1.0);
+                *st = v;
             }
+            if let Some(v) = end {
+                *en = v;
+            }
+            // After the brackets: they are given on the path as it runs before the flip.
             if flip {
-                path.reverse();
+                t.flip_on_path();
             }
             if let Some(e) = effect {
                 t.path_effect = e;
             }
-            n += 1;
+            if let Some(a) = align {
+                t.path_align = a;
+            }
+            if let Some(v) = spacing {
+                t.path_spacing = v;
+            }
             refresh_bounds(t);
         }
-        if n == 0 {
-            return Err(bad(C, "select type on a path"));
-        }
-        Ok(n)
+        Ok(())
     })?;
-    Ok(json!({ "changed": n }))
+    options(s)
 }
 
 // ---------- placeholder / insert ----------
@@ -388,36 +445,44 @@ fn fill_placeholder(s: &mut Session, p: &Value) -> Result<Value> {
     let ids = texts(s, p, "type.fillPlaceholder")?;
     s.edit("Fill with Placeholder Text", |d, _| {
         for id in &ids {
-            let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
-            let style = t.first_style();
-            let text = match &t.kind {
-                TextKind::Area { frame } => {
-                    let b = frame.bounds().unwrap_or_default();
-                    let chars_per_line = (b.width() / (style.size * 0.5)).max(1.0);
-                    let lines = (b.height() / style.effective_leading()).max(1.0);
-                    let want = (chars_per_line * lines) as usize;
-                    let mut out = String::new();
-                    let words: Vec<&str> = PLACEHOLDER.split(' ').collect();
-                    let mut i = 0;
-                    while out.len() < want && i < 10_000 {
-                        if !out.is_empty() {
-                            out.push(' ');
-                        }
-                        out.push_str(words[i % words.len()]);
-                        i += 1;
-                    }
-                    out
-                }
-                _ => PLACEHOLDER.split(". ").next().unwrap_or(PLACEHOLDER).to_string() + ".",
-            };
-            t.runs = vec![TextRun { text, style }];
-            refresh_bounds(t);
+            if let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) {
+                fill_with_placeholder(t);
+            }
         }
         Ok(())
     })?;
     Ok(ids_json(&ids))
 }
 
+/// Replace `t`'s text with placeholder text in its first style: area type is filled to its frame,
+/// other type gets a sentence (Type › Fill with Placeholder Text, and new type with Preferences ›
+/// Type › Fill New Type Objects With Placeholder Text).
+pub(crate) fn fill_with_placeholder(t: &mut TextObject) {
+    let style = t.first_style();
+    let text = match &t.kind {
+        TextKind::Area { frame } => {
+            let b = frame.bounds().unwrap_or_default();
+            let chars_per_line = (b.width() / (style.size * 0.5)).max(1.0);
+            let lines = (b.height() / style.effective_leading()).max(1.0);
+            let want = (chars_per_line * lines) as usize;
+            let mut out = String::new();
+            for (i, w) in PLACEHOLDER.split(' ').cycle().enumerate() {
+                if out.len() >= want || i >= 10_000 {
+                    break;
+                }
+                if !out.is_empty() {
+                    out.push(' ');
+                }
+                out.push_str(w);
+            }
+            out
+        }
+        _ => PLACEHOLDER.split(". ").next().unwrap_or(PLACEHOLDER).to_string() + ".",
+    };
+    t.runs = vec![TextRun { text, style }];
+    refresh_bounds(t);
+}
+
 pub(crate) fn special_char(name: &str) -> Option<&'static str> {
     Some(match name {
         "bullet" => "•",

crates/engine/src/cmd/xform.rs

@@ -45,7 +45,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Move Artboard",
             [],
             None,
-            "{index, dx, dy, moveArt?: bool, copy?: bool} move an artboard (and the unlocked art fully inside it); `copy` (Alt-drag) leaves them and moves copies → {index, moved: the art moved or the copies}",
+            "{index, dx, dy, moveArt?: bool, copy?: bool} move an artboard (and the art fully inside it; locked and hidden art only with prefs moveLockedWithArtboard); `copy` (Alt-drag) leaves them and moves copies → {index, moved: the art moved or the copies}",
             has_doc,
             artboard_move
         ),
@@ -371,35 +371,24 @@ fn sample_color(s: &mut Session, p: &Value) -> Result<Value> {
 fn artboard_move(s: &mut Session, p: &Value) -> Result<Value> {
     let i = p.get("index").and_then(Value::as_u64).ok_or_else(|| bad("artboard.move", "missing index"))? as usize;
     let dv = Vec2::new(f64_or(p, "dx", 0.0), f64_or(p, "dy", 0.0));
-    let move_art = bool_or(p, "moveArt", false);
-    let st = s.doc()?;
-    let rect = st.doc.artboards.get(i).map(|a| a.rect).ok_or_else(|| EngineError::Other("no such artboard".into()))?;
-    let art = if move_art { st.doc.art_on_artboard(rect) } else { vec![] };
+    let art = super::panelcmds::artboard_art(s, i, bool_or(p, "moveArt", false))?;
     let scale_strokes = s.prefs.scale_strokes;
     let copy = bool_or(p, "copy", false);
     let (index, moved) = s.edit(if copy { "Duplicate Artboard" } else { "Move Artboard" }, |d, _| {
-        let src = d.artboards.get(i).cloned().ok_or_else(|| EngineError::Other("no such artboard".into()))?;
         // A copy keeps the artboard (and its art) where they are and moves duplicates instead.
-        if !copy {
-            if let Some(a) = d.artboards.get_mut(i) {
-                a.rect = src.rect + dv;
-            }
-            for id in &art {
-                if let Some(n) = d.node_mut(*id) {
-                    n.transform(Affine::translate(dv), scale_strokes);
-                }
-            }
-            return Ok((i, art.clone()));
+        if copy {
+            return super::panelcmds::copy_artboard(d, i, dv, &art, scale_strokes);
         }
-        let index = super::panelcmds::push_artboard_copy(d, &src, src.rect + dv);
-        let mut copies = Vec::with_capacity(art.len());
+        let a = d.artboards.get_mut(i).ok_or_else(|| EngineError::Other("no such artboard".into()))?;
+        a.rect = a.rect + dv;
+        let id = a.id;
+        d.move_artboard_guides(id, dv);
         for id in &art {
-            let (Some((parent, at, _)), Some(n)) = (d.position(*id), d.node(*id).cloned()) else { continue };
-            let mut c = d.reid(&n);
-            c.transform(Affine::translate(dv), scale_strokes);
-            copies.push(d.insert(parent, at + 1, c)?);
+            if let Some(n) = d.node_mut(*id) {
+                n.transform(Affine::translate(dv), scale_strokes);
+            }
         }
-        Ok((index, copies))
+        Ok((i, art.clone()))
     })?;
     Ok(json!({ "index": index, "moved": moved.iter().map(|i| i.0).collect::<Vec<_>>() }))
 }

crates/engine/src/inspect.rs

@@ -1,7 +1,7 @@
 //! Agent-friendly document summaries and view-models for panels.
 
 use serde_json::{Value, json};
-use vectorcraft_doc::{ArrowAlign, LineCap, LineJoin, Node, NodeKind, StrokeAlign, StrokeLayer, WidthProfile};
+use vectorcraft_doc::{ArrowAlign, Document, LineCap, LineJoin, Node, NodeKind, StrokeAlign, StrokeLayer, WidthProfile};
 
 use crate::Session;
 
@@ -12,8 +12,23 @@ fn rect_json(r: Option<vectorcraft_geom::Rect>) -> Value {
     }
 }
 
-/// Compact tree summary of a node (for `document.inspect`).
+/// How much of the subtree a node summary carries.
+#[derive(Clone, Copy, Default)]
+pub struct SummaryOpts {
+    /// Child levels to include (`None`: the whole subtree). `0` is the node alone.
+    pub depth: Option<u64>,
+    /// Children shown per node (`None`: all, top of the stack first). A level that shows
+    /// fewer children than it has reports `childCount`, so truncation is never silent.
+    pub child_limit: Option<u64>,
+}
+
+/// Compact tree summary of a node (for `document.inspect`): the whole subtree.
 pub fn node_summary(n: &Node) -> Value {
+    node_summary_opts(n, SummaryOpts::default())
+}
+
+/// The same summary with [`SummaryOpts`] applied.
+pub fn node_summary_opts(n: &Node, opts: SummaryOpts) -> Value {
     let mut v = json!({
         "id": n.id.0,
         "name": n.display_name(),
@@ -69,12 +84,26 @@ pub fn node_summary(n: &Node) -> Value {
         _ => {}
     }
     if let Some(ch) = n.children() {
-        v["children"] = Value::Array(ch.iter().rev().map(|c| node_summary(c)).collect());
+        let total = ch.len();
+        let take_n = opts.child_limit.map_or(total, |l| l.min(total as u64) as usize);
+        if opts.depth.is_none_or(|d| d > 0) {
+            let next = SummaryOpts { depth: opts.depth.map(|d| d.saturating_sub(1)), child_limit: opts.child_limit };
+            v["children"] = Value::Array(ch.iter().rev().take(take_n).map(|c| node_summary_opts(c, next)).collect());
+        }
+        if take_n < total || v.get("children").is_none() {
+            v["childCount"] = json!(total);
+        }
     }
     v
 }
 
 pub fn document(s: &Session) -> Value {
+    document_opts(s, SummaryOpts::default())
+}
+
+/// The same summary with [`SummaryOpts`] applied to the layer tree (artboards and
+/// the rest always come whole): `depth: 0` is the skeleton — top layers with counts.
+pub fn document_opts(s: &Session, opts: SummaryOpts) -> Value {
     let Some(st) = s.active() else { return Value::Null };
     let d = &st.doc;
     json!({
@@ -86,7 +115,7 @@ pub fn document(s: &Session) -> Value {
         "colorMode": format!("{:?}", d.color_mode),
         "artboards": d.artboards.iter().map(|a| json!({"name": a.name, "x": a.rect.x0, "y": a.rect.y0, "width": a.rect.width(), "height": a.rect.height()})).collect::<Vec<_>>(),
         // Top of the stack first, like the Layers panel.
-        "layers": d.layers.iter().rev().map(|l| node_summary(l)).collect::<Vec<_>>(),
+        "layers": d.layers.iter().rev().map(|l| node_summary_opts(l, opts)).collect::<Vec<_>>(),
         "currentLayer": st.active_layer.map(|l| l.0),
         // The rows highlighted in the Layers panel (`layer.setCurrent`, `layer.highlight`).
         "layerRows": st.highlighted_rows().iter().map(|i| i.0).collect::<Vec<_>>(),
@@ -106,6 +135,69 @@ pub fn document(s: &Session) -> Value {
     })
 }
 
+/// What `document.find` matches: every given filter must hit (AND). All matching is
+/// case-insensitive; `name` and `text` are substrings, `kind` is the exact panel label
+/// (`Layer`, `Group`, `Path`, `Type`, `Image`, ...).
+pub struct FindFilter {
+    pub name: Option<String>,
+    pub kind: Option<String>,
+    pub text: Option<String>,
+}
+
+impl FindFilter {
+    /// True when no effective filter was given (empty strings count as absent).
+    pub fn is_empty(&self) -> bool {
+        [self.name.as_ref(), self.kind.as_ref(), self.text.as_ref()].iter().all(|f| f.is_none())
+    }
+
+    fn hits(&self, n: &Node) -> bool {
+        if let Some(needle) = &self.name
+            && !n.display_name().to_lowercase().contains(needle)
+        {
+            return false;
+        }
+        if let Some(kind) = &self.kind
+            && !n.kind_label().eq_ignore_ascii_case(kind)
+        {
+            return false;
+        }
+        if let Some(needle) = &self.text {
+            let NodeKind::Text(t) = &n.kind else { return false };
+            if !t.plain_text().to_lowercase().contains(needle) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+/// Search the whole layer tree, top of the stack first like the Layers panel.
+/// Returns at most `limit` hits as `{id, name, kind, path}` (`path` is the ancestor
+/// chain, layer first) plus the total hit count, so a capped reply stays explicit.
+pub fn find_nodes(doc: &Document, filter: &FindFilter, limit: u64) -> (Vec<Value>, u64) {
+    use std::sync::Arc;
+    let mut out = Vec::new();
+    let mut total = 0u64;
+    let mut ancestors: Vec<u64> = Vec::new();
+    fn walk(nodes: &[Arc<Node>], ancestors: &mut Vec<u64>, filter: &FindFilter, limit: u64, out: &mut Vec<Value>, total: &mut u64) {
+        for n in nodes.iter().rev() {
+            if filter.hits(n) {
+                *total += 1;
+                if (out.len() as u64) < limit {
+                    out.push(json!({"id": n.id.0, "name": n.display_name(), "kind": n.kind_label(), "path": ancestors}));
+                }
+            }
+            if let Some(ch) = n.children() {
+                ancestors.push(n.id.0);
+                walk(ch, ancestors, filter, limit, out, total);
+                ancestors.pop();
+            }
+        }
+    }
+    walk(&doc.layers, &mut ancestors, filter, limit, &mut out, &mut total);
+    (out, total)
+}
+
 /// Cap names as `stroke.set` takes them.
 pub const CAPS: [(LineCap, &str); 3] = [(LineCap::Butt, "butt"), (LineCap::Round, "round"), (LineCap::Square, "square")];
 /// Join names as `stroke.set` takes them.

crates/engine/src/lib.rs

@@ -89,6 +89,15 @@ pub struct Interaction {
     pub perspective_again: Option<Value>,
 }
 
+/// An open undo group ([`Session::begin_undo_group`]): the edits made in it are one undo step.
+#[derive(Clone, Debug)]
+pub struct UndoGroup {
+    /// The document before the group's first edit, as the undo step that edit recorded keeps it.
+    first: Option<Arc<Document>>,
+    /// The journal's length when the group began: a cancelled group drops the entries after it.
+    journal: usize,
+}
+
 /// Per-document editing state.
 #[derive(Clone, Debug)]
 pub struct DocState {
@@ -112,6 +121,8 @@ pub struct DocState {
     /// Isolation mode container.
     pub isolation: Option<NodeId>,
     pub interaction: Option<Interaction>,
+    /// Edits made while this is open are one undo step (a scrubbed numeric field).
+    pub undo_group: Option<UndoGroup>,
     /// For Object → Transform → Transform Again (⌘D).
     pub last_transform: Option<(Affine, bool)>,
     /// Selection saved by Select → Reselect.
@@ -166,6 +177,7 @@ impl DocState {
             layer_rows: vec![],
             isolation: None,
             interaction: None,
+            undo_group: None,
             last_transform: None,
             last_selection_cmd: None,
             uid: NEXT_DOC_UID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
@@ -197,11 +209,26 @@ impl DocState {
     /// Keep what interaction `it` (taken from this document) changed, as one undo step.
     pub(crate) fn keep_interaction(&mut self, it: Interaction) {
         if !Arc::ptr_eq(&it.doc, &self.doc) {
-            self.history.undo.push(HistoryEntry { label: it.label, doc: it.doc, selection: it.selection });
-            self.history.redo.clear();
+            self.push_undo(HistoryEntry { label: it.label, doc: it.doc, selection: it.selection });
             self.revision += 1;
         }
     }
+    /// Record undo step `e` (the document before an edit). In an undo group only the group's first
+    /// edit records one: the edits after it extend that step.
+    fn push_undo(&mut self, e: HistoryEntry) {
+        if let Some(g) = &mut self.undo_group {
+            let recorded = |first: &Arc<Document>| self.history.undo.last().is_some_and(|l| Arc::ptr_eq(&l.doc, first));
+            if g.first.as_ref().is_some_and(recorded) {
+                return;
+            }
+            g.first = Some(e.doc.clone());
+        }
+        self.history.undo.push(e);
+        if self.history.undo.len() > self.history.limit {
+            self.history.undo.remove(0);
+        }
+        self.history.redo.clear();
+    }
     /// End the interaction in progress, undoing what it changed.
     pub(crate) fn undo_interaction(&mut self) {
         if let Some(it) = self.interaction.take() {
@@ -293,7 +320,9 @@ fn strip_replay_only(id: &str, p: &mut Value) {
 /// have finite, in-range geometry, so saved files always reload and renderers never see NaN/∞.
 fn doc_sane(d: &Document, sel: &Selection) -> bool {
     let ok = |r: vectorcraft_geom::Rect| [r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite() && v.abs() <= MAX_COORD);
-    d.artboards.iter().all(|a| ok(a.rect)) && sel.objects.iter().all(|id| d.node(*id).and_then(|n| n.geometric_bounds()).is_none_or(ok))
+    d.artboards.iter().all(|a| ok(a.rect))
+        && d.guides.iter().all(|g| g.pos.is_finite() && g.pos.abs() <= MAX_COORD)
+        && sel.objects.iter().all(|id| d.node(*id).and_then(|n| n.geometric_bounds()).is_none_or(ok))
 }
 
 /// Where new art goes (Illustrator's drawing modes, Shift+D cycles).
@@ -330,6 +359,8 @@ pub struct Prefs {
     /// Scale Strokes & Effects.
     pub scale_strokes: bool,
     pub zoom_with_mouse_wheel: bool,
+    /// A horizontal drag on a numeric field or its label steps its value (#400).
+    pub scrub_numeric_fields: bool,
     /// Offset for Paste / duplicate (Illustrator pastes to the view centre; we offset by this).
     pub paste_offset: f64,
     // Selection & Anchor Display
@@ -550,6 +581,7 @@ impl Default for Prefs {
             scale_corners: false,
             scale_strokes: false,
             zoom_with_mouse_wheel: false,
+            scrub_numeric_fields: true,
             paste_offset: 10.0,
             selection_tolerance: 3.0,
             object_selection_by_path_only: false,
@@ -592,7 +624,7 @@ impl Default for Prefs {
             grid_subdivisions: 8,
             grids_in_back: true,
             show_pixel_grid: true,
-            smart_guide_color: s("#ff4af0"),
+            smart_guide_color: s("#ff3dfc"),
             alignment_guides: true,
             object_highlighting: true,
             transform_tools_guides: true,
@@ -742,6 +774,8 @@ pub struct Session {
     pub(crate) liquify_stroke: Option<Box<cmd::distortcmds::LiquifyStroke>>,
     /// A press on the Plane Switching Widget is under way: its drag and release are the widget's.
     pub(crate) plane_widget_press: bool,
+    /// A guide being dragged out of a ruler ([`Session::ruler_guide`]).
+    pub(crate) ruler_guide: Option<vectorcraft_tools::rulerguide::NewGuide>,
 }
 
 impl Default for Session {
@@ -786,6 +820,7 @@ impl Session {
             envelope_defaults: None,
             liquify_stroke: None,
             plane_widget_press: false,
+            ruler_guide: None,
         }
     }
 
@@ -1064,11 +1099,7 @@ impl Session {
                 st.selection.prune(&st.doc);
                 st.revision += 1;
                 if st.interaction.is_none() {
-                    st.history.undo.push(HistoryEntry { label: label.to_string(), doc: before, selection: before_sel });
-                    if st.history.undo.len() > st.history.limit {
-                        st.history.undo.remove(0);
-                    }
-                    st.history.redo.clear();
+                    st.push_undo(HistoryEntry { label: label.to_string(), doc: before, selection: before_sel });
                 }
                 Ok(v)
             }
@@ -1182,6 +1213,44 @@ impl Session {
         self.active().is_some_and(|d| d.interaction.is_some())
     }
 
+    // ---------- undo groups (scrubbed numeric fields) ----------
+
+    /// Open an undo group in the active document: until [`Session::end_undo_group`], the edits
+    /// made there (commands, committed interactions) are one undo step. A scrubbed numeric field
+    /// applies each value it passes as its own command, as a typed value is applied; the drag is
+    /// one step.
+    pub fn begin_undo_group(&mut self) {
+        let journal = self.journal.len();
+        if let Some(st) = self.active_mut()
+            && st.undo_group.is_none()
+        {
+            st.undo_group = Some(UndoGroup { first: None, journal });
+        }
+    }
+
+    /// Close the open undo groups: their edits stay one undo step or, `cancel`led (Escape), are
+    /// undone and dropped from the journal.
+    pub fn end_undo_group(&mut self, cancel: bool) {
+        let mut journal = None;
+        for st in &mut self.docs {
+            let Some(g) = st.undo_group.take() else { continue };
+            // Only while the group's step is still the newest one.
+            if cancel
+                && let Some(first) = g.first
+                && st.history.undo.last().is_some_and(|e| Arc::ptr_eq(&e.doc, &first))
+                && let Some(e) = st.history.undo.pop()
+            {
+                st.doc = e.doc;
+                st.selection = e.selection;
+                st.revision += 1;
+                journal = Some(g.journal);
+            }
+        }
+        if let Some(len) = journal {
+            self.journal.truncate(len);
+        }
+    }
+
     /// Commands with enablement (for menus, palette, MCP `list_commands`).
     pub fn commands(&self) -> Vec<CommandInfo> {
         command_specs().iter().map(|c| c.info(self)).collect()
@@ -1333,6 +1402,8 @@ mod tests_panelcmds;
 #[cfg(test)]
 mod tests_pathops;
 #[cfg(test)]
+mod tests_pathtype;
+#[cfg(test)]
 mod tests_pattern;
 #[cfg(test)]
 mod tests_pdffidelity;

crates/engine/src/tests.rs

@@ -364,6 +364,112 @@ fn document_node_summary_matches_inspect() {
     assert!(s.execute("document.node", &json!({"id": 999999, "summary": true})).is_err());
 }
 
+/// `depth` and `childLimit` slice a summary read; a level that shows fewer children
+/// than it has reports `childCount`, and invalid values are rejected, not reinterpreted.
+#[test]
+fn document_node_summary_slices_with_depth_and_limit() {
+    let mut s = session();
+    rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+    rect(&mut s, 20.0, 0.0, 10.0, 10.0);
+    s.execute("select.all", &json!({})).unwrap();
+    let inner = s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap();
+    rect(&mut s, 40.0, 0.0, 10.0, 10.0);
+    s.execute("select.all", &json!({})).unwrap();
+    let outer = s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap();
+    let mut read = |p: Value| s.execute("document.node", &p).unwrap();
+
+    let g = read(json!({"id": outer, "summary": true}));
+    assert_eq!(g["children"].as_array().map(Vec::len), Some(2));
+    assert!(g.get("childCount").is_none(), "nothing truncated: {g}");
+    // Limits beyond the tree are the whole tree, byte for byte.
+    assert_eq!(read(json!({"id": outer, "summary": true, "depth": u64::MAX, "childLimit": u64::MAX})), g);
+
+    let one = read(json!({"id": outer, "summary": true, "childLimit": 1}));
+    assert_eq!(one["children"].as_array().map(Vec::len), Some(1));
+    assert_eq!(one["childCount"], 2);
+
+    let flat = read(json!({"id": outer, "summary": true, "depth": 0}));
+    assert!(flat.get("children").is_none(), "{flat}");
+    assert_eq!(flat["childCount"], 2);
+
+    // Limits compose per level: the outer children show; the inner group's own
+    // children don't, and it says so.
+    let shallow = read(json!({"id": outer, "summary": true, "depth": 1}));
+    let kids = shallow["children"].as_array().unwrap();
+    assert_eq!(kids.len(), 2);
+    assert!(shallow.get("childCount").is_none(), "{shallow}");
+    let nested = kids.iter().find(|n| n["id"] == inner).unwrap();
+    assert!(nested.get("children").is_none(), "{nested}");
+    assert_eq!(nested["childCount"], 2);
+
+    for bad in [
+        json!({"id": outer, "summary": true, "depth": -1}),
+        json!({"id": outer, "summary": true, "depth": 1.5}),
+        json!({"id": outer, "summary": true, "childLimit": "many"}),
+        // A slice of the full object JSON would silently be the whole subtree.
+        json!({"id": outer, "depth": 0}),
+        json!({"id": outer, "summary": false, "childLimit": 1}),
+    ] {
+        assert!(s.execute("document.node", &bad).is_err(), "{bad}");
+    }
+}
+
+/// `document.inspect` slices the layer tree with the same options; artboards and the
+/// rest always come whole, and the default output is unchanged.
+#[test]
+fn document_inspect_slices_the_layer_tree() {
+    let mut s = session();
+    rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+    rect(&mut s, 20.0, 0.0, 10.0, 10.0);
+    s.execute("select.all", &json!({})).unwrap();
+    s.execute("object.group", &json!({})).unwrap();
+
+    let full = s.execute("document.inspect", &json!({})).unwrap();
+    assert!(full["layers"][0].get("childCount").is_none(), "{full}");
+    let flat = s.execute("document.inspect", &json!({"depth": 0})).unwrap();
+    assert!(flat["layers"][0].get("children").is_none(), "{flat}");
+    assert_eq!(flat["layers"][0]["childCount"], 1);
+    assert_eq!(flat["artboards"], full["artboards"]);
+    assert_eq!(flat["objects"], full["objects"]);
+    let one = s.execute("document.inspect", &json!({"childLimit": 0})).unwrap();
+    assert_eq!(one["layers"][0]["children"], json!([]));
+    assert_eq!(one["layers"][0]["childCount"], 1);
+    assert!(s.execute("document.inspect", &json!({"depth": "deep"})).is_err());
+}
+
+/// `document.find` searches names, kinds and type content across the whole tree and
+/// answers ids with ancestor paths plus the total, so capped replies stay explicit.
+#[test]
+fn document_find_searches_names_kinds_and_text() {
+    let mut s = session();
+    let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0).0;
+    s.execute("object.setProps", &json!({"ids": [a], "name": "Hero Banner"})).unwrap();
+    rect(&mut s, 20.0, 0.0, 10.0, 10.0);
+    s.execute("select.all", &json!({})).unwrap();
+    let group = s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap();
+    let mut find = |p: Value| s.execute("document.find", &p).unwrap();
+
+    let v = find(json!({"name": "hero"}));
+    assert_eq!(v["total"], 1);
+    assert_eq!(v["matches"][0]["id"], a);
+    assert_eq!(v["matches"][0]["path"], json!([1, group]));
+
+    let v = find(json!({"kind": "group"}));
+    assert_eq!(v["total"], 1);
+    assert_eq!(v["matches"][0]["id"], group);
+
+    // `limit: 0` counts without listing; a missing filter is rejected, not a full dump.
+    let v = find(json!({"kind": "rectangle", "limit": 0}));
+    assert_eq!(v["matches"].as_array().map(Vec::len), Some(0));
+    assert_eq!(v["total"], 2);
+    assert!(s.execute("document.find", &json!({})).is_err());
+    assert!(s.execute("document.find", &json!({"name": ""})).is_err());
+    assert!(s.execute("document.find", &json!({"name": "hero", "limit": "many"})).is_err());
+    // A filter of the wrong type is rejected, not dropped (dropping it would widen the search).
+    assert!(s.execute("document.find", &json!({"kind": "group", "name": 5})).is_err());
+    assert_eq!(s.execute("document.find", &json!({"kind": "nope"})).unwrap()["total"], 0);
+}
+
 /// Type reports the paint its characters show, and its own object-level paint apart from it.
 #[test]
 fn inspect_reports_the_paint_of_types_characters() {

crates/engine/src/tests_build.rs

@@ -320,6 +320,69 @@ fn shape_builder_tool_alt_deletes_line_pieces() {
     assert_eq!(layer_children(&s), 3, "square + the line's two loose ends");
 }
 
+/// Red square A (0..100) and blue square B (50..150 both ways), overlapping at a corner, selected.
+fn corner(s: &mut Session) -> (NodeId, NodeId) {
+    let a = rect(s, 0.0, 0.0, 100.0, 100.0);
+    let b = rect(s, 50.0, 50.0, 100.0, 100.0);
+    set_fill(s, a, Color::rgb(1.0, 0.0, 0.0));
+    set_fill(s, b, Color::rgb(0.0, 0.0, 1.0));
+    s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
+    (a, b)
+}
+
+/// (closed, anchors, length) of each of `ids`.
+fn shapes_of(s: &Session, ids: &[NodeId]) -> Vec<(bool, usize, f64)> {
+    ids.iter()
+        .map(|i| {
+            let (p, _) = outline(&node(s, *i));
+            (p.is_closed(), p.anchor_count(), (p.length() * 1e6).round() / 1e6)
+        })
+        .collect()
+}
+
+#[test]
+fn shape_builder_erase_click_on_an_edge_opens_its_path() {
+    let mut s = session();
+    corner(&mut s);
+    let r = s.execute("shapeBuilder.regions", &json!({})).unwrap();
+    assert_eq!(r["edges"].as_array().unwrap().len(), 4, "each outline cut in two where the other crosses it: {r}");
+    // A's side inside B (1 pt off it).
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[101, 75]], "erase": true})).unwrap();
+    assert_eq!((r["regions"].as_u64(), r["lines"].as_u64(), r["edges"].as_u64()), (Some(0), Some(0), Some(1)));
+    let out = ids(&r);
+    // A opens where B's outline crosses it and keeps its look; B is untouched.
+    assert_eq!(shapes_of(&s, &out), vec![(false, 5, 300.0), (true, 4, 400.0)]);
+    assert_eq!(node(&s, out[0]).appearance.fill_paint(), Paint::solid(Color::rgb(1.0, 0.0, 0.0)));
+    assert_eq!(s.journal.last().unwrap().0, "shapeBuilder.merge");
+    s.execute("edit.undo", &json!({})).unwrap();
+    let back: Vec<NodeId> = s.doc().unwrap().doc.children(s.doc().unwrap().doc.default_layer()).unwrap().iter().map(|n| n.id).collect();
+    assert_eq!(shapes_of(&s, &back), vec![(true, 4, 400.0); 2], "one undo step");
+}
+
+#[test]
+fn shape_builder_erase_drag_along_edges_deletes_each() {
+    let mut s = session();
+    corner(&mut s);
+    // Down A's side inside B, round the corner and along B's side inside A.
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[100, 75], [100, 50], [75, 50]], "erase": true})).unwrap();
+    assert_eq!((r["regions"].as_u64(), r["edges"].as_u64()), (Some(0), Some(2)));
+    assert_eq!(shapes_of(&s, &ids(&r)), vec![(false, 5, 300.0); 2]);
+}
+
+#[test]
+fn shape_builder_erase_drag_into_regions_deletes_them_not_the_edges_it_crosses() {
+    let mut s = session();
+    corner(&mut s);
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[25, 25], [75, 75]], "erase": true})).unwrap();
+    assert_eq!((r["regions"].as_u64(), r["edges"].as_u64()), (Some(2), Some(0)));
+    // A is gone; what is left of B stays closed and blue.
+    let out = ids(&r);
+    assert_eq!(out.len(), 1);
+    assert!((area(&s, out[0]) - 7500.0).abs() < 1e-6);
+    assert!(outline(&node(&s, out[0])).0.is_closed());
+    assert_eq!(node(&s, out[0]).appearance.fill_paint(), Paint::solid(Color::rgb(0.0, 0.0, 1.0)));
+}
+
 // ---------- Live Paint ----------
 
 fn live(s: &mut Session) -> NodeId {

crates/engine/src/tests_clipflavours.rs

@@ -7,7 +7,7 @@ use vectorcraft_geom::Point;
 use vectorcraft_tools::{Mods, PointerEvent, PointerKind, ToolKey};
 
 use super::*;
-use crate::cmd::clipboard::{PDF, PNG, SVG, TEXT};
+use crate::cmd::clipboard::{BITMAP, FILE_HEAD, PASTE_ORDER, PDF, PNG, SVG, TEXT, file_flavour};
 
 fn session() -> Session {
     let mut s = Session::new();
@@ -118,6 +118,29 @@ fn import_image_then_paste_gives_an_image() {
     assert!(s.execute("clipboard.importImage", &json!({"dataBase64": "!!"})).is_err());
 }
 
+#[test]
+fn copied_files_paste_by_their_content() {
+    let mut s = session();
+    copy_red_square(&mut s);
+    let png = decode(&run(&mut s, "clipboard.exportPng", json!({})));
+    let pdf = decode(&run(&mut s, "clipboard.exportPdf", json!({})));
+    let mut jpeg = vec![];
+    image::RgbImage::new(2, 2).write_to(&mut std::io::Cursor::new(&mut jpeg), image::ImageFormat::Jpeg).unwrap();
+    let svg = b"<svg xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"4\" height=\"4\"/></svg>";
+    let of = |name: &str, bytes: &[u8]| file_flavour(name, &bytes[..bytes.len().min(FILE_HEAD)], &PASTE_ORDER);
+    assert_eq!(of("red.png", &png), Some(PNG));
+    // The content tells, whatever the name says; bitmaps keep their own type.
+    assert_eq!(of("photo.txt", &jpeg), Some("image/jpeg"));
+    assert_eq!(of("art.svg", svg), Some(SVG));
+    assert_eq!(of("doc.pdf", &pdf), Some(PDF));
+    // Files that aren't art paste as nothing (not as their path).
+    assert_eq!(of("notes.txt", b"hello"), None);
+    assert_eq!(of("archive.zip", b"PK\x03\x04"), None);
+    // Only what was asked for.
+    assert_eq!(file_flavour("red.png", &png, &[TEXT, SVG]), None);
+    assert_eq!(file_flavour("art.svg", svg, &[BITMAP]), None);
+}
+
 #[test]
 fn import_text_then_paste_gives_point_text() {
     let mut s = session();

crates/engine/src/tests_draw2.rs

@@ -534,3 +534,128 @@ fn remove_anchor_points_keeps_the_paths_closed() {
     let spec = find_command("path.removeAnchors").unwrap();
     assert_eq!(spec.menu, &["Object", "Path"][..]);
 }
+
+fn undo_steps(s: &Session) -> usize {
+    s.doc().unwrap().history.undo.len()
+}
+
+#[test]
+fn convert_anchors_turns_the_selected_anchors_corner_or_smooth() {
+    // The Control bar's convert buttons: one undo step each, other anchors left alone.
+    let mut s = session();
+    let made = s.execute("path.create", &json!({"anchors": [{"x": 100, "y": 200}, {"x": 200, "y": 100}, {"x": 300, "y": 200}]})).unwrap();
+    let id = NodeId(made["id"].as_u64().unwrap());
+    s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 1]]})).unwrap();
+    let undo = undo_steps(&s);
+    s.execute("path.convertAnchors", &json!({"to": "smooth"})).unwrap();
+    let a = path(&s, id).subpaths[0].anchors.clone();
+    assert_eq!(undo_steps(&s), undo + 1);
+    assert_eq!(a[1].kind, vectorcraft_geom::AnchorKind::Smooth);
+    let r = 100.0 * 2f64.sqrt() / 3.0;
+    assert!(near(a[1].h_in, Point::new(200.0 - r, 100.0)) && near(a[1].h_out, Point::new(200.0 + r, 100.0)), "{:?}", a[1]);
+    assert!(!a[0].has_out() && !a[2].has_in(), "the neighbours keep theirs");
+    // Smooth again keeps the handles; corner retracts them.
+    s.execute("path.setHandle", &json!({"id": id.0, "anchor": 1, "which": "out", "x": 260, "y": 100})).unwrap();
+    let h = path(&s, id).subpaths[0].anchors[1];
+    s.execute("path.convertAnchors", &json!({"to": "smooth"})).unwrap();
+    assert_eq!(path(&s, id).subpaths[0].anchors[1], h);
+    s.execute("path.convertAnchors", &json!({"to": "corner"})).unwrap();
+    let a = path(&s, id).subpaths[0].anchors[1];
+    assert!(!a.has_in() && !a.has_out(), "{a:?}");
+    // Anchors that are gone (a stale selection) are skipped; a bad `to` is refused.
+    s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 99], [7, 0]]})).unwrap();
+    s.execute("path.convertAnchors", &json!({"to": "smooth"})).unwrap();
+    let undo = undo_steps(&s);
+    assert!(s.execute("path.convertAnchors", &json!({"to": "round"})).is_err());
+    assert_eq!(undo_steps(&s), undo);
+}
+
+#[test]
+fn cut_at_anchors_splits_paths_and_leaves_one_end_selected() {
+    // Cut Path at Selected Anchor Points: an open path becomes one path per piece, and one anchor
+    // of each cut stays selected, so dragging it pulls the path apart there.
+    let mut s = session();
+    let anchors = json!([{"x": 100, "y": 100}, {"x": 200, "y": 100, "in": [170, 80], "out": [230, 120]}, {"x": 300, "y": 100}, {"x": 400, "y": 100}]);
+    let id = NodeId(s.execute("path.create", &json!({"anchors": anchors})).unwrap()["id"].as_u64().unwrap());
+    s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 1], [0, 2]]})).unwrap();
+    let undo = undo_steps(&s);
+    let made = s.execute("path.cutAtAnchors", &json!({})).unwrap();
+    let ids: Vec<NodeId> = made["ids"].as_array().unwrap().iter().map(|v| NodeId(v.as_u64().unwrap())).collect();
+    assert_eq!(undo_steps(&s), undo + 1);
+    assert_eq!((ids.len(), ids[0]), (3, id));
+    let pieces: Vec<Vec<Point>> = ids.iter().map(|i| path(&s, *i).subpaths[0].anchors.iter().map(|a| a.p).collect()).collect();
+    let p = |x: f64| Point::new(x, 100.0);
+    assert_eq!(pieces, vec![vec![p(100.0), p(200.0)], vec![p(200.0), p(300.0)], vec![p(300.0), p(400.0)]]);
+    // The curve keeps its shape: each end keeps the handle on its own side only.
+    let (l, r) = (path(&s, ids[0]).subpaths[0].anchors[1], path(&s, ids[1]).subpaths[0].anchors[0]);
+    assert!(l.h_in == Point::new(170.0, 80.0) && !l.has_out() && r.h_out == Point::new(230.0, 120.0) && !r.has_in(), "{l:?} {r:?}");
+    let sel = s.doc().unwrap().selection.clone();
+    assert_eq!(sel.objects, vec![ids[1], ids[2]]);
+    assert!(sel.anchors.values().all(|a| a.iter().eq([&(0, 0)])), "{sel:?}");
+    s.execute("path.moveAnchors", &json!({"dx": 0, "dy": 50})).unwrap();
+    assert_eq!(path(&s, ids[0]).subpaths[0].anchors[1].p, p(200.0));
+    assert_eq!(path(&s, ids[1]).subpaths[0].anchors[0].p, Point::new(200.0, 150.0));
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(paths(&s).len(), 1);
+    // A closed path opens at the cut, its ends on top of each other.
+    let r = rect(&mut s, 500.0, 100.0, 100.0, 100.0);
+    s.execute("select.anchors", &json!({"id": r.0, "anchors": [[0, 2]]})).unwrap();
+    s.execute("path.cutAtAnchors", &json!({})).unwrap();
+    let sp = &path(&s, r).subpaths[0];
+    assert!(!sp.closed && sp.anchors.len() == 5 && sp.anchors[0].p == sp.anchors[4].p, "{sp:?}");
+    assert_eq!(s.doc().unwrap().selection.anchors[&r].iter().collect::<Vec<_>>(), [&(0, 0)]);
+    // Only the end points of an open path selected: nothing to cut.
+    s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 0], [0, 3]]})).unwrap();
+    let undo = undo_steps(&s);
+    assert!(s.execute("path.cutAtAnchors", &json!({})).is_err());
+    assert_eq!(undo_steps(&s), undo);
+}
+
+#[test]
+fn pen_with_alt_moves_one_handle_and_converts_anchors() {
+    // Discord feedback: Alt held with the Pen moves a direction handle on its own (and works as
+    // the Anchor Point tool on a selected path's anchors), while a path is being drawn too.
+    let alt = Mods { alt: true, ..Mods::default() };
+    let v = view();
+    let mut s = session();
+    let anchors = json!([{"x": 100, "y": 200}, {"x": 200, "y": 100, "in": [150, 100], "out": [250, 100]}, {"x": 300, "y": 200}]);
+    let id = NodeId(s.execute("path.create", &json!({"anchors": anchors})).unwrap()["id"].as_u64().unwrap());
+    s.select_tool("pen", v).unwrap();
+    let gesture = |s: &mut Session, pts: &[(f64, f64)], m: Mods| {
+        let undo = undo_steps(s);
+        s.pointer(&PointerEvent::new(PointerKind::Down, pts[0].0, pts[0].1).with_mods(m), v).unwrap();
+        for &(x, y) in &pts[1..] {
+            s.pointer(&PointerEvent::new(PointerKind::Drag, x, y).with_mods(m), v).unwrap();
+        }
+        let l = pts[pts.len() - 1];
+        s.pointer(&PointerEvent::new(PointerKind::Up, l.0, l.1).with_mods(m), v).unwrap();
+        undo_steps(s) - undo
+    };
+    // Alt-drag the out handle: it moves alone, the in handle stays.
+    assert_eq!(gesture(&mut s, &[(250.0, 100.0), (260.0, 130.0), (275.0, 165.0)], alt), 1);
+    assert!(!s.in_interaction());
+    let a = path(&s, id).subpaths[0].anchors[1];
+    assert_eq!((a.h_in, a.h_out), (Point::new(150.0, 100.0), Point::new(275.0, 165.0)));
+    assert_eq!(paths(&s).len(), 1, "no new path or anchor");
+    // Alt-click the anchor: a corner. Alt-drag it: new symmetric handles.
+    assert_eq!(gesture(&mut s, &[(200.0, 100.0)], alt), 1);
+    let a = path(&s, id).subpaths[0].anchors[1];
+    assert!(!a.has_in() && !a.has_out(), "{a:?}");
+    gesture(&mut s, &[(200.0, 100.0), (220.0, 100.0), (240.0, 110.0)], alt);
+    let a = path(&s, id).subpaths[0].anchors[1];
+    assert_eq!((a.h_in, a.h_out), (Point::new(160.0, 90.0), Point::new(240.0, 110.0)));
+    assert_eq!(path(&s, id).subpaths[0].anchors.len(), 3);
+    // Drawing: place a smooth point, then Alt-drag its outgoing handle; the next click goes on
+    // drawing the same path.
+    s.execute("select.none", &json!({})).unwrap();
+    gesture(&mut s, &[(100.0, 400.0)], Mods::default());
+    gesture(&mut s, &[(200.0, 400.0), (250.0, 400.0)], Mods::default());
+    let new = *s.doc().unwrap().selection.objects.first().unwrap();
+    gesture(&mut s, &[(250.0, 400.0), (230.0, 350.0)], alt);
+    let a = path(&s, new).subpaths[0].anchors[1];
+    assert_eq!((a.h_in, a.h_out), (Point::new(150.0, 400.0), Point::new(230.0, 350.0)));
+    gesture(&mut s, &[(300.0, 450.0)], Mods::default());
+    assert_eq!(path(&s, new).subpaths[0].anchors.len(), 3);
+    assert_eq!(paths(&s).len(), 2);
+}

crates/engine/src/tests_emptytype.rs

@@ -8,7 +8,9 @@ use vectorcraft_tools::{Mods, PointerEvent, PointerKind, ToolKey};
 use super::*;
 
 fn session() -> Session {
+    // Type placed by the Type tools starts empty (Fill New Type Objects With Placeholder Text off).
     let mut s = Session::new();
+    s.prefs.placeholder_text = false;
     s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
     s
 }

crates/engine/src/tests_journal.rs

@@ -249,3 +249,50 @@ fn a_failed_batch_gives_back_the_highlighted_rows_and_the_current_layer() {
     let r = replayed(&s);
     assert_eq!(documents(&r), documents(&s));
 }
+
+/// The edits made in an undo group (a scrubbed numeric field, #400) are one undo step, journaled
+/// one by one; a cancelled group undoes them and leaves the journal as it was.
+#[test]
+fn an_undo_group_is_one_undo_step() {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+    s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 100, "height": 50})).unwrap();
+    let width = |s: &Session| s.transform_box(&s.doc().unwrap().selection.objects).unwrap().rect.width();
+    let undo_len = |s: &Session| s.doc().unwrap().history.undo.len();
+    let (undo, journal) = (undo_len(&s), s.journal.len());
+    s.begin_undo_group();
+    for w in [101, 102, 103] {
+        s.execute("object.setBounds", &json!({"width": w})).unwrap();
+    }
+    // A live drag committed in the group (the Transparency panel's opacity field) joins it too.
+    s.begin_interaction("Opacity").unwrap();
+    s.preview("transparency.set", &json!({"opacity": 50})).unwrap();
+    s.commit_interaction().unwrap();
+    s.end_undo_group(false);
+    assert!((width(&s) - 103.0).abs() < 1e-9);
+    assert_eq!(undo_len(&s), undo + 1, "one undo step");
+    assert_eq!(s.journal.len(), journal + 4, "each edit journaled");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert!((width(&s) - 100.0).abs() < 1e-9, "undo takes the whole drag back");
+    assert_eq!(undo_len(&s), undo);
+    s.execute("edit.redo", &json!({})).unwrap();
+    assert!((width(&s) - 103.0).abs() < 1e-9);
+
+    // Escape: back where it started, with no trace in the history or the journal.
+    let (undo, journal) = (undo_len(&s), s.journal.len());
+    s.begin_undo_group();
+    s.execute("object.setBounds", &json!({"width": 150})).unwrap();
+    s.execute("object.setBounds", &json!({"width": 160})).unwrap();
+    s.end_undo_group(true);
+    assert!((width(&s) - 103.0).abs() < 1e-9);
+    assert_eq!((undo_len(&s), s.journal.len()), (undo, journal));
+    // Closed: the next edits are steps of their own again.
+    s.execute("object.setBounds", &json!({"width": 110})).unwrap();
+    s.execute("object.setBounds", &json!({"width": 120})).unwrap();
+    assert_eq!(undo_len(&s), undo + 2);
+    // A group with no edits records nothing, and cancelling it undoes nothing.
+    s.begin_undo_group();
+    s.end_undo_group(true);
+    assert!((width(&s) - 120.0).abs() < 1e-9);
+    assert_eq!(undo_len(&s), undo + 2);
+}

crates/engine/src/tests_livecorners.rs

@@ -5,6 +5,7 @@ use std::collections::BTreeSet;
 
 use serde_json::{Value, json};
 use vectorcraft_doc::{AnchorRef, LiveShape, NodeKind};
+use vectorcraft_geom::Affine;
 use vectorcraft_geom::shapes::CornerKind;
 
 use super::*;
@@ -105,3 +106,47 @@ fn a_drag_previews_one_corner_and_commits_one_step() {
     assert_eq!(selected_anchors(&s, id), Some(anchors(&[2, 3])));
     assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
 }
+
+/// How far each corner's cut reaches along x and y (top-left, top-right, bottom-right,
+/// bottom-left) of a rectangle with four cut corners: equal for a circular arc.
+fn spans(s: &Session, id: NodeId) -> Vec<(f64, f64)> {
+    let NodeKind::Path { path, .. } = &s.doc().unwrap().doc.node(id).unwrap().kind else { panic!("not a path") };
+    let a: Vec<_> = path.subpaths[0].anchors.iter().map(|a| a.p).collect();
+    assert_eq!(a.len(), 8, "four cut corners");
+    [(7, 0), (1, 2), (3, 4), (5, 6)].iter().map(|(i, j)| ((a[*j].x - a[*i].x).abs(), (a[*j].y - a[*i].y).abs())).collect()
+}
+
+fn assert_spans(s: &Session, id: NodeId, want: [f64; 4]) {
+    let got = spans(s, id);
+    let ok = got.iter().zip(want).all(|((x, y), r)| (x - r).abs() < 1e-9 && (y - r).abs() < 1e-9);
+    assert!(ok, "corners span {got:?}, want circles of radii {want:?}");
+}
+
+/// #442: on a rectangle that isn't square, every corner is the same circle, also past the limit
+/// and on a shape from a file that kept an uneven scale in its transform (before #291).
+#[test]
+fn corners_of_a_non_square_rectangle_are_alike_circles() {
+    let (mut s, id) = session();
+    run(&mut s, json!({"radius": 12}));
+    assert_spans(&s, id, [12.0; 4]);
+    // Past half the shorter side, every corner stops there.
+    run(&mut s, json!({"radius": 45}));
+    assert_spans(&s, id, [30.0; 4]);
+    // A 50 × 60 rectangle with 10 pt corners, saved stretched to 100 × 60: 20 × 10 ellipses.
+    {
+        let d = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc);
+        let NodeKind::Path { path, live: Some(live), .. } = &mut d.node_mut(id).unwrap().kind else { panic!("not live") };
+        let xf = Affine::translate((10.0, 10.0)) * Affine::scale_non_uniform(2.0, 1.0);
+        *live = LiveShape::Rectangle { w: 50.0, h: 60.0, radii: [10.0; 4], kinds: Default::default(), xf };
+        *path = live.to_path();
+    }
+    assert_eq!(spans(&s, id)[0], (20.0, 10.0));
+    // Rounding one corner makes every corner a circle: the others of the mean radius.
+    run(&mut s, json!({"corners": [1], "radius": 12}));
+    let mean = 10.0 * 2f64.sqrt();
+    assert_spans(&s, id, [mean, 12.0, mean, mean]);
+    let b = s.doc().unwrap().doc.node(id).unwrap().geometric_bounds().unwrap();
+    assert!((b.x0 - 10.0).abs() < 1e-9 && (b.x1 - 110.0).abs() < 1e-9 && (b.y1 - 70.0).abs() < 1e-9, "same bounds: {b:?}");
+    run(&mut s, json!({"radius": 8}));
+    assert_spans(&s, id, [8.0; 4]);
+}

crates/engine/src/tests_menucmds.rs

@@ -1,7 +1,7 @@
 //! Menu long-tail commands (Object/Edit/Select/Type/View/File), driven through `Session::execute`.
 
 use serde_json::{Value, json};
-use vectorcraft_color::Color;
+use vectorcraft_color::{Color, Paint};
 use vectorcraft_doc::{ColorMode, LiveShape, Node, NodeKind, TextKind};
 use vectorcraft_geom::Rect;
 
@@ -234,6 +234,30 @@ fn crop_image_disabled_without_image() {
     assert!(matches!(s.execute("object.cropImage", &json!({})), Err(EngineError::Disabled(..))));
 }
 
+#[test]
+fn mask_image_clips_it_to_its_outline_and_selects_the_clipping_path() {
+    let mut s = session();
+    let a = rect(&mut s, 10.0, 20.0, 100.0, 50.0);
+    sel(&mut s, &[a]);
+    let img = id_of(&s.execute("object.rasterize", &json!({"ppi": 72})).unwrap());
+    s.execute("object.rotate", &json!({"angle": 30})).unwrap();
+    let ib = bounds(&s, img);
+    let r = s.execute("object.maskImage", &json!({})).unwrap();
+    let (g, p) = (id_of(&r), NodeId(r["path"].as_u64().unwrap()));
+    let group = node(&s, g);
+    assert!(matches!(group.kind, NodeKind::Group { clip: true, .. }));
+    assert_eq!(group.children().unwrap().iter().map(|c| c.id).collect::<Vec<_>>(), [p, img]);
+    // The clipping path follows the rotated image's outline, so nothing is cut off yet.
+    assert!(matches!(node(&s, p).kind, NodeKind::Path { clipping: true, .. }));
+    let pb = bounds(&s, p);
+    assert!(close(pb.x0, ib.x0) && close(pb.y0, ib.y0) && close(pb.x1, ib.x1) && close(pb.y1, ib.y1), "{pb:?} {ib:?}");
+    assert_eq!(s.doc().unwrap().selection.objects, [p]);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert!(s.doc().unwrap().doc.node(g).is_none() && s.doc().unwrap().doc.node(img).is_some());
+    sel(&mut s, &[]);
+    assert!(matches!(s.execute("object.maskImage", &json!({})), Err(EngineError::Disabled(..))));
+}
+
 #[test]
 fn trim_marks_around_selection() {
     let mut s = session();
@@ -740,6 +764,219 @@ fn ruler_guides_and_lock() {
     assert!(s.execute("guide.remove", &json!({"index": 0})).is_err());
 }
 
+fn guides(s: &Session) -> Vec<(bool, f64)> {
+    s.doc().unwrap().doc.guides.iter().map(|g| (g.vertical, g.pos)).collect()
+}
+
+fn selected_guides(s: &Session) -> Vec<usize> {
+    s.doc().unwrap().selection.guides.clone()
+}
+
+/// #414: ruler guides are selected, moved, copied, nudged and deleted like art, over commands.
+#[test]
+fn ruler_guides_select_move_and_delete() {
+    let mut s = session();
+    let a = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+    for (vertical, pos) in [(true, 100.0), (false, 50.0), (true, 300.0)] {
+        s.execute("guide.add", &json!({"vertical": vertical, "pos": pos})).unwrap();
+    }
+    sel(&mut s, &[a]);
+    // Selecting guides deselects the art; toggle adds and removes.
+    assert_eq!(s.execute("guide.select", &json!({"indexes": [0]})).unwrap()["selected"], json!([0]));
+    assert!(selected(&s).is_empty());
+    assert_eq!(s.execute("guide.select", &json!({"indexes": [1], "toggle": true})).unwrap()["selected"], json!([0, 1]));
+    assert_eq!(s.execute("guide.list", &json!({})).unwrap()[1], json!({"index": 1, "vertical": false, "pos": 50.0, "selected": true}));
+    assert!(s.execute("guide.select", &json!({"indexes": [7]})).is_err());
+    // A move takes each selected guide along its own axis, in one undo step.
+    let n = undo_len(&s);
+    s.execute("guide.move", &json!({"dx": 10, "dy": -5})).unwrap();
+    assert_eq!(guides(&s), [(true, 110.0), (false, 45.0), (true, 300.0)]);
+    assert_eq!(undo_len(&s), n + 1);
+    // Alt: copies, which are then the selection.
+    s.execute("guide.move", &json!({"dx": 20, "copy": true})).unwrap();
+    assert_eq!(guides(&s).len(), 5);
+    assert_eq!(&guides(&s)[3..], [(true, 130.0), (false, 45.0)]);
+    assert_eq!(selected_guides(&s), [3, 4]);
+    // The arrow keys nudge them.
+    s.execute("object.nudge", &json!({"dx": 1, "dy": 0, "big": true})).unwrap();
+    assert_eq!(guides(&s)[3], (true, 140.0));
+    // Delete (edit.clear) deletes the selected guides; the others keep their places.
+    s.execute("guide.select", &json!({"indexes": [1, 3]})).unwrap();
+    assert_eq!(s.execute("guide.list", &json!({})).unwrap().as_array().unwrap().len(), 5);
+    s.execute("edit.clear", &json!({})).unwrap();
+    assert_eq!(guides(&s), [(true, 110.0), (true, 300.0), (false, 45.0)]);
+    assert!(selected_guides(&s).is_empty());
+    assert!(s.doc().unwrap().doc.node(a).is_some(), "the art stays");
+    // Removing one keeps the rest of the selection pointing at the same guides.
+    s.execute("guide.select", &json!({"indexes": [1, 2]})).unwrap();
+    assert_eq!(s.execute("guide.remove", &json!({"index": 0})).unwrap()["count"], 1);
+    assert_eq!((guides(&s), selected_guides(&s)), (vec![(true, 300.0), (false, 45.0)], vec![0, 1]));
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!((guides(&s).len(), selected_guides(&s)), (3, vec![1, 2]));
+    // Out of range positions are refused.
+    assert!(s.execute("guide.move", &json!({"index": 0, "pos": 1e300})).is_err());
+    assert!(s.execute("guide.add", &json!({"vertical": true, "pos": -1e300})).is_err());
+    // Locking deselects them, and they can't be picked again until unlocked.
+    s.execute("view.guides.lock", &json!({"locked": true})).unwrap();
+    assert!(selected_guides(&s).is_empty());
+    assert!(matches!(s.execute("guide.select", &json!({"indexes": [0]})), Err(EngineError::Disabled(..))));
+    assert!(matches!(s.execute("edit.clear", &json!({})), Err(EngineError::Disabled(..))));
+}
+
+/// #451: an artboard guide (`guide.add {artboard}`) runs across its artboard only, and is moved,
+/// copied and deleted with it; canvas guides stay put.
+#[test]
+fn artboard_guides_go_with_their_artboard() {
+    let mut s = session();
+    s.execute("artboard.new", &json!({"x": 900, "y": 0, "width": 400, "height": 300})).unwrap();
+    s.execute("guide.add", &json!({"vertical": true, "pos": 1000, "artboard": 1})).unwrap();
+    s.execute("guide.add", &json!({"vertical": false, "pos": 100})).unwrap();
+    let list = |s: &mut Session| s.execute("guide.list", &json!({})).unwrap();
+    assert_eq!(
+        list(&mut s),
+        json!([
+            {"index": 0, "vertical": true, "pos": 1000.0, "selected": false, "artboard": 1},
+            {"index": 1, "vertical": false, "pos": 100.0, "selected": false},
+        ])
+    );
+    let spans = |s: &Session| {
+        let d = &s.doc().unwrap().doc;
+        d.guides.iter().map(|g| d.guide_span(g)).collect::<Vec<_>>()
+    };
+    assert_eq!(spans(&s), [Some((0.0, 300.0)), None]);
+    for bad in [json!(5), json!("x"), json!(-1)] {
+        assert!(s.execute("guide.add", &json!({"vertical": true, "pos": 10, "artboard": bad})).is_err(), "{bad}");
+    }
+    // Moved, the artboard takes its guides along; in Artboard Options too, unless resized.
+    s.execute("artboard.move", &json!({"index": 1, "dx": 50, "dy": 20})).unwrap();
+    assert_eq!(guides(&s), [(true, 1050.0), (false, 100.0)]);
+    s.execute("artboard.setProps", &json!({"index": 1, "x": 960.5})).unwrap();
+    assert_eq!(guides(&s)[0], (true, 1060.5));
+    s.execute("artboard.setProps", &json!({"index": 1, "x": 900, "width": 500})).unwrap();
+    assert_eq!((guides(&s)[0], spans(&s)[0]), ((true, 1060.5), Some((20.0, 320.0))));
+    // Renumbered, it keeps them.
+    s.execute("artboard.reorder", &json!({"index": 1, "to": 0})).unwrap();
+    assert_eq!(list(&mut s)[0]["artboard"], 0);
+    // Duplicated (or Alt-dragged), the copy gets copies of them.
+    let dup = s.execute("artboard.duplicate", &json!({"index": 0})).unwrap()["index"].as_u64().unwrap();
+    let dx = s.doc().unwrap().doc.artboards[dup as usize].rect.x0 - 900.0;
+    assert_eq!(guides(&s), [(true, 1060.5), (false, 100.0), (true, 1060.5 + dx)]);
+    assert_eq!(list(&mut s)[2]["artboard"], dup);
+    s.execute("artboard.move", &json!({"index": 0, "dx": 0, "dy": 400, "copy": true})).unwrap();
+    assert_eq!((guides(&s).len(), list(&mut s)[3]["artboard"].clone()), (4, json!(3)));
+    // Rearranged, they follow their artboards.
+    s.execute("artboard.rearrange", &json!({"columns": 4})).unwrap();
+    let d = &s.doc().unwrap().doc;
+    for (g, ab) in d.guides.iter().filter_map(|g| Some((g, d.artboards.iter().find(|a| Some(a.id) == g.artboard)?))) {
+        assert_eq!(g.pos - ab.rect.x0, 160.5, "{g:?} on {ab:?}");
+    }
+    // Deleted, the artboard takes its guides; the selected ones left stay selected.
+    s.execute("guide.select", &json!({"indexes": [1, 2]})).unwrap();
+    let n = undo_len(&s);
+    s.execute("artboard.delete", &json!({"index": 0})).unwrap();
+    assert_eq!((guides(&s).len(), selected_guides(&s)), (3, vec![0, 1]));
+    assert_eq!(list(&mut s)[0], json!({"index": 0, "vertical": false, "pos": 100.0, "selected": true}));
+    assert_eq!(undo_len(&s), n + 1);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!((guides(&s).len(), selected_guides(&s)), (4, vec![1, 2]));
+    // Cut, too.
+    s.execute("artboard.cut", &json!({"index": 0})).unwrap();
+    assert_eq!((guides(&s).len(), selected_guides(&s)), (3, vec![0, 1]));
+}
+
+/// #451: a guide dragged out of a ruler snaps (to the art's corners, side midpoints and anchors,
+/// the artboards' edges and centres) and is made in one undo step where it is released over the
+/// canvas; with the Artboard tool it is an artboard guide of the active artboard.
+#[test]
+fn guides_dragged_out_of_a_ruler_snap_and_take_the_artboard_tool_s_artboard() {
+    use vectorcraft_tools::{Overlay, PointerEvent, PointerKind};
+    let mut s = session();
+    rect(&mut s, 100.0, 100.0, 100.0, 100.0);
+    let v = ViewInfo::default();
+    let ev = |kind, x, y| PointerEvent::new(kind, x, y);
+    let n = undo_len(&s);
+    s.ruler_guide(true, &ev(PointerKind::Drag, -10.0, 30.0), false, v).unwrap();
+    assert!(guides(&s).is_empty(), "still over the ruler");
+    s.ruler_guide(true, &ev(PointerKind::Drag, 153.0, 30.0), true, v).unwrap();
+    assert_eq!(guides(&s), [(true, 150.0)], "onto the line through the top and bottom midpoints");
+    assert!(s.overlays(v).iter().any(|o| matches!(o, Overlay::Label { text, .. } if text == "center")));
+    s.ruler_guide(true, &ev(PointerKind::Drag, 797.0, 30.0), true, v).unwrap();
+    assert_eq!(guides(&s), [(true, 800.0)], "the artboard's edge");
+    s.ruler_guide(true, &ev(PointerKind::Up, 797.0, 30.0), true, v).unwrap();
+    assert_eq!(guides(&s), [(true, 800.0)]);
+    assert_eq!(undo_len(&s), n + 1);
+    assert_eq!(s.doc().unwrap().history.undo.last().unwrap().label, "New Guide");
+    assert!(s.overlays(v).is_empty());
+    // Released off the canvas: none.
+    s.ruler_guide(false, &ev(PointerKind::Drag, 30.0, 250.0), true, v).unwrap();
+    s.ruler_guide(false, &ev(PointerKind::Up, 30.0, -10.0), false, v).unwrap();
+    assert_eq!((guides(&s).len(), undo_len(&s)), (1, n + 1));
+    // The Artboard tool: an artboard guide of its active artboard.
+    s.execute("artboard.new", &json!({"x": 900, "y": 0, "width": 400, "height": 300})).unwrap();
+    s.select_tool("artboard", v).unwrap();
+    s.set_tool_option("active", &json!(1));
+    s.ruler_guide(false, &ev(PointerKind::Drag, 1000.0, 50.0), true, v).unwrap();
+    s.ruler_guide(false, &ev(PointerKind::Up, 1000.0, 50.0), true, v).unwrap();
+    assert_eq!(
+        s.execute("guide.list", &json!({})).unwrap()[1],
+        json!({"index": 1, "vertical": false, "pos": 50.0, "selected": false, "artboard": 1})
+    );
+}
+
+/// #451: art moved with the Selection tool lands flush on the artboard's edges and centre (Smart
+/// Guides).
+#[test]
+fn moved_art_snaps_to_the_artboard_edges_and_centre() {
+    use vectorcraft_tools::{PointerEvent, PointerKind};
+    let mut s = session();
+    let a = rect(&mut s, 100.0, 100.0, 100.0, 100.0);
+    let v = ViewInfo::default();
+    s.select_tool("selection", v).unwrap();
+    let mut drag = |from: (f64, f64), to: (f64, f64)| {
+        for (kind, (x, y)) in [(PointerKind::Down, from), (PointerKind::Drag, to), (PointerKind::Up, to)] {
+            s.pointer(&PointerEvent::new(kind, x, y), v).unwrap();
+        }
+        let b = bounds(&s, a);
+        (b.x0, b.y0)
+    };
+    assert_eq!(drag((150.0, 150.0), (53.0, 147.0)), (0.0, 97.0), "3 pt off the left edge: flush with it");
+    assert_eq!(drag((50.0, 147.0), (402.0, 298.0)), (350.0, 250.0), "its centre on the artboard's");
+}
+
+/// #414: the Selection tool picks a ruler guide over the art and drags it in one undo step; with
+/// guides hidden or locked the press goes to the art.
+#[test]
+fn selection_tool_drags_a_ruler_guide() {
+    use vectorcraft_tools::{PointerEvent, PointerKind};
+    let mut s = session();
+    let a = rect(&mut s, 100.0, 100.0, 100.0, 100.0);
+    s.execute("guide.add", &json!({"vertical": true, "pos": 150})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    let v = ViewInfo { smart_guides: false, ..Default::default() };
+    s.select_tool("selection", v).unwrap();
+    let drag = |s: &mut Session, v: ViewInfo, from: (f64, f64), to: (f64, f64)| {
+        s.pointer(&PointerEvent::new(PointerKind::Down, from.0, from.1), v).unwrap();
+        s.pointer(&PointerEvent::new(PointerKind::Drag, to.0, to.1), v).unwrap();
+        s.pointer(&PointerEvent::new(PointerKind::Up, to.0, to.1), v).unwrap();
+    };
+    let n = undo_len(&s);
+    drag(&mut s, v, (151.0, 120.0), (171.0, 140.0));
+    assert_eq!(guides(&s), [(true, 170.0)]);
+    assert_eq!(selected_guides(&s), [0]);
+    assert!(selected(&s).is_empty());
+    assert_eq!(bounds(&s, a).x0, 100.0, "the art stays");
+    assert_eq!(undo_len(&s), n + 1);
+    assert_eq!(s.doc().unwrap().history.undo.last().unwrap().label, "Move Guide");
+    // Hidden guides: the press takes the art.
+    let hidden = ViewInfo { guides: false, ..v };
+    drag(&mut s, hidden, (170.0, 120.0), (180.0, 120.0));
+    assert_eq!((guides(&s), bounds(&s, a).x0), (vec![(true, 170.0)], 110.0));
+    // Locked guides too.
+    s.execute("view.guides.lock", &json!({"locked": true})).unwrap();
+    drag(&mut s, v, (170.0, 120.0), (180.0, 120.0));
+    assert_eq!((guides(&s), bounds(&s, a).x0), (vec![(true, 170.0)], 120.0));
+}
+
 // ---------- File ----------
 
 #[test]
@@ -766,6 +1003,122 @@ fn document_color_mode_converts_colours() {
     assert!(s.execute("file.documentColorMode", &json!({"mode": "lab"})).is_err());
 }
 
+/// Four RGB greys (#000000, #333333, #808080, #e6e6e6, as in issue #421) and a red, a 40% tint of a
+/// grey global swatch, a gradient to grey and a pattern of a grey tile → (session, the five
+/// rectangles, the tinted one, the gradient one).
+fn greys_document() -> (Session, Vec<NodeId>, NodeId, NodeId) {
+    let mut s = session();
+    let ids: Vec<NodeId> = ["#000000", "#333333", "#808080", "#e6e6e6", "#ff0000"]
+        .iter()
+        .map(|hex| {
+            let id = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+            fill(&mut s, id, hex);
+            id
+        })
+        .collect();
+    s.execute("swatch.new", &json!({"name": "Ink", "color": "#808080", "global": true})).unwrap();
+    let tint = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+    s.execute("paint.setFill", &json!({"ids": [tint.0], "swatch": "Ink", "tint": 40})).unwrap();
+    let grad = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+    let stops = json!([{"offset": 0, "color": "#ffffff"}, {"offset": 1, "color": "#333333"}]);
+    s.execute("paint.setFill", &json!({"ids": [grad.0], "gradient": {"kind": "linear", "stops": stops}})).unwrap();
+    let tile = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+    fill(&mut s, tile, "#808080");
+    s.execute("object.pattern.make", &json!({"ids": [tile.0], "name": "Grey Tile", "edit": false})).unwrap();
+    (s, ids, tint, grad)
+}
+
+/// The colour of pattern `name`'s first tile object.
+fn pattern_fill(s: &Session, name: &str) -> Color {
+    s.doc().unwrap().doc.pattern(name).unwrap().art[0].appearance.fill_paint().color().unwrap()
+}
+
+/// K of a colour that prints on the black plate only.
+fn k_only(c: Color) -> f32 {
+    match c {
+        Color::Cmyk { c: 0.0, m: 0.0, y: 0.0, k } => k,
+        other => panic!("not K only: {other:?}"),
+    }
+}
+
+#[test]
+fn document_color_mode_separates_rgb_greys_through_the_profile() {
+    let (mut s, ids, _, _) = greys_document();
+    s.execute("file.documentColorMode", &json!({"mode": "cmyk"})).unwrap();
+    // As Illustrator converts them: four-colour greys and a rich black.
+    let Color::Cmyk { c, m, y, k } = fill_of(&s, ids[2]) else { panic!("not CMYK") };
+    assert!(c > 0.05 && m > 0.05 && y > 0.05 && k > 0.0, "a four-colour mid grey: {c} {m} {y} {k}");
+    let Color::Cmyk { c, k, .. } = fill_of(&s, ids[0]) else { panic!("not CMYK") };
+    assert!(k > 0.9 && c > 0.3, "rich black: {c} {k}");
+    // Pattern tiles are swatches too: their art converts with the rest.
+    assert!(matches!(pattern_fill(&s, "Grey Tile"), Color::Cmyk { .. }), "{:?}", pattern_fill(&s, "Grey Tile"));
+    // Gray colours stay Gray.
+    let mut g = session();
+    let a = rect(&mut g, 0.0, 0.0, 10.0, 10.0);
+    g.execute("paint.setFill", &json!({"ids": [a.0], "color": {"gray": 0.3}})).unwrap();
+    g.execute("file.documentColorMode", &json!({"mode": "cmyk"})).unwrap();
+    assert_eq!(fill_of(&g, a), Color::gray(0.3));
+}
+
+#[test]
+fn document_color_mode_can_put_rgb_greys_on_the_black_plate() {
+    let (mut profile, pids, ..) = greys_document();
+    profile.execute("file.documentColorMode", &json!({"mode": "cmyk"})).unwrap();
+    let (mut s, ids, tint, grad) = greys_document();
+    let e = s.execute("file.documentColorMode", &json!({"mode": "cmyk", "grays": "rich"})).unwrap_err().to_string();
+    assert!(e.contains("grays"), "{e}");
+    s.execute("file.documentColorMode", &json!({"mode": "cmyk", "grays": "black"})).unwrap();
+    let close = |a: f32, b: f32| (a - b).abs() < 0.005;
+    for (id, want) in ids.iter().zip([1.0, 0.8, 0.498, 0.098]) {
+        let k = k_only(fill_of(&s, *id));
+        assert!(close(k, want), "K {k}, want {want}");
+    }
+    // Other colours convert through the profile as before.
+    assert_eq!(fill_of(&s, ids[4]), fill_of(&profile, pids[4]));
+    // Swatches, their tints, gradient stops and pattern tiles follow the same rule.
+    let d = &s.doc().unwrap().doc;
+    assert!(close(k_only(d.swatch("Ink").unwrap().paint.color().unwrap()), 0.498));
+    let Paint::Solid { color, swatch, tint: t } = node(&s, tint).appearance.fill_paint() else { panic!("not solid") };
+    assert!(close(k_only(color), 0.498 * 0.4) && swatch.as_deref() == Some("Ink") && t == 0.4, "{color:?} {swatch:?} {t}");
+    let Paint::Gradient(g) = node(&s, grad).appearance.fill_paint() else { panic!("not a gradient") };
+    let ks: Vec<f32> = g.gradient.stops.iter().map(|st| k_only(st.color)).collect();
+    assert!(close(ks[0], 0.0) && close(ks[1], 0.8), "{ks:?}");
+    assert!(close(k_only(pattern_fill(&s, "Grey Tile")), 0.498));
+    // To RGB, `grays` changes nothing.
+    s.execute("file.documentColorMode", &json!({"mode": "rgb", "grays": "black"})).unwrap();
+    let rgb = s.doc().unwrap().doc.layers.clone();
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("file.documentColorMode", &json!({"mode": "rgb"})).unwrap();
+    assert_eq!(s.doc().unwrap().doc.layers, rgb);
+}
+
+#[test]
+fn opening_in_cmyk_can_put_rgb_greys_on_the_black_plate() {
+    let mut s = session();
+    for hex in ["#000000", "#333333", "#808080", "#e6e6e6", "#ff0000"] {
+        let id = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+        fill(&mut s, id, hex);
+    }
+    let svg = s.execute("document.serialize", &json!({"format": "svg"})).unwrap()["text"].as_str().unwrap().to_string();
+    let data = vectorcraft_format::base64_encode(svg.as_bytes());
+    let mut o = Session::new();
+    o.execute("document.open", &json!({"name": "greys.svg", "dataBase64": data, "colorMode": "cmyk", "grays": "black"})).unwrap();
+    let d = &o.doc().unwrap().doc;
+    assert_eq!(d.color_mode, ColorMode::Cmyk);
+    let mut fills = vec![];
+    for l in &d.layers {
+        l.walk(&mut |n| fills.extend(n.children().is_none().then(|| n.appearance.fill_paint().color()).flatten()));
+    }
+    assert_eq!(fills.len(), 5, "{fills:?}");
+    for (c, want) in fills.iter().zip([1.0, 0.8, 0.498, 0.098]) {
+        let k = k_only(*c);
+        assert!((k - want).abs() < 0.005, "K {k}, want {want}");
+    }
+    assert!(matches!(fills[4], Color::Cmyk { m, y, .. } if m > 0.8 && y > 0.8), "red separates as usual: {:?}", fills[4]);
+    let e = Session::new().execute("document.open", &json!({"name": "greys.svg", "dataBase64": data, "grays": "k"})).unwrap_err().to_string();
+    assert!(e.contains("grays"), "{e}");
+}
+
 #[test]
 fn file_info_sets_title() {
     let mut s = session();

crates/engine/src/tests_panelcmds.rs

@@ -87,6 +87,109 @@ fn artboards_reorder_and_duplicate() {
     assert_eq!(s.doc().unwrap().doc.artboards[0].name, "Second");
 }
 
+/// The artboards' left edges and names.
+fn boards(s: &Session) -> Vec<(f64, String)> {
+    s.doc().unwrap().doc.artboards.iter().map(|a| (a.rect.x0, a.name.clone())).collect()
+}
+
+/// The left edge of object `id`.
+fn left(s: &Session, id: u64) -> f64 {
+    s.doc().unwrap().doc.node(NodeId(id)).unwrap().geometric_bounds().unwrap().x0
+}
+
+fn ids(v: &serde_json::Value) -> Vec<u64> {
+    v.as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect()
+}
+
+/// Duplicate Artboards (#446) copies the art on the artboard too, as the Artboard tool's Move/Copy
+/// Artwork with Artboard says, in one undo step.
+#[test]
+fn duplicate_artboard_copies_its_art() {
+    let mut s = session();
+    let r = rect(&mut s);
+    let out = s.execute("artboard.duplicate", &json!({"index": 0})).unwrap();
+    assert_eq!(out["index"], 1);
+    let copies = ids(&out["ids"]);
+    assert_eq!(copies.len(), 1);
+    assert_ne!(copies[0], r.0);
+    assert_eq!(boards(&s), vec![(0.0, "Artboard 1".into()), (820.0, "Artboard 1 copy".into())]);
+    assert_eq!(left(&s, copies[0]), 830.0, "the copy sits on the new artboard as the original on its own");
+    s.execute("edit.undo", &json!({})).unwrap();
+    let d = &s.doc().unwrap().doc;
+    assert_eq!((d.artboards.len(), d.layers[0].children().unwrap().len()), (1, 1), "one undo step");
+    // Off (the tool's option or the param): the artboard alone.
+    s.set_tool_options(Some("artboard"), json!({"moveArt": false}).as_object().unwrap());
+    assert_eq!(s.execute("artboard.duplicate", &json!({})).unwrap()["ids"], json!([]));
+    assert_eq!(ids(&s.execute("artboard.duplicate", &json!({"index": 0, "art": true})).unwrap()["ids"]).len(), 1);
+}
+
+/// With the Artboard tool, Copy and Paste copy its artboard with the art on it (#446): Paste places
+/// it right of the last artboard, Paste in Place where it was, also in another document; each paste
+/// is one undo step, and the tool takes the pasted artboard.
+#[test]
+fn artboard_tool_copy_and_paste_artboards_with_their_art() {
+    let mut s = session();
+    let r = rect(&mut s);
+    s.execute("artboard.new", &json!({"x": 0, "y": 700, "width": 100, "height": 100, "name": "Small"})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    // Nothing selected: Copy is off, until the Artboard tool is chosen.
+    let copy_enabled = |s: &Session| (crate::find_command("edit.copy").unwrap().enabled)(s).is_ok();
+    assert!(!copy_enabled(&s));
+    s.select_tool("artboard", ViewInfo::default()).unwrap();
+    assert!(copy_enabled(&s));
+    assert_eq!(s.execute("edit.copy", &json!({})).unwrap()["copied"], 1, "artboard 1 and its rectangle");
+    let out = s.execute("edit.paste", &json!({"center": [5, 5]})).unwrap();
+    assert_eq!(out["artboard"], 2);
+    let pasted = ids(&out["ids"]);
+    assert_eq!(left(&s, pasted[0]), 830.0, "beside the artboards, not at the view centre");
+    assert_eq!(boards(&s)[2], (820.0, "Artboard 1 copy".into()));
+    assert_eq!(s.tool_options()["active"], 2);
+    let st = s.doc().unwrap();
+    assert_eq!(st.selection.in_paint_order(&st.doc), vec![NodeId(pasted[0])]);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(boards(&s).len(), 2);
+    assert!(s.doc().unwrap().doc.node(NodeId(pasted[0])).is_none(), "one undo step");
+    // In place: on top of the original.
+    let out = s.execute("edit.pasteInPlace", &json!({})).unwrap();
+    assert_eq!(left(&s, ids(&out["ids"])[0]), 10.0);
+    let d = &s.doc().unwrap().doc;
+    assert_eq!(d.artboards[2].rect, d.artboards[0].rect);
+    // Into another document.
+    s.execute("file.new", &json!({"width": 300, "height": 300})).unwrap();
+    let out = s.execute("edit.paste", &json!({})).unwrap();
+    assert_eq!(boards(&s), vec![(0.0, "Artboard 1".into()), (320.0, "Artboard 1 copy".into())]);
+    let n = s.doc().unwrap().doc.node(NodeId(ids(&out["ids"])[0])).unwrap().geometric_bounds().unwrap();
+    assert_eq!((n.x0, n.width()), (330.0, 100.0));
+    // Paste on All Artboards pastes the art alone.
+    let out = s.execute("edit.pasteOnAllArtboards", &json!({})).unwrap();
+    assert_eq!((out["artboard"].clone(), ids(&out["ids"]).len(), boards(&s).len()), (json!(null), 2, 2));
+    // The clipboard still holds the artboard for the next document, and the original is untouched.
+    s.execute("document.activate", &json!({"index": 0})).unwrap();
+    assert!(s.doc().unwrap().doc.node(r).is_some());
+}
+
+/// With the Artboard tool, Cut takes its artboard and the art on it away in one undo step (#446),
+/// never the only artboard; pasting it back keeps its name.
+#[test]
+fn artboard_tool_cut_removes_the_artboard_and_its_art() {
+    let mut s = session();
+    let r = rect(&mut s);
+    let outside = s.execute("shape.rectangle", &json!({"x": 2000, "y": 0, "width": 10, "height": 10})).unwrap()["id"].as_u64().unwrap();
+    s.select_tool("artboard", ViewInfo::default()).unwrap();
+    assert!(s.execute("edit.cut", &json!({})).is_err(), "the only artboard");
+    s.execute("artboard.new", &json!({"x": 1000, "y": 0, "width": 100, "height": 100})).unwrap();
+    s.set_tool_option("active", &json!(0));
+    s.execute("edit.cut", &json!({})).unwrap();
+    let d = &s.doc().unwrap().doc;
+    assert_eq!((d.artboards.len(), d.node(r).is_none(), d.node(NodeId(outside)).is_some()), (1, true, true));
+    s.execute("edit.pasteInPlace", &json!({})).unwrap();
+    assert_eq!(boards(&s), vec![(1000.0, "Artboard 2".into()), (0.0, "Artboard 1".into())]);
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("edit.undo", &json!({})).unwrap();
+    let d = &s.doc().unwrap().doc;
+    assert_eq!((d.artboards.len(), d.node(r).is_some()), (2, true), "the cut is one undo step");
+}
+
 #[test]
 fn swatch_groups_duplicate_sort() {
     let mut s = session();

crates/engine/src/tests_pathtype.rs

@@ -0,0 +1,219 @@
+//! Type on a path (#429): Type on a Path Options keep its brackets, flip it, align it to the path
+//! and space it; the selection tools drag its brackets to move it along the path and across it.
+
+use serde_json::{Value, json};
+use vectorcraft_doc::{NodeKind, PathAlign, TextKind, TextObject};
+use vectorcraft_geom::{Point, Rect, Shape};
+use vectorcraft_tools::{Mods, PointerEvent, PointerKind};
+
+use super::*;
+
+fn session() -> Session {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
+    s
+}
+
+/// 12 pt type on a path along `d` (SVG path data), starting where the path is nearest `at`.
+fn path_type(s: &mut Session, d: &str, at: [f64; 2], text: &str) -> NodeId {
+    let pid = s.execute("path.create", &json!({ "d": d })).unwrap()["id"].as_u64().unwrap();
+    let r = s.execute("text.createInPath", &json!({"path": pid, "mode": "onPath", "text": text, "size": 12, "at": at})).unwrap();
+    let id = NodeId(r["id"].as_u64().unwrap());
+    s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
+    id
+}
+
+/// Type on the 400 pt line from (100, 300) to (500, 300), from its middle on.
+fn on_line(s: &mut Session) -> NodeId {
+    path_type(s, "M100 300 L500 300", [300.0, 310.0], "Slide")
+}
+
+fn text(s: &Session, id: NodeId) -> TextObject {
+    match &s.doc().unwrap().doc.node(id).unwrap().kind {
+        NodeKind::Text(t) => (**t).clone(),
+        k => panic!("not text: {k:?}"),
+    }
+}
+
+/// The type's start and end brackets as stored.
+fn brackets(s: &Session, id: NodeId) -> (f64, Option<f64>) {
+    match text(s, id).kind {
+        TextKind::OnPath { start, end, .. } => (start, end),
+        k => panic!("not type on a path: {k:?}"),
+    }
+}
+
+/// The glyphs' ink bounds in the document.
+fn ink(s: &Session, id: NodeId) -> Rect {
+    let t = text(s, id);
+    let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t);
+    lay.glyphs
+        .iter()
+        .filter(|g| !g.outline.elements().is_empty())
+        .map(|g| t.xf.transform_rect_bbox(g.outline.bounding_box()))
+        .reduce(|a, b| a.union(b))
+        .unwrap()
+}
+
+/// The glyph origins along the path, in reading order.
+fn origins(s: &Session, id: NodeId) -> Vec<Point> {
+    let t = text(s, id);
+    vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).glyphs.iter().map(|g| t.xf * g.origin).collect()
+}
+
+fn undo_len(s: &Session) -> usize {
+    s.doc().unwrap().history.undo.len()
+}
+
+fn last_step(s: &Session) -> String {
+    s.doc().unwrap().history.undo.last().unwrap().label.clone()
+}
+
+/// Press, drag and release `tool` from `from` to `to`.
+fn drag(s: &mut Session, tool: &str, from: Point, to: Point, mods: Mods) {
+    let v = ViewInfo::default();
+    s.select_tool(tool, v).unwrap();
+    for (kind, p) in [(PointerKind::Down, from), (PointerKind::Drag, to), (PointerKind::Up, to)] {
+        s.pointer(&PointerEvent::new(kind, p.x, p.y).with_mods(mods), v).unwrap();
+    }
+    assert!(!s.in_interaction());
+}
+
+fn near(a: f64, b: f64) -> bool {
+    (a - b).abs() < 1e-3
+}
+
+#[test]
+fn options_keep_the_brackets() {
+    let mut s = session();
+    let id = on_line(&mut s);
+    assert!(near(brackets(&s, id).0, 0.5));
+    // The query (what the dialog shows) has the current options.
+    let mut q = s.execute("type.pathOptions", &json!({})).unwrap();
+    assert!(near(q["start"].as_f64().unwrap(), 0.5), "{q}");
+    q.as_object_mut().unwrap().remove("start");
+    assert_eq!(q, json!({"end": null, "flip": false, "effect": "rainbow", "alignToPath": "baseline", "spacing": 0.0}));
+    let start = brackets(&s, id).0;
+    // OK with the dialog's values (effect, flip, align, spacing) leaves the type where it is.
+    let before = origins(&s, id);
+    s.execute("type.pathOptions", &json!({"effect": "rainbow", "flip": false, "alignToPath": "baseline", "spacing": 0})).unwrap();
+    assert_eq!(brackets(&s, id), (start, None));
+    assert_eq!(origins(&s, id), before);
+    // So does a new effect.
+    s.execute("type.pathOptions", &json!({"effect": "skew"})).unwrap();
+    assert_eq!(brackets(&s, id), (start, None));
+    assert_eq!(text(&s, id).path_effect, vectorcraft_doc::PathEffect::Skew);
+    // The end bracket is set, and put back at the end of the path.
+    s.execute("type.pathOptions", &json!({"end": 0.9})).unwrap();
+    assert_eq!(brackets(&s, id), (start, Some(0.9)));
+    s.execute("type.pathOptions", &json!({"end": null})).unwrap();
+    assert_eq!(brackets(&s, id), (start, None));
+    for bad in [json!({"start": "x"}), json!({"effect": "nope"}), json!({"alignToPath": "top"})] {
+        assert!(s.execute("type.pathOptions", &bad).is_err(), "{bad}");
+    }
+}
+
+#[test]
+fn flip_turns_the_type_to_the_other_side_of_its_stretch() {
+    let mut s = session();
+    let id = on_line(&mut s);
+    let up = ink(&s, id);
+    assert!(up.y1 < 301.0 && up.x0 > 299.0, "above the path from its middle: {up:?}");
+    let n = undo_len(&s);
+    let r = s.execute("type.pathOptions", &json!({"flip": true})).unwrap();
+    assert_eq!(undo_len(&s), n + 1);
+    // The path runs the other way and the brackets swap ends: the type keeps the right half.
+    assert!(near(r["start"].as_f64().unwrap(), 0.0) && near(r["end"].as_f64().unwrap(), 0.5), "{r}");
+    let down = ink(&s, id);
+    assert!(down.y0 > 299.0 && down.x0 > 299.0, "below the path, on the same half: {down:?}");
+    let o = origins(&s, id);
+    assert!(o.first().unwrap().x > o.last().unwrap().x, "reading right to left: {o:?}");
+    // Flipped back, it is as it was.
+    s.execute("type.pathOptions", &json!({"flip": true})).unwrap();
+    let (start, end) = brackets(&s, id);
+    assert!(near(start, 0.5) && end.is_none(), "{start} {end:?}");
+    assert!(ink(&s, id).y1 < 301.0);
+}
+
+#[test]
+fn a_flip_round_a_closed_path_keeps_the_type_in_place() {
+    let mut s = session();
+    let id = path_type(&mut s, "M100 100 L300 100 L300 300 L100 300 Z", [200.0, 90.0], "Ring");
+    let (start, _) = brackets(&s, id);
+    assert!(near(start, 0.125), "{start}");
+    let first = origins(&s, id)[0];
+    s.execute("type.pathOptions", &json!({"flip": true})).unwrap();
+    // Once round from the same point, the other way.
+    let (start, end) = brackets(&s, id);
+    assert!(near(start, 0.875) && end.is_none(), "{start} {end:?}");
+    assert!(origins(&s, id)[0].distance(first) < 8.0);
+}
+
+#[test]
+fn align_to_path_and_spacing() {
+    let mut s = session();
+    let id = on_line(&mut s);
+    s.execute("type.pathOptions", &json!({"alignToPath": "ascender"})).unwrap();
+    assert_eq!(text(&s, id).path_align, PathAlign::Ascender);
+    let hang = ink(&s, id);
+    assert!(hang.y0 > 299.0, "hangs below the path: {hang:?}");
+    s.execute("type.pathOptions", &json!({"alignToPath": "center"})).unwrap();
+    let mid = ink(&s, id);
+    assert!(mid.y0 < 300.0 && mid.y1 > 300.0, "the path runs through it: {mid:?}");
+    // Spacing closes glyphs up round the outside of a curve.
+    let id = path_type(&mut s, "M100 400 A60 60 0 0 1 220 400", [100.0, 400.0], "Round the bend");
+    let spread = |s: &Session| {
+        let o = origins(s, id);
+        o.first().unwrap().distance(*o.last().unwrap())
+    };
+    let loose = spread(&s);
+    s.execute("type.pathOptions", &json!({"spacing": 6})).unwrap();
+    assert!(spread(&s) < loose - 1.0, "{} < {loose}", spread(&s));
+    assert_eq!(s.execute("type.pathOptions", &json!({})).unwrap()["spacing"], json!(6.0));
+}
+
+#[test]
+fn dragging_the_centre_bracket_slides_the_type_and_across_the_path_flips_it() {
+    let mut s = session();
+    let id = on_line(&mut s);
+    let n = undo_len(&s);
+    // The centre bracket stands midway between the start (300) and the end of the path (500).
+    drag(&mut s, "selection", Point::new(400.0, 295.0), Point::new(440.0, 295.0), Mods::default());
+    assert_eq!(undo_len(&s), n + 1, "one step");
+    assert_eq!(last_step(&s), "Move Type on a Path");
+    let (start, end) = brackets(&s, id);
+    assert!(near(start, 0.6) && end.is_none(), "{start} {end:?}");
+    assert!(ink(&s, id).x0 > 339.0);
+    // Direct Selection drags it too; Cmd/Ctrl held below the path only slides it.
+    drag(&mut s, "directSelection", Point::new(420.0, 295.0), Point::new(380.0, 330.0), Mods { cmd: true, ..Mods::default() });
+    let (start, end) = brackets(&s, id);
+    assert!(near(start, 0.5) && end.is_none(), "{start} {end:?}");
+    assert!(ink(&s, id).y1 < 301.0, "still above the path");
+    // Across the path: flipped, on the same stretch.
+    drag(&mut s, "selection", Point::new(400.0, 295.0), Point::new(400.0, 330.0), Mods::default());
+    assert_eq!(undo_len(&s), n + 3);
+    let (start, end) = brackets(&s, id);
+    assert!(near(start, 0.0) && end.is_some_and(|e| near(e, 0.5)), "{start} {end:?}");
+    assert!(ink(&s, id).y0 > 299.0, "below the path");
+    // The step undoes as one.
+    s.execute("edit.undo", &json!({})).unwrap();
+    let (start, end) = brackets(&s, id);
+    assert!(near(start, 0.5) && end.is_none(), "{start} {end:?}");
+}
+
+#[test]
+fn dragging_the_start_and_end_brackets_sets_where_the_type_runs() {
+    let mut s = session();
+    let id = on_line(&mut s);
+    // The start bracket from the middle (300) to 200.
+    drag(&mut s, "selection", Point::new(300.0, 290.0), Point::new(200.0, 290.0), Mods::default());
+    assert!(near(brackets(&s, id).0, 0.25));
+    // The end bracket from the end of the path to 400.
+    drag(&mut s, "directSelection", Point::new(500.0, 290.0), Point::new(400.0, 290.0), Mods::default());
+    let (start, end) = brackets(&s, id);
+    assert!(near(start, 0.25) && end.is_some_and(|e| near(e, 0.75)), "{start} {end:?}");
+    let v: Value = s.execute("type.pathOptions", &json!({})).unwrap();
+    assert!(near(v["end"].as_f64().unwrap(), 0.75));
+    let r = ink(&s, id);
+    assert!(r.x0 > 199.0 && r.x1 < 401.0, "between the brackets: {r:?}");
+}

crates/engine/src/tests_prefs.rs

@@ -1,6 +1,6 @@
 //! Preferences: `prefs.get` / `prefs.set` / `prefs.reset` / `prefs.list`.
 
-use serde_json::json;
+use serde_json::{Value, json};
 
 use super::*;
 use crate::cmd::prefscmds::{PREF_CATEGORIES, PREF_GROUPS, PREF_SPECS, validate};
@@ -152,3 +152,412 @@ fn gpu_preference_defaults_to_power_saving_and_validates() {
     s.execute("prefs.reset", &json!({"category": "Performance"})).unwrap();
     assert_eq!(s.prefs.gpu_preference, "powerSaving");
 }
+
+/// Selection & Anchor Display › Tolerance, Object Selection by Path Only and Command Click to
+/// Select Objects Behind, and General › Double Click To Isolate, as the Selection tool sees them
+/// (#394).
+#[test]
+fn selection_preferences_drive_the_selection_tool() {
+    use vectorcraft_tools::{Mods, PointerEvent, PointerKind};
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+    let rect = |s: &mut Session, x: f64| {
+        NodeId(s.execute("shape.rectangle", &json!({"x": x, "y": 100, "width": 100, "height": 100})).unwrap()["id"].as_u64().unwrap())
+    };
+    // Two filled squares overlapping between x = 150 and 200, `front` on top.
+    let (back, front) = (rect(&mut s, 100.0), rect(&mut s, 150.0));
+    s.select_tool("selection", ViewInfo::default()).unwrap();
+    let set = |s: &mut Session, key: &str, value: Value| s.execute("prefs.set", &json!({"key": key, "value": value})).unwrap();
+    let click = |s: &mut Session, x: f64, mods: Mods| {
+        for k in [PointerKind::Down, PointerKind::Up] {
+            // Halfway between the bounding box's handles.
+            s.pointer(&PointerEvent::new(k, x, 125.0).with_mods(mods), ViewInfo::default()).unwrap();
+        }
+        s.doc().unwrap().selection.objects.clone()
+    };
+    let plain = Mods::default();
+    // Tolerance: the right edge's stroke ends at x = 250.5.
+    assert_eq!(click(&mut s, 252.5, plain), vec![front], "2 px out: within the default 3 px");
+    assert!(click(&mut s, 256.5, plain).is_empty(), "6 px out: beyond 3 px");
+    set(&mut s, "selectionTolerance", json!(8));
+    assert_eq!(click(&mut s, 256.5, plain), vec![front], "6 px out: within 8 px");
+    set(&mut s, "selectionTolerance", json!(1));
+    assert!(click(&mut s, 252.5, plain).is_empty(), "2 px out: beyond 1 px");
+    set(&mut s, "selectionTolerance", json!(3));
+    // Object Selection by Path Only: the fill no longer selects, the path does.
+    assert_eq!(click(&mut s, 225.0, plain), vec![front]);
+    set(&mut s, "objectSelectionByPathOnly", json!(true));
+    assert!(click(&mut s, 225.0, plain).is_empty(), "a click inside the fill selects nothing");
+    assert_eq!(click(&mut s, 250.0, plain), vec![front], "a click on the path selects it");
+    set(&mut s, "objectSelectionByPathOnly", json!(false));
+    // Command Click to Select Objects Behind (on by default): each Cmd/Ctrl-click goes one down,
+    // then back to the top.
+    let cmd = Mods { cmd: true, ..Mods::default() };
+    assert_eq!(click(&mut s, 175.0, plain), vec![front]);
+    assert_eq!(click(&mut s, 175.0, cmd), vec![back], "the object behind");
+    assert_eq!(click(&mut s, 175.0, cmd), vec![front], "back to the topmost");
+    set(&mut s, "ctrlClickSelectsBehind", json!(false));
+    assert_eq!(click(&mut s, 175.0, cmd), vec![front], "off: a plain click");
+    // Double Click To Isolate (on by default) isolates a group; off, it doesn't.
+    s.execute("select.all", &json!({})).unwrap();
+    s.execute("object.group", &json!({})).unwrap();
+    let double = |s: &mut Session| {
+        s.pointer(&PointerEvent::new(PointerKind::DoubleClick, 175.0, 150.0), ViewInfo::default()).unwrap();
+        s.doc().unwrap().isolation
+    };
+    set(&mut s, "doubleClickToIsolate", json!(false));
+    assert_eq!(double(&mut s), None, "off: no isolation");
+    set(&mut s, "doubleClickToIsolate", json!(true));
+    assert!(double(&mut s).is_some(), "on: the group is isolated");
+}
+
+/// General › Use Precise Cursors (#394): the Pen's pointer becomes a crosshair; the Selection
+/// tool's arrow stays.
+#[test]
+fn use_precise_cursors_makes_drawing_cursors_crosshairs() {
+    use vectorcraft_tools::{Cursor, Mods};
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+    let cursor = |s: &mut Session, tool: &str| {
+        s.select_tool(tool, ViewInfo::default()).unwrap();
+        s.cursor(vectorcraft_geom::Point::new(300.0, 300.0), Mods::default(), ViewInfo::default())
+    };
+    assert_eq!(cursor(&mut s, "pen"), Cursor::Pen);
+    s.execute("prefs.set", &json!({"key": "usePreciseCursors", "value": true})).unwrap();
+    assert_eq!(cursor(&mut s, "pen"), Cursor::Crosshair);
+    assert_eq!(cursor(&mut s, "selection"), Cursor::Arrow);
+}
+
+// ---------- #394, second batch ----------
+
+fn new_doc() -> Session {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+    s
+}
+
+fn square(s: &mut Session, x: f64, y: f64) -> NodeId {
+    NodeId(s.execute("shape.rectangle", &json!({"x": x, "y": y, "width": 50, "height": 50})).unwrap()["id"].as_u64().unwrap())
+}
+
+fn set_pref(s: &mut Session, key: &str, value: Value) {
+    s.execute("prefs.set", &json!({"key": key, "value": value})).unwrap();
+}
+
+fn gesture(s: &mut Session, v: ViewInfo, events: &[(vectorcraft_tools::PointerKind, f64, f64)]) {
+    for (k, x, y) in events {
+        s.pointer(&vectorcraft_tools::PointerEvent::new(*k, *x, *y), v).unwrap();
+    }
+}
+
+fn top_left(s: &Session, id: NodeId) -> (f64, f64) {
+    let b = s.doc().unwrap().doc.node(id).unwrap().geometric_bounds().unwrap();
+    (b.x0, b.y0)
+}
+
+/// View › Snap to Point with Selection & Anchor Display › Snap to Point's distance (#394): with
+/// Smart Guides off, the point a selection is dragged by lands on an anchor within 2 px.
+#[test]
+fn snap_to_point_lands_a_dragged_selection_on_anchors() {
+    use vectorcraft_tools::PointerKind::{Down, Drag, Up};
+    let mut s = new_doc();
+    let a = square(&mut s, 100.0, 100.0);
+    square(&mut s, 300.0, 100.0);
+    let v = ViewInfo { smart_guides: false, ..ViewInfo::default() };
+    s.select_tool("selection", v).unwrap();
+    // Grabbed by its centre and dropped 1.5, 1 px from the other square's top-left anchor.
+    let drag = |s: &mut Session, v: ViewInfo| {
+        gesture(s, v, &[(Down, 125.0, 125.0), (Drag, 200.0, 110.0), (Drag, 301.5, 101.0), (Up, 301.5, 101.0)]);
+        let at = top_left(s, a);
+        s.execute("edit.undo", &json!({})).unwrap();
+        at
+    };
+    assert_eq!(drag(&mut s, v), (275.0, 75.0), "the centre lands on the anchor");
+    set_pref(&mut s, "snapToPointTolerance", json!(1));
+    assert_eq!(drag(&mut s, v), (276.5, 76.0), "1.8 px is beyond 1 px");
+    set_pref(&mut s, "snapToPointTolerance", json!(2));
+    assert_eq!(drag(&mut s, ViewInfo { snap_to_point: false, ..v }), (276.5, 76.0), "View › Snap to Point off");
+}
+
+/// Preferences › Smart Guides (#394): Color, Alignment Guides, Anchor/Path Labels, Measurement
+/// Labels, Transform Tools and Snapping Tolerance change what the Selection tool shows while a
+/// square is dragged into line with another, and how far the pull reaches; a hidden guide still
+/// snaps.
+#[test]
+fn smart_guide_display_preferences_filter_the_overlays() {
+    use vectorcraft_tools::Overlay;
+    use vectorcraft_tools::PointerKind::{Down, Drag, Up};
+    let mut s = new_doc();
+    square(&mut s, 100.0, 100.0);
+    let b = square(&mut s, 200.0, 100.0);
+    let v = ViewInfo::default();
+    s.select_tool("selection", v).unwrap();
+    let count = |s: &mut Session, f: &dyn Fn(&Overlay) -> bool| s.overlays(v).iter().filter(|o| f(o)).count();
+    let line = |o: &Overlay| matches!(o, Overlay::Line { .. });
+    let label = |o: &Overlay| matches!(o, Overlay::Label { .. });
+    let measure = |o: &Overlay| matches!(o, Overlay::Measure { .. });
+    // `b` grabbed by its centre and dragged so its left edge comes `off` px from the first
+    // square's right edge (x = 150): the x of its left edge mid-drag, before the pointer is let go.
+    let drag_to = |s: &mut Session, off: f64| {
+        gesture(s, v, &[(Down, 225.0, 125.0), (Drag, 200.0, 125.0), (Drag, 175.0 + off, 125.0)]);
+        top_left(s, b).0
+    };
+    let release = |s: &mut Session| {
+        gesture(s, v, &[(Up, 175.0, 125.0)]);
+        s.execute("edit.undo", &json!({})).unwrap();
+    };
+    assert_eq!(drag_to(&mut s, 3.0), 150.0, "3 px off: into line");
+    assert!(count(&mut s, &line) > 0 && count(&mut s, &measure) == 1);
+    let magenta = s.overlays(v).iter().find_map(|o| if let Overlay::Line { color, .. } = o { Some(*color) } else { None });
+    assert_eq!(magenta, Some(vectorcraft_tools::guides::MAGENTA), "the default colour");
+    release(&mut s);
+    set_pref(&mut s, "smartGuideColor", json!("#00ff00"));
+    drag_to(&mut s, 3.0);
+    assert!(s.overlays(v).iter().all(|o| !matches!(o, Overlay::Line { color, .. } | Overlay::Label { color, .. } if *color != [0, 255, 0])));
+    release(&mut s);
+    set_pref(&mut s, "alignmentGuides", json!(false));
+    assert_eq!(drag_to(&mut s, 3.0), 150.0, "still into line");
+    assert_eq!(count(&mut s, &line), 0, "no line");
+    release(&mut s);
+    set_pref(&mut s, "measurementLabels", json!(false));
+    drag_to(&mut s, 3.0);
+    assert_eq!(count(&mut s, &measure), 0);
+    release(&mut s);
+    // Snapping Tolerance: 6 px is beyond the default 4, within 8.
+    assert_eq!(drag_to(&mut s, 6.0), 156.0);
+    release(&mut s);
+    set_pref(&mut s, "snappingTolerance", json!(8));
+    assert_eq!(drag_to(&mut s, 6.0), 150.0);
+    release(&mut s);
+    // Transform Tools: the size readout while a bounding-box handle is dragged.
+    let scale = |s: &mut Session| {
+        gesture(s, v, &[(Down, 225.0, 150.0), (Drag, 225.0, 170.0)]);
+        let n = count(s, &measure);
+        gesture(s, v, &[(Up, 225.0, 170.0)]);
+        s.execute("edit.undo", &json!({})).unwrap();
+        n
+    };
+    assert_eq!(scale(&mut s), 1);
+    set_pref(&mut s, "transformToolsGuides", json!(false));
+    assert_eq!(scale(&mut s), 0);
+    // Anchor/Path Labels: a drawn corner pulled onto an anchor says "anchor" (and still lands there).
+    s.select_tool("rectangle", v).unwrap();
+    let draw = |s: &mut Session| {
+        gesture(s, v, &[(Down, 300.0, 300.0), (Drag, 153.0, 151.0)]);
+        let n = count(s, &label);
+        gesture(s, v, &[(Up, 153.0, 151.0)]);
+        let at = top_left(s, s.doc().unwrap().selection.objects[0]);
+        s.execute("edit.undo", &json!({})).unwrap();
+        (n, at)
+    };
+    assert_eq!(draw(&mut s), (1, (150.0, 150.0)));
+    set_pref(&mut s, "anchorPathLabels", json!(false));
+    assert_eq!(draw(&mut s), (0, (150.0, 150.0)));
+}
+
+/// Enable Rubber Band for Pen Tool / Curvature Tool (#394): off, no segment follows the pointer.
+#[test]
+fn rubber_band_preferences_hide_the_preview_to_the_pointer() {
+    use vectorcraft_tools::Overlay;
+    use vectorcraft_tools::PointerKind::{Down, Move, Up};
+    let v = ViewInfo::default();
+    for (tool, key) in [("pen", "penRubberBand"), ("curvature", "curvatureRubberBand")] {
+        let mut s = new_doc();
+        s.select_tool(tool, v).unwrap();
+        gesture(&mut s, v, &[(Down, 50.0, 50.0), (Up, 50.0, 50.0), (Down, 150.0, 50.0), (Up, 150.0, 50.0), (Move, 200.0, 150.0)]);
+        let bands = |s: &mut Session| s.overlays(v).iter().filter(|o| matches!(o, Overlay::Path { .. })).count();
+        assert_eq!(bands(&mut s), 1, "{tool}: the rubber band");
+        set_pref(&mut s, key, json!(false));
+        assert_eq!(bands(&mut s), 0, "{tool}: off");
+    }
+}
+
+/// Move Locked and Hidden Artwork with Artboard (#394): off, an artboard moved with its art
+/// leaves locked and hidden objects where they are; on, they move too.
+#[test]
+fn move_locked_and_hidden_artwork_with_artboard() {
+    let mut s = new_doc();
+    let (free, locked, hidden) = (square(&mut s, 10.0, 10.0), square(&mut s, 100.0, 10.0), square(&mut s, 200.0, 10.0));
+    for (id, cmd) in [(locked, "object.lock"), (hidden, "object.hide")] {
+        s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
+        s.execute(cmd, &json!({})).unwrap();
+    }
+    let moved = |s: &mut Session| {
+        s.execute("artboard.move", &json!({"index": 0, "dx": 30, "dy": 0, "moveArt": true})).unwrap();
+        let xs = [free, locked, hidden].map(|id| top_left(s, id).0);
+        s.execute("edit.undo", &json!({})).unwrap();
+        xs
+    };
+    assert_eq!(moved(&mut s), [40.0, 100.0, 200.0]);
+    set_pref(&mut s, "moveLockedWithArtboard", json!(true));
+    assert_eq!(moved(&mut s), [40.0, 130.0, 230.0]);
+}
+
+/// General › Transform Pattern Tiles (#394) is what transforms do with pattern fills unless their
+/// `patterns` param says otherwise (the dialogs' Transform Patterns).
+#[test]
+fn transform_pattern_tiles_is_the_transforms_default() {
+    use vectorcraft_color::Paint;
+    let mut s = new_doc();
+    let tile = square(&mut s, 0.0, 0.0);
+    s.execute("select.set", &json!({"ids": [tile.0]})).unwrap();
+    s.execute("object.pattern.make", &json!({"name": "Dots", "width": 20, "height": 20})).unwrap();
+    s.execute("object.pattern.done", &json!({})).unwrap();
+    let big = square(&mut s, 100.0, 100.0);
+    s.execute("paint.setFill", &json!({"ids": [big.0], "swatch": "Dots"})).unwrap();
+    s.execute("select.set", &json!({"ids": [big.0]})).unwrap();
+    let tiles = |s: &Session| match s.doc().unwrap().doc.node(big).unwrap().appearance.fill_paint() {
+        Paint::Pattern { xf, .. } => xf.as_coeffs(),
+        p => panic!("not a pattern: {p:?}"),
+    };
+    s.execute("object.move", &json!({"dx": 10, "dy": 0})).unwrap();
+    assert_eq!(tiles(&s), [1.0, 0.0, 0.0, 1.0, 0.0, 0.0], "off: the tiles stay");
+    set_pref(&mut s, "transformPatternTiles", json!(true));
+    s.execute("object.move", &json!({"dx": 10, "dy": 0})).unwrap();
+    assert_eq!(tiles(&s), [1.0, 0.0, 0.0, 1.0, 10.0, 0.0], "on: they move with the art");
+    assert_eq!(s.journal.last().unwrap().1["patterns"], json!(true), "the journal keeps the choice");
+    s.execute("object.scale", &json!({"sx": 200, "origin": [0, 0], "patterns": false})).unwrap();
+    assert_eq!(tiles(&s), [1.0, 0.0, 0.0, 1.0, 10.0, 0.0], "the param wins");
+    s.execute("object.scale", &json!({"sx": 50, "origin": [0, 0]})).unwrap();
+    assert_eq!(tiles(&s), [0.5, 0.0, 0.0, 0.5, 5.0, 0.0]);
+}
+
+/// General › Select Same Tint % (#394): off, Select › Same › Fill Color takes every tint of the
+/// swatch; on, only the same tint.
+#[test]
+fn select_same_tint_percent() {
+    let mut s = new_doc();
+    s.execute("swatch.new", &json!({"name": "Ink", "color": "#cc0066", "spot": true})).unwrap();
+    // Before the others: new art takes the last fill applied.
+    square(&mut s, 300.0, 10.0);
+    let ids: Vec<NodeId> = [(10.0, 40), (100.0, 40), (200.0, 80)]
+        .into_iter()
+        .map(|(x, tint)| {
+            let id = square(&mut s, x, 10.0);
+            s.execute("paint.setFill", &json!({"ids": [id.0], "swatch": "Ink", "tint": tint})).unwrap();
+            id
+        })
+        .collect();
+    let same = |s: &mut Session| {
+        s.execute("select.set", &json!({"ids": [ids[0].0]})).unwrap();
+        s.execute("select.same.fillColor", &json!({})).unwrap();
+        s.doc().unwrap().selection.objects.len()
+    };
+    assert_eq!(same(&mut s), 3, "every tint of Ink");
+    set_pref(&mut s, "selectSameTintPercent", json!(true));
+    assert_eq!(same(&mut s), 2, "only Ink 40%");
+}
+
+fn style_at(s: &Session, id: NodeId, byte: usize) -> vectorcraft_doc::CharStyle {
+    let Some(vectorcraft_doc::NodeKind::Text(t)) = s.doc().unwrap().doc.node(id).map(|n| &n.kind) else { panic!("not text") };
+    let mut at = 0;
+    for r in &t.runs {
+        if byte < at + r.text.len() {
+            return r.style.clone();
+        }
+        at += r.text.len();
+    }
+    panic!("byte {byte} past the text")
+}
+
+/// Type › Size/Leading, Tracking and Baseline Shift (#394): the increments `type.step` and the
+/// font size shortcuts step by, on selected type objects and on the Type tool's selected text
+/// (Alt+arrows; Cmd/Ctrl too: five steps).
+#[test]
+fn type_increments_step_the_type() {
+    use vectorcraft_tools::PointerKind::{Down, Up};
+    use vectorcraft_tools::{Mods, ToolKey};
+    let mut s = new_doc();
+    let id = NodeId(s.execute("text.create", &json!({"x": 100, "y": 100, "text": "Hello world", "size": 20})).unwrap()["id"].as_u64().unwrap());
+    s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
+    s.execute("type.size.increase", &json!({})).unwrap();
+    assert_eq!(style_at(&s, id, 0).size, 22.0, "Size/Leading is 2 pt");
+    set_pref(&mut s, "typeSizeIncrement", json!(3));
+    s.execute("type.size.decrease", &json!({})).unwrap();
+    assert_eq!(style_at(&s, id, 0).size, 19.0);
+    s.execute("type.step", &json!({"attribute": "leading"})).unwrap();
+    assert!((style_at(&s, id, 0).leading.unwrap() - (19.0 * 1.2 + 3.0)).abs() < 1e-9, "from Auto");
+    set_pref(&mut s, "baselineShiftIncrement", json!(1.5));
+    s.execute("type.step", &json!({"attribute": "baselineShift", "by": -2})).unwrap();
+    assert_eq!(style_at(&s, id, 10).baseline_shift, -3.0);
+    // The Type tool: Alt+→ tracks the selected text by Tracking (20/1000 em), Cmd-Alt five times.
+    let v = ViewInfo::default();
+    s.select_tool("type", v).unwrap();
+    gesture(&mut s, v, &[(Down, 102.0, 95.0), (Up, 102.0, 95.0)]);
+    assert_eq!(s.tool_options()["editing"], json!(id.0), "editing the text");
+    let alt = Mods { alt: true, ..Mods::default() };
+    let select = |s: &mut Session, a: usize, b: usize| s.set_tool_option("select", &json!({"start": a, "end": b}));
+    select(&mut s, 0, 5);
+    s.tool_key(ToolKey::Right, alt, v).unwrap();
+    assert_eq!((style_at(&s, id, 0).tracking, style_at(&s, id, 6).tracking), (20.0, 0.0));
+    s.tool_key(ToolKey::Left, Mods { cmd: true, ..alt }, v).unwrap();
+    assert_eq!(style_at(&s, id, 4).tracking, -80.0);
+    // At a caret: Alt+← kerns the character before it, Alt+↓ opens up the paragraph's leading.
+    select(&mut s, 3, 3);
+    s.tool_key(ToolKey::Left, alt, v).unwrap();
+    assert_eq!((style_at(&s, id, 2).kerning, style_at(&s, id, 3).kerning), (Some(-20.0), None));
+    let leading = style_at(&s, id, 0).leading.unwrap();
+    s.tool_key(ToolKey::Down, alt, v).unwrap();
+    assert_eq!(style_at(&s, id, 8).leading, Some(leading + 3.0));
+    // Alt+Shift+↑ raises the selected text's baseline.
+    select(&mut s, 6, 11);
+    s.tool_key(ToolKey::Up, Mods { shift: true, ..alt }, v).unwrap();
+    assert_eq!((style_at(&s, id, 0).baseline_shift, style_at(&s, id, 6).baseline_shift), (-3.0, -1.5));
+    // The font size shortcut steps the selected text while the tool edits.
+    s.execute("type.size.increase", &json!({})).unwrap();
+    assert_eq!((style_at(&s, id, 0).size, style_at(&s, id, 6).size), (19.0, 22.0));
+}
+
+/// Type › Fill New Type Objects With Placeholder Text (#394, on by default): type the Type tool
+/// places starts with placeholder text, selected, so typing replaces it; off, it starts empty.
+#[test]
+fn new_type_starts_with_placeholder_text() {
+    use vectorcraft_tools::PointerKind::{Down, Drag, Up};
+    let v = ViewInfo::default();
+    let mut s = new_doc();
+    s.select_tool("type", v).unwrap();
+    let text = |s: &Session| {
+        let st = s.doc().unwrap();
+        match &st.doc.node(st.selection.objects[0]).unwrap().kind {
+            vectorcraft_doc::NodeKind::Text(t) => t.plain_text(),
+            _ => panic!("not text"),
+        }
+    };
+    gesture(&mut s, v, &[(Down, 50.0, 50.0), (Up, 50.0, 50.0)]);
+    let placeholder = text(&s);
+    assert!(placeholder.len() > 10, "{placeholder}");
+    assert_eq!((s.tool_options()["start"].clone(), s.tool_options()["end"].clone()), (json!(0), json!(placeholder.len())), "selected");
+    s.tool_text("Hi", v).unwrap();
+    assert_eq!(text(&s), "Hi");
+    // Area type is filled to its frame.
+    gesture(&mut s, v, &[(Down, 100.0, 150.0), (Drag, 300.0, 300.0), (Up, 300.0, 300.0)]);
+    assert!(text(&s).len() > placeholder.len());
+    set_pref(&mut s, "placeholderText", json!(false));
+    gesture(&mut s, v, &[(Down, 50.0, 350.0), (Up, 50.0, 350.0)]);
+    assert_eq!(text(&s), "");
+}
+
+/// Type › Enable Missing Glyph Protection (#394, on by default): characters a new font has no
+/// glyph for keep the font that has one; off, they take the new font.
+#[test]
+fn missing_glyph_protection_keeps_glyphs_a_new_font_lacks() {
+    let (from, to, c) = ("Source Sans 3", "JetBrains Mono", '\u{180}');
+    let db = vectorcraft_text::FontDb::global();
+    let covers = |f: &str| db.face(f, "Regular").is_some_and(|face| face.covers(c));
+    if !covers(from) || covers(to) {
+        return; // Installed fonts of these names cover other characters.
+    }
+    let mut s = new_doc();
+    let id = NodeId(s.execute("text.create", &json!({"x": 10, "y": 50, "text": "a\u{180}c", "font": from})).unwrap()["id"].as_u64().unwrap());
+    s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
+    let fonts = |s: &Session| [0, 1, 3].map(|b| style_at(s, id, b).font_family);
+    s.execute("text.setStyle", &json!({"font": to})).unwrap();
+    assert_eq!(fonts(&s), [to, from, to], "the character keeps its font");
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("text.setRangeStyle", &json!({"id": id.0, "start": 1, "end": 4, "font": to})).unwrap();
+    assert_eq!(fonts(&s), [from, from, to]);
+    s.execute("edit.undo", &json!({})).unwrap();
+    set_pref(&mut s, "missingGlyphProtection", json!(false));
+    s.execute("text.setStyle", &json!({"font": to})).unwrap();
+    assert_eq!(fonts(&s), [to, to, to]);
+}

crates/engine/src/tests_strokeux.rs

@@ -73,7 +73,7 @@ fn stroke_unit_follows_the_preference() {
     assert_eq!(s.stroke_unit(), Unit::Points);
     s.prefs.units_stroke = "millimeters".into();
     assert_eq!(s.stroke_unit(), Unit::Millimeters);
-    assert_eq!(s.stroke_unit().format(1.0), "0.353 mm");
+    assert_eq!(s.stroke_unit().format(1.0), "0.3528 mm");
 }
 
 #[test]

crates/engine/src/tests_textedit.rs

@@ -9,7 +9,9 @@ use vectorcraft_tools::{Mods, PointerEvent, PointerKind, ToolKey};
 use super::*;
 
 fn session() -> Session {
+    // Type placed by the Type tools starts empty (Fill New Type Objects With Placeholder Text off).
     let mut s = Session::new();
+    s.prefs.placeholder_text = false;
     s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
     s
 }
@@ -310,15 +312,18 @@ fn character_panel_flow_styles_the_selected_range_while_editing() {
 fn select_all_and_cut_like_ui() {
     let mut s = session();
     let v = ViewInfo::default();
+    s.execute("shape.rectangle", &json!({"x": 300, "y": 300, "width": 10, "height": 10})).unwrap();
     let id = text(&mut s, "abc def");
     s.select_tool("type", v).unwrap();
     let t = obj(&s, id);
     let p = t.xf * Point::new(2.0, -5.0);
     click(&mut s, p.x, p.y);
-    s.set_tool_option("selectAll", &json!(true));
-    let o = s.tool_options();
-    let len = obj(&s, id).plain_text().len() as u64;
-    let r = s.execute("text.getRange", &json!({"id": o["editing"], "start": o["start"], "end": o["end"].as_u64().unwrap().min(len)})).unwrap();
+    // Select All while editing takes the text, not the art (the rectangle stays unselected).
+    assert!(s.tool_wants_text());
+    let o = s.execute("select.all", &json!({})).unwrap();
+    assert_eq!(o, json!({"editing": id.0, "start": 0, "end": 7}));
+    assert_eq!(s.doc().unwrap().selection.objects, [id]);
+    let r = s.execute("text.getRange", &json!({"id": o["editing"], "start": o["start"], "end": o["end"]})).unwrap();
     assert_eq!(r["text"], json!("abc def"));
     s.set_tool_option("copy", &r["runs"]);
     key(&mut s, ToolKey::Delete, Mods::default());
@@ -326,6 +331,10 @@ fn select_all_and_cut_like_ui() {
     s.tool_text("abc def", v).unwrap();
     s.tool_text("abc def", v).unwrap();
     assert_eq!(obj(&s, id).plain_text(), "abc defabc def");
+    // Not editing: Select All selects the art again.
+    key(&mut s, ToolKey::Escape, Mods::default());
+    assert!(!s.tool_wants_text());
+    assert_eq!(s.execute("select.all", &json!({})).unwrap(), json!({"count": 2}));
 }
 
 #[test]

crates/engine/src/tests_typearea.rs

@@ -1,6 +1,6 @@
 //! Resizing area type (#252): a bounding-box handle drag and Area Type Options size the type area
 //! and the text reflows at its size; Direct Selection reshapes the frame by a corner or an edge.
-//! Point type still scales.
+//! Point type still scales. The type widget converts point type to area type and back.
 
 use serde_json::{Value, json};
 use vectorcraft_doc::{NodeKind, TextKind, TextObject};
@@ -267,3 +267,75 @@ fn reshape_area_is_a_registered_command() {
     assert!(cmd::find_command("object.transform").unwrap().params.contains("typeAreas"));
     assert!(session().commands().iter().any(|c| c.id == "text.reshapeArea" && c.enabled));
 }
+
+/// The Discord report: type in a frame dragged with the Type tool, then the Selection tool. Its
+/// bounding box resizes the type area (the text reflows at its size), it doesn't scale the type.
+#[test]
+fn type_in_a_dragged_frame_resizes_with_the_selection_tool() {
+    let mut s = session();
+    drag(&mut s, "type", Point::new(40.0, 40.0), Point::new(160.0, 80.0));
+    let v = ViewInfo::default();
+    s.tool_text(STORY, v).unwrap();
+    s.select_tool("selection", v).unwrap();
+    let id = s.doc().unwrap().selection.objects[0];
+    assert_eq!(frame(&s, id), Rect::new(0.0, 0.0, 120.0, 40.0));
+    let lines = layout(&s, id).lines.len();
+    drag(&mut s, "selection", Point::new(160.0, 80.0), Point::new(200.0, 140.0));
+    assert_eq!(last_step(&s), "Resize Type Area");
+    assert_eq!(frame(&s, id), Rect::new(0.0, 0.0, 160.0, 100.0));
+    assert_eq!(text(&s, id).xf, Affine::translate((40.0, 40.0)), "the type isn't scaled");
+    assert!(layout(&s, id).lines.len() > lines, "the text reflows into the larger area");
+}
+
+/// The type widget beside the selected type's bounding box (as the Selection tool shows it at
+/// the default view).
+fn widget(s: &Session) -> vectorcraft_tools::typewidget::TypeWidget {
+    let st = s.doc().unwrap();
+    let bx = s.transform_box(&st.selection.objects).unwrap();
+    vectorcraft_tools::typewidget::TypeWidget::of(&st.doc, &st.selection, &bx, ViewInfo::default().zoom).unwrap()
+}
+
+fn double_click(s: &mut Session, p: Point) {
+    let v = ViewInfo::default();
+    s.select_tool("selection", v).unwrap();
+    for kind in [PointerKind::Down, PointerKind::Up, PointerKind::Down, PointerKind::Up, PointerKind::DoubleClick] {
+        s.pointer(&PointerEvent::new(kind, p.x, p.y).with_mods(Mods::default()), v).unwrap();
+    }
+}
+
+/// Double-clicking the type widget converts point type to area type and back, each one undo
+/// step, keeping the text, its styles and where it stands; the selection stays.
+#[test]
+fn the_type_widget_converts_point_and_area_type() {
+    let mut s = session();
+    let id = id_of(&s.execute("text.create", &json!({"x": 40, "y": 100, "size": 18, "text": "Two words"})).unwrap());
+    s.execute("text.setRangeStyle", &json!({"id": id.0, "start": 4, "end": 9, "size": 24})).unwrap();
+    sel(&mut s, &[id]);
+    let before = text(&s, id);
+    let glyph = |t: &TextObject| t.xf * vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).glyphs[0].origin;
+    let w = widget(&s);
+    assert!(!w.area);
+    let n = undo_len(&s);
+    double_click(&mut s, w.at);
+    assert_eq!(undo_len(&s), n + 1, "one step");
+    assert_eq!(last_step(&s), "Convert To Area Type");
+    let t = text(&s, id);
+    assert!(matches!(t.kind, TextKind::Area { .. }));
+    assert_eq!((t.plain_text(), &t.runs), (before.plain_text(), &before.runs), "the text and its styles stay");
+    assert!(glyph(&t).distance(glyph(&before)) < 0.01, "the type stays where it was");
+    assert!(!layout(&s, id).overflow);
+    assert_eq!(s.doc().unwrap().selection.objects, vec![id]);
+    // Now area type: a filled widget, and a double-click turns it back into point type.
+    let w = widget(&s);
+    assert!(w.area);
+    double_click(&mut s, w.at);
+    assert_eq!(undo_len(&s), n + 2);
+    assert_eq!(last_step(&s), "Convert To Point Type");
+    let t = text(&s, id);
+    assert!(matches!(t.kind, TextKind::Point));
+    assert_eq!(t.runs, before.runs);
+    assert!(glyph(&t).distance(glyph(&before)) < 0.01);
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(text(&s, id), before);
+}

crates/engine/src/tooling.rs

@@ -13,6 +13,8 @@ pub struct ViewInfo {
     pub zoom: f64,
     pub outline: bool,
     pub smart_guides: bool,
+    /// View → Show Guides: the ruler guides show (and, unlocked, can be picked).
+    pub guides: bool,
     pub snap_to_grid: bool,
     pub show_bbox: bool,
     /// View → Snap to Pixel: drawing and moving land on whole pixels (points at 72 ppi).
@@ -31,6 +33,7 @@ impl Default for ViewInfo {
             zoom: 1.0,
             outline: false,
             smart_guides: true,
+            guides: true,
             snap_to_grid: false,
             show_bbox: true,
             snap_to_pixel: false,
@@ -41,6 +44,14 @@ impl Default for ViewInfo {
     }
 }
 
+/// The RGB of a colour preference (`#rrggbb`), or `fallback` when it doesn't parse.
+fn rgb(hex: &str, fallback: [u8; 3]) -> [u8; 3] {
+    vectorcraft_color::Color::from_hex(hex).map_or(fallback, |c| {
+        let [r, g, b, _] = c.to_rgba8(1.0);
+        [r, g, b]
+    })
+}
+
 /// Requests from tools that only the frontend can fulfil.
 #[derive(Clone, Debug, PartialEq)]
 pub enum UiRequest {
@@ -134,6 +145,7 @@ impl Session {
             paint: &self.paint,
             outline: view.outline,
             smart_guides: view.smart_guides,
+            guides: view.guides && !self.menu.guides_locked,
             snap_to_grid: view.snap_to_grid,
             show_bbox: view.show_bbox,
             snap_to_pixel: view.snap_to_pixel,
@@ -152,6 +164,24 @@ impl Session {
             slices_hidden: self.menu.slices_hidden,
             slices_locked: self.menu.slices_locked,
             auto_add_delete: !self.prefs.disable_auto_add_delete,
+            selection_tolerance: self.prefs.selection_tolerance,
+            path_only: self.prefs.object_selection_by_path_only,
+            double_click_isolate: self.prefs.double_click_to_isolate,
+            select_behind: self.prefs.ctrl_click_selects_behind,
+            highlight_anchors: self.prefs.highlight_anchors_on_hover,
+            snap_tolerance: self.prefs.snap_to_point_tolerance,
+            handles_multiple: self.prefs.show_handles_multiple_anchors,
+            corner_widget_max_angle: self.prefs.hide_corner_widget_above,
+            move_locked_with_artboard: self.prefs.move_locked_with_artboard,
+            pen_rubber_band: self.prefs.pen_rubber_band,
+            curvature_rubber_band: self.prefs.curvature_rubber_band,
+            placeholder_text: self.prefs.placeholder_text,
+            smart_guide_color: rgb(&self.prefs.smart_guide_color, vectorcraft_tools::guides::MAGENTA),
+            alignment_guides: self.prefs.alignment_guides,
+            anchor_path_labels: self.prefs.anchor_path_labels,
+            measurement_labels: self.prefs.measurement_labels,
+            transform_tools_guides: self.prefs.transform_tools_guides,
+            snapping_tolerance: self.prefs.snapping_tolerance,
             screen: view.screen,
             plane_widget: self.prefs.perspective_widget.show.then_some(self.prefs.perspective_widget.position),
         };
@@ -190,6 +220,30 @@ impl Session {
         self.apply_actions(acts)
     }
 
+    /// A guide dragged out of a ruler, whatever the tool: a vertical one out of the left ruler, a
+    /// horizontal one out of the top ruler. `ev` is the pointer in document space (a drag, then the
+    /// release), over the canvas or not (`on_canvas`). The guide shows where the pointer is over
+    /// the canvas, snapped as a moved guide is, and is made where the button is released over it
+    /// (one undo step); released anywhere else, none is. With the Artboard tool it is an artboard
+    /// guide of the active artboard.
+    pub fn ruler_guide(&mut self, vertical: bool, ev: &PointerEvent, on_canvas: bool, view: ViewInfo) -> Result<()> {
+        let g = match self.ruler_guide.take() {
+            Some(g) => Some(g),
+            None => {
+                let boards = self.active().map_or(0, |d| d.doc.artboards.len());
+                let active = (self.tool.id() == "artboard").then(|| self.tool.options()["active"].as_u64()).flatten();
+                let artboard = active.and_then(|i| usize::try_from(i).ok()).filter(|i| *i < boards);
+                self.with_tool_cx(view, |_, cx| Some(vectorcraft_tools::rulerguide::NewGuide::new(cx, vertical, artboard)))
+            }
+        };
+        let Some(mut g) = g else { return Ok(()) };
+        let acts = self.with_tool_cx(view, |_, cx| g.pointer(cx, ev, on_canvas));
+        if ev.kind != PointerKind::Up {
+            self.ruler_guide = Some(g);
+        }
+        self.apply_actions(acts).map(drop)
+    }
+
     /// Time passed while the pointer button is held (`dt` seconds; see [`Tool::tick`]): the
     /// desktop app ticks every frame of a press, agents with `holdMs` on a pointer event.
     pub fn tool_tick(&mut self, dt: f64, view: ViewInfo) -> Result<Vec<UiRequest>> {
@@ -257,6 +311,10 @@ impl Session {
 
     pub fn overlays(&mut self, view: ViewInfo) -> Vec<Overlay> {
         let mut v = self.with_tool_cx(view, |t, cx| t.overlays(cx));
+        if let Some(g) = self.ruler_guide.take() {
+            v.extend(self.with_tool_cx(view, |_, cx| g.overlays(cx)));
+            self.ruler_guide = Some(g);
+        }
         if let Some(d) = self.active() {
             let w = self.prefs.perspective_widget;
             let place = w.show.then_some(WidgetPlace { screen: view.screen.as_ref(), corner: w.position });
@@ -265,8 +323,11 @@ impl Session {
         v
     }
 
+    /// The pointer the active tool shows at `p` (General › Use Precise Cursors makes the drawing
+    /// tools' a crosshair, [`Cursor::precise`]).
     pub fn cursor(&mut self, p: Point, mods: Mods, view: ViewInfo) -> Cursor {
-        self.with_tool_cx(view, |t, cx| t.cursor(cx, p, mods))
+        let c = self.with_tool_cx(view, |t, cx| t.cursor(cx, p, mods));
+        if self.prefs.use_precise_cursors { c.precise() } else { c }
     }
 
     pub fn tool_options(&self) -> Value {

crates/engine/tests/import_fuzz.rs

@@ -873,10 +873,12 @@ proptest! {
         survive("mutated EPS PostScript", || vectorcraft_eps::import(&bytes).ok().map(|r| r.document))?;
     }
 
-    /// Hostile PostScript programs: operators in any order with any operands, opened and placed.
+    /// Hostile PostScript programs: operators in any order with any operands, opened and placed;
+    /// as Illustrator's too, its groups (`u` … `U`) unbalanced, deep and among clips.
     #[test]
-    fn eps_hostile_programs_never_panic(tokens in prop::collection::vec(arb_ps_token(), 0..60)) {
-        let ps = format!("%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 200 200\n%%EndComments\n{}\nshowpage\n", tokens.join(" "));
+    fn eps_hostile_programs_never_panic(tokens in prop::collection::vec(arb_ps_token(), 0..60), illustrator in any::<bool>()) {
+        let head = if illustrator { "%%Creator: Adobe Illustrator(R) 8.0\n%%EndComments\n/u {} def /U {} def" } else { "%%EndComments" };
+        let ps = format!("%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 200 200\n{head}\n{}\nshowpage\n", tokens.join(" "));
         survive("hostile PostScript", || vectorcraft_engine::cmd::fileio::load("x.eps", ps.as_bytes()).ok().map(|l| l.doc))?;
         let r = catch_quiet(|| {
             let mut s = rich_session();
@@ -922,6 +924,32 @@ fn arb_ps_token() -> impl Strategy<Value = String> {
             "<< /ShadingType 2 /ColorSpace /DeviceRGB /Coords [0 0 1 1] /Function << /FunctionType 2 /C0 [0 0 0] /C1 [1 1 1] /N 1 >> >>",
             "<< /PatternType 2 /Shading << /ShadingType 3 /ColorSpace /DeviceGray /Coords [0 0 0 9 9 9] /Function << /FunctionType 3 /Functions [] /Bounds [] /Encode [] >> >> >>",
             "<< /ImageType 1 /Width 2 /Height 2 /BitsPerComponent 8 /ImageMatrix [2 0 0 2 0 0] /DataSource (abcdefghijkl) >>",
+            "u", "U", "u u u", "U U", "{ u } 300 repeat", "1 1 300 { pop u 0 0 9 9 rectclip } for",
+            // Probing, files, forms and devices.
+            "status", "token", "bytesavailable", "resetfile", "pdfmark", "execform", "nulldevice", "strokepath", "pathforall",
+            "currenthsbcolor", "currentcolorrendering", "gcheck", "rootfont", "setcachedevice2", "writestring", "(%stdout) (w) file",
+            "//x", "{ //dup }", "/ReusableStreamDecode", "currentfile /ASCII85Decode filter /ReusableStreamDecode filter",
+            "<< /Predictor 12 /Columns 2 /Colors 1 >> /FlateDecode", "<< /FormType 1 /BBox [0 0 9 9] /PaintProc { pop 0 0 5 5 rectfill } >>",
+            // Tiling patterns, uncoloured ones and patterns drawing patterns.
+            "<< /PatternType 1 /PaintType 1 /XStep 5 /YStep 5 /BBox [0 0 5 5] /PaintProc { pop 0 0 3 3 rectfill } >> matrix makepattern",
+            "<< /PatternType 1 /PaintType 2 /XStep 5 /YStep 5 /BBox [0 0 5 5] /PaintProc { pop dup setpattern 0 0 3 3 rectfill } >>",
+            "[/Pattern /DeviceRGB] setcolorspace", "1 0 0", "setpattern",
+            // Mesh and function shadings, sampled functions.
+            "<< /ShadingType 4 /ColorSpace /DeviceGray /DataSource [0 0 0 0 0 9 0 1 0 0 9 1 1 9 9 0] >>",
+            "<< /ShadingType 5 /ColorSpace /DeviceGray /VerticesPerRow 2 /DataSource [0 0 0 9 0 1 0 9 1 9 9 0] >>",
+            "<< /ShadingType 6 /ColorSpace /DeviceGray /BitsPerCoordinate 8 /BitsPerComponent 8 /BitsPerFlag 8 /Decode [0 9 0 9 0 1] /DataSource <00ff10ff20ff30> >>",
+            "<< /ShadingType 7 /ColorSpace /DeviceRGB /BitsPerCoordinate 32 /BitsPerComponent 16 /BitsPerFlag 8 /Decode [0 9 0 9 0 1 0 1 0 1] /DataSource (abc) >>",
+            "<< /ShadingType 1 /ColorSpace /DeviceGray /Function << /FunctionType 0 /Domain [0 1 0 1] /Range [0 1] /Size [2 2] /BitsPerSample 8 /DataSource <00ff00ff> >> >>",
+            "<< /FunctionType 0 /Domain [0 1] /Range [0 1 0 1 0 1] /Size [99999999] /BitsPerSample 32 /DataSource () >>",
+            // Masked images.
+            "<< /ImageType 3 /InterleaveType 1 /DataDict << /ImageType 1 /Width 2 /Height 2 /BitsPerComponent 8 /ImageMatrix [2 0 0 2 0 0] /DataSource (abcdefghijklmnop) >> /MaskDict << /ImageType 1 /Width 2 /Height 2 /BitsPerComponent 1 /ImageMatrix [2 0 0 2 0 0] >> >>",
+            "<< /ImageType 3 /InterleaveType 2 /DataDict << /ImageType 1 /Width 3 /Height 1 /BitsPerComponent 8 /ImageMatrix [3 0 0 1 0 0] /DataSource (abcdefghijklmnop) >> /MaskDict << /ImageType 1 /Width 3 /Height 5 /BitsPerComponent 1 /ImageMatrix [3 0 0 5 0 0] >> >>",
+            // Type 3 fonts and the show operators that space their glyphs.
+            "/T3 << /FontType 3 /FontMatrix [0.1 0 0 0.1 0 0] /FontBBox [0 0 9 9] /Encoding [/a /b] /BuildChar { pop pop 9 0 setcharwidth 0 0 5 5 rectfill } >> definefont setfont",
+            "/T4 << /FontType 3 /FontMatrix [1 0 0 1 0 0] /BuildGlyph { pop pop (x) show } /Encoding [/a] >> definefont setfont",
+            "glyphshow", "xshow", "xyshow", "awidthshow", "kshow", "/a", "[1 2 3]",
+            // Executable strings and integer keys (Illustrator 8's procsets).
+            "(>>) cvx", "(1 2 add) cvx exec", "(x) cvx dup exec", "0 load", "1 { } def", "(mark) cvx cvlit"
         ])
         .prop_map(str::to_string),
     ]

crates/eps/Cargo.toml

@@ -15,6 +15,8 @@ vectorcraft-doc = { workspace = true }
 vectorcraft-effects = { workspace = true }
 vectorcraft-brush = { workspace = true }
 vectorcraft-text = { workspace = true }
+# Windows metafile previews, opened when a file's PostScript can't be read.
+vectorcraft-metafile = { workspace = true }
 # The TIFF writer (previews) and PackBits, shared with raster export.
 vectorcraft-render = { workspace = true }
 kurbo = { workspace = true }

crates/eps/src/import/data.rs

@@ -11,7 +11,7 @@ use vectorcraft_geom::Affine;
 
 use super::graphics::{Space, process};
 use super::interp::{Interp, matrix_of};
-use super::lex::{find, hex_decode};
+use super::lex::{Lexer, find, hex_decode};
 use super::obj::{DictRef, Key, Obj, Op, PsError, Res, Shared, ps_err};
 use crate::ps;
 
@@ -19,6 +19,8 @@ use crate::ps;
 const MAX_DATA: usize = 1 << 28;
 /// Most pixels an image may have.
 const MAX_PIXELS: usize = 1 << 26;
+/// Why an image is missing.
+const TOO_LARGE: &str = "images too large to read were left out";
 /// Most distinct colours an image converts through a tint transform.
 const MAX_TINTS: usize = 1 << 16;
 
@@ -159,6 +161,100 @@ pub(crate) struct Filter {
     name: Rc<str>,
     /// `SubFileDecode`'s count and end-of-data string.
     sub: (usize, Vec<u8>),
+    /// `FlateDecode`'s and `LZWDecode`'s `Predictor`: what it undoes.
+    predictor: Option<Predictor>,
+}
+
+/// A `Predictor` (2: TIFF, 10–15: PNG) with its `Colors`, `BitsPerComponent` and `Columns`.
+#[derive(Clone, Copy, Debug)]
+struct Predictor {
+    kind: u8,
+    colors: usize,
+    bpc: usize,
+    columns: usize,
+}
+
+impl Predictor {
+    /// The predictor of a filter's parameters, if it has one.
+    fn of(d: &DictRef) -> Res<Option<Self>> {
+        let num = |k: &str, default: f64| d.borrow().get(&Key::name(k)).and_then(Obj::as_num).unwrap_or(default);
+        let kind = num("Predictor", 1.0);
+        if kind <= 1.0 {
+            return Ok(None);
+        }
+        let (colors, bpc, columns) = (num("Colors", 1.0), num("BitsPerComponent", 8.0), num("Columns", 1.0));
+        if !(kind == 2.0 || (10.0..=15.0).contains(&kind))
+            || !(1.0..=32.0).contains(&colors)
+            || ![1.0, 2.0, 4.0, 8.0, 16.0].contains(&bpc)
+            || !(1.0..=1e6).contains(&columns)
+        {
+            return ps_err("rangecheck", "Predictor");
+        }
+        Ok(Some(Self { kind: kind as u8, colors: colors as usize, bpc: bpc as usize, columns: columns as usize }))
+    }
+
+    /// The data the predictor made `data` from.
+    fn undo(self, data: &[u8]) -> Vec<u8> {
+        // A row longer than the data is the data.
+        let row = (self.colors * self.bpc * self.columns).div_ceil(8).min(data.len().max(1));
+        // Bytes per pixel (at least one) is how far back the left neighbour is.
+        let bpp = (self.colors * self.bpc).div_ceil(8).max(1);
+        if self.kind == 2 {
+            let mut out = data.to_vec();
+            // Horizontal differencing, for 8-bit components (the common case).
+            if self.bpc == 8 {
+                for line in out.chunks_mut(row.max(1)) {
+                    for i in bpp..line.len() {
+                        let left = line.get(i - bpp).copied().unwrap_or(0);
+                        if let Some(b) = line.get_mut(i) {
+                            *b = b.wrapping_add(left);
+                        }
+                    }
+                }
+            }
+            return out;
+        }
+        // PNG: each row starts with its filter type.
+        let mut out: Vec<u8> = Vec::with_capacity(data.len());
+        let mut prev = vec![0u8; row];
+        for chunk in data.chunks(row + 1) {
+            let Some((&kind, line)) = chunk.split_first() else { break };
+            let mut cur = line.to_vec();
+            cur.resize(row, 0);
+            for i in 0..row {
+                let a = if i >= bpp { cur.get(i - bpp).copied().unwrap_or(0) } else { 0 };
+                let b = prev.get(i).copied().unwrap_or(0);
+                let c = if i >= bpp { prev.get(i - bpp).copied().unwrap_or(0) } else { 0 };
+                let add = match kind {
+                    1 => a,
+                    2 => b,
+                    3 => ((u16::from(a) + u16::from(b)) / 2) as u8,
+                    4 => paeth(a, b, c),
+                    _ => 0,
+                };
+                if let Some(v) = cur.get_mut(i) {
+                    *v = v.wrapping_add(add);
+                }
+            }
+            out.extend_from_slice(cur.get(..line.len().min(row)).unwrap_or_default());
+            prev = cur;
+        }
+        out
+    }
+}
+
+/// The PNG Paeth predictor.
+fn paeth(a: u8, b: u8, c: u8) -> u8 {
+    let (ia, ib, ic) = (i16::from(a), i16::from(b), i16::from(c));
+    let p = ia + ib - ic;
+    let (pa, pb, pc) = ((p - ia).abs(), (p - ib).abs(), (p - ic).abs());
+    if pa <= pb && pa <= pc {
+        a
+    } else if pb <= pc {
+        b
+    } else {
+        c
+    }
 }
 
 /// The bytes `f` decodes from `raw`, how many it read, and the channels of a decoded JPEG.
@@ -176,8 +272,13 @@ fn decode(f: &Filter, raw: &[u8]) -> Res<(Vec<u8>, usize, Option<u8>)> {
             (ps::ascii85_decode(&text).ok_or(PsError::Ps("ioerror", "ASCII85Decode".into()))?, end.map_or(raw.len(), |e| e + 2))
         }
         "RunLengthDecode" => run_length(raw)?,
-        "FlateDecode" => flate(raw)?,
-        "LZWDecode" => lzw(raw)?,
+        "FlateDecode" | "LZWDecode" => {
+            let (data, used) = if &*f.name == "FlateDecode" { flate(raw)? } else { lzw(raw)? };
+            match f.predictor {
+                Some(p) => (p.undo(&data), used),
+                None => (data, used),
+            }
+        }
         "DCTDecode" => {
             let (d, used, channels) = dct(raw)?;
             return Ok((d, used, Some(channels)));
@@ -202,13 +303,15 @@ fn decode(f: &Filter, raw: &[u8]) -> Res<(Vec<u8>, usize, Option<u8>)> {
                 }
             }
         }
-        "NullEncode" => (raw.to_vec(), raw.len()),
+        // Reads all of its source (up to the end of the filters below it) and keeps it.
+        "NullEncode" | "ReusableStreamDecode" => (raw.to_vec(), raw.len()),
         other => return ps_err("undefined", other),
     };
     Ok((data, used, None))
 }
 
 /// What a source of image data gives.
+#[derive(Clone)]
 enum Source {
     File(Rc<RefCell<Stream>>),
     Str(Vec<u8>),
@@ -263,9 +366,74 @@ impl Interp<'_> {
             }
             File => {
                 self.pop()?;
-                self.pop()?;
-                return ps_err("invalidfileaccess", "file");
+                let name = self.pop()?.text().unwrap_or_else(|| Rc::from(""));
+                // The standard files take what programs print (and give nothing); there is no
+                // file system to open others in.
+                if !matches!(&*name, "%stdout" | "%stderr" | "%stdin" | "%lineedit" | "%statementedit") {
+                    return ps_err("invalidfileaccess", "file");
+                }
+                self.push(Obj::File { stream: Rc::new(RefCell::new(Stream::Buf { data: vec![], pos: 0, rgb: None })), exec: false })?;
             }
+            Status => match self.pop()? {
+                Obj::File { .. } => self.push(Obj::Bool(true))?,
+                // A file name: there are no files.
+                Obj::Str(_) => self.push(Obj::Bool(false))?,
+                _ => return ps_err("typecheck", ""),
+            },
+            BytesAvailable => {
+                let Obj::File { stream: f, .. } = self.pop()? else { return ps_err("typecheck", "") };
+                self.materialize(&f)?;
+                let n = match &*f.borrow() {
+                    Stream::Current => self.lex.rest().len(),
+                    Stream::Buf { data, pos, .. } => data.len().saturating_sub(*pos),
+                    Stream::Pending(_) => 0,
+                };
+                self.push(Obj::Int(n as i64))?;
+            }
+            ResetFile => {
+                // A decoded (reusable) stream reads again from its start.
+                if let Obj::File { stream: f, .. } = self.pop()?
+                    && let Stream::Buf { pos, .. } = &mut *f.borrow_mut()
+                {
+                    *pos = 0;
+                }
+            }
+            Write | WriteString | WriteHexString => {
+                self.pop()?;
+                self.pop()?;
+            }
+            Read => {
+                let Obj::File { stream: f, .. } = self.pop()? else { return ps_err("typecheck", "") };
+                match self.read(&f, 1)?.first() {
+                    Some(b) => {
+                        self.push(Obj::Int(i64::from(*b)))?;
+                        self.push(Obj::Bool(true))?;
+                    }
+                    None => self.push(Obj::Bool(false))?,
+                }
+            }
+            FilePosition => {
+                let Obj::File { stream: f, .. } = self.pop()? else { return ps_err("typecheck", "") };
+                let Stream::Buf { pos, .. } = &*f.borrow() else { return ps_err("ioerror", "") };
+                self.push(Obj::Int(*pos as i64))?;
+            }
+            SetFilePosition => {
+                let at = self.pop_count()?;
+                let Obj::File { stream: f, .. } = self.pop()? else { return ps_err("typecheck", "") };
+                let Stream::Buf { data, pos, .. } = &mut *f.borrow_mut() else { return ps_err("ioerror", "") };
+                *pos = at.min(data.len());
+            }
+            // There are no files to delete, rename or run.
+            DeleteFile | Run => {
+                self.pop_str()?;
+                return ps_err("undefinedfilename", "");
+            }
+            RenameFile => {
+                self.pop_str()?;
+                self.pop_str()?;
+                return ps_err("undefinedfilename", "");
+            }
+            Token => self.token()?,
             Eexec => self.eexec()?,
             Image | ImageMask | ColorImage => self.image(op)?,
             _ => self.text_op(op)?,
@@ -273,6 +441,41 @@ impl Interp<'_> {
         Ok(())
     }
 
+    /// `token`: the next object read from a string (and the rest of it) or a file.
+    fn token(&mut self) -> Res {
+        match self.pop()? {
+            Obj::Str(s) => {
+                let bytes = s.to_vec();
+                let mut lex = Lexer::new(&bytes);
+                let Some(o) = lex.next()? else { return self.push(Obj::Bool(false)) };
+                let o = self.scanned(o, lex.immediate)?;
+                // The whitespace after the token is read with it.
+                let used = bytes.len() - lex.data().len();
+                self.push_interval(Obj::Str(s), used, bytes.len() - used)?;
+                self.push(o)?;
+            }
+            Obj::File { stream: f, .. } => {
+                self.materialize(&f)?;
+                let (o, immediate) = match &mut *f.borrow_mut() {
+                    Stream::Current => (self.lex.next()?, self.lex.immediate),
+                    Stream::Buf { data, pos, .. } => {
+                        let rest = data.get(*pos..).unwrap_or_default();
+                        let mut lex = Lexer::new(rest);
+                        let o = lex.next()?;
+                        *pos += rest.len() - lex.data().len();
+                        (o, lex.immediate)
+                    }
+                    Stream::Pending(_) => (None, false),
+                };
+                let Some(o) = o else { return self.push(Obj::Bool(false)) };
+                let o = self.scanned(o, immediate)?;
+                self.push(o)?;
+            }
+            _ => return ps_err("typecheck", "token"),
+        }
+        self.push(Obj::Bool(true))
+    }
+
     /// Up to `n` bytes of file `f`.
     fn read(&mut self, f: &Rc<RefCell<Stream>>, n: usize) -> Res<Vec<u8>> {
         self.materialize(f)?;
@@ -328,14 +531,13 @@ impl Interp<'_> {
         } else {
             (0, vec![])
         };
+        let mut predictor = None;
         if let Some(Obj::Dict(d)) = self.stack.last().cloned() {
             self.pop()?;
-            let predictor = d.borrow().get(&Key::name("Predictor")).and_then(Obj::as_num).unwrap_or(1.0);
-            if predictor > 1.0 {
-                return ps_err("undefined", "a filter predictor");
-            }
+            predictor = Predictor::of(&d)?;
         }
-        let spec = Filter { name, sub };
+        let spec_name = name.clone();
+        let spec = Filter { name, sub, predictor };
         let stream = match self.pop()? {
             Obj::File { stream: f, .. } => {
                 if let Stream::Buf { data, pos, .. } = &*f.borrow() {
@@ -377,7 +579,12 @@ impl Interp<'_> {
             }
             _ => return ps_err("typecheck", "filter"),
         };
-        self.push(Obj::File { stream: Rc::new(RefCell::new(stream)), exec: false })
+        let stream = Rc::new(RefCell::new(stream));
+        // A reusable stream reads its source when it is made: the data follows the operator.
+        if &*spec_name == "ReusableStreamDecode" {
+            self.materialize(&stream)?;
+        }
+        self.push(Obj::File { stream, exec: false })
     }
 
     /// The data an executable file runs as a program: what is left of it. `None` for the
@@ -389,6 +596,15 @@ impl Interp<'_> {
         self.read(f, MAX_DATA).map(Some)
     }
 
+    /// The decoded data left in file `f`, without reading it (a shading's or function's data).
+    pub(super) fn peek_all(&mut self, f: &Rc<RefCell<Stream>>) -> Res<Vec<u8>> {
+        self.materialize(f)?;
+        Ok(match &*f.borrow() {
+            Stream::Buf { data, pos, .. } => data.get(*pos..).unwrap_or_default().to_vec(),
+            _ => vec![],
+        })
+    }
+
     /// Decode the filters a file waits to run over the program's data, from where it is now.
     fn materialize(&mut self, f: &Rc<RefCell<Stream>>) -> Res {
         let chain = match &*f.borrow() {
@@ -467,17 +683,79 @@ impl Interp<'_> {
 
     fn image(&mut self, op: Op) -> Res {
         let mask = op == Op::ImageMask;
-        let spec = match self.stack.last() {
+        let img = match self.stack.last() {
             Some(Obj::Dict(_)) if op != Op::ColorImage => {
                 let d = self.pop_dict()?;
-                self.image_dict(&d, mask)?
+                let kind = d.borrow().get(&Key::name("ImageType")).and_then(Obj::as_num);
+                if kind == Some(3.0) && !mask {
+                    self.masked_image(&d)?
+                } else {
+                    let spec = self.image_dict(&d, mask)?;
+                    self.decode_image(spec)?
+                }
+            }
+            _ => {
+                let spec = self.image_operands(op)?;
+                self.decode_image(spec)?
             }
-            _ => self.image_operands(op)?,
         };
-        let Some(img) = self.decode_image(spec)? else { return Ok(()) };
+        let Some(img) = img else { return Ok(()) };
         self.place_image(img)
     }
 
+    /// ImageType 3: an image and the mask that says where it paints (where the mask's samples
+    /// read below one half through its `Decode`, as an image mask paints its 0 bits), in separate
+    /// sources (`InterleaveType` 3) or interleaved with the image's by row (2) or by sample (1).
+    fn masked_image(&mut self, d: &DictRef) -> Res<Option<Pixels>> {
+        let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();
+        let (Some(Obj::Dict(data)), Some(Obj::Dict(mask))) = (get("DataDict"), get("MaskDict")) else {
+            return ps_err("typecheck", "ImageType 3");
+        };
+        let interleave = get("InterleaveType").and_then(|o| o.as_num()).unwrap_or(1.0);
+        let mut image = self.image_dict(&data, false)?;
+        let mut stencil = self.image_dict(&mask, false)?;
+        stencil.space = Space::Gray;
+        let n = image.space.n();
+        if image.w.saturating_mul(image.h) > MAX_PIXELS || stencil.w.saturating_mul(stencil.h) > MAX_PIXELS {
+            self.out.warn(TOO_LARGE);
+            return Ok(None);
+        }
+        if interleave != 3.0 {
+            let src = image.sources.first().cloned().ok_or(PsError::Ps("undefined", "DataSource".into()))?;
+            let (pixels, samples) = if interleave == 2.0 {
+                let (mrow, drow) = (stencil.row_bytes(1), image.row_bytes(n));
+                let total = mrow.saturating_mul(stencil.h).saturating_add(drow.saturating_mul(image.h));
+                self.alloc(total)?;
+                let raw = self.source_bytes(&src, total.min(MAX_DATA))?;
+                by_rows(&raw, (mrow, stencil.h), (drow, image.h))
+            } else {
+                // Each sample: the mask's value, then the colour's, as many bits each.
+                stencil.bpc = image.bpc;
+                (stencil.w, stencil.h) = (image.w, image.h);
+                let row = (image.w * (n + 1) * usize::from(image.bpc)).div_ceil(8);
+                self.alloc(row.saturating_mul(image.h))?;
+                let raw = self.source_bytes(&src, row.saturating_mul(image.h).min(MAX_DATA))?;
+                by_samples(&raw, image.w, image.h, n, image.bpc)
+            };
+            stencil.sources = vec![Source::Str(pixels)];
+            image.sources = vec![Source::Str(samples)];
+        }
+        let Some(mut img) = self.decode_image(image)? else { return Ok(None) };
+        let Some(m) = self.decode_image(stencil)? else { return Ok(Some(img)) };
+        let (w, h, mw, mh) = (img.w as usize, img.h as usize, m.w as usize, m.h as usize);
+        for (i, px) in img.rgba.chunks_exact_mut(4).enumerate() {
+            let (x, y) = (i % w, i / w);
+            // The mask's pixel over this one (in 64 bits: rows times rows overflow 32).
+            let at = (y as u64 * mh as u64 / h.max(1) as u64) * mw as u64 + x as u64 * mw as u64 / w.max(1) as u64;
+            if usize::try_from(at * 4).ok().and_then(|i| m.rgba.get(i)).is_none_or(|v| *v >= 128)
+                && let Some(a) = px.get_mut(3)
+            {
+                *a = 0;
+            }
+        }
+        Ok(Some(img))
+    }
+
     /// The dictionary form of `image` and `imagemask`.
     fn image_dict(&mut self, d: &DictRef, mask: bool) -> Res<Spec> {
         let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();
@@ -494,10 +772,10 @@ impl Interp<'_> {
         let decode: Vec<f64> = get("Decode").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();
         let space = if mask { Space::Gray } else { (*self.g.space).clone() };
         let multi = get("MultipleDataSources").is_some_and(|o| matches!(o, Obj::Bool(true)));
-        let src = get("DataSource").ok_or(PsError::Ps("undefined", "DataSource".into()))?;
-        let sources = match (&src, multi) {
-            (Obj::Array { items, exec: false }, true) => items.borrow().iter().map(source).collect::<Res<Vec<_>>>()?,
-            _ => vec![source(&src)?],
+        let sources = match (get("DataSource"), multi) {
+            (None, _) => vec![],
+            (Some(Obj::Array { items, exec: false }), true) => items.borrow().iter().map(source).collect::<Res<Vec<_>>>()?,
+            (Some(src), _) => vec![source(&src)?],
         };
         let mask_color: Option<Vec<u32>> = (kind == 4.0)
             .then(|| {
@@ -544,7 +822,7 @@ impl Interp<'_> {
             return ps_err("rangecheck", "BitsPerComponent");
         }
         if s.w.saturating_mul(s.h) > MAX_PIXELS {
-            self.out.warn("images too large to read were left out");
+            self.out.warn(TOO_LARGE);
             return Ok(None);
         }
         self.alloc(s.w * s.h * 4)?;
@@ -667,6 +945,9 @@ impl Interp<'_> {
         if !xf.as_coeffs().iter().all(|v| v.is_finite()) || xf.determinant().abs() < 1e-12 {
             return Ok(());
         }
+        if self.g.null {
+            return Ok(());
+        }
         let Some(rgba) = image::RgbaImage::from_raw(img.w, img.h, img.rgba) else { return Ok(()) };
         let mut png = vec![];
         if rgba.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).is_err() {
@@ -700,6 +981,65 @@ struct Spec {
     stencil: Option<bool>,
 }
 
+impl Spec {
+    /// Bytes a row of `n` components takes.
+    fn row_bytes(&self, n: usize) -> usize {
+        (self.w * n * usize::from(self.bpc)).div_ceil(8)
+    }
+}
+
+/// Data of an ImageType 3 interleaved by row, split into the mask's and the image's: the one
+/// with fewer rows gives one row before each run of the other's (`(row bytes, rows)` each).
+fn by_rows(raw: &[u8], (mrow, mh): (usize, usize), (drow, dh): (usize, usize)) -> (Vec<u8>, Vec<u8>) {
+    let room = |row: usize, rows: usize| row.saturating_mul(rows).min(raw.len());
+    let (mut mask, mut data) = (Vec::with_capacity(room(mrow, mh)), Vec::with_capacity(room(drow, dh)));
+    let mut at = 0;
+    let mut take = |into: &mut Vec<u8>, n: usize| {
+        into.extend_from_slice(raw.get(at..at + n).unwrap_or_default());
+        at += n;
+    };
+    let (blocks, masks, rows) = if mh >= dh { (dh, mh / dh.max(1), 1) } else { (mh, 1, dh / mh.max(1)) };
+    for _ in 0..blocks {
+        for _ in 0..masks {
+            take(&mut mask, mrow);
+        }
+        for _ in 0..rows {
+            take(&mut data, drow);
+        }
+    }
+    (mask, data)
+}
+
+/// Data of an ImageType 3 interleaved by sample (the mask's value first, then `n` colour
+/// components, `bpc` bits each, rows from whole bytes), split into the mask's and the image's.
+fn by_samples(raw: &[u8], w: usize, h: usize, n: usize, bpc: u8) -> (Vec<u8>, Vec<u8>) {
+    let bpc = usize::from(bpc);
+    let bit = |at: usize| raw.get(at / 8).is_some_and(|b| b & (0x80 >> (at % 8)) != 0);
+    let (mrow, drow, row) = ((w * bpc).div_ceil(8), (w * n * bpc).div_ceil(8), (w * (n + 1) * bpc).div_ceil(8));
+    let (mut mask, mut data) = (vec![0u8; mrow * h], vec![0u8; drow * h]);
+    let put = |into: &mut [u8], at: usize| {
+        if let Some(b) = into.get_mut(at / 8) {
+            *b |= 0x80 >> (at % 8);
+        }
+    };
+    for y in 0..h {
+        for x in 0..w {
+            let from = y * row * 8 + x * (n + 1) * bpc;
+            for k in 0..bpc {
+                if bit(from + k) {
+                    put(&mut mask, y * mrow * 8 + x * bpc + k);
+                }
+            }
+            for k in 0..n * bpc {
+                if bit(from + bpc + k) {
+                    put(&mut data, y * drow * 8 + x * n * bpc + k);
+                }
+            }
+        }
+    }
+    (mask, data)
+}
+
 /// Decoded pixels.
 struct Pixels {
     w: u32,

crates/eps/src/import/graphics.rs

@@ -7,12 +7,13 @@ use std::sync::Arc;
 use kurbo::{PathEl, Shape};
 use vectorcraft_color::swatch::REGISTRATION;
 use vectorcraft_color::{Color, Gradient, GradientGeom, GradientKind, GradientPaint, GradientStop, Paint};
-use vectorcraft_doc::clipnest::{Clip, Drawn};
+use vectorcraft_doc::clipnest::{Clip, Drawn, MAX_NEST, deep_clips};
+use vectorcraft_doc::pattern::PatternDef;
 use vectorcraft_doc::{Appearance, AppearanceItem, Dash, Document, FillLayer, LineCap, LineJoin, Node, NodeId, NodeKind, StrokeLayer};
 use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect, Vec2};
 
 use super::interp::{Interp, MAX_GSAVE, matrix_obj};
-use super::obj::{DictRef, Key, Obj, Op, PsError, Res, ps_err};
+use super::obj::{DictRef, Key, Obj, Op, PsError, Res, Shared, ps_err};
 
 /// Most objects one file makes.
 const MAX_NODES: usize = 1 << 20;
@@ -21,19 +22,26 @@ const MAX_NODES: usize = 1 << 20;
 const LIMIT: f64 = 1e6;
 /// Width of a zero-width line (the thinnest a device draws), points.
 const HAIRLINE: f64 = 0.25;
+/// Most inks a `DeviceN` space has (PostScript's own limit).
+const MAX_INKS: usize = 32;
+/// Most dashes `strokepath` makes of a path (more and it outlines the path undashed).
+const MAX_DASHES: f64 = 1e5;
 /// Most entries an indexed colour space's table has.
 const MAX_HIVAL: usize = 4095;
 /// Most elements the current path may have.
 const MAX_PATH: usize = 1 << 20;
-/// Most path elements drawn in all.
+/// Most path elements drawn in all (each object's clips and groups counting as elements too).
 const MAX_DRAWN: usize = 1 << 24;
 /// Samples taken of a shading function that isn't a plain interpolation.
 const SHADING_SAMPLES: usize = 32;
 
 const FAR_AWAY: &str = "objects far outside the page were left out";
 const TOO_MUCH: &str = "the file draws more than VectorCraft reads: the rest was left out";
-const TILING_PATTERNS: &str = "pattern fills are filled with mid-grey";
-const SAMPLED_FUNCTIONS: &str = "shadings whose colours come from sampled functions are filled with their middle colour";
+const NESTED_PATTERNS: &str = "patterns nested too deeply are filled with mid-grey";
+/// Deepest patterns and glyph procedures drawn inside each other's art.
+pub(crate) const MAX_APART: u32 = 8;
+const UNKNOWN_FUNCTIONS: &str = "shadings whose functions are of an unknown type are filled with their middle colour";
+const UNKNOWN_SHADINGS: &str = "shadings of an unknown type were left out";
 
 /// A colour space.
 #[derive(Clone, Debug)]
@@ -51,14 +59,15 @@ pub(crate) enum Space {
         base: Rc<Space>,
         table: Rc<Vec<f64>>,
     },
-    Pattern,
+    /// Patterns; an uncoloured one paints in a colour of the underlying space.
+    Pattern(Option<Rc<Space>>),
 }
 
 impl Space {
     /// Components a colour has in it.
     pub fn n(&self) -> usize {
         match self {
-            Self::Gray | Self::Indexed { .. } | Self::Pattern => 1,
+            Self::Gray | Self::Indexed { .. } | Self::Pattern(_) => 1,
             Self::Rgb => 3,
             Self::Cmyk => 4,
             Self::Inks { names, .. } => names.len().max(1),
@@ -110,6 +119,11 @@ pub(crate) struct GState {
     pub saved_clips: Vec<Rc<[Arc<Clip>]>>,
     pub overprint: bool,
     pub font: Option<DictRef>,
+    /// `nulldevice`: painting draws nothing.
+    pub null: bool,
+    /// The colour is a shading pattern whose shading is a mesh: a fill paints it (the shading
+    /// and pattern space → the document).
+    pub mesh: Option<(DictRef, Affine)>,
 }
 
 impl Default for GState {
@@ -133,6 +147,8 @@ impl Default for GState {
             saved_clips: vec![],
             overprint: false,
             font: None,
+            null: false,
+            mesh: None,
         }
     }
 }
@@ -147,8 +163,13 @@ pub(crate) struct Out {
     pub page: Affine,
     /// The page (the bounding box) in document space.
     pub frame: Rect,
+    /// Clip and group ids are given in the order they open, so a chain of both sorts by id.
     next_clip: u32,
-    /// Path elements drawn so far (see [`MAX_DRAWN`]).
+    /// The groups open (outermost first), and how many more opened past [`MAX_NEST`] (their art
+    /// goes in the innermost group kept).
+    groups: Vec<Arc<Clip>>,
+    too_deep: usize,
+    /// Path elements (and the clips and groups of each object) drawn so far (see [`MAX_DRAWN`]).
     elements: usize,
     /// The path the last object was filled with: a stroke of the same path right after joins it.
     merge: Option<BezPath>,
@@ -160,6 +181,12 @@ pub(crate) struct Out {
     /// Rectangles painted with a shading (`shfill`): a clipping group of one is the clip path
     /// filled with it.
     pub shadings: Vec<NodeId>,
+    /// Tiling patterns made into pattern swatches: the pattern's `PaintProc` (a pattern made
+    /// again with `makepattern` shares it) and cell, the colour an uncoloured one painted in, and
+    /// the swatch's name.
+    tilings: Vec<(Shared<Obj>, Rect, Option<Paint>, String)>,
+    /// How deep art drawn apart (a pattern's cell, a Type 3 glyph) is nested.
+    pub apart: u32,
 }
 
 fn sane(r: Rect) -> bool {
@@ -175,12 +202,16 @@ impl Out {
             page,
             frame,
             next_clip: 0,
+            groups: vec![],
+            too_deep: 0,
             elements: 0,
             merge: None,
             cmyk: 0,
             rgb: 0,
             spots: vec![],
             shadings: vec![],
+            tilings: vec![],
+            apart: 0,
         }
     }
 
@@ -190,10 +221,48 @@ impl Out {
         }
     }
 
-    /// Add `node` under `clips`; `None` when it was left out.
+    /// Open a group: what is drawn until it ends ([`Self::end_group`]) goes in it.
+    pub fn begin_group(&mut self) {
+        if self.groups.len() >= MAX_NEST {
+            self.too_deep += 1;
+            self.warn(&format!("groups nested more than {MAX_NEST} deep were read as part of the group around them"));
+            return;
+        }
+        self.next_clip += 1;
+        self.groups.push(Arc::new(Clip { id: self.next_clip, region: None }));
+    }
+
+    /// End the innermost group open (an end without a beginning ends nothing).
+    pub fn end_group(&mut self) {
+        if self.too_deep > 0 {
+            self.too_deep -= 1;
+        } else {
+            self.groups.pop();
+        }
+    }
+
+    /// The chain an object drawn under `clips` is drawn in: the clips and the groups open, in the
+    /// order they opened.
+    pub fn chain(&self, clips: &[Arc<Clip>]) -> Vec<Arc<Clip>> {
+        if self.groups.is_empty() {
+            return clips.to_vec();
+        }
+        let mut chain = Vec::with_capacity(clips.len() + self.groups.len());
+        let (mut a, mut b) = (clips.iter().peekable(), self.groups.iter().peekable());
+        while let (Some(x), Some(y)) = (a.peek(), b.peek()) {
+            let next = if x.id < y.id { a.next() } else { b.next() };
+            chain.extend(next.cloned());
+        }
+        chain.extend(a.chain(b).cloned());
+        chain
+    }
+
+    /// Add `node` under `clips` (in the groups open); `None` when it was left out.
     pub fn push(&mut self, mut node: Node, clips: &[Arc<Clip>]) -> Option<NodeId> {
         self.merge = None;
-        self.elements = self.elements.saturating_add(node.path_data().map_or(1, |p| p.subpaths.iter().map(|s| s.anchors.len()).sum()));
+        let chain = self.chain(clips);
+        let size = node.path_data().map_or(1, |p| p.subpaths.iter().map(|s| s.anchors.len()).sum()) + chain.len();
+        self.elements = self.elements.saturating_add(size);
         if self.drawn.len() >= MAX_NODES || self.elements > MAX_DRAWN {
             self.warn(TOO_MUCH);
             return None;
@@ -204,7 +273,7 @@ impl Out {
         }
         node.id = self.doc.alloc_id();
         let id = node.id;
-        self.drawn.push((clips.to_vec(), node));
+        self.drawn.push((chain, node));
         Some(id)
     }
 
@@ -234,14 +303,15 @@ impl Out {
     /// clips (`gsave fill grestore stroke`).
     fn stroke(&mut self, bp: BezPath, st: StrokeLayer, clips: &[Arc<Clip>]) {
         self.count(&st.paint);
-        if self.merge.as_ref() == Some(&bp)
-            && let Some((chain, last)) = self.drawn.last_mut()
-            && chain.len() == clips.len()
-            && chain.iter().zip(clips).all(|(a, b)| Arc::ptr_eq(a, b))
-        {
-            last.appearance.items.push(AppearanceItem::Stroke(st));
-            self.merge = None;
-            return;
+        if self.merge.as_ref() == Some(&bp) {
+            let here = self.chain(clips);
+            if let Some((chain, last)) = self.drawn.last_mut()
+                && chain.iter().map(|c| c.id).eq(here.iter().map(|c| c.id))
+            {
+                last.appearance.items.push(AppearanceItem::Stroke(st));
+                self.merge = None;
+                return;
+            }
         }
         let n = Node::path(NodeId(0), PathData::from_bezpath(&bp), Appearance { items: vec![AppearanceItem::Stroke(st)], ..Appearance::default() });
         self.push(n, clips);
@@ -256,7 +326,7 @@ impl Out {
             return None;
         }
         self.next_clip += 1;
-        Some(Arc::new(Clip { id: self.next_clip, path, rule }))
+        Some(Arc::new(Clip { id: self.next_clip, region: Some((path, rule)) }))
     }
 }
 
@@ -440,18 +510,36 @@ impl Interp<'_> {
 
     // ---------- painting ----------
 
-    fn fill_path(&mut self, bp: BezPath, rule: FillRule) {
-        if bp.elements().is_empty() || self.g.paint.is_none() {
-            return;
+    fn fill_path(&mut self, bp: BezPath, rule: FillRule) -> Res {
+        if bp.elements().is_empty() || self.g.null {
+            return Ok(());
+        }
+        // A mesh pattern paints its shading inside the path.
+        if let Some((sh, m)) = self.g.mesh.clone() {
+            let clips = self.g.clips.clone();
+            self.clip_with(bp, rule);
+            let r = self.mesh_fill(&sh, m);
+            self.g.clips = clips;
+            return r;
+        }
+        if self.g.paint.is_none() {
+            return Ok(());
         }
         let (paint, overprint) = (self.g.paint.clone(), self.g.overprint);
         self.out.fill(bp, rule, paint, overprint, &self.g.clips);
+        Ok(())
     }
 
     fn stroke_path(&mut self, bp: BezPath) {
-        if bp.elements().is_empty() || self.g.paint.is_none() {
+        if bp.elements().is_empty() || self.g.paint.is_none() || self.g.null {
             return;
         }
+        let st = self.stroke_layer();
+        self.out.stroke(bp, st, &self.g.clips);
+    }
+
+    /// The stroke the graphics state draws, in document space.
+    fn stroke_layer(&self) -> StrokeLayer {
         let k = self.scale();
         let w = self.g.width * k;
         let mut st = StrokeLayer::new(self.g.paint.clone(), if w > 0.0 && w.is_finite() { w } else { HAIRLINE });
@@ -462,30 +550,194 @@ impl Interp<'_> {
         let pattern: Vec<f64> = self.g.dash.iter().map(|d| d * k).collect();
         let dash = Dash { pattern, offset: self.g.dash_offset * k, align_corners: false };
         st.dash = dash.is_dashed().then_some(dash);
-        self.out.stroke(bp, st, &self.g.clips);
+        st
     }
 
-    fn take_path(&mut self) -> BezPath {
+    /// The current path in user space, each element as its operator and points (quadratic
+    /// segments as cubic ones).
+    fn user_elements(&self) -> Res<Vec<(Op, Vec<Point>)>> {
+        let xf = self.xf();
+        if xf.determinant().abs() < 1e-12 {
+            return ps_err("undefinedresult", "");
+        }
+        let inv = xf.inverse();
+        let mut last = Point::ZERO;
+        let mut out = Vec::with_capacity(self.g.path.elements().len());
+        for el in self.g.path.elements() {
+            let (op, pts) = match *el {
+                PathEl::MoveTo(p) => (Op::MoveTo, vec![p]),
+                PathEl::LineTo(p) => (Op::LineTo, vec![p]),
+                PathEl::QuadTo(a, p) => (Op::CurveTo, vec![last + (a - last) * (2.0 / 3.0), p + (a - p) * (2.0 / 3.0), p]),
+                PathEl::CurveTo(a, b, p) => (Op::CurveTo, vec![a, b, p]),
+                PathEl::ClosePath => (Op::ClosePath, vec![]),
+            };
+            last = pts.last().copied().unwrap_or(last);
+            out.push((op, pts.into_iter().map(|p| inv * p).collect()));
+        }
+        Ok(out)
+    }
+
+    /// `pathforall`: the current path in user space, each element through its procedure.
+    fn path_for_all(&mut self) -> Res {
+        let close = self.pop_proc()?;
+        let curve = self.pop_proc()?;
+        let line = self.pop_proc()?;
+        let mv = self.pop_proc()?;
+        for (op, pts) in self.user_elements()? {
+            for p in pts {
+                self.push_num(p.x)?;
+                self.push_num(p.y)?;
+            }
+            let proc = match op {
+                Op::MoveTo => &mv,
+                Op::LineTo => &line,
+                Op::CurveTo => &curve,
+                _ => &close,
+            };
+            if !self.body(proc)? {
+                break;
+            }
+        }
+        Ok(())
+    }
+
+    /// Append user path `up` to the current path: a procedure of path operators, or the encoded
+    /// form (numbers and a string of operator codes).
+    fn user_path(&mut self, up: Obj) -> Res {
+        let items = up.items().cloned().ok_or(PsError::Ps("typecheck", "a user path".into()))?;
+        let encoded = match (items.get(0), items.get(1), items.len()) {
+            (Some(nums @ (Obj::Array { .. } | Obj::Str(_))), Some(Obj::Str(ops)), 2) => Some((nums, ops.to_vec())),
+            _ => None,
+        };
+        let Some((nums, ops)) = encoded else { return self.call(Obj::Array { items, exec: true }) };
+        // The operators by code, with how many operands each takes.
+        const OPS: [(Op, usize); 12] = [
+            (Op::SetBBox, 4),
+            (Op::MoveTo, 2),
+            (Op::RMoveTo, 2),
+            (Op::LineTo, 2),
+            (Op::RLineTo, 2),
+            (Op::CurveTo, 6),
+            (Op::RCurveTo, 6),
+            (Op::Arc, 5),
+            (Op::Arcn, 5),
+            (Op::Arct, 5),
+            (Op::ClosePath, 0),
+            (Op::UCache, 0),
+        ];
+        let nums: Vec<f64> = match nums {
+            Obj::Array { items, .. } => items.borrow().iter().filter_map(Obj::as_num).collect(),
+            _ => return ps_err("typecheck", "an encoded user path"),
+        };
+        let mut next = nums.into_iter();
+        let mut repeat = 1usize;
+        for code in ops {
+            if code >= 32 {
+                repeat = usize::from(code - 32);
+                continue;
+            }
+            let &(op, n) = OPS.get(usize::from(code)).ok_or(PsError::Ps("rangecheck", "a user path".into()))?;
+            for _ in 0..std::mem::replace(&mut repeat, 1) {
+                for _ in 0..n {
+                    let v = next.next().ok_or(PsError::Ps("rangecheck", "a user path".into()))?;
+                    self.push_num(v)?;
+                }
+                self.op(op)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// `ufill`, `ueofill`, `ustroke` (with an optional matrix): paint a user path, keeping the
+    /// current path.
+    fn paint_user_path(&mut self, op: Op) -> Res {
+        let m = match (op, self.stack.last()) {
+            (Op::UStroke, Some(Obj::Array { items, exec: false })) if items.len() == 6 && self.stack.len() >= 2 => Some(self.pop_matrix()?),
+            _ => None,
+        };
+        let up = self.pop()?;
+        self.gsave()?;
+        let depth = self.saved.len();
+        self.take_path();
+        let r = self.user_path(up).and_then(|()| {
+            if let Some(m) = m {
+                self.g.ctm *= m;
+            }
+            let bp = self.take_path();
+            match op {
+                Op::UStroke => {
+                    self.stroke_path(bp);
+                    Ok(())
+                }
+                _ => self.fill_path(bp, if op == Op::UEoFill { FillRule::EvenOdd } else { FillRule::NonZero }),
+            }
+        });
+        self.saved.truncate(depth);
+        self.grestore();
+        r
+    }
+
+    /// `upath`: the current path as a user path (a procedure, in user space).
+    fn upath(&mut self) -> Res {
+        self.pop_bool()?;
+        let elements = self.user_elements()?;
+        let b = self.xf().inverse().transform_rect_bbox(self.g.path.bounding_box());
+        let mut items: Vec<Obj> = [b.x0, b.y0, b.x1, b.y1].into_iter().map(Obj::Real).collect();
+        items.push(Obj::Op(Op::SetBBox));
+        for (op, pts) in elements {
+            items.extend(pts.iter().flat_map(|p| [Obj::Real(p.x), Obj::Real(p.y)]));
+            items.push(Obj::Op(op));
+        }
+        self.alloc(items.len() * std::mem::size_of::<Obj>())?;
+        self.push(Obj::proc(items))
+    }
+
+    /// `execform`: the form's `PaintProc` run with its matrix, clipped to its box.
+    fn exec_form(&mut self) -> Res {
+        let d = self.pop_dict()?;
+        let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();
+        let m = get("Matrix").and_then(|o| o.items().and_then(|i| super::interp::matrix_of(&i.borrow()))).unwrap_or(Affine::IDENTITY);
+        let bbox: Vec<f64> = get("BBox").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();
+        let paint = get("PaintProc").ok_or(PsError::Ps("undefined", "PaintProc".into()))?;
+        self.gsave()?;
+        let depth = self.saved.len();
+        self.g.ctm *= m;
+        if let [x0, y0, x1, y1] = bbox[..] {
+            let bp = self.rect_path(x0, y0, x1 - x0, y1 - y0);
+            self.take_path();
+            self.clip_with(bp, FillRule::NonZero);
+        }
+        self.push(Obj::Dict(d))?;
+        let r = self.call(paint);
+        self.saved.truncate(depth);
+        self.grestore();
+        r
+    }
+
+    pub(super) fn take_path(&mut self) -> BezPath {
         self.g.cur = None;
         self.g.start = None;
         std::mem::take(&mut self.g.path)
     }
 
     fn clip_with(&mut self, path: BezPath, rule: FillRule) {
-        if let Some(c) = self.out.clip(path, rule) {
+        let Some(c) = self.out.clip(path, rule) else { return };
+        if self.g.clips.len() < MAX_NEST {
             self.g.clips.push(c);
+        } else {
+            self.out.warn(&deep_clips());
         }
     }
 
     /// The area the clip leaves, in document space (the page without a clip).
     fn clip_bounds(&self) -> Rect {
-        self.g.clips.last().map_or(self.out.frame, |c| c.path.bounding_box())
+        self.g.clips.iter().rev().find_map(|c| c.region.as_ref()).map_or(self.out.frame, |(p, _)| p.bounding_box())
     }
 
     // ---------- colour ----------
 
     /// A colour space operand.
-    fn space_of(&mut self, o: &Obj, depth: u32) -> Res<Space> {
+    pub(super) fn space_of(&mut self, o: &Obj, depth: u32) -> Res<Space> {
         if depth > 4 {
             return ps_err("limitcheck", "setcolorspace");
         }
@@ -503,7 +755,10 @@ impl Interp<'_> {
             "DeviceGray" | "CIEBasedA" | "CalGray" => Space::Gray,
             "DeviceRGB" | "CIEBasedABC" | "CalRGB" | "Lab" | "CIEBasedDEF" => Space::Rgb,
             "DeviceCMYK" | "CIEBasedDEFG" => Space::Cmyk,
-            "Pattern" => Space::Pattern,
+            "Pattern" => Space::Pattern(match items.get(1) {
+                Some(base) => Some(Rc::new(self.space_of(base, depth + 1)?)),
+                None => None,
+            }),
             "ICCBased" => match arg(1)? {
                 Obj::Dict(d) => match d.borrow().get(&Key::name("N")).and_then(Obj::as_num) {
                     Some(1.0) => Space::Gray,
@@ -517,6 +772,9 @@ impl Interp<'_> {
                     Obj::Array { items, .. } => items.borrow().iter().filter_map(Obj::text).collect(),
                     o => o.text().into_iter().collect(),
                 };
+                if names.len() > MAX_INKS {
+                    return ps_err("limitcheck", "DeviceN");
+                }
                 let alt = self.space_of(&arg(2)?, depth + 1)?;
                 Space::Inks { names, alt: Rc::new(alt), tint: arg(3)? }
             }
@@ -559,6 +817,7 @@ impl Interp<'_> {
     /// Set the colour to `comps` in the current space.
     fn set_comps(&mut self, comps: Vec<f64>) -> Res {
         let space = self.g.space.clone();
+        self.g.mesh = None;
         self.g.paint = self.paint_of(&space, &comps)?;
         self.g.comps = comps;
         Ok(())
@@ -601,7 +860,7 @@ impl Interp<'_> {
                 let c = table.get(i * n..i * n + n).ok_or(PsError::Ps("rangecheck", "setcolor".into()))?.to_vec();
                 Paint::solid(process(base, &c).unwrap_or(Color::BLACK))
             }
-            Space::Pattern => Paint::None,
+            Space::Pattern(_) => Paint::None,
             s => Paint::solid(process(s, comps).unwrap_or(Color::BLACK)),
         })
     }
@@ -625,29 +884,119 @@ impl Interp<'_> {
         self.g.paint.color().map_or([0.0; 3], |c| c.to_rgb_uncalibrated())
     }
 
-    /// A pattern colour: a shading pattern's gradient (others mid-grey).
-    fn pattern_paint(&mut self, d: &DictRef) -> Res<Paint> {
+    /// `setcolor` in a pattern space: the pattern operand, and before it an uncoloured
+    /// pattern's colour in the underlying space.
+    fn set_pattern(&mut self, base: Option<Rc<Space>>) -> Res {
+        let Obj::Dict(d) = self.pop()? else { return ps_err("typecheck", "") };
+        let uncoloured = d.borrow().get(&Key::name("PaintType")).and_then(Obj::as_num) == Some(2.0);
+        let under = match base.filter(|_| uncoloured) {
+            Some(base) => {
+                let mut c = vec![0.0; base.n()];
+                for slot in c.iter_mut().rev() {
+                    *slot = self.pop_num()?;
+                }
+                Some(self.paint_of(&base, &c)?)
+            }
+            None => None,
+        };
+        self.g.mesh = None;
+        self.g.paint = self.pattern_paint(&d, under)?;
+        Ok(())
+    }
+
+    /// A pattern colour: a shading pattern's gradient, a tiling pattern's swatch (`under`: the
+    /// colour an uncoloured one paints in).
+    fn pattern_paint(&mut self, d: &DictRef, under: Option<Paint>) -> Res<Paint> {
         let kind = d.borrow().get(&Key::name("PatternType")).and_then(Obj::as_num);
         let sh = d.borrow().get(&Key::name("Shading")).cloned();
+        let m = d.borrow().get(&Key::name("VCMatrix")).and_then(|o| o.items().and_then(|i| super::interp::matrix_of(&i.borrow())));
+        // Pattern space → the document.
+        let m = self.out.page * m.unwrap_or(self.g.ctm);
         match (kind, sh) {
-            (Some(2.0), Some(Obj::Dict(sh))) => {
-                let m = d.borrow().get(&Key::name("VCMatrix")).and_then(|o| o.items().and_then(|i| super::interp::matrix_of(&i.borrow())));
-                let m = self.out.page * m.unwrap_or(self.g.ctm);
-                Ok(self.gradient(&sh, m)?.map_or(Paint::None, |g| Paint::Gradient(Box::new(g))))
-            }
-            _ => {
-                self.out.warn(TILING_PATTERNS);
-                Ok(Paint::solid(Color::gray(0.5)))
+            (Some(2.0), Some(Obj::Dict(sh))) if is_mesh(&sh) => {
+                self.g.mesh = Some((sh, m));
+                Ok(Paint::None)
             }
+            (Some(2.0), Some(Obj::Dict(sh))) => Ok(self.gradient(&sh, m)?.map_or(Paint::None, |g| Paint::Gradient(Box::new(g)))),
+            (Some(2.0), _) => ps_err("typecheck", "Shading"),
+            _ => self.tiling(d, under, m),
         }
     }
 
+    /// A tiling pattern as a pattern swatch (made the first time): its `PaintProc` drawn in
+    /// pattern space, one cell of `XStep` × `YStep` from the corner of its `BBox`; `m` maps pattern
+    /// space onto the document.
+    fn tiling(&mut self, d: &DictRef, under: Option<Paint>, m: Affine) -> Res<Paint> {
+        let get = |k: &str| d.borrow().get(&Key::name(k)).cloned();
+        let bbox: Vec<f64> = get("BBox").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();
+        let [x0, y0, x1, y1] = bbox[..] else { return ps_err("rangecheck", "BBox") };
+        let step = |k: &str| get(k).and_then(|o| o.as_num()).map(f64::abs).filter(|v| v.is_finite() && *v > 1e-9 && *v < LIMIT);
+        let (Some(xs), Some(ys)) = (step("XStep"), step("YStep")) else { return ps_err("rangecheck", "XStep") };
+        let tile = Rect::from_origin_size((x0.min(x1), y0.min(y1)), (xs, ys));
+        let xf = m * Affine::translate(tile.origin().to_vec2());
+        let proc = get("PaintProc").ok_or(PsError::Ps("undefined", "PaintProc".into()))?;
+        let key = proc.items().cloned().ok_or(PsError::Ps("typecheck", "PaintProc".into()))?;
+        if let Some((.., name)) = self.out.tilings.iter().find(|(p, t, u, _)| p.same(&key) && *t == tile && *u == under) {
+            return Ok(Paint::Pattern { pattern: name.clone(), xf });
+        }
+        if self.out.apart >= MAX_APART {
+            self.out.warn(NESTED_PATTERNS);
+            return Ok(Paint::solid(Color::gray(0.5)));
+        }
+        let paint = under.clone();
+        let art = self.draw_apart(Rect::new(x0, y0, x1, y1).abs(), |it| {
+            if let Some(p) = paint {
+                it.g.paint = p;
+            }
+            it.push(Obj::Dict(d.clone()))?;
+            it.call(proc)
+        })?;
+        if art.is_empty() {
+            return Ok(Paint::None);
+        }
+        let name =
+            (self.out.doc.patterns.len() + 1..).map(|i| format!("Pattern {i}")).find(|n| self.out.doc.pattern(n).is_none()).unwrap_or_default();
+        let mut def = PatternDef::new(&name, art);
+        def.tile = tile;
+        self.out.doc.patterns.push(def);
+        self.out.tilings.push((key, tile, under, name.clone()));
+        Ok(Paint::Pattern { pattern: name, xf })
+    }
+
+    /// The art `draw` draws on its own, in its own space (user space is the document's, the page
+    /// `frame`), from a fresh graphics state with the current font: a pattern's cell, a glyph.
+    pub fn draw_apart(&mut self, frame: Rect, draw: impl FnOnce(&mut Self) -> Res) -> Res<Vec<Arc<Node>>> {
+        let fresh = GState { font: self.g.font.clone(), ..GState::default() };
+        let g = std::mem::replace(&mut self.g, fresh);
+        let saved = std::mem::take(&mut self.saved);
+        let drawn = std::mem::take(&mut self.out.drawn);
+        let page = std::mem::replace(&mut self.out.page, Affine::IDENTITY);
+        let frame = std::mem::replace(&mut self.out.frame, frame);
+        let merge = self.out.merge.take();
+        // The art isn't in the groups open around it.
+        let groups = std::mem::take(&mut self.out.groups);
+        let too_deep = std::mem::take(&mut self.out.too_deep);
+        self.out.apart += 1;
+        let r = draw(self);
+        self.out.apart -= 1;
+        let art = std::mem::replace(&mut self.out.drawn, drawn);
+        (self.out.page, self.out.frame, self.out.merge) = (page, frame, merge);
+        (self.out.groups, self.out.too_deep) = (groups, too_deep);
+        (self.g, self.saved) = (g, saved);
+        r?;
+        let mut nodes = vectorcraft_doc::clipnest::nest(&mut self.out.doc, art);
+        if !self.out.shadings.is_empty() {
+            collapse(&mut nodes, &self.out.shadings);
+        }
+        Ok(nodes)
+    }
+
     /// An axial or radial shading as a gradient, `m` mapping its space onto the document.
     fn gradient(&mut self, sh: &DictRef, m: Affine) -> Res<Option<GradientPaint>> {
         let get = |k: &str| sh.borrow().get(&Key::name(k)).cloned();
         let kind = get("ShadingType").and_then(|o| o.as_num()).unwrap_or(0.0);
-        if kind != 2.0 && kind != 3.0 {
-            self.out.warn("shadings other than axial and radial ones (meshes, functions) were left out");
+        if !is_gradient(sh) {
+            self.out.warn(UNKNOWN_SHADINGS);
             return Ok(None);
         }
         let space = self.space_of(&get("ColorSpace").ok_or(PsError::Ps("undefined", "ColorSpace".into()))?, 0)?;
@@ -674,7 +1023,7 @@ impl Interp<'_> {
         let (r0, r1) = (c(2).max(0.0), c(5).max(1e-6));
         let mut stops = Vec::with_capacity(ts.len());
         for t in ts {
-            let comps = self.eval(&f, d0 + (d1 - d0) * t, 0)?;
+            let comps = self.eval(&f, &[d0 + (d1 - d0) * t], 0)?;
             let paint = self.paint_of(&space, &comps)?;
             let offset = if radial { (r0 + (r1 - r0) * t) / r1 } else { t };
             let stop = match paint {
@@ -697,8 +1046,9 @@ impl Interp<'_> {
         Ok(Some(g))
     }
 
-    /// A function (types 2 and 3; an array of them, one per component) at `t`.
-    fn eval(&mut self, f: &Obj, t: f64, depth: u32) -> Res<Vec<f64>> {
+    /// A function (types 0, 2 and 3; an array of them, one per component) at `x` (types 2 and 3
+    /// take one input).
+    pub fn eval(&mut self, f: &Obj, x: &[f64], depth: u32) -> Res<Vec<f64>> {
         if depth > 8 {
             return ps_err("limitcheck", "Function");
         }
@@ -708,7 +1058,7 @@ impl Interp<'_> {
                 let fs = items.to_vec();
                 let mut out = vec![];
                 for g in &fs {
-                    out.extend(self.eval(g, t, depth + 1)?.first().copied());
+                    out.extend(self.eval(g, x, depth + 1)?.first().copied());
                 }
                 return Ok(out);
             }
@@ -719,11 +1069,13 @@ impl Interp<'_> {
             o.and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default()
         };
         let domain = nums(get("Domain"));
+        let t = x.first().copied().unwrap_or(0.0);
         let t = match domain.as_slice() {
             [a, b, ..] => t.clamp(a.min(*b), a.max(*b)),
             _ => t,
         };
         match get("FunctionType").and_then(|o| o.as_num()) {
+            Some(0.0) => self.sampled(&d, x),
             Some(2.0) => {
                 let c0 = nums(get("C0"));
                 let c1 = nums(get("C1"));
@@ -743,10 +1095,10 @@ impl Interp<'_> {
                 let (e0, e1) = (encode.get(2 * k).copied().unwrap_or(0.0), encode.get(2 * k + 1).copied().unwrap_or(1.0));
                 let u = if b != a { e0 + (t - a) / (b - a) * (e1 - e0) } else { e0 };
                 let g = fs.get(k).cloned().ok_or(PsError::Ps("rangecheck", "Functions".into()))?;
-                self.eval(&g, u, depth + 1)
+                self.eval(&g, &[u], depth + 1)
             }
             _ => {
-                self.out.warn(SAMPLED_FUNCTIONS);
+                self.out.warn(UNKNOWN_FUNCTIONS);
                 let r = nums(get("Range"));
                 Ok(r.chunks(2).map(|p| p.iter().sum::<f64>() / 2.0).collect())
             }
@@ -768,7 +1120,82 @@ impl Interp<'_> {
             }
             InitGraphics => {
                 let font = self.g.font.take();
-                self.g = GState { font, ..GState::default() };
+                self.g = GState { font, null: self.g.null, ..GState::default() };
+            }
+            NullDevice => {
+                self.g.null = true;
+                self.g.ctm = Affine::IDENTITY;
+                self.g.clips.clear();
+            }
+            ExecForm => self.exec_form()?,
+            StrokePath => {
+                let bp = self.take_path();
+                let mut st = self.stroke_layer();
+                // A dash pattern far finer than the path would make countless pieces.
+                let period: f64 = st.dash.as_ref().map_or(0.0, |d| d.pattern.iter().sum());
+                if st.dash.is_some() && !(period > 0.0 && bp.perimeter(1e-3) / period < MAX_DASHES) {
+                    st.dash = None;
+                }
+                let tol = (0.01 / self.scale().max(1e-9)).clamp(1e-4, 1.0);
+                let outline = vectorcraft_effects::stroke::line_outline(&bp, &st, st.width, tol);
+                if outline.elements().len() >= MAX_PATH {
+                    return Err(PsError::Limit("a path has too many points"));
+                }
+                self.g.cur = outline.elements().iter().rev().find_map(|e| e.end_point());
+                self.g.start = self.g.cur;
+                self.g.path = outline;
+            }
+            PathForAll => self.path_for_all()?,
+            UFill | UEoFill | UStroke => self.paint_user_path(op)?,
+            UAppend => {
+                let up = self.pop()?;
+                self.user_path(up)?;
+            }
+            UPath => self.upath()?,
+            SetBBox => {
+                self.nums::<4>()?;
+            }
+            CurrentHsbColor => {
+                let [r, g, b] = self.current_rgb();
+                let (max, min) = (r.max(g).max(b), r.min(g).min(b));
+                let d = max - min;
+                let h = if d <= 0.0 {
+                    0.0
+                } else if max == r {
+                    ((g - b) / d).rem_euclid(6.0) / 6.0
+                } else if max == g {
+                    ((b - r) / d + 2.0) / 6.0
+                } else {
+                    ((r - g) / d + 4.0) / 6.0
+                };
+                let s = if max > 0.0 { d / max } else { 0.0 };
+                for v in [h, s, max] {
+                    self.push_num(f64::from(v))?;
+                }
+            }
+            CurrentColorRendering => {
+                let d = super::obj::Dict::from([(Key::name("ColorRenderingType"), Obj::Int(1))]);
+                self.push(Obj::dict(d))?;
+            }
+            FindColorRendering => {
+                self.pop()?;
+                self.push(Obj::name("DefaultColorRendering"))?;
+                self.push(Obj::Bool(false))?;
+            }
+            CurrentColorScreen => {
+                for _ in 0..4 {
+                    self.push(Obj::Real(60.0))?;
+                    self.push(Obj::Real(45.0))?;
+                    self.push(Obj::proc(vec![]))?;
+                }
+            }
+            CurrentSmoothness => self.push(Obj::Real(0.02))?,
+            SetHalftonePhase => {
+                self.nums::<2>()?;
+            }
+            CurrentHalftonePhase => {
+                self.push(Obj::Int(0))?;
+                self.push(Obj::Int(0))?;
             }
             GStateNew => self.push(Obj::GState(Rc::new(self.g.clone())))?,
             CurrentGState => {
@@ -856,9 +1283,8 @@ impl Interp<'_> {
                 self.push(o)?;
             }
             SetColor => {
-                if matches!(*self.g.space, Space::Pattern) {
-                    let Obj::Dict(d) = self.pop()? else { return ps_err("typecheck", "") };
-                    self.g.paint = self.pattern_paint(&d)?;
+                if let Space::Pattern(base) = &*self.g.space {
+                    self.set_pattern(base.clone())?;
                 } else {
                     let n = self.g.space.n();
                     let mut c = vec![0.0; n];
@@ -873,11 +1299,14 @@ impl Interp<'_> {
                     self.push_num(v)?;
                 }
             }
+            // `[/Pattern <current space>] setcolorspace setcolor`, unless in a pattern space already.
             SetPattern => {
-                let Obj::Dict(d) = self.pop()? else { return ps_err("typecheck", "") };
-                self.g.space = Rc::new(Space::Pattern);
-                self.g.space_obj = Obj::name("Pattern");
-                self.g.paint = self.pattern_paint(&d)?;
+                if !matches!(*self.g.space, Space::Pattern(_)) {
+                    self.g.space = Rc::new(Space::Pattern(Some(self.g.space.clone())));
+                    self.g.space_obj = Obj::array(vec![Obj::name("Pattern"), self.g.space_obj.clone()]);
+                }
+                let Space::Pattern(base) = &*self.g.space else { return ps_err("typecheck", "") };
+                self.set_pattern(base.clone())?;
             }
             MakePattern => {
                 let m = self.pop_matrix()?;
@@ -1132,7 +1561,7 @@ impl Interp<'_> {
             }
             Fill | EoFill => {
                 let bp = self.take_path();
-                self.fill_path(bp, if op == EoFill { FillRule::EvenOdd } else { FillRule::NonZero });
+                self.fill_path(bp, if op == EoFill { FillRule::EvenOdd } else { FillRule::NonZero })?;
             }
             Stroke => {
                 let bp = self.take_path();
@@ -1140,7 +1569,7 @@ impl Interp<'_> {
             }
             RectFill => {
                 let bp = self.rects()?;
-                self.fill_path(bp, FillRule::NonZero);
+                self.fill_path(bp, FillRule::NonZero)?;
             }
             RectStroke => {
                 let m = match self.stack.last() {
@@ -1156,6 +1585,13 @@ impl Interp<'_> {
             }
             ShFill => {
                 let d = self.pop_dict()?;
+                if self.g.null {
+                    return Ok(());
+                }
+                if is_mesh(&d) {
+                    let m = self.xf();
+                    return self.mesh_fill(&d, m);
+                }
                 let m = self.xf();
                 if let Some(g) = self.gradient(&d, m)? {
                     let area = self.clip_bounds();
@@ -1174,6 +1610,16 @@ impl Interp<'_> {
     }
 }
 
+/// Is shading `sh` axial or radial (a gradient)?
+fn is_gradient(sh: &DictRef) -> bool {
+    matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(2.0 | 3.0))
+}
+
+/// Is shading `sh` one [`Interp::mesh_fill`] paints?
+fn is_mesh(sh: &DictRef) -> bool {
+    matches!(sh.borrow().get(&Key::name("ShadingType")).and_then(Obj::as_num), Some(1.0 | 4.0 | 5.0 | 6.0 | 7.0))
+}
+
 /// Where a stitched function of linear interpolations changes slope (its bounds), when it is
 /// one; `None` for functions that must be sampled.
 fn linear_points(f: &Obj) -> Option<Vec<f64>> {

crates/eps/src/import/interp.rs

@@ -10,7 +10,7 @@ use std::rc::Rc;
 use vectorcraft_geom::Affine;
 
 use super::graphics::{GState, Out};
-use super::lex::Lexer;
+use super::lex::{IMMEDIATE, Lexer};
 use super::obj::{Dict, DictRef, Key, Obj, Op, PsError, Res, Shared, ps_err};
 
 /// Most operations one file may run.
@@ -49,11 +49,29 @@ pub(crate) struct Interp<'a> {
     /// Bytes asked for so far (see [`MAX_MEMORY`]).
     allocated: usize,
     seed: u32,
+    /// Where the error that is unwinding was raised (see [`Fault`]).
+    pub fault: Option<Fault>,
+    /// The width a Type 3 glyph procedure gave (`setcachedevice`, `setcharwidth`).
+    pub glyph_width: Option<[f64; 2]>,
     pub g: GState,
     pub saved: Vec<GState>,
     pub out: Out,
+    /// The program is an Illustrator file's: its `u` … `U` (written at the top level, whatever
+    /// its prolog defines them as) are groups.
+    pub illustrator: bool,
 }
 
+/// Where a PostScript error was raised: the operator that raised it (none for an unknown name)
+/// and the named procedures it ran in, innermost first, so the user and we can see the cause.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub(crate) struct Fault {
+    pub op: Option<&'static str>,
+    pub procs: Vec<Rc<str>>,
+}
+
+/// Most procedure names a [`Fault`] keeps.
+const FAULT_PROCS: usize = 3;
+
 fn new_dict() -> DictRef {
     Rc::new(RefCell::new(Dict::new()))
 }
@@ -125,9 +143,12 @@ impl<'a> Interp<'a> {
             ops: 0,
             allocated: 0,
             seed: 1,
+            fault: None,
+            glyph_width: None,
             g,
             saved: vec![],
             out,
+            illustrator: false,
         }
     }
 
@@ -135,10 +156,27 @@ impl<'a> Interp<'a> {
     pub fn run(&mut self) -> Res {
         loop {
             let Some(o) = self.lex.next()? else { return Ok(()) };
+            let o = self.scanned(o, self.lex.immediate)?;
+            // An Illustrator group begins before its `u` runs (`Some(true)`) and ends after its `U`
+            // has (`Some(false)`).
+            let group = match &o {
+                Obj::Exec(name) if self.illustrator => match &**name {
+                    "u" => Some(true),
+                    "U" => Some(false),
+                    _ => None,
+                },
+                _ => None,
+            };
+            if group == Some(true) {
+                self.out.begin_group();
+            }
             match self.exec_token(o) {
                 Err(PsError::Quit) => return Ok(()),
                 r => r?,
             }
+            if group == Some(false) {
+                self.out.end_group();
+            }
         }
     }
 
@@ -222,7 +260,7 @@ impl<'a> Interp<'a> {
 
     pub fn pop_str(&mut self) -> Res<Shared<u8>> {
         match self.pop()? {
-            Obj::Str(s) => Ok(s),
+            Obj::Str(s) | Obj::ExecStr(s) => Ok(s),
             _ => ps_err("typecheck", "a string"),
         }
     }
@@ -253,8 +291,12 @@ impl<'a> Interp<'a> {
 
     /// The value of name `name` on the dictionary stack.
     pub fn lookup(&self, name: &Rc<str>) -> Option<Obj> {
-        let key = Key::Name(name.clone());
-        self.dicts.iter().rev().find_map(|d| d.borrow().get(&key).cloned())
+        self.lookup_key(&Key::Name(name.clone()))
+    }
+
+    /// The value of any key (`load` takes numbers too) on the dictionary stack.
+    fn lookup_key(&self, key: &Key) -> Option<Obj> {
+        self.dicts.iter().rev().find_map(|d| d.borrow().get(key).cloned())
     }
 
     /// Count `bytes` the program makes against [`MAX_MEMORY`].
@@ -286,10 +328,24 @@ impl<'a> Interp<'a> {
         self.tick()?;
         match o {
             Obj::Exec(name) => {
-                let v = self.lookup(&name).ok_or_else(|| PsError::Ps("undefined", name.to_string()))?;
-                self.call(v)
+                let Some(v) = self.lookup(&name) else {
+                    self.fault.get_or_insert_default();
+                    return ps_err("undefined", &name);
+                };
+                let proc = matches!(v, Obj::Array { exec: true, .. });
+                let r = self.call(v);
+                if proc
+                    && matches!(r, Err(PsError::Ps(..)))
+                    && let Some(f) = self.fault.as_mut()
+                    && f.procs.len() < FAULT_PROCS
+                {
+                    f.procs.push(name);
+                }
+                r
             }
             Obj::Op(op) => self.op(op),
+            // An executable string runs, as an operator does (procedures are pushed).
+            s @ Obj::ExecStr(_) => self.call(s),
             o => self.push(o),
         }
     }
@@ -299,7 +355,11 @@ impl<'a> Interp<'a> {
     pub fn call(&mut self, v: Obj) -> Res {
         match v {
             Obj::Array { items, exec: true } => self.run_proc(&items),
-            Obj::File { stream, exec: true } => self.run_file(&stream),
+            Obj::File { stream, exec: true } => match self.program_of(&stream)? {
+                Some(program) => self.run_program(&program),
+                None => Ok(()),
+            },
+            Obj::ExecStr(s) => self.run_program(&s.to_vec()),
             Obj::Op(op) => self.op(op),
             Obj::Exec(name) => {
                 self.enter()?;
@@ -329,15 +389,14 @@ impl<'a> Interp<'a> {
         r
     }
 
-    /// Run what is left of an executable file as a program, token by token.
-    fn run_file(&mut self, f: &Rc<RefCell<super::data::Stream>>) -> Res {
-        let Some(program) = self.program_of(f)? else { return Ok(()) };
+    /// Run `program` (what is left of an executable file, an executable string), token by token.
+    fn run_program(&mut self, program: &[u8]) -> Res {
         self.enter()?;
-        let mut lex = Lexer::new(&program);
+        let mut lex = Lexer::new(program);
         let r = loop {
             match lex.next() {
                 Ok(Some(o)) => {
-                    if let Err(e) = self.exec_token(o) {
+                    if let Err(e) = self.scanned(o, lex.immediate).and_then(|o| self.exec_token(o)) {
                         break Err(e);
                     }
                 }
@@ -349,6 +408,32 @@ impl<'a> Interp<'a> {
         r
     }
 
+    /// An object as the scanner gives it: with `immediate`, its `//name`s replaced by their
+    /// values (down through procedures), as they are when read.
+    pub fn scanned(&self, o: Obj, immediate: bool) -> Res<Obj> {
+        if immediate { self.resolve(o, 0) } else { Ok(o) }
+    }
+
+    fn resolve(&self, o: Obj, depth: usize) -> Res<Obj> {
+        match o {
+            Obj::Exec(n) if n.starts_with(IMMEDIATE) => {
+                let name = n.get(IMMEDIATE.len()..).unwrap_or_default();
+                self.lookup(&Rc::from(name)).ok_or_else(|| PsError::Ps("undefined", name.to_string()))
+            }
+            Obj::Array { items, exec: true } if depth < MAX_DEPTH as usize => {
+                for i in 0..items.len() {
+                    let Some(item) = items.get(i) else { break };
+                    if matches!(&item, Obj::Exec(n) if n.starts_with(IMMEDIATE)) || matches!(&item, Obj::Array { exec: true, .. }) {
+                        // A procedure the scanner just made: nothing else reads it.
+                        items.write(i, &[self.resolve(item, depth + 1)?]);
+                    }
+                }
+                Ok(Obj::Array { items, exec: true })
+            }
+            o => Ok(o),
+        }
+    }
+
     fn run_items(&mut self, items: &Shared<Obj>) -> Res {
         let mut i = 0;
         loop {
@@ -381,7 +466,11 @@ impl<'a> Interp<'a> {
 
     pub fn op(&mut self, op: Op) -> Res {
         self.op_inner(op).map_err(|e| match e {
-            PsError::Ps(name, at) if at.is_empty() => PsError::Ps(name, op.name().to_string()),
+            PsError::Ps(name, at) => {
+                // The innermost operator raised it (`exec` running a procedure doesn't).
+                self.fault.get_or_insert(Fault { op: Some(op.name()), procs: vec![] });
+                PsError::Ps(name, if at.is_empty() { op.name().to_string() } else { at })
+            }
             e => e,
         })
     }
@@ -663,6 +752,7 @@ impl<'a> Interp<'a> {
                     Ok(()) => self.push(Obj::Bool(false))?,
                     Err(PsError::Ps(..) | PsError::Stop | PsError::Exit) => {
                         self.depth = depth;
+                        self.fault = None;
                         self.push(Obj::Bool(true))?;
                     }
                     Err(e) => return Err(e),
@@ -679,6 +769,7 @@ impl<'a> Interp<'a> {
                 let o = match self.pop()? {
                     Obj::Array { items, .. } => Obj::Array { items, exec: true },
                     Obj::File { stream, .. } => Obj::File { stream, exec: true },
+                    Obj::Str(s) => Obj::ExecStr(s),
                     Obj::Name(n) => Obj::Exec(n),
                     o => o,
                 };
@@ -688,6 +779,7 @@ impl<'a> Interp<'a> {
                 let o = match self.pop()? {
                     Obj::Array { items, .. } => Obj::Array { items, exec: false },
                     Obj::File { stream, .. } => Obj::File { stream, exec: false },
+                    Obj::ExecStr(s) => Obj::Str(s),
                     Obj::Exec(n) => Obj::Name(n),
                     o => o,
                 };
@@ -695,7 +787,10 @@ impl<'a> Interp<'a> {
             }
             Xcheck => {
                 let o = self.pop()?;
-                self.push(Obj::Bool(matches!(o, Obj::Array { exec: true, .. } | Obj::File { exec: true, .. } | Obj::Exec(_) | Obj::Op(_))))?;
+                self.push(Obj::Bool(matches!(
+                    o,
+                    Obj::Array { exec: true, .. } | Obj::File { exec: true, .. } | Obj::ExecStr(_) | Obj::Exec(_) | Obj::Op(_)
+                )))?;
             }
             Cvn => {
                 let s = self.pop_str()?;
@@ -748,7 +843,7 @@ impl<'a> Interp<'a> {
             Length => {
                 let n = match self.pop()? {
                     Obj::Array { items, .. } => items.len(),
-                    Obj::Str(s) => s.len(),
+                    Obj::Str(s) | Obj::ExecStr(s) => s.len(),
                     Obj::Dict(d) => d.borrow().len(),
                     Obj::Name(n) | Obj::Exec(n) => n.len(),
                     _ => return ps_err("typecheck", ""),
@@ -764,7 +859,7 @@ impl<'a> Interp<'a> {
                 let k = self.pop()?;
                 let o = match self.pop()? {
                     Obj::Array { items, .. } => items.get(index(&k)?).ok_or(PsError::Ps("rangecheck", String::new()))?,
-                    Obj::Str(s) => Obj::Int(i64::from(s.get(index(&k)?).ok_or(PsError::Ps("rangecheck", String::new()))?)),
+                    Obj::Str(s) | Obj::ExecStr(s) => Obj::Int(i64::from(s.get(index(&k)?).ok_or(PsError::Ps("rangecheck", String::new()))?)),
                     Obj::Dict(d) => {
                         let key = k.key().ok_or(PsError::Ps("typecheck", String::new()))?;
                         let v = d.borrow().get(&key).cloned();
@@ -877,8 +972,8 @@ impl<'a> Interp<'a> {
             }
             Load => {
                 let k = self.pop()?;
-                let name = k.text().ok_or(PsError::Ps("typecheck", String::new()))?;
-                let v = self.lookup(&name).ok_or_else(|| PsError::Ps("undefined", name.to_string()))?;
+                let key = k.key().ok_or(PsError::Ps("typecheck", String::new()))?;
+                let v = self.lookup_key(&key).ok_or_else(|| PsError::Ps("undefined", show_text(&k)))?;
                 self.push(v)?;
             }
             Store => {
@@ -953,12 +1048,60 @@ impl<'a> Interp<'a> {
                 }
             }
             Version => self.push(Obj::string(b"3010".to_vec()))?,
+            Revision => self.push(Obj::Int(1))?,
+            SerialNumber => self.push(Obj::Int(0))?,
             Product => self.push(Obj::string(b"VectorCraft".to_vec()))?,
             RealTime | UserTime => self.push(Obj::Int(0))?,
             Print | EqPrint | EqEqPrint => {
                 self.pop()?;
             }
             Pstack | Stack | Flush => {}
+            // What every interpreter (not only a distiller) answers, as Ghostscript does: the marks
+            // are dropped.
+            PdfMark => {
+                self.pop_to_mark()?;
+            }
+            Gcheck | Scheck => {
+                self.pop()?;
+                self.push(Obj::Bool(false))?;
+            }
+            CurrentShared => self.push(Obj::Bool(false))?,
+            SetShared | SetVmThreshold | VmReclaim | Echo => {
+                self.pop()?;
+            }
+            ClearDictStack => self.dicts.truncate(3),
+            ExecStack => {
+                let items = self.pop_array()?;
+                self.push_interval(Obj::Array { items, exec: false }, 0, 0)?;
+            }
+            SetCacheParams => {
+                self.pop_to_mark()?;
+            }
+            CurrentCacheParams | UCacheStatus => {
+                self.push(Obj::Mark)?;
+                for _ in 0..if op == UCacheStatus { 5 } else { 2 } {
+                    self.push(Obj::Int(1 << 20))?;
+                }
+            }
+            CacheStatus => {
+                for _ in 0..7 {
+                    self.push(Obj::Int(0))?;
+                }
+            }
+            StartJob => {
+                self.pop()?;
+                self.pop()?;
+                self.push(Obj::Bool(false))?;
+            }
+            CurrentObjectFormat => self.push(Obj::Int(0))?,
+            SetDevParams => {
+                self.pop_dict()?;
+                self.pop()?;
+            }
+            CurrentDevParams => {
+                self.pop()?;
+                self.push(Obj::dict(Dict::new()))?;
+            }
             _ => self.graphics_op(op)?,
         }
         Ok(())
@@ -1014,6 +1157,7 @@ impl<'a> Interp<'a> {
         let r = match o {
             Obj::Array { items, exec } => Obj::Array { items: items.sub(at, n).ok_or_else(range)?, exec },
             Obj::Str(s) => Obj::Str(s.sub(at, n).ok_or_else(range)?),
+            Obj::ExecStr(s) => Obj::ExecStr(s.sub(at, n).ok_or_else(range)?),
             _ => return ps_err("typecheck", "getinterval"),
         };
         self.push(r)
@@ -1032,7 +1176,7 @@ impl<'a> Interp<'a> {
                     }
                 }
             }
-            Obj::Str(s) => {
+            Obj::Str(s) | Obj::ExecStr(s) => {
                 for b in s.to_vec() {
                     self.push(Obj::Int(i64::from(b)))?;
                     if !self.body(&p)? {
@@ -1192,7 +1336,7 @@ fn show_text(o: &Obj) -> String {
         }
         Obj::Bool(b) => b.to_string(),
         Obj::Name(n) | Obj::Exec(n) => n.to_string(),
-        Obj::Str(s) => String::from_utf8_lossy(&s.borrow()).into_owned(),
+        Obj::Str(s) | Obj::ExecStr(s) => String::from_utf8_lossy(&s.borrow()).into_owned(),
         Obj::Op(op) => op.name().to_string(),
         _ => "--nostringval--".into(),
     }

crates/eps/src/import/lex.rs

@@ -15,8 +15,14 @@ pub(crate) struct Lexer<'a> {
     /// The whitespace character that ended the last token is still unread (data the program
     /// reads from itself starts after it).
     fresh: bool,
+    /// The last object read has immediately evaluated names (`//name`) in it, read as executable
+    /// names starting with [`IMMEDIATE`] for the interpreter to replace by their values.
+    pub immediate: bool,
 }
 
+/// How an immediately evaluated name (`//name`) is read, until the interpreter replaces it.
+pub(crate) const IMMEDIATE: &str = "//";
+
 fn is_space(b: u8) -> bool {
     matches!(b, b' ' | b'\t' | b'\r' | b'\n' | b'\x0c' | b'\0')
 }
@@ -31,7 +37,7 @@ fn syntax<T>(what: &str) -> Res<T> {
 
 impl<'a> Lexer<'a> {
     pub fn new(src: &'a [u8]) -> Self {
-        Self { src, pos: 0, fresh: false }
+        Self { src, pos: 0, fresh: false, immediate: false }
     }
 
     /// What is left to read.
@@ -86,6 +92,7 @@ impl<'a> Lexer<'a> {
 
     /// The next object at the top level (`None` at the end of the file).
     pub fn next(&mut self) -> Res<Option<Obj>> {
+        self.immediate = false;
         let t = self.token(0);
         self.fresh = true;
         t
@@ -140,13 +147,14 @@ impl<'a> Lexer<'a> {
             }
             b'}' | b')' => return syntax(&char::from(b).to_string()),
             b'/' => {
-                // `//name` is looked up when run (rather than when read).
+                // `//name` stands for the name's value when it is read.
                 let immediate = self.peek() == Some(b'/');
                 if immediate {
                     self.pos += 1;
+                    self.immediate = true;
                 }
                 let name = self.word();
-                if immediate { Obj::Exec(Rc::from(name.as_str())) } else { Obj::Name(Rc::from(name.as_str())) }
+                if immediate { Obj::Exec(Rc::from(format!("{IMMEDIATE}{name}").as_str())) } else { Obj::Name(Rc::from(name.as_str())) }
             }
             _ => {
                 self.pos -= 1;

crates/eps/src/import/mod.rs

@@ -4,38 +4,51 @@
 //! - `lex`: the scanner; `obj`: objects, operators and errors; `interp`: the stacks, running
 //!   procedures, and the operators that don't draw.
 //! - `graphics`: the graphics state, coordinates, paths, colours (grey, RGB, CMYK, spot inks as
-//!   spot swatches at a tint, indexed), painting, clipping, and axial and radial shadings as
-//!   gradients.
+//!   spot swatches at a tint, indexed, patterns), painting, clipping, axial and radial shadings as
+//!   gradients and tiling patterns as pattern swatches.
+//! - `shading`: function-based and mesh shadings as gradient meshes, sampled functions.
 //! - `data`: data the program reads from itself through decoding filters, and images.
-//! - `text`: fonts by name and type as point type.
+//! - `text`: fonts by name and type as point type; Type 3 fonts' glyphs drawn by their procedures.
+//! - `preview`: the previews a file carries, for when its PostScript can't be read.
+//!
+//! Clipped art comes in as clipping groups. In an Illustrator file (Illustrator 3–8, written with
+//! the prolog that defines its operators), the groups it writes (`u` … `U`, nested) come in as
+//! groups.
 //!
 //! The page is the file's `%%BoundingBox` (`%%HiResBoundingBox` when it has one), the first page
 //! of a PostScript file without one. A file whose program can't be read (an operator the
-//! interpreter doesn't know, an error, a limit reached) or that draws nothing comes in as its TIFF
-//! preview, with a warning; without a preview, what was drawn before the error is kept (with a
-//! warning), else the file is refused.
+//! interpreter doesn't know, an error, a limit reached) or that draws nothing comes in as its
+//! preview (a TIFF image, a Windows metafile or an EPSI bitmap), with a warning that names the
+//! error, the operator and the procedures it ran in; without a preview, what was drawn before the
+//! error is kept (with that warning), else the file is refused.
 
 mod data;
 mod graphics;
 mod interp;
 mod lex;
 mod obj;
+mod preview;
+mod shading;
 mod text;
 
 #[cfg(test)]
 mod tests;
 #[cfg(test)]
 mod tests_fontnames;
+#[cfg(test)]
+mod tests_generators;
+#[cfg(test)]
+mod tests_illustrator;
 
 use std::sync::Arc;
 
 use vectorcraft_color::Paint;
 use vectorcraft_color::swatch::Swatch;
-use vectorcraft_doc::{ColorMode, Document, ImageBlob, ImageObject, LayerColor, Node, NodeKind};
+use vectorcraft_doc::{ColorMode, Document, LayerColor, Node};
 use vectorcraft_geom::{Affine, Rect};
 
 use graphics::{GState, Out};
-use interp::Interp;
+use interp::{Fault, Interp};
 use obj::PsError;
 
 pub use text::family_style;
@@ -60,6 +73,8 @@ struct Dsc {
     /// `llx lly urx ury` in PostScript's default space.
     bbox: Option<[f64; 4]>,
     pages: Option<u32>,
+    /// Written by Illustrator (or in its format): `%AI…` comments, or Illustrator the creator.
+    illustrator: bool,
 }
 
 /// The four numbers of a bounding box comment's value, when it has them and they make a box.
@@ -90,6 +105,10 @@ impl Dsc {
                 }
             }
             let value = |key: &str| line.strip_prefix(key).map(str::trim);
+            let creator = value("%%Creator:").is_some_and(|v| v.contains("Illustrator")); // brand-ok: the creator its files name
+            if header && (line.starts_with("%AI") || line.starts_with("%%AI") || creator) {
+                d.illustrator = true;
+            }
             if let Some(v) = value("%%HiResBoundingBox:") {
                 if header || atend {
                     hires = box_of(v).or(hires);
@@ -111,21 +130,33 @@ impl Dsc {
     }
 }
 
-/// What went wrong, for the user.
-fn reason(e: &PsError) -> String {
-    match e {
+/// What went wrong, for the user (and for us, reading a report): the PostScript error, the
+/// operator that raised it and the procedure it ran in (`fault`).
+fn reason(e: &PsError, fault: Option<&Fault>) -> String {
+    let what = match e {
         PsError::Ps("undefined", at) => format!("it uses `{at}`, which VectorCraft's PostScript reader doesn't know"),
-        PsError::Ps(name, at) if at.is_empty() => format!("a PostScript error ({name})"),
-        PsError::Ps(name, at) => format!("a PostScript error ({name} in `{at}`)"),
-        PsError::Limit(what) => what.to_string(),
-        PsError::Exit | PsError::Stop => "the program stopped with an error".into(),
-        PsError::Quit => "the program ended early".into(),
+        PsError::Ps(name, at) => match fault.and_then(|f| f.op) {
+            Some(op) if at.is_empty() || at == op => format!("a PostScript error ({name} in `{op}`)"),
+            Some(op) => format!("a PostScript error ({name} in `{op}`: {at})"),
+            None if at.is_empty() => format!("a PostScript error ({name})"),
+            None => format!("a PostScript error ({name} in `{at}`)"),
+        },
+        PsError::Limit(what) => return what.to_string(),
+        PsError::Exit | PsError::Stop => return "the program stopped with an error".into(),
+        PsError::Quit => return "the program ended early".into(),
+    };
+    match fault.map(|f| f.procs.as_slice()).unwrap_or_default() {
+        [] => what,
+        procs => {
+            let names: Vec<String> = procs.iter().map(|p| format!("`{p}`")).collect();
+            format!("{what}, in {}", names.join(" in "))
+        }
     }
 }
 
 /// Read an EPS or PostScript file (its first page).
 pub fn import(bytes: &[u8]) -> Result<Imported, String> {
-    let (ps, tiff) = crate::sections(bytes).ok_or("the file's preview header points outside the file")?;
+    let (ps, _) = crate::sections(bytes).ok_or("the file's preview header points outside the file")?;
     if !ps.starts_with(b"%!") {
         return Err("this is not a PostScript file".into());
     }
@@ -136,8 +167,10 @@ pub fn import(bytes: &[u8]) -> Result<Imported, String> {
     doc.layers.clear();
     let page = Affine::new([1.0, 0.0, 0.0, -1.0, -llx, ury]);
     let mut it = Interp::new(ps, GState::default(), Out::new(doc, page, frame));
+    it.illustrator = dsc.illustrator;
     let result = it.run();
     it.release();
+    let fault = it.fault.take();
     let mut out = it.out;
     if let Some(n) = dsc.pages.filter(|n| *n > 1) {
         out.warn(&format!("only the first of the file's {n} pages was read"));
@@ -146,11 +179,11 @@ pub fn import(bytes: &[u8]) -> Result<Imported, String> {
     let why = match (&result, drew) {
         (Ok(()), true) => return Ok(finish(out)),
         (Ok(()), false) => "it draws nothing VectorCraft's PostScript reader can show".to_string(),
-        (Err(e), _) => reason(e),
+        (Err(e), _) => reason(e, fault.as_ref()),
     };
-    if let Some(doc) = tiff.and_then(|t| preview(t, frame)) {
-        let warnings = vec![format!("this file's PostScript couldn't be read ({why}): its preview was placed instead, at screen resolution")];
-        return Ok(Imported { document: doc, warnings, preview: true });
+    if let Some(p) = preview::preview(bytes, ps, frame) {
+        let warnings = vec![format!("this file's PostScript couldn't be read ({why}): {}", p.what)];
+        return Ok(Imported { document: p.document, warnings, preview: true });
     }
     if drew {
         out.warnings.insert(0, format!("the file was read up to an error ({why}): what follows it was left out"));
@@ -161,12 +194,12 @@ pub fn import(bytes: &[u8]) -> Result<Imported, String> {
             out.warn("the file draws nothing");
             Ok(finish(out))
         }
-        Err(e) => Err(format!("this PostScript file can't be read ({}): save it as PDF or SVG in the app that made it", reason(&e))),
+        Err(e) => Err(format!("this PostScript file can't be read ({}): save it as PDF or SVG in the app that made it", reason(&e, fault.as_ref()))),
     }
 }
 
-/// The document of what `out` drew: one layer, clipped art in clipping groups, the spot inks as
-/// spot swatches, in CMYK when most process colours were.
+/// The document of what `out` drew: one layer, clipped art in clipping groups (grouped art in
+/// groups), the spot inks as spot swatches, in CMYK when most process colours were.
 fn finish(mut out: Out) -> Imported {
     let drawn = std::mem::take(&mut out.drawn);
     let mut children = vectorcraft_doc::clipnest::nest(&mut out.doc, drawn);
@@ -183,6 +216,12 @@ fn finish(mut out: Out) -> Imported {
             doc.swatches.push(Swatch { name, paint: Paint::solid(color), global: true, spot: true });
         }
     }
+    // Tiling patterns are pattern swatches.
+    for name in doc.patterns.iter().map(|p| p.name.clone()).collect::<Vec<_>>() {
+        if doc.swatch(&name).is_none() {
+            doc.swatches.push(Swatch { paint: Paint::Pattern { pattern: name.clone(), xf: Affine::IDENTITY }, name, global: false, spot: false });
+        }
+    }
     let mut layer = Node::layer(doc.alloc_id(), "Layer 1", LayerColor::Preset(0));
     if let Some(c) = layer.children_mut() {
         *c = children;
@@ -190,27 +229,3 @@ fn finish(mut out: Out) -> Imported {
     doc.layers = vec![Arc::new(layer)];
     Imported { document: doc, warnings: out.warnings, preview: false }
 }
-
-/// A document of `frame`'s size showing TIFF preview `tiff` stretched over it.
-fn preview(tiff: &[u8], frame: Rect) -> Option<Document> {
-    let img = match image::load_from_memory_with_format(tiff, image::ImageFormat::Tiff) {
-        Ok(img) => img.to_rgba8(),
-        Err(_) => crate::tiff::palette_rgba(tiff)?,
-    };
-    let (w, h) = img.dimensions();
-    if w == 0 || h == 0 {
-        return None;
-    }
-    let mut png = vec![];
-    img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).ok()?;
-    let mut doc = Document::new(frame.width(), frame.height());
-    let blob = ImageBlob::new("image/png", png);
-    let key = blob.content_key();
-    doc.images.insert(key.clone(), blob);
-    let xf = Affine::scale_non_uniform(frame.width() / f64::from(w), frame.height() / f64::from(h));
-    let mut n = Node::new(doc.alloc_id(), NodeKind::Image(ImageObject { key, width: w, height: h, xf, link: None, placement: Default::default() }));
-    n.name = Some("Preview".into());
-    let layer = doc.layers.first().map(|l| l.id)?;
-    doc.insert(Some(layer), 0, n).ok()?;
-    Some(doc)
-}

crates/eps/src/import/obj.rs

@@ -32,6 +32,8 @@ pub(crate) enum Obj {
     /// An executable name: looked up and run.
     Exec(Rc<str>),
     Str(Shared<u8>),
+    /// An executable string (`cvx`): run, it runs its text as a program.
+    ExecStr(Shared<u8>),
     /// An array; executable ones are procedures.
     Array {
         items: Shared<Obj>,
@@ -85,7 +87,7 @@ impl Obj {
     pub fn text(&self) -> Option<Rc<str>> {
         match self {
             Self::Name(n) | Self::Exec(n) => Some(n.clone()),
-            Self::Str(s) => Some(Rc::from(String::from_utf8_lossy(&s.borrow()).as_ref())),
+            Self::Str(s) | Self::ExecStr(s) => Some(Rc::from(String::from_utf8_lossy(&s.borrow()).as_ref())),
             _ => None,
         }
     }
@@ -117,7 +119,7 @@ impl Obj {
             Self::Int(_) => "integertype",
             Self::Real(_) => "realtype",
             Self::Name(_) | Self::Exec(_) => "nametype",
-            Self::Str(_) => "stringtype",
+            Self::Str(_) | Self::ExecStr(_) => "stringtype",
             Self::Array { .. } => "arraytype",
             Self::Dict(_) => "dicttype",
             Self::Op(_) => "operatortype",
@@ -326,5 +328,21 @@ ops! {
     ResourceForAll = "resourceforall", Show = "show", AShow = "ashow",
     WidthShow = "widthshow", AWidthShow = "awidthshow", XShow = "xshow", YShow = "yshow", XYShow = "xyshow",
     KShow = "kshow", CShow = "cshow", GlyphShow = "glyphshow", StringWidth = "stringwidth", CharPath = "charpath",
-    SetCacheDevice = "setcachedevice", SetCharWidth = "setcharwidth",
+    SetCacheDevice = "setcachedevice", SetCharWidth = "setcharwidth", SetCacheDevice2 = "setcachedevice2", RootFont = "rootfont",
+    // Forms, devices and files programs probe (no output device or file system here).
+    ExecForm = "execform", NullDevice = "nulldevice", PdfMark = "pdfmark", Status = "status", Token = "token",
+    BytesAvailable = "bytesavailable", ResetFile = "resetfile", Write = "write", WriteString = "writestring",
+    WriteHexString = "writehexstring", Echo = "echo", StrokePath = "strokepath", PathForAll = "pathforall",
+    // Queries and settings without an effect on the art.
+    CurrentHsbColor = "currenthsbcolor", CurrentColorRendering = "currentcolorrendering",
+    FindColorRendering = "findcolorrendering", CurrentColorScreen = "currentcolorscreen", CurrentSmoothness = "currentsmoothness",
+    SetHalftonePhase = "sethalftonephase", CurrentHalftonePhase = "currenthalftonephase", SetDevParams = "setdevparams",
+    CurrentDevParams = "currentdevparams", Gcheck = "gcheck", Scheck = "scheck", CurrentShared = "currentshared",
+    SetShared = "setshared", ClearDictStack = "cleardictstack", ExecStack = "execstack", SetCacheParams = "setcacheparams",
+    CurrentCacheParams = "currentcacheparams", CacheStatus = "cachestatus", UCacheStatus = "ucachestatus",
+    SetVmThreshold = "setvmthreshold", VmReclaim = "vmreclaim", StartJob = "startjob", CurrentObjectFormat = "currentobjectformat",
+    Revision = "revision", SerialNumber = "serialnumber", Read = "read", FilePosition = "fileposition",
+    SetFilePosition = "setfileposition", DeleteFile = "deletefile", RenameFile = "renamefile", Run = "run",
+    // User paths.
+    UFill = "ufill", UEoFill = "ueofill", UStroke = "ustroke", UAppend = "uappend", UPath = "upath", SetBBox = "setbbox",
 }

crates/eps/src/import/preview.rs

@@ -0,0 +1,110 @@
+//! The previews an EPS file carries for apps that don't read PostScript, opened when its
+//! PostScript can't be: a TIFF image or a Windows metafile behind the binary header, or an EPSI
+//! bitmap in comments, stretched over the page.
+
+use vectorcraft_doc::{Document, ImageBlob, ImageObject, Node, NodeKind};
+use vectorcraft_geom::{Affine, Rect};
+
+/// Largest EPSI bitmap side read (pixels).
+const MAX_EPSI: usize = 8192;
+
+/// A preview's document and how the user is told about it.
+pub(super) struct Preview {
+    pub document: Document,
+    /// What was opened instead ("its preview was placed instead, …").
+    pub what: &'static str,
+}
+
+/// The best preview of `bytes` (the whole file; `ps` its PostScript) over `frame`: the TIFF
+/// image, else the metafile's vectors, else the EPSI bitmap.
+pub(super) fn preview(bytes: &[u8], ps: &[u8], frame: Rect) -> Option<Preview> {
+    const IMAGE: &str = "its preview was placed instead, at screen resolution";
+    if let Some(document) = crate::sections(bytes).and_then(|(_, tiff)| tiff).and_then(tiff_rgba).and_then(|img| image_doc(img, frame)) {
+        return Some(Preview { document, what: IMAGE });
+    }
+    if let Some(document) = crate::metafile_preview(bytes).and_then(|wmf| metafile_doc(wmf, frame)) {
+        return Some(Preview { document, what: "its Windows metafile preview was opened instead, which may simplify the art" });
+    }
+    epsi(ps).and_then(|img| image_doc(img, frame)).map(|document| Preview { document, what: IMAGE })
+}
+
+fn tiff_rgba(tiff: &[u8]) -> Option<image::RgbaImage> {
+    match image::load_from_memory_with_format(tiff, image::ImageFormat::Tiff) {
+        Ok(img) => Some(img.to_rgba8()),
+        Err(_) => crate::tiff::palette_rgba(tiff),
+    }
+}
+
+/// A document of `frame`'s size showing `img` stretched over it.
+fn image_doc(img: image::RgbaImage, frame: Rect) -> Option<Document> {
+    let (w, h) = img.dimensions();
+    if w == 0 || h == 0 {
+        return None;
+    }
+    let mut png = vec![];
+    img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).ok()?;
+    let mut doc = Document::new(frame.width(), frame.height());
+    let blob = ImageBlob::new("image/png", png);
+    let key = blob.content_key();
+    doc.images.insert(key.clone(), blob);
+    let xf = Affine::scale_non_uniform(frame.width() / f64::from(w), frame.height() / f64::from(h));
+    let mut n = Node::new(doc.alloc_id(), NodeKind::Image(ImageObject { key, width: w, height: h, xf, link: None, placement: Default::default() }));
+    n.name = Some("Preview".into());
+    let layer = doc.layers.first().map(|l| l.id)?;
+    doc.insert(Some(layer), 0, n).ok()?;
+    Some(doc)
+}
+
+/// A document of `frame`'s size with the metafile's art stretched from its picture frame over it.
+fn metafile_doc(wmf: &[u8], frame: Rect) -> Option<Document> {
+    let mut doc = vectorcraft_metafile::import(wmf).ok()?.document;
+    let from = doc.artboards.first()?.rect;
+    if from.width() <= 0.0 || from.height() <= 0.0 {
+        return None;
+    }
+    let a = Affine::translate(frame.origin().to_vec2())
+        * Affine::scale_non_uniform(frame.width() / from.width(), frame.height() / from.height())
+        * Affine::translate(-from.origin().to_vec2());
+    for layer in &mut doc.layers {
+        let layer = std::sync::Arc::make_mut(layer);
+        for n in layer.children_mut().into_iter().flatten() {
+            std::sync::Arc::make_mut(n).transform(a, true);
+        }
+    }
+    if let Some(board) = doc.artboards.first_mut() {
+        board.rect = frame;
+    }
+    doc.layers.iter().any(|l| l.children().is_some_and(|c| !c.is_empty())).then_some(doc)
+}
+
+/// The EPSI preview in `ps`'s comments (`%%BeginPreview: width height depth lines`, hex rows,
+/// 0 white and the largest value black).
+fn epsi(ps: &[u8]) -> Option<image::RgbaImage> {
+    let text = String::from_utf8_lossy(ps);
+    let mut lines = text.lines();
+    let head = lines.find_map(|l| l.strip_prefix("%%BeginPreview:"))?;
+    let n: Vec<usize> = head.split_whitespace().map_while(|w| w.parse().ok()).collect();
+    let [w, h, depth, ..] = n[..] else { return None };
+    if !(1..=MAX_EPSI).contains(&w) || !(1..=MAX_EPSI).contains(&h) || ![1, 2, 4, 8].contains(&depth) {
+        return None;
+    }
+    let row = (w * depth).div_ceil(8);
+    let mut hex = Vec::with_capacity((row * h * 2).min(ps.len()));
+    for l in lines {
+        if l.starts_with("%%EndPreview") || hex.len() >= row * h * 2 {
+            break;
+        }
+        hex.extend(l.strip_prefix('%')?.bytes().filter(u8::is_ascii_hexdigit));
+    }
+    let bytes = super::lex::hex_decode(&hex)?;
+    let max = (1u32 << depth) - 1;
+    let mut img = image::RgbaImage::new(w as u32, h as u32);
+    for (x, y, px) in img.enumerate_pixels_mut() {
+        let bit = y as usize * row * 8 + x as usize * depth;
+        let byte = u32::from(bytes.get(bit / 8).copied().unwrap_or(0));
+        let v = (byte >> (8 - depth - bit % 8)) & max;
+        let grey = (255 - v * 255 / max) as u8;
+        *px = image::Rgba([grey, grey, grey, 255]);
+    }
+    Some(img)
+}

crates/eps/src/import/shading.rs

@@ -0,0 +1,376 @@
+//! Shadings that aren't gradients, as gradient meshes: function-based ones (type 1) sampled on a
+//! grid, free-form and lattice triangle meshes (types 4 and 5) and Coons and tensor patch meshes
+//! (types 6 and 7), their vertices read from an array or packed in a string or file; and sampled
+//! functions (type 0) that shadings and tint transforms use.
+
+use std::sync::Arc;
+
+use vectorcraft_color::{Color, Paint};
+use vectorcraft_doc::live::GradientMesh;
+use vectorcraft_doc::{Node, NodeId, NodeKind};
+use vectorcraft_geom::{Affine, Point};
+
+use super::graphics::Space;
+use super::interp::{Interp, matrix_of};
+use super::obj::{DictRef, Key, Obj, PsError, Res, ps_err};
+
+/// Most patches (or triangles) one shading makes: past it, it is left out with a warning.
+const MAX_PATCHES: usize = 4096;
+/// Rows and columns of the mesh a function-based shading is sampled on.
+const FUNCTION_GRID: u32 = 16;
+/// Most samples a sampled function has.
+const MAX_SAMPLES: usize = 1 << 24;
+/// Most outputs (colour components) a sampled function has.
+const MAX_OUTPUTS: usize = 32;
+/// Work one patch costs against the operation budget.
+const PATCH_OPS: u64 = 64;
+
+const TOO_MANY_PATCHES: &str = "shadings of more than 4096 patches or triangles were left out";
+
+/// The numbers of a shading's vertices: from an array, or packed in bits ([`Packed`]).
+enum Vertices {
+    Nums(Vec<f64>, usize),
+    Packed(Packed),
+}
+
+/// Vertex data packed in bits: flags, coordinates and colour components, each its own width and
+/// mapped through `Decode`.
+struct Packed {
+    bytes: Vec<u8>,
+    /// The next bit.
+    at: usize,
+    flag: u32,
+    coord: u32,
+    comp: u32,
+    decode: Vec<f64>,
+}
+
+impl Packed {
+    fn bits(&mut self, n: u32) -> Option<u64> {
+        if n == 0 || n > 32 || self.at.checked_add(n as usize)? > self.bytes.len() * 8 {
+            return None;
+        }
+        let mut v = 0u64;
+        for _ in 0..n {
+            let byte = *self.bytes.get(self.at / 8)?;
+            v = v << 1 | u64::from(byte >> (7 - self.at % 8) & 1);
+            self.at += 1;
+        }
+        Some(v)
+    }
+
+    /// A value of `n` bits through decode range `i` (`[min max]` pairs).
+    fn value(&mut self, n: u32, i: usize) -> Option<f64> {
+        let raw = self.bits(n)? as f64;
+        let max = ((1u64 << n) - 1) as f64;
+        let (lo, hi) = (self.decode.get(2 * i).copied().unwrap_or(0.0), self.decode.get(2 * i + 1).copied().unwrap_or(1.0));
+        Some(lo + raw * (hi - lo) / max)
+    }
+}
+
+impl Vertices {
+    fn flag(&mut self) -> Option<u32> {
+        match self {
+            Self::Nums(v, at) => {
+                let f = *v.get(*at)?;
+                *at += 1;
+                Some(f.max(0.0) as u32)
+            }
+            Self::Packed(p) => p.bits(p.flag).map(|f| f as u32),
+        }
+    }
+
+    fn num(&mut self, comp: bool, i: usize) -> Option<f64> {
+        match self {
+            Self::Nums(v, at) => {
+                let f = *v.get(*at)?;
+                *at += 1;
+                f.is_finite().then_some(f)
+            }
+            Self::Packed(p) => p.value(if comp { p.comp } else { p.coord }, i),
+        }
+    }
+
+    fn point(&mut self) -> Option<Point> {
+        Some(Point::new(self.num(false, 0)?, self.num(false, 1)?))
+    }
+
+    /// A vertex colour's `n` values (components, or the function's input).
+    fn color(&mut self, n: usize) -> Option<Vec<f64>> {
+        (0..n).map(|i| self.num(true, 2 + i)).collect()
+    }
+
+    /// Packed vertices start at a byte (triangle meshes).
+    fn align(&mut self) {
+        if let Self::Packed(p) = self {
+            p.at = p.at.div_ceil(8) * 8;
+        }
+    }
+}
+
+impl Interp<'_> {
+    /// Paint shading `sh` (types 1, 4–7) as gradient meshes, `m` mapping shading space onto the
+    /// document, under the current clip.
+    pub fn mesh_fill(&mut self, sh: &DictRef, m: Affine) -> Res {
+        let get = |k: &str| sh.borrow().get(&Key::name(k)).cloned();
+        let kind = get("ShadingType").and_then(|o| o.as_num()).unwrap_or(0.0);
+        let space = self.space_of(&get("ColorSpace").ok_or(PsError::Ps("undefined", "ColorSpace".into()))?, 0)?;
+        let function = get("Function");
+        let meshes = if kind == 1.0 { self.function_mesh(sh, &space, m)? } else { self.patch_mesh(sh, kind, &space, function.as_ref(), m)? };
+        let Some(meshes) = meshes else {
+            self.out.warn(TOO_MANY_PATCHES);
+            return Ok(());
+        };
+        let mut nodes: Vec<Node> = meshes.into_iter().map(|g| Node::new(NodeId(0), NodeKind::Mesh(g))).collect();
+        let node = match nodes.len() {
+            0 => return Ok(()),
+            1 => nodes.swap_remove(0),
+            _ => {
+                let children = nodes
+                    .into_iter()
+                    .map(|mut n| {
+                        n.id = self.out.doc.alloc_id();
+                        Arc::new(n)
+                    })
+                    .collect();
+                Node::group(NodeId(0), children)
+            }
+        };
+        let clips = self.g.clips.clone();
+        self.out.push(node, &clips);
+        Ok(())
+    }
+
+    /// The colour of a vertex's values `v`: through the shading's function when it has one.
+    fn vertex_color(&mut self, space: &Space, function: Option<&Obj>, v: &[f64]) -> Res<Color> {
+        let comps = match function {
+            Some(f) => self.eval(f, v, 0)?,
+            None => v.to_vec(),
+        };
+        Ok(match self.paint_of(space, &comps)? {
+            Paint::Solid { color, .. } => color,
+            _ => Color::BLACK,
+        })
+    }
+
+    /// A function-based shading (type 1) sampled on a grid over its domain.
+    fn function_mesh(&mut self, sh: &DictRef, space: &Space, m: Affine) -> Res<Option<Vec<GradientMesh>>> {
+        let get = |k: &str| sh.borrow().get(&Key::name(k)).cloned();
+        let domain: Vec<f64> = get("Domain").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();
+        let [x0, x1, y0, y1] = <[f64; 4]>::try_from(domain).unwrap_or([0.0, 1.0, 0.0, 1.0]);
+        let f = get("Function").ok_or(PsError::Ps("undefined", "Function".into()))?;
+        let matrix = get("Matrix").and_then(|o| o.items().and_then(|i| matrix_of(&i.borrow()))).unwrap_or(Affine::IDENTITY);
+        let n = FUNCTION_GRID as usize;
+        let at = |i: usize, lo: f64, hi: f64| lo + (hi - lo) * i as f64 / n as f64;
+        let mut colors = Vec::with_capacity((n + 1) * (n + 1));
+        for r in 0..=n {
+            for c in 0..=n {
+                self.spend(PATCH_OPS)?;
+                colors.push(self.vertex_color(space, Some(&f), &[at(c, x0, x1), at(r, y0, y1)])?);
+            }
+        }
+        let xf = m * matrix;
+        let surface = |u: f64, v: f64| xf * Point::new(x0 + (x1 - x0) * u, y0 + (y1 - y0) * v);
+        let color = |u: f64, v: f64| {
+            let (c, r) = ((u * n as f64).round() as usize, (v * n as f64).round() as usize);
+            colors.get(r * (n + 1) + c).copied().unwrap_or(Color::BLACK)
+        };
+        Ok(Some(vec![GradientMesh::from_surface(FUNCTION_GRID, FUNCTION_GRID, &surface, &color)]))
+    }
+
+    /// The vertices of a mesh shading's `DataSource`.
+    fn vertices(&mut self, sh: &DictRef, flags: bool) -> Res<Vertices> {
+        let get = |k: &str| sh.borrow().get(&Key::name(k)).cloned();
+        let bytes = match get("DataSource").ok_or(PsError::Ps("undefined", "DataSource".into()))? {
+            Obj::Array { items, .. } => {
+                let v: Option<Vec<f64>> = items.borrow().iter().map(Obj::as_num).collect();
+                return Ok(Vertices::Nums(v.ok_or(PsError::Ps("typecheck", "DataSource".into()))?, 0));
+            }
+            Obj::Str(s) => s.to_vec(),
+            Obj::File { stream, .. } => self.peek_all(&stream)?,
+            _ => return ps_err("typecheck", "DataSource"),
+        };
+        let bits = |k: &str| get(k).and_then(|o| o.as_num()).filter(|v| (1.0..=32.0).contains(v)).map(|v| v as u32);
+        let (Some(coord), Some(comp)) = (bits("BitsPerCoordinate"), bits("BitsPerComponent")) else {
+            return ps_err("rangecheck", "BitsPerCoordinate");
+        };
+        let flag = if flags { bits("BitsPerFlag").ok_or(PsError::Ps("rangecheck", "BitsPerFlag".into()))? } else { 0 };
+        let decode: Vec<f64> = get("Decode").and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default();
+        Ok(Vertices::Packed(Packed { bytes, at: 0, flag, coord, comp, decode }))
+    }
+
+    /// A triangle (types 4, 5) or patch (6, 7) mesh in the document (`m`); `None` past
+    /// [`MAX_PATCHES`].
+    fn patch_mesh(&mut self, sh: &DictRef, kind: f64, space: &Space, function: Option<&Obj>, m: Affine) -> Res<Option<Vec<GradientMesh>>> {
+        let n = if function.is_some() { 1 } else { space.n() };
+        let mut v = self.vertices(sh, kind != 5.0)?;
+        let mut corner = |it: &mut Self, v: &mut Vertices| -> Res<Option<Color>> {
+            match v.color(n) {
+                Some(c) => it.vertex_color(space, function, &c).map(Some),
+                None => Ok(None),
+            }
+        };
+        if kind == 6.0 || kind == 7.0 {
+            return self.patches(&mut v, kind == 7.0, m, &mut corner);
+        }
+        let per_row = sh.borrow().get(&Key::name("VerticesPerRow")).and_then(Obj::as_num).filter(|r| (2.0..=1e6).contains(r)).map(|r| r as usize);
+        let lattice = kind == 5.0;
+        let mut pts: Vec<(Point, Color)> = vec![];
+        let mut tris: Vec<[usize; 3]> = vec![];
+        // Free-form: vertices still to come of the triangle being made.
+        let mut left = 0;
+        loop {
+            let flag = if lattice { 0 } else { v.flag().unwrap_or(u32::MAX) };
+            let Some(p) = v.point().filter(|_| flag != u32::MAX) else { break };
+            let Some(color) = corner(self, &mut v)? else { break };
+            if !lattice {
+                v.align();
+            }
+            self.spend(PATCH_OPS)?;
+            pts.push((m * p, color));
+            let i = pts.len() - 1;
+            if lattice {
+                // Each cell between two rows is two triangles.
+                if let Some(w) = per_row
+                    && i >= w
+                    && !i.is_multiple_of(w)
+                {
+                    tris.push([i - w - 1, i - w, i - 1]);
+                    tris.push([i - w, i - 1, i]);
+                }
+            } else if left > 0 {
+                // A vertex ending a triangle begun with flag 0.
+                left -= 1;
+                if left == 0 && i >= 2 {
+                    tris.push([i - 2, i - 1, i]);
+                }
+            } else {
+                // A triangle on the last one's edge (flag 1: its second and third vertices, 2: its
+                // first and third), or the first vertex of a new one.
+                match (flag, tris.last().copied()) {
+                    (1, Some([_, b, c])) => tris.push([b, c, i]),
+                    (2, Some([a, _, c])) => tris.push([a, c, i]),
+                    _ => left = 2,
+                }
+            }
+            if tris.len() > MAX_PATCHES {
+                return Ok(None);
+            }
+        }
+        let at = |i: usize| pts.get(i).copied().unwrap_or((Point::ZERO, Color::BLACK));
+        Ok(Some(tris.iter().filter_map(|t| GradientMesh::triangle(t.map(at))).collect()))
+    }
+
+    /// Coons (`tensor`: tensor-product) patches: twelve boundary points (a tensor patch's four
+    /// inner ones are read and left out), four corner colours; a patch on the last one's edge
+    /// (flag 1–3) takes that edge's four points and two colours from it.
+    fn patches(
+        &mut self,
+        v: &mut Vertices,
+        tensor: bool,
+        m: Affine,
+        corner: &mut impl FnMut(&mut Self, &mut Vertices) -> Res<Option<Color>>,
+    ) -> Res<Option<Vec<GradientMesh>>> {
+        let mut out = vec![];
+        let mut prev: Option<([Point; 12], [Color; 4])> = None;
+        while let Some(flag) = v.flag() {
+            let shared = match (flag, &prev) {
+                (0, _) => None,
+                (1, Some((p, c))) => Some(([p[3], p[4], p[5], p[6]], [c[1], c[2]])),
+                (2, Some((p, c))) => Some(([p[6], p[7], p[8], p[9]], [c[2], c[3]])),
+                (3, Some((p, c))) => Some(([p[9], p[10], p[11], p[0]], [c[3], c[0]])),
+                _ => return ps_err("rangecheck", "a patch flag"),
+            };
+            let mut cp = [Point::ZERO; 12];
+            let mut colors = [Color::BLACK; 4];
+            let (first_point, first_color) = match shared {
+                Some((pts, cs)) => {
+                    cp[..4].copy_from_slice(&pts);
+                    colors[..2].copy_from_slice(&cs);
+                    (4, 2)
+                }
+                None => (0, 0),
+            };
+            for slot in cp.iter_mut().skip(first_point) {
+                let Some(p) = v.point() else { return Ok(Some(out)) };
+                *slot = m * p;
+            }
+            if tensor && (0..4).any(|_| v.point().is_none()) {
+                return Ok(Some(out));
+            }
+            for slot in colors.iter_mut().skip(first_color) {
+                let Some(c) = corner(self, v)? else { return Ok(Some(out)) };
+                *slot = c;
+            }
+            self.spend(PATCH_OPS)?;
+            if out.len() >= MAX_PATCHES {
+                return Ok(None);
+            }
+            out.extend(GradientMesh::coons(&cp, colors));
+            prev = Some((cp, colors));
+        }
+        Ok(Some(out))
+    }
+
+    /// A sampled function (type 0) at `x`: the samples around it, interpolated linearly for
+    /// one input, the nearest one for more.
+    pub(super) fn sampled(&mut self, f: &DictRef, x: &[f64]) -> Res<Vec<f64>> {
+        let get = |k: &str| f.borrow().get(&Key::name(k)).cloned();
+        let nums =
+            |k: &str| -> Vec<f64> { get(k).and_then(|o| o.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())).unwrap_or_default() };
+        let (domain, range, size) = (nums("Domain"), nums("Range"), nums("Size"));
+        let m = domain.len() / 2;
+        let outs = range.len() / 2;
+        if m == 0 || outs == 0 || outs > MAX_OUTPUTS || size.len() < m || size.iter().any(|s| !(1.0..=MAX_SAMPLES as f64).contains(s)) {
+            return ps_err("rangecheck", "a sampled function");
+        }
+        let bps =
+            get("BitsPerSample").and_then(|o| o.as_num()).filter(|b| [1.0, 2.0, 4.0, 8.0, 12.0, 16.0, 24.0, 32.0].contains(b)).map(|b| b as usize);
+        let bps = bps.ok_or(PsError::Ps("rangecheck", "BitsPerSample".into()))?;
+        if size.iter().take(m).try_fold(1usize, |acc, s| acc.checked_mul(*s as usize)).is_none_or(|t| t > MAX_SAMPLES) {
+            return ps_err("limitcheck", "Size");
+        }
+        let bytes = match get("DataSource") {
+            Some(Obj::Str(s)) => s.to_vec(),
+            Some(Obj::File { stream, .. }) => self.peek_all(&stream)?,
+            _ => return ps_err("typecheck", "DataSource"),
+        };
+        let (encode, decode) = (nums("Encode"), nums("Decode"));
+        let max = ((1u64 << bps) - 1) as f64;
+        let sample = |index: usize, j: usize| -> f64 {
+            let bit = (index as u64 * outs as u64 + j as u64) * bps as u64;
+            let raw = (0..bps as u64).fold(0u64, |v, k| {
+                let b = usize::try_from((bit + k) / 8).ok().and_then(|i| bytes.get(i)).copied().unwrap_or(0);
+                v << 1 | u64::from(b >> (7 - (bit + k) % 8) & 1)
+            }) as f64;
+            let (d0, d1) = (
+                decode.get(2 * j).or(range.get(2 * j)).copied().unwrap_or(0.0),
+                decode.get(2 * j + 1).or(range.get(2 * j + 1)).copied().unwrap_or(1.0),
+            );
+            let (r0, r1) = (range.get(2 * j).copied().unwrap_or(0.0), range.get(2 * j + 1).copied().unwrap_or(1.0));
+            (d0 + raw * (d1 - d0) / max).clamp(r0.min(r1), r0.max(r1))
+        };
+        // Each input into sample space.
+        let mut pos = Vec::with_capacity(m);
+        for i in 0..m {
+            let (a, b) = (domain.get(2 * i).copied().unwrap_or(0.0), domain.get(2 * i + 1).copied().unwrap_or(1.0));
+            let s = size.get(i).copied().unwrap_or(1.0);
+            let (e0, e1) = (encode.get(2 * i).copied().unwrap_or(0.0), encode.get(2 * i + 1).copied().unwrap_or(s - 1.0));
+            let xi = x.get(i).copied().unwrap_or(a).clamp(a.min(b), a.max(b));
+            let e = if b != a { e0 + (xi - a) * (e1 - e0) / (b - a) } else { e0 };
+            pos.push(e.clamp(0.0, s - 1.0));
+        }
+        if let ([p], Some(s)) = (pos.as_slice(), size.first()) {
+            let (lo, hi) = (p.floor() as usize, (p.ceil() as usize).min(*s as usize - 1));
+            let t = p - p.floor();
+            return Ok((0..outs).map(|j| sample(lo, j) * (1.0 - t) + sample(hi, j) * t).collect());
+        }
+        let mut index = 0;
+        let mut stride = 1;
+        for (i, p) in pos.iter().enumerate() {
+            index += p.round() as usize * stride;
+            stride *= size.get(i).copied().unwrap_or(1.0) as usize;
+        }
+        Ok((0..outs).map(|j| sample(index, j)).collect())
+    }
+}

crates/eps/src/import/tests.rs

@@ -11,21 +11,21 @@ use crate::import::{Dsc, import};
 use crate::{EpsOptions, Level, Preview, Raster};
 
 /// `body` as an EPS file with a 100 × 100 pt bounding box.
-fn eps(body: &str) -> Vec<u8> {
+pub(super) fn eps(body: &str) -> Vec<u8> {
     format!("%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 100 100\n%%EndComments\n{body}\nshowpage\n%%EOF\n").into_bytes()
 }
 
-fn read(body: &str) -> crate::Imported {
+pub(super) fn read(body: &str) -> crate::Imported {
     import(&eps(body)).unwrap()
 }
 
 /// The objects of the document's layer.
-fn objects(d: &Document) -> Vec<Arc<Node>> {
+pub(super) fn objects(d: &Document) -> Vec<Arc<Node>> {
     d.layers[0].children().unwrap().clone()
 }
 
 /// Every object, down through groups, in order.
-fn all(d: &Document) -> Vec<Arc<Node>> {
+pub(super) fn all(d: &Document) -> Vec<Arc<Node>> {
     fn walk(n: &Arc<Node>, out: &mut Vec<Arc<Node>>) {
         out.push(n.clone());
         for c in n.children().into_iter().flatten() {
@@ -39,25 +39,25 @@ fn all(d: &Document) -> Vec<Arc<Node>> {
     out
 }
 
-fn fill(n: &Node) -> Option<&Paint> {
+pub(super) fn fill(n: &Node) -> Option<&Paint> {
     n.appearance.items.iter().find_map(|i| match i {
         AppearanceItem::Fill(f) => Some(&f.paint),
         _ => None,
     })
 }
 
-fn stroke(n: &Node) -> Option<&vectorcraft_doc::StrokeLayer> {
+pub(super) fn stroke(n: &Node) -> Option<&vectorcraft_doc::StrokeLayer> {
     n.appearance.items.iter().find_map(|i| match i {
         AppearanceItem::Stroke(s) => Some(s),
         _ => None,
     })
 }
 
-fn bounds(n: &Node) -> Rect {
+pub(super) fn bounds(n: &Node) -> Rect {
     n.geometric_bounds().unwrap()
 }
 
-fn near(a: Rect, b: Rect) -> bool {
+pub(super) fn near(a: Rect, b: Rect) -> bool {
     [(a.x0, b.x0), (a.y0, b.y0), (a.x1, b.x1), (a.y1, b.y1)].iter().all(|(x, y)| (x - y).abs() < 0.05)
 }
 
@@ -195,6 +195,20 @@ fn clips_become_clipping_groups() {
     assert!(matches!(o[0].kind, NodeKind::Group { clip: true, .. }));
 }
 
+#[test]
+fn clips_nest_only_so_deep() {
+    // Each clip inside the last one used to nest a clipping group one level deeper, past the stack.
+    let r = read("1 1 200000 { pop 0 0 50 50 rectclip } for 1 1 5 5 rectfill");
+    let mut depth = 0;
+    let mut n = objects(&r.document)[0].clone();
+    while let NodeKind::Group { children, clip: true } = &n.kind {
+        depth += 1;
+        n = children.last().unwrap().clone();
+    }
+    assert_eq!(depth, vectorcraft_doc::clipnest::MAX_NEST);
+    assert!(r.warnings.iter().any(|w| w.contains("clips nested more than")), "{:?}", r.warnings);
+}
+
 #[test]
 fn shadings_become_gradients() {
     let axial =
@@ -463,7 +477,7 @@ fn blue(body: &str) {
 }
 
 /// Check that PostScript `cond` leaves `true`.
-fn check(cond: &str) {
+pub(super) fn check(cond: &str) {
     blue(&format!("{cond} {{ 0 0 1 setrgbcolor }} {{ 1 0 0 setrgbcolor }} ifelse"));
 }
 

crates/eps/src/import/tests_generators.rs

@@ -0,0 +1,993 @@
+//! EPS as other apps write it: for each common generator, a short hand-written program with the
+//! constructs its files typically use (its prolog's kind of procedures, how it sets colour, fills
+//! with gradients and patterns, places images and sets type), each read as vectors without a
+//! fallback to the preview. No generator's files or prologs are copied: these reproduce the
+//! PostScript constructs only.
+
+use vectorcraft_color::{Color, Paint};
+use vectorcraft_doc::{ColorMode, Document, Node, NodeKind};
+use vectorcraft_geom::{FillRule, Point, Rect};
+
+use super::tests::{all, bounds, fill, near, objects, read, stroke};
+use crate::import::{Imported, import};
+use crate::ps::{ascii85, deflate};
+
+/// An EPS file of a 200 × 150 pt page made by `creator`.
+fn file(creator: &str, program: &str) -> Vec<u8> {
+    format!("%!PS-Adobe-3.0 EPSF-3.0\n%%Creator: {creator}\n%%BoundingBox: 0 0 200 150\n%%LanguageLevel: 3\n%%EndComments\n{program}\n%%EOF\n")
+        .into_bytes()
+}
+
+/// `r` came in as vectors, without a warning of an error or of art left out.
+fn clean(r: &Imported) {
+    assert!(!r.preview, "{:?}", r.warnings);
+    let bad = ["error", "couldn't", "left out", "mid-grey", "middle colour", "unknown"];
+    assert!(r.warnings.iter().all(|w| !bad.iter().any(|b| w.contains(b))), "{:?}", r.warnings);
+}
+
+fn open(creator: &str, program: &str) -> Imported {
+    let r = import(&file(creator, program)).unwrap();
+    clean(&r);
+    r
+}
+
+/// The objects of `kind` (`Node::kind_label`), down through groups.
+fn of_kind(d: &Document, kind: &str) -> Vec<std::sync::Arc<Node>> {
+    all(d).into_iter().filter(|n| n.kind_label() == kind).collect()
+}
+
+/// ASCII85 of Flate-compressed `data`, as inline data after an operator.
+fn a85_flate(data: &[u8]) -> String {
+    ascii85(&deflate(data))
+}
+
+/// Pixel `(x, y)` (straight RGBA) of the first image in `d`.
+fn pixel(d: &Document, x: u32, y: u32) -> [u8; 4] {
+    let im = all(d)
+        .into_iter()
+        .find_map(|n| match &n.kind {
+            NodeKind::Image(im) => Some(im.key.clone()),
+            _ => None,
+        })
+        .unwrap();
+    let img = image::load_from_memory(&d.images[&im].bytes).unwrap().to_rgba8();
+    img.get_pixel(x, y).0
+}
+
+/// A Coons or tensor patch (type 7: sixteen points) in the packed form of a mesh shading with
+/// 8-bit flags, 32-bit coordinates over `[0 200 0 150]` and 16-bit colour components.
+fn patch(points: &[(f64, f64)], colors: &[[f64; 3]]) -> Vec<u8> {
+    let mut v = vec![0u8];
+    for (x, y) in points {
+        v.extend(((x / 200.0 * f64::from(u32::MAX)).round() as u32).to_be_bytes());
+        v.extend(((y / 150.0 * f64::from(u32::MAX)).round() as u32).to_be_bytes());
+    }
+    for c in colors {
+        for k in c {
+            v.extend(((k * 65535.0).round() as u16).to_be_bytes());
+        }
+    }
+    v
+}
+
+/// The twelve boundary points of the square patch `(x0, y0)`–`(x1, y1)` in shading order (up its
+/// left side, along its top, down its right side, back along its bottom).
+fn square(x0: f64, y0: f64, x1: f64, y1: f64) -> Vec<(f64, f64)> {
+    let (dx, dy) = ((x1 - x0) / 3.0, (y1 - y0) / 3.0);
+    vec![
+        (x0, y0),
+        (x0, y0 + dy),
+        (x0, y0 + 2.0 * dy),
+        (x0, y1),
+        (x0 + dx, y1),
+        (x0 + 2.0 * dx, y1),
+        (x1, y1),
+        (x1, y0 + 2.0 * dy),
+        (x1, y0 + dy),
+        (x1, y0),
+        (x0 + 2.0 * dx, y0),
+        (x0 + dx, y0),
+    ]
+}
+
+/// cairo (Inkscape's EPS and PostScript export, and other GTK apps): a prolog of PDF-like
+/// operator procedures, `rectclip` and `cm`, gradients as `shfill` with stitched functions whose
+/// `Encode` a loop builds, tiling patterns, a Type 42 font with text set through `Tm`/`Tf`/`Tj`,
+/// images with a 1-bit mask interleaved by row (`ImageType 3`), stencil masks, images flushed with
+/// `status`/`flushfile`, and mesh gradients from a reusable stream.
+#[test]
+fn cairo_files_read_as_vectors() {
+    // Mask rows (1: paint, `Decode [1 0]`) before each image row.
+    let image = a85_flate(&[0b1000_0000, 255, 0, 0, 0, 255, 0, 0b0100_0000, 0, 0, 255, 255, 255, 255]);
+    let mut points = square(150.0, 10.0, 190.0, 50.0);
+    points.extend([(160.0, 20.0), (160.0, 40.0), (180.0, 40.0), (180.0, 20.0)]);
+    let mesh = a85_flate(&patch(&points, &[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [1.0, 1.0, 0.0]]));
+    let program = format!(
+        r##"%%BeginProlog
+50 dict begin
+/q {{ gsave }} bind def /Q {{ grestore }} bind def
+/cm {{ 6 array astore concat }} bind def
+/w {{ setlinewidth }} bind def /J {{ setlinecap }} bind def /j {{ setlinejoin }} bind def
+/M {{ setmiterlimit }} bind def /d {{ setdash }} bind def
+/m {{ moveto }} bind def /l {{ lineto }} bind def /c {{ curveto }} bind def /h {{ closepath }} bind def
+/re {{ 4 2 roll moveto 1 index 0 rlineto 0 exch rlineto neg 0 rlineto closepath }} bind def
+/S {{ stroke }} bind def /f {{ fill }} bind def /f* {{ eofill }} bind def /n {{ newpath }} bind def
+/W {{ clip }} bind def /W* {{ eoclip }} bind def /BT {{ }} bind def /ET {{ }} bind def
+/BDC {{ mark 3 1 roll /BDC pdfmark }} bind def /EMC {{ mark /EMC pdfmark }} bind def
+/cairo_store_point {{ /cairo_point_y exch def /cairo_point_x exch def }} def
+/Tj {{ show currentpoint cairo_store_point }} bind def
+/cairo_selectfont {{ cairo_font_matrix aload pop pop pop 0 0 6 array astore
+  cairo_font exch selectfont cairo_point_x cairo_point_y moveto }} bind def
+/Tf {{ pop /cairo_font exch def /cairo_font_matrix where {{ pop cairo_selectfont }} if }} bind def
+/Tm {{ 2 copy 8 2 roll 6 array astore /cairo_font_matrix exch def cairo_store_point
+  /cairo_font where {{ pop cairo_selectfont }} if }} bind def
+/g {{ setgray }} bind def /rg {{ setrgbcolor }} bind def /d1 {{ setcachedevice }} bind def
+/cairo_flush_ascii85_file {{ cairo_ascii85_file status {{ cairo_ascii85_file flushfile }} if }} def
+/cairo_image {{ image cairo_flush_ascii85_file }} def
+/cairo_imagemask {{ imagemask cairo_flush_ascii85_file }} def
+%%EndProlog
+%%BeginSetup
+11 dict begin
+/FontType 42 def /FontName /DejaVuSans def /PaintType 0 def
+/FontMatrix [ 1 0 0 1 0 0 ] def /FontBBox [ 0 0 0 0 ] def
+/Encoding 256 array def 0 1 255 {{ Encoding exch /.notdef put }} for
+Encoding 72 /H put Encoding 105 /i put
+/CharStrings 3 dict dup begin /.notdef 0 def /H 1 def /i 2 def end readonly def
+/sfnts [ <00010000000100000000000000> ] def
+/f-0-0 currentdict end definefont pop
+%%EndSetup
+%%Page: 1 1
+q 0 0 200 150 rectclip
+1 0 0 -1 0 150 cm q
+0.8 0.2 0.2 rg 10 10 40 30 re f
+0 g 1.5 w 1 J 0 j [ 4 2] 0 d 10 60 m 40 45 60 90 90 60 c S [] 0.0 d
+/BDC where {{ pop /Artifact << >> BDC EMC }} if
+q 100 10 60 30 re W n
+/CairoFunction << /FunctionType 3 /Domain [ 0 1 ] /Functions [
+  << /FunctionType 2 /Domain [ 0 1 ] /C0 [ 1 0 0 ] /C1 [ 0 1 0 ] /N 1 >>
+  << /FunctionType 2 /Domain [ 0 1 ] /C0 [ 0 1 0 ] /C1 [ 0 0 1 ] /N 1 >> ]
+  /Bounds [ 0.5 ] /Encode [ 1 1 2 {{ pop 0 1 }} for ] >> def
+<< /ShadingType 2 /ColorSpace /DeviceRGB /Coords [ 100 0 160 0 ] /Extend [ true true ] /Function CairoFunction >> shfill
+Q
+/CairoPattern {{ q 0 0 10 10 rectclip q 0.8 0 0.8 rg 0 0 5 5 re f Q Q }} bind def
+<< /PatternType 1 /PaintType 1 /TilingType 1 /XStep 10 /YStep 10 /BBox [0 0 10 10]
+   /PaintProc {{ pop CairoPattern }} >> [ 1 0 0 1 0 0 ] makepattern setpattern
+10 90 40 40 re f
+0 0.2 0.4 rg BT 12 0 0 -12 60 140 Tm /f-0-0 1 Tf (Hi)Tj ET
+q [ 20 0 0 -20 110 110 ] concat
+/cairo_ascii85_file currentfile /ASCII85Decode filter def
+/DeviceRGB setcolorspace
+<< /ImageType 3 /InterleaveType 2
+  /DataDict << /ImageType 1 /Width 2 /Height 2 /Interpolate false /BitsPerComponent 8
+    /Decode [ 0 1 0 1 0 1 ] /DataSource cairo_ascii85_file /FlateDecode filter /ImageMatrix [ 2 0 0 -2 0 2 ] >>
+  /MaskDict << /ImageType 1 /Width 2 /Height 2 /BitsPerComponent 1 /Decode [ 1 0 ] /ImageMatrix [ 2 0 0 -2 0 2 ] >>
+>> cairo_image
+{image}
+Q
+q 0 0 1 rg [ 20 0 0 -10 150 140 ] concat
+/cairo_ascii85_file currentfile /ASCII85Decode filter def
+8 1 true [ 8 0 0 -1 0 1 ] cairo_ascii85_file cairo_imagemask
+{mask}
+Q
+q currentfile /ASCII85Decode filter /FlateDecode filter /ReusableStreamDecode filter
+{mesh}
+/CairoData exch def
+<< /ShadingType 7 /ColorSpace /DeviceRGB /DataSource CairoData /BitsPerCoordinate 32
+   /BitsPerComponent 16 /BitsPerFlag 8 /Decode [ 0 200 0 150 0 1 0 1 0 1 ] >> shfill
+currentdict /CairoData undef
+Q
+Q Q
+showpage
+%%Trailer
+end"##,
+        mask = ascii85(&[0xF0]),
+    );
+    let r = open("cairo 1.18.4 (https://cairographics.org)", &program);
+    let d = &r.document;
+    // The tiling pattern is a pattern swatch of its cell.
+    assert_eq!(d.patterns.len(), 1);
+    let pat = &d.patterns[0];
+    assert!(near(pat.tile, Rect::new(0.0, 0.0, 10.0, 10.0)), "{:?}", pat.tile);
+    assert!(d.swatch(&pat.name).is_some_and(|s| matches!(s.paint, Paint::Pattern { .. })));
+    assert!(all(d).iter().any(|n| matches!(fill(n), Some(Paint::Pattern { .. }))));
+    // The stitched gradient, the dashed curve, the type, the masked image, the stencil and the mesh.
+    assert!(all(d).iter().any(|n| matches!(fill(n), Some(Paint::Gradient(_)))));
+    assert!(all(d).iter().any(|n| stroke(n).is_some_and(|s| s.dash.is_some())));
+    assert_eq!(of_kind(d, "Type").len(), 1);
+    assert_eq!(of_kind(d, "Image").len(), 2);
+    let im = all(d).into_iter().find(|n| matches!(&n.kind, NodeKind::Image(im) if im.width == 2)).unwrap();
+    let NodeKind::Image(im) = &im.kind else { panic!() };
+    let img = image::load_from_memory(&d.images[&im.key].bytes).unwrap().to_rgba8();
+    // Painted where the mask is 1, transparent where it is 0.
+    assert_eq!([img.get_pixel(0, 0).0, img.get_pixel(1, 0).0], [[255, 0, 0, 255], [0, 255, 0, 0]]);
+    assert_eq!([img.get_pixel(0, 1).0, img.get_pixel(1, 1).0], [[0, 0, 255, 0], [255, 255, 255, 255]]);
+    let mesh = of_kind(d, "Mesh");
+    assert_eq!(mesh.len(), 1);
+    // `cm` turned user space y down, as the document is.
+    assert!(near(bounds(&mesh[0]), Rect::new(150.0, 10.0, 190.0, 50.0)), "{:?}", bounds(&mesh[0]));
+}
+
+/// cairo's Type 3 fonts (fonts it can't embed otherwise): glyph procedures in an array, picked
+/// through `CharStrings` by `BuildGlyph`, widths from `d1`: the glyphs are drawn as their
+/// outlines, one group per string.
+#[test]
+fn type3_fonts_draw_their_glyph_procedures() {
+    let program = r##"/d1 { setcachedevice } bind def
+8 dict begin
+/FontType 3 def
+/FontMatrix [ 0.001 0 0 0.001 0 0 ] def
+/FontBBox [ 0 0 1000 1000 ] def
+/Encoding 256 array def 0 1 255 { Encoding exch /.notdef put } for
+Encoding 65 /g1 put
+/Glyphs [ { } { 600 0 0 0 500 700 d1 0 0 moveto 500 0 lineto 250 700 lineto closepath fill } ] def
+/CharStrings 2 dict dup begin /.notdef 0 def /g1 1 def end readonly def
+/BuildGlyph { exch dup /Glyphs get exch /CharStrings get 3 -1 roll 2 copy known not { pop /.notdef } if get get exec } bind def
+/BuildChar { 1 index /Encoding get exch get 1 index /BuildGlyph get exec } bind def
+currentdict end /f-1-0 exch definefont pop
+1 0 0 setrgbcolor
+/f-1-0 findfont 20 scalefont setfont 10 10 moveto (AA) show
+currentpoint 2 copy translate
+% `stringwidth` measures them without drawing.
+(A) stringwidth pop 12 eq { 0 0 1 setrgbcolor } if 0 0 moveto 3 0 65 2 0 (AA) awidthshow
+showpage"##;
+    let r = open("cairo", program);
+    let d = &r.document;
+    let groups = of_kind(d, "Group");
+    assert_eq!(groups.len(), 2, "{:?}", all(d).iter().map(|n| n.kind_label()).collect::<Vec<_>>());
+    assert_eq!(groups[0].name.as_deref(), Some("AA"));
+    let glyphs: Vec<Rect> = groups[0].children().unwrap().iter().map(|n| bounds(n)).collect();
+    // 500 × 700 units at 20 pt (0.02 pt a unit) on the baseline 10 pt up the page; the second glyph
+    // after the first one's width (600 units).
+    assert!(near(glyphs[0], Rect::new(10.0, 126.0, 20.0, 140.0)), "{glyphs:?}");
+    assert!(near(glyphs[1], Rect::new(22.0, 126.0, 32.0, 140.0)), "{glyphs:?}");
+    assert_eq!(fill(&groups[0].children().unwrap()[0]).and_then(Paint::color), Some(Color::rgb(1.0, 0.0, 0.0)));
+    // `awidthshow` spaces them (2 more, 3 more after an "A"), in blue: the width measured right.
+    let second: Vec<Rect> = groups[1].children().unwrap().iter().map(|n| bounds(n)).collect();
+    assert!((second[1].x0 - second[0].x0 - 17.0).abs() < 1e-6, "{second:?}");
+    assert_eq!(fill(&groups[1].children().unwrap()[0]).and_then(Paint::color), Some(Color::rgb(0.0, 0.0, 1.0)));
+}
+
+/// matplotlib's PostScript backend: a `mpldict` of short procedures defined with `_d`, Type 3
+/// fonts converted from TrueType (`CharStrings` of glyph procedures with `sc`, `BuildGlyph` and
+/// `BuildChar`) shown glyph by glyph with `glyphshow`, `clipbox`, marker procedures, and images as
+/// `colorimage` reading hexadecimal data with `readhexstring`.
+#[test]
+fn matplotlib_files_read_as_vectors() {
+    let program = r##"%%BeginProlog
+/mpldict 11 dict def
+mpldict begin
+/_d { bind def } bind def
+/m { moveto } _d
+/l { lineto } _d
+/r { rlineto } _d
+/c { curveto } _d
+/cl { closepath } _d
+/ce { closepath eofill } _d
+/box { m 1 index 0 r 0 exch r neg 0 r cl } _d
+/clipbox { box clip newpath } _d
+/sc { setcachedevice } _d
+%!PS-Adobe-3.0 Resource-Font
+10 dict begin
+/FontName /DejaVuSans def
+/PaintType 0 def
+/FontMatrix [ 0.00048828125 0 0 0.00048828125 0 0 ] def
+/FontBBox [ -2090 -948 3673 2524 ] def
+/FontType 3 def
+/Encoding [ /A /V ] def
+/CharStrings 3 dict dup begin
+/.notdef 0 def
+/A { 1401 0 16 0 1384 1493 sc 16 0 m 700 1493 l 1384 0 l ce } _d
+/V { 1401 0 16 0 1384 1493 sc 16 1493 m 700 0 l 1384 1493 l ce } _d
+end readonly def
+/BuildGlyph { exch begin CharStrings exch 2 copy known not { pop /.notdef } if get exec end } _d
+/BuildChar { 1 index /Encoding get exch get 1 index /BuildGlyph get exec } _d
+FontName currentdict end definefont pop
+end
+%%EndProlog
+mpldict begin
+0 0 translate
+0 0 200 150 rectclip
+gsave
+0 0 m 200 0 l 200 150 l 0 150 l cl
+1 setgray fill
+grestore
+gsave
+10 10 180 130 clipbox
+0.122 0.467 0.706 setrgbcolor 1.5 setlinewidth 1 setlinejoin 2 setlinecap [] 0 setdash
+newpath 10 10 m 50 60 l 90 30 l stroke
+/o { gsave newpath translate 3 0 m 0 0 3 0 360 arc cl gsave 1 0 0 setrgbcolor fill grestore stroke grestore } bind def
+10 10 o 50 60 o
+grestore
+0 setgray
+gsave 20 100 translate 0 rotate
+/DejaVuSans 20.0 selectfont 0 0 m /A glyphshow 13.68 0 m /V glyphshow
+grestore
+gsave 120 20 translate 40 40 scale
+/DataString 6 string def
+2 2 8 [ 2 0 0 -2 0 2 ] { currentfile DataString readhexstring pop } bind false 3 colorimage
+ff000000ff00
+0000ffffffff
+grestore
+end
+showpage"##;
+    let r = open("Matplotlib v3.9.0, https://matplotlib.org/", program);
+    let d = &r.document;
+    // The two glyphs are their outlines (even-odd, as `ce` fills them), at 20 pt.
+    let glyphs: Vec<_> = all(d).into_iter().filter(|n| matches!(n.kind, NodeKind::Path { rule: FillRule::EvenOdd, .. })).collect();
+    assert_eq!(glyphs.len(), 2);
+    let a = bounds(&glyphs[0]);
+    assert!(near(a, Rect::new(20.16, 150.0 - 100.0 - 14.58, 33.52, 50.0)), "{a:?}");
+    // Each marker is one object, filled and stroked; the image is its four pixels.
+    let markers = all(d).into_iter().filter(|n| fill(n).is_some() && stroke(n).is_some()).count();
+    assert_eq!(markers, 2);
+    assert_eq!([pixel(d, 0, 0), pixel(d, 1, 0), pixel(d, 0, 1)], [[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255]]);
+}
+
+/// CorelDRAW: a `wCorel…Dict` procset of `@` procedures defined with `bd`, `ld` and `xd`,
+/// `currentscreen` kept and `setscreen` replaced, CMYK colour kept in `$c $m $y $k`, a document
+/// in `save`/`restore` blocks, `showpage` redefined, fonts reencoded by copying their dictionary
+/// without its `FID`, and type set with `ashow` through `makefont`.
+#[test]
+fn coreldraw_files_read_as_vectors() {
+    let program = r##"%%BeginProlog
+%%BeginResource: procset wCorel3Dict 3.0 0
+/wCorel3Dict 300 dict def wCorel3Dict begin
+/bd{bind def}bind def/ld{load def}bd/xd{exch def}bd/_ null def/rp{{pop}repeat}bd
+/@cp/closepath ld/@gs/gsave ld/@gr/grestore ld/@np/newpath ld/Tl/translate ld
+/$sv 0 def/@sv{/$sv save def}bd/@rs{$sv restore}bd/spg/showpage ld/showpage{}bd
+currentscreen/@dsp xd/$dsp/@dsp def/$dsa xd/$dsf xd/$sdf false def/$SDF false def
+/$Scra 0 def/SetScr/setscreen ld/@ss{2 index 0 eq{$dsf 3 1 roll 4 -1 roll pop}if exch $Scra add exch SetScr}bd
+/$c 0 def/$m 0 def/$y 0 def/$k 0 def/$t 1 def/$n _ def/$o 0 def/$fil 0 def/$fm 0 def
+/$ctm matrix currentmatrix def/$ptm matrix def
+/L2? false/languagelevel where{pop languagelevel 2 ge{pop true}if}if def
+/@BeginSysCorelDict{systemdict/Corel30Dict known{systemdict/Corel30Dict get exec}if}bd
+/@EndSysCorelDict{systemdict/Corel30Dict known{systemdict/Corel30Dict get exec}if}bd
+/@sm{/$ctm $ctm currentmatrix def}bd/@rm{$ctm setmatrix}bd
+/k{/$k xd/$y xd/$m xd/$c xd/$n _ def}bd
+/@k{$c $m $y $k L2?{setcmykcolor}{4 rp 0 setgray}ifelse}bd
+/m/moveto ld/L/lineto ld/C/curveto ld/@c/closepath ld
+/F{@gs @k $fil 0 eq{fill}{eofill}ifelse @gr @np}bd
+/S{@k stroke}bd/@w{setlinewidth}bd
+/CorelDrawReencodeVect[16#80/Euro 16#e9/eacute]def
+/@reencode{findfont dup length dict begin{1 index/FID ne{def}{pop pop}ifelse}forall
+/Encoding Encoding 256 array copy def CorelDrawReencodeVect aload length 2 idiv{Encoding 3 1 roll put}repeat
+currentdict end definefont pop}bd
+/@F{/$fm xd findfont $fm makefont setfont}bd
+end
+%%EndResource
+%%EndProlog
+%%BeginSetup
+wCorel3Dict begin
+@BeginSysCorelDict
+2.6131 setmiterlimit 1.00 setflat
+/$fst 128 def
+0 45 {dup mul exch dup mul add 1 exch sub} @ss
+/_Helvetica/Helvetica @reencode
+%%EndSetup
+%%Page: 1 1
+@sv
+@sm
+@sv
+0 1 1 0 k
+10 10 m 90 10 L 90 60 L 10 60 L 10 10 L @c
+F
+@rs
+@sv
+1 @w 1 0 0 0 k
+10 70 m 50 90 70 90 90 70 C
+S
+@rs
+@sv
+0 0 0 1 k @k
+/_Helvetica [12 0 0 12 0 0] @F
+10 120 m 1 0 (Corel) ashow
+@rs
+@rs
+@EndSysCorelDict
+end
+showpage
+spg"##;
+    let r = open("CorelDRAW 2024", program);
+    let d = &r.document;
+    assert_eq!(d.color_mode, ColorMode::Cmyk);
+    let rect = all(d).into_iter().find(|n| fill(n).and_then(Paint::color) == Some(Color::cmyk(0.0, 1.0, 1.0, 0.0))).unwrap();
+    assert!(near(bounds(&rect), Rect::new(10.0, 90.0, 90.0, 140.0)), "{:?}", bounds(&rect));
+    assert!(all(d).iter().any(|n| stroke(n).is_some_and(|s| s.paint.color() == Some(Color::cmyk(1.0, 0.0, 0.0, 0.0)))));
+    let NodeKind::Text(t) = &of_kind(d, "Type")[0].kind else { panic!() };
+    assert!(t.plain_text().starts_with("Corel"));
+}
+
+/// Affinity Designer (and other PDF-engine exporters): PDF-like procedures, gradients as shading
+/// patterns (`makepattern setpattern`) with sampled functions, spot colours (`Separation`) and
+/// `DeviceN` inks with tint transforms, and images compressed with Flate and a PNG predictor.
+#[test]
+fn affinity_files_read_as_vectors() {
+    // Two rows of two RGB pixels, PNG-filtered: Sub, then Up.
+    let rows = [[1u8, 255, 0, 0, 1, 255, 0], [2, 0, 0, 255, 0, 0, 255]];
+    let image = a85_flate(&rows.concat());
+    let program = format!(
+        r##"%%BeginProlog
+/AFDict 40 dict def AFDict begin
+/languagelevel where {{ pop languagelevel }} {{ 1 }} ifelse 3 lt {{ (This file needs PostScript Level 3) print quit }} if
+/bd {{ bind def }} bind def
+/q {{ gsave }} bd /Q {{ grestore }} bd /cm {{ [ 7 1 roll ] concat }} bd
+/re {{ 4 2 roll moveto 1 index 0 rlineto 0 exch rlineto neg 0 rlineto closepath }} bd
+/f {{ fill }} bd /f* {{ eofill }} bd /W {{ clip }} bd /n {{ newpath }} bd
+/rg {{ setrgbcolor }} bd /k {{ setcmykcolor }} bd
+end
+%%EndProlog
+%%BeginSetup
+/setpagedevice where {{ pop << /PageSize [ 200 150 ] >> setpagedevice }} if
+%%EndSetup
+%%Page: 1 1
+AFDict begin
+q
+<< /PatternType 2 /Shading << /ShadingType 2 /ColorSpace /DeviceRGB /Coords [ 0 0 100 0 ]
+  /Function << /FunctionType 0 /Domain [ 0 1 ] /Range [ 0 1 0 1 0 1 ] /Size [ 3 ] /BitsPerSample 8
+    /DataSource <ff000000ff000000ff> >> /Extend [ true true ] >> >> matrix makepattern setpattern
+10 10 100 40 re f
+[ /Separation (PANTONE 185 C) /DeviceCMYK {{ dup 0.91 mul exch 0.76 mul 0 exch 0 4 1 roll }} ] setcolorspace
+0.5 setcolor 10 60 40 40 re f
+[ /DeviceN [ /Cyan /Magenta ] /DeviceCMYK {{ 0 0 }} ] setcolorspace
+0.3 0.7 setcolor 60 60 40 40 re f
+q 40 0 0 40 120 60 cm /DeviceRGB setcolorspace
+<< /ImageType 1 /Width 2 /Height 2 /BitsPerComponent 8 /Decode [ 0 1 0 1 0 1 ] /ImageMatrix [ 2 0 0 -2 0 2 ]
+   /DataSource currentfile /ASCII85Decode filter << /Predictor 15 /Colors 3 /Columns 2 /BitsPerComponent 8 >> /FlateDecode filter >> image
+{image}
+Q
+Q
+end
+showpage"##
+    );
+    let r = open("Affinity Designer 2", &program);
+    let d = &r.document;
+    let Some(Paint::Gradient(g)) = all(d).into_iter().find_map(|n| fill(&n).cloned()) else { panic!("no gradient") };
+    // The sampled function's colours, not its middle one: red, green, blue.
+    let at = |t: f32| g.gradient.stops.iter().find(|s| (s.offset - t).abs() < 1e-3).map(|s| s.color.to_rgb_uncalibrated());
+    assert_eq!([at(0.0), at(0.5), at(1.0)], [Some([1.0, 0.0, 0.0]), Some([0.0, 1.0, 0.0]), Some([0.0, 0.0, 1.0])]);
+    assert!(d.swatch("PANTONE 185 C").is_some_and(|s| s.spot));
+    assert!(all(d).iter().any(|n| matches!(fill(n), Some(Paint::Solid { swatch: Some(s), .. }) if s == "PANTONE 185 C")));
+    assert!(all(d).iter().any(|n| fill(n).and_then(Paint::color) == Some(Color::cmyk(0.3, 0.7, 0.0, 0.0))));
+    assert_eq!(
+        [pixel(d, 0, 0), pixel(d, 1, 0), pixel(d, 0, 1), pixel(d, 1, 1)],
+        [[255, 0, 0, 255], [0, 255, 0, 255], [255, 0, 255, 255], [0, 255, 255, 255]]
+    );
+}
+
+/// LibreOffice and OpenOffice: a prolog that keeps the operand and dictionary stack depths and a
+/// `save` to restore at the end, coordinates negated in its procedures, fonts reencoded to
+/// ISO Latin-1 and defined again under one name, and type stretched to a width with
+/// `stringwidth`.
+#[test]
+fn libreoffice_files_read_as_vectors() {
+    let program = r##"%%BeginProlog
+%%BeginResource: procset SDRes-Prolog 1.0 0
+/b4_inc_state save def
+/dict_count countdictstack def
+/op_count count 1 sub def
+userdict begin
+0 setgray 0 setlinecap 1 setlinewidth 0 setlinejoin 10 setmiterlimit [] 0 setdash newpath
+/languagelevel where {pop languagelevel 1 ne {false setstrokeadjust false setoverprint} if} if
+/bdef {bind def} bind def
+/c {setrgbcolor} bdef
+/l {neg lineto} bdef
+/rl {neg rlineto} bdef
+/lw {setlinewidth} bdef
+/m {neg moveto} bdef
+/ct {6 2 roll neg 6 2 roll neg 6 2 roll neg curveto} bdef
+/t {neg translate} bdef
+/s {scale} bdef
+/gs {gsave} bdef
+/gr {grestore} bdef
+/f {findfont dup length dict begin {1 index /FID ne {def} {pop pop} ifelse} forall /Encoding ISOLatin1Encoding def
+currentdict end /NFont exch definefont pop /NFont findfont} bdef
+/p {closepath} bdef
+/sf {scalefont setfont} bdef
+/ef {eofill} bdef
+/ps {stroke} bdef
+/pum {matrix currentmatrix} bdef
+/pom {setmatrix} bdef
+/bs {/aString exch def /nXOfs exch def /nWidth exch def currentpoint nXOfs 0 rmoveto pum nWidth aString stringwidth pop div 1 scale aString show pom moveto} bdef
+%%EndResource
+%%EndProlog
+%%BeginSetup
+%%EndSetup
+%%Page: 1 1
+%%BeginPageSetup
+%%EndPageSetup
+pum
+0.1 0.1 s
+0 -1500 t
+/tm matrix currentmatrix def
+gs
+tm setmatrix
+0.2 0.4 0.8 c 100 100 m 900 100 l 900 600 l 100 600 l 100 100 l p ef
+gr
+gs
+tm setmatrix
+10 lw 0 0 0 c 100 800 m 400 700 600 900 900 800 ct ps
+gr
+gs
+tm setmatrix
+/Helvetica f 120 sf 0 0 0 c 100 1300 m 800 0 (Office) bs
+gr
+pom
+count op_count sub {pop} repeat countdictstack dict_count sub {end} repeat b4_inc_state restore
+%%PageTrailer
+%%Trailer
+showpage"##;
+    let r = open("LibreOffice 24.2", program);
+    let d = &r.document;
+    let rect = all(d).into_iter().find(|n| fill(n).and_then(Paint::color) == Some(Color::rgb(0.2, 0.4, 0.8))).unwrap();
+    assert!(near(bounds(&rect), Rect::new(10.0, 10.0, 90.0, 60.0)), "{:?}", bounds(&rect));
+    assert!(all(d).iter().any(|n| stroke(n).is_some_and(|s| (s.width - 1.0).abs() < 1e-9)));
+    let NodeKind::Text(t) = &of_kind(d, "Type")[0].kind else { panic!() };
+    assert_eq!(t.plain_text(), "Office");
+}
+
+/// Ghostscript's `ps2write` and `eps2write`: a procset that captures dictionaries with `//name`
+/// (resolved when read, used after their dictionary is gone), probes the interpreter (`gcheck`,
+/// `currentglobal`, `/currentdistillerparams where`, an unguarded `pdfmark`), defines resources,
+/// and runs page content kept between `stream` and `endstream` through `SubFileDecode`, with
+/// `selectfont`, `xshow`, `rectfill`, `execform`, half-tone dictionaries and a triangle mesh.
+#[test]
+fn ghostscript_files_read_as_vectors() {
+    let program = r##"%%BeginProlog
+save
+countdictstack
+mark
+newpath
+/showpage {} def
+/setpagedevice {pop} def
+%%EndProlog
+%%Page: 1 1
+%%BeginProlog
+10 dict begin
+/this currentdict def
+/ebuf 200 string def
+/prnt { //ebuf cvs pop } bind def
+/knownget { 2 copy known { get true } { pop pop false } ifelse } bind def
+end
+20 dict begin
+/PDFR_GLOBAL false def
+/cp2g { dup gcheck not { dup type /dicttype eq { dup length dict copy } if } if } bind def
+/DefaultSwitch { dup where { pop pop } { false def } ifelse } bind def
+/PDFR_DEBUG DefaultSwitch
+/currentdistillerparams where { pop currentdistillerparams /CoreDistVersion get 5000 lt } { true } ifelse
+{ /setdistillerparams {pop} def } if
+[ /Title (gs) /DOCINFO pdfmark
+currentglobal true setglobal
+/PDFReader 10 dict def
+setglobal
+/OPDF << /Run { cvx exec } >> /ProcSet defineresource pop
+/q { gsave } bind def /Q { grestore } bind def
+/cm { [ 7 1 roll ] concat } bind def
+/rg { setrgbcolor } bind def
+/re { rectfill } bind def
+/Tf { selectfont } bind def
+/Td { moveto } bind def
+/stream { currentfile 0 (endstream) /SubFileDecode filter /OPDF /ProcSet findresource /Run get exec } bind def
+%%EndProlog
+<< /HalftoneType 1 /Frequency 60 /Angle 45 /SpotFunction { dup mul exch dup mul add 1 exch sub } >> sethalftone
+/Form1 << /FormType 1 /BBox [ 0 0 20 20 ] /Matrix [ 1 0 0 1 0 0 ] /PaintProc { pop 0 0 1 rg 0 0 20 20 re } >> def
+stream
+q 1 0 0 rg 10 10 80 40 re
+Q /Helvetica 50 Tf 20 100 Td (gs) [ 25 0 ] xshow
+endstream
+q 120 100 translate Form1 execform Q
+<< /ShadingType 4 /ColorSpace /DeviceRGB /DataSource [ 0 120 10 1 0 0  0 180 10 0 1 0  0 150 60 0 0 1  1 190 60 1 1 0 ] >> shfill
+end
+cleartomark countdictstack exch sub { end } repeat restore
+showpage"##;
+    let r = open("GPL Ghostscript 10.04.0 (eps2write)", program);
+    let d = &r.document;
+    let red = all(d).into_iter().find(|n| fill(n).and_then(Paint::color) == Some(Color::rgb(1.0, 0.0, 0.0))).unwrap();
+    assert!(near(bounds(&red), Rect::new(10.0, 100.0, 90.0, 140.0)), "{:?}", bounds(&red));
+    let form = all(d).into_iter().find(|n| fill(n).and_then(Paint::color) == Some(Color::rgb(0.0, 0.0, 1.0))).unwrap();
+    assert!(near(bounds(&form), Rect::new(120.0, 30.0, 140.0, 50.0)), "{:?}", bounds(&form));
+    assert_eq!(of_kind(d, "Type").len(), 1);
+    // Two triangles of a free-form mesh, the second on the first one's edge.
+    let meshes = of_kind(d, "Mesh");
+    assert_eq!(meshes.len(), 2);
+    assert!(near(bounds(&meshes[1]), Rect::new(150.0, 90.0, 190.0, 140.0)), "{:?}", bounds(&meshes[1]));
+}
+
+/// Illustrator's EPS (CS and later, through 2026): procsets that define helpers with
+/// `bdf`/`ndf`/`ddf`, probe the level and version (`{version cvr} stopped`), switch VM with
+/// `currentglobal`/`setglobal`, save and restore the whole graphics state through
+/// `currentcolorrendering`, `rootfont`, the colour transfers, half-tone and flatness, set up
+/// categories and keep fonts by VM (`gcheck`), while the art is drawn with procedures of their own.
+#[test]
+fn illustrator_procsets_read_as_vectors() {
+    let program = r##"%%BeginProlog
+%%BeginResource: procset Adobe_AGM_Utils 1.0 0
+systemdict /setpacking known { currentpacking true setpacking } if
+userdict /Adobe_AGM_Utils 75 dict dup begin put
+/bdf { bind def } bind def
+/nd { null def } bdf
+/xdf { exch def } bdf
+/ddf { put } bdf
+/xddf { 3 -1 roll put } bdf
+/ndf { exch dup where { pop pop pop } { xdf } ifelse } def
+/gx { get exec } bdf
+/ps_level /languagelevel where { pop systemdict /languagelevel gx } { 1 } ifelse def
+/level2 ps_level 2 ge def
+/level3 ps_level 3 ge def
+/ps_version { version cvr } stopped { -1 } if def
+/set_gvm { currentglobal exch setglobal } bdf
+/reset_gvm { setglobal } bdf
+/makereadonlyarray { /packedarray where { pop packedarray } { array astore readonly } ifelse } bdf
+/GSTATE 22 dict def
+/get_gstate {
+  GSTATE begin
+  /clr_spc currentcolorspace def
+  mark currentcolor counttomark array astore /clr_comps xdf pop
+  /fnt rootfont def
+  /lw currentlinewidth def /lc currentlinecap def /lj currentlinejoin def /ml currentmiterlimit def
+  currentdash /dsh_o xdf /dsh_a xdf
+  /sa currentstrokeadjust def
+  /crd currentcolorrendering def
+  /op currentoverprint def
+  /bg currentblackgeneration cvlit def
+  /ucr currentundercolorremoval cvlit def
+  currentcolortransfer cvlit /gy_x xdf cvlit /b_x xdf cvlit /g_x xdf cvlit /r_x xdf
+  /ht currenthalftone def
+  /flt currentflat def
+  end
+} def
+/set_gstate {
+  GSTATE begin
+  clr_spc setcolorspace clr_comps aload pop setcolor
+  fnt setfont lw setlinewidth lc setlinecap lj setlinejoin ml setmiterlimit dsh_a dsh_o setdash
+  sa setstrokeadjust crd setcolorrendering op setoverprint
+  bg cvx setblackgeneration ucr cvx setundercolorremoval
+  r_x cvx g_x cvx b_x cvx gy_x cvx setcolortransfer
+  ht /HalftoneType get dup 9 eq exch 100 eq or { ht sethalftone } if
+  flt setflat
+  end
+} def
+/ct_tst { 1183615869 internaldict pop } stopped pop
+currentdict readonly pop
+end
+systemdict /setpacking known { setpacking } if
+%%EndResource
+%%BeginResource: procset Adobe_AGM_Core 2.0 0
+userdict /Adobe_AGM_Core 200 dict dup begin put
+/AGMCORE_str256 256 string def
+/AGMCORE_deviceDPI 72 0 matrix defaultmatrix dtransform dup mul exch dup mul add sqrt def
+/AGMCORE_distilling /product where { pop systemdict /setdistillerparams known product (Adobe PostScript Parser) ne and } { false } ifelse def
+/AGMCORE_producing_seps currentpagedevice /Separations 2 copy known { get } { pop pop false } ifelse def
+/AGMCORE_page_size currentpagedevice /PageSize get def
+/Generic /Category findresource dup length dict copy /Category defineresource pop
+/AGMCORE_mo { moveto } def /AGMCORE_li { lineto } def /AGMCORE_cv { curveto } def /AGMCORE_cp { closepath } def
+/AGMCORE_rgb { setrgbcolor } def /AGMCORE_cmyk { setcmykcolor } def
+/doc_setup { Adobe_AGM_Utils begin get_gstate end } def
+/page_setup { Adobe_AGM_Utils begin set_gstate end } def
+end
+%%EndResource
+%%BeginResource: procset Adobe_CoolType_Core 2.31 0
+userdict /CT_Core 20 dict dup begin put
+/GVMFonts 10 dict def /LVMFonts 10 dict def
+/VMDictPut { dup gcheck { GVMFonts } { LVMFonts } ifelse 3 1 roll put } bind def
+/copyfont { currentglobal exch dup gcheck setglobal dup length dict copy exch setglobal } bind def
+end
+%%EndResource
+%%EndProlog
+%%BeginSetup
+Adobe_AGM_Core /doc_setup get exec
+CT_Core begin /Body /Helvetica findfont copyfont VMDictPut end
+%%EndSetup
+%%Page: 1 1
+%%BeginPageSetup
+Adobe_AGM_Core /page_setup get exec
+%%EndPageSetup
+Adobe_AGM_Core begin
+/mo { AGMCORE_mo } def /li { AGMCORE_li } def /cv { AGMCORE_cv } def /cp { AGMCORE_cp } def
+0 0.94 0.94 0.12 AGMCORE_cmyk
+10 140 mo 90 140 li 90 90 li 10 90 li cp fill
+0.2 0.4 0.8 AGMCORE_rgb
+100 20 mo 150 80 180 0 190 60 cv 2 setlinewidth stroke
+0 setgray CT_Core /LVMFonts get /Body get 12 scalefont setfont 10 30 moveto (Art) show
+end
+showpage"##;
+    let r = open("Adobe Illustrator(R) 30.0", program);
+    let d = &r.document;
+    let rect = all(d).into_iter().find(|n| fill(n).and_then(Paint::color) == Some(Color::cmyk(0.0, 0.94, 0.94, 0.12))).unwrap();
+    assert!(near(bounds(&rect), Rect::new(10.0, 10.0, 90.0, 60.0)), "{:?}", bounds(&rect));
+    assert!(all(d).iter().any(|n| stroke(n).is_some_and(|s| s.width == 2.0)));
+    assert_eq!(of_kind(d, "Type").len(), 1);
+}
+
+/// Shadings other apps paint with: function-based ones (type 1) over a sampled two-input
+/// function, free-form triangles packed in bits (type 4), lattices (type 5), Coons patches sharing
+/// an edge (type 6), and a mesh as a shading pattern's fill; all as gradient meshes.
+#[test]
+fn mesh_and_function_shadings_become_gradient_meshes() {
+    // Type 1: a 2 × 2 sampled function, red to green across, to blue down.
+    let r = read(
+        "<< /ShadingType 1 /ColorSpace /DeviceRGB /Domain [0 1 0 1] /Matrix [50 0 0 50 10 10] \
+         /Function << /FunctionType 0 /Domain [0 1 0 1] /Range [0 1 0 1 0 1] /Size [2 2] /BitsPerSample 8 \
+         /DataSource <ff000000ff000000ff000000> >> >> shfill",
+    );
+    clean(&r);
+    let m = &of_kind(&r.document, "Mesh")[0];
+    assert!(near(bounds(m), Rect::new(10.0, 40.0, 60.0, 90.0)), "{:?}", bounds(m));
+    let NodeKind::Mesh(g) = &m.kind else { panic!() };
+    // Its first corner (the domain's origin) is the first sample.
+    assert_eq!(g.points[0].color, Color::rgb(1.0, 0.0, 0.0));
+
+    // Type 4 packed: 8-bit flags, coordinates and components; a triangle and one on its edge.
+    let tri = [[0u8, 0, 0, 255, 0, 0], [0, 255, 0, 0, 255, 0], [0, 0, 255, 0, 0, 255], [1, 255, 255, 255, 255, 0]].concat();
+    let r = read(&format!(
+        "<< /ShadingType 4 /ColorSpace /DeviceRGB /BitsPerCoordinate 8 /BitsPerComponent 8 /BitsPerFlag 8 \
+         /Decode [0 255 0 255 0 1 0 1 0 1] /DataSource <{}> >> [0.2 0 0 0.2 0 0] concat shfill",
+        tri.iter().map(|b| format!("{b:02x}")).collect::<String>()
+    ));
+    clean(&r);
+    assert_eq!(of_kind(&r.document, "Mesh").len(), 2);
+
+    // Type 5: a 2 × 2 lattice is two triangles.
+    let r = read(
+        "<< /ShadingType 5 /ColorSpace /DeviceGray /VerticesPerRow 2 \
+         /DataSource [10 10 0  50 10 1  10 50 0.5  50 50 1] >> shfill",
+    );
+    clean(&r);
+    assert_eq!(of_kind(&r.document, "Mesh").len(), 2);
+
+    // Type 6: a patch, then one sharing its right side (flag 2).
+    let first: Vec<String> = square(10.0, 10.0, 40.0, 40.0).iter().map(|(x, y)| format!("{x} {y}")).collect();
+    let right = "40 40 50 40 60 40 70 40 70 30 70 20 70 10 60 10 50 10";
+    let r = read(&format!(
+        "<< /ShadingType 6 /ColorSpace /DeviceRGB /DataSource [0 {} 1 0 0 0 1 0 0 0 1 1 1 0  2 {right} 1 0 1 0 1 1] >> shfill",
+        first.join(" ")
+    ));
+    clean(&r);
+    let patches = of_kind(&r.document, "Mesh");
+    assert_eq!(patches.len(), 2);
+    assert!(near(bounds(&patches[1]), Rect::new(40.0, 60.0, 70.0, 90.0)), "{:?}", bounds(&patches[1]));
+
+    // A mesh through a shading pattern fills the path it paints, clipped to it.
+    let r = read(
+        "<< /PatternType 2 /Shading << /ShadingType 5 /ColorSpace /DeviceGray /VerticesPerRow 2 \
+         /DataSource [0 0 0  100 0 1  0 100 0.5  100 100 1] >> >> matrix makepattern setpattern \
+         newpath 20 20 30 0 360 arc fill",
+    );
+    clean(&r);
+    let o = objects(&r.document);
+    assert!(matches!(o[0].kind, NodeKind::Group { clip: true, .. }), "{:?}", o[0].kind_label());
+    assert_eq!(of_kind(&r.document, "Mesh").len(), 2);
+}
+
+/// Images with a mask (`ImageType 3`) interleaved by sample, and with the mask in its own source.
+#[test]
+fn masked_images_in_every_interleaving() {
+    // By sample: mask bit, then three colour bits, 1 bit each (two pixels a row, padded).
+    let r = read(
+        "/DeviceRGB setcolorspace 20 20 scale << /ImageType 3 /InterleaveType 1 \
+         /DataDict << /ImageType 1 /Width 2 /Height 1 /BitsPerComponent 1 /Decode [0 1 0 1 0 1] /ImageMatrix [2 0 0 1 0 0] \
+         /DataSource <c600> >> /MaskDict << /ImageType 1 /Width 2 /Height 1 /BitsPerComponent 1 /Decode [1 0] /ImageMatrix [2 0 0 1 0 0] >> >> image",
+    );
+    clean(&r);
+    // 1100 0110: painted red, then masked out.
+    assert_eq!((pixel(&r.document, 0, 0), pixel(&r.document, 1, 0)[3]), ([255, 0, 0, 255], 0));
+    // Separate sources, the mask at twice the resolution.
+    let r = read(
+        "/DeviceGray setcolorspace 20 20 scale << /ImageType 3 /InterleaveType 3 \
+         /DataDict << /ImageType 1 /Width 1 /Height 1 /BitsPerComponent 8 /Decode [0 1] /ImageMatrix [1 0 0 1 0 0] /DataSource <80> >> \
+         /MaskDict << /ImageType 1 /Width 2 /Height 2 /BitsPerComponent 1 /Decode [0 1] /ImageMatrix [2 0 0 2 0 0] /DataSource <4000> >> >> image",
+    );
+    clean(&r);
+    assert_eq!(pixel(&r.document, 0, 0), [128, 128, 128, 255]);
+}
+
+/// The warning for a file read only up to an error names the error, the operator that raised it
+/// and the procedures it ran in, innermost first; an error a program catches with `stopped` is
+/// not reported.
+#[test]
+fn errors_name_the_operator_and_the_procedures() {
+    let r = read("{ 1 (a) add } stopped pop 0 0 10 10 rectfill /inner { 1 (a) add } def /outer { inner } def outer");
+    assert!(r.warnings[0].contains("(typecheck in `add`), in `inner` in `outer`"), "{:?}", r.warnings);
+    let r = read("0 0 10 10 rectfill /p { frobnicate } def p");
+    assert!(r.warnings[0].contains("it uses `frobnicate`, which VectorCraft's PostScript reader doesn't know, in `p`"), "{:?}", r.warnings);
+    let r = read("0 0 10 10 rectfill 0 0 moveto (x) cvn moveto");
+    assert!(r.warnings[0].contains("typecheck in `moveto`: a number"), "{:?}", r.warnings);
+}
+
+/// Operators programs use to probe the interpreter or measure things: file `status`, `token`,
+/// `bytesavailable`, `pathforall`, `strokepath`, `nulldevice`, `currenthsbcolor`, the cache and
+/// device parameter queries.
+#[test]
+fn probing_operators_answer() {
+    super::tests::check("currentfile status (no such file) status not and");
+    super::tests::check("(12 /x {a}) token { 12 eq exch (/x {a}) eq and } { false } ifelse");
+    super::tests::check("() token not");
+    super::tests::check(
+        "/n 0 def 0 0 moveto 10 0 lineto { pop pop /n n 1 add def } { pop pop /n n 2 add def } { 6 { pop } repeat } {} pathforall n 3 eq",
+    );
+    super::tests::check("1 0 0 setrgbcolor currenthsbcolor 1 eq exch 1 eq and exch 0 eq and");
+    super::tests::check("currentcacheparams counttomark 2 eq exch pop exch pop exch pop");
+    super::tests::check("cachestatus 7 { pop } repeat true");
+    super::tests::check("currentcolorrendering /ColorRenderingType known");
+    super::tests::check("[ (x) /y ] gcheck not");
+    // `strokepath` makes the stroke's outline the path; `nulldevice` paints nothing.
+    let r = read("4 setlinewidth 10 50 moveto 90 50 lineto strokepath fill gsave nulldevice 0 0 100 100 rectfill grestore");
+    clean(&r);
+    let o = objects(&r.document);
+    assert_eq!(o.len(), 1);
+    assert!(near(bounds(&o[0]), Rect::new(10.0, 48.0, 90.0, 52.0)), "{:?}", bounds(&o[0]));
+}
+
+/// A file whose PostScript can't be read opens its Windows metafile preview (vectors) when its
+/// binary header has one, else its EPSI bitmap preview.
+#[test]
+fn metafile_and_epsi_previews_stand_in() {
+    let ps = super::tests::eps("0 0 10 10 rectfill frobnicate");
+    // A placeable metafile of one red rectangle over its 1000-unit frame.
+    let wmf = wmf_rectangle();
+    let mut bytes = vec![0xC5, 0xD0, 0xD3, 0xC6];
+    let words = [30u32, ps.len() as u32, 30 + ps.len() as u32, wmf.len() as u32, 0, 0];
+    for w in words {
+        bytes.extend(w.to_le_bytes());
+    }
+    bytes.extend(0xFFFFu16.to_le_bytes());
+    bytes.extend(&ps);
+    bytes.extend(&wmf);
+    let r = import(&bytes).unwrap();
+    assert!(r.preview);
+    assert!(r.warnings[0].contains("frobnicate") && r.warnings[0].contains("metafile"), "{:?}", r.warnings);
+    let paths: Vec<_> = all(&r.document).into_iter().filter(|n| n.kind_label() == "Path").collect();
+    assert!(!paths.is_empty());
+    assert!(near(bounds(&paths[0]), Rect::new(10.0, 10.0, 90.0, 90.0)), "{:?}", bounds(&paths[0]));
+
+    // An EPSI preview: 4 × 2 pixels, 1 bit, black on the left.
+    let epsi = "%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 100 100\n%%EndComments\n%%BeginPreview: 4 2 1 2\n% C0\n% C0\n%%EndPreview\nfrobnicate\n";
+    let r = import(epsi.as_bytes()).unwrap();
+    assert!(r.preview, "{:?}", r.warnings);
+    assert_eq!([pixel(&r.document, 0, 0), pixel(&r.document, 3, 1)], [[0, 0, 0, 255], [255, 255, 255, 255]]);
+}
+
+/// A placeable Windows metafile (1000 units an inch) of a red rectangle from (100, 100) to
+/// (900, 900) on a frame of 1000 × 1000 units.
+fn wmf_rectangle() -> Vec<u8> {
+    let mut v = vec![];
+    let w16 = |v: &mut Vec<u8>, x: u16| v.extend(x.to_le_bytes());
+    let w32 = |v: &mut Vec<u8>, x: u32| v.extend(x.to_le_bytes());
+    w32(&mut v, 0x9AC6_CDD7);
+    for x in [0u16, 0, 0, 1000, 1000, 1000] {
+        w16(&mut v, x);
+    }
+    w32(&mut v, 0);
+    let sum = v.chunks(2).fold(0u16, |a, c| a ^ u16::from_le_bytes([c[0], c[1]]));
+    w16(&mut v, sum);
+    let records: Vec<Vec<u16>> = vec![
+        vec![0x020B, 0, 0],               // SetWindowOrg
+        vec![0x020C, 1000, 1000],         // SetWindowExt
+        vec![0x02FC, 0, 0x00FF, 0, 0],    // CreateBrushIndirect: solid red
+        vec![0x012D, 0],                  // SelectObject
+        vec![0x041B, 900, 900, 100, 100], // Rectangle (bottom, right, top, left)
+        vec![0x0000],                     // EOF
+    ];
+    let size: usize = 9 + records.iter().map(|r| r.len() + 2).sum::<usize>();
+    for x in [1u16, 9, 0x0300] {
+        w16(&mut v, x);
+    }
+    w32(&mut v, size as u32);
+    w16(&mut v, 1);
+    w32(&mut v, 7);
+    w16(&mut v, 0);
+    for r in records {
+        w32(&mut v, r.len() as u32 + 2);
+        for x in r {
+            w16(&mut v, x);
+        }
+    }
+    v
+}
+
+/// Immediately evaluated names (`//name`) are their values when read: inside a procedure that
+/// runs after the dictionary that defined them is gone, and as an operand at the top.
+#[test]
+fn immediately_evaluated_names_are_read_as_their_values() {
+    super::tests::check("2 dict begin /v 7 def /p { //v } def currentdict end /d exch def d /p get exec 7 eq");
+    super::tests::check("/w 3 def //w 3 eq");
+    let r = read("/p { 0 0 10 10 } def //p rectfill");
+    clean(&r);
+    let r = read("0 0 10 10 rectfill /q { //nosuchname } def");
+    assert!(r.warnings[0].contains("nosuchname"), "{:?}", r.warnings);
+    let _ = Point::ZERO;
+}
+
+/// User paths (`ufill`, `ustroke`, `uappend`, `upath`, as procedures and in the encoded form),
+/// and reading a file byte by byte (`read`) with its position.
+#[test]
+fn user_paths_and_file_reads() {
+    let r = read(
+        "{ 0 0 50 50 setbbox 10 10 moveto 40 10 lineto 40 40 lineto closepath } ufill \
+         [ [0 0 50 50 60 60 90 60 90 90] <00010303> ] ustroke \
+         newpath 0 0 moveto 5 5 lineto",
+    );
+    clean(&r);
+    let o = objects(&r.document);
+    assert_eq!(o.len(), 2);
+    assert!(near(bounds(&o[0]), Rect::new(10.0, 60.0, 40.0, 90.0)), "{:?}", bounds(&o[0]));
+    assert!(stroke(&o[1]).is_some() && near(bounds(&o[1]), Rect::new(60.0, 10.0, 90.0, 40.0)), "{:?}", bounds(&o[1]));
+    super::tests::check(
+        "(ab) /ASCIIHexDecode filter pop (4142) /ASCIIHexDecode filter dup read pop 65 eq exch dup 0 setfileposition read pop 65 eq and",
+    );
+    super::tests::check("{ (x) deletefile } stopped revision 1 eq and");
+    // The bounding box, then each point with its operator.
+    super::tests::check("newpath 0 0 moveto 5 5 lineto false upath length 11 eq");
+}
+
+/// Programs that would run away through what this reader adds end at its limits: a pattern
+/// whose cell paints with itself, a Type 3 glyph that shows itself, a sampled function or mesh
+/// too large, a dash pattern too fine for `strokepath`.
+#[test]
+fn hostile_patterns_glyphs_and_shadings_end() {
+    let r = read(
+        "/P << /PatternType 1 /PaintType 1 /XStep 5 /YStep 5 /BBox [0 0 5 5] \
+         /PaintProc { pop P setpattern 0 0 5 5 rectfill } >> matrix makepattern def \
+         P setpattern 0 0 50 50 rectfill",
+    );
+    assert!(!r.preview && r.warnings.iter().any(|w| w.contains("nested too deeply")), "{:?}", r.warnings);
+    let r = import(&super::tests::eps(
+        "0 0 1 1 rectfill /T << /FontType 3 /FontMatrix [1 0 0 1 0 0] /Encoding [/a] \
+         /BuildChar { pop pop 0 0 moveto (a) show } >> definefont setfont 0 0 moveto (a) show",
+    ))
+    .unwrap();
+    assert!(r.warnings[0].contains("error"), "{:?}", r.warnings);
+    let r = read(
+        "0 0 1 1 rectfill << /ShadingType 2 /ColorSpace /DeviceGray /Coords [0 0 1 0] \
+         /Function << /FunctionType 0 /Domain [0 1] /Range [0 1] /Size [99999999] /BitsPerSample 8 /DataSource () >> >> shfill",
+    );
+    assert!(r.warnings[0].contains("rangecheck in `shfill`: a sampled function"), "{:?}", r.warnings);
+    // Procedures nesting through operators that run them end at the nesting limit.
+    for body in ["/f { { f } exec } def f", "/f { true { f } if } def f", "/f { 1 { f } repeat } def f", "/f { { f } stopped } def f"] {
+        assert!(import(&super::tests::eps(body)).is_err(), "{body}");
+    }
+    let r = read("[1e-9] 0 setdash 0 0 moveto 1000 1000 lineto strokepath fill");
+    clean(&r);
+    assert_eq!(objects(&r.document).len(), 1);
+}
+
+/// Illustrator 8 EPS (what stock art often comes as, #474): its gradient procset builds shading
+/// dictionaries with `bd` … `ed`, where `ed` is an executable string (`(>>) cvx`, or a Level 1
+/// dictionary builder), and its `discard` runs procedures it `load`s by integer keys.
+#[test]
+fn illustrator_8_gradients_and_executable_strings() {
+    let program = r##"%%BeginProlog
+userdict /AGM_Gradient 20 dict dup begin put
+/AGM_Gradient_private 201 dict def
+/initialize {
+  AGM_Gradient begin AGM_Gradient_private begin
+  /bd systemdict /mark get def
+  /ed /languagelevel where { pop languagelevel 2 ge } { false } ifelse
+    { (>>) } { (counttomark 2 idiv dup dict begin {def} repeat pop currentdict end) } ifelse cvx def
+  /ed1 (counttomark 2 idiv dup dict begin {def} repeat pop currentdict end) cvx def
+  end end
+} def
+userdict /discardDict 4 dict dup begin put
+0 { 0 1 0 setrgbcolor } def
+2 { 0 0 1 setrgbcolor } def
+end
+/gt38? false def
+/discard { discardDict begin /endString exch def gt38? { 2 add } if load stopped pop end } bind def
+%%EndProlog
+initialize
+AGM_Gradient begin AGM_Gradient_private begin
+bd /ShadingType 3 /ColorSpace /DeviceRGB
+  /Function bd /FunctionType 2 /Domain [0 1] /C0 [1 1 0] /C1 [0 0.5 0] /N 1 ed
+  /Extend [true true] /Coords [50 50 0 50 50 40] ed
+gsave 10 10 80 80 rectclip shfill grestore
+bd /Width 3 ed1 /Width get 3 eq { 0 (%AI5_EndPalette) discard 10 10 20 20 rectfill } if
+end end
+(x) cvx xcheck (x) cvx cvlit xcheck not and { 50 50 10 10 rectfill } if
+showpage"##;
+    let r = open("Adobe Illustrator(R) 8.0", program);
+    let d = &r.document;
+    let Some(Paint::Gradient(g)) = all(d).into_iter().find_map(|n| fill(&n).cloned()) else { panic!("no gradient") };
+    assert_eq!(g.gradient.kind, vectorcraft_color::GradientKind::Radial);
+    // `discard` ran the procedure under key 0 (green), not the one under 2.
+    assert!(all(d).iter().any(|n| fill(n).and_then(Paint::color) == Some(Color::rgb(0.0, 1.0, 0.0))));
+    assert_eq!(objects(d).len(), 3);
+}

crates/eps/src/import/tests_illustrator.rs

@@ -0,0 +1,91 @@
+//! Illustrator files (Illustrator 3–8 and their EPS): the groups they write (`u` … `U`) come in
+//! as groups, nested as they were, between and inside clipping groups.
+
+use std::sync::Arc;
+
+use vectorcraft_doc::clipnest::MAX_NEST;
+use vectorcraft_doc::{Node, NodeKind};
+
+use crate::import::import;
+
+/// A minimal file in Illustrator's format: its header comments, a prolog of our own defining the
+/// operators `body` uses (`u` and `U` as `ugroup` and `Ugroup`), and `body`.
+fn ai(header: &str, ugroup: &str, body: &str) -> Vec<u8> {
+    format!(
+        "%!PS-Adobe-3.0 EPSF-3.0\n{header}%%BoundingBox: 0 0 100 100\n%%EndComments\n%%BeginProlog\n\
+         /m {{moveto}} def /L {{lineto}} def /f {{closepath fill}} def /S {{stroke}} def /g {{setgray}} def\n\
+         /u {{{ugroup}}} def /U {{{}}} def\n%%EndProlog\n{body}\nshowpage\n%%EOF\n",
+        if ugroup.contains("gsave") { "grestore" } else { "" }
+    )
+    .into_bytes()
+}
+
+const AI8: &str = "%%Creator: Adobe Illustrator(R) 8.0\n%AI5_FileFormat 4.0\n";
+
+/// A triangle filled at `x`.
+fn tri(x: u32) -> String {
+    format!("{x} {x} m {} {x} L {} {} L f", x + 5, x + 5, x + 5)
+}
+
+/// The layer's objects as a tree: `p` a path, `c` a clip path, `g[…]` a group, `k[…]` a clipping
+/// group.
+fn tree(nodes: &[Arc<Node>]) -> String {
+    let one = |n: &Arc<Node>| match &n.kind {
+        NodeKind::Group { children, clip: false } => format!("g[{}]", tree(children)),
+        NodeKind::Group { children, clip: true } => format!("k[{}]", tree(children)),
+        NodeKind::Path { clipping: true, .. } => "c".into(),
+        NodeKind::Path { .. } => "p".into(),
+        k => format!("{k:?}"),
+    };
+    nodes.iter().map(one).collect::<Vec<_>>().join(" ")
+}
+
+fn read(header: &str, ugroup: &str, body: &str) -> (String, Vec<String>) {
+    let r = import(&ai(header, ugroup, body)).unwrap();
+    (tree(r.document.layers[0].children().unwrap()), r.warnings)
+}
+
+#[test]
+fn groups_and_nested_groups_come_in_as_groups() {
+    let body = format!("u {} u {} {} U U {}", tri(10), tri(30), tri(50), tri(70));
+    assert_eq!(read(AI8, "", &body), ("g[p g[p p]] p".into(), vec![]));
+    // Illustrator 3's header names it only as the creator; a prolog whose groups save and restore
+    // the graphics state groups the same.
+    assert_eq!(read("%%Creator:Adobe Illustrator(TM) 3.2\n", "gsave", &body).0, "g[p g[p p]] p");
+    // Groups of one object, and groups next to each other.
+    assert_eq!(read(AI8, "", &format!("u {} U u {} U", tri(10), tri(30))).0, "g[p] g[p]");
+}
+
+#[test]
+fn groups_nest_with_clipping_groups() {
+    // A clipping group inside a group, a group inside a clipping group.
+    let clip = "gsave 0 0 m 50 0 L 50 50 L 0 50 L closepath clip newpath";
+    let body = format!("u {} {clip} u {} {} U grestore {} U", tri(10), tri(20), tri(30), tri(40));
+    assert_eq!(read(AI8, "", &body).0, "g[p k[c g[p p]] p]");
+    // A fill and a stroke of one path in a group stay one object.
+    let body = "u 10 10 m 20 10 L 20 20 L closepath gsave 0 g fill grestore S U";
+    let r = import(&ai(AI8, "", body)).unwrap();
+    let layer = r.document.layers[0].children().unwrap();
+    assert_eq!(tree(layer), "g[p]");
+    assert_eq!(layer[0].children().unwrap()[0].appearance.items.len(), 2);
+}
+
+#[test]
+fn other_postscript_keeps_its_own_u() {
+    // A program that isn't Illustrator's may name its own procedures `u` and `U`.
+    let body = format!("u {} {} U", tri(10), tri(30));
+    assert_eq!(read("%%Creator: some app\n", "", &body).0, "p p");
+}
+
+#[test]
+fn unbalanced_and_runaway_groups_are_read_safely() {
+    // Ends without a beginning end nothing; groups left open hold the rest.
+    assert_eq!(read(AI8, "", &format!("U U {} u {} u {}", tri(10), tri(20), tri(30))).0, "p g[p g[p]]");
+    // Groups nest only so deep: the deeper ones' art goes into the innermost group read, and the
+    // groups around them close where they should.
+    let n = MAX_NEST + 50;
+    let body = format!("{} {} {} {}", "u ".repeat(n), tri(10), "U ".repeat(n), tri(30));
+    let (t, warnings) = read(AI8, "", &body);
+    assert_eq!(t, format!("{}p{} p", "g[".repeat(MAX_NEST), "]".repeat(MAX_NEST)));
+    assert!(warnings.iter().any(|w| w.contains("nested more than")), "{warnings:?}");
+}

crates/eps/src/import/text.rs

@@ -4,11 +4,14 @@
 
 use std::rc::Rc;
 
+use std::sync::Arc;
 use vectorcraft_color::Paint;
+
 use vectorcraft_doc::{CharStyle, Node, NodeId, NodeKind, TextObject};
 use vectorcraft_geom::{Affine, Point, Vec2};
 use vectorcraft_text::TextLayout;
 
+use super::graphics::MAX_APART;
 use super::interp::{Interp, matrix_obj, matrix_of};
 use super::obj::{Dict, DictRef, Key, Obj, Op, PsError, Res, ps_err};
 
@@ -133,44 +136,19 @@ impl Interp<'_> {
                 self.push(Obj::Bool(known))?;
             }
             ResourceForAll => self.resource_for_all()?,
-            Show => {
-                let s = self.pop_str()?.to_vec();
-                self.show(&s)?;
-            }
-            AShow => {
-                let s = self.pop_str()?.to_vec();
-                self.nums::<2>()?;
-                self.show(&s)?;
-            }
-            WidthShow => {
-                let s = self.pop_str()?.to_vec();
-                self.pop()?;
-                self.nums::<2>()?;
-                self.show(&s)?;
-            }
-            AWidthShow => {
-                let s = self.pop_str()?.to_vec();
-                self.nums::<2>()?;
-                self.pop()?;
-                self.nums::<2>()?;
-                self.show(&s)?;
-            }
-            XShow | YShow | XYShow => {
-                self.pop()?;
-                let s = self.pop_str()?.to_vec();
-                self.show(&s)?;
-            }
-            KShow => {
-                let s = self.pop_str()?.to_vec();
-                self.pop()?;
-                self.show(&s)?;
+            Show | AShow | WidthShow | AWidthShow | XShow | YShow | XYShow | KShow => {
+                let (s, spacing) = self.show_operands(op)?;
+                match self.type3_font() {
+                    Some(font) => self.show_type3(&font, &s, &spacing)?,
+                    None => self.show(&s)?,
+                }
             }
             CShow => {
                 // The procedure shows or places each character: it gets its code and width.
                 let s = self.pop_str()?.to_vec();
                 let proc = self.pop_proc()?;
                 for b in s {
-                    let (_, _, v) = self.set_type(&[b], Point::ZERO)?;
+                    let v = self.width_of(&[b])?;
                     self.push(Obj::Int(i64::from(b)))?;
                     self.push_num(v.x)?;
                     self.push_num(v.y)?;
@@ -181,12 +159,23 @@ impl Interp<'_> {
             }
             GlyphShow => {
                 let name = self.pop()?.text().unwrap_or_else(|| Rc::from(""));
-                let ch = glyph_char(&name);
-                self.show(ch.encode_utf8(&mut [0; 4]).as_bytes())?;
+                match self.type3_font() {
+                    Some(font) => {
+                        let start = self.out.drawn.len();
+                        let at = self.user_point()?;
+                        let w = self.type3_glyph(&font, Glyph::Name(name.clone()), at, true)?;
+                        self.g.cur = Some(self.xf() * (at + w));
+                        self.group_glyphs(start, &name);
+                    }
+                    None => {
+                        let ch = glyph_char(&name);
+                        self.show(ch.encode_utf8(&mut [0; 4]).as_bytes())?;
+                    }
+                }
             }
             StringWidth => {
                 let s = self.pop_str()?.to_vec();
-                let (_, _, v) = self.set_type(&s, Point::ZERO)?;
+                let v = self.width_of(&s)?;
                 self.push_num(v.x)?;
                 self.push_num(v.y)?;
             }
@@ -195,17 +184,169 @@ impl Interp<'_> {
                 let s = self.pop_str()?.to_vec();
                 self.char_path(&s)?;
             }
-            SetCacheDevice => {
-                self.nums::<6>()?;
-            }
-            SetCharWidth => {
-                self.nums::<2>()?;
+            // A glyph procedure gives its width (`w0x w0y` first).
+            SetCacheDevice => self.glyph_width = Some(self.nums::<6>()?[..2].try_into().unwrap_or_default()),
+            SetCharWidth => self.glyph_width = Some(self.nums::<2>()?),
+            SetCacheDevice2 => self.glyph_width = Some(self.nums::<10>()?[..2].try_into().unwrap_or_default()),
+            RootFont => {
+                let font = match self.g.font.clone() {
+                    Some(f) => f,
+                    None => self.find_font(&Obj::name(DEFAULT_FONT))?,
+                };
+                self.push(Obj::Dict(font))?;
             }
             _ => return ps_err("undefined", op.name()),
         }
         Ok(())
     }
 
+    /// The string of a show operator and how it spaces its glyphs.
+    fn show_operands(&mut self, op: Op) -> Res<(Vec<u8>, Spacing)> {
+        use Op::*;
+        let num_vec = |[x, y]: [f64; 2]| Vec2::new(x, y);
+        if matches!(op, XShow | YShow | XYShow) {
+            // A number array (an encoded number string spaces glyphs by their widths).
+            let widths = match self.pop()? {
+                Obj::Array { items, .. } => items.borrow().iter().filter_map(Obj::as_num).collect(),
+                _ => vec![],
+            };
+            let s = self.pop_str()?.to_vec();
+            return Ok((s, Spacing::Widths(widths, op)));
+        }
+        let s = self.pop_str()?.to_vec();
+        let spacing = match op {
+            AShow => Spacing::Add(num_vec(self.nums()?), None),
+            WidthShow => {
+                let ch = self.pop_int()?;
+                Spacing::Add(Vec2::ZERO, Some((ch, num_vec(self.nums()?))))
+            }
+            AWidthShow => {
+                let a = num_vec(self.nums()?);
+                let ch = self.pop_int()?;
+                Spacing::Add(a, Some((ch, num_vec(self.nums()?))))
+            }
+            KShow => Spacing::Kern(self.pop_proc()?),
+            _ => Spacing::Plain,
+        };
+        Ok((s, spacing))
+    }
+
+    /// The current font when it is a Type 3 font: its glyphs are drawn by its own procedures.
+    fn type3_font(&self) -> Option<DictRef> {
+        let font = self.g.font.clone()?;
+        let f = font.borrow();
+        let builds = f.contains_key(&Key::name("BuildGlyph")) || f.contains_key(&Key::name("BuildChar"));
+        let type3 = f.get(&Key::name("FontType")).and_then(Obj::as_num) == Some(3.0) && builds;
+        drop(f);
+        type3.then_some(font)
+    }
+
+    /// How far `s` moves the current point (user space).
+    fn width_of(&mut self, s: &[u8]) -> Res<Vec2> {
+        let Some(font) = self.type3_font() else { return Ok(self.set_type(s, Point::ZERO)?.2) };
+        let mut w = Vec2::ZERO;
+        for &code in s {
+            w += self.type3_glyph(&font, Glyph::Code(code), Point::new(w.x, w.y), false)?;
+        }
+        Ok(w)
+    }
+
+    /// `s` shown in Type 3 font `font`, glyph by glyph, spaced as `spacing` says.
+    fn show_type3(&mut self, font: &DictRef, s: &[u8], spacing: &Spacing) -> Res {
+        let start = self.out.drawn.len();
+        for (i, &code) in s.iter().enumerate() {
+            let at = self.user_point()?;
+            let w = self.type3_glyph(font, Glyph::Code(code), at, true)?;
+            let d = match spacing {
+                Spacing::Plain | Spacing::Kern(_) => w,
+                Spacing::Add(a, c) => w + *a + c.filter(|(ch, _)| *ch == i64::from(code)).map_or(Vec2::ZERO, |(_, v)| v),
+                Spacing::Widths(v, op) => {
+                    let n = |k: usize| v.get(k).copied();
+                    match op {
+                        Op::XShow => n(i).map(|x| Vec2::new(x, 0.0)),
+                        Op::YShow => n(i).map(|y| Vec2::new(0.0, y)),
+                        _ => n(2 * i).zip(n(2 * i + 1)).map(|(x, y)| Vec2::new(x, y)),
+                    }
+                    .unwrap_or(w)
+                }
+            };
+            self.g.cur = Some(self.xf() * (at + d));
+            if let (Spacing::Kern(p), Some(next)) = (spacing, s.get(i + 1)) {
+                self.push(Obj::Int(i64::from(code)))?;
+                self.push(Obj::Int(i64::from(*next)))?;
+                self.call(p.clone())?;
+            }
+        }
+        let text: String = s.iter().map(|b| char::from(*b)).filter(|c| !c.is_control()).collect();
+        self.group_glyphs(start, &text);
+        Ok(())
+    }
+
+    /// Glyph `glyph` of Type 3 font `font` drawn by its `BuildGlyph` (or `BuildChar`) procedure at
+    /// user point `at` (only measured unless `paint`) → its width (user space).
+    fn type3_glyph(&mut self, font: &DictRef, glyph: Glyph, at: Point, paint: bool) -> Res<Vec2> {
+        let (fm, build_glyph, build_char, encoding) = {
+            let f = font.borrow();
+            let get = |k: &str| f.get(&Key::name(k)).cloned();
+            let fm = get("FontMatrix").and_then(|o| o.items().and_then(|i| matrix_of(&i.borrow()))).unwrap_or(Affine::scale(0.001));
+            (fm, get("BuildGlyph"), get("BuildChar"), get("Encoding"))
+        };
+        let code_of = |name: &str| -> Option<u8> {
+            let items = encoding.as_ref()?.items()?.to_vec();
+            items.iter().position(|o| o.text().as_deref() == Some(name)).and_then(|i| u8::try_from(i).ok())
+        };
+        let (name, code) = match glyph {
+            Glyph::Code(c) => {
+                let name = encoding.as_ref().and_then(|e| e.items()?.get(usize::from(c))).and_then(|o| o.text());
+                (name.unwrap_or_else(|| Rc::from(".notdef")), Some(c))
+            }
+            Glyph::Name(n) => {
+                let code = code_of(&n);
+                (n, code)
+            }
+        };
+        let arg = match (build_glyph, build_char, code) {
+            (Some(p), ..) => Some((p, Obj::Name(name))),
+            (None, Some(p), Some(c)) => Some((p, Obj::Int(i64::from(c)))),
+            _ => None,
+        };
+        let Some((proc, arg)) = arg else { return Ok(Vec2::ZERO) };
+        // A glyph that shows type in its own font would draw itself without end.
+        if self.out.apart >= MAX_APART {
+            return ps_err("limitcheck", "a Type 3 glyph");
+        }
+        self.gsave()?;
+        let depth = self.saved.len();
+        self.g.ctm = self.g.ctm * Affine::translate(at.to_vec2()) * fm;
+        self.take_path();
+        self.g.null |= !paint;
+        self.glyph_width = None;
+        self.out.apart += 1;
+        let r = self.push(Obj::Dict(font.clone())).and_then(|()| self.push(arg)).and_then(|()| self.call(proc));
+        self.out.apart -= 1;
+        let [wx, wy] = self.glyph_width.take().unwrap_or_default();
+        self.saved.truncate(depth);
+        self.grestore();
+        r?;
+        Ok(fm * Point::new(wx, wy) - fm * Point::ZERO)
+    }
+
+    /// The objects drawn since `start` (one show's glyphs) as one group named `text`, when they
+    /// are several under the same clips.
+    fn group_glyphs(&mut self, start: usize, text: &str) {
+        let here = self.out.chain(&self.g.clips);
+        let Some(drawn) = self.out.drawn.get(start..) else { return };
+        let same = drawn.iter().all(|(c, _)| c.iter().map(|c| c.id).eq(here.iter().map(|c| c.id)));
+        if drawn.len() < 2 || !same {
+            return;
+        }
+        let children: Vec<Arc<Node>> = self.out.drawn.drain(start..).map(|(_, n)| Arc::new(n)).collect();
+        let mut group = Node::group(NodeId(0), children);
+        group.name = Some(text.chars().take(64).collect());
+        let clips = self.g.clips.clone();
+        self.out.push(group, &clips);
+    }
+
     /// The font named `k`: one the program defined, else a font of that name.
     fn find_font(&mut self, k: &Obj) -> Res<DictRef> {
         let key = k.key().ok_or(PsError::Ps("typecheck", "findfont".into()))?;
@@ -290,6 +431,26 @@ impl Interp<'_> {
     }
 }
 
+/// How a show operator spaces its glyphs (Type 3 fonts; type in other fonts is laid out as point
+/// type).
+enum Spacing {
+    /// By their widths.
+    Plain,
+    /// `ashow`, `widthshow`, `awidthshow`: by their widths plus a displacement, and another for one
+    /// character code.
+    Add(Vec2, Option<(i64, Vec2)>),
+    /// `xshow`, `yshow`, `xyshow` (the operator): by the numbers given.
+    Widths(Vec<f64>, Op),
+    /// `kshow`: by their widths, the procedure run between each two.
+    Kern(Obj),
+}
+
+/// A glyph of a Type 3 font, by character code or by name (`glyphshow`).
+enum Glyph {
+    Code(u8),
+    Name(Rc<str>),
+}
+
 /// A font scaled or transformed by `m` (`scalefont`, `makefont`).
 fn transformed(font: &DictRef, m: Affine) -> DictRef {
     let mut d = font.borrow().clone();

crates/eps/src/lib.rs

@@ -377,6 +377,19 @@ pub fn sections(bytes: &[u8]) -> Option<(&[u8], Option<&[u8]>)> {
     Some((ps, tiff))
 }
 
+/// The Windows metafile preview behind an EPS file's binary header, if it has one.
+pub fn metafile_preview(bytes: &[u8]) -> Option<&[u8]> {
+    if !bytes.starts_with(&DOS_MAGIC) {
+        return None;
+    }
+    let word = |at: usize| bytes.get(at..at + 4).and_then(|b| <[u8; 4]>::try_from(b).ok()).map(|b| u32::from_le_bytes(b) as usize);
+    let (start, len) = (word(12)?, word(16)?);
+    if start == 0 || len == 0 {
+        return None;
+    }
+    bytes.get(start..start.checked_add(len)?)
+}
+
 /// The native document an EPS file written by [`export`] carries, if any.
 pub fn native(bytes: &[u8]) -> Option<Vec<u8>> {
     let (ps, _) = sections(bytes)?;

crates/format/tests/native_v3.rs

@@ -184,3 +184,19 @@ fn pretty_files_are_indented_like_serde_json() {
     // The same JSON as the compact file.
     assert_eq!(json_of(&bytes), json_of(&save(&d, false)));
 }
+
+/// #451: a guide's artboard is written only for artboard guides, so canvas guides save as they
+/// did, and a file without it (an older version's) opens with canvas guides.
+#[test]
+fn artboard_guides_round_trip_and_canvas_guides_save_as_before() {
+    use vectorcraft_doc::Guide;
+    let mut d = Document::new(100.0, 100.0);
+    let id = d.artboards[0].id;
+    d.guides = vec![Guide::new(true, 10.0), Guide { artboard: Some(id), ..Guide::new(false, 20.0) }];
+    let mut v = json_of(&save(&d, false));
+    assert_eq!(v["document"]["guides"], json!([{"vertical": true, "pos": 10.0}, {"vertical": false, "pos": 20.0, "artboard": id}]));
+    assert_eq!(load(&save(&d, false)).unwrap().guides, d.guides);
+    v["document"]["guides"] = json!([{"vertical": false, "pos": 20.0}]);
+    let old = load(&serde_json::to_vec(&v).unwrap()).unwrap();
+    assert_eq!(old.guides, [Guide::new(false, 20.0)]);
+}

crates/geom/src/arc.rs

@@ -0,0 +1,101 @@
+//! Arc-length parametrization of a path: the point and direction at a distance along it, and the
+//! distance along it of the point nearest another (type on a path lays its glyphs out and the
+//! selection tools drag its brackets by distance along the path).
+
+use kurbo::{ParamCurve, ParamCurveArclen, ParamCurveNearest, PathSeg, Point, Vec2};
+
+use crate::PathData;
+
+const ACCURACY: f64 = 1e-4;
+
+/// A path's segments with their lengths, measured once.
+#[derive(Clone, Debug, Default)]
+pub struct ArcPath {
+    /// Segments of some length, each with the distance to its start and its length.
+    segs: Vec<(PathSeg, f64, f64)>,
+    len: f64,
+    closed: bool,
+}
+
+impl ArcPath {
+    pub fn new(path: &PathData) -> Self {
+        let mut segs = Vec::new();
+        let mut cum = 0.0;
+        for s in path.to_bezpath().segments() {
+            let l = s.arclen(ACCURACY);
+            if l.is_finite() && l > 1e-9 {
+                segs.push((s, cum, l));
+                cum += l;
+            }
+        }
+        Self { segs, len: cum, closed: path.is_closed() }
+    }
+
+    /// The path's length.
+    pub fn len(&self) -> f64 {
+        self.len
+    }
+
+    /// No segment has any length.
+    pub fn is_empty(&self) -> bool {
+        self.segs.is_empty()
+    }
+
+    pub fn is_closed(&self) -> bool {
+        self.closed
+    }
+
+    /// Point and unit tangent at distance `s` along the path: round and round a closed path, held
+    /// at an open one's ends.
+    pub fn at(&self, s: f64) -> (Point, Vec2) {
+        let s = if self.closed && self.len > 0.0 { s.rem_euclid(self.len) } else { s.clamp(0.0, self.len) };
+        let i = self.segs.partition_point(|(_, c, _)| *c <= s).saturating_sub(1);
+        let Some(&(seg, c, l)) = self.segs.get(i) else { return (Point::ZERO, Vec2::new(1.0, 0.0)) };
+        let t = seg.inv_arclen((s - c).min(l), ACCURACY).clamp(0.0, 1.0);
+        let p = seg.eval(t);
+        let (t0, t1) = ((t - 1e-4).max(0.0), (t + 1e-4).min(1.0));
+        let d = seg.eval(t1) - seg.eval(t0);
+        let len = d.hypot();
+        (p, if len > 1e-12 { d / len } else { Vec2::new(1.0, 0.0) })
+    }
+
+    /// The distance along the path of its point nearest `p`.
+    pub fn nearest(&self, p: Point) -> Option<f64> {
+        self.segs
+            .iter()
+            .map(|(seg, c, l)| {
+                let n = seg.nearest(p, ACCURACY);
+                (n.distance_sq, c + seg.subsegment(0.0..n.t).arclen(ACCURACY).min(*l))
+            })
+            .min_by(|a, b| a.0.total_cmp(&b.0))
+            .map(|(_, s)| s)
+    }
+
+    /// [`Self::nearest`] as a fraction (0..1) of the path's length.
+    pub fn fraction_at(&self, p: Point) -> Option<f64> {
+        (self.len > 0.0).then(|| self.nearest(p)).flatten().map(|s| (s / self.len).clamp(0.0, 1.0))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::shapes;
+    use kurbo::{Rect, Shape};
+
+    #[test]
+    fn points_and_nearest_distances_along_a_path() {
+        let line = PathData::from_bezpath(&kurbo::Line::new((0.0, 0.0), (100.0, 0.0)).to_path(0.1));
+        let a = ArcPath::new(&line);
+        assert!((a.len() - 100.0).abs() < 1e-6 && !a.is_closed());
+        assert!(a.at(25.0).0.distance(Point::new(25.0, 0.0)) < 1e-6);
+        // Held at an open path's ends.
+        assert!(a.at(150.0).0.distance(Point::new(100.0, 0.0)) < 1e-6);
+        assert!((a.nearest(Point::new(40.0, 30.0)).unwrap() - 40.0).abs() < 1e-6);
+        // Round a closed one.
+        let sq = ArcPath::new(&shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)));
+        assert!(sq.is_closed() && (sq.len() - 40.0).abs() < 1e-6);
+        assert!(sq.at(45.0).0.distance(sq.at(5.0).0) < 1e-6);
+        assert!(ArcPath::new(&PathData::default()).is_empty());
+    }
+}

crates/geom/src/lib.rs

@@ -7,6 +7,7 @@
 //! Coordinates are document points (1/72 in), y pointing down.
 #![forbid(unsafe_code)]
 
+pub mod arc;
 pub mod bez;
 pub mod hit;
 pub mod path;
@@ -15,6 +16,7 @@ pub mod recognize;
 pub mod shapes;
 pub mod snap;
 
+pub use arc::ArcPath;
 pub use kurbo;
 pub use kurbo::{Affine, BezPath, CubicBez, Line, ParamCurve, PathEl, PathSeg, Point, Rect, Shape, Size, Vec2};
 pub use path::{Anchor, AnchorKind, FillRule, PathData, SubPath};

crates/geom/src/path.rs

@@ -1,5 +1,7 @@
 //! The anchor-based editable path model.
 
+use std::collections::BTreeSet;
+
 use kurbo::{Affine, BezPath, CubicBez, ParamCurve, ParamCurveNearest, PathEl, Point, Rect, Shape};
 use serde::{Deserialize, Serialize};
 
@@ -268,6 +270,77 @@ impl SubPath {
         self.anchors.insert(seg + 1, mid);
         seg + 1
     }
+    /// Make anchor `i` smooth: handles in line with its neighbours (its one neighbour at an open
+    /// end), each a third of the way to that side's neighbour. A smooth anchor with both handles
+    /// keeps them. False when there is no such anchor or no direction (the neighbours coincide).
+    pub fn smooth_anchor(&mut self, i: usize) -> bool {
+        let n = self.anchors.len();
+        let prev = if i > 0 {
+            Some(i - 1)
+        } else if self.closed {
+            n.checked_sub(1)
+        } else {
+            None
+        };
+        let next = if i + 1 < n {
+            Some(i + 1)
+        } else if self.closed {
+            Some(0)
+        } else {
+            None
+        };
+        let at = |j: Option<usize>| j.and_then(|j| self.anchors.get(j)).map(|a| a.p);
+        let (prev, next) = (at(prev), at(next));
+        let Some(a) = self.anchors.get_mut(i) else { return false };
+        if a.kind == AnchorKind::Smooth && a.has_in() && a.has_out() {
+            return true;
+        }
+        let (pp, nn) = (prev.unwrap_or(a.p), next.unwrap_or(a.p));
+        let dir = nn - pp;
+        let l = dir.hypot();
+        if l <= 1e-9 {
+            return false;
+        }
+        let u = dir / l;
+        a.h_in = a.p - u * (a.p.distance(pp) / 3.0);
+        a.h_out = a.p + u * (a.p.distance(nn) / 3.0);
+        a.kind = AnchorKind::Smooth;
+        true
+    }
+    /// Cut at the anchors `at`: each becomes the end of one open piece and the start of the next,
+    /// its handle off each piece retracted (the shape doesn't change). A closed subpath opens at
+    /// its first cut, so one cut leaves one piece whose ends coincide. The ends of an open subpath
+    /// and indices past the end don't cut; with no cut left, the subpath comes back as it is.
+    pub fn cut_at(&self, at: &BTreeSet<usize>) -> Vec<SubPath> {
+        let n = self.anchors.len();
+        let mut cuts = at.iter().copied().filter(|&i| i < n && (self.closed || (i > 0 && i + 1 < n))).peekable();
+        let Some(&first) = cuts.peek().filter(|_| n >= 2) else { return vec![self.clone()] };
+        // A closed subpath's anchors from the first cut round to it again; an open one's as they are.
+        let (run, cuts): (Vec<Anchor>, BTreeSet<usize>) = if self.closed {
+            (self.anchors.iter().cycle().skip(first).take(n + 1).copied().collect(), cuts.map(|c| (c + n - first) % n).chain([n]).collect())
+        } else {
+            (self.anchors.clone(), cuts.collect())
+        };
+        let mut pieces = vec![];
+        let mut cur: Vec<Anchor> = vec![];
+        for (i, a) in run.into_iter().enumerate() {
+            if !cuts.contains(&i) {
+                cur.push(a);
+                continue;
+            }
+            if !cur.is_empty() {
+                cur.push(Anchor { h_out: a.p, kind: AnchorKind::Corner, ..a });
+                pieces.push(SubPath::new(std::mem::take(&mut cur), false));
+            }
+            if i < n {
+                cur.push(Anchor { h_in: a.p, kind: AnchorKind::Corner, ..a });
+            }
+        }
+        if cur.len() > 1 {
+            pieces.push(SubPath::new(cur, false));
+        }
+        pieces
+    }
     /// Signed area via the shoelace formula on the Bézier path (positive = clockwise in y-down).
     pub fn area(&self) -> f64 {
         let mut bp = BezPath::new();

crates/geom/src/shapes.rs

@@ -47,6 +47,18 @@ impl CornerKind {
     }
 }
 
+/// The largest corner radius a `w` × `h` rectangle draws: half its shorter side.
+pub fn max_corner_radius(w: f64, h: f64) -> f64 {
+    w.abs().min(h.abs()) / 2.0
+}
+
+/// The radius a corner of a `w` × `h` rectangle is drawn with: `radius`, no larger than
+/// [`max_corner_radius`] (the same limit for every corner, so opposite corners match), 0 when
+/// negative or not a number.
+pub fn fitted_corner_radius(w: f64, h: f64, radius: f64) -> f64 {
+    radius.max(0.0).min(max_corner_radius(w, h))
+}
+
 /// Rectangle whose corners (top-left, top-right, bottom-right, bottom-left, y down) each have
 /// their own radius and kind, every radius clamped to half the shorter side. A corner without a
 /// radius is one anchor, the others two (where the cut meets each side). Clockwise from the
@@ -63,7 +75,6 @@ pub fn rectangle_anchor_corners(r: Rect, radii: [f64; 4]) -> Vec<usize> {
 /// The anchors of [`rectangle_with_corners`], each with its corner.
 fn corner_anchors(r: Rect, radii: [f64; 4], kinds: [CornerKind; 4]) -> Vec<(usize, Anchor)> {
     let r = r.abs();
-    let max = r.width().min(r.height()) / 2.0;
     // Each corner, with the directions of the side arriving at it and of the side leaving it.
     let corners = [
         (Point::new(r.x0, r.y0), Vec2::new(0.0, -1.0), Vec2::new(1.0, 0.0)),
@@ -74,7 +85,7 @@ fn corner_anchors(r: Rect, radii: [f64; 4], kinds: [CornerKind; 4]) -> Vec<(usiz
     let mut out = Vec::with_capacity(8);
     let mut top_left_start = None;
     for (k, ((c, din, dout), (rad, kind))) in corners.into_iter().zip(radii.into_iter().zip(kinds)).enumerate() {
-        let rad = rad.max(0.0).min(max);
+        let rad = fitted_corner_radius(r.width(), r.height(), rad);
         if rad <= 1e-9 {
             out.push((k, Anchor::corner(c)));
             continue;
@@ -312,6 +323,24 @@ mod tests {
         assert_eq!(CornerKind::ALL.map(CornerKind::next), [CornerKind::InvertedRound, CornerKind::Chamfer, CornerKind::Round]);
     }
 
+    /// #442: on a rectangle that isn't square, every corner is a circular arc of the same radius,
+    /// and radii past the limit stop at half the shorter side, whichever side a corner is on.
+    #[test]
+    fn corners_of_a_non_square_rectangle_are_alike() {
+        let r = Rect::new(0.0, 0.0, 200.0, 80.0);
+        assert_eq!(max_corner_radius(-200.0, 80.0), 40.0);
+        assert_eq!([30.0, 60.0, -1.0, f64::NAN].map(|x| fitted_corner_radius(200.0, 80.0, x)), [30.0, 40.0, 0.0, 0.0]);
+        for (radius, drawn) in [(30.0, 30.0), (60.0, 40.0)] {
+            for kinds in [[CornerKind::Round; 4], [CornerKind::Chamfer, CornerKind::InvertedRound, CornerKind::Round, CornerKind::Chamfer]] {
+                let a: Vec<Point> = rectangle_with_corners(r, [radius; 4], kinds).subpaths[0].anchors.iter().map(|a| a.p).collect();
+                for (i, j) in [(7, 0), (1, 2), (3, 4), (5, 6)] {
+                    let (x, y) = ((a[j].x - a[i].x).abs(), (a[j].y - a[i].y).abs());
+                    assert!((x - drawn).abs() < 1e-9 && (y - drawn).abs() < 1e-9, "radius {radius}: a corner spans {x} × {y}");
+                }
+            }
+        }
+    }
+
     #[test]
     fn polygon_first_vertex_up() {
         let p = polygon(Point::new(0.0, 0.0), 10.0, 6, 0.0);

crates/geom/tests/prop_geom.rs

@@ -179,6 +179,35 @@ proptest! {
         prop_assert!((q.length() - p.length()).abs() < 1e-3 * p.length().max(1.0));
     }
 
+    /// Cutting at anchors keeps every segment as it was, in order (a closed subpath's from its
+    /// first cut), in open pieces of two or more anchors. A smoothed corner gets handles on a line
+    /// through it.
+    #[test]
+    fn cut_at_keeps_the_segments(p in arb_path_data(), cuts in proptest::collection::btree_set(0usize..12, 0..4), pick in 0usize..100) {
+        let sp = &p.subpaths[pick % p.subpaths.len()];
+        let n = sp.anchors.len();
+        let pieces = sp.cut_at(&cuts);
+        let segs = |s: &vectorcraft_geom::SubPath| (0..s.segment_count()).map(|i| s.segment(i)).collect::<Vec<_>>();
+        let mut want = segs(sp);
+        if pieces.len() > 1 || pieces.first().is_some_and(|q| q.closed != sp.closed) {
+            prop_assert!(pieces.iter().all(|q| !q.closed && q.anchors.len() >= 2));
+            if sp.closed {
+                want.rotate_left(cuts.iter().copied().find(|&c| c < n).unwrap_or(0));
+            }
+        } else {
+            prop_assert_eq!(&pieces, &vec![sp.clone()]);
+        }
+        prop_assert_eq!(pieces.iter().flat_map(segs).collect::<Vec<_>>(), want);
+        let mut s = sp.clone();
+        let i = pick % n.max(1);
+        let corner = s.anchors.get(i).is_some_and(|a| a.kind == vectorcraft_geom::AnchorKind::Corner);
+        if s.smooth_anchor(i) && corner {
+            let a = s.anchors[i];
+            let (u, v) = (a.h_in - a.p, a.h_out - a.p);
+            prop_assert!(u.cross(v).abs() <= 1e-6 * (1.0 + u.hypot() * v.hypot()) && u.dot(v) <= 0.0, "{a:?}");
+        }
+    }
+
     /// Polygon area via the shoelace formula equals the path's signed area magnitude and
     /// SubPath::area.
     #[test]

crates/mcp/src/headless.rs

@@ -271,7 +271,7 @@ impl Backend for Headless {
                 self.exec(&id, &params)
             }
             "engine.commands" => Ok(self.commands()),
-            "document.inspect" => self.exec("document.inspect", &json!({})),
+            "document.inspect" => self.exec("document.inspect", p),
             "document.node" => self.exec("document.node", p),
             "document.json" => self.exec("document.json", &json!({})),
             "ui.tool.select" => self.select_tool(p),

crates/mcp/src/resources.rs

@@ -44,7 +44,7 @@ pub static TEMPLATES: &[Template] = &[
         uri: "vectorcraft://object/{id}",
         name: "object",
         title: "One layer or object",
-        description: "The layer or object with this id, with its children, bounds and paint (document.node {summary: true})",
+        description: "The layer or object with this id, with its children, bounds and paint (document.node {summary: true}). Large containers can be sliced with run_command document.node {id, summary, depth, childLimit}: truncated levels report childCount",
         mime: "application/json",
         live: Live::Objects,
     },

crates/mcp/src/tests.rs

@@ -175,6 +175,15 @@ fn headless_end_to_end() {
     assert_eq!(rect["fill"], "#ff0000", "{rect}");
     assert_eq!(rect["stroke"], "None");
 
+    // A depth-0 inspect is the skeleton: top layers with counts, nothing below them;
+    // a bad slice is a tool error, not a full dump.
+    let r = call(&mut s, 41, "inspect_document", json!({"depth": 0}));
+    let skel: Value = serde_json::from_str(&text_of(&r)).unwrap();
+    assert!(skel["layers"][0].get("children").is_none(), "{skel}");
+    assert_eq!(skel["layers"][0]["childCount"], layer["children"].as_array().unwrap().len());
+    assert_eq!(skel["artboards"], doc["artboards"]);
+    assert_eq!(call(&mut s, 42, "inspect_document", json!({"depth": -1}))["isError"], true);
+
     // Screenshot returns image content (base64 PNG) and text.
     let shot_path = tmp("shot.png");
     let r = call(&mut s, 5, "screenshot", json!({"path": shot_path.to_str().unwrap()}));
@@ -504,3 +513,54 @@ fn oversized_screenshot_and_png_export_are_errors() {
     let r = call(&mut s, 4, "screenshot", json!({"scale": 0.01}));
     assert_eq!(r["isError"], false, "{r}");
 }
+
+/// Preferences reach agents' gestures (#394): `prefs.set` Object Selection by Path Only, then a
+/// click inside a filled square selects nothing; Command Click to Select Objects Behind, a
+/// Cmd-click selects the square underneath.
+#[test]
+fn selection_preferences_apply_to_pointer_gestures() {
+    let mut s = server();
+    let square = |s: &mut Server, id: u64, x: u64| {
+        let r = call(s, id, "draw_shape", json!({"shape": "rectangle", "x": x, "y": 100, "width": 100, "height": 100, "fill": "#ff0000"}));
+        serde_json::from_str::<Value>(&text_of(&r)).unwrap()["id"].as_u64().unwrap()
+    };
+    let (back, front) = (square(&mut s, 1, 100), square(&mut s, 2, 150));
+    let click = |s: &mut Server, id: u64, x: f64, mods: Value| {
+        let events = json!([{"kind": "down", "x": x, "y": 125}, {"kind": "up", "x": x, "y": 125}]);
+        let r = call(s, id, "pointer_gesture", json!({"tool": "selection", "events": events, "mods": mods}));
+        assert_eq!(r["isError"], false, "{r}");
+        serde_json::from_str::<Value>(&text_of(&r)).unwrap()["selection"].clone()
+    };
+    assert_eq!(click(&mut s, 3, 175.0, json!({})), json!([front]));
+    assert_eq!(click(&mut s, 4, 175.0, json!({"cmd": true})), json!([back]), "Cmd-click selects behind");
+    let r = call(&mut s, 5, "run_command", json!({"command": "prefs.set", "params": {"key": "objectSelectionByPathOnly", "value": true}}));
+    assert_eq!(r["isError"], false, "{r}");
+    assert_eq!(click(&mut s, 6, 225.0, json!({})), json!([]), "path only: the fill doesn't select");
+    assert_eq!(click(&mut s, 7, 250.0, json!({})), json!([front]), "the path does");
+}
+
+/// Type preferences reach agents (#394): type the Type tool places starts with placeholder text,
+/// selected; Alt+→ tracks it by Tracking and Cmd+Shift+. steps its size by Size/Leading.
+#[test]
+fn type_preferences_apply_to_agents() {
+    let mut s = server();
+    let events = json!([{"kind": "down", "x": 100, "y": 100}, {"kind": "up", "x": 100, "y": 100}]);
+    let r = call(&mut s, 1, "pointer_gesture", json!({"tool": "type", "events": events}));
+    assert_eq!(r["isError"], false, "{r}");
+    let id = serde_json::from_str::<Value>(&text_of(&r)).unwrap()["selection"][0].as_u64().unwrap();
+    let style = |s: &mut Server, n: u64| {
+        let r = call(s, n, "run_command", json!({"command": "text.getRange", "params": {"id": id}}));
+        let v = serde_json::from_str::<Value>(&text_of(&r)).unwrap();
+        assert!(v["text"].as_str().unwrap().len() > 10, "placeholder text: {v}");
+        let st = &v["runs"][0]["style"];
+        (st["size"].as_f64().unwrap(), st["tracking"].as_f64().unwrap())
+    };
+    let (size, tracking) = style(&mut s, 2);
+    let r = call(&mut s, 3, "run_command", json!({"command": "prefs.set", "params": {"values": {"typeSizeIncrement": 4, "trackingIncrement": 50}}}));
+    assert_eq!(r["isError"], false, "{r}");
+    let r = call(&mut s, 4, "press_key", json!({"key": "Right", "mods": {"alt": true}}));
+    assert_eq!(r["isError"], false, "{r}");
+    let r = call(&mut s, 5, "press_key", json!({"key": ".", "mods": {"cmd": true, "shift": true}}));
+    assert_eq!(r["isError"], false, "{r}");
+    assert_eq!(style(&mut s, 6), (size + 4.0, tracking + 50.0));
+}

crates/mcp/src/tests_distortkeys.rs

@@ -1,5 +1,6 @@
 //! `press_key` with the Width and Puppet Warp tools: Delete and Backspace reach the selected width
-//! point or pin, and clear the selected art when the tool has nothing selected.
+//! point or pin, and clear the selected art when the tool has nothing selected. Cmd+A while the
+//! Type tool edits selects the text, not the art.
 
 use serde_json::{Value, json};
 
@@ -64,3 +65,15 @@ fn delete_and_backspace_reach_the_puppet_warp_tool() {
         assert!(!exists(&h, id), "{key} cleared the art");
     }
 }
+
+#[test]
+fn cmd_a_while_the_type_tool_edits_selects_the_text() {
+    let mut h = session();
+    run(&mut h, "shape.rectangle", json!({"x": 300, "y": 300, "width": 20, "height": 20}));
+    let id = run(&mut h, "text.create", json!({"x": 100, "y": 100, "text": "Hello", "size": 20}))["id"].as_u64().unwrap();
+    click(&mut h, "type", 102.0, 95.0);
+    let r = ok(&mut h, "press_key", json!({"key": "A", "mods": {"cmd": true}}));
+    assert_eq!(r["command"], "select.all");
+    assert_eq!(r["result"], json!({"editing": id, "start": 0, "end": 5}));
+    assert_eq!(h.session.doc().unwrap().selection.objects, [vectorcraft_doc::NodeId(id)], "the art selection stays");
+}

crates/mcp/src/tests_fileio.rs

@@ -145,3 +145,55 @@ fn pdf_pages(pdf: &[u8]) -> usize {
         .unwrap();
     h.session.doc().unwrap().doc.artboards.len()
 }
+
+/// Issue #421 over MCP: RGB greys switched to CMYK with `grays: "black"` print on the black plate
+/// only, in the document and in the exported PDF.
+#[test]
+fn document_color_mode_puts_rgb_greys_on_the_black_plate() {
+    let svg = tmp("greys.svg");
+    std::fs::write(
+        &svg,
+        r##"<svg xmlns="http://www.w3.org/2000/svg" width="200pt" height="50pt" viewBox="0 0 200 50">
+<rect x="0" y="0" width="50" height="50" fill="#000000"/><rect x="50" y="0" width="50" height="50" fill="#333333"/>
+<rect x="100" y="0" width="50" height="50" fill="#808080"/><rect x="150" y="0" width="50" height="50" fill="#e6e6e6"/>
+</svg>"##,
+    )
+    .unwrap();
+    let want = [1.0, 0.8, 0.498, 0.098];
+    let k_only = |h: &Headless| -> Vec<f32> {
+        let mut ks = vec![];
+        for l in &h.session.doc().unwrap().doc.layers {
+            l.walk(&mut |n| {
+                if n.children().is_none()
+                    && let Some(c) = n.appearance.fill_paint().color()
+                {
+                    let v = serde_json::to_value(c).unwrap();
+                    assert!(v["model"] == "cmyk" && v["c"] == 0.0 && v["m"] == 0.0 && v["y"] == 0.0, "not K only: {v}");
+                    ks.push(v["k"].as_f64().unwrap() as f32);
+                }
+            });
+        }
+        ks
+    };
+    let close = |ks: &[f32]| ks.len() == want.len() && ks.iter().zip(want).all(|(k, w)| (k - w).abs() < 0.005);
+    let mut h = Headless::new();
+    text(&call_tool(&mut h, "open_file", &json!({"path": svg})));
+    let r = text(&call_tool(&mut h, "run_command", &json!({"command": "file.documentColorMode", "params": {"mode": "cmyk", "grays": "black"}})));
+    assert_eq!(r["changed"], 4);
+    let ks = k_only(&h);
+    assert!(close(&ks), "{ks:?}");
+    // The PDF carries the same inks (DeviceCMYK opens as CMYK).
+    let pdf = text(&call_tool(&mut h, "export", &json!({"format": "pdf"})));
+    let mut back = Headless::new();
+    back.call("engine.execute", json!({"command": "document.open", "params": {"name": "greys.pdf", "dataBase64": pdf["dataBase64"]}})).unwrap();
+    let ks = k_only(&back);
+    assert!(close(&ks), "{ks:?}");
+    // document.open takes the same option.
+    let mut o = Headless::new();
+    let r = call_tool(&mut o, "run_command", &json!({"command": "document.open", "params": {"path": svg, "colorMode": "cmyk", "grays": "black"}}));
+    text(&r);
+    let ks = k_only(&o);
+    assert!(close(&ks), "{ks:?}");
+    let bad = call_tool(&mut o, "run_command", &json!({"command": "file.documentColorMode", "params": {"mode": "rgb", "grays": "rich"}}));
+    assert!(bad.is_error, "{bad:?}");
+}

crates/mcp/src/tools.rs

@@ -100,8 +100,14 @@ pub fn tool_definitions() -> Vec<Value> {
         tool(
             "inspect_document",
             "Inspect document",
-            "Summary of the active document: artboards, layer tree (ids, names, kinds, bounds, fill/stroke), selection, undo history, current tool and default paint.",
-            empty(),
+            "Summary of the active document: artboards, layer tree (ids, names, kinds, bounds, fill/stroke), selection, undo history, current tool and default paint. On a large document pass depth: 0 for the layer skeleton (truncated levels report childCount), then locate objects with run_command document.find and read them with document.node.",
+            obj(
+                json!({
+                    "depth": {"type": "integer", "minimum": 0, "description": "Child levels of the layer tree to include (default all; 0 = top layers with counts)"},
+                    "childLimit": {"type": "integer", "minimum": 0, "description": "Children shown per node (default all; a level that shows fewer reports childCount)"}
+                }),
+                &[],
+            ),
             true,
         ),
         tool(
@@ -256,7 +262,7 @@ pub fn tool_definitions() -> Vec<Value> {
             "open_file",
             "Open file",
             &format!(
-                "Open a file as a new, active document: .{} (see run_command document.formats). Templates (.ait, native templates) open as a new untitled document.",
+                "Open a file as a new, active document: .{} (see run_command document.formats). Templates (.ait, native templates) open as a new untitled document. The reply's `warnings` say what didn't come in as it was (an EPS shown as its preview image says why its PostScript couldn't be read).",
                 OPEN_EXTS.join(", .")
             ),
             obj(json!({"path": string("File path")}), &["path"]),
@@ -683,7 +689,12 @@ fn dispatch(b: &mut dyn Backend, name: &str, a: &Args) -> Result<ToolResult, Str
             let method = if name == "invoke_menu" && b.has_ui() { "ui.menu.invoke" } else { "engine.execute" };
             j(b.call(method, json!({"command": cmd, "params": params}))?)
         }
-        "inspect_document" => j(b.call("document.inspect", json!({}))?),
+        "inspect_document" => {
+            // Only the slicing options reach the command, which validates them.
+            let slice: Map<String, Value> =
+                a.iter().filter(|(k, _)| matches!(k.as_str(), "depth" | "childLimit")).map(|(k, v)| (k.clone(), v.clone())).collect();
+            j(b.call("document.inspect", Value::Object(slice))?)
+        }
         "inspect_ui" => {
             need_ui(b, name)?;
             j(b.call("ui.inspect", json!({}))?)