Part of #394: Preferences for snapping, handles, rubber bands, pattern tiles, tints and type

Fourteen more Preferences options that were stored but read by nothing now
act, for the mouse and for agents (prefs.set, then pointer_gesture,
press_key or the commands):

- Selection & Anchor Display: Snap to Point and its distance (with Smart
  Guides off, View > Snap to Point lands a dragged selection's grabbed
  point, drawn points and reference points on anchors and ruler guides);
  Move Locked and Hidden Artwork with Artboard (artboard.move, the Artboard
  tool and Rearrange; off, hidden art now stays too); Enable Rubber Band for
  the Pen and Curvature tools; Handles (solid, hollow, large);
  Show handles when multiple anchors are selected (canvas and Direct
  Selection's handle picking); Hide Corner Widget for angles greater than.
- General: Transform Pattern Tiles is the default of a new `patterns`
  param on object.transform/move/rotate/scale/reflect/shear/transformEach
  (journalled when the art uses a pattern), and the transform dialogs get a
  Transform Patterns checkbox; Select Same Tint % (off, Select > Same
  Fill/Stroke Color takes every tint of a global or spot swatch).
- Type: new type.step {attribute, by} steps size, leading, tracking, kerning
  and baseline shift by the Size/Leading, Tracking and Baseline Shift
  increments; Increase/Decrease Font Size (Cmd+Shift+. and Cmd+Shift+,);
  the Type tool's Alt+arrows (kerning at a caret or tracking, leading,
  Shift for baseline shift, Cmd/Ctrl for five steps). Enable Missing Glyph
  Protection keeps characters a new font lacks in the font that had them
  (text.setStyle, text.setRangeStyle). Fill New Type Objects With
  Placeholder Text: type the Type tools place starts with placeholder text,
  selected (text.create / text.createInPath take `placeholder`).

Units > General, Stroke and Type were already the single source of truth
(units.rs). Auto Size New Area Type, Show Font Names in English and
Highlight Alternate Glyphs need subsystems the app doesn't have yet and
stay open with the rest of #394.

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).

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"
@@ -4642,6 +4690,7 @@ dependencies = [
  "log",
  "serde",
  "serde_json",
+ "toml",
  "vectorcraft-cad",
  "vectorcraft-color",
  "vectorcraft-doc",
@@ -5640,6 +5689,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, and the missing-font export warning (#319); 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) and skeleton reads with `document.find` for large documents over MCP (#416); see [Honest assessment](#honest-assessment-2026-10-05))._
 
 ## Where we are
 
@@ -42,7 +42,7 @@ 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); 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); 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 |
 
 ### Where we're lacking (in priority order)
@@ -63,7 +63,8 @@ Ordered by how much each gap blocks someone from switching. Sizes are one-agent
    spell-check dictionary (open licence), Touch Type and Snap to Glyph. Vertical point, area and path type have
    initial support. 35–48 h across type core and advanced.
 5. **Brushes, symbols and libraries:** brush options depth; original brush, symbol and graphic-style libraries
-   generated in code (never Adobe's); dynamic symbols; Start Global Edit. 14–22 h.
+   generated in code (never Adobe's); dynamic symbols; Start Global Edit; brushes driven by pen tilt, bearing and
+   barrel rotation (6D art pens, #372), which needs tablet input beyond pressure on every platform. 20–32 h.
 6. **Automation:** Variables (data merge), a scripting surface over the command registry, batch. 8–12 h.
 7. **Views and windows:** multiple windows and arrange, Consolidate All Windows, video
    rulers. 15–25 h.
@@ -89,7 +90,7 @@ 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:
@@ -102,8 +103,10 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - 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), 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. They reach agents too (`prefs.set`, then `pointer_gesture` or `press_key`; `ui.wheel` on the control channel). About 45 stored options still do nothing yet (the rest of #394: Auto Size New Area Type, Show Font Names in English, Highlight Alternate Glyphs, the smart guide display options, performance, devices…).
   - 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.
   - 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).
@@ -112,24 +115,24 @@ 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. 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.
+  - **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.
   - **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.
   - **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.
+  - **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, 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.
+- **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 (Shift snaps them to the ruler's ticks) 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 art's edges, centres and 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.
 - **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.
   - 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.
+- **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; 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, 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; 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).
 - **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.
@@ -144,11 +147,11 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 - **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, 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).
+  - 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); 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.
+  - 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).
 - **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.
+- **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).
 - **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
@@ -157,12 +160,12 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 |---|---|---|---|
 | M0 | Skeleton + vertical slice | ✅ done | — |
 | M1 | Selection, transform, layers, MCP | ✅ mostly done (transform reference point snaps to anchors/centres; rotated objects keep a rotated bounding box and their angle; Free Transform, Scale and Reflect along a rotated box pending) | 4–6 |
-| M2 | Drawing tools + smart guides | ✅ mostly done (Flare, Reshape, Live Corners widget dragging landed; Shaper, the remaining Pen modifier nuances) | 15–20 |
+| M2 | Drawing tools + smart guides | ✅ mostly done (Flare, Reshape, Live Corners widget dragging and per-corner radii and kinds landed; Shaper, the remaining Pen modifier nuances) | 15–20 |
 | M3 | Paint & appearance (swatches, color, gradient, stroke, appearance, transparency, styles) | ✅ done (M3.7–M3.98): swatches, groups, libraries, tints, Lab spots and Registration; Color Picker, Color panel, Color Guide, Color Themes, Edit Colors and Recolor Artwork; gradients that follow every transform, the annotator, linked stops, freeform gradients, focal points, gradients on strokes and Expand; stroke geometry, arrowheads, dashes fitted to corners, stroke on type, width profiles and the Width tool, Scale Strokes and preview bounds; Appearance targeting, container appearance, target circles, Expand Appearance; knockout, isolation, blend accuracy, CMYK blending, overprint, Attributes, masks and clipping, Flatten Transparency; graphic styles, links and libraries. Left: freeform and mixed spot/process gradients export as stops or process colours to SVG/PDF; confirm the Scale Strokes & Effects default | 4–8 |
 | 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 edge erase, 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 |
+| 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; 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, 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 |
@@ -189,26 +192,26 @@ 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 | 10–15 |
-| Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 86% | Live Paint gap options, Shape Builder edge cases | 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 and options | 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) | 6–10 |
+| 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 |
 | Live vector effects | 5 | 85% | Outline Object, Pathfinder Hard/Soft Mix and Trap, SVG Filters | 6–10 |
 | 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 — hanging punctuation, line-start brackets, 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 |
 | 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 |
+| Guides, grids, smart guides, snapping, rulers | 3 | 80% | global/video rulers, smart-guide preference depth, Alt swapping a ruler guide's orientation, ruler guides selected together with art (marquee, Shift-click) and on layers (dragging existing guides is done, #414) | 3–6 |
 | 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 |
 | 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 45 Preferences options stored but not yet acted on (#394: smart guide display options, Auto Size New Area Type, Show Font Names in English, Highlight Alternate Glyphs, Show Pixel Grid, performance, devices…) | 16–26 |
 | 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 |

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-web/src/web.rs

@@ -1,12 +1,14 @@
-//! The browser shell: web `Services`, drag-and-drop, and the eframe web runner.
+//! The browser shell: web `Services`, drag-and-drop, the eframe web runner, and starting again
+//! with new graphics when the page loses them (#369).
 
-use std::cell::Cell;
+use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 
 use vectorcraft_engine::Session;
 use vectorcraft_engine::cmd::fileio;
-use vectorcraft_engine::cmd::recovery::{Hold, RecoveryStore};
+use vectorcraft_engine::cmd::recovery::{self, Hold, RecoveryStore};
+use vectorcraft_ui_egui::graphics::GraphicsLoss;
 use vectorcraft_ui_egui::place::{DropTarget, PlaceArrival, PlaceInbox};
 use vectorcraft_ui_egui::print::{PrintJob, PrintService, Printer};
 use vectorcraft_ui_egui::{Services, VectorcraftApp};
@@ -23,58 +25,123 @@ type DragPos = Rc<Cell<Option<(f32, f32, bool)>>>;
 const CANVAS_ID: &str = "vectorcraft_canvas";
 const LOADING_ID: &str = "vectorcraft_loading";
 
+/// How many times the page starts again with new graphics after losing them before it gives up
+/// (a GPU that keeps failing).
+const MAX_RESTARTS: u32 = 3;
+
+/// What the page keeps while the app runs, across graphics restarts.
+#[derive(Clone)]
+struct Host {
+    runner: eframe::WebRunner,
+    inbox: Inbox,
+    place_inbox: PlaceInbox,
+    drag: DragPos,
+    /// 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>,
+    /// Graphics restarts so far.
+    restarts: u32,
+}
+
 pub fn start() {
     eframe::WebLogger::init(log::LevelFilter::Info).ok();
-    wasm_bindgen_futures::spawn_local(async {
-        let Some(document) = web_sys::window().and_then(|w| w.document()) else {
-            log::error!("no document");
-            return;
-        };
-        let Some(canvas) = document.get_element_by_id(CANVAS_ID).and_then(|e| e.dyn_into::<web_sys::HtmlCanvasElement>().ok()) else {
-            log::error!("missing <canvas id=\"{CANVAS_ID}\">");
-            return;
-        };
-        let drag = track_drag(&canvas);
+    let Some(canvas) = element(CANVAS_ID).and_then(|e| e.dyn_into::<web_sys::HtmlCanvasElement>().ok()) else {
+        log::error!("missing <canvas id=\"{CANVAS_ID}\">");
+        return;
+    };
+    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;
-        let mut options = eframe::WebOptions::default();
-        if query().contains("webgl")
-            && let eframe::egui_wgpu::WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup
-        {
-            create.instance_descriptor.backends = eframe::wgpu::Backends::GL;
-        }
-        let result = eframe::WebRunner::new()
-            .start(
-                canvas,
-                options,
-                Box::new(move |cc| {
-                    if let Some(rs) = &cc.wgpu_render_state {
-                        log::info!("vectorcraft-web: wgpu backend {:?}", rs.adapter.get_info().backend);
+        let host = Host {
+            runner: eframe::WebRunner::new(),
+            inbox: Arc::default(),
+            place_inbox: Arc::default(),
+            drag: DragPos::default(),
+            locks,
+            restarts: 0,
+        };
+        run(host, canvas, None).await;
+    });
+}
+
+/// An app whose graphics were lost, on its way to new ones.
+struct Moving {
+    app: VectorcraftApp,
+    /// Its unsaved changes are kept in recovery copies ([`VectorcraftApp::graphics_lost`]).
+    kept: bool,
+}
+
+/// Run the app on `canvas`: the `moving` one when starting again after losing the graphics, else
+/// a new one.
+async fn run(host: Host, canvas: web_sys::HtmlCanvasElement, moving: Option<Moving>) {
+    track_drag(&canvas, &host.drag);
+    let kept = moving.as_ref().map(|m| m.kept);
+    // The app until the new runner takes it (still here if starting fails before).
+    let slot = Rc::new(RefCell::new(moving.map(|m| m.app)));
+    let (runner, taken, page) = (host.runner.clone(), slot.clone(), canvas.clone());
+    let result = runner
+        .start(
+            canvas,
+            web_options(),
+            Box::new(move |cc| {
+                let ctx = &cc.egui_ctx;
+                let loss = GraphicsLoss::default();
+                watch_canvas(&page, &loss, ctx);
+                if let Some(rs) = &cc.wgpu_render_state {
+                    log::info!("vectorcraft-web: wgpu backend {:?}", rs.adapter.get_info().backend);
+                    let (loss, ctx) = (loss.clone(), ctx.clone());
+                    rs.device.set_device_lost_callback(move |reason, msg| loss.report(&ctx, format!("{reason:?}: {msg}")));
+                }
+                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) => {
+                        // The old services asked the old context for frames.
+                        app.services = services;
+                        app.status("The graphics were lost and have been restarted");
+                        app
                     }
-                    let inbox: Inbox = Arc::default();
-                    let place_inbox: PlaceInbox = Arc::default();
-                    let app = VectorcraftApp::new(Session::new(), services(inbox.clone(), place_inbox.clone(), cc.egui_ctx.clone(), locks));
-                    Ok(Box::new(WebShell { app, inbox, place_inbox, drag }))
-                }),
-            )
-            .await;
-        if let Some(el) = document.get_element_by_id(LOADING_ID) {
-            match result {
-                Ok(()) => el.remove(),
-                Err(e) => el.set_inner_html(&format!("<p>VectorCraft failed to start: {e:?}</p><p>A browser with WebGPU or WebGL2 is required.</p>")),
+                    None => VectorcraftApp::new(Session::new(), services),
+                };
+                Ok(Box::new(WebShell { app: Some(app), host, canvas: page, loss }))
+            }),
+        )
+        .await;
+    match (result, kept) {
+        (Ok(()), _) => {
+            if let Some(el) = element(LOADING_ID) {
+                el.remove();
             }
         }
-    });
+        (Err(e), None) => notice(&[&format!("VectorCraft failed to start: {}", js_err(e)), "A browser with WebGPU or WebGL2 is required."]),
+        (Err(e), Some(kept)) => {
+            log::error!("vectorcraft-web: couldn't restart the graphics: {}", js_err(e));
+            give_up(slot.borrow_mut().take(), kept);
+        }
+    }
+}
+
+/// The runner's options: wgpu (WebGPU where available, else WebGL2; `?webgl` forces WebGL2).
+fn web_options() -> eframe::WebOptions {
+    let mut options = eframe::WebOptions::default();
+    if query().contains("webgl")
+        && let eframe::egui_wgpu::WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup
+    {
+        create.instance_descriptor.backends = eframe::wgpu::Backends::GL;
+    }
+    options
 }
 
 fn query() -> String {
     web_sys::window().and_then(|w| w.location().search().ok()).unwrap_or_default()
 }
 
-/// Follow file drags over the canvas: drag events carry the pointer position, which egui doesn't
-/// get during a drag.
-fn track_drag(canvas: &web_sys::HtmlCanvasElement) -> DragPos {
-    let pos = DragPos::default();
+fn element(id: &str) -> Option<web_sys::Element> {
+    web_sys::window()?.document()?.get_element_by_id(id)
+}
+
+/// Follow file drags over `canvas` into `pos`: drag events carry the pointer position, which egui
+/// doesn't get during a drag.
+fn track_drag(canvas: &web_sys::HtmlCanvasElement, pos: &DragPos) {
     let p = pos.clone();
     let on_drag = wasm_bindgen::closure::Closure::<dyn FnMut(web_sys::DragEvent)>::new(move |e: web_sys::DragEvent| {
         p.set(Some((e.offset_x() as f32, e.offset_y() as f32, e.shift_key())));
@@ -84,29 +151,123 @@ fn track_drag(canvas: &web_sys::HtmlCanvasElement) -> DragPos {
             log::error!("couldn't follow {kind} events: {e:?}");
         }
     }
-    // The listener lives as long as the page.
+    // The listener lives as long as the canvas.
     on_drag.forget();
-    pos
+}
+
+/// 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) {
+    let (loss, ctx) = (loss.clone(), ctx.clone());
+    let on_lost = wasm_bindgen::closure::Closure::<dyn FnMut(web_sys::Event)>::new(move |_: web_sys::Event| {
+        loss.report(&ctx, "the WebGL context was lost");
+    });
+    if let Err(e) = canvas.add_event_listener_with_callback("webglcontextlost", on_lost.as_ref().unchecked_ref()) {
+        log::error!("couldn't watch for a lost WebGL context: {e:?}");
+    }
+    // The listener lives as long as the canvas.
+    on_lost.forget();
+}
+
+/// A new canvas in place of `old`, whose graphics were lost (a canvas whose WebGL context is lost
+/// can't get another).
+fn fresh_canvas(old: &web_sys::HtmlCanvasElement) -> Result<web_sys::HtmlCanvasElement, String> {
+    let new: web_sys::HtmlCanvasElement = old.clone_node().map_err(js_err)?.dyn_into().map_err(|_| "not a canvas")?;
+    old.replace_with_with_node_1(&new).map_err(js_err)?;
+    Ok(new)
+}
+
+/// The graphics are lost for good: the dead canvas goes (it would show a stale picture), the app
+/// (if still here) lets go of its recovery copies so the reloaded page offers them at once, and
+/// the page says what to do.
+fn give_up(app: Option<VectorcraftApp>, kept: bool) {
+    if let Some(mut app) = app {
+        recovery::leave(&mut app.session);
+    }
+    if let Some(canvas) = element(CANVAS_ID) {
+        canvas.remove();
+    }
+    notice(&[
+        "The graphics were lost and couldn't be restarted.",
+        if kept {
+            "Your unsaved changes are kept in this browser: reload the page to get them back."
+        } else {
+            "Reload the page to go on (changes not saved yet may be lost)."
+        },
+    ]);
+}
+
+/// Show `lines` in the middle of the page (where the loading message was).
+fn notice(lines: &[&str]) {
+    let Some(document) = web_sys::window().and_then(|w| w.document()) else { return };
+    let el = match document.get_element_by_id(LOADING_ID) {
+        Some(el) => el,
+        None => {
+            let Ok(el) = document.create_element("div") else { return };
+            el.set_id(LOADING_ID);
+            let Some(body) = document.body() else { return };
+            if let Err(e) = body.append_child(&el) {
+                log::error!("couldn't show a message: {e:?}");
+            }
+            el
+        }
+    };
+    el.set_text_content(None);
+    for line in lines {
+        if let Ok(p) = document.create_element("p") {
+            p.set_text_content(Some(line));
+            // Best effort: the log has the message too.
+            el.append_child(&p).ok();
+        }
+    }
 }
 
 /// Wraps the app to read dropped files asynchronously (browsers can't read them synchronously)
 /// and feed them through the inboxes: placed where they were dropped on the canvas, else opened.
+/// When the graphics are lost it hands the app to a new runner on a new canvas.
 struct WebShell {
-    app: VectorcraftApp,
-    inbox: Inbox,
-    place_inbox: PlaceInbox,
-    drag: DragPos,
+    /// `None` once handed on.
+    app: Option<VectorcraftApp>,
+    host: Host,
+    canvas: web_sys::HtmlCanvasElement,
+    loss: GraphicsLoss,
+}
+
+impl WebShell {
+    /// The graphics were lost (`why`): keep recovery copies, then start again on a new canvas
+    /// with the same app once this frame is over (the runner is busy with it until then).
+    fn restart(&mut self, why: &str) {
+        let Some(mut app) = self.app.take() else { return };
+        let kept = app.graphics_lost(why);
+        let mut host = self.host.clone();
+        host.restarts += 1;
+        let canvas =
+            if host.restarts > MAX_RESTARTS { Err(format!("the graphics were lost {MAX_RESTARTS} times")) } else { fresh_canvas(&self.canvas) };
+        match canvas {
+            Ok(canvas) => wasm_bindgen_futures::spawn_local(run(host, canvas, Some(Moving { app, kept }))),
+            Err(e) => {
+                log::error!("vectorcraft-web: giving up on the graphics: {e}");
+                let runner = host.runner;
+                wasm_bindgen_futures::spawn_local(async move { runner.destroy() });
+                give_up(Some(app), kept);
+            }
+        }
+    }
 }
 
 impl eframe::App for WebShell {
     fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        if let Some(why) = self.loss.take() {
+            self.restart(&why);
+        }
+        let Some(app) = &mut self.app else { return };
         let dropped = ctx.input_mut(|i| std::mem::take(&mut i.raw.dropped_files));
         if !dropped.is_empty() {
-            let at = self.drag.take();
+            let at = self.host.drag.take();
             let z = ctx.zoom_factor();
-            let target = self.app.drop_target(at.map(|(x, y, _)| egui::pos2(x / z, y / z)), at.is_some_and(|a| a.2));
+            let target = app.drop_target(at.map(|(x, y, _)| egui::pos2(x / z, y / z)), at.is_some_and(|a| a.2));
             for f in dropped {
-                let (inbox, place_inbox, ctx) = (self.inbox.clone(), self.place_inbox.clone(), ctx.clone());
+                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 {
@@ -124,15 +285,19 @@ impl eframe::App for WebShell {
                 });
             }
         }
-        self.app.logic(ctx);
+        app.logic(ctx);
     }
 
     fn raw_input_hook(&mut self, _ctx: &egui::Context, raw: &mut egui::RawInput) {
-        self.app.raw_input_hook(raw);
+        if let Some(app) = &mut self.app {
+            app.raw_input_hook(raw);
+        }
     }
 
     fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
-        self.app.ui(ui);
+        if let Some(app) = &mut self.app {
+            app.ui(ui);
+        }
     }
 }
 

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).

apps/vectorcraft/src/clipboard.rs

@@ -4,11 +4,16 @@
 //! - Windows: text, SVG, PDF, PNG and an opaque bitmap (for apps that don't read PNG) in one go;
 //!   Paste reads each of them.
 //! - 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 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.
@@ -29,6 +34,23 @@ fn decode_png(png: &[u8]) -> Option<image::RgbaImage> {
     Some(image::load_from_memory_with_format(png, image::ImageFormat::Png).ok()?.to_rgba8())
 }
 
+/// 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;
@@ -123,16 +145,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 => raw::is_format_avail(formats::CF_BITMAP) || formats_of(PNG).any(raw::is_format_avail),
+                    m => formats_of(m).any(raw::is_format_avail),
+                })
         }
     }
 
@@ -245,6 +277,9 @@ 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 => {
@@ -262,3 +297,48 @@ mod portable {
         }
     }
 }
+
+#[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));
+    }
+}

apps/vectorcraft/src/main.rs

@@ -25,45 +25,69 @@ mod window;
 
 use vectorcraft_engine::Session;
 use vectorcraft_engine::cmd::fileio;
+use vectorcraft_ui_egui::graphics::GraphicsLoss;
 use vectorcraft_ui_egui::{FilePick, Services, VectorcraftApp};
 
-struct App(VectorcraftApp, #[cfg(target_os = "macos")] Option<native_menu::NativeMenu>);
+struct App {
+    app: VectorcraftApp,
+    /// Reported by wgpu when the window's graphics device is lost (a driver reset).
+    graphics_loss: GraphicsLoss,
+    /// The graphics device was lost and the unsaved changes are kept for Data Recovery.
+    graphics_lost: bool,
+    #[cfg(target_os = "macos")]
+    menu: Option<native_menu::NativeMenu>,
+}
 
 impl eframe::App for App {
     fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        if let Some(why) = self.graphics_loss.take() {
+            // eframe can't give a window a new device: the user saves and starts again.
+            self.graphics_lost = self.app.graphics_lost(&why);
+            self.app.status(if self.graphics_lost {
+                "The graphics device was lost: unsaved changes are kept for Data Recovery. Save your documents and restart VectorCraft"
+            } else {
+                "The graphics device was lost: save your documents and restart VectorCraft"
+            });
+        }
+        if self.graphics_lost && ctx.input(|i| i.viewport().close_requested()) {
+            // The window can't show the Save Changes question: it closes, and the next launch
+            // offers the changes back.
+            vectorcraft_ui_egui::background::wait_all(&mut self.app);
+            return;
+        }
         #[cfg(target_os = "macos")]
         {
-            if self.1.is_none() && std::env::var_os("VECTORCRAFT_NO_NATIVE_MENU").is_none() {
-                self.1 = Some(native_menu::NativeMenu::install(&mut self.0));
+            if self.menu.is_none() && std::env::var_os("VECTORCRAFT_NO_NATIVE_MENU").is_none() {
+                self.menu = Some(native_menu::NativeMenu::install(&mut self.app));
             }
-            if let Some(m) = &mut self.1 {
-                m.poll(&mut self.0);
+            if let Some(m) = &mut self.menu {
+                m.poll(&mut self.app, ctx);
             }
-            open_files(&mut self.0, open_documents::take());
+            open_files(&mut self.app, open_documents::take());
         }
-        self.0.logic(ctx);
-        window::track(ctx, &mut self.0.ui.window);
-        if self.0.ui.status == "quit" {
+        self.app.logic(ctx);
+        window::track(ctx, &mut self.app.ui.window);
+        if self.app.ui.status == "quit" {
             ctx.send_viewport_cmd(egui::ViewportCommand::Close);
         }
     }
     fn raw_input_hook(&mut self, _ctx: &egui::Context, raw: &mut egui::RawInput) {
-        self.0.raw_input_hook(raw);
+        self.app.raw_input_hook(raw);
     }
     fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
-        self.0.ui(ui);
+        self.app.ui(ui);
         #[cfg(target_os = "macos")]
-        if self.0.take_ime_discard() {
+        if self.app.take_ime_discard() {
             discard_marked_text();
         }
     }
     #[cfg(not(feature = "windows7"))]
     fn on_exit(&mut self) {
-        save_prefs(&self.0);
+        save_prefs(&self.app);
     }
     #[cfg(feature = "windows7")]
     fn on_exit(&mut self, _gl: Option<&eframe::glow::Context>) {
-        save_prefs(&self.0);
+        save_prefs(&self.app);
     }
 }
 
@@ -363,11 +387,14 @@ fn main() -> eframe::Result {
                 let recovery = prefs_path().and_then(|p| Some(p.parent()?.join("Data Recovery").to_string_lossy().to_string()));
                 app.session.recovery.set_default_folder(recovery);
             }
+            let graphics_loss = GraphicsLoss::default();
             #[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:?})");
                 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}")));
             }
             #[cfg(feature = "windows7")]
             {
@@ -382,11 +409,13 @@ fn main() -> eframe::Result {
             #[cfg(target_os = "macos")]
             open_documents::set_ui(&cc.egui_ctx);
             open_files(&mut app, files);
-            Ok(Box::new(App(
+            Ok(Box::new(App {
                 app,
+                graphics_loss,
+                graphics_lost: false,
                 #[cfg(target_os = "macos")]
-                None,
-            )))
+                menu: None,
+            }))
         }),
     )
 }

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();

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/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,8 +78,8 @@ 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, CharAlign, CharPosition, CharStyle, FirstBaseline, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathEffect,
+    ScriptMetrics, TabAlign, TabStop, TextKind, TextObject, TextRun, TextStyleDef, TextWrap, WrapShape,
 };
 pub use vectorcraft_color as color;
 pub use vectorcraft_geom as geom;
@@ -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()
     }
@@ -902,16 +914,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,8 +932,8 @@ 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
     }
@@ -1076,12 +1087,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/node.rs

@@ -1,14 +1,17 @@
 //! Document nodes.
 
+use std::collections::BTreeSet;
 use std::sync::Arc;
 
 use serde::{Deserialize, Serialize};
 use vectorcraft_color::BlendMode;
-use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect, shapes};
+use vectorcraft_geom::shapes::{self, CornerKind};
+use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect};
 
 use crate::appearance::Appearance;
 use crate::live::{BlendSpec, EnvelopeKind, GradientMesh, Outliner};
 use crate::pattern::RepeatSpec;
+use crate::selection::AnchorRef;
 use crate::text::TextObject;
 
 /// Stable per-document object id. Never reused.
@@ -82,6 +85,9 @@ pub enum LiveShape {
         /// Corner radii: top-left, top-right, bottom-right, bottom-left. In the same units as
         /// `w`/`h`: the corners are circular arcs in the document whenever `xf` doesn't scale.
         radii: [f64; 4],
+        /// Corner kinds, in the same order (Live Corners' corner types).
+        #[serde(default, skip_serializing_if = "all_round")]
+        kinds: [CornerKind; 4],
         /// Maps the untransformed shape (origin at its top-left) into the document. A rotation
         /// or reflection plus a move, unless a shear (or a file saved before transforms folded
         /// their scale into `w`/`h`) put more in it.
@@ -118,15 +124,8 @@ impl LiveShape {
     /// Regenerate the path.
     pub fn to_path(&self) -> PathData {
         match self {
-            LiveShape::Rectangle { w, h, radii, xf } => {
-                let r = Rect::new(0.0, 0.0, *w, *h);
-                let p = if radii.iter().all(|x| (x - radii[0]).abs() < 1e-9) {
-                    shapes::rounded_rectangle(r, radii[0])
-                } else {
-                    // Per-corner radii: generate uniformly then adjust (approximation until M2.5).
-                    shapes::rounded_rectangle(r, radii.iter().cloned().fold(0.0, f64::max))
-                };
-                p.transformed(*xf)
+            LiveShape::Rectangle { w, h, radii, kinds, xf } => {
+                shapes::rectangle_with_corners(Rect::new(0.0, 0.0, *w, *h), *radii, *kinds).transformed(*xf)
             }
             LiveShape::Ellipse { w, h, xf, .. } => shapes::ellipse(Rect::new(0.0, 0.0, *w, *h)).transformed(*xf),
             LiveShape::Polygon { radius, sides, xf } => shapes::polygon(Point::ZERO, *radius, *sides, 0.0).transformed(*xf),
@@ -144,7 +143,7 @@ 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 } => {
+            LiveShape::Rectangle { w, h, radii, xf, .. } => {
                 let m = 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;
@@ -185,6 +184,44 @@ impl LiveShape {
             _ => false,
         }
     }
+    /// The corner (radii order) of each anchor of a rectangle's path; empty for other shapes.
+    pub fn anchor_corners(&self) -> Vec<usize> {
+        match self {
+            LiveShape::Rectangle { w, h, radii, .. } => shapes::rectangle_anchor_corners(Rect::new(0.0, 0.0, *w, *h), *radii),
+            _ => vec![],
+        }
+    }
+    /// The corners of a rectangle that hold one of `anchors` (of its only subpath).
+    pub fn corners_of(&self, anchors: &BTreeSet<AnchorRef>) -> [bool; 4] {
+        let map = self.anchor_corners();
+        let mut out = [false; 4];
+        for k in anchors.iter().filter(|(si, _)| *si == 0).filter_map(|(_, ai)| map.get(*ai)) {
+            if let Some(c) = out.get_mut(*k) {
+                *c = true;
+            }
+        }
+        out
+    }
+    /// The corners Live Corners edit for a selection: those holding a selected anchor when the
+    /// shape is partly selected (Direct Selection), else all four.
+    pub fn picked_corners(&self, partial: Option<&BTreeSet<AnchorRef>>) -> [bool; 4] {
+        let picked = partial.map_or([true; 4], |a| self.corners_of(a));
+        if picked.contains(&true) { picked } else { [true; 4] }
+    }
+    /// The anchors of a rectangle's `corners` (to keep them selected as its path changes).
+    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).
+    pub fn corner_style(&self, corners: [bool; 4]) -> (Option<f64>, Option<CornerKind>) {
+        let LiveShape::Rectangle { radii, kinds, .. } = self 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))
+    }
     /// Rotation angle of the live shape in degrees (shown in the Properties panel).
     pub fn angle_deg(&self) -> f64 {
         match self {
@@ -197,6 +234,10 @@ impl LiveShape {
     }
 }
 
+fn all_round(kinds: &[CornerKind; 4]) -> bool {
+    kinds.iter().all(|k| *k == CornerKind::Round)
+}
+
 /// What a transform scales besides geometry, by its mean scale (the square root of its
 /// determinant). `Scaling::default()` (and `false`) scales nothing else; `true` scales stroke
 /// weights and dashes only. Transforms the user asks for take theirs from Scale Strokes & Effects
@@ -211,6 +252,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 {
@@ -485,6 +529,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 { .. })
     }
@@ -680,6 +730,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);
@@ -1200,14 +1253,44 @@ mod tests {
 
     #[test]
     fn rect_live_shape_roundtrip() {
-        let l = LiveShape::Rectangle { w: 10.0, h: 20.0, radii: [0.0; 4], xf: Affine::translate((5.0, 5.0)) };
+        let l = LiveShape::Rectangle { w: 10.0, h: 20.0, radii: [0.0; 4], kinds: Default::default(), xf: Affine::translate((5.0, 5.0)) };
         assert_eq!(l.to_path().bounds(), Some(Rect::new(5.0, 5.0, 15.0, 25.0)));
         assert_eq!(l.label(), "Rectangle");
     }
 
+    #[test]
+    fn rectangle_corners_map_to_their_anchors() {
+        let mut l = LiveShape::Rectangle { w: 100.0, h: 50.0, radii: [0.0, 10.0, 0.0, 0.0], kinds: Default::default(), xf: Affine::IDENTITY };
+        // Anchors: top-left, the top-right corner's two, bottom-right, bottom-left.
+        assert_eq!(l.anchor_corners(), [0, 1, 1, 2, 3]);
+        assert_eq!(l.to_path().anchor_count(), 5);
+        let set = |v: &[usize]| v.iter().map(|ai| (0, *ai)).collect::<BTreeSet<AnchorRef>>();
+        assert_eq!(l.corners_of(&set(&[2, 4])), [false, true, false, true]);
+        assert_eq!(l.corners_of(&set(&[9])), [false; 4], "out of range");
+        assert_eq!(l.corner_anchors([false, true, false, true]), set(&[1, 2, 4]));
+        // Partly selected: the corners of the selected anchors; wholly (or no anchor): all four.
+        assert_eq!(l.picked_corners(Some(&set(&[0]))), [true, false, false, false]);
+        assert_eq!(l.picked_corners(None), [true; 4]);
+        assert_eq!(l.picked_corners(Some(&set(&[]))), [true; 4]);
+        assert_eq!(l.corner_style([false, true, false, false]), (Some(10.0), Some(CornerKind::Round)));
+        assert_eq!(l.corner_style([true, true, false, false]), (None, Some(CornerKind::Round)));
+        assert_eq!(l.corner_style([true, false, true, true]), (Some(0.0), Some(CornerKind::Round)));
+        // Corner kinds save only when some corner isn't round, and older files read as round.
+        let json = serde_json::to_value(&l).unwrap();
+        assert!(json.get("kinds").is_none(), "{json}");
+        assert_eq!(serde_json::from_value::<LiveShape>(json).unwrap(), l);
+        if let LiveShape::Rectangle { kinds, .. } = &mut l {
+            kinds[1] = CornerKind::Chamfer;
+        }
+        let json = serde_json::to_value(&l).unwrap();
+        assert_eq!(json["kinds"], serde_json::json!(["round", "chamfer", "round", "round"]));
+        assert_eq!(serde_json::from_value::<LiveShape>(json).unwrap(), l);
+        assert!(LiveShape::Ellipse { w: 1.0, h: 1.0, pie: (0.0, 360.0), xf: Affine::IDENTITY }.anchor_corners().is_empty());
+    }
+
     /// A node holding a live rectangle (`w` × `h`, all radii `r`, placed by `xf`) and its path.
     fn live_rect(w: f64, h: f64, r: f64, xf: Affine) -> Node {
-        let live = LiveShape::Rectangle { w, h, radii: [r; 4], xf };
+        let live = LiveShape::Rectangle { w, h, radii: [r; 4], kinds: Default::default(), xf };
         let mut n = Node::path(NodeId(1), live.to_path(), Appearance::default_art());
         if let NodeKind::Path { live: slot, .. } = &mut n.kind {
             *slot = Some(live);
@@ -1216,7 +1299,7 @@ mod tests {
     }
 
     fn live_of(n: &Node) -> (f64, f64, [f64; 4], Affine) {
-        let NodeKind::Path { live: Some(LiveShape::Rectangle { w, h, radii, xf }), .. } = &n.kind else { panic!("not a live rectangle") };
+        let NodeKind::Path { live: Some(LiveShape::Rectangle { w, h, radii, xf, .. }), .. } = &n.kind else { panic!("not a live rectangle") };
         (*w, *h, *radii, *xf)
     }
 
@@ -1247,7 +1330,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() {

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 { vertical: true, pos: 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/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,
         }
     }

crates/engine/src/cmd/buildcmds.rs

@@ -16,10 +16,11 @@ 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, Point, Rect, Shape as _};
+use vectorcraft_geom::{FillRule, PathData, Point, Rect};
 use vectorcraft_pathops as po;
 use vectorcraft_tools::builder::{
-    self as b, EDGE_NAME, FACE_NAME, LIVE_PAINT_NAME, SOURCES_NAME, edge_near, face_at, is_live_paint, sample_polyline, shapes_for, sorted_roots,
+    self as b, BuilderMap, EDGE_NAME, FACE_NAME, LIVE_PAINT_NAME, SOURCES_NAME, Touched, edge_near, face_at, is_live_paint, sample_polyline,
+    sorted_roots,
 };
 use vectorcraft_trace as tr;
 
@@ -38,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), fill?: \"#rrggbb\" | {color|swatch|gradient|none} (default: the fill of the object under the first point)} → {ids, merged, regions}",
+            "{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}",
             has_selection_or_ids,
             sb_merge
         ),
@@ -47,7 +48,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Shape Builder Regions",
             [],
             None,
-            "{ids?} → {regions: [{bounds: [x0,y0,x1,y1], area, sources: [id…]}]} faces of the planar arrangement",
+            "{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",
             has_selection_or_ids,
             sb_regions
         ),
@@ -224,37 +225,51 @@ 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));
     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, count) = s.edit(label, |d, sel| {
-        let (shapes, leaves) = shapes_for(d, &roots);
+    let (ids, merged, regions, lines) = s.edit(label, |d, sel| {
+        let (map, leaves) = BuilderMap::new(d, &roots);
         let leaves: Vec<Node> = leaves.into_iter().cloned().collect();
-        if shapes.is_empty() {
+        if map.shapes.is_empty() {
             return Err(EngineError::Other("Shape Builder: select paths or compound paths".into()));
         }
-        let regs = po::regions(&shapes);
-        let shapes_r: Vec<(kurbo::BezPath, Rect)> = regs.iter().map(|r| (r.path.to_bezpath(), r.path.bounds().unwrap_or(Rect::ZERO))).collect();
         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: Vec<usize> = vec![];
+        let mut touched = Touched::default();
         for q in sample_polyline(&pts, step) {
-            if let Some(i) = shapes_r.iter().position(|(bp, bb)| bb.contains(q) && bp.winding(q) != 0)
-                && !touched.contains(&i)
-            {
-                touched.push(i);
-            }
+            touched.add(map.hit(q, line_tol));
         }
         if touched.is_empty() {
             return Err(EngineError::Other("Shape Builder: no region under the pointer".into()));
         }
-        let picked: Vec<&po::Region> = touched.iter().map(|&i| &regs[i]).collect();
-        let union = po::merge_regions(&picked);
-        let affected: Vec<bool> = (0..shapes.len()).map(|i| picked.iter().any(|r| r.sources.contains(&i))).collect();
-        let style_src = regs[touched[0]].top();
+        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
+        // area only lines enclose) of the front-most object and the current fill.
+        let covered = picked.iter().find_map(|r| r.top());
+        let style_src = covered.or(map.shapes.len().checked_sub(1));
+        let merged_fill = fill.or_else(|| covered.is_none().then_some(current_fill));
         let mut new_nodes: Vec<Node> = vec![];
         let mut merged_id = None;
-        for (i, (sh, leaf)) in shapes.iter().zip(&leaves).enumerate() {
-            if !affected[i] {
+        for (i, (sh, leaf)) in map.shapes.iter().zip(&leaves).enumerate() {
+            let pieces: Vec<usize> = map.lines.iter().enumerate().filter(|(_, (l, _))| l.key == i as u64).map(|(k, _)| k).collect();
+            if !pieces.is_empty() {
+                // An open path loses the pieces deleted and those between merged (or deleted) regions.
+                let keep: Vec<usize> =
+                    pieces.iter().copied().filter(|k| !touched.lines.contains(k) && !map.line_between(*k, &touched.regions)).collect();
+                if keep.len() == pieces.len() {
+                    new_nodes.push(d.reid(leaf));
+                } else {
+                    for k in keep {
+                        if let Some((l, _)) = map.lines.get(k) {
+                            new_nodes.push(shape_node(d, l.path.clone(), Some(leaf)));
+                        }
+                    }
+                }
+            } 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);
@@ -262,9 +277,9 @@ fn sb_merge(s: &mut Session, p: &Value) -> Result<Value> {
                     new_nodes.push(shape_node(d, rest, Some(leaf)));
                 }
             }
-            if !erase && Some(i) == style_src {
+            if !erase && !union.is_empty() && Some(i) == style_src {
                 let mut m = shape_node(d, union.clone(), Some(leaf));
-                if let Some(f) = &fill {
+                if let Some(f) = &merged_fill {
                     m.appearance.set_fill(f.clone());
                 }
                 merged_id = Some(m.id);
@@ -273,9 +288,9 @@ 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.len()))
+        Ok((new_ids, merged_id, touched.regions.len(), touched.lines.len()))
     })?;
-    Ok(json!({ "ids": ids_json(&ids), "merged": merged.map(|m| m.0), "regions": count }))
+    Ok(json!({ "ids": ids_json(&ids), "merged": merged.map(|m| m.0), "regions": regions, "lines": lines }))
 }
 
 /// Remove the roots and insert `nodes` where the front-most root was. Returns the new ids.
@@ -300,20 +315,22 @@ 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 (shapes, leaves) = shapes_for(d, &roots);
-    let regs = po::regions(&shapes);
-    let out: Vec<Value> = regs
+    let (map, leaves) = BuilderMap::new(d, &roots);
+    let id_of = |i: usize| leaves.get(i).map(|n| n.id.0);
+    let regions: Vec<Value> = map
+        .regions
         .iter()
-        .filter_map(|r| {
-            let bb = r.path.bounds()?;
-            Some(json!({
+        .map(|(r, _, bb)| {
+            json!({
                 "bounds": [bb.x0, bb.y0, bb.x1, bb.y1],
                 "area": po::area(&r.path, FillRule::NonZero),
-                "sources": r.sources.iter().map(|&i| leaves[i].id.0).collect::<Vec<_>>(),
-            }))
+                "sources": r.sources.iter().filter_map(|&i| id_of(i)).collect::<Vec<_>>(),
+            })
         })
         .collect();
-    Ok(json!({ "regions": out }))
+    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 }))
 }
 
 // ---------- 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::*;

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/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
         ),
@@ -166,7 +166,13 @@ fn rect_of(p: &Value, cmd: &str) -> Result<Rect> {
 fn rectangle(s: &mut Session, p: &Value) -> Result<Value> {
     let r = rect_of(p, "shape.rectangle")?;
     let radius = f64_or(p, "radius", 0.0).max(0.0);
-    let live = LiveShape::Rectangle { w: r.width(), h: r.height(), radii: [radius; 4], xf: Affine::translate(r.origin().to_vec2()) };
+    let live = LiveShape::Rectangle {
+        w: r.width(),
+        h: r.height(),
+        radii: [radius; 4],
+        kinds: Default::default(),
+        xf: Affine::translate(r.origin().to_vec2()),
+    };
     let label = if radius > 0.0 { "Rounded Rectangle" } else { "Rectangle" };
     add_art(s, label, path_kind(live.to_path(), Some(live)), None)
 }
@@ -408,8 +414,11 @@ 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)
 }
 

crates/engine/src/cmd/docmenu.rs

@@ -155,8 +155,34 @@ pub fn specs() -> Vec<CommandSpec> {
             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!(query "guide.list", "Guides", [], None, "{} → [{index, vertical, pos, selected}…] 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",
@@ -428,6 +454,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 }))
 }
 
@@ -458,28 +488,95 @@ fn guide_add(s: &mut Session, p: &Value) -> Result<Value> {
     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)| json!({ "index": i, "vertical": g.vertical, "pos": g.pos, "selected": st.selection.guides.contains(&i) });
+    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| {
+        let kept = |i: &usize| !gone.contains(i);
+        // The guides left selected keep their place among the rest.
+        let left: Vec<usize> = sel.guides.iter().filter(|i| kept(i)).map(|i| i - gone.iter().filter(|g| *g < i).count()).collect();
+        d.guides = std::mem::take(&mut d.guides).into_iter().enumerate().filter(|(i, _)| kept(i)).map(|(_, g)| g).collect();
+        sel.set_guides(left);
+        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 = Guide { vertical: g.vertical, pos: g.pos + if g.vertical { dx } else { 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/edit.rs

@@ -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",
@@ -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())
 }
 
@@ -206,6 +252,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)?,

crates/engine/src/cmd/menucmds.rs

@@ -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
         ),
@@ -147,7 +147,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 +288,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 {
@@ -658,7 +659,7 @@ pub(crate) fn detect_shape(path: &PathData) -> Option<LiveShape> {
         }
         let rot = Affine::rotate(e0.y.atan2(e0.x));
         let flip = if e0.cross(e1) < 0.0 { Affine::scale_non_uniform(1.0, -1.0) } else { Affine::IDENTITY };
-        return Some(LiveShape::Rectangle { w, h, radii: [0.0; 4], xf: Affine::translate(a[0].p.to_vec2()) * rot * flip });
+        return Some(LiveShape::Rectangle { w, h, radii: [0.0; 4], kinds: Default::default(), xf: Affine::translate(a[0].p.to_vec2()) * rot * flip });
     }
     let b = path.bounds()?;
     let c = b.center();
@@ -742,6 +743,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 +755,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 {

crates/engine/src/cmd/mod.rs

@@ -144,6 +144,11 @@ 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 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

@@ -6,6 +6,7 @@ use std::sync::Arc;
 use serde_json::{Value, json};
 use vectorcraft_color::{BlendMode, Paint};
 use vectorcraft_doc::{Appearance, Document, Knockout, Node, NodeId, NodeKind, OrientedBox, Scaling};
+use vectorcraft_geom::shapes::CornerKind;
 use vectorcraft_geom::{Affine, FillRule, Point, Rect, Vec2};
 
 use super::edit::{duplicate_in, selected_roots};
@@ -20,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
         ),
@@ -39,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
         ),
@@ -48,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
         ),
@@ -57,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
         ),
@@ -67,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(
@@ -180,7 +189,15 @@ pub fn specs() -> Vec<CommandSpec> {
             set_bounds
         ),
         cmd!("object.expandShape", "Expand Shape", ["Object", "Shape"], None, "{} convert live shapes to plain paths", has_selection, expand_shape),
-        cmd!("object.setLiveShape", "Live Shape Properties", [], None, "{id?, radius?: pt (all corners), sides?: n}", has_selection, set_live_shape),
+        cmd!(
+            "object.setLiveShape",
+            "Live Shape Properties",
+            [],
+            None,
+            "{id?, ids?, radius?: pt, kind?: \"round\"|\"invertedRound\"|\"chamfer\", corners?: [0..3…], sides?: n} (Live Corners: radius and kind set a rectangle's corners: `corners` (0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left), else the corners with a Direct-Selected anchor, else all four; sides: a polygon's)",
+            has_selection,
+            set_live_shape
+        ),
     ]
 }
 
@@ -199,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 {
@@ -259,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)
 }
@@ -962,15 +1006,50 @@ fn expand_shape(s: &mut Session, _: &Value) -> Result<Value> {
     ok()
 }
 
+/// The `corners` of `object.setLiveShape`: a mask of corner indices 0–3.
+fn corners_param(p: &Value) -> Result<Option<[bool; 4]>> {
+    let Some(v) = p.get("corners").filter(|v| !v.is_null()) else { return Ok(None) };
+    let err = || {
+        bad(
+            "object.setLiveShape",
+            format!("`corners` must list corner indices 0–3 (0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left), not {v}"),
+        )
+    };
+    let mut mask = [false; 4];
+    for k in v.as_array().ok_or_else(err)? {
+        let slot = k.as_u64().and_then(|k| mask.get_mut(usize::try_from(k).ok()?)).ok_or_else(err)?;
+        *slot = true;
+    }
+    Ok(Some(mask))
+}
+
 fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
     let ids = targets(s, p)?;
-    s.edit("Live Shape", |d, _| {
+    let corners = corners_param(p)?;
+    let kind = p
+        .get("kind")
+        .filter(|v| !v.is_null())
+        .map(|v| {
+            serde_json::from_value::<CornerKind>(v.clone())
+                .map_err(|_| bad("object.setLiveShape", format!("`kind` must be \"round\", \"invertedRound\" or \"chamfer\", not {v}")))
+        })
+        .transpose()?;
+    let radius = p.get("radius").and_then(Value::as_f64);
+    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 };
+            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)));
             match live {
-                vectorcraft_doc::LiveShape::Rectangle { radii, .. } => {
-                    if let Some(r) = p.get("radius").and_then(Value::as_f64) {
-                        *radii = [r.max(0.0); 4];
+                vectorcraft_doc::LiveShape::Rectangle { radii, kinds, .. } => {
+                    for ((_, r), k) in picked.iter().zip(radii.iter_mut()).zip(kinds.iter_mut()).filter(|((on, _), _)| **on) {
+                        if let Some(radius) = radius {
+                            *r = radius.max(0.0);
+                        }
+                        if let Some(kind) = kind {
+                            *k = kind;
+                        }
                     }
                 }
                 vectorcraft_doc::LiveShape::Polygon { sides, .. } => {
@@ -981,6 +1060,12 @@ fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
                 _ => {}
             }
             *path = live.to_path();
+            // Direct-Selected corners stay selected as they gain or lose anchors.
+            if let (Some(anchors), Some(selected)) = (partial, selected)
+                && live.anchor_corners() != layout
+            {
+                *anchors = live.corner_anchors(selected);
+            }
         }
         Ok(())
     })?;

crates/engine/src/cmd/panelcmds.rs

@@ -24,7 +24,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "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)}",
             has_doc,
             set_format
         ),
@@ -114,11 +114,13 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
         "mojikumi",
         "direction",
         "leadingModel",
+        "charAlign",
     ];
     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() {
@@ -179,6 +181,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") {

crates/engine/src/cmd/recovery.rs

@@ -487,6 +487,22 @@ pub fn release(s: &mut Session) {
     store.remove_area(&area);
 }
 
+/// Let go of this session's area but leave its copies, as a crash would, so the next app started
+/// offers them at once instead of waiting for the heartbeat to go stale: for an app that can't go
+/// on (the web page lost its graphics and has to be reloaded). Its documents keep no copies.
+pub fn leave(s: &mut Session) {
+    for st in &mut s.docs {
+        st.recovery = None;
+    }
+    let Some(Own { store, area, hold, beats }) = s.recovery.own.take() else { return };
+    if beats {
+        // Best effort: if the heartbeat stays, the copies are offered once it is stale.
+        let _ = store.remove(&format!("{area}/{BEAT}"));
+    }
+    // The lock or announcement goes too.
+    drop(hold);
+}
+
 /// A document's recovery copy: its entry and the document it holds.
 #[derive(Clone, Debug)]
 pub struct RecoveryCopy {

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())
     })?;
@@ -378,7 +468,11 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
         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 +488,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> {

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;
             }
@@ -433,6 +438,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;
@@ -388,36 +388,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
         ),
@@ -374,7 +374,7 @@ fn artboard_move(s: &mut Session, p: &Value) -> Result<Value> {
     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 = if move_art { st.doc.art_on_artboard(rect, s.prefs.move_locked_with_artboard) } else { vec![] };
     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, _| {

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

@@ -293,7 +293,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).
@@ -1305,6 +1307,8 @@ mod tests_liquify;
 #[cfg(test)]
 mod tests_live;
 #[cfg(test)]
+mod tests_livecorners;
+#[cfg(test)]
 mod tests_maskview;
 #[cfg(test)]
 mod tests_menucmds;

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

@@ -172,6 +172,154 @@ fn shape_builder_tool_drives_the_command() {
     assert_eq!(layer_children(&s), 1);
 }
 
+/// A red 100 × 100 square crossed by a stroke-only vertical line at x = 50, both selected.
+fn square_and_line(s: &mut Session) -> (NodeId, NodeId) {
+    let a = rect(s, 0.0, 0.0, 100.0, 100.0);
+    set_fill(s, a, Color::rgb(1.0, 0.0, 0.0));
+    let l = line(s, (50.0, -20.0), (50.0, 120.0));
+    s.execute("select.set", &json!({"ids": [a.0, l.0]})).unwrap();
+    (a, l)
+}
+
+/// The open paths among `ids`, as (anchors, bounds).
+fn open_paths(s: &Session, ids: &[NodeId]) -> Vec<(usize, Rect)> {
+    ids.iter()
+        .map(|i| node(s, *i))
+        .filter(|n| !outline(n).0.is_closed())
+        .map(|n| (outline(&n).0.anchor_count(), n.geometric_bounds().unwrap()))
+        .collect()
+}
+
+#[test]
+fn shape_builder_line_splits_a_shape_into_regions() {
+    let mut s = session();
+    let (a, l) = square_and_line(&mut s);
+    let r = s.execute("shapeBuilder.regions", &json!({})).unwrap();
+    let regs = r["regions"].as_array().unwrap();
+    assert_eq!(regs.len(), 2, "{r}");
+    for x in regs {
+        assert!((x["area"].as_f64().unwrap() - 5000.0).abs() < 1e-6);
+        assert_eq!(x["sources"], json!([a.0]));
+    }
+    let lines = r["lines"].as_array().unwrap();
+    assert_eq!(lines.len(), 3, "the line cut at both sides of the square");
+    assert!(lines.iter().all(|x| x["source"] == l.0));
+}
+
+#[test]
+fn shape_builder_click_on_a_side_of_a_line_splits_the_shape() {
+    let mut s = session();
+    square_and_line(&mut s);
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[25, 50]]})).unwrap();
+    assert_eq!(r["regions"], 1);
+    let out = ids(&r);
+    let merged = NodeId(r["merged"].as_u64().unwrap());
+    assert_eq!(node(&s, merged).geometric_bounds().unwrap(), Rect::new(0.0, 0.0, 50.0, 100.0));
+    assert_eq!(node(&s, merged).appearance.fill_paint(), Paint::solid(Color::rgb(1.0, 0.0, 0.0)));
+    let closed: Vec<f64> = out.iter().filter(|i| outline(&node(&s, **i)).0.is_closed()).map(|i| area(&s, *i)).collect();
+    assert_eq!(closed.len(), 2, "both halves");
+    assert!(closed.iter().all(|a| (a - 5000.0).abs() < 1.0), "{closed:?}");
+    // The line only bounds the region: it stays whole.
+    assert_eq!(open_paths(&s, &out), vec![(2, Rect::new(50.0, -20.0, 50.0, 120.0))]);
+}
+
+#[test]
+fn shape_builder_merge_across_a_line_removes_the_piece_between() {
+    let mut s = session();
+    square_and_line(&mut s);
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[25, 50], [75, 50]]})).unwrap();
+    assert_eq!(r["regions"], 2);
+    let out = ids(&r);
+    let merged = NodeId(r["merged"].as_u64().unwrap());
+    assert!((area(&s, merged) - 10000.0).abs() < 1.0);
+    assert_eq!(out.len(), 3, "merged square + the line's two loose ends");
+    let mut ends = open_paths(&s, &out);
+    ends.sort_by(|a, b| a.1.y0.total_cmp(&b.1.y0));
+    assert_eq!(ends, vec![(2, Rect::new(50.0, -20.0, 50.0, 0.0)), (2, Rect::new(50.0, 100.0, 50.0, 120.0))]);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(layer_children(&s), 2);
+}
+
+#[test]
+fn shape_builder_alt_deletes_a_region_or_a_line_piece() {
+    let mut s = session();
+    square_and_line(&mut s);
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[75, 50]], "erase": true})).unwrap();
+    assert!(r["merged"].is_null());
+    let out = ids(&r);
+    let left: Vec<NodeId> = out.iter().copied().filter(|i| outline(&node(&s, *i)).0.is_closed()).collect();
+    assert_eq!(left.len(), 1);
+    assert_eq!(node(&s, left[0]).geometric_bounds().unwrap(), Rect::new(0.0, 0.0, 50.0, 100.0));
+    assert_eq!(open_paths(&s, &out).len(), 1, "the line stays whole");
+
+    // Alt on the line inside the square deletes that piece only.
+    let mut s = session();
+    square_and_line(&mut s);
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[51, 50]], "erase": true, "tolerance": 2})).unwrap();
+    assert_eq!((r["regions"].as_u64(), r["lines"].as_u64()), (Some(0), Some(1)));
+    let out = ids(&r);
+    assert_eq!(out.len(), 3);
+    let sq: Vec<NodeId> = out.iter().copied().filter(|i| outline(&node(&s, *i)).0.is_closed()).collect();
+    assert_eq!(sq.len(), 1);
+    assert!((area(&s, sq[0]) - 10000.0).abs() < 1.0, "the square is untouched");
+    assert_eq!(open_paths(&s, &out).len(), 2);
+}
+
+#[test]
+fn shape_builder_fills_an_area_lines_enclose() {
+    let mut s = session();
+    let l1 = line(&mut s, (0.0, 0.0), (100.0, 100.0));
+    let l2 = line(&mut s, (100.0, 0.0), (0.0, 100.0));
+    let l3 = line(&mut s, (-10.0, 80.0), (110.0, 80.0));
+    s.execute("select.set", &json!({"ids": [l1.0, l2.0, l3.0]})).unwrap();
+    let r = s.execute("shapeBuilder.regions", &json!({})).unwrap();
+    assert_eq!(r["regions"].as_array().unwrap().len(), 1);
+    assert_eq!(r["regions"][0]["sources"], json!([]));
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[50, 70]]})).unwrap();
+    let merged = NodeId(r["merged"].as_u64().unwrap());
+    assert!((area(&s, merged) - 900.0).abs() < 1e-6, "{}", area(&s, merged));
+    assert_eq!(node(&s, merged).appearance.fill_paint(), s.paint.fill, "the current fill");
+    assert!(!node(&s, merged).appearance.stroke_paint().is_none(), "the lines' stroke");
+    assert_eq!(ids(&r).len(), 4, "the triangle + the three lines, which only bound it");
+}
+
+#[test]
+fn shape_builder_closes_filled_open_paths() {
+    let mut s = session();
+    let r = s.execute("path.create", &json!({"anchors": [{"x": 0, "y": 0}, {"x": 100, "y": 0}, {"x": 100, "y": 100}]})).unwrap();
+    let p = NodeId(r["id"].as_u64().unwrap());
+    set_fill(&mut s, p, Color::rgb(0.0, 1.0, 0.0));
+    s.execute("select.set", &json!({"ids": [p.0]})).unwrap();
+    let r = s.execute("shapeBuilder.regions", &json!({})).unwrap();
+    assert_eq!(r["regions"].as_array().unwrap().len(), 1, "the fill's area, closed by an invisible edge");
+    assert!((r["regions"][0]["area"].as_f64().unwrap() - 5000.0).abs() < 1e-6);
+    assert_eq!(r["lines"], json!([]));
+    // Unfilled, it is only an edge.
+    s.edit("t", |d, _| {
+        d.node_mut(p).unwrap().appearance.set_fill(Paint::None);
+        Ok(())
+    })
+    .unwrap();
+    let r = s.execute("shapeBuilder.regions", &json!({})).unwrap();
+    assert_eq!(r["regions"], json!([]));
+    assert_eq!(r["lines"].as_array().unwrap().len(), 1);
+}
+
+#[test]
+fn shape_builder_tool_alt_deletes_line_pieces() {
+    let mut s = session();
+    square_and_line(&mut s);
+    let v = ViewInfo::default();
+    s.select_tool("shapeBuilder", v).unwrap();
+    let alt = Mods { alt: true, ..Default::default() };
+    s.pointer(&PointerEvent::new(PointerKind::Move, 51.0, 50.0).with_mods(alt), v).unwrap();
+    assert_eq!(s.overlays(v).len(), 1, "the line piece is highlighted");
+    s.pointer(&PointerEvent::new(PointerKind::Down, 51.0, 50.0).with_mods(alt), v).unwrap();
+    s.pointer(&PointerEvent::new(PointerKind::Up, 51.0, 50.0).with_mods(alt), v).unwrap();
+    assert_eq!(s.journal.last().unwrap().0, "shapeBuilder.merge");
+    assert_eq!(layer_children(&s), 3, "square + the line's two loose ends");
+}
+
 // ---------- 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_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_livecorners.rs

@@ -0,0 +1,107 @@
+//! Live Corners on live rectangles: `object.setLiveShape` rounds the given corners, the
+//! Direct-Selected ones or all four, sets corner kinds, and keeps selected corners selected.
+
+use std::collections::BTreeSet;
+
+use serde_json::{Value, json};
+use vectorcraft_doc::{AnchorRef, LiveShape, NodeKind};
+use vectorcraft_geom::shapes::CornerKind;
+
+use super::*;
+
+/// A 100 × 60 pt live rectangle at (10, 10), selected.
+fn session() -> (Session, NodeId) {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+    let id = s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 100, "height": 60})).unwrap()["id"].as_u64().unwrap();
+    (s, NodeId(id))
+}
+
+fn run(s: &mut Session, p: Value) {
+    s.execute("object.setLiveShape", &p).unwrap_or_else(|e| panic!("{p}: {e}"));
+}
+
+fn corners(s: &Session, id: NodeId) -> ([f64; 4], [CornerKind; 4], usize) {
+    let n = s.doc().unwrap().doc.node(id).unwrap();
+    let NodeKind::Path { live: Some(LiveShape::Rectangle { radii, kinds, .. }), path, .. } = &n.kind else { panic!("not a live rectangle") };
+    (*radii, *kinds, path.anchor_count())
+}
+
+fn selected_anchors(s: &Session, id: NodeId) -> Option<BTreeSet<AnchorRef>> {
+    s.doc().unwrap().selection.partial(id).cloned()
+}
+
+fn anchors(v: &[usize]) -> BTreeSet<AnchorRef> {
+    v.iter().map(|ai| (0, *ai)).collect()
+}
+
+#[test]
+fn a_whole_rectangle_rounds_all_corners_and_given_corners_alone() {
+    let (mut s, id) = session();
+    run(&mut s, json!({"radius": 8}));
+    assert_eq!(corners(&s, id), ([8.0; 4], [CornerKind::Round; 4], 8));
+    run(&mut s, json!({"id": id.0, "radius": 0}));
+    // One corner: only it rounds, and the path gains one anchor (one undo step).
+    let undo = s.doc().unwrap().history.undo.len();
+    run(&mut s, json!({"ids": [id.0], "corners": [1], "radius": 12}));
+    assert_eq!(corners(&s, id), ([0.0, 12.0, 0.0, 0.0], [CornerKind::Round; 4], 5));
+    assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
+    let b = s.doc().unwrap().doc.node(id).unwrap().geometric_bounds().unwrap();
+    assert!((b.x1 - 110.0).abs() < 1e-9 && (b.y0 - 10.0).abs() < 1e-9, "the shape keeps its bounds: {b:?}");
+    // Kinds alone, then both; the others stay as they were.
+    run(&mut s, json!({"corners": [1, 3], "kind": "chamfer"}));
+    run(&mut s, json!({"corners": [3], "radius": 5, "kind": "invertedRound"}));
+    assert_eq!(corners(&s, id), ([0.0, 12.0, 0.0, 5.0], [CornerKind::Round, CornerKind::Chamfer, CornerKind::Round, CornerKind::InvertedRound], 6));
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(corners(&s, id).1[3], CornerKind::Chamfer);
+}
+
+#[test]
+fn bad_corners_and_kinds_are_errors() {
+    let (mut s, id) = session();
+    for p in
+        [json!({"corners": [4], "radius": 5}), json!({"corners": ["a"]}), json!({"corners": 1}), json!({"corners": [-1]}), json!({"kind": "wavy"})]
+    {
+        assert!(s.execute("object.setLiveShape", &p).is_err(), "{p}");
+    }
+    assert_eq!(corners(&s, id), ([0.0; 4], [CornerKind::Round; 4], 4), "nothing changed");
+}
+
+#[test]
+fn direct_selected_corners_round_alone_and_stay_selected() {
+    let (mut s, id) = session();
+    // Direct Selection picks the top-right and bottom-left corners.
+    s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 1], [0, 3]], "mode": "set"})).unwrap();
+    run(&mut s, json!({"radius": 10}));
+    assert_eq!(corners(&s, id), ([0.0, 10.0, 0.0, 10.0], [CornerKind::Round; 4], 6));
+    // Anchors: top-left, top-right's two, bottom-right, bottom-left's two.
+    assert_eq!(selected_anchors(&s, id), Some(anchors(&[1, 2, 4, 5])));
+    // The same corners again (a field in the Properties panel), now with their two anchors each.
+    run(&mut s, json!({"kind": "chamfer"}));
+    assert_eq!(corners(&s, id).1, [CornerKind::Round, CornerKind::Chamfer, CornerKind::Round, CornerKind::Chamfer]);
+    run(&mut s, json!({"radius": 0}));
+    assert_eq!(corners(&s, id).2, 4);
+    assert_eq!(selected_anchors(&s, id), Some(anchors(&[1, 3])));
+    // Undo brings back the selection with the shape.
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(selected_anchors(&s, id), Some(anchors(&[1, 2, 4, 5])));
+    // Explicit corners win over the selection, which follows its own corners.
+    run(&mut s, json!({"corners": [0], "radius": 4}));
+    assert_eq!(corners(&s, id).0, [4.0, 10.0, 0.0, 10.0]);
+    assert_eq!(selected_anchors(&s, id), Some(anchors(&[1, 2, 4, 5])), "the top-left corner comes first and last");
+}
+
+#[test]
+fn a_drag_previews_one_corner_and_commits_one_step() {
+    let (mut s, id) = session();
+    s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 2]], "mode": "set"})).unwrap();
+    let undo = s.doc().unwrap().history.undo.len();
+    s.begin_interaction("Corner Radius").unwrap();
+    for r in [5.0, 9.0, 14.0] {
+        s.preview("object.setLiveShape", &json!({"id": id.0, "radius": r, "corners": [2]})).unwrap();
+    }
+    s.commit_interaction().unwrap();
+    assert_eq!(corners(&s, id), ([0.0, 0.0, 14.0, 0.0], [CornerKind::Round; 4], 5));
+    assert_eq!(selected_anchors(&s, id), Some(anchors(&[2, 3])));
+    assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
+}

crates/engine/src/tests_menucmds.rs

@@ -740,6 +740,99 @@ 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(..))));
+}
+
+/// #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]

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,336 @@ 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");
+}
+
+/// 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_recovery.rs

@@ -269,6 +269,23 @@ fn announced_areas_stay_held_while_their_app_is_paused() {
     assert!(offered(&mut c).is_empty());
 }
 
+#[test]
+fn an_app_that_leaves_has_its_copies_offered_at_once() {
+    for store in [MemoryStore::without_locks(), MemoryStore::announcing(), MemoryStore::default()] {
+        let store = Arc::new(store);
+        let mut a = session_in(&store);
+        a.execute("file.recovery.save", &json!({})).unwrap();
+        let mut b = relaunch(&store);
+        assert!(offered(&mut b).is_empty(), "A still runs");
+        // A can't go on (its page lost its graphics): its copies stay, for the next app at once.
+        cmd::recovery::leave(&mut a);
+        assert!(a.doc().unwrap().recovery.is_none());
+        assert_eq!(copies(store.as_ref()), ["Untitled-1-1"]);
+        assert_eq!(offered(&mut b), ["Untitled-1"]);
+        assert_eq!(restored(b.execute("file.recovery.restore", &json!({})).unwrap()), 1);
+    }
+}
+
 #[test]
 fn folder_areas_are_locked_by_running_apps() {
     let dir = std::env::temp_dir().join(format!("vc-recovery-locks-{}", std::process::id()));

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/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,
@@ -134,6 +137,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 +156,18 @@ 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,
             screen: view.screen,
             plane_widget: self.prefs.perspective_widget.show.then_some(self.prefs.perspective_widget.position),
         };
@@ -265,8 +281,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/geom/src/shapes.rs

@@ -3,6 +3,7 @@
 use std::f64::consts::{PI, TAU};
 
 use kurbo::{Point, Rect, Vec2};
+use serde::{Deserialize, Serialize};
 
 use crate::path::{Anchor, AnchorKind, PathData, SubPath};
 
@@ -17,25 +18,85 @@ pub fn rectangle(r: Rect) -> PathData {
 
 /// Rounded rectangle (8 anchors). The radius is clamped to half the shorter side.
 pub fn rounded_rectangle(r: Rect, radius: f64) -> PathData {
-    let r = r.abs();
-    let rad = radius.max(0.0).min(r.width() / 2.0).min(r.height() / 2.0);
-    if rad <= 1e-9 {
-        return rectangle(r);
+    rectangle_with_corners(r, [radius; 4], [CornerKind::Round; 4])
+}
+
+/// How a rectangle's corner is cut (Live Corners).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum CornerKind {
+    /// A quarter circle, bulging outwards.
+    #[default]
+    Round,
+    /// A quarter circle cut into the shape, centred on the corner.
+    InvertedRound,
+    /// A straight bevel.
+    Chamfer,
+}
+
+impl CornerKind {
+    pub const ALL: [CornerKind; 3] = [CornerKind::Round, CornerKind::InvertedRound, CornerKind::Chamfer];
+
+    /// The kind after this one (Alt-clicking a corner widget cycles through them).
+    pub fn next(self) -> Self {
+        match self {
+            CornerKind::Round => CornerKind::InvertedRound,
+            CornerKind::InvertedRound => CornerKind::Chamfer,
+            CornerKind::Chamfer => CornerKind::Round,
+        }
     }
-    let k = rad * KAPPA;
-    let (x0, y0, x1, y1) = (r.x0, r.y0, r.x1, r.y1);
-    let a = |p: (f64, f64), hin: (f64, f64), hout: (f64, f64)| Anchor { p: p.into(), h_in: hin.into(), h_out: hout.into(), kind: AnchorKind::Corner };
-    let anchors = vec![
-        a((x0 + rad, y0), (x0 + rad - k, y0), (x0 + rad, y0)),
-        a((x1 - rad, y0), (x1 - rad, y0), (x1 - rad + k, y0)),
-        a((x1, y0 + rad), (x1, y0 + rad - k), (x1, y0 + rad)),
-        a((x1, y1 - rad), (x1, y1 - rad), (x1, y1 - rad + k)),
-        a((x1 - rad, y1), (x1 - rad + k, y1), (x1 - rad, y1)),
-        a((x0 + rad, y1), (x0 + rad, y1), (x0 + rad - k, y1)),
-        a((x0, y1 - rad), (x0, y1 - rad + k), (x0, y1 - rad)),
-        a((x0, y0 + rad), (x0, y0 + rad), (x0, y0 + rad - k)),
+}
+
+/// 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
+/// top-left corner, its anchor on the top side first.
+pub fn rectangle_with_corners(r: Rect, radii: [f64; 4], kinds: [CornerKind; 4]) -> PathData {
+    PathData::single(SubPath::new(corner_anchors(r, radii, kinds).into_iter().map(|(_, a)| a).collect(), true))
+}
+
+/// The corner (index into `radii`) of each anchor of [`rectangle_with_corners`].
+pub fn rectangle_anchor_corners(r: Rect, radii: [f64; 4]) -> Vec<usize> {
+    corner_anchors(r, radii, [CornerKind::Round; 4]).into_iter().map(|(k, _)| k).collect()
+}
+
+/// 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)),
+        (Point::new(r.x1, r.y0), Vec2::new(1.0, 0.0), Vec2::new(0.0, 1.0)),
+        (Point::new(r.x1, r.y1), Vec2::new(0.0, 1.0), Vec2::new(-1.0, 0.0)),
+        (Point::new(r.x0, r.y1), Vec2::new(-1.0, 0.0), Vec2::new(0.0, -1.0)),
     ];
-    PathData::single(SubPath::new(anchors, true))
+    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);
+        if rad <= 1e-9 {
+            out.push((k, Anchor::corner(c)));
+            continue;
+        }
+        // The cut runs from `start` on the arriving side to `end` on the leaving one.
+        let (start, end, h) = (c - din * rad, c + dout * rad, rad * KAPPA);
+        let (h_out, h_in) = match kind {
+            CornerKind::Round => (start + din * h, end - dout * h),
+            CornerKind::InvertedRound => (start + dout * h, end - din * h),
+            CornerKind::Chamfer => (start, end),
+        };
+        let start = Anchor { p: start, h_in: start, h_out, kind: AnchorKind::Corner };
+        let end = Anchor { p: end, h_in, h_out: end, kind: AnchorKind::Corner };
+        if k == 0 {
+            top_left_start = Some(start);
+        } else {
+            out.push((k, start));
+        }
+        out.push((k, end));
+    }
+    out.extend(top_left_start.map(|a| (0, a)));
+    out
 }
 
 /// Ellipse inscribed in `r` with 4 smooth anchors (left, top, right, bottom).
@@ -203,6 +264,54 @@ mod tests {
         assert_eq!(rounded_rectangle(Rect::new(0.0, 0.0, 20.0, 10.0), 0.0).anchor_count(), 4);
     }
 
+    #[test]
+    fn uniform_corners_keep_the_rounded_rectangle_layout() {
+        // The 8 anchors a rounded rectangle always had, from the top side's first one.
+        let (r, rad) = (Rect::new(10.0, 20.0, 110.0, 70.0), 7.5);
+        let (x0, y0, x1, y1, k) = (10.0, 20.0, 110.0, 70.0, rad * KAPPA);
+        let a =
+            |p: (f64, f64), hin: (f64, f64), hout: (f64, f64)| Anchor { p: p.into(), h_in: hin.into(), h_out: hout.into(), kind: AnchorKind::Corner };
+        let want = vec![
+            a((x0 + rad, y0), (x0 + rad - k, y0), (x0 + rad, y0)),
+            a((x1 - rad, y0), (x1 - rad, y0), (x1 - rad + k, y0)),
+            a((x1, y0 + rad), (x1, y0 + rad - k), (x1, y0 + rad)),
+            a((x1, y1 - rad), (x1, y1 - rad), (x1, y1 - rad + k)),
+            a((x1 - rad, y1), (x1 - rad + k, y1), (x1 - rad, y1)),
+            a((x0 + rad, y1), (x0 + rad, y1), (x0 + rad - k, y1)),
+            a((x0, y1 - rad), (x0, y1 - rad + k), (x0, y1 - rad)),
+            a((x0, y0 + rad), (x0, y0 + rad), (x0, y0 + rad - k)),
+        ];
+        assert_eq!(rounded_rectangle(r, rad).subpaths[0].anchors, want);
+        assert_eq!(rectangle_anchor_corners(r, [rad; 4]), [0, 1, 1, 2, 2, 3, 3, 0]);
+        assert_eq!(rounded_rectangle(r, 0.0), rectangle(r));
+    }
+
+    #[test]
+    fn each_corner_takes_its_own_radius_and_kind() {
+        let r = Rect::new(0.0, 0.0, 100.0, 60.0);
+        // Only the top-right corner rounded: 5 anchors, the corner's two on its sides.
+        let radii = [0.0, 10.0, 0.0, 0.0];
+        let p = rectangle_with_corners(r, radii, [CornerKind::Round; 4]);
+        let pts: Vec<Point> = p.subpaths[0].anchors.iter().map(|a| a.p).collect();
+        assert_eq!(pts, [Point::new(0.0, 0.0), Point::new(90.0, 0.0), Point::new(100.0, 10.0), Point::new(100.0, 60.0), Point::new(0.0, 60.0)]);
+        assert_eq!(rectangle_anchor_corners(r, radii), [0, 1, 1, 2, 3]);
+        let quarter = PI * 25.0;
+        assert!((p.subpaths[0].area() - (6000.0 - 100.0 + quarter)).abs() < 0.1, "a quarter circle off one corner");
+        // The top-left corner rounded: its top-side anchor first, its left-side one last.
+        assert_eq!(rectangle_anchor_corners(r, [10.0, 0.0, 0.0, 200.0]), [0, 1, 2, 3, 3, 0]);
+        // Inverted round cuts a quarter circle out; a chamfer cuts a triangle.
+        let inverted = rectangle_with_corners(r, radii, [CornerKind::InvertedRound; 4]);
+        assert!((inverted.subpaths[0].area() - (6000.0 - quarter)).abs() < 0.1);
+        let chamfer = rectangle_with_corners(r, radii, [CornerKind::Chamfer; 4]);
+        assert!((chamfer.subpaths[0].area() - (6000.0 - 50.0)).abs() < 1e-9);
+        assert!(chamfer.subpaths[0].anchors.iter().all(|a| !a.has_in() && !a.has_out()), "straight");
+        // Radii clamp to half the shorter side; negative and NaN radii are none.
+        let p = rectangle_with_corners(r, [500.0, -5.0, f64::NAN, 0.0], [CornerKind::Round; 4]);
+        assert_eq!(p.subpaths[0].anchors[0].p, Point::new(30.0, 0.0));
+        assert_eq!(p.anchor_count(), 5);
+        assert_eq!(CornerKind::ALL.map(CornerKind::next), [CornerKind::InvertedRound, CornerKind::Chamfer, CornerKind::Round]);
+    }
+
     #[test]
     fn polygon_first_vertex_up() {
         let p = polygon(Point::new(0.0, 0.0), 10.0, 6, 0.0);

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/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(
@@ -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!({}))?)

crates/pathops/README.md

@@ -35,6 +35,7 @@ pub struct Region { pub path: PathData, pub sources: Vec<usize> }
 pub fn regions(shapes: &[Shape]) -> Vec<Region>;            // all faces of the arrangement
 pub fn region_at(shapes: &[Shape], p: Point) -> Option<Region>;
 pub fn merge_regions(regions: &[&Region]) -> PathData;      // Shape Builder merge = union
+pub fn shape_builder(shapes: &[Shape]) -> (Vec<Region>, Vec<Shape>); // (regions, open-path pieces)
 ```
 
 Each result takes its key as follows:
@@ -58,6 +59,8 @@ pub fn interior_point(path: &PathData) -> Option<Point>;
 
 Unlike `regions`, which splits the filled areas of closed shapes, `live_paint` treats every path as an edge, open paths included. Three crossing lines enclose a triangle, a line across a rectangle splits it in two, and an area enclosed by paths becomes a face even when nothing fills it. Each face lists the inputs whose fill covers it; the list is empty for an area that is only enclosed by paths. Each edge is a piece of a path, split wherever another path meets it, and keeps the key of the front-most input it lies on.
 
+`shape_builder` gives the Shape Builder's regions. With closed paths only, they are the `regions`. Once an open path is among them, they are the `live_paint` faces, so a stroke-only line across a shape splits it and lines can enclose a region of their own. The second list holds the pieces of each path that has no closed subpath, keyed by its index, so the Shape Builder can delete them one by one. The caller closes any open path whose fill should count. Inputs with more than `SHAPE_BUILDER_MAX_SEGMENTS` segments fall back to the filled areas.
+
 ## Offset / stroke
 
 ```rust

crates/pathops/src/lib.rs

@@ -20,7 +20,7 @@ pub use edit::{
 };
 pub use offset::{Cap, Join, offset_path, outline_stroke, stroke_region};
 pub use pathfinder::{PathfinderOp, Region, Shape, merge_regions, pathfinder, region_at, regions};
-pub use planar::{interior_point, live_paint};
+pub use planar::{SHAPE_BUILDER_MAX_SEGMENTS, interior_point, live_paint, shape_builder};
 
 /// Errors from fallible operations.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]

crates/pathops/src/planar.rs

@@ -288,6 +288,32 @@ pub fn live_paint(shapes: &[Shape]) -> (Vec<Region>, Vec<Shape>) {
     build(shapes).unwrap_or_default()
 }
 
+/// Most segments the Shape Builder sweeps with open paths as edges: the planar map costs far more
+/// than the filled areas' arrangement, so past this only the filled areas count.
+pub const SHAPE_BUILDER_MAX_SEGMENTS: usize = 4096;
+
+/// Shape Builder regions of `shapes` (back → front), and the pieces of their open paths.
+///
+/// Closed paths bound regions with their filled areas, as in [`regions`](crate::regions). Open
+/// paths (the caller closes the ones whose fill should count) are cutting edges: a line across a
+/// shape splits it, lines around an area enclose a region nothing fills (empty `sources`), and each
+/// path with no closed subpath comes back cut wherever another path meets it, as pieces keyed by
+/// its index in `shapes`. With no open path, more than [`SHAPE_BUILDER_MAX_SEGMENTS`] segments or
+/// a map that can't be built, only the filled areas count and there are no pieces.
+pub fn shape_builder(shapes: &[Shape]) -> (Vec<Region>, Vec<Shape>) {
+    let has_open = shapes.iter().flat_map(|s| &s.path.subpaths).any(|sp| !sp.closed && sp.anchors.len() >= 2);
+    let segments: usize = shapes.iter().flat_map(|s| &s.path.subpaths).map(|sp| sp.segment_count()).sum();
+    if has_open && segments <= SHAPE_BUILDER_MAX_SEGMENTS {
+        let keyed: Vec<Shape> = shapes.iter().enumerate().map(|(i, s)| Shape::new(s.path.clone(), s.rule, i as u64)).collect();
+        let (faces, edges) = live_paint(&keyed);
+        if !faces.is_empty() || !edges.is_empty() {
+            let is_line = |i: u64| shapes.get(i as usize).is_some_and(|s| !s.path.subpaths.iter().any(|sp| sp.closed));
+            return (faces, edges.into_iter().filter(|e| is_line(e.key)).collect());
+        }
+    }
+    (crate::regions(shapes), Vec::new())
+}
+
 fn build(shapes: &[Shape]) -> Option<(Vec<Region>, Vec<Shape>)> {
     let mut inputs: Vec<(BezPath, usize)> = Vec::new();
     for (i, s) in shapes.iter().enumerate() {
@@ -736,6 +762,69 @@ mod tests {
         assert_eq!(edges.len(), 1);
     }
 
+    #[test]
+    fn shape_builder_lines_cut_regions() {
+        // A line across a rectangle: two regions, the line in three pieces keyed by its index.
+        let s = [rect(0.0, 0.0, 100.0, 50.0, 7), line((40.0, -20.0), (60.0, 70.0), 8)];
+        let (regions, lines) = shape_builder(&s);
+        assert_eq!(regions.len(), 2);
+        assert!(regions.iter().all(|r| r.sources == [0]));
+        assert_eq!(lines.len(), 3);
+        assert!(lines.iter().all(|l| l.key == 1 && !l.path.is_closed()));
+        // Lines alone enclose a region nothing fills.
+        let s = [line((0.0, 0.0), (100.0, 100.0), 0), line((100.0, 0.0), (0.0, 100.0), 0), line((-10.0, 80.0), (110.0, 80.0), 0)];
+        let (regions, lines) = shape_builder(&s);
+        assert_eq!(regions.len(), 1);
+        assert!(regions[0].sources.is_empty() && regions[0].top().is_none());
+        assert_eq!(lines.len(), 9);
+    }
+
+    #[test]
+    fn shape_builder_closed_only_or_degenerate_is_the_filled_arrangement() {
+        let s = [rect(0.0, 0.0, 100.0, 100.0, 0), rect(50.0, 0.0, 150.0, 100.0, 1)];
+        assert_eq!(shape_builder(&s), (crate::regions(&s), vec![]));
+        // A broken line can't be swept: what the filled areas give (nothing here, without a panic).
+        let s = [rect(0.0, 0.0, 100.0, 100.0, 0), line((0.0, 0.0), (f64::NAN, 1.0), 1)];
+        assert_eq!(shape_builder(&s), (crate::regions(&s), vec![]));
+        // Zero-length and doubled-back lines don't break it either.
+        let s = [
+            rect(0.0, 0.0, 100.0, 100.0, 0),
+            line((50.0, 50.0), (50.0, 50.0), 1),
+            line((0.0, 0.0), (100.0, 0.0), 2),
+            line((50.0, 0.0), (50.0, 100.0), 3),
+        ];
+        let (regions, _) = shape_builder(&s);
+        assert_eq!(regions.len(), 2);
+        assert!((regions.iter().map(area).sum::<f64>() - 10000.0).abs() < 1e-6);
+    }
+
+    #[test]
+    fn shape_builder_stays_quick_up_to_its_cap() {
+        // A wavy ring of nearly the most segments the map takes, crossed by a few lines.
+        let n = SHAPE_BUILDER_MAX_SEGMENTS - 8;
+        let ring: Vec<Point> = (0..n)
+            .map(|k| {
+                let t = k as f64 / n as f64 * std::f64::consts::TAU;
+                let r = 100.0 + 5.0 * (t * 200.0).sin();
+                Point::new(r * t.cos(), r * t.sin())
+            })
+            .collect();
+        let mut s = vec![Shape::new(PathData::single(SubPath::polyline(&ring, true)), FillRule::NonZero, 0)];
+        for k in 0..4 {
+            let y = -60.0 + 40.0 * f64::from(k);
+            s.push(line((-150.0, y), (150.0, y + 7.0), 1));
+        }
+        let started = std::time::Instant::now();
+        let (regions, lines) = shape_builder(&s);
+        assert!(regions.len() >= 5, "the ring cut in five bands at least (the waves make pockets)");
+        assert!(lines.len() >= 12, "{}", lines.len());
+        assert!(started.elapsed().as_secs_f64() < 5.0, "{:?}", started.elapsed());
+        // Past the cap, only the filled areas count.
+        s.push(line((0.0, 0.0), (1.0, 1.0), 2));
+        s[0].path.subpaths[0].anchors.extend((0..16).map(|k| vectorcraft_geom::Anchor::corner(Point::new(100.0, f64::from(k)))));
+        assert!(shape_builder(&s).1.is_empty());
+    }
+
     fn arb_segment() -> impl Strategy<Value = Shape> {
         let c = || (0..10i32).prop_map(|v| f64::from(v) * 10.0);
         prop_oneof![

crates/pdf/src/import.rs

@@ -11,7 +11,7 @@ use hayro_interpret::{
     MaskType, PathDrawMode, SoftMask, StrokeProps, interpret_page,
 };
 use hayro_syntax::object::Name;
-use kurbo::{Affine, BezPath, Rect, Shape};
+use kurbo::{Affine, BezPath, PathEl, Rect, Shape};
 use vectorcraft_color::{BlendMode, Color, Paint, Swatch};
 use vectorcraft_doc::{
     Appearance, AppearanceItem, Artboard, ColorMode, Dash, Document, FillLayer, ImageBlob, ImageObject, Knockout, LayerColor, LineCap, LineJoin,
@@ -21,7 +21,7 @@ use vectorcraft_geom::{FillRule, PathData};
 
 use crate::import_color::{Colors, Native};
 use crate::import_mask::{MaskSpec, contains, is_rectangle, luminance, mask_spec, white_cover};
-use crate::import_scan::{Ocgs, Scan, all_on, hides_forms, scan_page};
+use crate::import_scan::{MAX_NESTING, Ocgs, Scan, all_on, hides_forms, scan_page};
 use crate::import_shading::{clipped, extend_clip, fold_stop_opacity, mesh_shading, shading_gradient};
 use crate::import_text::{Families, Look, Placement, TextLine, Upright};
 use crate::{CropTo, ImportOptions, ImportReport, PdfError, TextAs};
@@ -46,6 +46,60 @@ enum Slot {
     Group(usize),
 }
 
+/// What each group's layer holds, in paint order: its sublayers (their groups) and, where its
+/// own group is listed, its art.
+type Nesting = HashMap<usize, Vec<usize>>;
+
+/// Group `g` paints (its first art): note where its art goes in its layer, and where that layer
+/// goes when it is new: in its parent's layer (placed the same way) or, for a top-level group, in
+/// `slots`.
+fn place_group(g: usize, ocgs: &Ocgs, slots: &mut Vec<Slot>, nesting: &mut Nesting) {
+    let placed = nesting.contains_key(&g);
+    nesting.entry(g).or_default().push(g);
+    if placed {
+        return;
+    }
+    let mut child = g;
+    // Each parent is placed before its sublayers, so the chain ends (within the nesting depth).
+    for _ in 0..=MAX_NESTING {
+        let Some(parent) = ocgs.list.get(child).and_then(|o| o.parent) else { break };
+        let placed = nesting.contains_key(&parent);
+        nesting.entry(parent).or_default().push(child);
+        if placed {
+            return;
+        }
+        child = parent;
+    }
+    slots.push(Slot::Group(child));
+}
+
+/// The layer of group `g`, in `color`: its art and sublayers. `None` for a group that isn't read.
+fn group_layer(
+    b: &mut Builder<'_>,
+    g: usize,
+    ocgs: &Ocgs,
+    nesting: &Nesting,
+    art: &mut HashMap<usize, Vec<Arc<Node>>>,
+    color: LayerColor,
+) -> Option<Node> {
+    let ocg = ocgs.list.get(g)?;
+    let mut l = Node::layer(b.id(), &ocg.name, color);
+    (l.visible, l.locked) = (ocg.on, ocg.locked);
+    let mut children = vec![];
+    for &c in nesting.get(&g).into_iter().flatten() {
+        if c == g {
+            children.extend(art.remove(&g).unwrap_or_default());
+        } else if let Some(sub) = group_layer(b, c, ocgs, nesting, art, color) {
+            children.push(Arc::new(sub));
+        }
+    }
+    if let NodeKind::Layer { children: c, printable, .. } = &mut l.kind {
+        *c = children;
+        *printable = ocg.print;
+    }
+    Some(l)
+}
+
 /// Import a PDF, returning the document plus warnings about content that was approximated or skipped.
 pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportReport, PdfError> {
     let original = crate::pages::open(bytes, opts.password.as_deref())?;
@@ -54,7 +108,7 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
     let route = opts.layers && !ocgs.list.is_empty();
     // Content that is off imports as hidden layers: an update of the file turns every group on
     // (unless a form is hidden by its own group: its art couldn't be told apart).
-    let hide = route && ocgs.any_off();
+    let hide = route && ocgs.skips_any();
     let turned_on = (hide && !picked.iter().filter_map(|&n| original.pages().get(n)).any(|p| hides_forms(p, &mut ocgs)))
         .then(|| all_on(bytes, &original))
         .flatten()
@@ -100,6 +154,7 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
     let mut placeholder = true;
     let mut slots: Vec<Slot> = vec![];
     let mut group_art: HashMap<usize, Vec<Arc<Node>>> = HashMap::new();
+    let mut nesting = Nesting::new();
     for (i, &number) in picked.iter().enumerate() {
         let Some(page) = pages.get(number) else { continue };
         // The chosen box sits at (x, 0); the page draws round it.
@@ -158,7 +213,7 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
                 None => slots.push(page_layer(&mut b, art)),
                 Some(g) => {
                     let into = group_art.entry(g).or_insert_with(|| {
-                        slots.push(Slot::Group(g));
+                        place_group(g, &ocgs, &mut slots, &mut nesting);
                         vec![]
                     });
                     into.extend(art);
@@ -172,16 +227,11 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
     for (n, slot) in slots.into_iter().enumerate() {
         let layer = match slot {
             Slot::Page(l) => *l,
-            Slot::Group(g) => {
-                let Some(ocg) = ocgs.list.get(g) else { continue };
-                let mut l = Node::layer(b.id(), &ocg.name, LayerColor::Preset((n % 27) as u8));
-                (l.visible, l.locked) = (ocg.on, ocg.locked);
-                if let NodeKind::Layer { children, printable, .. } = &mut l.kind {
-                    *children = group_art.remove(&g).unwrap_or_default();
-                    *printable = ocg.print;
-                }
-                l
-            }
+            // Sublayers take their top-level layer's colour.
+            Slot::Group(g) => match group_layer(&mut b, g, &ocgs, &nesting, &mut group_art, LayerColor::Preset((n % 27) as u8)) {
+                Some(l) => l,
+                None => continue,
+            },
         };
         doc.layers.push(Arc::new(layer));
     }
@@ -497,6 +547,8 @@ struct Builder<'p> {
     /// A transparency group was just pushed: a form's (whose flags come next) or an image's.
     pending: bool,
     nested: u32,
+    /// The last filled path: its node and its outline (a stroke of the same outline joins it).
+    last_fill: Option<(NodeId, BezPath)>,
 }
 
 fn blend(b: hayro_interpret::BlendMode) -> BlendMode {
@@ -528,6 +580,29 @@ fn fill_rule(r: hayro_interpret::FillRule) -> FillRule {
     }
 }
 
+/// `p` with every subpath closed: how a fill reads it.
+fn closed_subpaths(p: &BezPath) -> BezPath {
+    let mut out = BezPath::new();
+    let mut open = false;
+    for el in p.elements() {
+        if open && matches!(el, PathEl::MoveTo(_)) {
+            out.push(PathEl::ClosePath);
+        }
+        out.push(*el);
+        open = !matches!(el, PathEl::ClosePath);
+    }
+    if open {
+        out.push(PathEl::ClosePath);
+    }
+    out
+}
+
+/// Do a fill of `fill` and a stroke of `stroke` paint one object's outline? Applications write the
+/// fill without closing the path (filling closes it) and the stroke closed.
+fn same_outline(fill: &BezPath, stroke: &BezPath) -> bool {
+    fill.elements() == stroke.elements() || closed_subpaths(fill).elements() == closed_subpaths(stroke).elements()
+}
+
 fn mean_scale(a: Affine) -> f64 {
     a.determinant().abs().sqrt()
 }
@@ -606,6 +681,7 @@ impl<'p> Builder<'p> {
             marked: vec![],
             pending: false,
             nested: 0,
+            last_fill: None,
         }
     }
 
@@ -656,10 +732,15 @@ impl<'p> Builder<'p> {
         let children = self.close_frames();
         let groups = std::mem::take(&mut self.root_groups);
         let mut parts: Vec<(Option<usize>, Vec<Arc<Node>>)> = vec![];
+        // Thousands of groups: find each one's part by index.
+        let mut at: HashMap<Option<usize>, usize> = HashMap::new();
         for (n, g) in children.into_iter().zip(groups.into_iter().chain(std::iter::repeat(None))) {
-            match parts.iter_mut().find(|(k, _)| *k == g) {
-                Some((_, v)) => v.push(n),
-                None => parts.push((g, vec![n])),
+            let i = *at.entry(g).or_insert_with(|| {
+                parts.push((g, vec![]));
+                parts.len() - 1
+            });
+            if let Some((_, v)) = parts.get_mut(i) {
+                v.push(n);
             }
         }
         parts
@@ -1219,24 +1300,35 @@ impl<'a> Device<'a> for Builder<'_> {
                 if let NodeKind::Path { rule: r, .. } = &mut n.kind {
                     *r = fill_rule(*rule);
                 }
+                self.last_fill = Some((n.id, bp));
                 let n = wrap(self, n);
                 self.push_node(n);
             }
             PathDrawMode::Stroke(props) => {
                 let st = stroke_layer(paint, opacity, props, mean_scale(transform));
-                // Fill-then-stroke of the same path (the `B` operator) becomes one object.
+                // Fill-then-stroke of the same path (the `B` operator, or a fill and a stroke of
+                // the outline as Illustrator writes an object) becomes one object: a path with a
+                // fill and a live stroke.
                 let blend = self.blend;
+                let fill = self.last_fill.take();
                 let last = match self.mask {
                     Some(_) => self.masked.last_mut(),
                     None => self.stack.last_mut().and_then(|f| f.children.last_mut()),
                 };
                 if band.is_none()
                     && let Some(last) = last
+                    && let Some((id, outline)) = fill
+                    && last.id == id
                     && last.blend == blend
-                    && last.path_data() == Some(&pd)
                     && last.appearance.stroke().is_none()
+                    && same_outline(&outline, &bp)
                 {
-                    Arc::make_mut(last).appearance.items.push(AppearanceItem::Stroke(st));
+                    let last = Arc::make_mut(last);
+                    // The stroke's outline: closing it changes the stroke, not the fill.
+                    if let Some(p) = last.path_data_mut() {
+                        *p = pd;
+                    }
+                    last.appearance.items.push(AppearanceItem::Stroke(st));
                     return;
                 }
                 let n = Node::path(self.id(), pd, Appearance { items: vec![AppearanceItem::Stroke(st)], ..Default::default() });

crates/pdf/src/import_scan.rs

@@ -1,6 +1,6 @@
 //! What the interpreter doesn't tell the import, read from the file itself: the optional content
-//! groups (layers) with their states, which group each marked-content sequence belongs to, the
-//! isolate and knockout flags of transparency groups, and the names of the fonts.
+//! groups (layers) with their states and nesting, which group each marked-content sequence belongs
+//! to, the isolate and knockout flags of transparency groups, and the names of the fonts.
 //!
 //! hayro-interpret reports a marked-content sequence by its tag alone and a transparency group
 //! without its flags, and skips the content of groups that are off. So each page's content is
@@ -16,7 +16,7 @@ use hayro_interpret::CacheKey;
 use hayro_syntax::Pdf;
 use hayro_syntax::content::TypedIter;
 use hayro_syntax::content::ops::TypedInstruction;
-use hayro_syntax::object::{Array, Dict, FromBytes, Name, Object, ObjectIdentifier, dict_or_stream};
+use hayro_syntax::object::{Array, Dict, FromBytes, MaybeRef, Name, Object, ObjectIdentifier, dict_or_stream};
 use hayro_syntax::page::{Page, Resources};
 
 /// The interpreter's limit on nested form XObjects.
@@ -25,6 +25,8 @@ const MAX_DEPTH: u32 = 50;
 const MAX_OPS: usize = 2_000_000;
 /// The most groups read.
 const MAX_GROUPS: usize = 10_000;
+/// The deepest layers nest in the configuration's `/Order`.
+pub(crate) const MAX_NESTING: usize = 32;
 
 /// An optional content group: a layer.
 #[derive(Clone, Debug, PartialEq)]
@@ -35,6 +37,8 @@ pub(crate) struct Ocg {
     /// Printed (its print usage isn't off).
     pub print: bool,
     pub locked: bool,
+    /// The group it is listed under in the layer order (a sublayer of it).
+    pub parent: Option<usize>,
 }
 
 /// The file's optional content groups.
@@ -44,6 +48,10 @@ pub(crate) struct Ocgs {
     index: HashMap<ObjectIdentifier, usize>,
     /// The groups that are off (as the interpreter decides it).
     off: HashSet<ObjectIdentifier>,
+    /// The groups whose view state applies when the file opens (an `/AS` entry for viewing).
+    view_auto: HashSet<ObjectIdentifier>,
+    /// The groups placed in the layer order.
+    placed: HashSet<usize>,
 }
 
 impl Ocgs {
@@ -68,35 +76,88 @@ impl Ocgs {
             o.off.remove(&id);
         }
         o.off.extend(refs(&config, b"OFF"));
+        let auto = config.get::<Array<'_>>(b"AS").map(|a| a.iter::<Dict<'_>>().take(MAX_GROUPS).collect::<Vec<_>>()).unwrap_or_default();
+        for d in auto.iter().filter(|d| d.get::<Name<'_>>(b"Event").is_some_and(|e| e.as_ref() == b"View")) {
+            o.view_auto.extend(refs(d, b"OCGs"));
+        }
         let locked: HashSet<_> = refs(&config, b"Locked").into_iter().collect();
         for id in all {
             if let Some(d) = xref.get::<Dict<'_>>(id) {
                 o.add(id, &d, locked.contains(&id));
             }
         }
+        if let Some(order) = config.get::<Array<'_>>(b"Order") {
+            o.nest(&order, None, 0, xref, &mut 0);
+        }
         o
     }
 
+    /// Read the layer order `order` (listed under group `parent`): a group followed by an array
+    /// lists that array's groups as its sublayers; an array starting with a label lists its
+    /// groups under the label, which isn't a group (they go under `parent`). A group listed twice
+    /// stays where it is first listed. `seen`: the entries read so far.
+    fn nest(&mut self, order: &Array<'_>, parent: Option<usize>, depth: usize, xref: &hayro_syntax::xref::XRef, seen: &mut usize) {
+        let mut prev = None;
+        for item in order.raw_iter() {
+            *seen += 1;
+            if *seen > 4 * MAX_GROUPS {
+                return;
+            }
+            let sub = match item {
+                MaybeRef::Ref(r) => {
+                    let id = ObjectIdentifier::from(r);
+                    let sub = xref.get::<Array<'_>>(id);
+                    if sub.is_none() {
+                        prev = self.place(id, parent);
+                    }
+                    sub
+                }
+                MaybeRef::NotRef(o) => o.into_array(),
+            };
+            if let Some(sub) = sub
+                && depth < MAX_NESTING
+            {
+                let label = matches!(sub.raw_iter().next(), Some(MaybeRef::NotRef(Object::String(_))));
+                let under = prev.take().filter(|_| !label).or(parent);
+                self.nest(&sub, under, depth + 1, xref, seen);
+            }
+        }
+    }
+
+    /// Put group `id` under `parent` in the layer order → its index, unless it isn't a group or
+    /// is already placed. Each group is placed after its parent, so the nesting has no cycles.
+    fn place(&mut self, id: ObjectIdentifier, parent: Option<usize>) -> Option<usize> {
+        let i = *self.index.get(&id)?;
+        let placed = self.placed.insert(i);
+        let g = self.list.get_mut(i).filter(|_| placed)?;
+        g.parent = parent;
+        Some(i)
+    }
+
     /// Note group `id` (its dictionary `d`) → its index.
     fn add(&mut self, id: ObjectIdentifier, d: &Dict<'_>, locked: bool) -> usize {
         if let Some(i) = self.index.get(&id) {
             return *i;
         }
         let name = d.get::<hayro_syntax::object::String<'_>>(b"Name").map(|s| text_string(s.as_bytes())).unwrap_or_default();
-        let print = d
-            .get::<Dict<'_>>(b"Usage")
-            .and_then(|u| u.get::<Dict<'_>>(b"Print"))
-            .and_then(|p| p.get::<Name<'_>>(b"PrintState"))
-            .is_none_or(|s| s.as_ref() != b"OFF");
-        let on = !self.off.contains(&id);
-        self.list.push(Ocg { name: if name.is_empty() { format!("Layer {}", self.list.len() + 1) } else { name }, on, print, locked });
+        let print = usage(d, b"Print", b"PrintState") != Some(false);
+        // A view state applies when the configuration says so on opening; an off one hides the
+        // group all the same (it says how the group is meant to be seen).
+        let view = usage(d, b"View", b"ViewState");
+        let on = match view {
+            Some(v) if self.view_auto.contains(&id) => v,
+            Some(false) => false,
+            _ => !self.off.contains(&id),
+        };
+        let name = if name.is_empty() { format!("Layer {}", self.list.len() + 1) } else { name };
+        self.list.push(Ocg { name, on, print, locked, parent: None });
         self.index.insert(id, self.list.len() - 1);
         self.list.len() - 1
     }
 
-    /// Is any group off?
-    pub fn any_off(&self) -> bool {
-        self.list.iter().any(|g| !g.on)
+    /// Does the interpreter leave out the art of some group (off in the default configuration)?
+    pub fn skips_any(&self) -> bool {
+        self.index.keys().any(|id| self.off.contains(id))
     }
 
     /// The group content marked with `/OC` (`d`: the group or membership dictionary, `id` its
@@ -119,6 +180,16 @@ impl Ocgs {
     }
 }
 
+/// The state (`ON` → true, `OFF` → false) group `d`'s usage `category` gives in `key`.
+fn usage(d: &Dict<'_>, category: &[u8], key: &[u8]) -> Option<bool> {
+    let state = d.get::<Dict<'_>>(b"Usage")?.get::<Dict<'_>>(category)?.get::<Name<'_>>(key)?;
+    match state.as_ref() {
+        b"ON" => Some(true),
+        b"OFF" => Some(false),
+        _ => None,
+    }
+}
+
 /// A PDF text string: UTF-16 (with its byte order mark), UTF-8 (with one) or PDFDocEncoding
 /// (read as Latin-1, which it matches for letters).
 pub(crate) fn text_string(b: &[u8]) -> String {

crates/pdf/src/tests_import_fidelity.rs

@@ -1,11 +1,11 @@
 //! Import fidelity: soft masks → opacity masks, isolated and knockout groups, tiling patterns →
 //! pattern swatches, text → point type, mesh shadings → gradient meshes, gradient stop opacity
-//! and shading Extend flags.
+//! and shading Extend flags; strokes stay live strokes.
 
 use std::sync::Arc;
 
 use vectorcraft_color::{BlendMode, Color, Gradient, GradientKind, GradientPaint, GradientStop, Paint};
-use vectorcraft_doc::{Appearance, AppearanceItem, Document, Knockout, Node, NodeId, NodeKind, OpacityMask};
+use vectorcraft_doc::{Appearance, AppearanceItem, Document, Knockout, LineCap, LineJoin, Node, NodeId, NodeKind, OpacityMask};
 use vectorcraft_geom::{Rect, shapes};
 use vectorcraft_testkit::pdf::{PdfPage, first_extra, pdf_with};
 
@@ -390,3 +390,57 @@ fn glyphs_turned_along_a_curve_become_type_on_a_path() {
     assert_eq!(straight.len(), 1);
     assert!(matches!(straight[0].kind, vectorcraft_doc::TextKind::Point), "{:?}", straight[0].kind);
 }
+
+/// The leaves (objects that aren't groups or clipping paths) of a document.
+fn objects(d: &Document) -> Vec<Node> {
+    all(d).into_iter().filter(|n| !n.is_container() && !matches!(n.kind, NodeKind::Path { clipping: true, .. })).collect()
+}
+
+#[test]
+fn an_object_written_as_a_fill_and_a_closed_stroke_stays_one_path_with_a_live_stroke() {
+    // As Illustrator writes an object: the fill of the outline left open, then the stroke of it
+    // closed, each in its own transform. Two subpaths: one ending on its start, one not.
+    let outline = "0 0 m -20 1 l -30 -12 l -30 30 l 0 0 l 5 5 m 10 5 l 10 10 l";
+    let content = format!(
+        "0.2 0.2 0.2 rg q 1 0 0 1 50 50 cm {outline} f Q 1 1 1 RG 1.5 w 1 J 1 j 4 M [3 2] 1 d q 1 0 0 1 50 50 cm {} S Q",
+        outline.replace(" 5 5 m", " h 5 5 m") + " h"
+    );
+    let d = open(&one_page(&content, "", &[]));
+    let objs = objects(&d);
+    assert_eq!(objs.len(), 1, "one object, not a fill and a separate stroke: {objs:#?}");
+    let n = &objs[0];
+    assert_eq!(fill_color(n), Some(Color::rgb(0.2, 0.2, 0.2)));
+    let st = n.appearance.stroke().expect("a live stroke");
+    assert_eq!(st.paint.color(), Some(Color::WHITE));
+    assert!((st.width - 1.5).abs() < 1e-6);
+    assert_eq!((st.cap, st.join), (LineCap::Round, LineJoin::Round));
+    assert!((st.miter_limit - 4.0).abs() < 1e-6);
+    let dash = st.dash.as_ref().expect("dashed");
+    assert_eq!((dash.pattern.as_slice(), dash.offset), (&[3.0, 2.0][..], 1.0));
+    // The stroke's outline: both subpaths closed, as they were stroked.
+    let p = n.path_data().unwrap();
+    assert_eq!(p.subpaths.len(), 2);
+    assert!(p.is_closed());
+}
+
+#[test]
+fn different_outlines_filled_and_stroked_stay_apart() {
+    let d = open(&one_page("1 0 0 rg 10 10 m 40 10 l 40 40 l f 0 0 1 RG 10 10 m 40 10 l 40 40 l 10 40 l h S 0 g 50 50 m 60 60 l S", "", &[]));
+    let objs = objects(&d);
+    assert_eq!(objs.len(), 3);
+    assert!(objs[0].appearance.stroke().is_none() && objs[1].appearance.fill().is_none());
+}
+
+#[test]
+fn a_stroke_under_a_stretched_transform_stays_a_stroke() {
+    // Stretched twice as wide: the stroke keeps its average width (√2 × 2 pt) rather than
+    // becoming a filled outline.
+    let d = open(&one_page("0 0 1 RG 2 w q 2 0 0 1 0 0 cm 10 10 m 40 10 l 40 40 l S Q", "", &[]));
+    let objs = objects(&d);
+    assert_eq!(objs.len(), 1);
+    assert!(objs[0].appearance.fill().is_none());
+    let st = objs[0].appearance.stroke().expect("a stroke");
+    assert!((st.width - 2.0 * 2f64.sqrt()).abs() < 1e-6, "{}", st.width);
+    let b = objs[0].geometric_bounds().unwrap();
+    assert!((b.x0 - 20.0).abs() < 1e-6 && (b.x1 - 80.0).abs() < 1e-6, "{b:?}");
+}

crates/pdf/src/tests_import_layers.rs

@@ -1,5 +1,5 @@
-//! Optional content groups become layers: name, visibility, print state and lock; art that is
-//! off comes in as a hidden layer.
+//! Optional content groups become layers: name, visibility (the default configuration's or the
+//! view state's), print state, lock and nesting; art that is off comes in as a hidden layer.
 
 use vectorcraft_color::Color;
 use vectorcraft_doc::{Document, Node, NodeKind};
@@ -192,3 +192,109 @@ fn a_page_fill_that_is_art_stays() {
     assert_eq!(names(&d), ["Shapes", "Page 1"]);
     assert_eq!(path_count(&d), 3);
 }
+
+/// A page drawing a red, a blue and a green square in groups `defs` (as `/MC0`–`/MC2`), the
+/// catalog listing them with default configuration `config`, plus `more` objects; in `config` and
+/// `more`, `{0}`–`{2}` stand for the groups.
+fn three_groups(defs: [&str; 3], more: &[&str], config: &str) -> Vec<u8> {
+    let refs = [0, 1, 2].map(|i| format!("{} 0 R", first_extra(1) + i));
+    let fill = |s: &str| (0..3).fold(s.to_string(), |s, i| s.replace(&format!("{{{i}}}"), &refs[i]));
+    let content = "/OC /MC0 BDC 1 0 0 rg 10 10 20 20 re f EMC /OC /MC1 BDC 0 0 1 rg 40 40 20 20 re f EMC /OC /MC2 BDC 0 1 0 rg 70 70 20 20 re f EMC";
+    let page = PdfPage { resources: fill("/Properties << /MC0 {0} /MC1 {1} /MC2 {2} >>"), ..PdfPage::new(100.0, 100.0, content) };
+    let catalog = format!("/OCProperties << /OCGs [{}] /D << {} >> >> ", refs.join(" "), fill(config));
+    let more: Vec<String> = more.iter().map(|m| fill(m)).collect();
+    let objs: Vec<&str> = defs.iter().copied().chain(more.iter().map(String::as_str)).collect();
+    pdf_with_catalog(&[page], &objs, &catalog, None)
+}
+
+fn ocg(name: &str, usage: &str) -> String {
+    format!("<< /Type /OCG /Name ({name}) {usage} >>")
+}
+
+fn visibility(layers: &[std::sync::Arc<Node>]) -> Vec<bool> {
+    layers.iter().map(|l| l.visible).collect()
+}
+
+#[test]
+fn a_view_state_that_is_off_hides_the_layer_with_its_art() {
+    let off = ocg("Off", "/Usage << /View << /ViewState /OFF >> >>");
+    // With an /AS entry for viewing, the view state wins over the default configuration.
+    let on = ocg("On", "/Usage << /View << /ViewState /ON >> >>");
+    let bytes = three_groups([&ocg("Plain", ""), &off, &on], &[], "/OFF [{2}] /AS [<< /Event /View /Category [/View] /OCGs [{1} {2}] >>]");
+    let d = import(&bytes).unwrap();
+    assert_eq!(names(&d), ["Plain", "Off", "On"]);
+    assert_eq!(visibility(&d.layers), [true, false, true]);
+    assert_eq!(colors(&d.layers[1]), [Color::rgb(0.0, 0.0, 1.0)]);
+    assert_eq!(colors(&d.layers[2]), [Color::rgb(0.0, 1.0, 0.0)], "the art the default configuration hides is read");
+    // Without one, a view state that is off still hides the layer.
+    let d = import(&three_groups([&ocg("Plain", ""), &off, &ocg("Other", "")], &[], "")).unwrap();
+    assert_eq!(visibility(&d.layers), [true, false, true]);
+    assert_eq!(colors(&d.layers[1]), [Color::rgb(0.0, 0.0, 1.0)]);
+}
+
+#[test]
+fn nested_groups_become_sublayers_and_hidden_ones_keep_their_art() {
+    // The order as an object of its own (as Illustrator writes it): "Top" holds "Sub", which is
+    // off; a label's groups stay at the level of the label.
+    let order = first_extra(1) + 3;
+    let bytes = three_groups(
+        [&ocg("Top", ""), &ocg("Sub", ""), &ocg("Other", "")],
+        &["[{0} [{1}] [(Label) {2}]]"],
+        &format!("/OFF [{{1}}] /Order {order} 0 R"),
+    );
+    let d = import(&bytes).unwrap();
+    assert_eq!(names(&d), ["Top", "Other"]);
+    assert_eq!(visibility(&d.layers), [true, true]);
+    let top = d.layers[0].children().unwrap();
+    assert_eq!(top.len(), 2, "its art, then its sublayer");
+    assert_eq!(top[0].appearance.fill().and_then(|f| f.paint.color()), Some(Color::rgb(1.0, 0.0, 0.0)));
+    let sub = &top[1];
+    assert!(matches!(sub.kind, NodeKind::Layer { .. }) && sub.name.as_deref() == Some("Sub"));
+    assert!(!sub.visible, "the sublayer that is off is hidden");
+    assert_eq!(colors(sub), [Color::rgb(0.0, 0.0, 1.0)], "with its art");
+    assert_eq!(d.layer_color(sub.id), d.layer_color(d.layers[0].id), "a sublayer takes its layer's colour");
+    assert_eq!(colors(&d.layers[1]), [Color::rgb(0.0, 1.0, 0.0)]);
+}
+
+#[test]
+fn a_sublayer_that_paints_first_brings_its_parent_layer() {
+    // "Sub" paints first; "Top", its parent, paints its own art last.
+    let bytes = three_groups([&ocg("Sub", ""), &ocg("Other", ""), &ocg("Top", "")], &[], "/Order [{2} [{0}] {1}]");
+    let d = import(&bytes).unwrap();
+    assert_eq!(names(&d), ["Top", "Other"]);
+    let top = d.layers[0].children().unwrap();
+    assert_eq!(top.len(), 2);
+    assert_eq!(top[0].name.as_deref(), Some("Sub"));
+    assert_eq!(colors(&top[0]), [Color::rgb(1.0, 0.0, 0.0)]);
+    assert_eq!(top[1].appearance.fill().and_then(|f| f.paint.color()), Some(Color::rgb(0.0, 1.0, 0.0)));
+}
+
+#[test]
+fn hostile_layer_orders_stay_bounded() {
+    // A group listed twice, under itself, and an order nested far deeper than layers go.
+    let deep = format!("{}{{2}}{}", "[".repeat(100), "]".repeat(100));
+    let order = format!("[{{0}} [{{0}} {{1}}] {{1}} [{{0}}] {deep}]");
+    let d = import(&three_groups([&ocg("A", ""), &ocg("B", ""), &ocg("C", "")], &[], &format!("/Order {order}"))).unwrap();
+    assert_eq!(names(&d), ["A", "C"], "C, listed too deep, stays a top-level layer");
+    assert_eq!(d.layers[0].children().unwrap()[1].name.as_deref(), Some("B"));
+    let mut count = 0;
+    d.walk(|n| count += usize::from(matches!(n.kind, NodeKind::Layer { .. })));
+    assert_eq!(count, 3, "each group is one layer");
+}
+
+#[test]
+fn thousands_of_layers_hidden_ones_included_all_come_in() {
+    const N: usize = 3000;
+    let first = first_extra(1);
+    let objs: Vec<String> = (0..N).map(|i| ocg(&format!("L{i}"), "")).collect();
+    let refs: Vec<String> = (0..N).map(|i| format!("{} 0 R", first + i)).collect();
+    let props: String = refs.iter().enumerate().map(|(i, r)| format!("/M{i} {r} ")).collect();
+    let content: String = (0..N).map(|i| format!("/OC /M{i} BDC {} {} 1 1 re f EMC ", i % 100, i / 100)).collect();
+    let off: Vec<&str> = refs.iter().step_by(2).map(String::as_str).collect();
+    let catalog = format!("/OCProperties << /OCGs [{}] /D << /OFF [{}] >> >> ", refs.join(" "), off.join(" "));
+    let page = PdfPage { resources: format!("/Properties << {props}>>"), ..PdfPage::new(100.0, 100.0, &content) };
+    let objs: Vec<&str> = objs.iter().map(String::as_str).collect();
+    let d = import(&pdf_with_catalog(&[page], &objs, &catalog, None)).unwrap();
+    assert_eq!(d.layers.len(), N);
+    assert!(d.layers.iter().enumerate().all(|(i, l)| l.visible == (i % 2 == 1) && l.children().is_some_and(|c| c.len() == 1)));
+}

crates/svg/src/css.rs

@@ -10,6 +10,7 @@ use serde::{Deserialize, Serialize};
 use vectorcraft_color::{BlendMode, Color, GradientKind, GradientPaint, Paint};
 use vectorcraft_doc::{AppearanceItem, CharStyle, Document, Justify, LineCap, LiveShape, Node, NodeId, NodeKind, StrokeAlign, StrokeLayer, TextKind};
 use vectorcraft_effects::RasterFx;
+use vectorcraft_geom::shapes::CornerKind;
 use vectorcraft_geom::{Affine, PathData, Point, Rect};
 
 use crate::export::sanitize_id;
@@ -600,7 +601,10 @@ fn corners(path: &PathData, live: Option<&LiveShape>) -> Option<Corners> {
         b.abs() < 1e-9 && c.abs() < 1e-9
     };
     match live {
-        Some(LiveShape::Rectangle { radii, xf, .. }) if upright(xf) => {
+        // CSS rounds corners only: an inverted round or chamfered corner has no border radius.
+        Some(LiveShape::Rectangle { radii, kinds, xf, .. })
+            if upright(xf) && radii.iter().zip(kinds).all(|(r, k)| *r <= 0.0 || *k == CornerKind::Round) =>
+        {
             let [a, _, _, d, _, _] = xf.as_coeffs();
             let s = (a * d).abs().sqrt();
             if radii.iter().all(|r| *r <= 0.0) {

crates/svg/src/import.rs

@@ -677,9 +677,12 @@ impl Importer {
             return Some(vec![]);
         }
         let text::PendingText { name, mut obj, servers, paints, non_scaling, under, .. } = self.slots.texts.get(i)?.clone();
+        // The scale the type draws at becomes its size (last, below): text space grows by `grow`.
+        let xf = ts * obj.xf;
+        let grow = text::size_scale(&obj, xf);
         // usvg resolved the `url(#…)` paints (the paths after the main one) in the element's user
         // space; runs paint in text space.
-        let to_text = obj.xf.inverse();
+        let to_text = Affine::scale(grow) * obj.xf.inverse();
         let slot_paint = |im: &mut Self, k: usize, m: Affine| match kids.get(main + 1 + k) {
             Some(usvg::Node::Path(p)) => p.fill().map_or(Paint::None, |f| {
                 let area = kurbo::Shape::bounding_box(&bezpath(p.data(), m));
@@ -697,7 +700,7 @@ impl Importer {
                 run.style.stroke = server(k);
             }
         }
-        obj.xf = ts * obj.xf;
+        obj.xf = xf;
         if non_scaling && !vector_effect::unscale_text(&mut obj, self.screen) {
             let label = if name.is_empty() || made_up(&name) { "a text".to_string() } else { format!("text '{name}'") };
             self.warn(format!("non-scaling stroke on {label} approximated: the text is stretched or skewed"));
@@ -712,6 +715,7 @@ impl Importer {
             ap.set_contents_at(1);
             ap
         });
+        text::fold_scale(&mut obj, grow);
         let mut n = self.named(&name, NodeKind::Text(Box::new(obj)));
         if let Some(ap) = under {
             n.appearance = ap;

crates/svg/src/import/text.rs

@@ -15,12 +15,16 @@
 //! line spacing), other vertical moves become baseline shift, horizontal moves become kerning (an
 //! absolute `x` is measured against the laid-out text), and rotations become character rotation.
 //! `<textPath>` becomes type on a path; vertical `writing-mode` becomes type on a vertical path.
+//!
+//! Type takes the size it draws at: the scale of the transforms and `viewBox` above a `<text>`
+//! moves into its sizes ([`size_scale`], [`fold_scale`]), and the rest (a stretch, skew,
+//! rotation or reflection) stays its transform.
 
 use std::borrow::Cow;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt::Write as _;
-use std::ops::Range;
+use std::ops::{Range, RangeInclusive};
 use std::rc::Rc;
 use std::str::FromStr;
 
@@ -653,6 +657,52 @@ fn stroke_under(cells: &mut [Cell], label: &str, warnings: &mut Vec<String>) ->
     first
 }
 
+/// The type sizes the Character panel takes, in points.
+const SIZES: RangeInclusive<f64> = 0.1..=1296.0;
+
+/// How much of `xf` (text space → document) [`fold_scale`] makes the type's size: the scale
+/// across the baseline for point type (a stretch along it, a skew, a rotation and a reflection
+/// stay in the transform), the mean scale for type on a path, whose baseline turns. Not past the
+/// Character panel's sizes (the rest stays in the transform); 1 when `xf` collapses the text.
+pub(super) fn size_scale(t: &TextObject, xf: Affine) -> f64 {
+    let [a, b, ..] = xf.as_coeffs();
+    let det = xf.determinant().abs();
+    let k = match t.kind {
+        TextKind::OnPath { .. } => det.sqrt(),
+        _ => det / a.hypot(b),
+    };
+    // To 6 significant digits: usvg's transforms are single precision, and `rotate(30) scale(2)`
+    // makes 7 pt type 14 pt, not 13.9999998 pt (the type draws the same either way).
+    let p = 10f64.powi((5.0 - k.log10().floor()) as i32);
+    let k = (k * p).round() / p;
+    if !(k.is_finite() && k > 0.0) {
+        return 1.0;
+    }
+    let (lo, hi) = t.runs.iter().map(|r| r.style.size).fold((f64::INFINITY, 0.0f64), |(lo, hi), s| (lo.min(s), hi.max(s)));
+    // Sizes already outside the range don't move further out.
+    if k > 1.0 { k.min((SIZES.end() / hi).max(1.0)) } else { k.max((SIZES.start() / lo).min(1.0)) }
+}
+
+/// Make text space `k` times larger and the transform `1 / k` times smaller, so the type draws
+/// the same at `k` times its size (and leading, baseline shift, character strokes and path): the
+/// size the Character panel shows is the size it draws at.
+pub(super) fn fold_scale(t: &mut TextObject, k: f64) {
+    for r in &mut t.runs {
+        let st = &mut r.style;
+        st.size *= k;
+        st.leading = st.leading.map(|l| l * k);
+        st.baseline_shift *= k;
+    }
+    t.scale_char_strokes(k);
+    let up = Affine::scale(k);
+    match &mut t.kind {
+        TextKind::OnPath { path, .. } | TextKind::Area { frame: path } => path.transform(up),
+        TextKind::Point => {}
+    }
+    t.cached_bounds = t.cached_bounds.map(|b| up.transform_rect_bbox(b));
+    t.xf *= Affine::scale(1.0 / k);
+}
+
 /// `v`, or 0 when far-off positions added up past f64's range.
 fn finite(v: f64) -> f64 {
     if v.is_finite() { v } else { 0.0 }

crates/svg/tests/css_rules.rs

@@ -6,7 +6,8 @@
 
 use vectorcraft_color::{BlendMode, Color, Gradient, GradientGeom, GradientKind, GradientPaint, Paint};
 use vectorcraft_doc::{Appearance, CharStyle, Document, Effect, Justify, LiveShape, Node, NodeId, NodeKind, TextObject};
-use vectorcraft_geom::{Affine, Point, Rect, shapes};
+use vectorcraft_geom::shapes::{self, CornerKind};
+use vectorcraft_geom::{Affine, Point, Rect};
 use vectorcraft_svg::{CssOptions, CssRule, CssUnits, ExportOptions, Styling, css_rules, export};
 
 fn doc() -> Document {
@@ -29,7 +30,7 @@ fn rect(d: &mut Document, (x, y, w, h): (f64, f64, f64, f64), radius: f64) -> No
         Appearance::basic(fill, Paint::solid(Color::rgb8(0, 0, 255)), 2.0),
     );
     if let NodeKind::Path { live, .. } = &mut n.kind {
-        *live = Some(LiveShape::Rectangle { w, h, radii: [radius; 4], xf: Affine::translate((x, y)) });
+        *live = Some(LiveShape::Rectangle { w, h, radii: [radius; 4], kinds: Default::default(), xf: Affine::translate((x, y)) });
     }
     n
 }
@@ -69,6 +70,22 @@ fn rectangle_gives_background_border_and_radius() {
     );
 }
 
+#[test]
+fn live_corners_give_per_corner_radii_and_only_round_ones() {
+    let mut d = doc();
+    let mut n = rect(&mut d, (0.0, 0.0, 100.0, 50.0), 0.0);
+    if let NodeKind::Path { live: Some(LiveShape::Rectangle { radii, kinds, .. }), .. } = &mut n.kind {
+        *radii = [0.0, 8.0, 0.0, 4.0];
+        kinds[0] = CornerKind::Chamfer;
+    }
+    let id = add(&mut d, n);
+    assert_eq!(prop(&one(&d, id, &CssOptions::default()), "border-radius"), Some("0 8px 0 4px"), "a square corner's kind doesn't matter");
+    if let Some(NodeKind::Path { live: Some(LiveShape::Rectangle { kinds, .. }), .. }) = d.node_mut(id).map(|n| &mut n.kind) {
+        kinds[1] = CornerKind::InvertedRound;
+    }
+    assert!(prop(&one(&d, id, &CssOptions::default()), "border-radius").is_none(), "CSS can't cut a corner in");
+}
+
 #[test]
 fn ellipses_round_fully_and_options_change_units_and_names() {
     let mut d = doc();

crates/svg/tests/import_text.rs

@@ -385,3 +385,136 @@ fn far_off_positions_stay_finite() {
         assert!(r.style.baseline_shift.is_finite() && r.style.kerning.is_none_or(f64::is_finite) && r.style.rotation.is_finite(), "{r:?}");
     }
 }
+
+/// Drawn bounds of the laid-out text in the document.
+fn drawn(t: &TextObject) -> Rect {
+    t.xf.transform_rect_bbox(layout(FontDb::global(), t).bounds)
+}
+
+/// The linear part of a transform.
+fn linear(t: &TextObject) -> [f64; 4] {
+    let [a, b, c, d, ..] = t.xf.as_coeffs();
+    [a, b, c, d]
+}
+
+fn close4(a: [f64; 4], b: [f64; 4]) -> bool {
+    // usvg's transforms are single precision.
+    a.iter().zip(b).all(|(a, b)| close(*a, b, 1e-6))
+}
+
+#[test]
+fn a_scale_above_text_becomes_its_size() {
+    // #396: a group's or the text's own scale is the size the type shows and draws at.
+    let d = open(
+        r#"<text x="50" y="100" font-size="7">HHHH Hamburg</text>
+        <g transform="scale(3)"><text x="16" y="60" font-size="7">HHHH Hamburg</text></g>
+        <text x="50" y="400" font-size="7" transform="scale(2)">HHHH Hamburg</text>"#,
+    );
+    let t = texts(&d);
+    let sizes: Vec<f64> = t.iter().map(|t| t.first_style().size).collect();
+    assert!(close(sizes[0], 7.0, 1e-9) && close(sizes[1], 21.0, 1e-9) && close(sizes[2], 14.0, 1e-9), "{sizes:?}");
+    for t in &t {
+        assert!(close4(linear(t), [1.0, 0.0, 0.0, 1.0]), "{:?}", t.xf);
+    }
+    assert!(t[1].xf.translation().to_point().distance(Point::new(48.0, 180.0)) < 1e-9, "{:?}", t[1].xf);
+    assert!(t[2].xf.translation().to_point().distance(Point::new(100.0, 800.0)) < 1e-9, "{:?}", t[2].xf);
+    // Drawn as large as their sizes say.
+    let h: Vec<f64> = t.iter().map(|t| drawn(t).height() / t.first_style().size).collect();
+    assert!(close(h[1], h[0], 1e-6) && close(h[2], h[0], 1e-6), "{h:?}");
+}
+
+#[test]
+fn a_viewbox_scale_becomes_the_size() {
+    let d = import(
+        r#"<svg xmlns="http://www.w3.org/2000/svg" width="306" height="396" viewBox="0 0 612 792"><text x="50" y="100" font-size="7">HH</text></svg>"#,
+    )
+    .unwrap();
+    let t = only_text(&d);
+    assert!(close(t.first_style().size, 3.5, 1e-9), "{}", t.first_style().size);
+    assert!(close4(linear(t), [1.0, 0.0, 0.0, 1.0]), "{:?}", t.xf);
+    assert!(t.xf.translation().to_point().distance(Point::new(25.0, 50.0)) < 1e-9, "{:?}", t.xf);
+}
+
+#[test]
+fn a_rotated_scale_scales_every_length_and_keeps_the_rotation() {
+    // The same text written at twice the size: the scale moves into size, leading, baseline
+    // shift and the character strokes; spacing in ems stays.
+    let scaled = open(
+        r#"<text transform="translate(100 50) rotate(30) scale(2)" x="5" y="10" font-size="7" letter-spacing="1" word-spacing="2" stroke="red" stroke-width="0.5" stroke-dasharray="1 2">Ab <tspan baseline-shift="3">c</tspan><tspan x="5" dy="12">Two</tspan></text>"#,
+    );
+    let written = open(
+        r#"<text transform="translate(100 50) rotate(30)" x="10" y="20" font-size="14" letter-spacing="2" word-spacing="4" stroke="red" stroke-width="1" stroke-dasharray="2 4">Ab <tspan baseline-shift="6">c</tspan><tspan x="10" dy="24">Two</tspan></text>"#,
+    );
+    let (s, w) = (only_text(&scaled), only_text(&written));
+    assert_eq!(s.runs, w.runs);
+    assert!(s.runs.iter().any(|r| r.style.leading == Some(24.0) && r.text.contains("Two")), "{:?}", s.runs);
+    assert!(close(s.xf.determinant(), 1.0, 1e-6), "{:?}", s.xf);
+    let r = 30f64.to_radians();
+    assert!(close4(linear(s), [r.cos(), r.sin(), -r.sin(), r.cos()]), "{:?}", s.xf);
+    for (a, b) in glyph_origins(s).iter().zip(glyph_origins(w)) {
+        assert!(a.distance(b) < 1e-6, "{a:?} {b:?}");
+    }
+}
+
+#[test]
+fn a_stretch_or_skew_stays_the_transform() {
+    // The scale across the baseline is the size; a stretch along it or a skew stays.
+    let d = open(
+        r#"<text x="10" y="20" font-size="7" transform="scale(3 1)">HH</text>
+        <text x="10" y="20" font-size="7" transform="scale(1 3)">HH</text>
+        <text x="10" y="20" font-size="7" transform="skewX(20)">HH</text>"#,
+    );
+    let t = texts(&d);
+    let sizes: Vec<f64> = t.iter().map(|t| t.first_style().size).collect();
+    assert!(close(sizes[0], 7.0, 1e-9) && close(sizes[1], 21.0, 1e-9) && close(sizes[2], 7.0, 1e-9), "{sizes:?}");
+    assert!(close4(linear(t[0]), [3.0, 0.0, 0.0, 1.0]), "{:?}", t[0].xf);
+    assert!(close4(linear(t[1]), [1.0 / 3.0, 0.0, 0.0, 1.0]), "{:?}", t[1].xf);
+    assert!(close4(linear(t[2]), [1.0, 0.0, 20f64.to_radians().tan(), 1.0]), "{:?}", t[2].xf);
+    // `scale(1 3)` draws three times as tall as `scale(3 1)`, a third as wide.
+    let (wide, tall) = (drawn(t[0]), drawn(t[1]));
+    assert!(close(tall.height(), 3.0 * wide.height(), 1e-6) && close(3.0 * tall.width(), wide.width(), 1e-6), "{wide:?} {tall:?}");
+    assert!(t[1].xf.translation().to_point().distance(Point::new(10.0, 60.0)) < 1e-9, "{:?}", t[1].xf);
+}
+
+#[test]
+fn type_on_a_scaled_path_takes_the_scale() {
+    let d = open(
+        r##"<g transform="scale(2)"><path id="p" d="M10 100 L110 100" fill="none"/>
+        <text font-size="10"><textPath href="#p">Curve</textPath></text></g>"##,
+    );
+    let t = only_text(&d);
+    assert!(close(t.first_style().size, 20.0, 1e-9), "{}", t.first_style().size);
+    assert!(close(t.xf.determinant(), 1.0, 1e-6), "{:?}", t.xf);
+    let TextKind::OnPath { path, .. } = &t.kind else { panic!("{:?}", t.kind) };
+    let b = t.xf.transform_rect_bbox(path.bounds().unwrap());
+    assert!(close(b.x0, 20.0, 1e-9) && close(b.x1, 220.0, 1e-9) && close(b.y0, 200.0, 1e-9), "{b:?}");
+}
+
+#[test]
+fn folded_sizes_stay_in_the_character_panels_range() {
+    // Past 1296 pt (or under 0.1 pt) the rest of the scale stays the transform.
+    let d = open(
+        r#"<g transform="scale(20)"><text y="10" font-size="100">Big</text></g>
+        <g transform="scale(0.001)"><text y="10" font-size="7">Small</text></g>
+        <text y="10" font-size="2000">Huge</text>"#,
+    );
+    let t = texts(&d);
+    let size = |i: usize| t[i].first_style().size;
+    assert!(close(size(0), 1296.0, 1e-9) && close(size(0) * linear(t[0])[0], 2000.0, 1e-9), "{:?}", t[0].xf);
+    assert!(close(size(1), 0.1, 1e-9) && close(size(1) * linear(t[1])[0], 0.007, 1e-9), "{:?}", t[1].xf);
+    assert!(close(size(2), 2000.0, 1e-9) && close4(linear(t[2]), [1.0, 0.0, 0.0, 1.0]), "unscaled type keeps its size");
+}
+
+#[test]
+fn gradients_on_scaled_text_stay_in_place() {
+    let d = open(
+        r##"<defs><linearGradient id="user" gradientUnits="userSpaceOnUse" x1="20" y1="0" x2="120" y2="0"><stop offset="0" stop-color="#f00"/><stop offset="1" stop-color="#00f"/></linearGradient></defs>
+        <g transform="scale(2)"><text x="20" y="50" font-size="20" fill="url(#user)">Gradient</text></g>"##,
+    );
+    let t = only_text(&d);
+    assert!(close(t.first_style().size, 40.0, 1e-9));
+    let Paint::Gradient(g) = &t.runs[0].style.fill else { panic!("{:?}", t.runs[0].style.fill) };
+    let geom = g.geom.unwrap();
+    let (start, end) = (t.xf * geom.start, t.xf * geom.end);
+    assert!(start.distance(Point::new(40.0, 0.0)) < 1e-6 && end.distance(Point::new(240.0, 0.0)) < 1e-6, "{start:?} {end:?}");
+}

crates/svg/tests/import_units.rs

@@ -115,11 +115,10 @@ fn text_lengths_in_physical_units() {
     assert!(close(o.x, 72.0) && close(o.y, 144.0), "{o:?}");
     let st = t.first_style();
     assert!(close(st.tracking, 100.0), "{}", st.tracking);
-    // User units of a physical root are CSS pixels (0.75 pt): the text carries that scale.
-    let scale = t.xf.as_coeffs()[0];
-    assert!(close(scale, 0.75), "{:?}", t.xf);
-    assert!(close(st.stroke_width * scale, 1.0), "{}", st.stroke_width);
-    assert!(close(st.size * scale, 15.0), "{}", st.size);
+    // User units of a physical root are CSS pixels (0.75 pt): that scale moves into the type.
+    assert!(close(t.xf.as_coeffs()[0], 1.0), "{:?}", t.xf);
+    assert!(close(st.stroke_width, 1.0), "{}", st.stroke_width);
+    assert!(close(st.size, 15.0), "{}", st.size);
 }
 
 #[test]

crates/svg/tests/non_scaling_stroke.rs

@@ -84,9 +84,10 @@ fn type_keeps_its_non_scaling_stroke_width() {
     let (d, warnings) = import_with_report(svg).unwrap();
     let t = text(&d);
     let st = &t.runs[0].style;
-    // Text space is scaled 2×: half the width there is the width on screen.
+    // The scale became the type's size: the stroke and its dashes keep their width on screen.
+    assert!(close(st.size, 40.0) && close(t.xf.determinant(), 1.0), "{} {:?}", st.size, t.xf);
     assert!(close(st.stroke_width * t.xf.determinant().sqrt(), 3.0), "{} {:?}", st.stroke_width, t.xf);
-    assert_eq!(st.stroke_dash.as_ref().map(|d| d.pattern.clone()), Some(vec![2.0, 1.0]));
+    assert_eq!(st.stroke_dash.as_ref().map(|d| d.pattern.clone()), Some(vec![4.0, 2.0]));
     assert!(warnings.is_empty(), "{warnings:?}");
 
     let (_, warnings) = import_with_report(&svg.replace("scale(2)", "scale(2 1)")).unwrap();

crates/svg/tests/roundtrip.rs

@@ -386,6 +386,33 @@ fn text_roundtrip_and_escaping() {
     assert!(t.xf.translation().to_point().distance(Point::new(20.0, 50.0)) < 0.01);
 }
 
+#[test]
+fn scaled_text_roundtrips_at_the_size_it_draws() {
+    // Type scaled with its object (its transform scales it) comes back at the size it draws at,
+    // drawn the same, and stays so on the next round trip; a stretch stays the transform.
+    let at = Affine::translate((20.0, 50.0));
+    let stretch = at * Affine::rotate(0.5) * Affine::scale_non_uniform(2.0, 1.0);
+    for (xf, size) in [(at * Affine::scale(2.0), 18.0), (at * Affine::rotate(0.5) * Affine::scale(3.0), 27.0), (stretch, 9.0)] {
+        let mut t = TextObject::point(Point::ZERO, "Scaled\ntype", CharStyle { size: 9.0, leading: Some(11.0), ..CharStyle::default() });
+        t.xf = xf;
+        let drawn = |t: &TextObject| t.xf.transform_rect_bbox(vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).bounds);
+        let before = drawn(&t);
+        let id = Document::new(200.0, 200.0).alloc_id();
+        let d = doc_with(vec![Node::new(id, NodeKind::Text(Box::new(t)))]);
+        let once = roundtrip(&d);
+        let NodeKind::Text(t) = &art(&once)[0].kind else { panic!() };
+        // Within the precision of the exported matrix (3 decimals); the second line carries the
+        // leading.
+        let near = |a: f64, b: f64| (a - b).abs() < b * 1e-3;
+        let st = &t.runs.last().unwrap().style;
+        assert!(near(st.size, size) && near(st.leading.unwrap(), 11.0 * size / 9.0), "{xf:?}: {st:?}");
+        assert!(close_rect(drawn(t), before, 0.05), "{xf:?}: {:?} {before:?}", drawn(t));
+        let twice = roundtrip(&once);
+        let NodeKind::Text(t2) = &art(&twice)[0].kind else { panic!() };
+        assert!(near(t2.first_style().size, size) && close_rect(drawn(t2), before, 0.05), "{xf:?}: {:?} {:?}", t2.runs, drawn(t2));
+    }
+}
+
 #[test]
 fn text_on_path_roundtrip() {
     let mut d = Document::new(200.0, 200.0);

crates/text/src/layout.rs

@@ -281,7 +281,10 @@ fn is_japanese_letter(c: char) -> bool {
         return true;
     }
     is_cjk(c)
-        && !matches!(c as u32, 0x3000..=0x303F | 0xAC00..=0xD7AF | 0xFF01..=0xFF0F | 0xFF1A..=0xFF20 | 0xFF3B..=0xFF40 | 0xFF5B..=0xFF65)
+        && !matches!(
+            c as u32,
+            0x3000..=0x303F | 0x3130..=0x318F | 0xAC00..=0xD7AF | 0xFF01..=0xFF0F | 0xFF1A..=0xFF20 | 0xFF3B..=0xFF40 | 0xFF5B..=0xFF65 | 0xFFA0..=0xFFDC
+        )
         && c != '・'
         && punct(c).is_none()
 }
@@ -320,6 +323,26 @@ fn space_japanese_and_latin(sg: &mut [SGlyph]) -> Vec<f64> {
     added
 }
 
+/// The size of `g`'s em, in points.
+fn glyph_em(g: &SGlyph) -> f64 {
+    g.face.units_per_em() * g.sy
+}
+
+/// How far up (line space) Character Alignment `a` moves glyph `g` on a line whose largest em is
+/// `line_em`: the glyph's em box top, centre or bottom onto the line's (the em box running from
+/// its centre less half an em to its centre plus half an em above the baseline). Nothing on the
+/// Roman baseline, or for the line's largest characters.
+fn align_shift(g: &SGlyph, a: vectorcraft_doc::CharAlign, line_em: f64) -> f64 {
+    use vectorcraft_doc::CharAlign;
+    let k = match a {
+        CharAlign::RomanBaseline => return 0.0,
+        CharAlign::EmBoxTop => 0.5,
+        CharAlign::EmBoxCenter => 0.0,
+        CharAlign::EmBoxBottom => -0.5,
+    };
+    (g.face.ideographic_centre() + k) * (line_em - glyph_em(g)).max(0.0)
+}
+
 /// The length an upright glyph takes down the column before tracking and justification: its
 /// vertical advance (the font's vertical metrics), else its advance, at least one em.
 fn upright_cell(g: &SGlyph) -> f64 {
@@ -798,7 +821,8 @@ fn japanese_letters_for_the_latin_space_are_kana_kanji_and_marks_not_hangul_or_p
     for c in ['あ', 'カ', '漢', '々', '〆', '〇', 'Ａ'] {
         assert!(is_japanese_letter(c), "{c}");
     }
-    for c in ['한', '。', '「', '・', '、', 'a'] {
+    // Hangul in every form: syllables, compatibility jamo (ㄱ ㅏ), half-width jamo (ﾡ).
+    for c in ['한', 'ㄱ', 'ㅏ', '\u{FFA1}', '。', '「', '・', '、', 'a'] {
         assert!(!is_japanese_letter(c), "{c}");
     }
 }
@@ -1056,6 +1080,8 @@ fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Opt
             };
             let li = cx.out.lines.len();
             let glyph_start = cx.out.glyphs.len();
+            // Character Alignment lines smaller characters up with the line's largest em box.
+            let line_em = sg.get(i..end).map_or(0.0, |line| line.iter().map(glyph_em).fold(0.0, f64::max));
             let mut x_end = start_x;
             // Tab stops are measured from the frame's left edge (point type: the origin).
             let tab_origin = if regions.is_some() { x0 } else { 0.0 };
@@ -1088,7 +1114,8 @@ fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Opt
                         adv += per_gap;
                     }
                 }
-                cx.emit(g, Affine::translate((x, baseline)), Point::new(x, baseline), 0.0, adv, li);
+                let y = baseline - align_shift(g, cx.style_at(g.byte).char_align, line_em);
+                cx.emit(g, Affine::translate((x, y)), Point::new(x, y), 0.0, adv, li);
                 x += adv;
                 if j < trimmed {
                     x_end = x;

crates/text/src/tests.rs

@@ -557,3 +557,31 @@ fn em_box_top_leading_hangs_lines_from_the_line_above() {
         em.lines[1].baseline - em.lines[0].baseline
     );
 }
+
+/// Character Alignment: a 20 pt character next to a 40 pt one lines its em box top, centre or
+/// bottom up with the big one's (the em box from 0.12 em below the baseline to 0.88 em above it,
+/// in fonts without vertical metrics), or stays on the baseline; in vertical type the same across
+/// the column (top → right).
+#[test]
+fn character_alignment_lines_small_characters_up_with_the_largest_em_box() {
+    use vectorcraft_doc::{CharAlign, TextRun};
+    for vertical_type in [false, true] {
+        let place = |a: CharAlign| {
+            let mut t = point("", style(40.0));
+            t.vertical = vertical_type;
+            t.runs = vec![
+                TextRun { text: "大".into(), style: style(40.0) },
+                TextRun { text: "小".into(), style: CharStyle { char_align: a, ..style(20.0) } },
+            ];
+            let l = layout(db(), &t);
+            // How far the small character's origin sits above the big one's (to the right, vertical).
+            let (big, small) = (l.glyphs[0].origin, l.glyphs[1].origin);
+            if vertical_type { small.x - big.x } else { big.y - small.y }
+        };
+        let near = |a: f64, b: f64| (a - b).abs() < 0.01;
+        assert!(near(place(CharAlign::RomanBaseline), 0.0), "vertical {vertical_type}");
+        assert!(near(place(CharAlign::EmBoxTop), 0.88 * 20.0), "top: {}", place(CharAlign::EmBoxTop));
+        assert!(near(place(CharAlign::EmBoxCenter), 0.38 * 20.0), "centre: {}", place(CharAlign::EmBoxCenter));
+        assert!(near(place(CharAlign::EmBoxBottom), -0.12 * 20.0), "bottom: {}", place(CharAlign::EmBoxBottom));
+    }
+}

crates/tools/src/builder.rs

@@ -1,7 +1,8 @@
 //! Shape Builder (Shift+M), Live Paint Bucket (K) and Live Paint Selection (Shift+L).
 //!
 //! The tools only emit commands (`shapeBuilder.merge`, `livePaint.fill`, `livePaint.strokeEdge`,
-//! `select.*`); the planar arrangement comes from `vectorcraft_pathops::regions`.
+//! `select.*`); the planar arrangement comes from `vectorcraft_pathops::shape_builder` (Shape
+//! Builder) and `vectorcraft_pathops::live_paint` (Live Paint).
 //!
 //! **Live Paint groups** are ordinary groups (no special node kind): the group's name starts with
 //! [`LIVE_PAINT_PREFIX`]; its first child is a hidden group named [`SOURCES_NAME`] holding the
@@ -151,6 +152,141 @@ pub fn shapes_for<'a>(doc: &'a Document, roots: &[NodeId]) -> (Vec<po::Shape>, V
     (shapes, used)
 }
 
+/// Shape Builder inputs: [`shapes_for`], with the open subpaths of filled paths closed where that
+/// encloses an area (the fill bounds a region, as if an invisible edge closed it). Unfilled open
+/// paths and straight lines stay open and cut the regions they cross.
+fn shape_builder_shapes<'a>(doc: &'a Document, roots: &[NodeId]) -> (Vec<po::Shape>, Vec<&'a Node>) {
+    let (mut shapes, leaves) = shapes_for(doc, roots);
+    for (s, l) in shapes.iter_mut().zip(&leaves) {
+        if l.appearance.fill_paint().is_none() {
+            continue;
+        }
+        for sp in s.path.subpaths.iter_mut().filter(|sp| !sp.closed) {
+            let mut closed = sp.clone();
+            closed.closed = true;
+            let mut bp = BezPath::new();
+            closed.to_bezpath_into(&mut bp);
+            let size = bp.bounding_box().size();
+            sp.closed = bp.area().abs() > 1e-9 * (size.width * size.width + size.height * size.height);
+        }
+    }
+    (shapes, leaves)
+}
+
+/// A planar-map face with its outline and bounds, ready for hit tests.
+pub type Face = (po::Region, BezPath, Rect);
+
+fn faces_of(regions: Vec<po::Region>) -> Vec<Face> {
+    regions
+        .into_iter()
+        .filter_map(|r| {
+            let bp = r.path.to_bezpath();
+            let b = r.path.bounds()?;
+            Some((r, bp, b))
+        })
+        .collect()
+}
+
+/// The Shape Builder's planar map of a selection.
+#[derive(Default)]
+pub struct BuilderMap {
+    /// The inputs, back → front (see [`po::shape_builder`]).
+    pub shapes: Vec<po::Shape>,
+    pub regions: Vec<Face>,
+    /// Pieces of the unfilled open paths, keyed by input index, with their bounds.
+    pub lines: Vec<(po::Shape, Rect)>,
+}
+
+/// What a Shape Builder gesture touches at a point.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Hit {
+    Region(usize),
+    Line(usize),
+}
+
+impl BuilderMap {
+    /// The map of `roots` (sorted back → front), with the leaves the inputs came from.
+    pub fn new<'a>(doc: &'a Document, roots: &[NodeId]) -> (Self, Vec<&'a Node>) {
+        let (shapes, leaves) = shape_builder_shapes(doc, roots);
+        if shapes.is_empty() {
+            return (Self::default(), leaves);
+        }
+        let (regions, lines) = po::shape_builder(&shapes);
+        let lines = lines.into_iter().filter_map(|l| Some((l.path.bounds()?, l))).map(|(b, l)| (l, b)).collect();
+        (Self { shapes, regions: faces_of(regions), lines }, leaves)
+    }
+
+    /// The region containing `p`.
+    pub fn region_at(&self, p: Point) -> Option<usize> {
+        self.regions.iter().position(|(_, bp, b)| b.contains(p) && bp.winding(p) != 0)
+    }
+
+    /// The line piece nearest `p`, within `tol`.
+    pub fn line_near(&self, p: Point, tol: f64) -> Option<usize> {
+        let mut best: Option<(f64, usize)> = None;
+        for (i, (l, b)) in self.lines.iter().enumerate() {
+            if b.inflate(tol, tol).contains(p)
+                && let Some((.., d)) = l.path.nearest(p)
+                && d <= tol
+                && best.is_none_or(|b| d < b.0)
+            {
+                best = Some((d, i));
+            }
+        }
+        best.map(|b| b.1)
+    }
+
+    /// What a gesture at `p` touches: with `line_tol` (erasing), a line piece that close, else the
+    /// region under it.
+    pub fn hit(&self, p: Point, line_tol: Option<f64>) -> Option<Hit> {
+        line_tol.and_then(|t| self.line_near(p, t)).map(Hit::Line).or_else(|| self.region_at(p).map(Hit::Region))
+    }
+
+    /// Does line piece `i` run between two of `regions` (an edge that merging or deleting them
+    /// removes)?
+    pub fn line_between(&self, i: usize, regions: &[usize]) -> bool {
+        let Some(sp) = self.lines.get(i).and_then(|(l, _)| l.path.subpaths.first()) else { return false };
+        let n = sp.segment_count();
+        if n == 0 {
+            return false;
+        }
+        let c = sp.segment(n / 2);
+        use kurbo::{ParamCurve as _, ParamCurveDeriv as _};
+        let (m, d) = (c.eval(0.5), c.deriv().eval(0.5).to_vec2());
+        let len = d.hypot();
+        if !(len.is_finite() && len > 0.0) {
+            return false;
+        }
+        // A little to each side: inside the faces next to it, which share it exactly.
+        let off = d.turn_90() * (0.05f64.min(0.05 * c.p0.distance(c.p3)).max(1e-6) / len);
+        [m + off, m - off].into_iter().all(|q| self.region_at(q).is_some_and(|r| regions.contains(&r)))
+    }
+}
+
+/// The regions and line pieces a Shape Builder gesture has touched, in the order touched.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Touched {
+    pub regions: Vec<usize>,
+    pub lines: Vec<usize>,
+}
+
+impl Touched {
+    pub fn add(&mut self, hit: Option<Hit>) {
+        let (list, i) = match hit {
+            Some(Hit::Region(i)) => (&mut self.regions, i),
+            Some(Hit::Line(i)) => (&mut self.lines, i),
+            None => return,
+        };
+        if !list.contains(&i) {
+            list.push(i);
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.regions.is_empty() && self.lines.is_empty()
+    }
+}
+
 /// Selected roots sorted back → front in document order.
 pub fn sorted_roots(doc: &Document, ids: &[NodeId]) -> Vec<NodeId> {
     let mut v: Vec<(Vec<usize>, NodeId)> = ids.iter().filter_map(|id| doc.index_path(*id).map(|p| (p, *id))).collect();
@@ -238,13 +374,12 @@ pub fn hatch(path: &BezPath, gap: f64) -> BezPath {
     out
 }
 
-/// Regions of the current selection, cached by document identity and selection.
+/// The planar map of the current selection, cached by document identity and selection.
 #[derive(Default)]
 struct RegionCache {
     key: Option<(usize, Vec<NodeId>)>,
-    regions: Vec<(po::Region, BezPath, Rect)>,
-    /// Live Paint faces (every path an edge, open ones included) rather than Shape Builder
-    /// regions (the filled areas of the shapes).
+    map: BuilderMap,
+    /// Live Paint faces (every path an edge, filled or not) rather than Shape Builder regions.
     live: bool,
 }
 
@@ -252,58 +387,57 @@ impl RegionCache {
     fn live_paint() -> Self {
         Self { live: true, ..Default::default() }
     }
-    fn get(&mut self, cx: &ToolContext) -> &[(po::Region, BezPath, Rect)] {
+    fn get(&mut self, cx: &ToolContext) -> &BuilderMap {
         let key = (cx.doc as *const Document as usize, cx.selection.objects.clone());
         if self.key.as_ref() != Some(&key) {
             let roots = sorted_roots(cx.doc, &cx.selection.objects);
-            let (shapes, _) = shapes_for(cx.doc, &roots);
-            self.regions = if shapes.is_empty() {
-                vec![]
+            self.map = if self.live {
+                let (shapes, _) = shapes_for(cx.doc, &roots);
+                let regions = if shapes.is_empty() { vec![] } else { faces_of(po::live_paint(&shapes).0) };
+                BuilderMap { regions, ..Default::default() }
             } else {
-                let regions = if self.live { po::live_paint(&shapes).0 } else { po::regions(&shapes) };
-                regions
-                    .into_iter()
-                    .filter_map(|r| {
-                        let bp = r.path.to_bezpath();
-                        let b = r.path.bounds()?;
-                        Some((r, bp, b))
-                    })
-                    .collect()
+                BuilderMap::new(cx.doc, &roots).0
             };
             self.key = Some(key);
         }
-        &self.regions
+        &self.map
     }
     fn at(&mut self, cx: &ToolContext, p: Point) -> Option<usize> {
-        self.get(cx).iter().position(|(_, bp, b)| b.contains(p) && bp.winding(p) != 0)
+        self.get(cx).region_at(p)
     }
 }
 
 // ---------- Shape Builder ----------
 
-/// Shape Builder tool: drag across regions to merge them, Alt-drag to delete them.
+/// Shape Builder tool: drag across regions to merge them, Alt-drag to delete them (and the pieces
+/// of open paths it passes over).
 #[derive(Default)]
 pub struct ShapeBuilderTool {
     cache: RegionCache,
-    hover: Option<usize>,
+    hover: Option<Hit>,
     points: Vec<Point>,
-    touched: Vec<usize>,
+    touched: Touched,
     dragging: bool,
     alt: bool,
 }
 
+/// How close (screen px) the pointer must come to a line piece to delete it.
+const LINE_TOL_PX: f64 = 4.0;
+
 impl ShapeBuilderTool {
+    fn line_tol(cx: &ToolContext, alt: bool) -> Option<f64> {
+        alt.then(|| cx.tol(LINE_TOL_PX))
+    }
+
     fn touch(&mut self, cx: &ToolContext, from: Option<Point>, to: Point) {
         let pts = match from {
             Some(a) => sample_polyline(&[a, to], cx.tol(2.0)),
             None => vec![to],
         };
+        let tol = Self::line_tol(cx, self.alt);
         for p in pts {
-            if let Some(i) = self.cache.at(cx, p)
-                && !self.touched.contains(&i)
-            {
-                self.touched.push(i);
-            }
+            let hit = self.cache.get(cx).hit(p, tol);
+            self.touched.add(hit);
         }
     }
 }
@@ -317,7 +451,7 @@ impl Tool for ShapeBuilderTool {
         let p = ev.pos;
         match ev.kind {
             PointerKind::Move => {
-                self.hover = self.cache.at(cx, p);
+                self.hover = self.cache.get(cx).hit(p, Self::line_tol(cx, ev.mods.alt));
                 vec![]
             }
             PointerKind::Down => {
@@ -327,7 +461,7 @@ impl Tool for ShapeBuilderTool {
                 self.dragging = true;
                 self.alt = ev.mods.alt;
                 self.points = vec![p];
-                self.touched.clear();
+                self.touched = Touched::default();
                 self.touch(cx, None, p);
                 vec![]
             }
@@ -353,7 +487,12 @@ impl Tool for ShapeBuilderTool {
                 self.cache.key = None;
                 let roots = sorted_roots(cx.doc, &cx.selection.objects);
                 let pts: Vec<Value> = points.iter().map(|q| json!([q.x, q.y])).collect();
-                vec![Action::Exec("shapeBuilder.merge".into(), json!({ "ids": json_ids(&roots), "points": pts, "erase": self.alt || ev.mods.alt }))]
+                let erase = self.alt || ev.mods.alt;
+                let mut params = json!({ "ids": json_ids(&roots), "points": pts, "erase": erase });
+                if let Some(t) = Self::line_tol(cx, erase) {
+                    params["tolerance"] = json!(t);
+                }
+                vec![Action::Exec("shapeBuilder.merge".into(), params)]
             }
             _ => vec![],
         }
@@ -361,13 +500,26 @@ impl Tool for ShapeBuilderTool {
 
     fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
         let mut out = vec![];
-        let regions = &self.cache.regions;
+        let map = &self.cache.map;
         let color = if self.dragging && self.alt { HIGHLIGHT_RED } else { HATCH };
-        let show: Vec<usize> = if self.dragging { self.touched.clone() } else { self.hover.into_iter().collect() };
-        for i in show {
-            if let Some((_, bp, _)) = regions.get(i) {
-                out.push(Overlay::Path { path: hatch(bp, cx.tol(4.0)), color, width: 1.0, dashed: false });
-                out.push(Overlay::Path { path: bp.clone(), color, width: 1.0, dashed: false });
+        let show: Vec<Hit> = if self.dragging {
+            self.touched.regions.iter().map(|&i| Hit::Region(i)).chain(self.touched.lines.iter().map(|&i| Hit::Line(i))).collect()
+        } else {
+            self.hover.into_iter().collect()
+        };
+        for hit in show {
+            match hit {
+                Hit::Region(i) => {
+                    if let Some((_, bp, _)) = map.regions.get(i) {
+                        out.push(Overlay::Path { path: hatch(bp, cx.tol(4.0)), color, width: 1.0, dashed: false });
+                        out.push(Overlay::Path { path: bp.clone(), color, width: 1.0, dashed: false });
+                    }
+                }
+                Hit::Line(i) => {
+                    if let Some((l, _)) = map.lines.get(i) {
+                        out.push(Overlay::Path { path: l.path.to_bezpath(), color: HIGHLIGHT_RED, width: 3.0, dashed: false });
+                    }
+                }
             }
         }
         if self.dragging && self.points.len() > 1 {
@@ -434,6 +586,7 @@ fn lp_overlays(h: &LpHover, cache: &RegionCache) -> Vec<Overlay> {
         LpHover::None => vec![],
         LpHover::Part(bp) => vec![Overlay::Path { path: bp.clone(), color: HIGHLIGHT_RED, width: 4.0, dashed: false }],
         LpHover::Region(i) => cache
+            .map
             .regions
             .get(*i)
             .map(|(_, bp, _)| vec![Overlay::Path { path: bp.clone(), color: HIGHLIGHT_RED, width: 4.0, dashed: false }])
@@ -623,7 +776,7 @@ mod tests {
         let mut t = ShapeBuilderTool::default();
         t.pointer(&cx, &ev(PointerKind::Down, 25.0, 50.0));
         t.pointer(&cx, &ev(PointerKind::Drag, 75.0, 50.0));
-        assert_eq!(t.touched.len(), 2);
+        assert_eq!(t.touched.regions.len(), 2);
         assert!(t.busy());
         let acts = t.pointer(&cx, &ev(PointerKind::Up, 75.0, 50.0));
         let Action::Exec(id, v) = &acts[0] else { panic!("{acts:?}") };

crates/tools/src/corners.rs

@@ -1,12 +1,19 @@
-//! Live Corners: the widgets inside each corner of a selected live rectangle. Dragging one rounds
-//! (or sharpens) all four corners together. The Selection and Direct Selection tools share this,
-//! and the canvas draws the widgets from the same geometry.
+//! Live Corners: the widgets inside the corners of a selected live rectangle. Dragging one rounds
+//! (or sharpens) the corners whose widgets show together: all four when the whole shape is
+//! selected, those with a selected anchor when Direct Selection picked some. Alt-clicking a widget
+//! cycles their corner kind (round, inverted round, chamfer); double-clicking one opens the
+//! Corners dialog. The Selection and Direct Selection tools share this, and the canvas draws the
+//! widgets from the same geometry.
 
-use serde_json::json;
+use serde_json::{Map, Value, json};
 use vectorcraft_doc::{Document, LiveShape, NodeId, NodeKind, Selection};
+use vectorcraft_geom::shapes::CornerKind;
 use vectorcraft_geom::{Affine, Point, Vec2};
 
-use crate::{Action, Overlay, ToolContext};
+use crate::{Action, Overlay, PointerEvent, ToolContext};
+
+/// The dialog a double-click on a corner widget opens: `{id, corners}`.
+pub const DIALOG: &str = "corners";
 
 /// Widgets sit at least this far inside their corner (screen px), further in once the radius is.
 const MIN_INSET_PX: f64 = 10.0;
@@ -24,9 +31,12 @@ pub struct CornerWidgets {
     w: f64,
     h: f64,
     radii: [f64; 4],
+    kinds: [CornerKind; 4],
     xf: Affine,
     /// Widget centres in document coordinates, in radii order.
     pub points: [Point; 4],
+    /// The corners whose widgets show (and which a drag edits).
+    pub shown: [bool; 4],
 }
 
 impl CornerWidgets {
@@ -36,10 +46,9 @@ impl CornerWidgets {
         if !doc.is_editable(id) {
             return None;
         }
-        let Some(NodeKind::Path { live: Some(LiveShape::Rectangle { w, h, radii, xf }), .. }) = doc.node(id).map(|n| &n.kind) else {
-            return None;
-        };
-        let (w, h, radii, xf) = (*w, *h, *radii, *xf);
+        let Some(NodeKind::Path { live: Some(live), .. }) = doc.node(id).map(|n| &n.kind) else { return None };
+        let LiveShape::Rectangle { w, h, radii, kinds, xf } = live else { return None };
+        let (w, h, radii, kinds, xf) = (*w, *h, *radii, *kinds, *xf);
         // Screen pixels per shape unit along each side (the shape may be scaled or skewed).
         let c = xf.as_coeffs();
         let (px, py) = (Vec2::new(c[0], c[1]).hypot() * zoom, Vec2::new(c[2], c[3]).hypot() * zoom);
@@ -52,7 +61,22 @@ impl CornerWidgets {
             let iy = radii[k].max(MIN_INSET_PX / py).min(h / 2.0);
             xf * Point::new(fx * w + sx * ix, fy * h + sy * iy)
         });
-        Some(Self { id, w, h, radii, xf, points })
+        Some(Self { id, w, h, radii, kinds, xf, points, shown: live.picked_corners(selection.partial(id)) })
+    }
+
+    /// Selection & Anchor Display → Hide Corner Widget for angles greater than: the widgets of
+    /// corners wider than `max` degrees (a skewed rectangle's obtuse ones) hide; none if all do.
+    pub fn within_angle(mut self, max: f64) -> Option<Self> {
+        // The angle between the shape's sides where they meet at the top-left corner; the
+        // top-right and bottom-left corners are its supplement.
+        let c = self.xf.as_coeffs();
+        let (u, v) = (Vec2::new(c[0], c[1]), Vec2::new(c[2], c[3]));
+        let a = u.cross(v).abs().atan2(u.dot(v)).to_degrees();
+        for (k, shown) in self.shown.iter_mut().enumerate() {
+            let angle = if k % 2 == 0 { a } else { 180.0 - a };
+            *shown &= angle <= max + 1e-9;
+        }
+        self.shown.contains(&true).then_some(self)
     }
 
     /// The widgets the active tool can drag (View → Show Corner Widget on).
@@ -60,12 +84,35 @@ impl CornerWidgets {
         if !cx.corner_widgets {
             return None;
         }
-        Self::of(cx.doc, cx.selection, cx.zoom)
+        Self::of(cx.doc, cx.selection, cx.zoom)?.within_angle(cx.corner_widget_max_angle)
     }
 
-    /// Index of the widget nearest to `p` within `tol` (document units).
+    /// The centres of the widgets that show.
+    pub fn visible(&self) -> impl Iterator<Item = Point> + '_ {
+        self.points.iter().zip(self.shown).filter(|(_, on)| *on).map(|(p, _)| *p)
+    }
+
+    /// The indices of the shown corners.
+    fn shown_indices(&self) -> Value {
+        (0..4).filter(|k| self.shown[*k]).collect()
+    }
+
+    /// Index of the shown widget nearest to `p` within `tol` (document units).
     pub fn hit(&self, p: Point, tol: f64) -> Option<usize> {
-        (0..4).filter(|k| self.points[*k].distance(p) <= tol).min_by(|a, b| self.points[*a].distance(p).total_cmp(&self.points[*b].distance(p)))
+        let d = |k: &usize| self.points[*k].distance(p);
+        (0..4).filter(|k| self.shown[*k] && d(k) <= tol).min_by(|a, b| d(a).total_cmp(&d(b)))
+    }
+
+    /// `object.setLiveShape` params setting `key` on the shown corners (all four unless some are
+    /// hidden, which `corners` then leaves out).
+    fn command(&self, key: &str, value: Value) -> Value {
+        let mut p = Map::new();
+        p.insert("id".into(), json!(self.id.0));
+        p.insert(key.into(), value);
+        if self.shown != [true; 4] {
+            p.insert("corners".into(), self.shown_indices());
+        }
+        Value::Object(p)
     }
 }
 
@@ -74,23 +121,32 @@ pub fn over_widget(cx: &ToolContext, p: Point) -> bool {
     CornerWidgets::for_tool(cx).and_then(|w| w.hit(p, cx.tol(5.0))).is_some()
 }
 
-/// Dragging a corner widget: the radius follows the pointer along the corner's diagonal.
+/// A double-click on a corner widget opens the Corners dialog for the shown corners.
+pub fn double_click(cx: &ToolContext, p: Point) -> Option<Action> {
+    let w = CornerWidgets::for_tool(cx)?;
+    w.hit(p, cx.tol(5.0))?;
+    Some(Action::Dialog(DIALOG.into(), json!({ "id": w.id.0, "corners": w.shown_indices() })))
+}
+
+/// Dragging a corner widget: the radius follows the pointer along the corner's diagonal. An
+/// Alt-click (no drag) cycles the corner kind instead.
 #[derive(Clone, Copy, Debug)]
 pub struct CornerDrag {
     widgets: CornerWidgets,
     corner: usize,
     start: Point,
     began: bool,
+    alt: bool,
     radius: f64,
     at: Point,
 }
 
 impl CornerDrag {
-    /// Start a drag when `p` is on a widget of the selection.
-    pub fn hit(cx: &ToolContext, p: Point) -> Option<Self> {
-        let widgets = CornerWidgets::for_tool(cx)?;
+    /// Start a drag when the press `ev` is on a widget of the selection.
+    pub fn hit(cx: &ToolContext, ev: &PointerEvent) -> Option<Self> {
+        let (widgets, p) = (CornerWidgets::for_tool(cx)?, ev.pos);
         let corner = widgets.hit(p, cx.tol(5.0))?;
-        Some(Self { widgets, corner, start: p, began: false, radius: widgets.radii[corner], at: p })
+        Some(Self { widgets, corner, start: p, began: false, alt: ev.mods.alt, radius: widgets.radii[corner], at: p })
     }
 
     /// The start radius (as drawn: no larger than fits) plus the pointer's travel along the
@@ -115,12 +171,19 @@ impl CornerDrag {
         }
         self.radius = self.radius_at(p);
         self.at = p;
-        out.push(Action::Preview("object.setLiveShape".into(), json!({ "id": self.widgets.id.0, "radius": self.radius })));
+        out.push(Action::Preview("object.setLiveShape".into(), self.widgets.command("radius", json!(self.radius))));
         out
     }
 
     pub fn finish(self) -> Vec<Action> {
-        if self.began { vec![Action::Commit] } else { vec![] }
+        if self.began {
+            vec![Action::Commit]
+        } else if self.alt {
+            let kind = self.widgets.kinds[self.corner].next();
+            vec![Action::Exec("object.setLiveShape".into(), self.widgets.command("kind", json!(kind)))]
+        } else {
+            vec![]
+        }
     }
 
     /// The radius readout next to the pointer.
@@ -136,7 +199,7 @@ impl CornerDrag {
 mod tests {
     use super::*;
     use crate::testutil::*;
-    use crate::{PointerEvent, PointerKind};
+    use crate::{Mods, PointerKind};
     use vectorcraft_doc::{Appearance, Node};
 
     /// A live 100 × 100 rectangle at (100, 100) with corner radius `r`.
@@ -144,7 +207,7 @@ mod tests {
         let mut d = Document::new(500.0, 500.0);
         let l = d.layers[0].id;
         let id = d.alloc_id();
-        let live = LiveShape::Rectangle { w: 100.0, h: 100.0, radii: [r; 4], xf };
+        let live = LiveShape::Rectangle { w: 100.0, h: 100.0, radii: [r; 4], kinds: Default::default(), xf };
         let mut n = Node::path(id, live.to_path(), Appearance::default_art());
         if let NodeKind::Path { live: slot, .. } = &mut n.kind {
             *slot = Some(live);
@@ -221,6 +284,76 @@ mod tests {
         assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 190.0, 110.0)).is_empty());
     }
 
+    #[test]
+    fn direct_selected_corners_show_their_widgets_alone_and_round_alone() {
+        let (d, id) = live_rect(0.0, Affine::translate((100.0, 100.0)));
+        // Direct Selection picked the bottom-right anchor.
+        let mut s = selected(id);
+        s.anchors.insert(id, [(0, 2)].into());
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let w = CornerWidgets::of(&d, &s, 1.0).unwrap();
+        assert_eq!(w.shown, [false, false, true, false]);
+        assert_eq!(w.visible().collect::<Vec<_>>(), [Point::new(190.0, 190.0)]);
+        assert!(!over_widget(&cx, Point::new(110.0, 110.0)), "the other corners hide theirs");
+        let mut t = crate::create("directSelection");
+        assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 190.0, 191.0)).is_empty());
+        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 175.0, 176.0));
+        assert_eq!(a[0], Action::Begin("Corner Radius".into()));
+        assert_eq!(a[1], Action::Preview("object.setLiveShape".into(), json!({"id": id.0, "radius": 15.0, "corners": [2]})));
+        assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 175.0, 176.0)), vec![Action::Commit]);
+    }
+
+    #[test]
+    fn alt_click_cycles_the_kind_and_double_click_opens_the_dialog() {
+        let (d, id) = live_rect(10.0, Affine::translate((100.0, 100.0)));
+        let p = paint();
+        let alt = Mods { alt: true, ..Mods::default() };
+        let whole = selected(id);
+        let mut part = selected(id);
+        part.anchors.insert(id, [(0, 0), (0, 7)].into());
+        for (s, extra) in [(&whole, json!({})), (&part, json!({"corners": [0]}))] {
+            let cx = cx(&d, s, &p);
+            let mut want = json!({"id": id.0, "kind": "invertedRound"});
+            want.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
+            for tool in ["selection", "directSelection"] {
+                let mut t = crate::create(tool);
+                assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 110.0, 110.0).with_mods(alt)).is_empty());
+                let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 110.0, 110.0).with_mods(alt));
+                assert_eq!(a, vec![Action::Exec("object.setLiveShape".into(), want.clone())], "{tool}");
+            }
+        }
+        // A double-click on a widget opens Corners for the shown corners; elsewhere it doesn't.
+        let cx1 = cx(&d, &part, &p);
+        let a = crate::create("directSelection").pointer(&cx1, &PointerEvent::new(PointerKind::DoubleClick, 110.0, 110.0));
+        assert_eq!(a, vec![Action::Dialog(DIALOG.into(), json!({"id": id.0, "corners": [0]}))]);
+        let cx2 = cx(&d, &whole, &p);
+        let a = crate::create("selection").pointer(&cx2, &PointerEvent::new(PointerKind::DoubleClick, 190.0, 110.0));
+        assert_eq!(a, vec![Action::Dialog(DIALOG.into(), json!({"id": id.0, "corners": [0, 1, 2, 3]}))]);
+        assert!(crate::create("selection").pointer(&cx2, &PointerEvent::new(PointerKind::DoubleClick, 150.0, 150.0)).is_empty());
+    }
+
+    /// Hide Corner Widget for angles greater than (#394): a rectangle's right angles hide below
+    /// 90°; sheared, only its acute corners keep their widgets.
+    #[test]
+    fn corners_wider_than_the_preference_hide_their_widgets() {
+        let (d, id) = live_rect(0.0, Affine::translate((100.0, 100.0)));
+        let w = CornerWidgets::of(&d, &selected(id), 1.0).unwrap();
+        assert_eq!(w.within_angle(177.0).map(|w| w.shown), Some([true; 4]));
+        assert_eq!(w.within_angle(90.0).map(|w| w.shown), Some([true; 4]));
+        assert!(w.within_angle(89.0).is_none());
+        // Sheared by 30°: 60° at the top-left and bottom-right corners, 120° at the others.
+        let shear = Affine::translate((100.0, 100.0)) * Affine::new([1.0, 0.0, 30f64.to_radians().tan(), 1.0, 0.0, 0.0]);
+        let (d, id) = live_rect(0.0, shear);
+        let w = CornerWidgets::of(&d, &selected(id), 1.0).unwrap();
+        assert_eq!(w.within_angle(100.0).map(|w| w.shown), Some([true, false, true, false]));
+        let s = selected(id);
+        let p = paint();
+        let c = ToolContext { corner_widget_max_angle: 100.0, ..cx(&d, &s, &p) };
+        assert!(over_widget(&c, w.points[0]));
+        assert!(!over_widget(&c, w.points[1]), "the 120° corner's widget is hidden");
+    }
+
     #[test]
     fn widgets_off_or_elsewhere_keep_the_tools_behaviour() {
         let (d, id) = live_rect(0.0, Affine::translate((100.0, 100.0)));

crates/tools/src/direct.rs

@@ -3,13 +3,15 @@
 //! Direct Selection: click an anchor to select it (Shift toggles), click a segment to select the
 //! path's anchors on that segment, drag to move selected anchors, drag a direction handle to
 //! reshape (Shift keeps it at 45° steps round its anchor, Alt moves it alone; smart guides snap
-//! it), marquee to select anchors, drag a live rectangle's corner widget to round its corners.
+//! it), marquee to select anchors, drag a live rectangle's corner widget to round its corners
+//! (the selected ones when anchors are selected; Alt-click cycles their kind, double-click opens
+//! the Corners dialog).
 //! Group Selection: click selects the leaf; each further click on it adds the next enclosing group.
-//! Both pick the key objects of a blend. Direct Selection also edits a blend's spine: drag its
-//! points (a key object on a point moves with it) and, once a point is clicked, its handles; and
-//! the points of selected gradient meshes and mesh envelopes and their handles ([`MeshEdit`]).
-//! Dragging a corner or an edge of area type's frame reshapes the type area (`text.reshapeArea`):
-//! the text reflows at its size.
+//! Both pick the key objects of a blend, and click or drag ruler guides ([`crate::rulerguide`]).
+//! Direct Selection also edits a blend's spine: drag its points (a key object on a point moves
+//! with it) and, once a point is clicked, its handles; and the points of selected gradient meshes
+//! and mesh envelopes and their handles ([`MeshEdit`]). Dragging a corner or an edge of area
+//! type's frame reshapes the type area (`text.reshapeArea`): the text reflows at its size.
 //!
 //! A press on the stroke of a path that isn't selected as a whole selects that segment's two anchors
 //! (the fill, or Alt, selects the whole path); dragging the segment bends it if it's curved, else
@@ -23,8 +25,9 @@ use vectorcraft_doc::{AnchorRef, Node, NodeId, NodeKind};
 use vectorcraft_geom::{PathData, Point, Rect};
 
 use crate::bbox::move_delta;
-use crate::corners::{CornerDrag, over_widget};
+use crate::corners::{self, CornerDrag, over_widget};
 use crate::meshedit::MeshEdit;
+use crate::rulerguide::GuideEdit;
 use crate::select::{is_area_type, matrix_json};
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext};
 
@@ -93,11 +96,14 @@ pub struct DirectSelectionTool {
     mesh: MeshEdit,
     /// Smart guides of the handle being dragged.
     guides: Vec<Overlay>,
+    /// The anchor under the pointer (Highlight anchors on mouse over): its path, where it is.
+    hover: Option<(NodeId, Point)>,
+    guide: GuideEdit,
 }
 
 impl DirectSelectionTool {
     pub fn new(group: bool) -> Self {
-        Self { group, state: State::Idle, spine: None, mesh: MeshEdit::default(), guides: vec![] }
+        Self { group, state: State::Idle, spine: None, mesh: MeshEdit::default(), guides: vec![], hover: None, guide: GuideEdit::default() }
     }
 }
 
@@ -183,8 +189,17 @@ fn hit_frame_edge(cx: &ToolContext, p: Point, tol: f64) -> Option<(NodeId, Vec<A
     })
 }
 
+/// Selection & Anchor Display → Show handles when multiple anchors are selected: off, handles show
+/// (and drag) only while a single anchor is selected.
+pub fn handles_shown(selection: &vectorcraft_doc::Selection, multiple: bool) -> bool {
+    multiple || selection.anchors.values().map(|set| set.len()).sum::<usize>() <= 1
+}
+
 /// Direction handle of a partially selected anchor under `p`: (id, si, ai, is_out).
 fn hit_handle(cx: &ToolContext, p: Point, tol: f64) -> Option<(NodeId, usize, usize, bool)> {
+    if !handles_shown(cx.selection, cx.handles_multiple) {
+        return None;
+    }
     for (id, set) in &cx.selection.anchors {
         let Some(pd) = cx.doc.node(*id).and_then(|n| n.path_data()) else { continue };
         for &(si, ai) in set {
@@ -230,13 +245,20 @@ impl Tool for DirectSelectionTool {
         if self.group { "groupSelection" } else { "directSelection" }
     }
     fn busy(&self) -> bool {
-        !matches!(self.state, State::Idle)
+        !matches!(self.state, State::Idle) || self.guide.busy()
     }
     fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
+        if let Some(out) = self.guide.pointer(cx, ev) {
+            return out;
+        }
         let p = ev.pos;
-        let tol = cx.tol(4.0);
+        let tol = cx.pick_tol();
         match (ev.kind, self.state.clone()) {
             (PointerKind::Down, _) if self.group => {
+                if let Some(out) = self.guide.press(cx, ev) {
+                    self.state = State::Idle;
+                    return out;
+                }
                 let Some(h) = hit_test(cx.doc, p, cx.hit_options()) else {
                     self.state = State::Marquee { start: p, cur: p, add: ev.mods.shift };
                     return vec![];
@@ -257,8 +279,13 @@ impl Tool for DirectSelectionTool {
                     vec![Action::Exec("select.set".into(), json!({"ids": [target.0]}))]
                 }
             }
+            (PointerKind::DoubleClick, _) if !self.group => corners::double_click(cx, p).into_iter().collect(),
+            (PointerKind::Move, State::Idle) => {
+                self.hover = if self.group || !cx.highlight_anchors { None } else { hovered_anchor(cx, p) };
+                vec![]
+            }
             (PointerKind::Down, _) => {
-                if let Some(c) = CornerDrag::hit(cx, p) {
+                if let Some(c) = CornerDrag::hit(cx, ev) {
                     self.state = State::Corner(c);
                     return vec![];
                 }
@@ -300,6 +327,10 @@ impl Tool for DirectSelectionTool {
                 if let Some((id, anchors)) = hit_frame_edge(cx, p, tol) {
                     return self.press_type_area(cx, id, anchors, p, ev.mods.shift);
                 }
+                if let Some(out) = self.guide.press(cx, ev) {
+                    self.state = State::Idle;
+                    return out;
+                }
                 if let Some(h) = hit_test(cx.doc, p, cx.hit_options()) {
                     // A segment of a path that isn't selected as a whole: its two anchors get
                     // selected, and dragging it reshapes it if it's curved, else moves it. Alt picks
@@ -489,6 +520,10 @@ impl Tool for DirectSelectionTool {
                 if matches!(self.state, State::Handle { .. }) {
                     out.extend(self.guides.iter().cloned());
                 }
+                if let Some((id, p)) = self.hover.filter(|_| matches!(self.state, State::Idle)) {
+                    out.push(Overlay::Anchor { p, color: cx.doc.layer_color(id), filled: false, size: 8.0 });
+                }
+                out.extend(self.guide.overlays(cx));
                 out
             }
         }
@@ -497,10 +532,22 @@ impl Tool for DirectSelectionTool {
         if !self.group && (matches!(self.state, State::Corner(_)) || over_widget(cx, p)) {
             return Cursor::CornerRadius;
         }
-        Cursor::ArrowHollow
+        // A press on the highlighted anchor picks it, not the guide.
+        self.guide.cursor(cx, p).filter(|_| self.hover.is_none() || self.guide.busy()).unwrap_or(Cursor::ArrowHollow)
     }
 }
 
+/// The anchor within the selection tolerance of `p`, of a selected path or the path under `p`:
+/// what Highlight anchors on mouse over marks (a press there picks it).
+fn hovered_anchor(cx: &ToolContext, p: Point) -> Option<(NodeId, Point)> {
+    let under = hit_test(cx.doc, p, cx.hit_options()).map(|h| h.leaf);
+    let tol = cx.pick_tol();
+    cx.selection.objects.iter().copied().chain(under).find_map(|id| {
+        let path = cx.doc.node(id).and_then(editable_path)?;
+        path.anchors().find(|(_, _, a)| a.p.distance(p) <= tol).map(|(_, _, a)| (id, a.p))
+    })
+}
+
 /// The frame anchors of the selected area type, which Direct Selection drags.
 fn frame_overlays(cx: &ToolContext) -> Vec<Overlay> {
     let mut out = vec![];
@@ -547,6 +594,26 @@ mod tests {
     use crate::testutil::*;
     use vectorcraft_doc::Selection;
 
+    /// #414: a ruler guide is picked over the art, but an anchor on it is picked first.
+    #[test]
+    fn direct_and_group_selection_pick_ruler_guides() {
+        let (mut d, id) = doc_with_rect();
+        d.guides.push(vectorcraft_doc::Guide { vertical: true, pos: 100.0 });
+        let (s, p) = (Selection::default(), paint());
+        let c = cx(&d, &s, &p);
+        let down = |t: &mut DirectSelectionTool, y: f64| t.pointer(&c, &PointerEvent::new(PointerKind::Down, 100.0, y));
+        let pick = vec![Action::Exec("guide.select".into(), json!({"indexes": [0]}))];
+        for group in [false, true] {
+            let mut t = DirectSelectionTool::new(group);
+            assert_eq!(down(&mut t, 150.0), pick, "on the rect's edge (group: {group})");
+            assert!(t.busy());
+            t.pointer(&c, &PointerEvent::new(PointerKind::Up, 100.0, 150.0));
+            assert_eq!(t.cursor(&c, Point::new(101.0, 300.0), Mods::default()), Cursor::ResizeH);
+        }
+        let mut t = DirectSelectionTool::new(false);
+        assert_eq!(down(&mut t, 100.0), vec![Action::Exec("select.anchors".into(), json!({"id": id.0, "anchors": [[0, 0]], "mode": "set"}))]);
+    }
+
     /// A blend of two 20 pt squares centred on (110, 310) and (210, 310), selected.
     fn blend_doc() -> (vectorcraft_doc::Document, NodeId, NodeId) {
         let (mut d, _) = doc_with_rect();
@@ -561,6 +628,30 @@ mod tests {
         (d, g, k1)
     }
 
+    /// Highlight anchors on mouse over (#394): the anchor under the pointer, within the selection
+    /// tolerance, shows enlarged; none with the preference off or away from anchors.
+    #[test]
+    fn the_anchor_under_the_pointer_is_highlighted() {
+        let (d, id) = doc_with_rect();
+        let s = Selection::default();
+        let p = paint();
+        let big = |t: &DirectSelectionTool, cx: &ToolContext| {
+            t.overlays(cx).into_iter().find_map(|o| match o {
+                Overlay::Anchor { p, size, .. } if size > 5.0 => Some(p),
+                _ => None,
+            })
+        };
+        let mut t = DirectSelectionTool::new(false);
+        let on = cx(&d, &s, &p);
+        t.pointer(&on, &PointerEvent::new(PointerKind::Move, 102.0, 101.0));
+        assert_eq!(big(&t, &on), Some(Point::new(100.0, 100.0)), "the corner of {id:?}");
+        t.pointer(&on, &PointerEvent::new(PointerKind::Move, 150.0, 100.0));
+        assert_eq!(big(&t, &on), None, "mid-segment: no anchor");
+        let off = ToolContext { highlight_anchors: false, ..cx(&d, &s, &p) };
+        t.pointer(&off, &PointerEvent::new(PointerKind::Move, 102.0, 101.0));
+        assert_eq!(big(&t, &off), None, "off");
+    }
+
     #[test]
     fn dragging_a_spine_point_moves_it() {
         let (d, g, _) = blend_doc();

crates/tools/src/draw2/curvature.rs

@@ -3,7 +3,7 @@
 //! Each click adds a point and the path curves smoothly through all points. Alt-click or
 //! double-click a point toggles it between smooth and corner; drag a point to move it; click the
 //! first point to close; Backspace/Delete removes the last touched point; Esc/Enter ends the path.
-//! A rubber band shows the curve to the cursor.
+//! A rubber band shows the curve to the cursor (Enable Rubber Band for Curvature Tool).
 
 use serde_json::{Value, json};
 use vectorcraft_doc::NodeId;
@@ -167,7 +167,8 @@ impl Tool for CurvatureTool {
             return vec![];
         }
         let mut o = vec![];
-        if !self.closed
+        if cx.curvature_rubber_band
+            && !self.closed
             && self.drag.is_none()
             && let Some(h) = self.hover
         {

crates/tools/src/guides.rs

@@ -17,6 +17,7 @@ enum Kind {
     Edge,
     Artboard,
     Bleed,
+    Guide,
 }
 
 impl Kind {
@@ -27,6 +28,7 @@ impl Kind {
             Kind::Edge => "path",
             Kind::Artboard => "artboard",
             Kind::Bleed => "bleed",
+            Kind::Guide => "guide",
         }
     }
 }
@@ -95,6 +97,27 @@ impl Targets {
         t
     }
 
+    /// View → Snap to Point: only these targets' anchors pull, and the ruler guides (shown and
+    /// unlocked, as the selection tools pick them) pull the pointer into line.
+    fn for_snap_to_point(mut self, cx: &ToolContext) -> Self {
+        self.points.retain(|(_, k)| *k == Kind::Anchor);
+        self.xs.clear();
+        self.ys.clear();
+        if cx.guides {
+            for g in &cx.doc.guides {
+                let (lines, at) = if g.vertical { (&mut self.xs, Point::new(g.pos, 0.0)) } else { (&mut self.ys, Point::new(0.0, g.pos)) };
+                lines.push((g.pos, at, Kind::Guide));
+            }
+        }
+        self
+    }
+
+    /// What a dragged selection's grabbed point snaps to with View → Snap to Point and Smart
+    /// Guides off: the anchors of the art but `exclude` and the ruler guides.
+    pub fn snap_to_point(cx: &ToolContext, exclude: &[NodeId]) -> Option<Self> {
+        (cx.snap_to_point && !cx.smart_guides).then(|| Self::collect(cx.doc, exclude, None).for_snap_to_point(cx))
+    }
+
     /// Anchors and centres of the visible leaves under `roots` (the roots included) whose bounds
     /// reach into `near`.
     fn points_near(doc: &Document, roots: &[NodeId], near: Rect) -> Self {
@@ -142,6 +165,23 @@ impl Targets {
         (out, ov)
     }
 
+    /// Snap a ruler guide at `v` (the x of a vertical one, the y of a horizontal one) into line
+    /// with the nearest edge, centre or anchor within `tol`: where it goes, and a label there.
+    pub fn snap_guide(&self, vertical: bool, v: f64, tol: f64) -> (f64, Vec<Overlay>) {
+        let along = |q: &Point| if vertical { q.x } else { q.y };
+        let lines = if vertical { &self.xs } else { &self.ys };
+        let best = lines
+            .iter()
+            .map(|(t, from, k)| (*t, *from, *k))
+            .chain(self.points.iter().map(|(q, k)| (along(q), *q, *k)))
+            .filter(|(t, ..)| (t - v).abs() <= tol)
+            .min_by(|a, b| (a.0 - v).abs().total_cmp(&(b.0 - v).abs()));
+        match best {
+            Some((t, from, k)) => (t, vec![Overlay::Label { p: from, text: k.label().into(), color: MAGENTA }]),
+            None => (v, vec![]),
+        }
+    }
+
     /// Snap a dragged point that carries others along at `offsets` (a resize handle and the
     /// bleed edge beyond it): onto an anchor or centre near the point itself, otherwise into line
     /// with targets, each axis on whichever of them comes nearest.
@@ -292,19 +332,22 @@ pub fn snap_draw(cx: &ToolContext, p: Point, exclude: &[NodeId]) -> (Point, Vec<
     snap_with(cx, p, || Targets::collect(cx.doc, exclude, None))
 }
 
-/// Snap `p` to pixels or the grid when they are on, else to the smart guide `targets`.
+/// Snap `p` to pixels or the grid when they are on, else to the smart guide `targets`, else (Snap
+/// to Point) to their anchors and the ruler guides within the Snap to Point distance.
 fn snap_with(cx: &ToolContext, p: Point, targets: impl FnOnce() -> Targets) -> (Point, Vec<Overlay>) {
     if cx.snap_to_pixel {
         return (Point::new(p.x.round(), p.y.round()), vec![]);
     }
     if cx.snap_to_grid {
-        let s = cx.doc.grid.spacing / cx.doc.grid.subdivisions.max(1) as f64;
-        return (vectorcraft_geom::snap::snap_point_to_grid(p, s), vec![]);
+        return (vectorcraft_geom::snap::snap_point_to_grid(p, cx.grid_step()), vec![]);
     }
-    if !cx.smart_guides {
-        return (p, vec![]);
+    if cx.smart_guides {
+        return targets().snap_point(p, cx.tol(5.0));
     }
-    targets().snap_point(p, cx.tol(5.0))
+    if cx.snap_to_point {
+        return targets().for_snap_to_point(cx).snap_point(p, cx.tol(cx.snap_tolerance));
+    }
+    (p, vec![])
 }
 
 /// Where a dragged direction handle of anchor `ai` of subpath `si` of path `id` goes for the
@@ -334,7 +377,7 @@ pub fn snap_pick(cx: &ToolContext, p: Point) -> (Point, Vec<Overlay>) {
     if !(cx.snap_to_point || cx.smart_guides) {
         return (p, vec![]);
     }
-    let tol = cx.tol(5.0);
+    let tol = cx.tol(if cx.smart_guides { 5.0 } else { cx.snap_tolerance });
     let mut roots = cx.selection.objects.clone();
     roots.extend(hit_test(cx.doc, p, HitOptions { tol, ..cx.hit_options() }).map(|h| h.leaf));
     let near = Rect::new(p.x - tol, p.y - tol, p.x + tol, p.y + tol);

crates/tools/src/lib.rs

@@ -23,6 +23,7 @@ pub mod params;
 pub mod pen;
 pub mod place;
 pub mod printtiling;
+pub mod rulerguide;
 pub mod select;
 pub mod settings;
 pub mod shape;
@@ -201,6 +202,13 @@ impl ScreenFrame {
     pub fn at(&self, x: f64, y: f64) -> Point {
         self.origin + self.right * x + self.down * y
     }
+    /// Where the document point `p` is, in screen pixels from the window's top-left corner (the
+    /// inverse of [`Self::at`]); none for a degenerate frame.
+    pub fn to_screen(&self, p: Point) -> Option<(f64, f64)> {
+        let (r, d, v) = (self.right, self.down, p - self.origin);
+        let det = r.x * d.y - d.x * r.y;
+        (det.is_finite() && det.abs() > 1e-12).then(|| ((v.x * d.y - d.x * v.y) / det, (r.x * v.y - v.x * r.y) / det))
+    }
 }
 
 /// Read-only context a tool sees.
@@ -213,12 +221,16 @@ pub struct ToolContext<'a> {
     pub paint: &'a PaintDefaults,
     pub outline: bool,
     pub smart_guides: bool,
+    /// View → Show Guides with Lock Guides off: the selection tools pick and drag ruler guides.
+    pub guides: bool,
     pub snap_to_grid: bool,
     /// Bounding box shown (View → Show/Hide Bounding Box).
     pub show_bbox: bool,
     /// View → Snap to Pixel.
     pub snap_to_pixel: bool,
-    /// View → Snap to Point: picked points (a transform's reference point) land on anchors.
+    /// View → Snap to Point: with Smart Guides off, dragged selections, drawn points and picked
+    /// points (a transform's reference point) land on anchors and ruler guides within
+    /// [`Self::snap_tolerance`].
     pub snap_to_point: bool,
     /// View → Show Corner Widget: live rectangles show draggable Live Corners widgets.
     pub corner_widgets: bool,
@@ -253,6 +265,41 @@ pub struct ToolContext<'a> {
     /// General → Disable Auto Add/Delete is off: the Pen adds an anchor on a selected path's
     /// segment and deletes one of its anchors.
     pub auto_add_delete: bool,
+    /// Selection & Anchor Display → Tolerance: how near (screen pixels) a click must be to a path
+    /// or an anchor to pick it.
+    pub selection_tolerance: f64,
+    /// Selection & Anchor Display → Object Selection by Path Only: a click inside a filled path
+    /// doesn't pick it, only one on its path does.
+    pub path_only: bool,
+    /// General → Double Click To Isolate: a double-click on a group with the Selection tool
+    /// isolates it.
+    pub double_click_isolate: bool,
+    /// Selection & Anchor Display → Command Click to Select Objects Behind: Cmd/Ctrl-click with the
+    /// Selection tool selects the object under the selected one, the next click the one under
+    /// that.
+    pub select_behind: bool,
+    /// Selection & Anchor Display → Highlight anchors on mouse over: Direct Selection marks the
+    /// anchor under the pointer.
+    pub highlight_anchors: bool,
+    /// Selection & Anchor Display → Snap to Point (screen pixels): how near an anchor or a ruler
+    /// guide pulls the pointer while View → Snap to Point is on.
+    pub snap_tolerance: f64,
+    /// Selection & Anchor Display → Show handles when multiple anchors are selected: off, Direct
+    /// Selection shows and drags handles only while a single anchor is selected.
+    pub handles_multiple: bool,
+    /// Selection & Anchor Display → Hide Corner Widget for angles greater than (degrees): corners
+    /// wider than this show no Live Corners widget.
+    pub corner_widget_max_angle: f64,
+    /// Selection & Anchor Display → Move Locked and Hidden Artwork with Artboard.
+    pub move_locked_with_artboard: bool,
+    /// Selection & Anchor Display → Enable Rubber Band for Pen Tool: the Pen previews the next
+    /// segment to the pointer.
+    pub pen_rubber_band: bool,
+    /// Selection & Anchor Display → Enable Rubber Band for Curvature Tool.
+    pub curvature_rubber_band: bool,
+    /// Type → Fill New Type Objects With Placeholder Text: type the Type tools place starts with
+    /// placeholder text, selected.
+    pub placeholder_text: bool,
     /// The document window (none headless): screen-fixed widgets sit in it.
     pub screen: Option<ScreenFrame>,
     /// Where the Plane Switching Widget sits (Perspective Grid Options); None while it's hidden.
@@ -276,8 +323,16 @@ impl ToolContext<'_> {
     pub fn offset_label(&self, dx: f64, dy: f64) -> String {
         format!("dX: {}\ndY: {}", self.len(dx), self.len(dy))
     }
+    /// What Snap to Grid snaps to: the grid's subdivisions (or its lines without any).
+    pub fn grid_step(&self) -> f64 {
+        self.doc.grid.spacing / self.doc.grid.subdivisions.max(1) as f64
+    }
+    /// The selection tolerance in document units ([`Self::selection_tolerance`]).
+    pub fn pick_tol(&self) -> f64 {
+        self.tol(self.selection_tolerance)
+    }
     pub fn hit_options(&self) -> vectorcraft_doc::hit::HitOptions {
-        vectorcraft_doc::hit::HitOptions { tol: self.tol(3.0), outline: self.outline, path_only: false }
+        vectorcraft_doc::hit::HitOptions { tol: self.pick_tol(), outline: self.outline, path_only: self.path_only }
     }
 }
 
@@ -356,6 +411,27 @@ pub enum Cursor {
     BlendAnchor,
 }
 
+impl Cursor {
+    /// General › Use Precise Cursors: the drawing tools' pointers (the Pen's in every state, the
+    /// Eyedropper's, the Slice and Blend tools') become a plain crosshair at the hotspot.
+    pub fn precise(self) -> Self {
+        match self {
+            Cursor::Pen
+            | Cursor::PenAdd
+            | Cursor::PenDelete
+            | Cursor::PenClose
+            | Cursor::PenContinue
+            | Cursor::PenConvert
+            | Cursor::Eyedropper
+            | Cursor::Slice
+            | Cursor::Blend
+            | Cursor::BlendObject
+            | Cursor::BlendAnchor => Cursor::Crosshair,
+            c => c,
+        }
+    }
+}
+
 /// A tool state machine.
 pub trait Tool: Send {
     fn id(&self) -> &'static str;
@@ -506,6 +582,7 @@ pub(crate) mod testutil {
             paint: p,
             outline: false,
             smart_guides: true,
+            guides: true,
             snap_to_grid: false,
             show_bbox: true,
             snap_to_pixel: false,
@@ -524,6 +601,18 @@ pub(crate) mod testutil {
             slices_hidden: false,
             slices_locked: false,
             auto_add_delete: true,
+            selection_tolerance: 3.0,
+            path_only: false,
+            double_click_isolate: true,
+            select_behind: true,
+            highlight_anchors: true,
+            snap_tolerance: 2.0,
+            handles_multiple: true,
+            corner_widget_max_angle: 177.0,
+            move_locked_with_artboard: false,
+            pen_rubber_band: true,
+            curvature_rubber_band: true,
+            placeholder_text: false,
             screen: None,
             plane_widget: Some(Default::default()),
         }

crates/tools/src/pen.rs

@@ -6,7 +6,7 @@
 //! Clicking the first anchor closes the path. Clicking the last one retracts its outgoing handle, so
 //! the next segment leaves it as a corner; dragging from it pulls a new one out on its own.
 //! Enter/Esc (or switching tools) ends the path. Clicking the end of a selected open path continues
-//! it. The rubber-band preview shows the next segment. Auto Add/Delete: between paths, a click on a
+//! it. The rubber-band preview shows the next segment (Enable Rubber Band for Pen Tool). Auto Add/Delete: between paths, a click on a
 //! segment of a selected path adds an anchor there and a click on one of its anchors deletes it
 //! (Shift held or General → Disable Auto Add/Delete starts a new path instead). On a selected
 //! blend's spine a click adds a point (on a point no key object sits on: deletes it).
@@ -201,7 +201,7 @@ impl Tool for PenTool {
         vec![]
     }
     fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
-        if !self.drawing || self.drag.is_some() || self.handle.is_some() {
+        if !cx.pen_rubber_band || !self.drawing || self.drag.is_some() || self.handle.is_some() {
             return vec![];
         }
         let (Some((id, _, last, out)), Some(h)) = (active_path(cx), self.hover) else { return vec![] };

crates/tools/src/rulerguide.rs

@@ -0,0 +1,314 @@
+//! Ruler guides on the canvas, for the selection tools. A press on a guide selects it (Shift adds
+//! it to the selected guides or, released without a drag, takes it out); dragging moves the
+//! selected guides (Alt copies them). The dragged guide snaps: with Shift to the ruler's ticks,
+//! else as a drawn point does (whole pixels, the grid, or with Smart Guides the art's edges,
+//! centres and anchors). Dropped off the canvas onto its ruler, the guide is deleted. Hidden or
+//! locked guides (View › Guides) can't be picked.
+
+use serde_json::json;
+use vectorcraft_geom::Point;
+
+use crate::guides::Targets;
+use crate::{Action, Cursor, Overlay, PointerEvent, PointerKind, ToolContext};
+
+/// The ruler guide under `p`: the nearest within the selection tolerance (the newest of equals).
+pub fn guide_at(cx: &ToolContext, p: Point) -> Option<usize> {
+    if !cx.guides {
+        return None;
+    }
+    let tol = cx.pick_tol();
+    let off = |pos: f64, vertical: bool| (if vertical { p.x } else { p.y } - pos).abs();
+    cx.doc
+        .guides
+        .iter()
+        .enumerate()
+        .map(|(i, g)| (i, off(g.pos, g.vertical)))
+        .filter(|(_, d)| *d <= tol)
+        .min_by(|a, b| a.1.total_cmp(&b.1).then(b.0.cmp(&a.0)))
+        .map(|(i, _)| i)
+}
+
+/// The pointer for a guide: it moves sideways if vertical, up and down if horizontal.
+fn guide_cursor(vertical: bool) -> Cursor {
+    if vertical { Cursor::ResizeH } else { Cursor::ResizeV }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct Drag {
+    index: usize,
+    vertical: bool,
+    /// Where the guide was, and where it is now (x of a vertical guide, y of a horizontal one).
+    from: f64,
+    at: f64,
+    start: Point,
+    pointer: Point,
+    began: bool,
+    /// Shift-pressed on a selected guide: released without a drag, it leaves the selection.
+    deselect: bool,
+}
+
+/// A selection tool's ruler-guide handling: [`Self::press`] on a press, [`Self::pointer`] for
+/// the rest of the gesture.
+#[derive(Default)]
+pub struct GuideEdit {
+    drag: Option<Drag>,
+    /// Smart Guides targets, gathered when the drag starts.
+    targets: Option<Targets>,
+    /// The smart guide the dragged guide snapped to.
+    snapped: Vec<Overlay>,
+}
+
+impl GuideEdit {
+    /// Is a guide pressed or being dragged?
+    pub fn busy(&self) -> bool {
+        self.drag.is_some()
+    }
+
+    /// A press `ev` on a ruler guide: it gets selected and the drag starts. None (and nothing
+    /// done) when no guide is there.
+    pub fn press(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Option<Vec<Action>> {
+        let index = guide_at(cx, ev.pos)?;
+        let g = cx.doc.guides.get(index)?;
+        let (shift, selected) = (ev.mods.shift, cx.selection.guides.contains(&index));
+        self.drag = Some(Drag {
+            index,
+            vertical: g.vertical,
+            from: g.pos,
+            at: g.pos,
+            start: ev.pos,
+            pointer: ev.pos,
+            began: false,
+            deselect: shift && selected,
+        });
+        self.targets = None;
+        self.snapped.clear();
+        Some(match (selected, shift) {
+            (true, _) => vec![],
+            (false, true) => vec![Action::Exec("guide.select".into(), json!({ "indexes": [index], "toggle": true }))],
+            (false, false) => vec![Action::Exec("guide.select".into(), json!({ "indexes": [index] }))],
+        })
+    }
+
+    /// The drag and release of a guide [`Self::press`] picked; None when no guide is pressed.
+    pub fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Option<Vec<Action>> {
+        let mut d = self.drag?;
+        Some(match ev.kind {
+            PointerKind::Drag => {
+                let out = self.drag_to(cx, &mut d, ev);
+                self.drag = Some(d);
+                out
+            }
+            PointerKind::Up => {
+                self.drag = None;
+                self.targets = None;
+                self.snapped.clear();
+                if d.began && on_ruler(cx, d.vertical, ev.pos) {
+                    // Dropped on its ruler: the guide goes (a copy is just not made).
+                    let mut out = vec![Action::Cancel];
+                    if !ev.mods.alt {
+                        out.push(Action::Exec("guide.remove".into(), json!({ "index": d.index })));
+                    }
+                    out
+                } else if d.began {
+                    vec![Action::Commit]
+                } else if d.deselect {
+                    vec![Action::Exec("guide.select".into(), json!({ "indexes": [d.index], "toggle": true }))]
+                } else {
+                    vec![]
+                }
+            }
+            // Another press ends the gesture.
+            _ => {
+                self.drag = None;
+                return None;
+            }
+        })
+    }
+
+    fn drag_to(&mut self, cx: &ToolContext, d: &mut Drag, ev: &PointerEvent) -> Vec<Action> {
+        let p = ev.pos;
+        let mut out = vec![];
+        if !d.began {
+            if p.distance(d.start) < cx.tol(3.0) {
+                return out;
+            }
+            d.began = true;
+            out.push(Action::Begin(if ev.mods.alt { "Copy Guide" } else { "Move Guide" }.into()));
+            self.targets = cx.smart_guides.then(|| Targets::collect(cx.doc, &[], None));
+        }
+        let moved = p - d.start;
+        let (at, snapped) = self.snap(cx, d.vertical, d.from + if d.vertical { moved.x } else { moved.y }, ev.mods.shift);
+        (d.at, d.pointer, self.snapped) = (at, p, snapped);
+        // The other selected guides follow the pointer: vertical ones across, horizontal ones down.
+        let (dx, dy) = if d.vertical { (at - d.from, moved.y) } else { (moved.x, at - d.from) };
+        out.push(Action::Preview("guide.move".into(), json!({ "dx": dx, "dy": dy, "copy": ev.mods.alt })));
+        out
+    }
+
+    /// Where a guide dragged to `v` goes: with Shift on the nearest ruler tick, else on whole
+    /// pixels, the grid or a smart guide (as a drawn point snaps).
+    fn snap(&self, cx: &ToolContext, vertical: bool, v: f64, shift: bool) -> (f64, Vec<Overlay>) {
+        if shift {
+            return (cx.unit.snap_to_ruler_tick(v, cx.zoom), vec![]);
+        }
+        if cx.snap_to_pixel {
+            return (v.round(), vec![]);
+        }
+        if cx.snap_to_grid {
+            return (vectorcraft_geom::snap::snap_to_grid(v, cx.grid_step(), 0.0), vec![]);
+        }
+        match &self.targets {
+            Some(t) => t.snap_guide(vertical, v, cx.tol(5.0)),
+            None => (v, vec![]),
+        }
+    }
+
+    /// The pointer over a guide, or while one is dragged.
+    pub fn cursor(&self, cx: &ToolContext, p: Point) -> Option<Cursor> {
+        if let Some(d) = &self.drag {
+            return Some(guide_cursor(d.vertical));
+        }
+        guide_at(cx, p).and_then(|i| cx.doc.guides.get(i)).map(|g| guide_cursor(g.vertical))
+    }
+
+    /// While a guide is dragged: the smart guide it snapped to and its position by the pointer.
+    pub fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
+        let Some(d) = self.drag.filter(|d| d.began) else { return vec![] };
+        let mut o = self.snapped.clone();
+        let axis = if d.vertical { "X" } else { "Y" };
+        o.push(Overlay::Measure { p: d.pointer, text: format!("{axis}: {}", cx.len(d.at)) });
+        o
+    }
+}
+
+/// Is `p` off the canvas on the side of the ruler a guide comes from (the top one for a
+/// horizontal guide, the left one for a vertical guide)? Never without a window.
+fn on_ruler(cx: &ToolContext, vertical: bool, p: Point) -> bool {
+    cx.screen.and_then(|s| s.to_screen(p)).is_some_and(|(x, y)| if vertical { x < 0.0 } else { y < 0.0 })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::testutil::*;
+    use crate::{Mods, ScreenFrame};
+    use vectorcraft_doc::{Guide, Selection};
+    use vectorcraft_geom::Vec2;
+
+    fn ev(kind: PointerKind, x: f64, y: f64, mods: Mods) -> PointerEvent {
+        PointerEvent::new(kind, x, y).with_mods(mods)
+    }
+
+    fn guides_doc() -> vectorcraft_doc::Document {
+        let (mut d, _) = doc_with_rect();
+        d.guides = vec![Guide { vertical: true, pos: 300.0 }, Guide { vertical: false, pos: 400.0 }];
+        d
+    }
+
+    #[test]
+    fn picks_the_guide_within_the_tolerance_unless_hidden_or_locked() {
+        let (d, s, p) = (guides_doc(), Selection::default(), paint());
+        let c = cx(&d, &s, &p);
+        assert_eq!(guide_at(&c, Point::new(302.0, 50.0)), Some(0));
+        assert_eq!(guide_at(&c, Point::new(50.0, 398.0)), Some(1));
+        // Where they cross, the nearer one.
+        assert_eq!(guide_at(&c, Point::new(301.0, 398.0)), Some(0));
+        assert_eq!(guide_at(&c, Point::new(305.0, 50.0)), None, "beyond the 3 px tolerance");
+        let hidden = ToolContext { guides: false, ..cx(&d, &s, &p) };
+        assert_eq!(guide_at(&hidden, Point::new(300.0, 50.0)), None);
+    }
+
+    #[test]
+    fn a_drag_moves_the_selected_guides_in_one_step() {
+        let d = guides_doc();
+        let (s, p) = (Selection::default(), paint());
+        let c = cx(&d, &s, &p);
+        let mut g = GuideEdit::default();
+        let m = Mods::default();
+        assert_eq!(g.press(&c, &ev(PointerKind::Down, 300.0, 50.0, m)), Some(vec![Action::Exec("guide.select".into(), json!({"indexes": [0]}))]));
+        // The tool sees the guide selected from now on.
+        let mut s = s;
+        s.set_guides([0]);
+        let c = cx(&d, &s, &p);
+        let a = g.pointer(&c, &ev(PointerKind::Drag, 340.0, 60.0, m)).unwrap();
+        assert_eq!(a[0], Action::Begin("Move Guide".into()));
+        assert_eq!(a[1], Action::Preview("guide.move".into(), json!({"dx": 40.0, "dy": 10.0, "copy": false})));
+        assert!(matches!(g.overlays(&c).last(), Some(Overlay::Measure { text, .. }) if text == "X: 340.00 pt"));
+        assert_eq!(g.cursor(&c, Point::ZERO), Some(Cursor::ResizeH));
+        assert_eq!(g.pointer(&c, &ev(PointerKind::Up, 340.0, 60.0, m)), Some(vec![Action::Commit]));
+        assert!(!g.busy() && g.pointer(&c, &ev(PointerKind::Drag, 0.0, 0.0, m)).is_none());
+    }
+
+    #[test]
+    fn the_dragged_guide_snaps_to_art_ruler_ticks_and_the_grid() {
+        let d = guides_doc();
+        let mut s = Selection::default();
+        s.set_guides([0]);
+        let p = paint();
+        let drag_to = |c: &ToolContext, x: f64, mods: Mods| {
+            let mut g = GuideEdit::default();
+            g.press(c, &ev(PointerKind::Down, 300.0, 50.0, Mods::default()));
+            let a = g.pointer(c, &ev(PointerKind::Drag, x, 50.0, mods)).unwrap();
+            let Some(Action::Preview(_, v)) = a.last() else { panic!("{a:?}") };
+            (300.0 + v["dx"].as_f64().unwrap(), g.overlays(c))
+        };
+        // Smart Guides: onto the rect's right edge (x = 200), labelled.
+        let (x, ov) = drag_to(&cx(&d, &s, &p), 203.0, Mods::default());
+        assert_eq!(x, 200.0);
+        assert!(matches!(&ov[0], Overlay::Label { .. }));
+        let off = ToolContext { smart_guides: false, ..cx(&d, &s, &p) };
+        assert_eq!(drag_to(&off, 203.0, Mods::default()).0, 203.0);
+        // Shift: the ruler's ticks (labels every 50 pt at 100 %, ticks every 5 pt).
+        assert_eq!(drag_to(&off, 223.0, Mods { shift: true, ..Default::default() }).0, 225.0);
+        let zoomed = ToolContext { zoom: 5.0, ..cx(&d, &s, &p) };
+        assert_eq!(drag_to(&zoomed, 223.4, Mods { shift: true, ..Default::default() }).0, 223.0, "every point at 500 %");
+        let grid = ToolContext { snap_to_grid: true, ..cx(&d, &s, &p) };
+        assert_eq!(drag_to(&grid, 226.0, Mods::default()).0, 225.0, "the grid's 9 pt subdivisions");
+    }
+
+    #[test]
+    fn shift_click_toggles_and_alt_drag_copies() {
+        let d = guides_doc();
+        let mut s = Selection::default();
+        s.set_guides([0, 1]);
+        let p = paint();
+        let c = cx(&d, &s, &p);
+        let (shift, alt) = (Mods { shift: true, ..Default::default() }, Mods { alt: true, ..Default::default() });
+        let mut g = GuideEdit::default();
+        assert_eq!(g.press(&c, &ev(PointerKind::Down, 50.0, 400.0, shift)), Some(vec![]));
+        let deselect = Action::Exec("guide.select".into(), json!({"indexes": [1], "toggle": true}));
+        assert_eq!(g.pointer(&c, &ev(PointerKind::Up, 50.0, 400.0, shift)), Some(vec![deselect]));
+        g.press(&c, &ev(PointerKind::Down, 50.0, 400.0, alt));
+        let a = g.pointer(&c, &ev(PointerKind::Drag, 50.0, 420.0, alt)).unwrap();
+        assert_eq!(a[0], Action::Begin("Copy Guide".into()));
+        assert_eq!(a[1], Action::Preview("guide.move".into(), json!({"dx": 0.0, "dy": 20.0, "copy": true})));
+    }
+
+    #[test]
+    fn dropped_on_its_ruler_the_guide_is_deleted() {
+        let d = guides_doc();
+        let p = paint();
+        let mut s = Selection::default();
+        s.set_guides([1]);
+        // The window shows the document from (0, 0) at 100 %: above y = 0 is the top ruler.
+        let screen = ScreenFrame { origin: Point::ZERO, right: Vec2::new(1.0, 0.0), down: Vec2::new(0.0, 1.0), size: (800.0, 600.0) };
+        let c = ToolContext { screen: Some(screen), ..cx(&d, &s, &p) };
+        let m = Mods::default();
+        let gesture = |to: Point, mods: Mods| {
+            let mut g = GuideEdit::default();
+            g.press(&c, &ev(PointerKind::Down, 50.0, 400.0, m));
+            g.pointer(&c, &ev(PointerKind::Drag, to.x, to.y, mods));
+            g.pointer(&c, &ev(PointerKind::Up, to.x, to.y, mods)).unwrap()
+        };
+        assert_eq!(gesture(Point::new(50.0, -6.0), m), vec![Action::Cancel, Action::Exec("guide.remove".into(), json!({"index": 1}))]);
+        assert_eq!(gesture(Point::new(50.0, -6.0), Mods { alt: true, ..m }), vec![Action::Cancel], "a copy is just not made");
+        // Off the left side: not its ruler.
+        assert_eq!(gesture(Point::new(-6.0, 300.0), m), vec![Action::Commit]);
+        // Headless (no window): no ruler to drop it on.
+        let mut g = GuideEdit::default();
+        let c = cx(&d, &s, &p);
+        g.press(&c, &ev(PointerKind::Down, 50.0, 400.0, m));
+        g.pointer(&c, &ev(PointerKind::Drag, 50.0, -6.0, m));
+        assert_eq!(g.pointer(&c, &ev(PointerKind::Up, 50.0, -6.0, m)), Some(vec![Action::Commit]));
+    }
+}

crates/tools/src/select.rs

@@ -1,17 +1,22 @@
-//! The Selection tool (V): click/shift-click, marquee, move (Alt copies, Shift constrains),
+//! The Selection tool (V): click/shift-click, marquee, move (Alt copies, Shift constrains; Smart
+//! Guides, or with them off View › Snap to Point, snap it),
 //! bounding-box scale (Shift proportional, Alt from centre) and rotate (outside corners, Shift 45°),
-//! drag a live rectangle's corner widget to round its corners, double-click to enter isolation mode.
+//! drag a live rectangle's corner widget to round its corners (Alt-click cycles their kind,
+//! double-click opens the Corners dialog), double-click to enter isolation mode (Double Click To
+//! Isolate), Cmd/Ctrl-click to select the object behind (Command Click to Select Objects Behind),
+//! click or drag a ruler guide ([`crate::rulerguide`]).
 //! The bounding box stands at the selection's own angle after a rotation, so its handles scale
 //! along the objects' axes. A handle drag resizes area type's frame (the type area) instead of
 //! scaling its type: the text reflows at its size.
 
 use serde_json::{Value, json};
-use vectorcraft_doc::hit::{hit_test, marquee};
+use vectorcraft_doc::hit::{hit_test, marquee, objects_at};
 use vectorcraft_doc::{NodeId, OrientedBox};
 use vectorcraft_geom::{Affine, Point, Rect};
 
 use crate::bbox::{Handle, hit_handle, in_rotate_zone, move_delta, rotate_for_drag, scale_for_drag};
-use crate::corners::{CornerDrag, over_widget};
+use crate::corners::{self, CornerDrag, over_widget};
+use crate::rulerguide::GuideEdit;
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, json_ids};
 
 #[derive(Clone, Debug, Default)]
@@ -51,7 +56,11 @@ pub struct SelectionTool {
     measure: Option<(Point, String)>,
     guides: Vec<Overlay>,
     targets: Option<crate::guides::Targets>,
+    /// View → Snap to Point (Smart Guides off): the anchors and ruler guides the grabbed point
+    /// lands on while moving.
+    points: Option<crate::guides::Targets>,
     start_bounds: Option<Rect>,
+    guide: GuideEdit,
 }
 
 pub fn matrix_json(a: Affine) -> Value {
@@ -99,18 +108,27 @@ impl Tool for SelectionTool {
     }
 
     fn busy(&self) -> bool {
-        !matches!(self.state, State::Idle)
+        !matches!(self.state, State::Idle) || self.guide.busy()
     }
 
     fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
+        if let Some(out) = self.guide.pointer(cx, ev) {
+            return out;
+        }
         let p = ev.pos;
         let m = ev.mods;
         match (ev.kind, self.state.clone()) {
             (PointerKind::DoubleClick, _) => {
                 self.state = State::Idle;
+                if let Some(a) = corners::double_click(cx, p) {
+                    return vec![a];
+                }
+                if crate::rulerguide::guide_at(cx, p).is_some() {
+                    return vec![];
+                }
                 if let Some(h) = hit_test(cx.doc, p, cx.hit_options()) {
                     let top = h.top_object(cx.isolation);
-                    if cx.doc.node(top).is_some_and(|n| matches!(n.kind, vectorcraft_doc::NodeKind::Group { .. })) {
+                    if cx.double_click_isolate && cx.doc.node(top).is_some_and(|n| matches!(n.kind, vectorcraft_doc::NodeKind::Group { .. })) {
                         return vec![Action::Exec("object.isolate".into(), json!({ "id": top.0 }))];
                     }
                     if cx.doc.node(top).is_some_and(|n| matches!(n.kind, vectorcraft_doc::NodeKind::Text(_))) {
@@ -123,7 +141,7 @@ impl Tool for SelectionTool {
             }
             (PointerKind::Down, _) => {
                 // 1. Live Corners widgets, then the bounding-box handles of the current selection.
-                if let Some(c) = CornerDrag::hit(cx, p) {
+                if let Some(c) = CornerDrag::hit(cx, ev) {
                     self.state = State::Corner(c);
                     return vec![];
                 }
@@ -148,7 +166,19 @@ impl Tool for SelectionTool {
                         None => {}
                     }
                 }
-                // 2. Objects.
+                // 2. Ruler guides (over the art, as they are drawn).
+                if let Some(out) = self.guide.press(cx, ev) {
+                    self.state = State::Idle;
+                    return out;
+                }
+                // 3. Objects: Cmd/Ctrl-click selects the one under the selected one (cycling).
+                if m.cmd
+                    && cx.select_behind
+                    && let Some(behind) = object_behind(cx, p)
+                {
+                    self.state = State::Moving { start: p, began: false, deselect: None };
+                    return vec![Action::Exec("select.set".into(), json!({ "ids": [behind.0] }))];
+                }
                 match hit_test(cx.doc, p, cx.hit_options()) {
                     Some(h) => {
                         let top = h.top_object(cx.isolation);
@@ -186,8 +216,15 @@ impl Tool for SelectionTool {
                 if !began {
                     self.start_bounds = selection_bounds(cx);
                     self.targets = cx.smart_guides.then(|| crate::guides::Targets::collect(cx.doc, &cx.selection.objects, None));
+                    self.points = crate::guides::Targets::snap_to_point(cx, &cx.selection.objects);
                 }
                 self.guides.clear();
+                // Snap to Point: the point the selection was grabbed by lands on an anchor or guide.
+                if let Some(t) = &self.points {
+                    let (q, ov) = t.snap_point(start + d, cx.tol(cx.snap_tolerance));
+                    d = q - start;
+                    self.guides = ov;
+                }
                 if let (Some(t), Some(b)) = (&self.targets, self.start_bounds) {
                     let (adj, ov) = t.snap_rect(b + d, cx.tol(5.0));
                     d += adj;
@@ -243,6 +280,7 @@ impl Tool for SelectionTool {
                 self.measure = None;
                 self.guides.clear();
                 self.targets = None;
+                self.points = None;
                 match (began, deselect) {
                     (true, _) => vec![Action::Commit],
                     (false, Some(id)) => vec![Action::Exec("select.toggle".into(), json!({ "id": id.0 }))],
@@ -281,6 +319,7 @@ impl Tool for SelectionTool {
             _ => {}
         }
         o.extend(self.guides.iter().cloned());
+        o.extend(self.guide.overlays(cx));
         if let Some((p, t)) = &self.measure {
             o.push(Overlay::Measure { p: *p, text: t.clone() });
         }
@@ -295,6 +334,9 @@ impl Tool for SelectionTool {
             State::Corner(_) => return Cursor::CornerRadius,
             _ => {}
         }
+        if self.guide.busy() {
+            return self.guide.cursor(cx, p).unwrap_or_default();
+        }
         if over_widget(cx, p) {
             return Cursor::CornerRadius;
         }
@@ -307,6 +349,9 @@ impl Tool for SelectionTool {
                 None => {}
             }
         }
+        if let Some(c) = self.guide.cursor(cx, p) {
+            return c;
+        }
         if let Some(h) = hit_test(cx.doc, p, cx.hit_options()) {
             if cx.selection.contains(h.top_object(cx.isolation)) || m.alt {
                 return Cursor::Move;
@@ -317,6 +362,14 @@ impl Tool for SelectionTool {
     }
 }
 
+/// Select Behind: of the objects under `p` (topmost first), the one below the lowest selected
+/// one, back to the topmost after the bottom one; the topmost when none is selected.
+fn object_behind(cx: &ToolContext, p: Point) -> Option<NodeId> {
+    let stack = objects_at(cx.doc, p, cx.hit_options(), cx.isolation);
+    let next = stack.iter().rposition(|id| cx.selection.contains(*id)).map_or(0, |i| i + 1);
+    stack.get(next).or(stack.first()).copied()
+}
+
 /// Is `n` area type (text in a frame) whose frame the tools reshape? Type in perspective isn't:
 /// it transforms whole.
 pub(crate) fn is_area_type(n: &vectorcraft_doc::Node) -> bool {
@@ -358,6 +411,27 @@ mod tests {
         assert!(t.pointer(&cx, &ev(PointerKind::Up, 150.0, 150.0)).is_empty());
     }
 
+    /// #414: a press on a ruler guide picks it over the art, and drags it.
+    #[test]
+    fn a_press_on_a_ruler_guide_picks_it_over_the_art() {
+        let (mut d, _) = doc_with_rect();
+        d.guides.push(vectorcraft_doc::Guide { vertical: false, pos: 150.0 });
+        let s = Selection::default();
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let mut t = SelectionTool::default();
+        assert_eq!(t.cursor(&cx, Point::new(160.0, 151.0), Mods::default()), Cursor::ResizeV);
+        let a = t.pointer(&cx, &ev(PointerKind::Down, 160.0, 151.0));
+        assert_eq!(a, vec![Action::Exec("guide.select".into(), json!({"indexes": [0]}))]);
+        assert!(t.busy());
+        let a = t.pointer(&cx, &ev(PointerKind::Drag, 160.0, 171.0));
+        assert_eq!(a[1], Action::Preview("guide.move".into(), json!({"dx": 0.0, "dy": 20.0, "copy": false})));
+        assert_eq!(t.pointer(&cx, &ev(PointerKind::Up, 160.0, 171.0)), vec![Action::Commit]);
+        assert!(!t.busy());
+        // A double-click there doesn't go through to the art.
+        assert!(t.pointer(&cx, &ev(PointerKind::DoubleClick, 160.0, 150.0)).is_empty());
+    }
+
     #[test]
     fn drag_moves_with_single_undo() {
         let (d, id) = doc_with_rect();

crates/tools/src/text.rs

@@ -11,7 +11,9 @@
 //! undo step per typing session: the tool keeps the styled runs locally and previews a single
 //! `text.editRange` (the changed span, with its styled runs) against the session snapshot.
 //! Styling a selected range goes through `text.setRangeStyle` (the Character panel reads the
-//! selection from [`Tool::options`]).
+//! selection from [`Tool::options`]); Alt+arrows step it by the Preferences › Type increments
+//! (`type.step`). New type starts with placeholder text, selected, when Fill New Type Objects With
+//! Placeholder Text is on.
 //!
 //! IME: the marked text of a composition is part of the typing session (so it lays out in place),
 //! underlined, until the IME commits it (it then goes through [`Tool::text_input`]) or clears it.
@@ -263,7 +265,7 @@ impl TypeTool {
                 let mode = if on_path { "onPath" } else { "area" };
                 out.push(Action::Exec(
                     "text.createInPath".into(),
-                    json!({"path": pid.0, "mode": mode, "text": "", "at": [start.x, start.y], "vertical": self.vertical}),
+                    json!({"path": pid.0, "mode": mode, "text": "", "at": [start.x, start.y], "vertical": self.vertical, "placeholder": cx.placeholder_text}),
                 ));
                 out.push(Action::Notify("text.editNew".into()));
                 return out;
@@ -275,6 +277,7 @@ impl TypeTool {
             None => json!({"x": start.x, "y": start.y, "text": ""}),
         };
         params["vertical"] = json!(self.vertical);
+        params["placeholder"] = json!(cx.placeholder_text);
         out.push(Action::Exec("text.create".into(), params));
         out.push(Action::Notify("text.editNew".into()));
         out
@@ -303,6 +306,18 @@ impl TypeTool {
 
 /// Byte range in `s` of the characters `r` (IME ranges count characters; carets count bytes).
 /// `None` when `r` runs past the end of `s` or backwards.
+/// The `type.step` an Alt+arrow asks for, by one step: ←/→ kerning at a `caret`, else tracking;
+/// ↑/↓ leading (down opens it up); Shift+↑/↓ baseline shift.
+fn step_key(key: ToolKey, shift: bool, caret: bool) -> Option<(&'static str, f64)> {
+    let sign = |up: bool| if up { 1.0 } else { -1.0 };
+    Some(match (key, shift) {
+        (ToolKey::Left | ToolKey::Right, false) => (if caret { "kerning" } else { "tracking" }, sign(key == ToolKey::Right)),
+        (ToolKey::Up | ToolKey::Down, false) => ("leading", sign(key == ToolKey::Down)),
+        (ToolKey::Up | ToolKey::Down, true) => ("baselineShift", sign(key == ToolKey::Up)),
+        _ => return None,
+    })
+}
+
 fn char_range_to_bytes(s: &str, r: Range<usize>) -> Option<Range<usize>> {
     let byte = |c: usize| if c == s.chars().count() { Some(s.len()) } else { s.char_indices().nth(c).map(|(i, _)| i) };
     let (a, b) = (byte(r.start)?, byte(r.end)?);
@@ -454,6 +469,16 @@ impl Tool for TypeTool {
         self.caret = self.caret.min(len);
         self.anchor = self.anchor.min(len);
         let (a, b) = self.sel();
+        // Alt+arrows step the type by the Preferences › Type increments (Cmd/Ctrl too: five steps).
+        if mods.alt
+            && let Some(id) = self.editing
+            && let Some((attribute, by)) = step_key(key, mods.shift, a == b)
+        {
+            let mut out = self.commit();
+            let by = if mods.cmd { by * 5.0 } else { by };
+            out.push(Action::Exec("type.step".into(), json!({"id": id.0, "start": a, "end": b, "attribute": attribute, "by": by})));
+            return out;
+        }
         let word = mods.cmd || mods.alt;
         let lay = self.layout(&t);
         let key = if lay.vertical {
@@ -623,7 +648,10 @@ impl Tool for TypeTool {
             && let Some(id) = cx.selection.objects.first().copied()
         {
             self.start_editing(id, 0);
-            self.fresh = Self::text(cx, id).filter(|t| matches!(t.kind, TextKind::Point)).map(|_| id);
+            let t = Self::text(cx, id);
+            self.fresh = t.filter(|t| matches!(t.kind, TextKind::Point)).map(|_| id);
+            // Placeholder text comes selected: typing replaces it.
+            self.caret = t.map_or(0, |t| edit::runs_len(&t.runs));
         }
     }
     /// `{editing, start, end, caret, anchor, typing, composing}` — the Character panel styles

crates/tools/src/xform/artboard.rs

@@ -79,7 +79,7 @@ impl ArtboardTool {
         self.guides.clear();
         self.targets = cx.smart_guides.then(|| {
             let art = match cx.doc.artboards.get(index) {
-                Some(a) if art_moves => cx.doc.art_on_artboard(a.rect),
+                Some(a) if art_moves => cx.doc.art_on_artboard(a.rect, cx.move_locked_with_artboard),
                 _ => vec![],
             };
             Targets::for_artboard(cx.doc, index, &art)
@@ -96,7 +96,7 @@ impl ArtboardTool {
             return Point::new(p.x.round(), p.y.round());
         }
         if cx.snap_to_grid {
-            return vectorcraft_geom::snap::snap_point_to_grid(p, grid_step(cx));
+            return vectorcraft_geom::snap::snap_point_to_grid(p, cx.grid_step());
         }
         let Some(t) = &self.targets else { return p };
         let offsets: &[Vec2] = if bleed == Vec2::ZERO { &[] } else { &[bleed] };
@@ -114,7 +114,7 @@ impl ArtboardTool {
             return Vec2::new((tl.x + d.x).round() - tl.x, (tl.y + d.y).round() - tl.y);
         }
         if cx.snap_to_grid {
-            return vectorcraft_geom::snap::snap_point_to_grid(tl + d, grid_step(cx)) - tl;
+            return vectorcraft_geom::snap::snap_point_to_grid(tl + d, cx.grid_step()) - tl;
         }
         let Some(t) = (if copy { &self.copy_targets } else { &self.targets }) else { return d };
         let moved = rect + d;
@@ -144,10 +144,6 @@ fn bleed_offset(cx: &ToolContext, rect: Rect, handle: Handle) -> Vec2 {
 }
 
 /// The grid's snapping step (gridline spacing over subdivisions), as `guides::snap_draw` uses.
-fn grid_step(cx: &ToolContext) -> f64 {
-    cx.doc.grid.spacing / cx.doc.grid.subdivisions.max(1) as f64
-}
-
 impl Tool for ArtboardTool {
     fn id(&self) -> &'static str {
         "artboard"

crates/ui-egui/Cargo.toml

@@ -33,3 +33,7 @@ log = { workspace = true }
 [dev-dependencies]
 vectorcraft-testkit = { workspace = true }
 wat = { workspace = true }
+
+[build-dependencies]
+serde_json = { workspace = true }
+toml = "1"

crates/ui-egui/build.rs

@@ -0,0 +1,105 @@
+//! Bake the contributor credits into the binary as static Rust tables (craftrules
+//! standards/contributors.md). Nothing is read at run time.
+//!
+//! - contributors/contributors.json: commit stats per GitHub username, generated by craftrules
+//!   scripts/contributors.py, which also marks whose people.toml entry it verified.
+//! - contributors/people.toml: the names people chose for themselves. A name is used only when the
+//!   JSON says the entry was verified (`people_entry`).
+//!
+//! A missing or malformed file gives empty tables (or no names) and a warning.
+
+use std::fmt::Write as _;
+
+use serde_json::Value;
+
+fn main() {
+    let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../contributors");
+    let json = read(&dir.join("contributors.json"), "the About window shows no contributors", |t| {
+        serde_json::from_str::<Value>(t).map_err(|e| e.to_string())
+    })
+    .unwrap_or(Value::Null);
+    let people = read(&dir.join("people.toml"), "contributors are shown by username only", |t| t.parse::<toml::Table>().map_err(|e| e.to_string()))
+        .unwrap_or_default();
+    let out = std::path::PathBuf::from(std::env::var_os("OUT_DIR").unwrap_or_default()).join("credits.rs");
+    if let Err(e) = std::fs::write(&out, generate(&json, &people)) {
+        println!("cargo::warning=writing {}: {e}", out.display());
+    }
+}
+
+fn read<T>(path: &std::path::Path, fallback: &str, parse: impl Fn(&str) -> Result<T, String>) -> Option<T> {
+    println!("cargo::rerun-if-changed={}", path.display());
+    let r = std::fs::read_to_string(path).map_err(|e| e.to_string()).and_then(|t| parse(&t));
+    if let Err(e) = &r {
+        println!("cargo::warning={}: {e}; {fallback}", path.display());
+    }
+    r.ok()
+}
+
+/// A non-empty string field of someone's people.toml entry, as a Rust `Option<&str>` literal.
+fn name(v: Option<&str>) -> String {
+    match v.map(str::trim).filter(|s| !s.is_empty()) {
+        Some(x) => format!("Some({x:?})"),
+        None => "None".into(),
+    }
+}
+
+fn s(v: &Value, k: &str) -> String {
+    format!("{:?}", v.get(k).and_then(Value::as_str).unwrap_or(""))
+}
+
+fn n(v: &Value, k: &str) -> u64 {
+    v.get(k).and_then(Value::as_u64).unwrap_or(0)
+}
+
+fn rows(json: &Value, k: &str) -> Vec<Value> {
+    json.get(k).and_then(Value::as_array).cloned().unwrap_or_default()
+}
+
+fn generate(json: &Value, people: &toml::Table) -> String {
+    let mut o = String::new();
+    let _ = writeln!(o, "pub static TOTAL_COMMITS: u64 = {};", n(json, "commits"));
+    let _ = writeln!(o, "pub static CONTRIBUTORS: &[Contributor] = &[");
+    for c in rows(json, "contributors") {
+        let login = c.get("login").and_then(Value::as_str).unwrap_or("");
+        if login.is_empty() {
+            continue;
+        }
+        // Names only from a verified, self-chosen people.toml entry.
+        let entry = people.get("people").and_then(|p| p.get(login)).filter(|_| c.get("people_entry").and_then(Value::as_bool) == Some(true));
+        let field = |k: &str| entry.and_then(|e| e.get(k)).and_then(toml::Value::as_str);
+        let synced = entry.and_then(|e| e.get("sync_github_name")).and_then(toml::Value::as_bool) == Some(true);
+        let display = field("display_name")
+            .filter(|s| !s.trim().is_empty())
+            .or_else(|| if synced { c.get("github_name").and_then(Value::as_str) } else { None });
+        let _ = writeln!(
+            o,
+            "    Contributor {{ login: {login:?}, display_name: {}, real_name: {}, prs: {}, commits: {}, lines_added: {}, lines_deleted: {}, binary_added: {}, binary_deleted: {}, first_commit: {}, last_commit: {} }},",
+            name(display),
+            name(field("real_name")),
+            n(&c, "prs"),
+            n(&c, "commits"),
+            n(&c, "lines_added"),
+            n(&c, "lines_deleted"),
+            n(&c, "binary_added"),
+            n(&c, "binary_deleted"),
+            s(&c, "first_commit"),
+            s(&c, "last_commit"),
+        );
+    }
+    let _ = writeln!(o, "];");
+    let _ = writeln!(o, "pub static MODELS: &[Model] = &[");
+    for m in rows(json, "models") {
+        let _ = writeln!(
+            o,
+            "    Model {{ company: {}, model: {}, version: {}, commits: {}, lines_added: {}, lines_deleted: {} }},",
+            s(&m, "company"),
+            s(&m, "model"),
+            s(&m, "version"),
+            n(&m, "commits"),
+            n(&m, "lines_added"),
+            n(&m, "lines_deleted"),
+        );
+    }
+    let _ = writeln!(o, "];");
+    o
+}

crates/ui-egui/src/canvas.rs

@@ -206,8 +206,11 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
             painter.add(Shape::convex_polygon(xf.quad(ab.rect), Color32::WHITE, Stroke::NONE));
         }
     }
-    if app.ui.view.grid {
-        grid(&painter, &xf, doc.grid.spacing, doc.grid.subdivisions);
+    // The grid behind the art (Guides & Grid › Grids In Back), else over it below.
+    let grid_look = app.ui.view.grid.then(|| LineLook::grid(&app.session.prefs));
+    let grids_in_back = app.session.prefs.grids_in_back;
+    if let Some(look) = grid_look.filter(|_| grids_in_back) {
+        grid(&painter, &xf, doc.grid.spacing, doc.grid.subdivisions, look);
     }
 
     // Artwork raster.
@@ -287,6 +290,9 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
         let b = xf.to_screen(old.to_doc(rect.max));
         painter.image(tex.id(), egui::Rect::from_min_max(a, b), egui::Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
     }
+    if let Some(look) = grid_look.filter(|_| !grids_in_back) {
+        grid(&painter, &xf, doc.grid.spacing, doc.grid.subdivisions, look);
+    }
     // Artboard edges and names.
     let active_ab = 0;
     for (i, ab) in doc.artboards.iter().enumerate() {
@@ -308,7 +314,11 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
         }
     }
     if app.ui.view.guides {
-        for g in &doc.guides {
+        let look = LineLook::guides(&app.session.prefs, &t);
+        // Selected guides in the selection colour.
+        let picked = LineLook { color: t.selection, ..look };
+        let selected: &[usize] = app.session.active().map_or(&[], |st| &st.selection.guides);
+        for (i, g) in doc.guides.iter().enumerate() {
             let (a, b) = if g.vertical {
                 let x = xf.to_screen(Point::new(g.pos, 0.0)).x;
                 (pos2(x, rect.top()), pos2(x, rect.bottom()))
@@ -316,7 +326,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
                 let y = xf.to_screen(Point::new(0.0, g.pos)).y;
                 (pos2(rect.left(), y), pos2(rect.right(), y))
             };
-            painter.line_segment([a, b], Stroke::new(1.0, t.guide));
+            if selected.contains(&i) { picked } else { look }.guide(&painter, a, b);
         }
     }
 
@@ -342,7 +352,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
     // View → Hide Gradient Annotator hides the Gradient tool's annotator.
     if app.session.tool_id() != "gradient" || app.ui.view.gradient_annotator {
         let overlays = app.session.overlays(view_info);
-        draw_overlays(&painter, &xf, &overlays, &t);
+        draw_overlays(&painter, &xf, &overlays, &t, HandleLook::of(&app.session.prefs));
     }
     ime_output(app, ui.ctx(), &xf);
     crate::place::paint_drop_highlight(app, ui.ctx(), &painter, rect);
@@ -418,8 +428,10 @@ fn cursor_icon(c: Cursor) -> egui::CursorIcon {
 }
 
 fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect: egui::Rect) {
-    let (pointer, m, space, scroll, zoom_delta) =
-        ui.input(|i| (i.pointer.clone(), i.modifiers, i.key_down(egui::Key::Space), i.smooth_scroll_delta, i.zoom_delta()));
+    let line = ui.ctx().options(|o| o.input_options.line_scroll_speed);
+    let wheel_zooms = app.session.prefs.zoom_with_mouse_wheel;
+    let (pointer, m, space, (factor, scroll)) =
+        ui.input(|i| (i.pointer.clone(), i.modifiers, i.key_down(egui::Key::Space), wheel(i, wheel_zooms, line, rect.height())));
     let v = *app.view().unwrap_or(&View::default());
     let xf = Xf::new(rect, &v);
     let hover = pointer.hover_pos().filter(|p| rect.contains(*p));
@@ -427,12 +439,8 @@ fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect:
     let view = app.view_info();
     let drag: Option<Drag> = ui.data(|d| d.get_temp(drag_id()));
 
-    // Zoom: pinch / Cmd-scroll / Alt-scroll around the pointer. Plain scroll pans.
+    // Zoom around the pointer, or scroll ([`wheel`]).
     if resp.hovered() {
-        let mut factor = zoom_delta as f64;
-        if m.alt && scroll.y != 0.0 {
-            factor *= (scroll.y as f64 * 0.01).exp();
-        }
         if (factor - 1.0).abs() > 1e-6 {
             if let (Some(p), Some(vm)) = (hover, app.view_mut()) {
                 let before = xf.to_doc(p);
@@ -441,8 +449,7 @@ fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect:
                 let after = nx.to_doc(p);
                 vm.center += before - after;
             }
-        } else if (scroll.x != 0.0 || scroll.y != 0.0)
-            && !m.alt
+        } else if scroll != egui::Vec2::ZERO
             && let Some(vm) = app.view_mut()
         {
             let d = Xf { rect, zoom: vm.zoom, center: vm.center, rot: vm.rotation.to_radians() }.delta_to_doc(scroll);
@@ -481,7 +488,9 @@ fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect:
                 app.select_tool(if is_selection_tool(&last) { &last } else { "selection" });
                 kind = Drag::TempSelect;
             }
-            let ev = PointerEvent { kind: PointerKind::Down, pos: xf.to_doc(p), mods: mods(m, space), pressure: pen_pressure(ui, true) };
+            // Cmd only brought the selection tool: its click is a plain one, not Select Behind.
+            let mods = Mods { cmd: m.command && kind != Drag::TempSelect, ..mods(m, space) };
+            let ev = PointerEvent { kind: PointerKind::Down, pos: xf.to_doc(p), mods, pressure: pen_pressure(ui, true) };
             dispatch(app, &ev, view);
             kind
         };
@@ -591,6 +600,46 @@ fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect:
     }
 }
 
+/// How much one point of wheel motion zooms (as `exp(points × WHEEL_ZOOM)`).
+const WHEEL_ZOOM: f64 = 0.01;
+
+/// What the wheel and a pinch did over the canvas this frame: a zoom factor (about the pointer)
+/// and a scroll (screen points the content moves). The wheel scrolls, Cmd- and Alt-wheel zoom.
+/// With General › Zoom with Mouse Wheel (`wheel_zooms`) the wheel zooms, Shift-wheel scrolls up
+/// and down and Cmd/Ctrl-wheel sideways. `line` and `page`: points per wheel line and page.
+fn wheel(i: &egui::InputState, wheel_zooms: bool, line: f32, page: f32) -> (f64, egui::Vec2) {
+    if !wheel_zooms {
+        // egui makes Cmd-wheel (and a pinch) its zoom and the rest a smoothed scroll.
+        let (zoom, scroll) = (f64::from(i.zoom_delta()), i.smooth_scroll_delta);
+        return if i.modifiers.alt && scroll.y != 0.0 { (zoom * (f64::from(scroll.y) * WHEEL_ZOOM).exp(), egui::Vec2::ZERO) } else { (zoom, scroll) };
+    }
+    // The wheel events themselves: egui's own handling turns Cmd-wheel into a zoom.
+    let mut zoom = i.multi_touch().map_or(1.0, |t| f64::from(t.zoom_delta));
+    let mut scroll = egui::Vec2::ZERO;
+    for e in &i.events {
+        match e {
+            egui::Event::MouseWheel { unit, delta, modifiers, .. } => {
+                let d = match unit {
+                    egui::MouseWheelUnit::Point => *delta,
+                    egui::MouseWheelUnit::Line => *delta * line,
+                    egui::MouseWheelUnit::Page => *delta * page,
+                };
+                if modifiers.command {
+                    scroll.x += d.x + d.y;
+                } else if modifiers.shift {
+                    scroll.y += d.x + d.y;
+                } else {
+                    zoom *= (f64::from(d.y) * WHEEL_ZOOM).exp();
+                    scroll.x += d.x;
+                }
+            }
+            egui::Event::Zoom(f) => zoom *= f64::from(*f),
+            _ => {}
+        }
+    }
+    (zoom, scroll)
+}
+
 /// A Selection tool move dragged off the canvas (to `p`, over a panel) turns into a panel drag of
 /// the selected art ([`widgets::PanelDrag::Art`]): the move is dropped, so the art stays where it
 /// was, and the panel it is released on takes it (the Graphic Styles panel makes a style of it).
@@ -675,28 +724,82 @@ fn checker(p: &egui::Painter, quad: &[Pos2], ab: Rect, zoom: f64, tex: egui::Tex
     p.add(Shape::mesh(mesh));
 }
 
-fn grid(p: &egui::Painter, xf: &Xf, spacing: f64, subdiv: u32) {
+/// The look of the grid or of the guides (Preferences › Guides & Grid › Color and Style).
+#[derive(Clone, Copy)]
+struct LineLook {
+    color: Color32,
+    dots: bool,
+}
+
+impl LineLook {
+    fn grid(prefs: &vectorcraft_engine::Prefs) -> Self {
+        Self { color: pref_color(&prefs.grid_color, Color32::from_gray(200)), dots: prefs.grid_style == "dots" }
+    }
+
+    fn guides(prefs: &vectorcraft_engine::Prefs, t: &Tokens) -> Self {
+        Self { color: pref_color(&prefs.guide_color, t.guide), dots: prefs.guide_style == "dots" }
+    }
+
+    /// A guide from `a` to `b`: a line, or dots.
+    fn guide(self, p: &egui::Painter, a: Pos2, b: Pos2) {
+        if self.dots {
+            p.extend(Shape::dotted_line(&[a, b], self.color, 4.0, 0.75));
+        } else {
+            p.line_segment([a, b], Stroke::new(1.0, self.color));
+        }
+    }
+}
+
+/// A `#rrggbb` colour preference, `fallback` when it doesn't parse.
+fn pref_color(hex: &str, fallback: Color32) -> Color32 {
+    vectorcraft_color::Color::from_hex(hex).map_or(fallback, |c| crate::panels::c32(&c))
+}
+
+/// The grid (View → Show Grid): a gridline every `spacing` and `subdiv` lighter lines between
+/// (left out when they would crowd). In the Dots style, a dot where gridlines cross the
+/// subdivisions instead.
+fn grid(p: &egui::Painter, xf: &Xf, spacing: f64, subdiv: u32, look: LineLook) {
     let r = xf.rect;
     let a = xf.to_doc(r.min);
     let b = xf.to_doc(r.max);
     let sub = spacing / subdiv.max(1) as f64;
     let step = if sub * xf.zoom >= 6.0 { sub } else { spacing };
-    if step * xf.zoom < 4.0 {
+    // Dots crowd sooner than lines.
+    if step * xf.zoom < 4.0 || (look.dots && spacing * xf.zoom < 8.0) {
         return;
     }
-    let mut x = (a.x / step).floor() * step;
-    while x <= b.x {
-        let major = (x / spacing).round() * spacing == x || (x / spacing - (x / spacing).round()).abs() < 1e-6;
-        let sx = xf.to_screen(Point::new(x, 0.0)).x;
-        p.line_segment([pos2(sx, r.top()), pos2(sx, r.bottom())], Stroke::new(1.0, Color32::from_black_alpha(if major { 60 } else { 22 })));
-        x += step;
+    let major = |v: f64| (v / spacing - (v / spacing).round()).abs() < 1e-6;
+    // The lines across the view, on screen, each with whether it is a gridline.
+    let lines = |from: f64, to: f64, screen: &dyn Fn(f64) -> f32| {
+        let mut v = (from / step).floor() * step;
+        let mut out = vec![];
+        while v <= to {
+            out.push((screen(v), major(v)));
+            v += step;
+        }
+        out
+    };
+    let xs = lines(a.x, b.x, &|x| xf.to_screen(Point::new(x, 0.0)).x);
+    let ys = lines(a.y, b.y, &|y| xf.to_screen(Point::new(0.0, y)).y);
+    if look.dots {
+        let mut mesh = egui::Mesh::default();
+        for &(x, mx) in &xs {
+            for &(y, my) in &ys {
+                if mx || my {
+                    mesh.add_colored_rect(egui::Rect::from_center_size(pos2(x, y), vec2(1.5, 1.5)), look.color);
+                }
+            }
+        }
+        p.add(Shape::mesh(mesh));
+        return;
     }
-    let mut y = (a.y / step).floor() * step;
-    while y <= b.y {
-        let major = (y / spacing - (y / spacing).round()).abs() < 1e-6;
-        let sy = xf.to_screen(Point::new(0.0, y)).y;
-        p.line_segment([pos2(r.left(), sy), pos2(r.right(), sy)], Stroke::new(1.0, Color32::from_black_alpha(if major { 60 } else { 22 })));
-        y += step;
+    let minor = look.color.gamma_multiply(0.4);
+    let stroke = |major: bool| Stroke::new(1.0, if major { look.color } else { minor });
+    for (x, m) in xs {
+        p.line_segment([pos2(x, r.top()), pos2(x, r.bottom())], stroke(m));
+    }
+    for (y, m) in ys {
+        p.line_segment([pos2(r.left(), y), pos2(r.right(), y)], stroke(m));
     }
 }
 
@@ -717,24 +820,33 @@ fn ruler_rects(full: egui::Rect) -> [egui::Rect; 3] {
 }
 
 /// A drag from a ruler onto the canvas makes a guide where the button is released: a horizontal
-/// one from the top ruler, a vertical one from the left ruler. Released anywhere else, it makes
-/// none.
+/// one from the top ruler, a vertical one from the left ruler; with Shift on the nearest ruler
+/// tick. Released anywhere else, it makes none.
 fn ruler_guides(app: &mut VectorcraftApp, ui: &Ui, full: egui::Rect, canvas: egui::Rect, xf: &Xf, t: &Tokens) {
     let [top, left, _] = ruler_rects(full);
+    let shift = ui.input(|i| i.modifiers.shift);
     for (r, vertical, id) in [(top, false, "ruler-top"), (left, true, "ruler-left")] {
         let resp = ui.interact(r, egui::Id::new(id), Sense::drag());
         let Some(p) = resp.interact_pointer_pos().filter(|p| canvas.contains(*p)) else { continue };
+        let d = xf.to_doc(p);
+        let mut pos = if vertical { d.x } else { d.y };
+        if shift {
+            pos = app.session.general_unit().snap_to_ruler_tick(pos, xf.zoom);
+        }
         if resp.drag_stopped() {
-            let d = xf.to_doc(p);
             // The new guide shows even if guides were hidden.
             app.ui.view.guides = true;
-            if let Err(e) = app.run("guide.add", json!({ "vertical": vertical, "pos": if vertical { d.x } else { d.y } })) {
+            if let Err(e) = app.run("guide.add", json!({ "vertical": vertical, "pos": pos })) {
                 app.status(e);
             }
         } else if resp.dragged() {
-            let line =
-                if vertical { [pos2(p.x, canvas.top()), pos2(p.x, canvas.bottom())] } else { [pos2(canvas.left(), p.y), pos2(canvas.right(), p.y)] };
-            ui.painter_at(canvas).line_segment(line, Stroke::new(1.0, t.guide));
+            let at = xf.to_screen(if vertical { Point::new(pos, d.y) } else { Point::new(d.x, pos) });
+            let (a, b) = if vertical {
+                (pos2(at.x, canvas.top()), pos2(at.x, canvas.bottom()))
+            } else {
+                (pos2(canvas.left(), at.y), pos2(canvas.right(), at.y))
+            };
+            LineLook::guides(&app.session.prefs, t).guide(&ui.painter_at(canvas), a, b);
         }
     }
 }
@@ -753,8 +865,7 @@ fn rulers(ui: &Ui, full: egui::Rect, xf: &Xf, hover: Option<Point>, unit: Unit,
     // Pick a label step (in `unit`) that gives ≥ 50 px between labels; positions below are in `unit`
     // (`per` points each).
     let per = unit.points();
-    let steps = [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];
-    let step = steps.iter().copied().find(|s| s * per * xf.zoom >= 50.0).unwrap_or(10000.0);
+    let step = unit.ruler_step(xf.zoom);
     let minor = step / 10.0;
     let font = egui::FontId::proportional(9.5);
     let a = xf.to_doc(top.left_top());
@@ -895,9 +1006,15 @@ fn walk_drawn<'a>(n: &'a Node, f: &mut impl FnMut(&'a Node)) {
     }
 }
 
-/// The topmost editable object under document point `p` at `zoom` (3 px tolerance).
+/// The topmost editable object under document point `p` at `zoom`, as the selection tools pick it
+/// (Selection & Anchor Display › Tolerance and Object Selection by Path Only).
 fn hit_at(app: &VectorcraftApp, p: Point, zoom: f64) -> Option<vectorcraft_doc::hit::Hit> {
-    let opt = vectorcraft_doc::hit::HitOptions { tol: 3.0 / zoom, outline: app.ui.view.outline, path_only: false };
+    let prefs = &app.session.prefs;
+    let opt = vectorcraft_doc::hit::HitOptions {
+        tol: prefs.selection_tolerance / zoom,
+        outline: app.ui.view.outline,
+        path_only: prefs.object_selection_by_path_only,
+    };
     vectorcraft_doc::hit::hit_test(&app.session.active()?.doc, p, opt)
 }
 
@@ -1001,6 +1118,31 @@ fn selected_anchor(c: Color32) -> Color32 {
     if c == Color32::from_rgb(0x4f, 0x80, 0xff) { Color32::from_rgb(0x3d, 0x82, 0xff) } else { c }
 }
 
+/// How anchors and handles look: Selection & Anchor Display › Size and Handles.
+#[derive(Clone, Copy)]
+struct HandleLook<'a> {
+    /// Points bigger (or smaller) than the default size 3, per step of Size (1–7).
+    grow: f32,
+    /// `solid` (the default), `hollow` or `large`.
+    style: &'a str,
+}
+
+impl<'a> HandleLook<'a> {
+    fn of(prefs: &'a vectorcraft_engine::Prefs) -> Self {
+        Self { grow: prefs.anchor_size.clamp(1, 7) as f32 - 3.0, style: &prefs.handle_style }
+    }
+
+    /// A direction handle's end at `c`: a solid dot, a hollow one or a larger solid one.
+    fn draw(self, p: &egui::Painter, c: Pos2, color: Color32) {
+        let r = 2.75 + self.grow / 2.0;
+        let hollow = self.style == "hollow";
+        p.circle_filled(c, if self.style == "large" { r + 1.5 } else { r }, if hollow { Color32::WHITE } else { color });
+        if hollow {
+            p.circle_stroke(c, r, Stroke::new(1.0, color));
+        }
+    }
+}
+
 fn anchor_square(p: &egui::Painter, c: Pos2, color: Color32, filled: bool, size: f32) {
     let r = egui::Rect::from_center_size(c, vec2(size, size));
     if filled {
@@ -1090,10 +1232,7 @@ fn slice_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
         return;
     }
     let prefs = &app.session.prefs;
-    let line = vectorcraft_color::Color::from_hex(&prefs.slice_line_color).map_or(Color32::from_rgb(0xff, 0x3f, 0x3f), |c| {
-        let [r, g, b, _] = c.to_rgba8(1.0);
-        Color32::from_rgb(r, g, b)
-    });
+    let line = pref_color(&prefs.slice_line_color, Color32::from_rgb(0xff, 0x3f, 0x3f));
     let dim = line.gamma_multiply(0.55);
     let selected = &st.selection.slices;
     let objects = &st.selection.objects;
@@ -1163,6 +1302,14 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
     let Some(st) = app.session.active() else { return };
     let tool = app.session.tool_id();
     let direct = matches!(tool, "directSelection" | "pen" | "addAnchor" | "deleteAnchor" | "anchorPoint" | "curvature");
+    // Selection & Anchor Display › Size (1–7, 3 the default): anchors, handles and the bounding
+    // box's handles a point bigger or smaller per step.
+    let look = HandleLook::of(&app.session.prefs);
+    let grow = look.grow;
+    let anchor = |direct: bool| grow + if direct { 5.0 } else { 4.0 };
+    // The selected anchors' handles (drawn once they are counted: Show handles when multiple
+    // anchors are selected off shows them for a single one only).
+    let (mut handles, mut with_handles) = (vec![], 0);
     for id in &st.selection.objects {
         let Some(n) = st.doc.node(*id) else { continue };
         let color = c32(st.doc.layer_color(*id));
@@ -1173,7 +1320,7 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
         walk_drawn(n, &mut |c| {
             if let Some((_, Some(grid))) = vectorcraft_doc::live::envelope_overlay(c) {
                 for q in &grid.points {
-                    anchor_square(p, xf.to_screen(q.p), color, false, if direct { 5.0 } else { 4.0 });
+                    anchor_square(p, xf.to_screen(q.p), color, false, anchor(direct));
                 }
                 return;
             }
@@ -1185,28 +1332,17 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
                 };
                 let sp = xf.to_screen(a.p);
                 if sel && (direct || partial.is_some()) {
-                    for h in [a.h_in, a.h_out] {
-                        if h.distance(a.p) > 1e-6 {
-                            let hp = xf.to_screen(h);
-                            p.line_segment([sp, hp], Stroke::new(1.0, color));
-                            p.circle_filled(hp, 2.75, color);
-                        }
-                    }
+                    with_handles += 1;
+                    handles.extend([a.h_in, a.h_out].into_iter().filter(|h| h.distance(a.p) > 1e-6).map(|h| (sp, xf.to_screen(h), color)));
                 }
-                anchor_square(
-                    p,
-                    sp,
-                    if sel && partial.is_some() { selected_anchor(color) } else { color },
-                    sel,
-                    if partial.is_some() || direct { 5.0 } else { 4.0 },
-                );
+                anchor_square(p, sp, if sel && partial.is_some() { selected_anchor(color) } else { color }, sel, anchor(partial.is_some() || direct));
             }
         });
         // Centre point (Attributes panel → Show Center).
         if n.shows_center()
             && let Some(b) = n.geometric_bounds()
         {
-            anchor_square(p, xf.to_screen(b.center()), color, true, 4.0);
+            anchor_square(p, xf.to_screen(b.center()), color, true, anchor(false));
         }
         // Text: baseline marker (area type shows its frame instead, which may not be a rectangle).
         if let NodeKind::Text(tx) = &n.kind
@@ -1219,6 +1355,12 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
             p.circle_filled(o, 2.5, color);
         }
     }
+    if app.session.prefs.show_handles_multiple_anchors || with_handles <= 1 {
+        for (sp, hp, color) in handles {
+            p.line_segment([sp, hp], Stroke::new(1.0, color));
+            look.draw(p, hp, color);
+        }
+    }
     // The spine of each selected blend (or of the blend a selected key object belongs to).
     let mut spines = vec![];
     for id in &st.selection.objects {
@@ -1230,16 +1372,17 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
         let color = c32(st.doc.layer_color(b));
         stroke_path(p, &path.to_bezpath(), xf, Stroke::new(1.0, color));
         for (_, _, a) in path.anchors() {
-            anchor_square(p, xf.to_screen(a.p), color, false, if direct { 5.0 } else { 4.0 });
+            anchor_square(p, xf.to_screen(a.p), color, false, anchor(direct));
         }
     }
     // Live Corners widgets (Selection / Direct Selection on a single live rectangle).
     if matches!(tool, "selection" | "directSelection")
         && app.ui.view.corner_widgets
         && let Some(w) = vectorcraft_tools::corners::CornerWidgets::of(&st.doc, &st.selection, xf.zoom)
+            .and_then(|w| w.within_angle(app.session.prefs.hide_corner_widget_above))
     {
         let color = c32(st.doc.layer_color(w.id));
-        for sp in w.points.map(|q| xf.to_screen(q)) {
+        for sp in w.visible().map(|q| xf.to_screen(q)) {
             p.circle_filled(sp, 3.0, Color32::WHITE);
             p.circle_stroke(sp, 3.0, Stroke::new(1.0, color));
             p.circle_filled(sp, 1.0, color);
@@ -1251,7 +1394,7 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
         p.add(Shape::closed_line(b.corners().iter().map(|q| xf.to_screen(*q)).collect(), Stroke::new(1.0, color)));
         for h in vectorcraft_tools::bbox::Handle::ALL {
             let c = xf.to_screen(b.to_doc() * h.pos(b.rect));
-            let hr = egui::Rect::from_center_size(c, vec2(6.0, 6.0));
+            let hr = egui::Rect::from_center_size(c, vec2(6.0 + grow, 6.0 + grow));
             p.rect_filled(hr, 0.0, Color32::WHITE);
             p.rect_stroke(hr, 0.0, Stroke::new(1.0, color), StrokeKind::Inside);
         }
@@ -1286,7 +1429,7 @@ fn names_an_artboard(text: &str) -> bool {
     text.split_once(" - ").is_some_and(|(n, _)| n.len() >= 2 && n.bytes().all(|b| b.is_ascii_digit()))
 }
 
-fn draw_overlays(p: &egui::Painter, xf: &Xf, overlays: &[Overlay], t: &Tokens) {
+fn draw_overlays(p: &egui::Painter, xf: &Xf, overlays: &[Overlay], t: &Tokens, look: HandleLook) {
     for o in overlays {
         match o {
             Overlay::Marquee(r) => {
@@ -1316,9 +1459,7 @@ fn draw_overlays(p: &egui::Painter, xf: &Xf, overlays: &[Overlay], t: &Tokens) {
                 }
             }
             Overlay::Anchor { p: pt, color, filled, size } => anchor_square(p, xf.to_screen(*pt), c32(*color), *filled, *size),
-            Overlay::Handle { p: pt, color } => {
-                p.circle_filled(xf.to_screen(*pt), 2.8, c32(*color));
-            }
+            Overlay::Handle { p: pt, color } => look.draw(p, xf.to_screen(*pt), c32(*color)),
             Overlay::Label { p: pt, text, color } => {
                 let sp = xf.to_screen(*pt) + vec2(8.0, -14.0);
                 p.text(
@@ -1592,6 +1733,69 @@ mod tests {
         assert_eq!(app.session.active().unwrap().doc.art_bounds(), None, "the tool drew nothing");
     }
 
+    /// #414: guides dragged out of the rulers are picked and dragged with the Selection tool
+    /// (highlighted while selected), go with Delete or Backspace, and dragged back onto their
+    /// ruler.
+    #[test]
+    fn the_selection_tool_moves_and_deletes_ruler_guides() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+        // A square under the guides: the press takes the guide.
+        app.session.execute("shape.rectangle", &json!({"x": 50, "y": 50, "width": 300, "height": 200})).unwrap();
+        app.session.execute("select.none", &json!({})).unwrap();
+        let art = app.session.active().unwrap().doc.art_bounds();
+        app.ui.view.rulers = true;
+        app.select_tool("selection");
+        let ctx = egui::Context::default();
+        frame(&mut app, &ctx, vec![]);
+        let rect = app.canvas_rect.unwrap();
+        let xf = Xf::new(rect, app.view().unwrap());
+        let button = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+        let drag = |app: &mut VectorcraftApp, from: Pos2, to: Pos2| {
+            frame(app, &ctx, vec![egui::Event::PointerMoved(from)]);
+            frame(app, &ctx, vec![button(from, true)]);
+            frame(app, &ctx, vec![egui::Event::PointerMoved(to)]);
+            frame(app, &ctx, vec![button(to, false)]);
+        };
+        let guides = |app: &VectorcraftApp| app.session.active().unwrap().doc.guides.iter().map(|g| (g.vertical, g.pos)).collect::<Vec<_>>();
+        // Two guides out of the rulers.
+        let (h, v) = (pos2(rect.center().x + 30.0, rect.center().y + 20.0), pos2(rect.center().x - 40.0, rect.center().y));
+        drag(&mut app, pos2(h.x, rect.top() - RULER / 2.0), h);
+        drag(&mut app, pos2(rect.left() - RULER / 2.0, v.y), v);
+        assert_eq!(guides(&app), [(false, xf.to_doc(h).y), (true, xf.to_doc(v).x)]);
+        // Drag the horizontal one down 30 px (across the vertical one: the nearer is picked).
+        let to = pos2(h.x + 10.0, h.y + 30.0);
+        drag(&mut app, h, to);
+        let st = app.session.active().unwrap();
+        assert_eq!(guides(&app), [(false, xf.to_doc(to).y), (true, xf.to_doc(v).x)]);
+        assert_eq!((st.selection.guides.clone(), st.selection.objects.clone()), (vec![0], vec![]));
+        assert_eq!(st.history.undo.last().unwrap().label, "Move Guide");
+        let picked = Tokens::get(&ctx).selection;
+        let s = shapes(&mut app, &ctx);
+        assert!(s.iter().any(|s| matches!(s, Shape::LineSegment { points, stroke } if stroke.color == picked && points[0].y == to.y)), "highlighted");
+        // Backspace deletes the selected guide; Delete too.
+        let press = |app: &mut VectorcraftApp, key| {
+            let ev = egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE };
+            let mut out = ctx.run_ui(egui::RawInput { events: vec![ev], ..Default::default() }, |ui| crate::shortcuts::handle(app, ui.ctx()));
+            out.textures_delta.clear();
+        };
+        press(&mut app, egui::Key::Backspace);
+        assert_eq!(guides(&app), [(true, xf.to_doc(v).x)]);
+        app.session.execute("guide.select", &json!({"indexes": [0]})).unwrap();
+        press(&mut app, egui::Key::Delete);
+        assert!(guides(&app).is_empty());
+        app.session.execute("edit.undo", &json!({})).unwrap();
+        // Hide Guides deselects them.
+        app.session.execute("guide.select", &json!({"indexes": [0]})).unwrap();
+        app.run("view.guides", json!({})).unwrap();
+        assert!(app.session.active().unwrap().selection.guides.is_empty());
+        app.run("view.guides", json!({})).unwrap();
+        // Dragged back onto its ruler, the vertical guide goes.
+        drag(&mut app, v, pos2(rect.left() - RULER / 2.0, v.y + 20.0));
+        assert!(guides(&app).is_empty(), "{:?}", guides(&app));
+        assert_eq!(app.session.active().unwrap().doc.art_bounds(), art, "the square stayed");
+    }
+
     #[test]
     fn cmd_with_another_tool_drags_with_the_selection_tool_used_last() {
         let mut app = VectorcraftApp::new(Session::new(), Default::default());
@@ -1635,6 +1839,173 @@ mod tests {
         assert_eq!(cmd_drag(&mut app, inside, inside), "selection");
     }
 
+    /// One headless canvas frame → the shapes drawn, `Shape::Vec`s flattened.
+    fn shapes(app: &mut VectorcraftApp, ctx: &egui::Context) -> Vec<Shape> {
+        fn flat(s: Shape, out: &mut Vec<Shape>) {
+            match s {
+                Shape::Vec(v) => v.into_iter().for_each(|s| flat(s, out)),
+                s => out.push(s),
+            }
+        }
+        let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0))), ..Default::default() };
+        let mut out = ctx.run_ui(raw, |ui| show(app, ui));
+        out.textures_delta.clear();
+        let mut v = vec![];
+        out.shapes.into_iter().for_each(|c| flat(c.shape, &mut v));
+        v
+    }
+
+    /// Guides & Grid (#394): the grid in Grid Color, behind the art or, with Grids In Back off,
+    /// over it, as dots in the Dots style; the guides in Guides Color and Style.
+    #[test]
+    fn grid_and_guides_take_their_preferences() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+        app.session.execute("guide.add", &json!({"vertical": true, "pos": 100})).unwrap();
+        app.ui.view.grid = true;
+        app.ui.view.guides = true;
+        let (red, green) = (Color32::from_rgb(255, 0, 0), Color32::from_rgb(0, 255, 0));
+        app.session.execute("prefs.set", &json!({"values": {"gridColor": "#ff0000", "guideColor": "#00ff00"}})).unwrap();
+        let ctx = egui::Context::default();
+        let red_line = |s: &Shape| matches!(s, Shape::LineSegment { stroke, .. } if stroke.color == red);
+        // → (index of the first red gridline, index of the art's image).
+        let order = |app: &mut VectorcraftApp| {
+            let s = shapes(app, &ctx);
+            let art = app.canvas.texture.as_ref().unwrap().id();
+            let image = s.iter().position(|s| matches!(s, Shape::Mesh(m) if m.texture_id == art)).expect("the art");
+            (s.iter().position(red_line).expect("a gridline in Grid Color"), image, s)
+        };
+        let (grid, art, s) = order(&mut app);
+        assert!(grid < art, "Grids In Back: under the art");
+        assert!(s.iter().any(|s| matches!(s, Shape::LineSegment { stroke, .. } if stroke.color == green)), "the guide in Guides Color");
+        app.session.execute("prefs.set", &json!({"key": "gridsInBack", "value": false})).unwrap();
+        let (grid, art, _) = order(&mut app);
+        assert!(grid > art, "Grids In Back off: over the art");
+        app.session.execute("prefs.set", &json!({"values": {"gridStyle": "dots", "guideStyle": "dots"}})).unwrap();
+        let s = shapes(&mut app, &ctx);
+        assert!(!s.iter().any(red_line), "no gridlines in the Dots style");
+        let red_dots = |s: &Shape| matches!(s, Shape::Mesh(m) if m.vertices.len() > 40 && m.vertices.iter().all(|v| v.color == red));
+        assert!(s.iter().any(red_dots), "the grid's dots");
+        assert!(s.iter().any(|s| matches!(s, Shape::Circle(c) if c.fill == green)), "the guide dotted");
+    }
+
+    /// Selection & Anchor Display › Size (#394): anchors and the bounding box's handles grow.
+    #[test]
+    fn anchor_size_scales_anchors_and_handles() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+        app.session.execute("shape.rectangle", &json!({"x": 150, "y": 100, "width": 100, "height": 100})).unwrap();
+        let ctx = egui::Context::default();
+        // The sizes of the squares drawn (anchors and handles are squares).
+        let sizes = |app: &mut VectorcraftApp| {
+            let mut v: Vec<f32> = shapes(app, &ctx).iter().filter_map(|s| if let Shape::Rect(r) = s { Some(r.rect.width()) } else { None }).collect();
+            v.sort_by(f32::total_cmp);
+            v.dedup();
+            v
+        };
+        let small = sizes(&mut app);
+        assert!(small.contains(&4.0) && small.contains(&6.0), "anchors 4, handles 6 by default: {small:?}");
+        app.session.execute("prefs.set", &json!({"key": "anchorSize", "value": 7})).unwrap();
+        let big = sizes(&mut app);
+        assert!(big.contains(&8.0) && big.contains(&10.0) && !big.contains(&4.0), "4 points bigger at 7: {big:?}");
+    }
+
+    /// Selection & Anchor Display › Handles and Show handles when multiple anchors are selected
+    /// (#394): handle ends drawn solid, hollow or large; with the latter off, a second selected
+    /// anchor hides the handles.
+    #[test]
+    fn handle_style_and_handles_of_multiple_anchors() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+        let id = app.session.execute("shape.ellipse", &json!({"x": 100, "y": 100, "width": 100, "height": 100})).unwrap()["id"].clone();
+        app.session.select_tool("directSelection", app.view_info()).unwrap();
+        let ctx = egui::Context::default();
+        let select = |app: &mut VectorcraftApp, anchors: serde_json::Value| {
+            app.session.execute("select.anchors", &json!({"id": id, "anchors": anchors, "mode": "set"})).unwrap();
+        };
+        // The handle ends: (radius, filled white).
+        let dots = |app: &mut VectorcraftApp| -> Vec<(f32, bool)> {
+            shapes(app, &ctx)
+                .iter()
+                .filter_map(|s| match s {
+                    Shape::Circle(c) if c.fill != Color32::TRANSPARENT => Some((c.radius, c.fill == Color32::WHITE)),
+                    _ => None,
+                })
+                .collect()
+        };
+        select(&mut app, json!([[0, 0]]));
+        assert_eq!(dots(&mut app), [(2.75, false); 2], "solid by default");
+        app.session.execute("prefs.set", &json!({"key": "handleStyle", "value": "hollow"})).unwrap();
+        assert_eq!(dots(&mut app), [(2.75, true); 2]);
+        app.session.execute("prefs.set", &json!({"key": "handleStyle", "value": "large"})).unwrap();
+        assert_eq!(dots(&mut app), [(4.25, false); 2]);
+        select(&mut app, json!([[0, 0], [0, 1]]));
+        assert_eq!(dots(&mut app).len(), 4, "both anchors' handles");
+        app.session.execute("prefs.set", &json!({"key": "showHandlesMultipleAnchors", "value": false})).unwrap();
+        assert!(dots(&mut app).is_empty(), "off: none for two anchors");
+        select(&mut app, json!([[0, 1]]));
+        assert_eq!(dots(&mut app).len(), 2, "one anchor still shows them");
+    }
+
+    /// Hide Corner Widget for angles greater than (#394): a rectangle's 90° corners lose their
+    /// widgets below 90°.
+    #[test]
+    fn corner_widgets_hide_above_the_preference_angle() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+        app.session.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 100, "height": 100})).unwrap();
+        let ctx = egui::Context::default();
+        let widgets = |app: &mut VectorcraftApp| {
+            shapes(app, &ctx).iter().filter(|s| matches!(s, Shape::Circle(c) if c.radius == 3.0 && c.fill == Color32::WHITE)).count()
+        };
+        assert_eq!(widgets(&mut app), 4);
+        app.session.execute("prefs.set", &json!({"key": "hideCornerWidgetAbove", "value": 80})).unwrap();
+        assert_eq!(widgets(&mut app), 0);
+    }
+
+    /// General › Zoom with Mouse Wheel (#394), through the control channel's `ui.wheel`: off,
+    /// the wheel scrolls and Cmd-wheel zooms; on, the wheel zooms about the pointer, Shift-wheel
+    /// scrolls up and down and Cmd/Ctrl-wheel sideways.
+    #[test]
+    fn zoom_with_mouse_wheel_preference() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+        let ctx = egui::Context::default();
+        // A canvas frame through the host's input hook (it feeds the control channel's input).
+        let run = |app: &mut VectorcraftApp| {
+            let mut raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0))), ..Default::default() };
+            app.raw_input_hook(&mut raw);
+            let mut out = ctx.run_ui(raw, |ui| show(app, ui));
+            out.textures_delta.clear();
+        };
+        run(&mut app);
+        let rect = app.canvas_rect.unwrap();
+        let at = rect.center() + vec2(60.0, 40.0);
+        // One notch up at `at`: → (zoom ratio, scroll in points, how far the point under `at` moved).
+        let turn = |app: &mut VectorcraftApp, shift: bool, cmd: bool| {
+            let before = *app.view().unwrap();
+            crate::tests_synthetic::control(app, &ctx, "ui.wheel", json!({"x": at.x, "y": at.y, "dy": 1, "shift": shift, "cmd": cmd}));
+            // egui spreads a notch over a few frames.
+            for _ in 0..40 {
+                run(app);
+            }
+            let after = *app.view().unwrap();
+            let moved = Xf::new(rect, &after).to_doc(at).distance(Xf::new(rect, &before).to_doc(at));
+            (after.zoom / before.zoom, (after.center - before.center) * after.zoom, moved)
+        };
+        let (zoom, scroll, _) = turn(&mut app, false, false);
+        assert!((zoom - 1.0).abs() < 1e-9 && scroll.x == 0.0 && scroll.y < -1.0, "off: the wheel scrolls up ({zoom}, {scroll:?})");
+        let (zoom, _, moved) = turn(&mut app, false, true);
+        assert!(zoom > 1.01 && moved < 1e-6, "off: Cmd-wheel zooms in about the pointer ({zoom}, {moved})");
+        app.session.execute("prefs.set", &json!({"key": "zoomWithMouseWheel", "value": true})).unwrap();
+        let (zoom, _, moved) = turn(&mut app, false, false);
+        assert!(zoom > 1.01 && moved < 1e-6, "on: the wheel zooms in about the pointer ({zoom}, {moved})");
+        let (zoom, scroll, _) = turn(&mut app, true, false);
+        assert!((zoom - 1.0).abs() < 1e-9 && scroll.x == 0.0 && scroll.y < -1.0, "on: Shift-wheel scrolls up ({zoom}, {scroll:?})");
+        let (zoom, scroll, _) = turn(&mut app, false, true);
+        assert!((zoom - 1.0).abs() < 1e-9 && scroll.x < -1.0 && scroll.y == 0.0, "on: Cmd-wheel scrolls sideways ({zoom}, {scroll:?})");
+    }
+
     #[test]
     fn cmd_space_zooms_and_space_pans_whatever_the_tool() {
         use egui::{Event, Modifiers};
@@ -1985,6 +2356,8 @@ mod tests {
     #[test]
     fn japanese_ime_composes_on_the_canvas_with_its_window_at_the_caret() {
         let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        // The type placed starts empty (Fill New Type Objects With Placeholder Text off).
+        app.session.prefs.placeholder_text = false;
         app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
         let ctx = egui::Context::default();
         // Not editing: the IME stays off (single-key tool shortcuts keep working).

crates/ui-egui/src/control.rs

@@ -105,6 +105,13 @@ fn key_from(name: &str) -> Option<egui::Key> {
     })
 }
 
+/// The modifier keys a request holds down (`cmd`, `ctrl`, `alt`, `shift`; `cmd` is Command on
+/// macOS, Ctrl elsewhere).
+fn modifiers(p: &Value) -> egui::Modifiers {
+    let b = |n: &str| p.get(n).and_then(Value::as_bool).unwrap_or(false);
+    egui::Modifiers { alt: b("alt"), ctrl: b("ctrl"), shift: b("shift"), mac_cmd: b("cmd") && cfg!(target_os = "macos"), command: b("cmd") }
+}
+
 pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context, req: &ControlRequest) -> Outcome {
     let p = &req.params;
     let s = |k: &str| p.get(k).and_then(Value::as_str);
@@ -116,7 +123,7 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context, req: &ControlReques
             wrap(app.run(id, params))
         }
         "engine.commands" => ok(all_commands(app)),
-        "document.inspect" => wrap(app.run("document.inspect", json!({}))),
+        "document.inspect" => wrap(app.run("document.inspect", p.clone())),
         "ui.inspect" => ok(inspect(app, ctx)),
         "ui.menu.list" => ok(serde_json::to_value(crate::menus::menu_entries(app)).unwrap_or_default()),
         "ui.contextMenu.list" => ok(serde_json::to_value(crate::menus::context_entries(app)).unwrap_or_default()),
@@ -159,14 +166,7 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context, req: &ControlReques
         }
         "ui.key" => {
             let Some(k) = s("key").and_then(key_from) else { return err("unknown or missing `key`") };
-            let b = |n: &str| p.get(n).and_then(Value::as_bool).unwrap_or(false);
-            let m = egui::Modifiers {
-                alt: b("alt"),
-                ctrl: b("ctrl"),
-                shift: b("shift"),
-                mac_cmd: b("cmd") && cfg!(target_os = "macos"),
-                command: b("cmd"),
-            };
+            let m = modifiers(p);
             app.synthetic.push(egui::Event::Key { key: k, physical_key: None, pressed: true, repeat: false, modifiers: m });
             // Typed text comes with the press, so it shares the key's frame and modifiers.
             if let Some(t) = s("text") {
@@ -189,14 +189,7 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context, req: &ControlReques
                 Some("right") | Some("secondary") => egui::PointerButton::Secondary,
                 _ => egui::PointerButton::Primary,
             };
-            let b = |n: &str| p.get(n).and_then(Value::as_bool).unwrap_or(false);
-            let modifiers = egui::Modifiers {
-                alt: b("alt"),
-                ctrl: b("ctrl"),
-                shift: b("shift"),
-                mac_cmd: b("cmd") && cfg!(target_os = "macos"),
-                command: b("cmd"),
-            };
+            let modifiers = modifiers(p);
             let a = egui::pos2(f("x"), f("y"));
             let end = if req.method == "ui.drag" { egui::pos2(f("toX"), f("toY")) } else { a };
             app.synthetic.push(egui::Event::PointerMoved(a));
@@ -217,6 +210,18 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context, req: &ControlReques
             ctx.request_repaint();
             ok(Value::Null)
         }
+        "ui.wheel" => {
+            // Mouse wheel notches over screen point (x, y): `dy` up (+) or down, `dx` sideways
+            // (`unit: "point"` for trackpad-like points), with modifiers as `ui.click` takes them.
+            let f = |k: &str| p.get(k).and_then(Value::as_f64).unwrap_or(0.0) as f32;
+            let unit = if s("unit") == Some("point") { egui::MouseWheelUnit::Point } else { egui::MouseWheelUnit::Line };
+            // Notches, not a flood: a turn stays within what a real wheel sends.
+            let delta = egui::vec2(f("dx"), f("dy")).clamp(egui::Vec2::splat(-100.0), egui::Vec2::splat(100.0));
+            app.synthetic.push(egui::Event::PointerMoved(egui::pos2(f("x"), f("y"))));
+            app.synthetic.push(egui::Event::MouseWheel { unit, delta, phase: egui::TouchPhase::Move, modifiers: modifiers(p) });
+            ctx.request_repaint();
+            ok(Value::Null)
+        }
         "ui.text" => {
             app.synthetic.push(egui::Event::Text(s("text").unwrap_or("").to_string()));
             ctx.request_repaint();

crates/ui-egui/src/credits.rs

@@ -0,0 +1,404 @@
+//! The About window's credits: every contributor (GitHub login always; display and real names only
+//! with recorded consent) and the AI models that helped. The tables are baked into the binary by
+//! build.rs from contributors/contributors.json (craftrules standards/contributors.md); nothing is
+//! read at run time.
+
+use std::cmp::Ordering;
+
+use egui::RichText;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Contributor {
+    pub login: &'static str,
+    pub display_name: Option<&'static str>,
+    pub real_name: Option<&'static str>,
+    pub prs: u64,
+    pub commits: u64,
+    pub lines_added: u64,
+    pub lines_deleted: u64,
+    pub binary_added: u64,
+    pub binary_deleted: u64,
+    /// ISO 8601 UTC; empty for someone credited only through a merged PR.
+    pub first_commit: &'static str,
+    pub last_commit: &'static str,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Model {
+    pub company: &'static str,
+    pub model: &'static str,
+    pub version: &'static str,
+    pub commits: u64,
+    pub lines_added: u64,
+    pub lines_deleted: u64,
+}
+
+include!(concat!(env!("OUT_DIR"), "/credits.rs"));
+
+/// Which name to show. Display and real names fall back to the `@username` when not given.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum NameMode {
+    #[default]
+    Username,
+    DisplayName,
+    RealName,
+}
+
+impl NameMode {
+    pub const ALL: [NameMode; 3] = [NameMode::Username, NameMode::DisplayName, NameMode::RealName];
+
+    pub fn label(self) -> &'static str {
+        match self {
+            NameMode::Username => tl!("Username"),
+            NameMode::DisplayName => tl!("Display name"),
+            NameMode::RealName => tl!("Real name"),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum SortKey {
+    Name,
+    Prs,
+    Commits,
+    LinesAdded,
+    LinesDeleted,
+    LinesDelta,
+    BinaryAdded,
+    BinaryDeleted,
+    #[default]
+    FirstCommit,
+    LastCommit,
+}
+
+impl SortKey {
+    pub const ALL: [SortKey; 10] = [
+        SortKey::Name,
+        SortKey::Prs,
+        SortKey::Commits,
+        SortKey::LinesAdded,
+        SortKey::LinesDeleted,
+        SortKey::LinesDelta,
+        SortKey::BinaryAdded,
+        SortKey::BinaryDeleted,
+        SortKey::FirstCommit,
+        SortKey::LastCommit,
+    ];
+
+    /// Menu label and table header, in the UI language (the short count headers stay as they are).
+    pub fn label(self) -> (&'static str, &'static str) {
+        match self {
+            SortKey::Name => (tl!("Name (A–Z)"), tl!("Name")),
+            SortKey::Prs => (tl!("Merged PRs"), "PRs"),
+            SortKey::Commits => (tl!("Commits"), tl!("Commits")),
+            SortKey::LinesAdded => (tl!("Lines added"), "+LOC"),
+            SortKey::LinesDeleted => (tl!("Lines deleted"), "−LOC"),
+            SortKey::LinesDelta => (tl!("Line delta"), "ΔLOC"),
+            SortKey::BinaryAdded => (tl!("Binary assets added"), "+Bin"),
+            SortKey::BinaryDeleted => (tl!("Binary assets removed"), "−Bin"),
+            SortKey::FirstCommit => (tl!("First commit"), tl!("First")),
+            SortKey::LastCommit => (tl!("Last commit"), tl!("Last")),
+        }
+    }
+
+    /// Names and dates read naturally oldest/A first; counts read biggest first.
+    pub fn default_ascending(self) -> bool {
+        matches!(self, SortKey::Name | SortKey::FirstCommit | SortKey::LastCommit)
+    }
+}
+
+impl Contributor {
+    pub fn name(&self, mode: NameMode) -> String {
+        let chosen = match mode {
+            NameMode::Username => None,
+            NameMode::DisplayName => self.display_name,
+            NameMode::RealName => self.real_name,
+        };
+        chosen.map_or_else(|| format!("@{}", self.login), str::to_string)
+    }
+
+    pub fn lines_delta(&self) -> i128 {
+        i128::from(self.lines_added) - i128::from(self.lines_deleted)
+    }
+
+    /// One line with everything we know, for tooltips.
+    pub fn summary(&self) -> String {
+        format!(
+            "@{}: {} PRs, {} commits, +{} / −{} lines (Δ {}), +{} / −{} binary assets, {} – {}",
+            self.login,
+            self.prs,
+            self.commits,
+            group(self.lines_added),
+            group(self.lines_deleted),
+            signed(self.lines_delta()),
+            self.binary_added,
+            self.binary_deleted,
+            day(self.first_commit),
+            day(self.last_commit),
+        )
+    }
+}
+
+/// Alphabetical key: case-insensitive, ignoring the `@` of usernames.
+fn name_key(name: &str) -> String {
+    name.trim_start_matches('@').to_lowercase()
+}
+
+fn compare(a: &Contributor, b: &Contributor, mode: NameMode, key: SortKey) -> Ordering {
+    match key {
+        SortKey::Name => name_key(&a.name(mode)).cmp(&name_key(&b.name(mode))),
+        SortKey::Prs => a.prs.cmp(&b.prs),
+        SortKey::Commits => a.commits.cmp(&b.commits),
+        SortKey::LinesAdded => a.lines_added.cmp(&b.lines_added),
+        SortKey::LinesDeleted => a.lines_deleted.cmp(&b.lines_deleted),
+        SortKey::LinesDelta => a.lines_delta().cmp(&b.lines_delta()),
+        SortKey::BinaryAdded => a.binary_added.cmp(&b.binary_added),
+        SortKey::BinaryDeleted => a.binary_deleted.cmp(&b.binary_deleted),
+        // A PR-only contributor (no commit date) sorts after everyone with a date.
+        SortKey::FirstCommit => dated(a.first_commit).cmp(&dated(b.first_commit)),
+        SortKey::LastCommit => dated(a.last_commit).cmp(&dated(b.last_commit)),
+    }
+}
+
+fn dated(d: &str) -> (bool, &str) {
+    (d.is_empty(), d)
+}
+
+/// Contributors in display order. Ties fall back to the name (A–Z) so the order is stable.
+pub fn sorted(list: &[Contributor], mode: NameMode, key: SortKey, ascending: bool) -> Vec<&Contributor> {
+    let mut v: Vec<&Contributor> = list.iter().collect();
+    v.sort_by(|a, b| {
+        let o = compare(a, b, mode, key);
+        let o = if ascending { o } else { o.reverse() };
+        o.then_with(|| compare(a, b, mode, SortKey::Name)).then_with(|| a.login.cmp(b.login))
+    });
+    v
+}
+
+fn group(n: u64) -> String {
+    let s = n.to_string();
+    let mut out = String::with_capacity(s.len() + s.len() / 3);
+    for (i, ch) in s.chars().enumerate() {
+        if i > 0 && (s.len() - i).is_multiple_of(3) {
+            out.push(',');
+        }
+        out.push(ch);
+    }
+    out
+}
+
+fn signed(n: i128) -> String {
+    let g = group(u64::try_from(n.unsigned_abs()).unwrap_or(u64::MAX));
+    if n < 0 { format!("−{g}") } else { format!("+{g}") }
+}
+
+fn day(iso: &str) -> &str {
+    if iso.is_empty() { "—" } else { iso.get(..10).unwrap_or(iso) }
+}
+
+/// The About window doesn't resize: long lists scroll inside it.
+const SCROLL_HEIGHT: f32 = 340.0;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct View {
+    names: NameMode,
+    key: SortKey,
+    ascending: bool,
+    table: bool,
+}
+
+impl Default for View {
+    fn default() -> Self {
+        View { names: NameMode::Username, key: SortKey::FirstCommit, ascending: true, table: false }
+    }
+}
+
+/// About ▸ Contributors: a name toggle, a sort, and the list as a grab bag or a table.
+pub fn contributors_ui(ui: &mut egui::Ui) {
+    let id = egui::Id::new("credits_view");
+    let mut v = ui.data_mut(|d| d.get_temp::<View>(id)).unwrap_or_default();
+    ui.horizontal_wrapped(|ui| {
+        ui.label(tl!("Show"));
+        for m in NameMode::ALL {
+            if ui.selectable_label(v.names == m, m.label()).clicked() {
+                v.names = m;
+            }
+        }
+        ui.separator();
+        ui.label(tl!("Sort"));
+        egui::ComboBox::from_id_salt("credits_sort").selected_text(v.key.label().0).show_ui(ui, |ui| {
+            for k in SortKey::ALL {
+                if ui.selectable_label(v.key == k, k.label().0).clicked() {
+                    v.key = k;
+                    v.ascending = k.default_ascending();
+                }
+            }
+        });
+        if ui.button(if v.ascending { "▲" } else { "▼" }).on_hover_text(tl!("Reverse the order")).clicked() {
+            v.ascending = !v.ascending;
+        }
+        ui.separator();
+        if ui.selectable_label(!v.table, tl!("Grab bag")).clicked() {
+            v.table = false;
+        }
+        if ui.selectable_label(v.table, tl!("Table")).clicked() {
+            v.table = true;
+        }
+    });
+    let list = sorted(CONTRIBUTORS, v.names, v.key, v.ascending);
+    let (people, commits) = (group(list.len() as u64), group(TOTAL_COMMITS));
+    let counts = crate::i18n::fmt(tl!("{people} contributors · {commits} commits"), &[("people", &people), ("commits", &commits)]);
+    ui.label(RichText::new(counts).small().weak());
+    ui.separator();
+    egui::ScrollArea::both().max_height(SCROLL_HEIGHT).auto_shrink([false, true]).show(ui, |ui| {
+        if list.is_empty() {
+            ui.label(tl!("No contributor data was built into this copy."));
+        } else if v.table {
+            table(ui, &list, &mut v);
+        } else {
+            ui.horizontal_wrapped(|ui| {
+                for (i, c) in list.iter().enumerate() {
+                    if i > 0 {
+                        ui.label(RichText::new("·").weak());
+                    }
+                    ui.hyperlink_to(c.name(v.names), format!("https://github.com/{}", c.login)).on_hover_text(c.summary());
+                }
+            });
+        }
+    });
+    ui.data_mut(|d| d.insert_temp(id, v));
+}
+
+fn table(ui: &mut egui::Ui, list: &[&Contributor], v: &mut View) {
+    egui::Grid::new("credits_table").striped(true).num_columns(SortKey::ALL.len()).show(ui, |ui| {
+        for k in SortKey::ALL {
+            let arrow = if v.key == k { if v.ascending { " ▲" } else { " ▼" } } else { "" };
+            if ui.button(RichText::new(format!("{}{arrow}", k.label().1)).strong()).on_hover_text(k.label().0).clicked() {
+                if v.key == k {
+                    v.ascending = !v.ascending;
+                } else {
+                    v.key = k;
+                    v.ascending = k.default_ascending();
+                }
+            }
+        }
+        ui.end_row();
+        for c in list {
+            ui.hyperlink_to(c.name(v.names), format!("https://github.com/{}", c.login)).on_hover_text(c.summary());
+            ui.label(group(c.prs));
+            ui.label(group(c.commits));
+            ui.label(group(c.lines_added));
+            ui.label(group(c.lines_deleted));
+            ui.label(signed(c.lines_delta()));
+            ui.label(group(c.binary_added));
+            ui.label(group(c.binary_deleted));
+            ui.label(day(c.first_commit));
+            ui.label(day(c.last_commit));
+            ui.end_row();
+        }
+    });
+}
+
+/// About ▸ Models: AI models credited in Co-Authored-By trailers.
+pub fn models_ui(ui: &mut egui::Ui) {
+    if MODELS.is_empty() {
+        ui.label(tl!("No model credits were built into this copy."));
+        return;
+    }
+    let assisted: u64 = MODELS.iter().map(|m| m.commits).max().unwrap_or(0).max(1);
+    egui::ScrollArea::both().max_height(SCROLL_HEIGHT).auto_shrink([false, true]).show(ui, |ui| {
+        egui::Grid::new("credits_models").striped(true).num_columns(6).show(ui, |ui| {
+            for h in [tl!("Company"), tl!("Model"), tl!("Version"), tl!("Commits"), tl!("% of all commits"), tl!("Lines +/−")] {
+                ui.label(RichText::new(h).strong());
+            }
+            ui.end_row();
+            for m in MODELS {
+                ui.label(m.company);
+                ui.label(m.model);
+                ui.label(m.version);
+                ui.label(group(m.commits));
+                ui.label(format!("{:.0}%", 100.0 * m.commits as f64 / TOTAL_COMMITS.max(assisted) as f64));
+                ui.label(format!("+{} / −{}", group(m.lines_added), group(m.lines_deleted)));
+                ui.end_row();
+            }
+        });
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn c(
+        login: &'static str,
+        display: Option<&'static str>,
+        real: Option<&'static str>,
+        added: u64,
+        deleted: u64,
+        first: &'static str,
+    ) -> Contributor {
+        Contributor {
+            login,
+            display_name: display,
+            real_name: real,
+            prs: 0,
+            commits: 1,
+            lines_added: added,
+            lines_deleted: deleted,
+            binary_added: 0,
+            binary_deleted: 0,
+            first_commit: first,
+            last_commit: first,
+        }
+    }
+
+    fn people() -> [Contributor; 4] {
+        [
+            c("zed", None, None, 5, 50, "2026-01-02T00:00:00Z"),
+            c("Bob", Some("Ann"), None, 10, 0, "2026-01-01T00:00:00Z"),
+            c("alice", None, None, 7, 1, ""),
+            c("carol", None, Some("Dana"), 1, 0, "2026-01-03T00:00:00Z"),
+        ]
+    }
+
+    fn logins(v: &[&Contributor]) -> Vec<&'static str> {
+        v.iter().map(|c| c.login).collect()
+    }
+
+    #[test]
+    fn names_fall_back_to_the_username() {
+        let p = c("bob", Some("Bobby"), None, 0, 0, "");
+        assert_eq!(p.name(NameMode::Username), "@bob");
+        assert_eq!(p.name(NameMode::DisplayName), "Bobby");
+        assert_eq!(p.name(NameMode::RealName), "@bob");
+    }
+
+    #[test]
+    fn alphabetical_ignores_at_and_case() {
+        let all = people();
+        let v = sorted(&all, NameMode::Username, SortKey::Name, true);
+        assert_eq!(logins(&v), ["alice", "Bob", "carol", "zed"]);
+        let v = sorted(&all, NameMode::DisplayName, SortKey::Name, true);
+        assert_eq!(logins(&v), ["alice", "Bob", "carol", "zed"]); // "Ann" sorts with the @usernames
+        let v = sorted(&all, NameMode::RealName, SortKey::Name, false);
+        assert_eq!(logins(&v), ["zed", "carol", "Bob", "alice"]); // "Dana" between bob and zed
+    }
+
+    #[test]
+    fn delta_and_dates() {
+        let all = people();
+        let v = sorted(&all, NameMode::Username, SortKey::LinesDelta, false);
+        assert_eq!(logins(&v), ["Bob", "alice", "carol", "zed"]);
+        let v = sorted(&all, NameMode::Username, SortKey::FirstCommit, true);
+        assert_eq!(logins(&v), ["Bob", "zed", "carol", "alice"]); // undated last
+    }
+
+    #[test]
+    fn formatting() {
+        assert_eq!(group(1234567), "1,234,567");
+        assert_eq!(group(12), "12");
+        assert_eq!(signed(-1000), "−1,000");
+        assert_eq!(day("2026-10-07T18:45:23Z"), "2026-10-07");
+        assert_eq!(day(""), "—");
+    }
+}

crates/ui-egui/src/dialogs/about.rs

@@ -16,32 +16,60 @@ pub(super) fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
         .anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
         .frame(egui::Frame::window(&ctx.global_style()).inner_margin(egui::Margin::same(18)))
         .show(ctx, |ui| {
-            ui.set_width(380.0);
+            // Tabs: About · Contributors · Models (the credits are compiled in, see `credits`).
+            let tab_id = egui::Id::new("about_tab");
+            let mut tab = ui.data_mut(|d| d.get_temp::<u8>(tab_id)).unwrap_or(0);
             ui.horizontal(|ui| {
-                let (r, _) = ui.allocate_exact_size(egui::vec2(44.0, 44.0), egui::Sense::hover());
-                crate::brand::paint_mark(ui, r);
-                ui.vertical(|ui| {
-                    ui.label(egui::RichText::new("VectorCraft").font(theme::semibold(22.0)));
-                    ui.label(crate::i18n::fmt(
-                        tl!("Version {version} — open-source vector illustration in pure Rust."),
-                        &[("version", env!("CARGO_PKG_VERSION"))],
-                    ));
-                });
+                for (i, label) in [tl!("About"), tl!("Contributors"), tl!("Models")].into_iter().enumerate() {
+                    let i = i as u8;
+                    if ui.selectable_label(tab == i, label).clicked() {
+                        tab = i;
+                    }
+                }
             });
-            ui.add_space(12.0);
-            crate::community::links(app, ui);
-            ui.add_space(12.0);
-            ui.label(
-                egui::RichText::new(tl!(
-                    "Part of ArtCraft. MIT OR Apache-2.0. Fonts: Source Sans 3, Inter, JetBrains Mono (OFL). Icons: Lucide (ISC) + VectorCraft."
-                ))
-                .size(11.0),
-            );
-            // The GPU the window renders with, for bug reports (Preferences › Performance picks it).
-            if let Some(adapter) = &app.graphics_adapter {
-                ui.add_space(6.0);
-                ui.label(egui::RichText::new(crate::i18n::fmt(tl!("Graphics: {adapter}"), &[("adapter", adapter.as_str())])).size(11.0));
+            ui.data_mut(|d| d.insert_temp(tab_id, tab));
+            ui.separator();
+            match tab {
+                1 => {
+                    ui.set_width(660.0);
+                    crate::credits::contributors_ui(ui);
+                }
+                2 => {
+                    ui.set_width(660.0);
+                    crate::credits::models_ui(ui);
+                }
+                _ => about_tab(app, ui),
             }
         });
     app.ui.about = open;
 }
+
+/// The About tab: mark, version, community links, licences and the GPU in use.
+fn about_tab(app: &mut VectorcraftApp, ui: &mut egui::Ui) {
+    ui.set_width(380.0);
+    ui.horizontal(|ui| {
+        let (r, _) = ui.allocate_exact_size(egui::vec2(44.0, 44.0), egui::Sense::hover());
+        crate::brand::paint_mark(ui, r);
+        ui.vertical(|ui| {
+            ui.label(egui::RichText::new("VectorCraft").font(theme::semibold(22.0)));
+            ui.label(crate::i18n::fmt(
+                tl!("Version {version} — open-source vector illustration in pure Rust."),
+                &[("version", env!("CARGO_PKG_VERSION"))],
+            ));
+        });
+    });
+    ui.add_space(12.0);
+    crate::community::links(app, ui);
+    ui.add_space(12.0);
+    ui.label(
+        egui::RichText::new(tl!(
+            "Part of ArtCraft. MIT OR Apache-2.0. Fonts: Source Sans 3, Inter, JetBrains Mono (OFL). Icons: Lucide (ISC) + VectorCraft."
+        ))
+        .size(11.0),
+    );
+    // The GPU the window renders with, for bug reports (Preferences › Performance picks it).
+    if let Some(adapter) = &app.graphics_adapter {
+        ui.add_space(6.0);
+        ui.label(egui::RichText::new(crate::i18n::fmt(tl!("Graphics: {adapter}"), &[("adapter", adapter.as_str())])).size(11.0));
+    }
+}

crates/ui-egui/src/dialogs/color_guide_options.rs

@@ -41,13 +41,7 @@ fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
     };
     form::slider(ui, d, "steps", tl!("Steps:"), 1.0..=max, "", &ramp);
     form::slider(ui, d, "amount", tl!("Variation:"), 0.0..=100.0, "%", &ramp);
-    ui.horizontal(|ui| {
-        ui.add_space(form::SLIDER_LABEL + ui.spacing().item_spacing.x);
-        let (r, _) = ui.allocate_exact_size(vec2(form::SLIDER_WIDTH, 14.0), Sense::hover());
-        let font = egui::FontId::proportional(11.0);
-        ui.painter().text(r.left_center(), egui::Align2::LEFT_CENTER, tl!("Less"), font.clone(), t.text_dim);
-        ui.painter().text(r.right_center(), egui::Align2::RIGHT_CENTER, tl!("More"), font, t.text_dim);
-    });
+    form::slider_ends(ui, form::SLIDER_LABEL, (tl!("Less"), tl!("More")));
     ui.add_space(10.0);
     // Preview: the base colour's row of variations.
     let o = options(app, d);

crates/ui-egui/src/dialogs/corners.rs

@@ -0,0 +1,199 @@
+//! Corners: double-clicking a Live Corners widget (or `ui.corners`) sets the corner kind and
+//! radius of a live rectangle's corners: those whose widgets show (the Direct-Selected ones, else
+//! all four). OK runs `object.setLiveShape` for them, one undo step.
+//!
+//! Fields: `id`, `corners` (indices 0–3: top-left, top-right, bottom-right, bottom-left), `kind`
+//! ("round", "invertedRound" or "chamfer") and `radius` (pt). While the corners differ in kind
+//! or radius, that field is absent and OK leaves it as it is.
+
+use serde_json::{Value, json};
+use vectorcraft_engine::doc::{NodeId, NodeKind};
+use vectorcraft_geom::shapes::CornerKind;
+
+use super::swatch_options::{grid, label};
+use super::{DialogSpec, form, run_and_close};
+use crate::state::Dialog;
+use crate::{VectorcraftApp, widgets};
+
+/// The dialog kind of Corners (the corner widgets' double-click).
+pub const KIND: &str = vectorcraft_tools::corners::DIALOG;
+
+pub(super) const SPEC: DialogSpec = DialogSpec { heading: |_| tl!("Corners").into(), body, confirm, min_width: 280.0, ..DialogSpec::FORM };
+
+/// Open Corners for `{id?, corners?}`: the live rectangle `id` (default: the selected one) and its
+/// `corners` (default: the selected corners), filled in with their kind and radius.
+pub fn open(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
+    let st = app.session.active().ok_or("no document")?;
+    let id = match p.get("id").and_then(Value::as_u64) {
+        Some(id) => NodeId(id),
+        None => match st.selection.objects[..] {
+            [id] => id,
+            _ => return Err("select one live rectangle, or give its `id`".into()),
+        },
+    };
+    let Some(NodeKind::Path { live: Some(live @ vectorcraft_engine::doc::LiveShape::Rectangle { .. }), .. }) = st.doc.node(id).map(|n| &n.kind)
+    else {
+        return Err("Corners edits a live rectangle".into());
+    };
+    let corners = match p.get("corners").and_then(Value::as_array) {
+        Some(a) => std::array::from_fn(|k| a.iter().any(|v| v.as_u64() == Some(k as u64))),
+        None => live.picked_corners(st.selection.partial(id)),
+    };
+    if !corners.contains(&true) {
+        return Err("give corners 0–3".into());
+    }
+    let (radius, kind) = live.corner_style(corners);
+    let mut fields = json!({"id": id.0, "corners": (0..4).filter(|k| corners[*k]).collect::<Vec<_>>()});
+    if let Some(k) = kind {
+        fields["kind"] = json!(k);
+    }
+    if let Some(r) = radius {
+        fields["radius"] = json!(r);
+    }
+    app.ui.dialog = Some(Dialog::new(KIND, fields));
+    Ok(Value::Null)
+}
+
+fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
+    let unit = app.session.general_unit();
+    let current = d.fields.get("kind").and_then(|k| serde_json::from_value::<CornerKind>(k.clone()).ok());
+    grid(ui, |ui| {
+        label(ui, tl!("Corner:"));
+        ui.vertical(|ui| {
+            for k in CornerKind::ALL {
+                let name = match k {
+                    CornerKind::Round => tl!("Round"),
+                    CornerKind::InvertedRound => tl!("Inverted Round"),
+                    CornerKind::Chamfer => tl!("Chamfer"),
+                };
+                if widgets::radio(ui, name, Some(k) == current, true) {
+                    d.fields.insert("kind".into(), json!(k));
+                }
+            }
+        });
+        ui.end_row();
+        label(ui, tl!("Radius:"));
+        form::length(ui, d, "radius", unit, 120.0);
+        ui.end_row();
+    });
+    false
+}
+
+fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
+    let mut p = json!({"id": d.fields.get("id"), "corners": d.fields.get("corners")});
+    if let Some(k) = d.fields.get("kind") {
+        p["kind"] = k.clone();
+    }
+    if d.fields.contains_key("radius") {
+        p["radius"] = json!(d.f64("radius", 0.0));
+    }
+    run_and_close(app, "object.setLiveShape", p)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use vectorcraft_engine::Session;
+    use vectorcraft_engine::doc::LiveShape;
+    use vectorcraft_tools::corners::CornerWidgets;
+    use vectorcraft_tools::{PointerEvent, PointerKind};
+
+    /// A selected 100 pt live square at (100, 100).
+    fn app() -> (VectorcraftApp, u64) {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 400, "height": 400})).unwrap();
+        let id = app.run("shape.rectangle", json!({"x": 100, "y": 100, "width": 100, "height": 100})).unwrap()["id"].as_u64().unwrap();
+        (app, id)
+    }
+
+    fn live(app: &VectorcraftApp, id: u64) -> LiveShape {
+        let Some(NodeKind::Path { live: Some(l), .. }) = app.session.active().unwrap().doc.node(NodeId(id)).map(|n| n.kind.clone()) else {
+            panic!("not live")
+        };
+        l
+    }
+
+    fn corners(app: &VectorcraftApp, id: u64) -> ([f64; 4], [CornerKind; 4]) {
+        let LiveShape::Rectangle { radii, kinds, .. } = live(app, id) else { panic!("not a rectangle") };
+        (radii, kinds)
+    }
+
+    /// The radius the Properties panel's Corner Radius field shows.
+    fn panel_radius(app: &VectorcraftApp, id: u64) -> Option<f64> {
+        let n = app.session.active().unwrap().doc.node(NodeId(id)).unwrap().clone();
+        crate::panels::corner_radius(app, &n, &live(app, id))
+    }
+
+    fn shown(app: &mut VectorcraftApp) -> Vec<String> {
+        fn texts(s: &egui::Shape, out: &mut Vec<String>) {
+            match s {
+                egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
+                egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
+                _ => {}
+            }
+        }
+        let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx);
+        // A new window lays itself out in its first frame and paints in the next.
+        ctx.run_ui(Default::default(), |ui| super::super::show(app, ui.ctx())).textures_delta.clear();
+        let mut out = ctx.run_ui(Default::default(), |ui| super::super::show(app, ui.ctx()));
+        out.textures_delta.clear();
+        let mut v = vec![];
+        out.shapes.iter().for_each(|c| texts(&c.shape, &mut v));
+        v
+    }
+
+    #[test]
+    fn double_clicking_a_direct_selected_corner_edits_it_alone() {
+        let (mut app, id) = app();
+        // Direct Selection picks the bottom-right anchor: only its widget shows.
+        app.run("select.anchors", json!({"id": id, "anchors": [[0, 2]], "mode": "set"})).unwrap();
+        app.select_tool("directSelection");
+        let view = app.view_info();
+        let st = app.session.active().unwrap();
+        let at: Vec<_> = CornerWidgets::of(&st.doc, &st.selection, view.zoom).unwrap().visible().collect();
+        assert_eq!(at.len(), 1);
+        crate::canvas::dispatch(&mut app, &PointerEvent::new(PointerKind::DoubleClick, at[0].x, at[0].y), view);
+        let d = app.ui.dialog.clone().expect("Corners opened");
+        assert_eq!(
+            (d.kind.as_str(), d.fields.get("corners"), d.fields.get("kind"), d.f64("radius", -1.0)),
+            (KIND, Some(&json!([2])), Some(&json!("round")), 0.0)
+        );
+        let texts = shown(&mut app);
+        for s in ["Corners", "Corner:", "Round", "Inverted Round", "Chamfer", "Radius:"] {
+            assert!(texts.iter().any(|t| t == s), "{s} in {texts:?}");
+        }
+        let d = app.ui.dialog.as_mut().unwrap();
+        d.fields.insert("kind".into(), json!("chamfer"));
+        d.fields.insert("radius".into(), json!(12));
+        super::super::confirm(&mut app).unwrap();
+        assert!(app.ui.dialog.is_none());
+        assert_eq!(corners(&app, id), ([0.0, 0.0, 12.0, 0.0], [CornerKind::Round, CornerKind::Round, CornerKind::Chamfer, CornerKind::Round]));
+        // The panels' radius field shows the selected corner's radius, blank for the whole
+        // shape (its corners differ).
+        assert_eq!(panel_radius(&app, id), Some(12.0));
+        app.run("select.set", json!({"ids": [id]})).unwrap();
+        assert_eq!(panel_radius(&app, id), None);
+    }
+
+    #[test]
+    fn ui_corners_opens_on_the_selection_and_leaves_mixed_values_alone() {
+        let (mut app, id) = app();
+        app.run("object.setLiveShape", json!({"corners": [0], "radius": 5, "kind": "invertedRound"})).unwrap();
+        app.run("ui.corners", json!({})).unwrap();
+        let d = app.ui.dialog.clone().unwrap();
+        assert_eq!(d.fields.get("corners"), Some(&json!([0, 1, 2, 3])));
+        assert!(d.fields.get("kind").is_none() && d.fields.get("radius").is_none(), "mixed: {d:?}");
+        let before = corners(&app, id);
+        super::super::confirm(&mut app).unwrap();
+        assert_eq!(corners(&app, id), before);
+        // A radius for all four keeps their kinds.
+        app.run("ui.corners", json!({"id": id})).unwrap();
+        app.ui.dialog.as_mut().unwrap().fields.insert("radius".into(), json!("3 pt"));
+        super::super::confirm(&mut app).unwrap();
+        assert_eq!(corners(&app, id), ([3.0; 4], before.1));
+        // Only live rectangles, and only real corners.
+        assert!(app.run("ui.corners", json!({"id": 9999})).is_err());
+        assert!(app.run("ui.corners", json!({"corners": [7]})).is_err());
+    }
+}

crates/ui-egui/src/dialogs/form.rs

@@ -329,6 +329,19 @@ pub(super) fn slider_w(
     }
 }
 
+/// The words at the two ends of a slider's rail (Less … More), under a slider whose label column
+/// is `label_w` wide.
+pub(super) fn slider_ends(ui: &mut egui::Ui, label_w: f32, (left, right): (&str, &str)) {
+    let t = Tokens::get(ui.ctx());
+    ui.horizontal(|ui| {
+        ui.add_space(label_w + ui.spacing().item_spacing.x);
+        let (r, _) = ui.allocate_exact_size(egui::vec2(SLIDER_WIDTH, 14.0), egui::Sense::hover());
+        let font = egui::FontId::proportional(11.0);
+        ui.painter().text(r.left_center(), egui::Align2::LEFT_CENTER, left, font.clone(), t.text_dim);
+        ui.painter().text(r.right_center(), egui::Align2::RIGHT_CENTER, right, font, t.text_dim);
+    });
+}
+
 /// The field where [`preview`] keeps the parameters it last previewed.
 pub(super) const PREVIEWED: &str = "__previewed";
 

crates/ui-egui/src/dialogs/freehand.rs

@@ -0,0 +1,217 @@
+//! Tool Options of the freehand tools (double-click Pencil, Paintbrush, Smooth, Blob Brush or
+//! Eraser): the options each tool keeps, which last across tool switches and are saved with the
+//! preferences. OK sets them with `tool.setOption {tool, values}`.
+//!
+//! Fields: `tool`; `fidelity` (points; Pencil, Paintbrush and Smooth), `fill` (Pencil and
+//! Paintbrush), `closeWithin` and `editWithin` (screen pixels, 0 turns it off; Pencil and
+//! Paintbrush) and `size` (points; Blob Brush and Eraser).
+
+use serde_json::{Map, Value, json};
+
+use super::document_setup::check;
+use super::{DialogSpec, form, run_and_close};
+use crate::state::Dialog;
+use crate::theme::Tokens;
+use crate::{VectorcraftApp, widgets};
+
+/// The dialog kind of the freehand tools' Tool Options.
+pub const KIND: &str = "freehandOptions";
+
+pub(super) const SPEC: DialogSpec = DialogSpec { heading, body, confirm, min_width: 420.0, ..DialogSpec::FORM };
+
+/// The tools the dialog serves.
+pub const TOOLS: [&str; 5] = ["pencil", "paintbrush", "smooth", "blobBrush", "eraser"];
+
+/// The options the dialog edits, in the order it shows them (a tool has those it reports).
+const KEYS: [&str; 5] = ["fidelity", "size", "fill", "closeWithin", "editWithin"];
+
+/// Width of the label column: wide enough for the tolerances' labels when there are any.
+fn label_w(d: &Dialog) -> f32 {
+    if d.fields.contains_key("closeWithin") { 230.0 } else { 90.0 }
+}
+
+/// The range of the Fidelity slider (points); the field takes what the tool allows.
+const FIDELITY: (f64, f64) = (0.5, 20.0);
+
+fn heading(d: &Dialog) -> String {
+    let label = vectorcraft_tools::tool_info(&d.str("tool")).map_or("", |t| t.label);
+    crate::i18n::fmt(tl!("{tool} Options"), &[("tool", tl!(label))])
+}
+
+/// Open the options of freehand tool `tool` with their current values.
+pub fn open(app: &mut VectorcraftApp, tool: &str) -> Result<Value, String> {
+    if !TOOLS.contains(&tool) {
+        return Err(format!("`{tool}` isn't a freehand tool"));
+    }
+    let o = app.session.tool_options_of(tool);
+    let mut fields: Map<String, Value> = KEYS.iter().filter_map(|key| Some((key.to_string(), o.get(*key)?.clone()))).collect();
+    fields.insert("tool".into(), json!(tool));
+    app.ui.dialog = Some(Dialog { kind: KIND.into(), fields });
+    Ok(json!({ "dialog": KIND }))
+}
+
+/// A row with a number field for `d.fields[key]` (`suffix` is its unit), kept within `range`.
+fn number(ui: &mut egui::Ui, d: &mut Dialog, (key, label): (&str, &str), suffix: &str, decimals: usize, range: (f64, f64)) {
+    let label_w = label_w(d);
+    let v = d.f64(key, 0.0);
+    widgets::label_row(ui, label, label_w, |ui| {
+        if let Some(x) = widgets::plain_field(ui, ("freehand-field", key), v, suffix, decimals, 72.0) {
+            d.fields.insert(key.into(), json!(x.clamp(range.0, range.1)));
+        }
+    });
+}
+
+/// The Fidelity row: a slider over [`FIDELITY`] in tenths, and a field.
+fn fidelity(ui: &mut egui::Ui, d: &mut Dialog) {
+    let label_w = label_w(d);
+    let t = Tokens::get(ui.ctx());
+    let v = d.f64("fidelity", 1.5);
+    let (min, max) = FIDELITY;
+    let mut new = None;
+    widgets::label_row(ui, tl!("Fidelity:"), label_w, |ui| {
+        let at = ((v.clamp(min, max) - min) / (max - min)) as f32;
+        if let (Some(x), _) = widgets::color_slider(ui, "freehand-fidelity", at, form::SLIDER_WIDTH, &|_| t.input_border) {
+            new = Some(((min + x as f64 * (max - min)) * 10.0).round() / 10.0);
+        }
+        if let Some(x) = widgets::plain_field(ui, "freehand-fidelity-field", v, "pt", 1, 64.0) {
+            new = Some(x.clamp(0.05, 100.0));
+        }
+    });
+    if let Some(n) = new.filter(|n| *n != v) {
+        d.fields.insert("fidelity".into(), json!(n));
+    }
+    form::slider_ends(ui, label_w, (tl!("Accurate"), tl!("Smooth")));
+    ui.label(
+        egui::RichText::new(tl!("A lower value follows the stroke closely; a higher one gives fewer points and smoother curves."))
+            .size(11.5)
+            .color(t.text_dim),
+    );
+}
+
+fn body(_app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
+    if d.fields.contains_key("fidelity") {
+        fidelity(ui, d);
+        ui.add_space(10.0);
+    }
+    if d.fields.contains_key("size") {
+        number(ui, d, ("size", tl!("Size:")), "pt", 1, (0.1, 1000.0));
+    }
+    if d.fields.contains_key("fill") {
+        check(ui, d, "fill", tl!("Fill new strokes"));
+        ui.add_space(6.0);
+    }
+    if d.fields.contains_key("closeWithin") {
+        number(ui, d, ("closeWithin", tl!("Close paths when ends are within:")), "px", 0, (0.0, 100.0));
+    }
+    if d.fields.contains_key("editWithin") {
+        number(ui, d, ("editWithin", tl!("Edit selected paths within:")), "px", 0, (0.0, 100.0));
+    }
+    false
+}
+
+/// OK: set the tool's options.
+fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
+    let values: Map<String, Value> = KEYS.iter().filter_map(|k| Some((k.to_string(), d.fields.get(*k)?.clone()))).collect();
+    run_and_close(app, "tool.setOption", json!({ "tool": d.str("tool"), "values": values }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use vectorcraft_engine::Session;
+
+    fn app() -> VectorcraftApp {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+        app
+    }
+
+    /// The labels the open dialog paints.
+    fn painted(app: &mut VectorcraftApp) -> String {
+        crate::tests_labels::painted_text(app, |app, ui| super::super::show(app, ui.ctx()))
+    }
+
+    #[test]
+    fn each_tool_shows_its_options_and_ok_sets_them() {
+        let mut app = app();
+        // Pencil: Fidelity, fill, the two tolerances; no Size.
+        app.run("tool.options", json!({"tool": "pencil"})).unwrap();
+        let text = painted(&mut app);
+        for label in [
+            "Pencil Tool Options",
+            "Fidelity:",
+            "Accurate",
+            "Smooth",
+            "Fill new strokes",
+            "Close paths when ends are within:",
+            "Edit selected paths within:",
+        ] {
+            assert!(text.contains(label), "{label} in {text}");
+        }
+        assert!(!text.contains("Size:"), "{text}");
+        let d = app.ui.dialog.as_mut().unwrap();
+        assert_eq!((d.f64("fidelity", 0.0), d.bool("fill"), d.f64("closeWithin", 0.0), d.f64("editWithin", 0.0)), (1.5, false, 15.0, 12.0));
+        for (k, v) in [("fidelity", json!(6.5)), ("fill", json!(true)), ("closeWithin", json!(0)), ("editWithin", json!(20))] {
+            d.fields.insert(k.into(), v);
+        }
+        super::super::confirm(&mut app).unwrap();
+        assert!(app.ui.dialog.is_none());
+        let o = app.session.tool_options_of("pencil");
+        assert_eq!(
+            (o["fidelity"].as_f64(), o["fill"].as_bool(), o["closeWithin"].as_f64(), o["editWithin"].as_f64()),
+            (Some(6.5), Some(true), Some(0.0), Some(20.0))
+        );
+        // The Paintbrush keeps its own: the Pencil's change left it alone.
+        app.run("tool.options", json!({"tool": "paintbrush"})).unwrap();
+        let d = app.ui.dialog.as_ref().unwrap();
+        assert_eq!((d.f64("fidelity", 0.0), d.bool("fill")), (1.5, false));
+        assert!(painted(&mut app).contains("Paintbrush Tool Options"));
+        // Smooth has Fidelity only, the Blob Brush and the Eraser Size only.
+        app.run("tool.options", json!({"tool": "smooth"})).unwrap();
+        let text = painted(&mut app);
+        assert!(text.contains("Smooth Tool Options") && text.contains("Fidelity:"), "{text}");
+        assert!(!text.contains("Fill new strokes") && !text.contains("Size:"), "{text}");
+        for tool in ["blobBrush", "eraser"] {
+            app.run("tool.options", json!({"tool": tool})).unwrap();
+            let text = painted(&mut app);
+            assert!(text.contains("Size:") && !text.contains("Fidelity:"), "{tool}: {text}");
+            app.ui.dialog.as_mut().unwrap().fields.insert("size".into(), json!(24));
+            super::super::confirm(&mut app).unwrap();
+            assert_eq!(app.session.tool_options_of(tool)["size"].as_f64(), Some(24.0), "{tool}");
+        }
+    }
+
+    #[test]
+    fn a_new_fidelity_changes_what_the_pencil_draws() {
+        let mut app = app();
+        // The anchors of a wave drawn around height `y0`, with nothing selected (a stroke starting
+        // at the end of a selected path would continue it).
+        let anchors = |app: &mut VectorcraftApp, y0: f64| {
+            app.run("select.set", json!({"ids": []})).unwrap();
+            app.select_tool("pencil");
+            let view = app.view_info();
+            let pts: Vec<_> = (0..=40).map(|i| (20.0 + i as f64 * 8.0, y0 + 30.0 * (i as f64 * 0.25).sin())).collect();
+            let pointer = |kind, (x, y)| vectorcraft_tools::PointerEvent::new(kind, x, y);
+            crate::canvas::dispatch(app, &pointer(vectorcraft_tools::PointerKind::Down, pts[0]), view);
+            for p in &pts[1..] {
+                crate::canvas::dispatch(app, &pointer(vectorcraft_tools::PointerKind::Drag, *p), view);
+            }
+            crate::canvas::dispatch(app, &pointer(vectorcraft_tools::PointerKind::Up, pts[40]), view);
+            let doc = &app.session.doc().unwrap().doc;
+            doc.layers[0].children().unwrap().last().unwrap().path_data().map_or(0, |p| p.subpaths.iter().map(|s| s.anchors.len()).sum::<usize>())
+        };
+        let precise = anchors(&mut app, 100.0);
+        app.run("tool.options", json!({"tool": "pencil"})).unwrap();
+        app.ui.dialog.as_mut().unwrap().fields.insert("fidelity".into(), json!(12));
+        super::super::confirm(&mut app).unwrap();
+        let smooth = anchors(&mut app, 200.0);
+        assert!(smooth < precise, "{smooth} anchors at fidelity 12, {precise} at the default");
+    }
+
+    #[test]
+    fn the_other_tools_have_no_freehand_options() {
+        let mut app = app();
+        assert!(open(&mut app, "pen").is_err());
+        assert!(app.ui.dialog.is_none());
+    }
+}

crates/ui-egui/src/dialogs/mod.rs

@@ -15,6 +15,7 @@ pub mod color_guide_options;
 mod color_picker;
 mod command;
 pub mod confirm;
+pub mod corners;
 mod document_setup;
 pub mod dxf_import;
 pub mod dxf_options;
@@ -30,6 +31,7 @@ pub mod file_info;
 pub mod flatten;
 pub mod flattener_presets;
 mod form;
+pub mod freehand;
 mod gradient_stop;
 pub mod graphic_style_options;
 pub mod halftone;
@@ -230,6 +232,7 @@ registry! {
     SpotColors: [spot_colors::KIND] => spot_colors::SPEC,
     TransformEach: [transform_each::KIND] => transform_each::SPEC,
     WidthPoint: [width_point::KIND] => width_point::SPEC,
+    Corners: [corners::KIND] => corners::SPEC,
     SavePdf: [save_pdf::KIND] => save_pdf::SPEC,
     SvgOptions: [svg_options::KIND] => svg_options::SPEC,
     NewDocumentMore: [new_document::MORE] => new_document::MORE_SPEC,
@@ -266,6 +269,7 @@ registry! {
     PerspectiveGrid: [perspective_grid::KIND] => perspective_grid::SPEC,
     Envelope: [envelope::WARP, envelope::MESH, envelope::OPTIONS] => envelope::SPEC,
     LiquifyOptions: [liquify::KIND] => liquify::SPEC,
+    FreehandOptions: [freehand::KIND] => freehand::SPEC,
     PerspectiveGridPresets: [perspective_presets::KIND] => perspective_presets::SPEC,
     PerspectiveGridOptions: [perspective_options::KIND] => perspective_options::SPEC,
     BlendOptions: [blend_options::KIND] => blend_options::SPEC,

crates/ui-egui/src/dialogs/tools.rs

@@ -70,6 +70,13 @@ pub fn open_tool_dialog(app: &mut VectorcraftApp, kind: &str, p: Value) {
             }
             return;
         }
+        // Double-clicking a Live Corners widget: Corners.
+        super::corners::KIND => {
+            if let Err(e) = super::corners::open(app, &p) {
+                app.status(e);
+            }
+            return;
+        }
         // Double-clicking a slice with the Slice Selection tool: Slice Options.
         super::slices::OPTIONS => {
             if let Err(e) = super::slices::open_options(app) {

crates/ui-egui/src/dialogs/transform.rs

@@ -1,5 +1,5 @@
-//! Transform dialogs: Move, Rotate, Scale, Reflect and Shear (with Copy; Scale also has Uniform,
-//! Scale Corners and Scale Strokes & Effects).
+//! Transform dialogs: Move, Rotate, Scale, Reflect and Shear (with Transform Patterns and Copy;
+//! Scale also has Uniform, Scale Corners and Scale Strokes & Effects).
 
 use serde_json::{Value, json};
 
@@ -26,10 +26,17 @@ fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
         form::check(ui, d, "uniform", tl!("Uniform"));
         scale_options(app, ui, d);
     }
+    d.fields.insert("patterns".into(), Value::Bool(transform_patterns(app, d)));
+    form::check(ui, d, "patterns", tl!("Transform Patterns"));
     form::check(ui, d, "copy", tl!("Copy (make a transformed copy)"));
     false
 }
 
+/// Transform Patterns: the dialog's field, else General › Transform Pattern Tiles.
+fn transform_patterns(app: &VectorcraftApp, d: &Dialog) -> bool {
+    d.fields.get("patterns").and_then(Value::as_bool).unwrap_or(app.session.prefs.transform_pattern_tiles)
+}
+
 /// The scale options: (dialog field, preference, label).
 const SCALE_OPTIONS: [(&str, &str, &str); 2] = [("corners", "scaleCorners", "Scale Corners"), ("strokes", "scaleStrokes", "Scale Strokes & Effects")];
 
@@ -74,17 +81,21 @@ fn origin_params(d: &Dialog, mut p: Value) -> Value {
 }
 
 fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
-    let copy = d.bool("copy");
+    let (copy, patterns) = (d.bool("copy"), transform_patterns(app, d));
     let (id, params) = match d.kind.as_str() {
-        "move" => return run_and_close(app, "object.move", json!({"dx": d.f64("dx", 0.0), "dy": d.f64("dy", 0.0), "copy": copy})),
-        "rotate" => ("object.rotate", json!({"angle": d.f64("angle", 0.0), "copy": copy})),
+        "move" => {
+            return run_and_close(app, "object.move", json!({"dx": d.f64("dx", 0.0), "dy": d.f64("dy", 0.0), "copy": copy, "patterns": patterns}));
+        }
+        "rotate" => ("object.rotate", json!({"angle": d.f64("angle", 0.0), "copy": copy, "patterns": patterns})),
         "scale" => {
             let sx = d.f64("sx", 100.0);
             let sy = if d.bool("uniform") { sx } else { d.f64("sy", 100.0) };
-            ("object.scale", with_scale_options(app, d, json!({"sx": sx, "sy": sy, "copy": copy}))?)
+            ("object.scale", with_scale_options(app, d, json!({"sx": sx, "sy": sy, "copy": copy, "patterns": patterns}))?)
         }
-        "reflect" => ("object.reflect", json!({"axis": d.fields.get("axis").cloned().unwrap_or(json!("vertical")), "copy": copy})),
-        _ => ("object.shear", json!({"angle": d.f64("angle", 0.0), "axis": d.str("axis"), "copy": copy})),
+        "reflect" => {
+            ("object.reflect", json!({"axis": d.fields.get("axis").cloned().unwrap_or(json!("vertical")), "copy": copy, "patterns": patterns}))
+        }
+        _ => ("object.shear", json!({"angle": d.f64("angle", 0.0), "axis": d.str("axis"), "copy": copy, "patterns": patterns})),
     };
     run_and_close(app, id, origin_params(d, params))
 }
@@ -121,4 +132,27 @@ mod tests {
         let (cmd, p) = app.session.journal.last().unwrap();
         assert_eq!((cmd.as_str(), &p["strokes"], &p["corners"]), ("object.scale", &json!(false), &json!(true)));
     }
+
+    /// Transform Patterns starts from General › Transform Pattern Tiles (#394) and goes with the
+    /// command.
+    #[test]
+    fn transform_patterns_starts_from_the_preference() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 300, "height": 300})).unwrap();
+        app.run("shape.rectangle", json!({"x": 0, "y": 0, "width": 50, "height": 50})).unwrap();
+        let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx);
+        for on in [false, true] {
+            app.run("prefs.set", json!({"key": "transformPatternTiles", "value": on})).unwrap();
+            crate::menus::invoke(&mut app, "object.move", json!({}));
+            let mut out = ctx.run_ui(egui::RawInput::default(), |ui| crate::dialogs::show(&mut app, ui.ctx()));
+            out.textures_delta.clear();
+            let d = app.ui.dialog.as_mut().unwrap();
+            assert_eq!(d.fields["patterns"], json!(on));
+            d.fields.insert("dx".into(), json!(10));
+            crate::dialogs::confirm(&mut app).unwrap();
+            let (cmd, p) = app.session.journal.last().unwrap();
+            assert_eq!((cmd.as_str(), &p["patterns"]), ("object.move", &json!(on)));
+        }
+    }
 }

crates/ui-egui/src/find_font.rs

@@ -4,10 +4,10 @@
 use egui::Ui;
 use serde_json::{Value, json};
 
-use crate::VectorcraftApp;
 use crate::state::Dialog;
 use crate::theme::{self, Tokens};
 use crate::widgets;
+use crate::{VectorcraftApp, font_menu};
 
 /// Open the dialog.
 pub fn open(app: &mut VectorcraftApp) {
@@ -34,6 +34,7 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
     let Some(mut d) = app.ui.dialog.clone() else { return };
     let t = Tokens::get(ctx);
     let list = fonts(app);
+    let sample = font_menu::sample_text(app);
     let mut close = false;
     let mut act: Option<&str> = None;
     egui::Area::new(egui::Id::new("modal-dim")).order(egui::Order::Middle).fixed_pos(egui::pos2(0.0, 0.0)).show(ctx, |ui| {
@@ -71,9 +72,11 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
             widgets::subheader(ui, tl!("Replace With Font"));
             let fam = d.str("family");
             ui.horizontal(|ui| {
-                if let Some(f) = widgets::font_dropdown(ui, "ff-family", &fam, 220.0) {
+                // Picks the font only: nothing is previewed on the document.
+                let pick = font_menu::font_menu(ui, "ff-family", &fam, 220.0, sample.as_deref(), font_menu::MenuLook::of(app));
+                if let Some((f, style)) = font_menu::picked(app, pick) {
                     d.fields.insert("family".into(), json!(f));
-                    d.fields.insert("style".into(), json!(""));
+                    d.fields.insert("style".into(), json!(style.unwrap_or_default()));
                 }
                 let styles = vectorcraft_text::FontDb::global().styles(&d.str("family"));
                 // "(closest)" is ours; the font's style names are shown as they are.

crates/ui-egui/src/font_menu.rs

@@ -1,12 +1,13 @@
-//! The font family menu of the Character and Properties panels: a search field over every family
-//! available, each row the family's name and a sample of the selected text set in it. The row
-//! under the pointer or reached with ↑/↓ previews its font on the selected text (one live
-//! interaction, nothing in the history); a click or Enter applies it as one step, Escape or
-//! closing the menu puts the text back. A star marks a favourite family, and the ★ filter lists
-//! only those. Preferences › Type › Enable in-menu font previews and Font Preview Size turn the
-//! samples off or size the rows.
+//! The font family menu of the Character, Properties and Glyphs panels and Find Font's Replace
+//! With: a search field over every family available, each row the family's name and a sample of
+//! the selected text set in it. In the Character and Properties panels the row under the pointer
+//! or reached with ↑/↓ previews its font on the selected text (one live interaction, nothing in
+//! the history); a click or Enter applies it as one step, Escape or closing the menu puts the text
+//! back. The Glyphs panel and Find Font only pick a font ([`picked`]): nothing is previewed on the
+//! document. A star marks a favourite family, and the ★ filter lists only those. Preferences ›
+//! Type › Enable in-menu font previews and Font Preview Size turn the samples off or size the
+//! rows.
 
-use std::cell::RefCell;
 use std::collections::HashMap;
 use std::sync::Arc;
 
@@ -480,7 +481,7 @@ impl Samples {
 }
 
 thread_local! {
-    static SAMPLES: RefCell<Samples> = RefCell::new(Samples::default());
+    static SAMPLES: crate::graphics::TexCache<Samples> = crate::graphics::TexCache::default();
 }
 
 /// The sample of `family` for a row `height` points high: the selected text set in it (else a
@@ -638,15 +639,7 @@ pub(crate) fn apply(app: &mut VectorcraftApp, ctx: &egui::Context, pick: FontPic
                 app.sync_views();
             }
         }
-        FontPick::Favorite(f) => {
-            let favs = &mut app.ui.favorite_fonts;
-            match favs.iter().position(|x| x.eq_ignore_ascii_case(&f)) {
-                Some(i) => {
-                    favs.remove(i);
-                }
-                None => favs.push(f),
-            }
-        }
+        FontPick::Favorite(f) => toggle_favorite(app, f),
         FontPick::Chosen(f, style) => {
             if previewing {
                 app.session.cancel_interaction().ok();
@@ -659,6 +652,31 @@ pub(crate) fn apply(app: &mut VectorcraftApp, ctx: &egui::Context, pick: FontPic
     }
 }
 
+/// Star `family`, or take its star off (any case).
+fn toggle_favorite(app: &mut VectorcraftApp, family: String) {
+    let favs = &mut app.ui.favorite_fonts;
+    match favs.iter().position(|x| x.eq_ignore_ascii_case(&family)) {
+        Some(i) => {
+            favs.remove(i);
+        }
+        None => favs.push(family),
+    }
+}
+
+/// For a font menu that only picks a font and never changes the document (Find Font's Replace
+/// With, the Glyphs panel): the family (and style) chosen, if any. A star is toggled here; the
+/// highlighted row is not previewed.
+pub(crate) fn picked(app: &mut VectorcraftApp, pick: Option<FontPick>) -> Option<(String, Option<String>)> {
+    match pick? {
+        FontPick::Chosen(f, style) => Some((f, style)),
+        FontPick::Favorite(f) => {
+            toggle_favorite(app, f);
+            None
+        }
+        FontPick::Preview(..) | FontPick::EndPreview => None,
+    }
+}
+
 /// The command that sets font `family` (and `style`, else the closest the family has) on what the
 /// menus act on.
 fn font_command(app: &VectorcraftApp, family: &str, style: Option<&str>) -> (&'static str, serde_json::Value) {

crates/ui-egui/src/graphics.rs

@@ -0,0 +1,231 @@
+//! Losing the graphics device, and the textures uploaded to it (#369).
+//!
+//! A window can lose its graphics device: a driver reset or a GPU hang on the desktop, the browser
+//! dropping the page's WebGPU device or WebGL context. Everything uploaded to it is gone and
+//! nothing it draws reaches the screen any more, while the app itself goes on.
+//!
+//! - The host reports the loss through a [`GraphicsLoss`] (from wgpu's device-lost callback, the
+//!   canvas's `webglcontextlost` event), and the app keeps recovery copies of the modified
+//!   documents at once ([`VectorcraftApp::graphics_lost`]).
+//! - The web host then starts again with new graphics and a new egui context, handing it the same
+//!   app. The app notices the new context and makes everything it uploaded to the old one again:
+//!   its fonts and theme, the canvas, and every texture cache ([`TexCache`]).
+
+use std::cell::{Cell, Ref, RefCell, RefMut};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex};
+
+use crate::VectorcraftApp;
+
+/// Raised by the host when the window's graphics device is lost (from any thread), read on the UI
+/// thread. Cheap to clone; the clones share the report.
+#[derive(Clone, Default)]
+pub struct GraphicsLoss(Arc<Mutex<Option<String>>>);
+
+impl GraphicsLoss {
+    /// The graphics device was lost (`why`, for the log): the next frame of `ctx` handles it. A
+    /// second report before then adds nothing.
+    pub fn report(&self, ctx: &egui::Context, why: impl Into<String>) {
+        let why = why.into();
+        log::error!("vectorcraft: the graphics device was lost: {why}");
+        self.0.lock().unwrap_or_else(|e| e.into_inner()).get_or_insert(why);
+        ctx.request_repaint();
+    }
+
+    /// The loss reported since the last call, if any.
+    pub fn take(&self) -> Option<String> {
+        self.0.lock().unwrap_or_else(|e| e.into_inner()).take()
+    }
+}
+
+/// A number naming egui context `ctx`, the same every call and different from every other
+/// context's.
+pub(crate) fn context_tag(ctx: &egui::Context) -> u64 {
+    static NEXT: AtomicU64 = AtomicU64::new(1);
+    let id = egui::Id::new("vectorcraft-context-tag");
+    if let Some(tag) = ctx.data(|d| d.get_temp::<u64>(id)) {
+        return tag;
+    }
+    ctx.data_mut(|d| *d.get_temp_mut_or_insert_with(id, || NEXT.fetch_add(1, Ordering::Relaxed)))
+}
+
+thread_local! {
+    /// Bumped when the UI moves to a new egui context: [`TexCache`]s made before are emptied.
+    static EPOCH: Cell<u64> = const { Cell::new(0) };
+}
+
+/// The UI moved to a new egui context: every [`TexCache`] of this thread empties at its next use.
+pub(crate) fn forget_textures() {
+    EPOCH.with(|e| e.set(e.get().wrapping_add(1)));
+}
+
+/// A per-thread cache holding textures (thumbnails, previews, samples). Textures belong to the
+/// egui context they were uploaded to, so the cache goes back to `T::default()` when the UI moves
+/// to another one ([`forget_textures`]). Used like the `RefCell` it wraps.
+#[derive(Default)]
+pub(crate) struct TexCache<T> {
+    epoch: Cell<u64>,
+    value: RefCell<T>,
+}
+
+impl<T: Default> TexCache<T> {
+    /// Empty the cache if it was filled for another context.
+    fn refresh(&self) {
+        let now = EPOCH.with(Cell::get);
+        if self.epoch.replace(now) != now {
+            *self.value.borrow_mut() = T::default();
+        }
+    }
+
+    pub(crate) fn borrow(&self) -> Ref<'_, T> {
+        self.refresh();
+        self.value.borrow()
+    }
+
+    pub(crate) fn borrow_mut(&self) -> RefMut<'_, T> {
+        self.refresh();
+        self.value.borrow_mut()
+    }
+}
+
+impl VectorcraftApp {
+    /// The window's graphics device was lost (`why`, from [`GraphicsLoss::take`]): recovery copies
+    /// of the modified documents are written now, since the window may never draw again (even
+    /// with Data Recovery turned off: they go when the documents are saved or closed) → whether
+    /// every modified document has an up-to-date copy (none modified counts).
+    pub fn graphics_lost(&mut self, why: &str) -> bool {
+        if let Err(e) = self.session.execute("file.recovery.save", &serde_json::json!({})) {
+            log::warn!("vectorcraft: no recovery copies after losing the graphics ({why}): {e}");
+        }
+        self.session.documents().iter().filter(|st| st.is_dirty()).all(|st| st.recovery.as_ref().is_some_and(|c| Arc::ptr_eq(&c.doc, &st.doc)))
+    }
+
+    /// Textures live in one egui context. When the host hands the app a new one (it started again
+    /// after losing its graphics), everything uploaded to the old one is made again: the fonts and
+    /// theme, the canvas, the place cursor's thumbnails and every [`TexCache`].
+    pub(crate) fn adopt_context(&mut self, ctx: &egui::Context) {
+        let tag = context_tag(ctx);
+        if self.context == tag {
+            return;
+        }
+        if self.context != 0 {
+            log::info!("vectorcraft: new graphics context: uploading the UI again");
+            forget_textures();
+            self.styled = false;
+            self.fonts_ready = false;
+            self.ui_fonts = Default::default();
+            self.canvas.texture = None;
+            self.canvas.key = None;
+            self.place.forget_textures();
+        }
+        self.context = tag;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use serde_json::json;
+    use vectorcraft_engine::Session;
+    use vectorcraft_engine::cmd::recovery::{MemoryStore, RecoveryStore};
+
+    use super::*;
+    use crate::Services;
+
+    /// One headless frame of the whole window (800×600) in `ctx`.
+    fn frame(app: &mut VectorcraftApp, ctx: &egui::Context) {
+        let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0))), ..Default::default() };
+        let mut out = ctx.run_ui(raw, |ui| {
+            app.logic(ui.ctx());
+            app.ui(ui);
+        });
+        out.textures_delta.clear();
+    }
+
+    /// The name of texture `id` in `ctx`, if `ctx` has it.
+    fn texture_name(ctx: &egui::Context, id: egui::TextureId) -> Option<String> {
+        ctx.tex_manager().read().meta(id).map(|m| m.name.clone())
+    }
+
+    fn app() -> VectorcraftApp {
+        let mut app = VectorcraftApp::new(Session::new(), Services::default());
+        app.run("file.new", json!({"width": 200, "height": 100})).unwrap();
+        app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 20})).unwrap();
+        app
+    }
+
+    #[test]
+    fn a_loss_is_reported_once_from_any_thread() {
+        let (loss, ctx) = (GraphicsLoss::default(), egui::Context::default());
+        let (l, c) = (loss.clone(), ctx.clone());
+        std::thread::spawn(move || {
+            l.report(&c, "Unknown: driver reset");
+            l.report(&c, "Destroyed");
+        })
+        .join()
+        .unwrap();
+        assert_eq!(loss.take().as_deref(), Some("Unknown: driver reset"), "the first report wins");
+        assert_eq!(loss.take(), None, "handled once");
+    }
+
+    #[test]
+    fn a_tex_cache_empties_when_the_ui_moves_to_a_new_context() {
+        thread_local! {
+            static CACHE: TexCache<Vec<u32>> = TexCache::default();
+        }
+        CACHE.with(|c| c.borrow_mut().push(7));
+        assert_eq!(CACHE.with(|c| c.borrow().clone()), [7]);
+        forget_textures();
+        assert!(CACHE.with(|c| c.borrow().is_empty()), "emptied for the new context");
+        CACHE.with(|c| c.borrow_mut().push(8));
+        assert_eq!(CACHE.with(|c| c.borrow().clone()), [8], "and filled again");
+    }
+
+    #[test]
+    fn the_app_uploads_everything_again_in_a_new_context() {
+        let mut app = app();
+        let old = egui::Context::default();
+        // Fonts, then the canvas.
+        for _ in 0..3 {
+            frame(&mut app, &old);
+        }
+        let canvas = app.canvas.texture.as_ref().map(egui::TextureHandle::id).expect("the canvas is drawn");
+        assert_eq!(texture_name(&old, canvas).as_deref(), Some("canvas"));
+        let preview = |ctx: &egui::Context| {
+            let mut tex = None;
+            ctx.run_ui(Default::default(), |ui| {
+                tex = crate::widgets::doc_preview(ui, "loss", egui::vec2(8.0, 8.0), |w, h| Some(vectorcraft_doc::Document::new(w, h)))
+            })
+            .textures_delta
+            .clear();
+            tex.expect("a preview").id()
+        };
+        assert_eq!(texture_name(&old, preview(&old)).as_deref(), Some("preview-8x8@1:loss"));
+
+        // The host lost its graphics and started again: same app, new context.
+        let new = egui::Context::default();
+        for _ in 0..3 {
+            frame(&mut app, &new);
+        }
+        let canvas = app.canvas.texture.as_ref().map(egui::TextureHandle::id).expect("the canvas is drawn again");
+        assert_eq!(texture_name(&new, canvas).as_deref(), Some("canvas"), "uploaded to the new context");
+        assert_eq!(texture_name(&new, preview(&new)).as_deref(), Some("preview-8x8@1:loss"), "cached previews are made again");
+        assert_eq!(new.global_style().visuals.panel_fill, old.global_style().visuals.panel_fill, "the theme is applied again");
+        assert!(new.fonts(|f| f.definitions().font_data.contains_key("SourceSans3")), "and the fonts installed");
+    }
+
+    #[test]
+    fn losing_the_graphics_keeps_recovery_copies_at_once() {
+        let store = Arc::new(MemoryStore::default());
+        let mut app = VectorcraftApp::new(Session::new(), Services { recovery_store: Some(store.clone()), ..Default::default() });
+        assert!(app.graphics_lost("test"), "nothing modified: nothing to lose");
+        app.run("file.new", json!({"width": 200, "height": 100})).unwrap();
+        app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 20})).unwrap();
+        app.session.prefs.autosave_recovery = false;
+        assert!(app.graphics_lost("test"), "copied even with Data Recovery off");
+        assert_eq!(store.list().unwrap().iter().filter(|n| n.ends_with(".vectorcraft")).count(), 1);
+        // Without a store the work isn't safe.
+        assert!(!self::app().graphics_lost("test"));
+    }
+}

crates/ui-egui/src/i18n/cs.tsv

@@ -572,3 +572,34 @@
 	Collapse Panels to Icons	Sbalit panely na ikony
 	Collapse to Icons	Sbalit na ikony
 	Expand Panels	Rozbalit panely
+
+# About › Contributors / Models (credits.rs)
+	About	O aplikaci
+	Contributors	Přispěvatelé
+	Models	Modely
+	Username	Uživatelské jméno
+	Display name	Zobrazované jméno
+	Real name	Skutečné jméno
+	Sort	Řadit
+	Reverse the order	Obrátit pořadí
+	Grab bag	Volný seznam
+	Table	Tabulka
+	Name (A–Z)	Jméno (A–Z)
+	Merged PRs	Sloučené PR
+	Commits	Commity
+	Lines added	Přidané řádky
+	Lines deleted	Odstraněné řádky
+	Line delta	Rozdíl řádků
+	Binary assets added	Přidané binární soubory
+	Binary assets removed	Odstraněné binární soubory
+	First commit	První commit
+	Last commit	Poslední commit
+	First	První
+	Last	Poslední
+	{people} contributors · {commits} commits	Přispěvatelé: {people} · Commity: {commits}
+	No contributor data was built into this copy.	Tato kopie neobsahuje údaje o přispěvatelích.
+	No model credits were built into this copy.	Tato kopie neobsahuje uvedení modelů.
+	Company	Společnost
+	Version	Verze
+	% of all commits	% všech commitů
+	Lines +/−	Řádky +/−

crates/ui-egui/src/i18n/es.tsv

@@ -36,11 +36,13 @@
 	[Default] is protected: New… starts an editable copy.	[Predeterminado] está protegido: Nuevo… crea una copia editable.
 	[Unnamed]	[Sin nombre]
 	A File…	Un archivo…
+	A lower value follows the stroke closely; a higher one gives fewer points and smoother curves.	Un valor menor sigue el trazo de cerca; uno mayor da menos puntos y curvas más suaves.
 	A new preset starting from the selected one	Un preajuste nuevo a partir del seleccionado
 	A saved copy of the selected preset	Una copia guardada del preajuste seleccionado
 	About VectorCraft	Acerca de VectorCraft
 	above	arriba
 	Absolute Position	Posición absoluta
+	Accurate	Preciso
 	Abutting	Contiguo
 	Action {n}	Acción {n}
 	Actions	Acciones
@@ -297,6 +299,7 @@
 	Changing these settings changes how raster effects look when exported, flattened or expanded.	Cambiar estos ajustes modifica el aspecto de los efectos ráster al exportar, acoplar o expandir.
 	Channel	Canal
 	Character	Carácter
+	Character Alignment	Alineación de caracteres
 	Character / Paragraph	Carácter / Párrafo
 	Character Rotation	Rotación de caracteres
 	Character Set:	Juego de caracteres:
@@ -347,6 +350,7 @@
 	Close All	Cerrar todo
 	Close Library	Cerrar biblioteca
 	Close Path	Cerrar trazado
+	Close paths when ends are within:	Cerrar trazados cuando los extremos estén a menos de:
 	Cmd	Cmd
 	CMYK	CMYK
 	CMYK Color	Color CMYK
@@ -466,6 +470,11 @@
 	Corner Radius:	Radio de esquina:
 	Corner:	Esquina:
 	Corners	Esquinas
+	Chamfer	Chaflán
+	Corners…	Esquinas…
+	Inverted Round	Redondeada invertida
+	Radius:	Radio:
+	Round	Redondeada
 	Couldn't copy to the system clipboard: {e}	No se pudo copiar al portapapeles del sistema: {e}
 	Couldn't paste from the clipboard: {e}	No se pudo pegar desde el portapapeles: {e}
 	Couldn't save recovery data: {e}	No se pudieron guardar los datos de recuperación: {e}
@@ -721,6 +730,7 @@
 	Edit Pattern	Editar motivo
 	Edit PDF Preset	Editar preajuste de PDF
 	Edit Print Preset	Editar preajuste de impresión
+	Edit selected paths within:	Editar trazados seleccionados a menos de:
 	Edit Selection	Editar selección
 	Edit Selection…	Editar selección…
 	Edit Symbol	Editar símbolo
@@ -743,6 +753,9 @@
 	Ellipse Tool	Herramienta Elipse
 	Ellipse…	Elipse…
 	Ellipsis	Puntos suspensivos
+	Em Box Bottom/Left	Abajo/izquierda del cuadro eme
+	Em Box Center	Centro del cuadro eme
+	Em Box Top/Right	Arriba/derecha del cuadro eme
 	Em Dash	Raya
 	Em Space	Espacio eme
 	Embed	Incrustar
@@ -887,6 +900,7 @@
 	Fill & Stroke	Relleno y trazo
 	Fill (X), double-click for the Color Picker	Relleno (X), doble clic para el selector de color
 	Fill and Stroke	Relleno y trazo
+	Fill new strokes	Rellenar trazos nuevos
 	Fill Color	Color de relleno
 	Fill New Type Objects With Placeholder Text	Rellenar nuevos objetos de texto con texto de muestra
 	Fill Rule	Regla de relleno
@@ -898,6 +912,7 @@
 	Find Font	Buscar fuente
 	Find Font…	Buscar fuente…
 	Find Next	Buscar siguiente
+	Find Objects	Buscar objetos
 	First Page	Primera página
 	First-line Left Indent	Sangría izquierda en primera línea
 	Fisheye…	Ojo de pez…
@@ -907,6 +922,9 @@
 	Fit Artboard in Window	Encajar mesa de trabajo en la ventana
 	Fit dashes to corners and ends	Ajustar guiones a esquinas y extremos
 	Fit Headline	Ajustar titular
+	Decrease Font Size	Reducir tamaño de fuente
+	Increase Font Size	Aumentar tamaño de fuente
+	Step Type	Ajustar texto por incrementos
 	Fit in View	Encajar en la vista
 	Fit in Window	Encajar en la ventana
 	Fit on Screen	Encajar en pantalla
@@ -1914,6 +1932,11 @@
 	Recent Font	Fuente reciente
 	Recent Font 1	Fuente reciente 1
 	Recent Font 10	Fuente reciente 10
+	Recent Font 11	Fuente reciente 11
+	Recent Font 12	Fuente reciente 12
+	Recent Font 13	Fuente reciente 13
+	Recent Font 14	Fuente reciente 14
+	Recent Font 15	Fuente reciente 15
 	Recent Font 2	Fuente reciente 2
 	Recent Font 3	Fuente reciente 3
 	Recent Font 4	Fuente reciente 4
@@ -2071,6 +2094,7 @@
 	Right-to-Left Paragraph Direction	Dirección de párrafo de derecha a izquierda
 	Right:	Derecha:
 	Rise…	Ascenso…
+	Roman Baseline	Línea de base latina
 	Roman Hanging Punctuation	Puntuación colgante romana
 	Rotate	Rotar
 	Rotate 90° CW	Rotar 90° en sentido horario
@@ -2253,6 +2277,7 @@
 	Select art and use New Brush to make one.	Selecciona una ilustración y usa Nuevo pincel para crear uno.
 	Select Freeform Point	Seleccionar punto libre
 	Select Gradient Stop	Seleccionar parada de degradado
+	Select Guides	Seleccionar guías
 	Select Objects	Seleccionar objetos
 	Select objects to see their CSS, or Generate CSS for the whole document.	Selecciona objetos para ver su CSS, o usa Generar CSS para todo el documento.
 	Select Same Tint %	Seleccionar mismo % de matiz
@@ -2957,3 +2982,34 @@
 # Leading model (Paragraph panel menu, East Asian options).
 	Top-to-Top Leading	Interlineado de superior a superior
 	Bottom-to-Bottom Leading	Interlineado de inferior a inferior
+
+# About › Contributors / Models (credits.rs)
+	About	Acerca de
+	Contributors	Colaboradores
+	Models	Modelos
+	Username	Nombre de usuario
+	Display name	Nombre visible
+	Real name	Nombre real
+	Sort	Ordenar
+	Reverse the order	Invertir el orden
+	Grab bag	Lista libre
+	Table	Tabla
+	Name (A–Z)	Nombre (A–Z)
+	Merged PRs	PR fusionadas
+	Commits	Commits
+	Lines added	Líneas agregadas
+	Lines deleted	Líneas eliminadas
+	Line delta	Diferencia de líneas
+	Binary assets added	Recursos binarios agregados
+	Binary assets removed	Recursos binarios eliminados
+	First commit	Primer commit
+	Last commit	Último commit
+	First	Primero
+	Last	Último
+	{people} contributors · {commits} commits	{people} colaboradores · {commits} commits
+	No contributor data was built into this copy.	Esta copia no incluye datos de colaboradores.
+	No model credits were built into this copy.	Esta copia no incluye créditos de modelos.
+	Company	Empresa
+	Version	Versión
+	% of all commits	% de todos los commits
+	Lines +/−	Líneas +/−

crates/ui-egui/src/i18n/ja.tsv

@@ -12,7 +12,11 @@
 	All Scripts	すべての文字
 	Any Kind	すべての種類
 	Bottom-to-Bottom Leading	欧文ベースライン基準の行送り
+	Character Alignment	文字揃え
 	Decorative	装飾
+	Em Box Bottom/Left	仮想ボディの下 / 左
+	Em Box Center	仮想ボディの中央
+	Em Box Top/Right	仮想ボディの上 / 右
 	Favorites	お気に入り
 	Japanese	日本語
 	Join Our Discord	Discord に参加
@@ -20,6 +24,7 @@
 	Mojikumi Set	文字組み
 	Latin	欧文
 	Monospaced	等幅
+	Roman Baseline	欧文ベースライン
 	Rounded	丸ゴシック
 	Sans Serif / Gothic	ゴシック・サンセリフ
 	Script / Brush	筆書体・スクリプト
@@ -80,6 +85,7 @@
 	Clear	消去
 	Find and Replace…	検索と置換…
 	Find Next	次を検索
+	Find Objects	オブジェクトを検索
 	Spelling	スペルチェック
 	Auto Spell Check	自動スペルチェック
 	Check Spelling…	スペルチェック…
@@ -284,6 +290,9 @@
 	Release Selection	選択部分をリリース
 	Remove Threading	スレッドを解除
 	Fit Headline	ヘッドラインを合わせる
+	Decrease Font Size	フォントサイズを小さく
+	Increase Font Size	フォントサイズを大きく
+	Step Type	文字を段階的に調整
 	Find Font…	フォントの検索と置換…
 	Change Case	大文字と小文字の変更
 	UPPERCASE	すべて大文字
@@ -660,9 +669,11 @@
 	< 1 sec	1 秒未満
 	<Opacity Mask>	<不透明マスク>
 	A File…	ファイル…
+	A lower value follows the stroke closely; a higher one gives fewer points and smoother curves.	値を小さくするとストロークに忠実に、大きくするとポイントが少なく滑らかな曲線になります。
 	A new preset starting from the selected one	選択したプリセットをもとにした新しいプリセット
 	A saved copy of the selected preset	選択したプリセットの保存済みの複製
 	Absolute Position	絶対位置
+	Accurate	精細
 	Abutting	隣接
 	Activate Document	ドキュメントをアクティブにする
 	Active Perspective Plane	アクティブな遠近面
@@ -869,6 +880,7 @@
 	Clipboard as Text	クリップボードをテキストとして取得
 	Close Library	ライブラリを閉じる
 	Close Path	パスを閉じる
+	Close paths when ends are within:	端点が次の距離以内のとき、パスを閉じる：
 	Collate	部単位で印刷
 	Collect in New Layer	新規レイヤーに集める
 	Color Burn	焼き込みカラー
@@ -940,6 +952,11 @@
 	Corner Radius:	角丸の半径:
 	Corner:	角の形状:
 	Corners	コーナー
+	Round	丸型
+	Radius:	半径:
+	Inverted Round	反転した丸型
+	Corners…	コーナー…
+	Chamfer	面取り
 	Create Clipping Mask	クリッピングマスクを作成
 	Create Document	ドキュメントを作成
 	Create From:	作成元:
@@ -1118,6 +1135,7 @@
 	Edit Print Preset	プリントプリセットを編集
 	Edit Symbol	シンボルを編集
 	Edit Theme	テーマを編集
+	Edit selected paths within:	選択したパスを次の距離以内で編集：
 	Edit or Apply Color Group	カラーグループを編集または適用
 	Edit or Apply Color Group…	カラーグループを編集または適用…
 	Edit or Apply Colors	カラーを編集／適用
@@ -1236,6 +1254,7 @@
 	Fill New Type Objects With Placeholder Text	新規テキストオブジェクトをダミーテキストで埋める
 	Fill Rule	塗りのルール
 	Fill and Stroke	塗りと線
+	Fill new strokes	新しいストロークに塗りを適用
 	Fill:	塗り:
 	Find	検索
 	Find Font	フォントを検索
@@ -1933,6 +1952,11 @@
 	Recent Files	最近使ったファイル
 	Recent Font 1	最近使ったフォント 1
 	Recent Font 10	最近使ったフォント 10
+	Recent Font 11	最近使ったフォント 11
+	Recent Font 12	最近使ったフォント 12
+	Recent Font 13	最近使ったフォント 13
+	Recent Font 14	最近使ったフォント 14
+	Recent Font 15	最近使ったフォント 15
 	Recent Font 2	最近使ったフォント 2
 	Recent Font 3	最近使ったフォント 3
 	Recent Font 4	最近使ったフォント 4
@@ -2824,6 +2848,7 @@
 	Search	検索
 	Security	セキュリティ
 	Select All Pins	すべてのピンを選択
+	Select Guides	ガイドを選択
 	Select text or click into text with the Type tool to insert glyphs	字形を挿入するには、テキストを選択するか、文字ツールでテキスト内をクリックしてください
 	Server-side (.map)	サーバーサイド (.map)
 	Set 1	セット 1
@@ -2946,3 +2971,34 @@
 	Saved Selection 25	保存した選択範囲 25
 	Left-to-Right Paragraph Direction	左から右への段落方向
 	Right-to-Left Paragraph Direction	右から左への段落方向
+
+# About › Contributors / Models (credits.rs)
+	About	情報
+	Contributors	コントリビューター
+	Models	モデル
+	Username	ユーザー名
+	Display name	表示名
+	Real name	本名
+	Sort	並べ替え
+	Reverse the order	順序を逆にする
+	Grab bag	まとめて表示
+	Table	表
+	Name (A–Z)	名前 (A–Z)
+	Merged PRs	マージされた PR
+	Commits	コミット
+	Lines added	追加した行数
+	Lines deleted	削除した行数
+	Line delta	行数の増減
+	Binary assets added	追加したバイナリアセット
+	Binary assets removed	削除したバイナリアセット
+	First commit	最初のコミット
+	Last commit	最後のコミット
+	First	最初
+	Last	最後
+	{people} contributors · {commits} commits	コントリビューター {people} 人 · コミット {commits} 件
+	No contributor data was built into this copy.	このビルドには貢献者のデータが含まれていません。
+	No model credits were built into this copy.	このビルドにはモデルのクレジットが含まれていません。
+	Company	企業
+	Version	バージョン
+	% of all commits	全コミットに占める割合
+	Lines +/−	行数 +/−

crates/ui-egui/src/i18n/pt-br.tsv

@@ -99,10 +99,12 @@
 	< 1 sec	< 1 segundo
 	<Opacity Mask>	<máscara de opacidade>
 	A File…	Um arquivo…
+	A lower value follows the stroke closely; a higher one gives fewer points and smoother curves.	Um valor menor segue o traço de perto; um valor maior gera menos pontos e curvas mais suaves.
 	A new preset starting from the selected one	Um novo predefinido a partir do selecionado
 	A saved copy of the selected preset	Uma cópia salva do predefinido selecionado
 	About VectorCraft	Sobre o VectorCraft
 	Absolute Position	Posição Absoluta
+	Accurate	Preciso
 	Abutting	Contíguo
 	Actions	Ações
 	Activate Document	Ativar Documento
@@ -322,6 +324,7 @@
 	Cascade	Em Cascata
 	Center Artwork	Centralizar Arte
 	Centimeters	Centímetros
+	Chamfer	Chanfro
 	Change	Alterar
 	Change All	Alterar Tudo
 	Change Case	Alterar Maiúsculas/Minúsculas
@@ -333,6 +336,7 @@
 	Changing these settings changes how raster effects look when exported, flattened or expanded.	Alterar estas configurações muda a aparência dos efeitos de raster ao exportar, achatar ou expandir.
 	Channel	Canal
 	Character	Caractere
+	Character Alignment	Alinhamento de Caracteres
 	Character / Paragraph	Caractere / Parágrafo
 	Character Rotation	Rotação de Caractere
 	Character Set:	Conjunto de Caracteres:
@@ -380,6 +384,7 @@
 	Close All	Fechar Tudo
 	Close Library	Fechar Biblioteca
 	Close Path	Fechar Caminho
+	Close paths when ends are within:	Fechar caminhos quando as extremidades estiverem a menos de:
 	Collapse Panels to Icons	Recolher Painéis em Ícones
 	Collapse to Icons	Recolher em Ícones
 	Collate	Agrupar
@@ -477,6 +482,7 @@
 	Corner Radius:	Raio do Canto:
 	Corner:	Canto:
 	Corners	Cantos
+	Corners…	Cantos…
 	Create	Criar
 	Create Clipping Mask	Criar Máscara de Recorte
 	Create Document	Criar Documento
@@ -693,6 +699,7 @@
 	Edit PDF Preset	Editar Predefinido de PDF
 	Edit Pattern	Editar Padrão
 	Edit Print Preset	Editar Predefinido de Impressão
+	Edit selected paths within:	Editar caminhos selecionados a menos de:
 	Edit Selection…	Editar Seleção…
 	Edit Symbol	Editar Símbolo
 	Edit Text	Editar Texto
@@ -715,6 +722,9 @@
 	Ellipse Tool	Ferramenta Elipse
 	Ellipse…	Elipse…
 	Ellipsis	Reticências
+	Em Box Bottom/Left	Base/Esquerda da Caixa Eme
+	Em Box Center	Centro da Caixa Eme
+	Em Box Top/Right	Topo/Direita da Caixa Eme
 	Em Dash	Travessão
 	Em Space	Espaço Em
 	Embed	Incorporar
@@ -846,6 +856,7 @@
 	Fill New Type Objects With Placeholder Text	Preencher Novos Objetos de Texto com Texto de Placeholder
 	Fill Rule	Regra de Preenchimento
 	Fill and Stroke	Preenchimento e Traçado
+	Fill new strokes	Preencher novos traçados
 	Fill with Placeholder Text	Preencher com Texto de Placeholder
 	Fill:	Preenchimento:
 	Find	Localizar
@@ -861,6 +872,9 @@
 	Fit All in Window	Ajustar Tudo na Janela
 	Fit Artboard in Window	Ajustar Mesa de Trabalho na Janela
 	Fit Headline	Ajustar Manchete
+	Decrease Font Size	Diminuir Tamanho da Fonte
+	Increase Font Size	Aumentar Tamanho da Fonte
+	Step Type	Ajustar Texto em Incrementos
 	Fit dashes to corners and ends	Ajustar tracejados aos cantos e extremidades
 	Fit in Window	Ajustar na Janela
 	Fit on Screen	Ajustar na Tela
@@ -1085,6 +1099,7 @@
 	Invert	Inverter
 	Invert Colors	Inverter Cores
 	Invert Mask	Inverter Máscara
+	Inverted Round	Arredondado Invertido
 	Isolate	Isolar
 	Isolate Blending	Isolar Mesclagem
 	Isolate Group	Isolar Grupo
@@ -1703,6 +1718,7 @@
 	Radial	Radial
 	Radial Glows	Brilhos Radiais
 	Radial Gradient	Gradiente Radial
+	Radius:	Raio:
 	Rainbow	Arco-íris
 	Random	Aleatório
 	Randomize Colors	Randomizar Cores
@@ -1726,6 +1742,11 @@
 	Recent Files	Arquivos Recentes
 	Recent Font 1	Fonte Recente 1
 	Recent Font 10	Fonte Recente 10
+	Recent Font 11	Fonte Recente 11
+	Recent Font 12	Fonte Recente 12
+	Recent Font 13	Fonte Recente 13
+	Recent Font 14	Fonte Recente 14
+	Recent Font 15	Fonte Recente 15
 	Recent Font 2	Fonte Recente 2
 	Recent Font 3	Fonte Recente 3
 	Recent Font 4	Fonte Recente 4
@@ -1864,6 +1885,7 @@
 	Right Plane	Plano Direito
 	Right:	Direita:
 	Rise…	Rise…
+	Roman Baseline	Linha de Base Romana
 	Roman Hanging Punctuation	Pontuação Pendurada Romana
 	Rotate	Girar
 	Rotate Tool	Ferramenta Girar
@@ -1871,6 +1893,7 @@
 	Rotate…	Girar…
 	Rotation	Rotação
 	Roughen…	Enrugar…
+	Round	Arredondado
 	Round Cap	Extremidade Redonda
 	Round Corners…	Cantos Arredondados…
 	Round Join	Junção Redonda
@@ -1993,6 +2016,7 @@
 	Select Appearance Item	Selecionar Item de Aparência
 	Select Freeform Point	Selecionar Ponto Livre
 	Select Gradient Stop	Selecionar Parada de Gradiente
+	Select Guides	Selecionar Guias
 	Select Objects	Selecionar Objetos
 	Select Same Tint %	Selecionar Mesmo Tom %
 	Select Slices	Selecionar Fatias
@@ -2565,3 +2589,34 @@
 @plural	{n} star|{n} stars	{n} estrela|{n} estrelas
 @plural	{n} step|{n} steps	{n} passo|{n} passos
 @plural	{n} stroke|{n} strokes	{n} traçado|{n} traçados
+
+# About › Contributors / Models (credits.rs)
+	About	Sobre
+	Contributors	Colaboradores
+	Models	Modelos
+	Username	Nome de usuário
+	Display name	Nome de exibição
+	Real name	Nome real
+	Sort	Ordenar
+	Reverse the order	Inverter a ordem
+	Grab bag	Todos juntos
+	Table	Tabela
+	Name (A–Z)	Nome (A–Z)
+	Merged PRs	PRs mesclados
+	Commits	Commits
+	Lines added	Linhas adicionadas
+	Lines deleted	Linhas removidas
+	Line delta	Saldo de linhas
+	Binary assets added	Arquivos binários adicionados
+	Binary assets removed	Arquivos binários removidos
+	First commit	Primeiro commit
+	Last commit	Último commit
+	First	Primeiro
+	Last	Último
+	{people} contributors · {commits} commits	{people} colaboradores · {commits} commits
+	No contributor data was built into this copy.	Esta cópia foi compilada sem dados de colaboradores.
+	No model credits were built into this copy.	Esta cópia foi compilada sem créditos de modelos.
+	Company	Empresa
+	Version	Versão
+	% of all commits	% de todos os commits
+	Lines +/−	Linhas +/−

crates/ui-egui/src/i18n/zh-hans.tsv

@@ -40,11 +40,13 @@
 	[Default] is protected: New… starts an editable copy.	[默认] 受保护：“新建…”会创建可编辑的副本。
 	[Unnamed]	[未命名]
 	A File…	文件…
+	A lower value follows the stroke closely; a higher one gives fewer points and smoother curves.	数值较小时紧贴所绘线条，较大时锚点较少、曲线更平滑。
 	A new preset starting from the selected one	以所选预设为基础的新预设
 	A saved copy of the selected preset	所选预设的副本
 	About VectorCraft	关于 VectorCraft
 	above	以上
 	Absolute Position	绝对位置
+	Accurate	精确
 	Abutting	相邻
 	Action {n}	动作 {n}
 	Actions	动作
@@ -300,6 +302,7 @@
 	Changing these settings changes how raster effects look when exported, flattened or expanded.	更改这些设置会改变栅格效果在导出、拼合或扩展时的外观。
 	Channel	色版
 	Character	字符
+	Character Alignment	字符对齐
 	Character / Paragraph	字符/段落
 	Character Rotation	字符旋转
 	Character Set:	字符集：
@@ -350,6 +353,7 @@
 	Close All	全部关闭
 	Close Library	关闭库
 	Close Path	闭合路径
+	Close paths when ends are within:	端点相距在以下范围内时闭合路径：
 	Cmd	Cmd
 	CMYK	CMYK
 	CMYK Color	CMYK 颜色
@@ -467,6 +471,10 @@
 	Corner Radius:	圆角半径：
 	Corner:	转角：
 	Corners	转角
+	Round	圆角
+	Inverted Round	反向圆角
+	Corners…	转角…
+	Chamfer	倒角
 	Couldn't copy to the system clipboard: {e}	无法复制到系统剪贴板：{e}
 	Couldn't paste from the clipboard: {e}	无法从剪贴板粘贴：{e}
 	Couldn't save recovery data: {e}	无法存储恢复数据：{e}
@@ -718,6 +726,7 @@
 	Edit Pattern	编辑图案
 	Edit PDF Preset	编辑 PDF 预设
 	Edit Print Preset	编辑打印预设
+	Edit selected paths within:	在以下范围内编辑所选路径：
 	Edit Selection…	编辑所选对象…
 	Edit Symbol	编辑符号
 	Edit Text	编辑文字
@@ -739,6 +748,9 @@
 	Ellipse Tool	椭圆工具
 	Ellipse…	椭圆形…
 	Ellipsis	删节号
+	Em Box Bottom/Left	全角字框下 / 左
+	Em Box Center	全角字框居中
+	Em Box Top/Right	全角字框上 / 右
 	Em Dash	长破折号
 	Em Space	全角空格
 	Embed	嵌入
@@ -882,6 +894,7 @@
 	Fill & Stroke	填色和描边
 	Fill (X), double-click for the Color Picker	填色 (X)，双击打开拾色器
 	Fill and Stroke	填色和描边
+	Fill new strokes	为新描边应用填色
 	Fill Color	填色
 	Fill New Type Objects With Placeholder Text	用占位文本填充新文字对象
 	Fill Rule	填充规则
@@ -893,6 +906,7 @@
 	Find Font	查找字体
 	Find Font…	查找字体…
 	Find Next	查找下一个
+	Find Objects	查找对象
 	First Page	第一页
 	First-line Left Indent	首行左缩进
 	Fisheye…	鱼眼…
@@ -902,6 +916,9 @@
 	Fit Artboard in Window	使画板适合窗口
 	Fit dashes to corners and ends	让虚线贴合转角与端点
 	Fit Headline	适合标题
+	Decrease Font Size	减小字体大小
+	Increase Font Size	增大字体大小
+	Step Type	按增量调整文字
 	Fit in View	适合视图
 	Fit in Window	适合窗口
 	Fit on Screen	显示全页
@@ -1890,6 +1907,11 @@
 	Recent Font	最近字体
 	Recent Font 1	最近使用的字体 1
 	Recent Font 10	最近使用的字体 10
+	Recent Font 11	最近使用的字体 11
+	Recent Font 12	最近使用的字体 12
+	Recent Font 13	最近使用的字体 13
+	Recent Font 14	最近使用的字体 14
+	Recent Font 15	最近使用的字体 15
 	Recent Font 2	最近使用的字体 2
 	Recent Font 3	最近使用的字体 3
 	Recent Font 4	最近使用的字体 4
@@ -2044,6 +2066,7 @@
 	Right-Justified Tab	右对齐制表位
 	Right:	右：
 	Rise…	上升…
+	Roman Baseline	罗马基线
 	Roman Hanging Punctuation	西文悬挂标点
 	Rotate	旋转
 	Rotate 90° CW	顺时针旋转 90°
@@ -3170,6 +3193,7 @@
 	Release to Layers (Build)	释放到图层 (累积)
 	Release to Layers (Sequence)	释放到图层 (顺序)
 	Select Art	选择图稿
+	Select Guides	选择参考线
 	Show All Layers	显示所有图层
 	Unlock All Layers	解锁所有图层
 
@@ -3205,3 +3229,34 @@
 	Saved Selection 23	已保存的选区 23
 	Saved Selection 24	已保存的选区 24
 	Saved Selection 25	已保存的选区 25
+
+# About › Contributors / Models (credits.rs)
+	About	关于
+	Contributors	贡献者
+	Models	模型
+	Username	用户名
+	Display name	显示名称
+	Real name	真实姓名
+	Sort	排序
+	Reverse the order	反转顺序
+	Grab bag	名单
+	Table	表格
+	Name (A–Z)	名称 (A–Z)
+	Merged PRs	已合并的 PR
+	Commits	提交
+	Lines added	新增行数
+	Lines deleted	删除行数
+	Line delta	行数变化
+	Binary assets added	新增二进制资源
+	Binary assets removed	删除二进制资源
+	First commit	首次提交
+	Last commit	最近提交
+	First	首次
+	Last	最近
+	{people} contributors · {commits} commits	{people} 位贡献者 · {commits} 次提交
+	No contributor data was built into this copy.	此版本未包含贡献者数据。
+	No model credits were built into this copy.	此版本未包含模型致谢。
+	Company	公司
+	Version	版本
+	% of all commits	占全部提交的百分比
+	Lines +/−	行数 +/−