Fix #429: Type on a path brackets, flip and Type on a Path Options that keep the type in place

Type on a path could only be repositioned by Type on a Path Options, whose menu item sent
`{start: 0}`, so OK threw the text to the start of its path; nothing showed or dragged its
brackets. Now, as in Illustrator:

- Type on a path flows between a start and an end bracket (`TextKind::OnPath { end }`, None:
  the end of the path or once round a closed one; `TextKind::path_span`). Flipping
  (`TextObject::flip_on_path`) reverses the path keeping a closed path's first anchor and swaps
  the brackets, so the type keeps its stretch of the path.
- Type on a Path Options gains Align to Path (ascender, descender, center, baseline) and
  Spacing (glyphs spaced as if set that far above the path: closed up round the outside of
  curves, opened up round the inside), laid out by the text engine.
- `type.pathOptions {start?, end?, flip?, effect?, alignToPath?, spacing?, ids?}` sets them in
  one undo step; with none of them it queries. The menu item opens the dialog with the selected
  type's Effect, Flip, Align to Path and Spacing (dropdowns for the choices) and leaves the
  brackets alone, so OK as opened changes nothing.
- The Selection and Direct Selection tools show selected type on a path's path and its start,
  centre and end brackets (`tools::pathtype`, with a bracket cursor): dragging the start or end
  bracket sets where the type runs, dragging the centre bracket slides it along the path and,
  across the path, flips it (Cmd/Ctrl held: it only slides). Each drag is one undo step.
- Arc-length measuring moved to `vectorcraft_geom::ArcPath` (layout, the tools and
  `text.createInPath` share it). SVG export outlines path type whose end bracket, alignment or
  spacing `<textPath>` can't express.
- docs/mcp.md documents the command and the drags; ROADMAP updated; dialog strings translated.

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

@@ -4690,6 +4690,7 @@ dependencies = [
  "log",
  "serde",
  "serde_json",
+ "toml",
  "vectorcraft-cad",
  "vectorcraft-color",
  "vectorcraft-doc",

ROADMAP.md

@@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob
 
 This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands.
 
-_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), 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) and the Wayland clipboard with copied-file paste (#398); see [Honest assessment](#honest-assessment-2026-10-05))._
+_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429); see [Honest assessment](#honest-assessment-2026-10-05))._
 
 ## Where we are
 
@@ -44,6 +44,7 @@ since 2026-10-01.
 | **Robustness** | good, new | ~2,840 tests, property tests, no panics in shipped code (lints, the `guard` safety net, import fuzzing), Data Recovery. Missing: a corpus of real-world files, Windows/Linux/browser QA |
 | **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); hybrid-graphics laptops render on the power-saving GPU by default (#306); web drops land in the document they were dropped on (#359); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); on Linux/Wayland the clipboard reads the compositor's own (data-control) and copied image files paste, but files can't be dropped on the window under Wayland until eframe moves to winit 0.31 (#398; the Wayland side is verified by compilation only); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) |
 | **Agent automation** | beyond Illustrator | Every command, gesture and dialog is drivable over MCP, the CLI and the control channel |
+| **Scrubby numeric fields** | beyond Illustrator | As in Photoshop, dragging a numeric field's label (`W:`, `Opacity:`, the Character panel's icons) left or right steps its value live; one undo step per drag, Escape cancels (#400) |
 
 ### Where we're lacking (in priority order)
 
@@ -90,7 +91,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), large containers slice with `document.node {depth?, childLimit?}` (truncated levels report `childCount`), 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:
@@ -103,7 +104,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 move by dragging their heading (the band down from the top edge, as a title bar), stay on screen and keep where they were moved for the session; the form dialogs' choices are dropdowns (Offset Path's Joins, Average's and Shear's and Reflect's axis), and Offset Path lists Offset, Joins, Miter Limit and previews (#423).
   - Dialogs open with their first field focused and its value selected: type a value and press Enter (Move, Rotate, Scale…). Number fields in panels and dialogs step with Up/Down (Shift: ten, Ctrl/Cmd: a tenth of their unit), applied at once.
+  - Scrubby labels (#400, beyond Illustrator, as in Photoshop): dragging a numeric field's label left or right (the ↔ cursor shows over it) steps the value one unit every 2 points (Shift: ten, Ctrl/Cmd: a tenth; counts stay whole), in the field's unit and within its limits, applied live as the art follows; the whole drag is one undo step and Escape puts the value back. A click on the label focuses the field; the text box itself never scrubs, and a field with no label doesn't. Text labels before a field (Transform, Properties, Control bar, Stroke, Transparency, form rows in dialogs) and the Character and Paragraph panels' icons act as labels. Preferences › General › Scrub Numeric Fields by Dragging (on by default) turns it off.
   - Tab shows and hides the panels (in the Type tool it types a tab) without moving the keyboard focus onto a field, so the next shortcut or letter still works; in dialogs and panel fields it moves between fields.
   - Cmd/Ctrl+A follows the keyboard: in a panel, dialog or search field it selects the field's text, while the Type tool edits it selects all of that text (also `select.all` over MCP), and only otherwise every object. On macOS the menu bar's Select All, Cut, Copy and Paste (keys or clicks) act on a focused field too. Not yet: Select All across threaded frames (one frame's text is selected).
   - On Windows and Linux the app bar is the window's title bar (its own minimize, maximize and close buttons, drag to move, edges to resize), with the dragon app icon as the brand mark; dialogs and menus size to their content. As on a native menu bar, once one menu is open, moving the pointer onto another title opens that one.
@@ -123,21 +127,21 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - **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, 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, with the Selection, Group Selection or Direct Selection tool, and resizing by the bounding-box handles: the dragged edges align with the other objects; anchors dragged with Direct Selection: the one pressed on lands on other anchors, its own path's that stay put among them, on path segments or in line with them, the others following, Shift keeps 45° steps, and with Smart Guides off Snap to Point pulls it onto anchors; the Artboard tool snaps artboards, and their bleed, to other artboards, bleeds and art, the grid or whole pixels while moving, copying and resizing them, and the Transform panel shows and edits the active artboard's X/Y/W/H), guides dragged out of the rulers (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; 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.
+- **Type:** Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity) and Options (Flip, Align to Path, Spacing; OK keeps the type where it is), type on a path's start, centre and end brackets (Selection and Direct Selection drag them to set where the type runs, slide it along its path and, across the path, flip it: #429), Character and Paragraph Styles (override-preserving redefine), Area Type Options (rows/columns/inset/first baseline), threaded text across any closed shapes, Fit Headline. Area type resizes like Illustrator's type areas: a bounding-box handle drag (Selection tool) or Area Type Options Width/Height size the frame and the text reflows at its size (threads too); Direct Selection drags a frame corner or edge (`text.reshapeArea`). Point type still scales. 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 an opening bracket starting a wrapped line flush with its start, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline; Character panel menu › Character Alignment (with the East Asian options; `text.setFormat` or `text.setRangeStyle {charAlign}`) lines characters smaller than the largest on their line up on the Roman baseline or the em box top/right, centre or bottom/left (ICF top and bottom not yet); Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines.
 - **Transparency:** opacity masks (clip/invert/disable/link), exported as SVG `<mask>` and PDF soft masks.
 - **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder (stroke-only open paths and lines cut the regions they cross and enclose regions of their own; Alt deletes their pieces; filled open paths count as closed), Live Paint (every path an edge, open lines included), Image Trace (12 presets), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror).
 - **Paint and appearance (M3):**
   - **Swatches:** names follow the colour model and are unique; Swatch Options (process/spot, Global, Gray/RGB/HSB/CMYK/Web, live preview); editing a global or spot swatch recolours every linked fill, stroke and text run in one undo step; multi-select and delete with confirmation; New Swatch and New Color Group dialogs (a group from the selected artwork's colours); swatches in colour groups convert, separate and count like any other. The Swatches panel selects ranges and whole groups, has a find field, and drags swatches to reorder, regroup or paint art; Add Used Colors, Select All Unused, Merge, Ungroup and Sort by Kind; a CMYK document keeps applied colours in CMYK. Swatch libraries: nine generated colour libraries and five gradient libraries in a library panel, saved and loaded as `.vcswatches`, `.gpl` or CSS. Tints of global and spot colours ("Name 40%") stay linked and separate as a percentage of their plate. Spot colours can be defined in Lab (Spot Colors options). A built-in [Registration] swatch prints on every plate.
-  - **Colour:** a Color Picker (colour field, H/S/B/R/G/B channel slider, HSB/RGB/Lab/CMYK fields, hex, web-only snapping, out-of-gamut correction); the Color panel follows each colour's own model and Alt-click paints the other proxy; proxies look through groups and show "?" for mixed paint; Invert, Complement, Apply Last Color (`,`) and Apply Last Gradient (`.`) keep the colour model; every paint command feeds the recent colours. The Color Guide has 21 harmony rules, Steps and Variation options and Limit to Library. Adjust Color Balance (its Global mode shifts tints) and Saturate preview live; Edit Colors and Recolor also reach meshes, images and patterns. Recolor Artwork has colour reduction, five recolour methods, presets, Limit to Library, a colour-wheel Edit tab and Edit Color Group; a local Color Themes panel saves five-colour themes. Fill/Stroke chips open swatch and mixer popovers, panels have their shortcuts, and Eyedropper Options pick up and apply chosen attributes (Alt and Shift+Alt, image pixels). Fills and strokes can overprint (Attributes panel, Overprint Black options), and CMYK documents blend in inks on screen, in PDF and when flattening.
+  - **Colour:** a Color Picker (colour field, H/S/B/R/G/B channel slider, HSB/RGB/Lab/CMYK fields, hex, web-only snapping, out-of-gamut correction); the Color panel follows each colour's own model and Alt-click paints the other proxy; proxies look through groups and show "?" for mixed paint; Invert, Complement, Apply Last Color (`,`) and Apply Last Gradient (`.`) keep the colour model; every paint command feeds the recent colours. The Color Guide has 21 harmony rules, Steps and Variation options and Limit to Library. Adjust Color Balance (its Global mode shifts tints) and Saturate preview live; Edit Colors and Recolor also reach meshes, images and patterns. Recolor Artwork has colour reduction, five recolour methods, presets, Limit to Library, a colour-wheel Edit tab and Edit Color Group; a local Color Themes panel saves five-colour themes. Fill/Stroke chips open swatch and mixer popovers, 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. Document Color Mode converts the art, symbols, pattern tiles and swatches through the colour settings: Gray stays Gray, RGB greys separate into four-colour greys and a rich black as Illustrator does, or go on the black plate only with `grays: "black"` (also for `document.open {colorMode}`).
   - **Gradients:** lossless, validated gradient params; gradients follow rotate, reflect, shear, non-uniform scale and distortions; the Gradient tool edits the fill or stroke of the active proxy, type included; an interactive on-canvas annotator (move, length/angle, rotate, add/move/delete/duplicate stops, midpoints, a stop popover, Delete and arrow keys). The Gradient panel has the Fill/Stroke proxy, a gradient-swatch dropdown with Save to Swatches, midpoint locations, Alt-drag to copy or swap stops, swatch drops on the ramp and a stop eyedropper; copied appearances and graphic styles place gradients on each target's own bounds; gradient handles snap and honour Constrain Angle. Gradient stops stay linked to global and spot swatches. Freeform gradients (points and lines) are edited on the canvas; radial gradients have an extent ellipse, an aspect handle and an off-centre focal point (SVG `fx`/`fy`, PDF two-point radials). A stroke's gradient runs within, along or across it. Object ▸ Expand turns gradients into N objects or a gradient mesh.
-  - **Strokes:** one stroke-geometry module shared by the canvas, SVG, PDF and Outline Stroke; dotted lines (zero-length dashes draw dots or squares); arrowheads with hollow outlines, tip-on-end or extend-past-end alignment and one opacity for line and head. SVG and PDF export arrowheads, width profiles, brushes and aligned strokes exactly as the canvas draws them; Outline Stroke and the live Outline Stroke effect outline every stroke item as drawn (dashes, heads, profiles, alignment); dashes can be fitted to corners and path ends; width profiles carry through dashes, and their corners take the join. The Stroke panel edits type's character strokes, follows the stroke units, shows mixed values blank and opens from the Control bar. A width profile library, thirty more arrowheads, and Width Point Edit with multi-select and discontinuous points. Visual bounds and clicks cover the whole painted stroke. Scale Strokes & Effects, Scale Corners and Use Preview Bounds work everywhere, and new art inherits stroke options, a graphic style or the whole last appearance.
-  - **Appearance:** the Appearance panel's selected row drives every paint, stroke, gradient and transparency edit (`item` on the commands); effects apply to one fill or stroke; per-item Opacity popups; Mixed Appearances, Layers target dots and basic-appearance rules. Effects can be reordered, moved between items and copied by dragging; Show All Hidden Attributes; clicking an effect edits it in place; the object thumbnail drags onto art; effects render on type, images, symbols, blends, envelopes, meshes and repeats, and per-item raster effects export. Groups, layers and type have their own fills, strokes and effects (Contents and Characters rows); the Layers panel's target circles target layers, groups and objects; Expand Appearance turns fills, strokes, effects and brushes into objects.
+  - **Strokes:** one stroke-geometry module shared by the canvas, SVG, PDF and Outline Stroke; dotted lines (zero-length dashes draw dots or squares); arrowheads with hollow outlines, tip-on-end or extend-past-end alignment and one opacity for line and head. SVG and PDF export arrowheads, width profiles, brushes and aligned strokes exactly as the canvas draws them; Outline Stroke and the live Outline Stroke effect outline every stroke item as drawn (dashes, heads, profiles, alignment); dashes can be fitted to corners and path ends; width profiles carry through dashes, and their corners take the join. The Stroke panel edits type's character strokes, follows the stroke units (its weight presets are round values in that unit: `0.25 mm`, `0.0625 in`, `1 px`, #426; fields show four decimals in mm, cm and inches, three in points), shows mixed values blank and opens from the Control bar. A width profile library, thirty more arrowheads, and Width Point Edit with multi-select and discontinuous points. Visual bounds and clicks cover the whole painted stroke. Scale Strokes & Effects, Scale Corners and Use Preview Bounds work everywhere, and new art inherits stroke options, a graphic style or the whole last appearance.
+  - **Appearance:** the Appearance panel's selected row drives every paint, stroke, gradient and transparency edit (`item` on the commands); effects apply to one fill or stroke; per-item Opacity popups, whose blend-mode list and opacity slider stay open inside them (#430; the Control bar's Stroke popover too); Mixed Appearances, Layers target dots and basic-appearance rules. Effects can be reordered, moved between items and copied by dragging; Show All Hidden Attributes; clicking an effect edits it in place; the object thumbnail drags onto art; effects render on type, images, symbols, blends, envelopes, meshes and repeats, and per-item raster effects export. Groups, layers and type have their own fills, strokes and effects (Contents and Characters rows); the Layers panel's target circles target layers, groups and objects; Expand Appearance turns fills, strokes, effects and brushes into objects.
   - **Masks and clipping:** opacity-mask controls work while the mask is being edited; transparency commands take ids and work without a selection; clipping sets clip by compound paths, even-odd paths, text and groups on screen and in raster export, matching SVG/PDF. Alt-click shows only the mask; SVG masks keep Clip and Invert; the transparency grid is per-document state; a clipping path's own fill and stroke paint behind and over the clipped art; layers can be clipping masks.
   - **Transparency:** three-state Knockout Group (on, neutral, off), Opacity & Mask Define Knockout Shape, Page Isolated Blending and Page Knockout Group, on screen and in SVG/PDF. Blend modes match the standard formulas on screen, in SVG and in PDF, and non-isolated groups blend with the art below. Flatten Transparency with presets, a dialog and a Flattener Preview panel.
   - **Graphic styles:** styles keep opacity and blend mode, capture groups and type, apply on top with Alt, and link to the objects using them; Redefine, Break Link, Graphic Style Options, Select All Unused, Sort by Name, and Select > Same Graphic Style / Appearance Attribute. The panel has list and thumbnail views with rendered previews, merge, reorder and drag and drop, plus a Control bar Style picker; six generated style libraries save and load as `.vcstyles`.
@@ -146,7 +150,7 @@ 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 (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).
+  - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units (SVG type under a transform or `viewBox` scale opens at the size it draws at, the scale moved into its size, leading, baseline shift and strokes, a stretch, skew or rotation kept as its transform: #396; a top-level group with a clip path, such as a clipped Inkscape layer, opens as a layer with a clipping mask, its name kept: #420); PDF and PDF-compatible `.ai` in and out (layers, with hidden ones kept hidden with their art and nested ones as sublayers, on pages of up to 64 million operators, art whose layer can't be told going to a hidden, non-printing layer rather than showing or printing: #419; strokes kept live, a fill and a stroke of one outline as one object; masks, editable text with type set along a curve coming back as type on a path, each artboard's art on its own page only, an `.ai`'s white page under its layers left out rather than coming in as art, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3). CMYK images keep their ink amounts from PDF import (and from placed CMYK TIFFs) to PDF export: a CMYK JPEG passes through unchanged, others stay CMYK (DeviceCMYK, or ICC-based CMYK in PDF/X-3/X-4) unless the Output settings convert them; the canvas shows them through the working CMYK profile (#320).
   - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs Illustrator's AGM/CoolType prologs (resource categories, `resourceforall`, `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters, `cshow`, metadata skipped with `flushfile`), so Illustrator 30 EPS files open as vectors, 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; 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.
@@ -164,7 +168,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 | M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | ✅ done (M4.14–M4.98 on 2026-10-05): Save As/Save a Copy/Revert/templates, Data Recovery and background save, SVG import and export fidelity (units, text, symbols, filters, SVGZ, Preserve Editing, SVG Options), PDF import (colours, layers, masks, editable text, security) and export (presets, marks, bleed, ICC and output intent, raster effects, subset fonts, PDF/X-1a, X-3 and X-4, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3), Place and Links, Package, EPS and DXF in and out, EMF/WMF, TIFF/BMP/Targa/PSD/GIF/PNG-8 export, Print and print presets, slices, Save for Web, Asset Export, clipboard flavours, File Info. Left: DWG (use DXF), PSD placement as layers, overprint read back from PDF, polish | 3–6 |
 | M5 | Performance | 🟡 background render + caches + MT done; `vectorcraft-cli bench` and `vectorcraft-cli perf` (budget suite); file format v2 opens 3× faster (50k paths: 722 → 244 ms); raster effects (glows, shadows, blur, feather) no longer force the whole frame single-threaded (filtered offscreen per effect, verified equal to the single-threaded reference); effect-heavy demos need a clean-machine benchmark; dirty-region rendering, GPU backend spike pending | 15–25 |
 | M6 | Path operations (Pathfinder, Shape Builder, offset…) | ✅ mostly done (Boolean precision on almost-horizontal edges fixed and the property tests made deterministic; Shape Builder gap detection, large-offset bug open) | 3–6 |
-| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options (with Width/Height), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, filter by script and kind, list a family's styles, and star favourites; 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 |
+| 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 and Options with draggable start/centre/end brackets (slide, flip), tab stops + Tabs panel, Hebrew/Arabic bidirectional text and Paragraph Direction done; tab leaders, spell check, vertical type pending | 45–60 |
 | M8 | Transform & distort (Puppet Warp, Liquify tools, Envelopes, Blends, Perspective Grid) | ✅ done (M8.1–M8.20 on 2026-10-06, fidelity pass): Liquify Tool Options with one shared brush, pen pressure, hold-to-apply, a safe scope and incremental strokes; tool options that last; Puppet Warp rotation, multi-select, Control bar and a rest-shape session that follows Undo; Width tool on compound paths; Envelope dialogs with preview, Reset with Warp/Mesh, full Envelope Options, type/images/symbols/appearance/gradients/patterns distorted on canvas and in every export, warps that keep their frame, Edit Contents, mesh handles and Control bar; Blend Options, anchor-targeted Blend tool, editable spine, keys picked on the canvas, faithful interpolation and knockout; Perspective Grid with Define Grid, presets, lock/snap/rulers, widgets, the 1–4 plane switch, movable planes, Perspective Selection scale/copy/perpendicular/Transform Again, and type and symbols truly projected with Edit Text. Left: Anti-Alias and Preserve Shape output, warp-envelope point editing, brush interpolation in blends, Free Transform/Scale/Reflect along a rotated box | 2–4 |
 | M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder and Color Adjustments; SVG Filters, Document Raster Effects Settings, 3D pending | 86–135 |
 | M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG `<pattern>`/PDF export) and live Repeat (radial/grid/mirror) done; brushes/symbols in progress | 23–37 |
@@ -200,17 +204,17 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Raster effects (Effect Gallery, Document Raster Effects Settings) | 4 | 20% | ~55 Photoshop-style filters (Artistic, Brush Strokes, Distort, Pixelate, Sketch, Stylize, Texture, Video) and the Effect Gallery; Document Raster Effects Settings and raster effects in PDF are done | 28–42 |
 | 3D and Materials | 4 | 0% | Extrude & Bevel, Revolve, Inflate, Rotate, lighting, materials (software renderer) | 50–80 |
 | Type core | 9 | 79% | Middle Eastern features beyond bidi layout and Paragraph Direction (Character Direction, digit types, kashidas, the Middle Eastern composers, editable bidirectional SVG text, a split caret where directions meet); composer/hyphenation options, Optical Margin Alignment, hidden characters, Transform Again after a type-area resize (it scales the type), partial selection of type-area anchors by marquee | 15–20 |
-| Type advanced | 4 | 50% | CJK composition for vertical type (ruby, mojikumi beyond Line-end Punctuation Half Width — hanging punctuation, line-start brackets, kinsoku sets and the Mojikumi Settings dialog —, proportional vertical metrics, manual tate-chu-yoko, 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 |
+| Type advanced | 4 | 50% | CJK composition for vertical type (ruby, mojikumi beyond Line-end Punctuation Half Width — the other sets (and their paragraph-start bracket and indent rules), hanging punctuation, 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

@@ -181,6 +181,21 @@ fn mcp_protocol_over_stdio() {
     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"}}));

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,7 +78,7 @@ 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, CharAlign, CharPosition, CharStyle, FirstBaseline, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathEffect,
+    AreaOptions, CharAlign, CharPosition, CharStyle, FirstBaseline, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathAlign, PathEffect,
     ScriptMetrics, TabAlign, TabStop, TextKind, TextObject, TextRun, TextStyleDef, TextWrap, WrapShape,
 };
 pub use vectorcraft_color as color;
@@ -167,6 +167,18 @@ impl Unit {
             Unit::Feet => "Feet",
         }
     }
+    /// The rulers' label step at `zoom` (screen pixels per point), in this unit: the first of
+    /// 1, 2, 5 × 10ⁿ that puts labels at least 50 pixels apart. Ticks mark every tenth of it.
+    pub fn ruler_step(self, zoom: f64) -> f64 {
+        const STEPS: [f64; 19] =
+            [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 25.0, 50.0, 100.0, 200.0, 500.0, 1000.0, 2000.0, 5000.0, 10000.0];
+        STEPS.iter().copied().find(|s| s * self.points() * zoom >= 50.0).unwrap_or(10000.0)
+    }
+    /// `v` (points) on the nearest ruler tick at `zoom` ([`Self::ruler_step`]).
+    pub fn snap_to_ruler_tick(self, v: f64, zoom: f64) -> f64 {
+        let tick = self.ruler_step(zoom) / 10.0 * self.points();
+        (v / tick).round() * tick
+    }
     pub fn from_pt(self, v: f64) -> f64 {
         v / self.points()
     }
@@ -179,7 +191,10 @@ impl Unit {
     }
     /// [`Unit::format`] without the suffix (`12.5`), for narrow fields.
     pub fn number(self, pt: f64) -> String {
-        let s = format!("{:.3}", self.from_pt(pt));
+        // Three decimals for the small units (`595.276 pt`), four for the large ones (`8.2677 in`,
+        // `35.2778 mm`, the `0.0078 in` stroke preset); trailing zeros are trimmed (`1 pt` is `1`).
+        let decimals = if matches!(self, Unit::Points | Unit::Pixels | Unit::Picas) { 3 } else { 4 };
+        let s = format!("{:.*}", decimals, self.from_pt(pt));
         let s = s.trim_end_matches('0').trim_end_matches('.');
         if s == "-0" { "0".into() } else { s.into() }
     }
@@ -902,16 +917,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 +935,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 +1090,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

@@ -252,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 {
@@ -526,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 { .. })
     }
@@ -721,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);
@@ -1318,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/tests_units.rs

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

crates/doc/src/text.rs

@@ -539,6 +539,36 @@ impl PathEffect {
     }
 }
 
+/// Type on a Path Options › Align to Path: which height of the type runs along the path.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum PathAlign {
+    /// The font's top edge: the type hangs below the path.
+    Ascender,
+    /// The font's bottom edge: the type stands above the path.
+    Descender,
+    /// Halfway between the ascender and the descender.
+    Center,
+    /// The baseline (the default).
+    #[default]
+    Baseline,
+}
+
+impl PathAlign {
+    pub const ALL: [PathAlign; 4] = [PathAlign::Ascender, PathAlign::Descender, PathAlign::Center, PathAlign::Baseline];
+    pub fn id(self) -> &'static str {
+        match self {
+            PathAlign::Ascender => "ascender",
+            PathAlign::Descender => "descender",
+            PathAlign::Center => "center",
+            PathAlign::Baseline => "baseline",
+        }
+    }
+    pub fn parse(s: &str) -> Option<Self> {
+        Self::ALL.into_iter().find(|a| a.id().eq_ignore_ascii_case(s.trim()))
+    }
+}
+
 /// Area Type Options: rows and columns, gutters, inset and first baseline of area type.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
@@ -583,8 +613,48 @@ pub enum TextKind {
     Point,
     /// Area type flowed inside `frame` (document coordinates, untransformed by `xf`).
     Area { frame: PathData },
-    /// Type on a path, starting at `start` (0..1 of the path length).
-    OnPath { path: PathData, start: f64 },
+    /// Type on a path, flowing from its start bracket `start` to its end bracket `end` (0..1 of the
+    /// path length; no `end`: the end of the path, or once round a closed path). See
+    /// [`TextKind::path_span`].
+    OnPath {
+        path: PathData,
+        start: f64,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        end: Option<f64>,
+    },
+}
+
+impl TextKind {
+    /// Type on a path's span: from its start to its end bracket, as fractions of its path's length.
+    /// Round a closed path the end may be past 1 (the span runs on past the path's start), a full
+    /// turn without an end or with the end at the start. None for other type.
+    pub fn path_span(&self) -> Option<(f64, f64)> {
+        let TextKind::OnPath { path, start, end } = self else { return None };
+        let s = fraction(*start);
+        Some(if path.is_closed() {
+            let run = end.map_or(0.0, |e| (fraction(e) - s).rem_euclid(1.0));
+            (s, s + if run < 1e-9 { 1.0 } else { run })
+        } else {
+            (s, end.map_or(1.0, |e| fraction(e).max(s)))
+        })
+    }
+}
+
+/// `x` as a fraction of a path's length (0..1; 0 when not finite).
+fn fraction(x: f64) -> f64 {
+    if x.is_finite() { x.clamp(0.0, 1.0) } else { 0.0 }
+}
+
+/// `path` run the other way, each point as far from its new start as it was from its old end
+/// (the subpaths in reverse order, a closed one keeping its first anchor first).
+fn reverse_from_end(path: &mut PathData) {
+    path.subpaths.reverse();
+    for sp in &mut path.subpaths {
+        sp.reverse();
+        if sp.closed && !sp.anchors.is_empty() {
+            sp.anchors.rotate_right(1);
+        }
+    }
 }
 
 /// A text object. `runs` split into paragraphs at `\n`.
@@ -605,6 +675,14 @@ pub struct TextObject {
     /// Type on a Path effect (type on a path only).
     #[serde(default, rename = "pathEffect", skip_serializing_if = "crate::skip::is_default")]
     pub path_effect: PathEffect,
+    /// Type on a Path Options › Align to Path (type on a path only).
+    #[serde(default, rename = "pathAlign", skip_serializing_if = "crate::skip::is_default")]
+    pub path_align: PathAlign,
+    /// Type on a Path Options › Spacing in points (type on a path only): glyphs are spaced as if
+    /// set this far above the path, which closes them up round the outside of a curve and opens
+    /// them up round the inside.
+    #[serde(default, rename = "pathSpacing", skip_serializing_if = "crate::skip::is_default")]
+    pub path_spacing: f64,
     /// Wrap objects above this area type, resolved by the engine after each edit (text space).
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub wrap: Vec<WrapShape>,
@@ -623,6 +701,8 @@ impl TextObject {
             para: ParaStyle::default(),
             area: AreaOptions::default(),
             path_effect: PathEffect::default(),
+            path_align: PathAlign::default(),
+            path_spacing: 0.0,
             wrap: Vec::new(),
             cached_bounds: None,
         }
@@ -652,6 +732,29 @@ impl TextObject {
     pub fn transform(&mut self, a: Affine) {
         self.xf = a * self.xf;
     }
+    /// Type on a path's path in document space; None for other type.
+    pub fn type_path(&self) -> Option<PathData> {
+        match &self.kind {
+            TextKind::OnPath { path, .. } => Some(path.transformed(self.xf)),
+            _ => None,
+        }
+    }
+    /// Flip type on a path to the other side of its path (Type on a Path Options › Flip, or its
+    /// centre bracket dragged across the path): the path runs the other way and the brackets swap
+    /// ends, so the type keeps its stretch of the path. False, changing nothing, for other type.
+    pub fn flip_on_path(&mut self) -> bool {
+        let Some((s, e)) = self.kind.path_span() else { return false };
+        let TextKind::OnPath { path, start, end } = &mut self.kind else { return false };
+        reverse_from_end(path);
+        if path.is_closed() {
+            *start = (1.0 - e).rem_euclid(1.0);
+            *end = (e - s < 1.0 - 1e-9).then(|| (1.0 - s).rem_euclid(1.0));
+        } else {
+            *start = 1.0 - e;
+            *end = (s > 1e-9).then_some(1.0 - s);
+        }
+        true
+    }
     /// Area type's frame (the type area) in document space; None for other type.
     pub fn area_frame(&self) -> Option<PathData> {
         match &self.kind {

crates/engine/src/cmd/colormgmt.rs

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

crates/engine/src/cmd/create.rs

@@ -50,7 +50,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Create Text",
             [],
             None,
-            "{x, y, text, vertical?: bool = false, size?: pt, font?: family, style?, color?, area?: {width, height}} → {id}",
+            "{x, y, text, vertical?: bool = false, size?: pt, font?: family, style?, color?, area?: {width, height}, placeholder?: bool (fill it with placeholder text instead, as the Type tools do with prefs placeholderText)} → {id}",
             has_doc,
             text_create
         ),
@@ -414,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,15 +155,41 @@ 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",
             "Document Color Mode",
             ["File", "Document Color Mode"],
             None,
-            "{mode: \"cmyk\"|\"rgb\", convert?: true (convert every colour of the art, symbols and swatches through the colour settings; swatch links kept; greys stay greys), intent?} → {changed}",
+            "{mode: \"cmyk\"|\"rgb\", convert?: true (convert every colour of the art, symbols, pattern tiles and swatches through the colour settings; swatch links kept; Gray colours stay Gray, on the black plate), intent?, grays?: \"profile\" (default: RGB greys separate through the CMYK profile like any colour, into four-colour greys and a rich black) | \"black\" (to CMYK, RGB greys with R = G = B go on the black plate only, K = their grey value)} → {changed}",
             has_doc,
             super::colormgmt::convert_mode
         ),
@@ -428,6 +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.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,7 +114,7 @@ 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)?;
+    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
@@ -117,14 +126,33 @@ fn doc_node(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 /// `depth` / `childLimit` for a summary read: absent (or null) means no limit.
-/// A present value that is not a non-negative integer is rejected rather than
-/// silently reinterpreted.
-fn slice_opts(p: &Value) -> Result<inspect::SummaryOpts> {
-    let opt = |key: &str| match p.get(key) {
+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("document.node", format!("`{key}` must be a non-negative integer"))),
+        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"))),
     };
-    Ok(inspect::SummaryOpts { depth: opt("depth")?, child_limit: opt("childLimit")? })
+    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}`).
@@ -135,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())
 }
 
@@ -224,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/fileio/load.rs

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

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

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

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

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

crates/engine/src/cmd/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 {
@@ -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

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

crates/engine/src/cmd/prefscmds.rs

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

crates/engine/src/cmd/select.rs

@@ -3,6 +3,7 @@
 use std::collections::BTreeSet;
 
 use serde_json::{Value, json};
+use vectorcraft_color::Paint;
 use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
 
 use super::*;
@@ -30,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)
@@ -255,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

@@ -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",
@@ -332,6 +359,45 @@ impl CharChange {
     }
 }
 
+/// 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);
+        });
+    }
+}
+
 fn set_range_style(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "text.setRangeStyle";
     let id = id_param(p, "id").ok_or_else(|| bad(C, "missing `id`"))?;
@@ -339,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, _| {
@@ -347,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())
     })?;
@@ -382,10 +453,10 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let text = str_param(p, "text").unwrap_or("").to_string();
     let start = match point_param(p, "at") {
-        Some(at) if on_path => vectorcraft_text::path_fraction_at(&path.to_bezpath(), at).0,
+        Some(at) if on_path => vectorcraft_geom::ArcPath::new(path).fraction_at(at).unwrap_or(0.0),
         _ => 0.0,
     };
-    let kind = if on_path { TextKind::OnPath { path: path.clone(), start } } else { TextKind::Area { frame: path.clone() } };
+    let kind = if on_path { TextKind::OnPath { path: path.clone(), start, end: None } } else { TextKind::Area { frame: path.clone() } };
     let mut t = TextObject {
         vertical: p.get("vertical").and_then(Value::as_bool).unwrap_or(false),
         kind,
@@ -394,10 +465,16 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
         para: super::create::new_type_para(),
         area: Default::default(),
         path_effect: Default::default(),
+        path_align: Default::default(),
+        path_spacing: 0.0,
         wrap: Vec::new(),
         cached_bounds: None,
     };
-    refresh_bounds(&mut t);
+    if bool_or(p, "placeholder", false) {
+        super::typemenu::fill_with_placeholder(&mut t);
+    } else {
+        refresh_bounds(&mut t);
+    }
     let id = s.edit(if on_path { "Type on a Path" } else { "Area Type" }, |d, sel| {
         let (par, idx, _) = d.position(pid).ok_or(EngineError::NoNode(pid))?;
         d.remove(pid)?;
@@ -413,6 +490,95 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({"id": id.0}))
 }
 
+/// What `type.step` changes.
+#[derive(Clone, Copy, PartialEq)]
+enum Step {
+    Size,
+    Leading,
+    Tracking,
+    Kerning,
+    BaselineShift,
+}
+
+/// The Type tool's selected text while it edits (its typing session ends first: one undo step).
+fn editing_range(s: &mut Session) -> Result<Option<(NodeId, usize, usize)>> {
+    let o = s.tool_options();
+    let Some(id) = o.get("editing").and_then(Value::as_u64).map(NodeId) else { return Ok(None) };
+    if super::edit::typing_in_progress(s) {
+        s.set_tool_option("commitTyping", &Value::Bool(true));
+        s.commit_interaction()?;
+    }
+    let at = |k: &str| byte_param(&o, k).unwrap_or(0);
+    Ok(Some((id, at("start"), at("end"))))
+}
+
+fn type_step(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "type.step";
+    let step = match str_param(p, "attribute") {
+        Some("size") => Step::Size,
+        Some("leading") => Step::Leading,
+        Some("tracking") => Step::Tracking,
+        Some("kerning") => Step::Kerning,
+        Some("baselineShift") => Step::BaselineShift,
+        _ => return Err(bad(C, "attribute must be size|leading|tracking|kerning|baselineShift")),
+    };
+    let by = f64_or(p, "by", 1.0);
+    if !by.is_finite() {
+        return Err(bad(C, "by must be a number"));
+    }
+    let prefs = &s.prefs;
+    let inc = by.clamp(-1000.0, 1000.0)
+        * match step {
+            Step::Size | Step::Leading => prefs.type_size_increment,
+            Step::Tracking | Step::Kerning => prefs.tracking_increment,
+            Step::BaselineShift => prefs.baseline_shift_increment,
+        };
+    // (text, its range; None: all of it).
+    let targets: Vec<(NodeId, Option<(usize, usize)>)> = match id_param(p, "id") {
+        Some(id) => vec![(id, Some(range_of(p, edit::runs_len(&text_ref(s, id)?.runs))))],
+        None => match editing_range(s)? {
+            Some((id, a, b)) => vec![(id, Some((a.min(b), a.max(b))))],
+            None => super::typecmd::text_targets(s, p, C)?.into_iter().map(|id| (id, None)).collect(),
+        },
+    };
+    // The ranges stepped. At a caret: kerning is the space after the character before it, leading
+    // the paragraph's; the rest wait for a selection.
+    let mut ranges = vec![];
+    for (id, range) in targets {
+        let text = text_ref(s, id)?.plain_text();
+        let (a, b) = range.map_or((0, text.len()), |(a, b)| (a.min(text.len()), b.min(text.len())));
+        let (a, b) = match step {
+            _ if a < b => (a, b),
+            Step::Kerning => (edit::prev_char(&text, a), a),
+            Step::Leading => {
+                let para = edit::paragraph_at(&text, a);
+                (para.start, para.end)
+            }
+            _ => continue,
+        };
+        if a < b {
+            ranges.push((id, a, b));
+        }
+    }
+    if !ranges.is_empty() {
+        s.edit("Character", |d, _| {
+            for &(id, a, b) in &ranges {
+                let t = text_mut(d, id).ok_or(EngineError::NoNode(id))?;
+                edit::style_range(&mut t.runs, a, b, |st| match step {
+                    Step::Size => st.size = (st.size + inc).clamp(0.1, 1296.0),
+                    Step::Leading => st.leading = Some((st.effective_leading() + inc).clamp(0.1, 5000.0)),
+                    Step::Tracking => st.tracking = (st.tracking + inc).clamp(-1000.0, 10000.0),
+                    Step::Kerning => st.kerning = Some((st.kerning.unwrap_or(0.0) + inc).clamp(-1000.0, 10000.0)),
+                    Step::BaselineShift => st.baseline_shift = (st.baseline_shift + inc).clamp(-1296.0, 1296.0),
+                });
+                refresh_bounds(t);
+            }
+            Ok(())
+        })?;
+    }
+    Ok(json!({ "ids": ranges.iter().map(|(id, ..)| id.0).collect::<Vec<_>>() }))
+}
+
 /// Tracking (1/1000 em) that makes the first paragraph of `t` exactly `target` wide, if it fits
 /// on one line at all.
 fn headline_tracking(t: &TextObject, target: f64) -> Option<f64> {
@@ -431,6 +597,8 @@ fn headline_tracking(t: &TextObject, target: f64) -> Option<f64> {
             para: Default::default(),
             area: Default::default(),
             path_effect: Default::default(),
+            path_align: Default::default(),
+            path_spacing: 0.0,
             wrap: Vec::new(),
             cached_bounds: None,
         };

crates/engine/src/cmd/typecmd.rs

@@ -238,9 +238,11 @@ fn set_style(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad(C, "nothing to change"));
     }
     let ids = text_targets(s, p, C)?;
+    let protect = s.prefs.missing_glyph_protection && (font.is_some() || style.is_some());
     s.edit("Character", |d, _| {
         for id in &ids {
             let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
+            let before = protect.then(|| t.runs.clone());
             for r in &mut t.runs {
                 let st = &mut r.style;
                 if let Some(f) = &font {
@@ -265,6 +267,9 @@ fn set_style(s: &mut Session, p: &Value) -> Result<Value> {
                     st.features = f.clone();
                 }
             }
+            if let Some(before) = before {
+                super::textedit::protect_missing_glyphs(&before, &mut t.runs);
+            }
             if let Some(j) = justify {
                 t.para.justify = j;
             }

crates/engine/src/cmd/typemenu.rs

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

crates/engine/src/cmd/xform.rs

@@ -45,7 +45,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Move Artboard",
             [],
             None,
-            "{index, dx, dy, moveArt?: bool, copy?: bool} move an artboard (and the unlocked art fully inside it); `copy` (Alt-drag) leaves them and moves copies → {index, moved: the art moved or the copies}",
+            "{index, dx, dy, moveArt?: bool, copy?: bool} move an artboard (and the art fully inside it; locked and hidden art only with prefs moveLockedWithArtboard); `copy` (Alt-drag) leaves them and moves copies → {index, moved: the art moved or the copies}",
             has_doc,
             artboard_move
         ),
@@ -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;
 
@@ -98,6 +98,12 @@ pub fn node_summary_opts(n: &Node, opts: SummaryOpts) -> Value {
 }
 
 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!({
@@ -109,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<_>>(),
@@ -129,6 +135,69 @@ pub fn document(s: &Session) -> Value {
     })
 }
 
+/// What `document.find` matches: every given filter must hit (AND). All matching is
+/// case-insensitive; `name` and `text` are substrings, `kind` is the exact panel label
+/// (`Layer`, `Group`, `Path`, `Type`, `Image`, ...).
+pub struct FindFilter {
+    pub name: Option<String>,
+    pub kind: Option<String>,
+    pub text: Option<String>,
+}
+
+impl FindFilter {
+    /// True when no effective filter was given (empty strings count as absent).
+    pub fn is_empty(&self) -> bool {
+        [self.name.as_ref(), self.kind.as_ref(), self.text.as_ref()].iter().all(|f| f.is_none())
+    }
+
+    fn hits(&self, n: &Node) -> bool {
+        if let Some(needle) = &self.name
+            && !n.display_name().to_lowercase().contains(needle)
+        {
+            return false;
+        }
+        if let Some(kind) = &self.kind
+            && !n.kind_label().eq_ignore_ascii_case(kind)
+        {
+            return false;
+        }
+        if let Some(needle) = &self.text {
+            let NodeKind::Text(t) = &n.kind else { return false };
+            if !t.plain_text().to_lowercase().contains(needle) {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+/// Search the whole layer tree, top of the stack first like the Layers panel.
+/// Returns at most `limit` hits as `{id, name, kind, path}` (`path` is the ancestor
+/// chain, layer first) plus the total hit count, so a capped reply stays explicit.
+pub fn find_nodes(doc: &Document, filter: &FindFilter, limit: u64) -> (Vec<Value>, u64) {
+    use std::sync::Arc;
+    let mut out = Vec::new();
+    let mut total = 0u64;
+    let mut ancestors: Vec<u64> = Vec::new();
+    fn walk(nodes: &[Arc<Node>], ancestors: &mut Vec<u64>, filter: &FindFilter, limit: u64, out: &mut Vec<Value>, total: &mut u64) {
+        for n in nodes.iter().rev() {
+            if filter.hits(n) {
+                *total += 1;
+                if (out.len() as u64) < limit {
+                    out.push(json!({"id": n.id.0, "name": n.display_name(), "kind": n.kind_label(), "path": ancestors}));
+                }
+            }
+            if let Some(ch) = n.children() {
+                ancestors.push(n.id.0);
+                walk(ch, ancestors, filter, limit, out, total);
+                ancestors.pop();
+            }
+        }
+    }
+    walk(&doc.layers, &mut ancestors, filter, limit, &mut out, &mut total);
+    (out, total)
+}
+
 /// Cap names as `stroke.set` takes them.
 pub const CAPS: [(LineCap, &str); 3] = [(LineCap::Butt, "butt"), (LineCap::Round, "round"), (LineCap::Square, "square")];
 /// Join names as `stroke.set` takes them.

crates/engine/src/lib.rs

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

crates/engine/src/tests.rs

@@ -414,6 +414,62 @@ fn document_node_summary_slices_with_depth_and_limit() {
     }
 }
 
+/// `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_emptytype.rs

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

crates/engine/src/tests_journal.rs

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

crates/engine/src/tests_menucmds.rs

@@ -1,7 +1,7 @@
 //! Menu long-tail commands (Object/Edit/Select/Type/View/File), driven through `Session::execute`.
 
 use serde_json::{Value, json};
-use vectorcraft_color::Color;
+use vectorcraft_color::{Color, Paint};
 use vectorcraft_doc::{ColorMode, LiveShape, Node, NodeKind, TextKind};
 use vectorcraft_geom::Rect;
 
@@ -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]
@@ -766,6 +859,122 @@ fn document_color_mode_converts_colours() {
     assert!(s.execute("file.documentColorMode", &json!({"mode": "lab"})).is_err());
 }
 
+/// Four RGB greys (#000000, #333333, #808080, #e6e6e6, as in issue #421) and a red, a 40% tint of a
+/// grey global swatch, a gradient to grey and a pattern of a grey tile → (session, the five
+/// rectangles, the tinted one, the gradient one).
+fn greys_document() -> (Session, Vec<NodeId>, NodeId, NodeId) {
+    let mut s = session();
+    let ids: Vec<NodeId> = ["#000000", "#333333", "#808080", "#e6e6e6", "#ff0000"]
+        .iter()
+        .map(|hex| {
+            let id = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+            fill(&mut s, id, hex);
+            id
+        })
+        .collect();
+    s.execute("swatch.new", &json!({"name": "Ink", "color": "#808080", "global": true})).unwrap();
+    let tint = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+    s.execute("paint.setFill", &json!({"ids": [tint.0], "swatch": "Ink", "tint": 40})).unwrap();
+    let grad = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+    let stops = json!([{"offset": 0, "color": "#ffffff"}, {"offset": 1, "color": "#333333"}]);
+    s.execute("paint.setFill", &json!({"ids": [grad.0], "gradient": {"kind": "linear", "stops": stops}})).unwrap();
+    let tile = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+    fill(&mut s, tile, "#808080");
+    s.execute("object.pattern.make", &json!({"ids": [tile.0], "name": "Grey Tile", "edit": false})).unwrap();
+    (s, ids, tint, grad)
+}
+
+/// The colour of pattern `name`'s first tile object.
+fn pattern_fill(s: &Session, name: &str) -> Color {
+    s.doc().unwrap().doc.pattern(name).unwrap().art[0].appearance.fill_paint().color().unwrap()
+}
+
+/// K of a colour that prints on the black plate only.
+fn k_only(c: Color) -> f32 {
+    match c {
+        Color::Cmyk { c: 0.0, m: 0.0, y: 0.0, k } => k,
+        other => panic!("not K only: {other:?}"),
+    }
+}
+
+#[test]
+fn document_color_mode_separates_rgb_greys_through_the_profile() {
+    let (mut s, ids, _, _) = greys_document();
+    s.execute("file.documentColorMode", &json!({"mode": "cmyk"})).unwrap();
+    // As Illustrator converts them: four-colour greys and a rich black.
+    let Color::Cmyk { c, m, y, k } = fill_of(&s, ids[2]) else { panic!("not CMYK") };
+    assert!(c > 0.05 && m > 0.05 && y > 0.05 && k > 0.0, "a four-colour mid grey: {c} {m} {y} {k}");
+    let Color::Cmyk { c, k, .. } = fill_of(&s, ids[0]) else { panic!("not CMYK") };
+    assert!(k > 0.9 && c > 0.3, "rich black: {c} {k}");
+    // Pattern tiles are swatches too: their art converts with the rest.
+    assert!(matches!(pattern_fill(&s, "Grey Tile"), Color::Cmyk { .. }), "{:?}", pattern_fill(&s, "Grey Tile"));
+    // Gray colours stay Gray.
+    let mut g = session();
+    let a = rect(&mut g, 0.0, 0.0, 10.0, 10.0);
+    g.execute("paint.setFill", &json!({"ids": [a.0], "color": {"gray": 0.3}})).unwrap();
+    g.execute("file.documentColorMode", &json!({"mode": "cmyk"})).unwrap();
+    assert_eq!(fill_of(&g, a), Color::gray(0.3));
+}
+
+#[test]
+fn document_color_mode_can_put_rgb_greys_on_the_black_plate() {
+    let (mut profile, pids, ..) = greys_document();
+    profile.execute("file.documentColorMode", &json!({"mode": "cmyk"})).unwrap();
+    let (mut s, ids, tint, grad) = greys_document();
+    let e = s.execute("file.documentColorMode", &json!({"mode": "cmyk", "grays": "rich"})).unwrap_err().to_string();
+    assert!(e.contains("grays"), "{e}");
+    s.execute("file.documentColorMode", &json!({"mode": "cmyk", "grays": "black"})).unwrap();
+    let close = |a: f32, b: f32| (a - b).abs() < 0.005;
+    for (id, want) in ids.iter().zip([1.0, 0.8, 0.498, 0.098]) {
+        let k = k_only(fill_of(&s, *id));
+        assert!(close(k, want), "K {k}, want {want}");
+    }
+    // Other colours convert through the profile as before.
+    assert_eq!(fill_of(&s, ids[4]), fill_of(&profile, pids[4]));
+    // Swatches, their tints, gradient stops and pattern tiles follow the same rule.
+    let d = &s.doc().unwrap().doc;
+    assert!(close(k_only(d.swatch("Ink").unwrap().paint.color().unwrap()), 0.498));
+    let Paint::Solid { color, swatch, tint: t } = node(&s, tint).appearance.fill_paint() else { panic!("not solid") };
+    assert!(close(k_only(color), 0.498 * 0.4) && swatch.as_deref() == Some("Ink") && t == 0.4, "{color:?} {swatch:?} {t}");
+    let Paint::Gradient(g) = node(&s, grad).appearance.fill_paint() else { panic!("not a gradient") };
+    let ks: Vec<f32> = g.gradient.stops.iter().map(|st| k_only(st.color)).collect();
+    assert!(close(ks[0], 0.0) && close(ks[1], 0.8), "{ks:?}");
+    assert!(close(k_only(pattern_fill(&s, "Grey Tile")), 0.498));
+    // To RGB, `grays` changes nothing.
+    s.execute("file.documentColorMode", &json!({"mode": "rgb", "grays": "black"})).unwrap();
+    let rgb = s.doc().unwrap().doc.layers.clone();
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("file.documentColorMode", &json!({"mode": "rgb"})).unwrap();
+    assert_eq!(s.doc().unwrap().doc.layers, rgb);
+}
+
+#[test]
+fn opening_in_cmyk_can_put_rgb_greys_on_the_black_plate() {
+    let mut s = session();
+    for hex in ["#000000", "#333333", "#808080", "#e6e6e6", "#ff0000"] {
+        let id = rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+        fill(&mut s, id, hex);
+    }
+    let svg = s.execute("document.serialize", &json!({"format": "svg"})).unwrap()["text"].as_str().unwrap().to_string();
+    let data = vectorcraft_format::base64_encode(svg.as_bytes());
+    let mut o = Session::new();
+    o.execute("document.open", &json!({"name": "greys.svg", "dataBase64": data, "colorMode": "cmyk", "grays": "black"})).unwrap();
+    let d = &o.doc().unwrap().doc;
+    assert_eq!(d.color_mode, ColorMode::Cmyk);
+    let mut fills = vec![];
+    for l in &d.layers {
+        l.walk(&mut |n| fills.extend(n.children().is_none().then(|| n.appearance.fill_paint().color()).flatten()));
+    }
+    assert_eq!(fills.len(), 5, "{fills:?}");
+    for (c, want) in fills.iter().zip([1.0, 0.8, 0.498, 0.098]) {
+        let k = k_only(*c);
+        assert!((k - want).abs() < 0.005, "K {k}, want {want}");
+    }
+    assert!(matches!(fills[4], Color::Cmyk { m, y, .. } if m > 0.8 && y > 0.8), "red separates as usual: {:?}", fills[4]);
+    let e = Session::new().execute("document.open", &json!({"name": "greys.svg", "dataBase64": data, "grays": "k"})).unwrap_err().to_string();
+    assert!(e.contains("grays"), "{e}");
+}
+
 #[test]
 fn file_info_sets_title() {
     let mut s = session();

crates/engine/src/tests_pathtype.rs

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

crates/engine/src/tests_prefs.rs

@@ -1,6 +1,6 @@
 //! Preferences: `prefs.get` / `prefs.set` / `prefs.reset` / `prefs.list`.
 
-use serde_json::json;
+use serde_json::{Value, json};
 
 use super::*;
 use crate::cmd::prefscmds::{PREF_CATEGORIES, PREF_GROUPS, PREF_SPECS, validate};
@@ -152,3 +152,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_strokeux.rs

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

crates/engine/src/tests_textedit.rs

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

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/arc.rs

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

crates/geom/src/lib.rs

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

crates/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/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_fileio.rs

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

crates/mcp/src/tools.rs

@@ -100,8 +100,14 @@ pub fn tool_definitions() -> Vec<Value> {
         tool(
             "inspect_document",
             "Inspect document",
-            "Summary of the active document: artboards, layer tree (ids, names, kinds, bounds, fill/stroke), selection, undo history, current tool and default paint.",
-            empty(),
+            "Summary of the active document: artboards, layer tree (ids, names, kinds, bounds, fill/stroke), selection, undo history, current tool and default paint. On a large document pass depth: 0 for the layer skeleton (truncated levels report childCount), then locate objects with run_command document.find and read them with document.node.",
+            obj(
+                json!({
+                    "depth": {"type": "integer", "minimum": 0, "description": "Child levels of the layer tree to include (default all; 0 = top layers with counts)"},
+                    "childLimit": {"type": "integer", "minimum": 0, "description": "Children shown per node (default all; a level that shows fewer reports childCount)"}
+                }),
+                &[],
+            ),
             true,
         ),
         tool(
@@ -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/pdf/src/import.rs

@@ -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::{MAX_NESTING, Ocgs, Scan, all_on, hides_forms, scan_page};
+use crate::import_scan::{MAX_NESTING, Ocgs, Scan, all_on, hides_forms, scan_page, tag_key};
 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};
@@ -32,6 +32,9 @@ const TEXT_OUTLINES: &str = "<Text Outlines>";
 const MAX_NESTED: u32 = 8;
 /// A tiling pattern read this many times with the same art is taken to always draw it.
 const PATTERN_REUSE: u32 = 16;
+/// Stands for the group of art whose group couldn't be told (see [`Builder::unsure`]): it goes
+/// to a hidden, non-printing layer of its page.
+const UNSORTED: usize = usize::MAX;
 
 /// Import a PDF (or PDF-compatible `.ai`) with default options.
 pub fn import(bytes: &[u8]) -> Result<Document, PdfError> {
@@ -146,6 +149,9 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
     doc.layers.clear();
     let taken: Vec<String> = doc.swatches_iter().map(|s| s.name.clone()).chain(doc.swatch_groups.iter().map(|g| g.name.clone())).collect();
     let mut b = Builder::new(doc.peek_next_id(), Colors::new(&pdf, taken.clone()), opts.text_as, route);
+    // The art of a group that is off (drawn as `all_on` turned it on) or doesn't print mustn't
+    // show or print on its page's layer.
+    b.unsure = route && ocgs.list.iter().any(|g| (all_on && !g.on) || !g.print);
     b.taken = taken;
     b.warnings = notes;
     let cache = InterpreterCache::new();
@@ -198,19 +204,22 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
             show_center_mark: false,
             show_cross_hairs: false,
         });
-        let page_layer = |b: &mut Builder<'_>, art: Vec<Arc<Node>>| {
-            let mut layer = Node::layer(b.id(), &format!("Page {}", number + 1), LayerColor::Preset((i % 27) as u8));
-            if let NodeKind::Layer { children: c, .. } = &mut layer.kind {
-                *c = art;
+        let page_layer = |b: &mut Builder<'_>, art: Vec<Arc<Node>>, shown: bool| {
+            let name = if shown { format!("Page {}", number + 1) } else { format!("Page {} (unsorted)", number + 1) };
+            let mut layer = Node::layer(b.id(), &name, LayerColor::Preset((i % 27) as u8));
+            layer.visible = shown;
+            if let NodeKind::Layer { children: c, printable, .. } = &mut layer.kind {
+                (*c, *printable) = (art, shown);
             }
             Slot::Page(Box::new(layer))
         };
         if parts.is_empty() {
-            slots.push(page_layer(&mut b, vec![]));
+            slots.push(page_layer(&mut b, vec![], true));
         }
         for (key, art) in parts {
             match key {
-                None => slots.push(page_layer(&mut b, art)),
+                None => slots.push(page_layer(&mut b, art, true)),
+                Some(UNSORTED) => slots.push(page_layer(&mut b, art, false)),
                 Some(g) => {
                     let into = group_art.entry(g).or_insert_with(|| {
                         place_group(g, &ocgs, &mut slots, &mut nesting);
@@ -542,6 +551,9 @@ struct Builder<'p> {
     aligned: bool,
     /// Whether optional content groups become layers.
     route: bool,
+    /// Some groups are hidden or don't print: art in marked content whose group can't be told
+    /// (once the scan and the interpreter part) is [`UNSORTED`] rather than the page's.
+    unsure: bool,
     /// The marked-content sequences open: the group each marks.
     marked: Vec<Option<usize>>,
     /// A transparency group was just pushed: a form's (whose flags come next) or an image's.
@@ -678,6 +690,7 @@ impl<'p> Builder<'p> {
             group_at: 0,
             aligned: true,
             route,
+            unsure: false,
             marked: vec![],
             pending: false,
             nested: 0,
@@ -1521,13 +1534,15 @@ impl<'a> Device<'a> for Builder<'_> {
         let at = self.tag_at;
         self.tag_at += 1;
         let group = match self.scan.tags.get(at) {
-            Some((t, g)) if self.aligned && t.as_slice() == tag => *g,
+            Some((t, g)) if self.aligned && *t == tag_key(tag) => *g,
             _ => {
                 if self.route && self.aligned {
                     self.aligned = false;
-                    self.warn("some art couldn't be told apart by layer and went to its page's layer");
+                    let why = if self.scan.cut { "a page draws more than can be read for its layers: " } else { "" };
+                    let went = if self.unsure { "a hidden, non-printing layer of its page" } else { "its page's layer" };
+                    self.warn(&format!("{why}some art couldn't be told apart by layer and went to {went}"));
                 }
-                None
+                self.unsure.then_some(UNSORTED)
             }
         }
         .filter(|_| self.route);

crates/pdf/src/import_scan.rs

@@ -21,8 +21,14 @@ use hayro_syntax::page::{Page, Resources};
 
 /// The interpreter's limit on nested form XObjects.
 const MAX_DEPTH: u32 = 50;
-/// The most content operators walked per page: past it the rest of the page isn't told apart.
-const MAX_OPS: usize = 2_000_000;
+/// The most content operators walked per page (a guard against forms drawn within each other
+/// many times over): the art past it can't be told apart by group. A drawing of a million paths
+/// takes a few million; the walk reads about 15 million a second, twice as fast as the
+/// interpreter draws them.
+const MAX_OPS: usize = 64_000_000;
+/// The most marked-content sequences noted per page (24 bytes each): past it the rest of the
+/// page isn't told apart either.
+const MAX_TAGS: usize = 4_000_000;
 /// The most groups read.
 const MAX_GROUPS: usize = 10_000;
 /// The deepest layers nest in the configuration's `/Order`.
@@ -206,10 +212,35 @@ pub(crate) fn text_string(b: &[u8]) -> String {
 /// One page as the interpreter walks it.
 #[derive(Default)]
 pub(crate) struct Scan {
-    /// Each marked-content sequence: its tag and the group (index into [`Ocgs::list`]) it marks.
-    pub tags: Vec<(Vec<u8>, Option<usize>)>,
+    /// Each marked-content sequence: its tag ([`tag_key`]) and the group (index into
+    /// [`Ocgs::list`]) it marks.
+    pub tags: Vec<(u64, Option<usize>)>,
     /// Each form transparency group: isolated, knockout.
     pub groups: Vec<(bool, bool)>,
+    /// The walk stopped at [`MAX_OPS`] or [`MAX_TAGS`]: the rest of the page isn't told apart.
+    pub cut: bool,
+}
+
+/// A marked-content tag as [`Scan::tags`] keeps it: its FNV-1a hash (the tags are only compared,
+/// and a page can have millions).
+pub(crate) fn tag_key(tag: &[u8]) -> u64 {
+    tag.iter().fold(0xcbf2_9ce4_8422_2325, |h, &b| (h ^ u64::from(b)).wrapping_mul(0x0100_0000_01b3))
+}
+
+/// [`MAX_OPS`], lowered by tests that need a page past it.
+#[cfg(not(test))]
+fn max_ops() -> usize {
+    MAX_OPS
+}
+
+#[cfg(test)]
+thread_local! {
+    pub(crate) static TEST_MAX_OPS: std::cell::Cell<usize> = const { std::cell::Cell::new(MAX_OPS) };
+}
+
+#[cfg(test)]
+fn max_ops() -> usize {
+    TEST_MAX_OPS.with(std::cell::Cell::get)
 }
 
 struct Walker<'w, 'p> {
@@ -220,6 +251,7 @@ struct Walker<'w, 'p> {
     fonts: &'w mut HashMap<u128, String>,
     visible: Vec<bool>,
     ops: usize,
+    max_ops: usize,
     out: Scan,
     /// A form XObject hidden by its own optional content was met.
     hidden_form: bool,
@@ -273,7 +305,8 @@ impl Walker<'_, '_> {
         self.note_fonts(res);
         while let Some(op) = iter.next() {
             self.ops += 1;
-            if self.ops > MAX_OPS {
+            if self.ops > self.max_ops || self.out.tags.len() >= MAX_TAGS {
+                self.out.cut = true;
                 return;
             }
             match op {
@@ -296,11 +329,11 @@ impl Walker<'_, '_> {
                             None
                         }
                     };
-                    self.out.tags.push((bdc.0.to_vec(), group));
+                    self.out.tags.push((tag_key(bdc.0.as_ref()), group));
                 }
                 TypedInstruction::BeginMarkedContent(bmc) => {
                     self.begin(true);
-                    self.out.tags.push((bmc.0.to_vec(), None));
+                    self.out.tags.push((tag_key(bmc.0.as_ref()), None));
                 }
                 TypedInstruction::EndMarkedContent(_) => {
                     self.visible.pop();
@@ -347,7 +380,7 @@ pub(crate) fn scan_page(page: &Page<'_>, ocgs: &mut Ocgs, all_on: bool, fonts: &
 
 fn walk_page<'w, 'p>(page: &Page<'p>, ocgs: &'w mut Ocgs, all_on: bool, fonts: &'w mut HashMap<u128, String>) -> Walker<'w, 'p> {
     let off = if all_on { HashSet::new() } else { ocgs.off.clone() };
-    let mut w = Walker { ocgs, off, xref: page.xref(), fonts, visible: vec![], ops: 0, out: Scan::default(), hidden_form: false };
+    let mut w = Walker { ocgs, off, xref: page.xref(), fonts, visible: vec![], ops: 0, max_ops: max_ops(), out: Scan::default(), hidden_form: false };
     w.walk(page.typed_operations(), page.resources(), 0);
     w
 }

crates/pdf/src/import_text.rs

@@ -269,7 +269,7 @@ impl TextLine {
         t.xf = Affine::translate(self.at.origin.to_vec2()) * Affine::rotate(angle);
         let db = vectorcraft_text::FontDb::global();
         if let Some(path) = path {
-            t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&path), start: 0.0 };
+            t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&path), start: 0.0, end: None };
             t.xf = Affine::IDENTITY;
             t.cached_bounds = Some(vectorcraft_text::layout(db, &t).bounds);
             return Some((t, self.opacity));

crates/pdf/src/tests_import_layers.rs

@@ -1,5 +1,6 @@
 //! 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.
+//! view state's), print state, lock and nesting; art that is off comes in as a hidden layer, and
+//! art past what is read of a huge page never shows or prints a hidden layer.
 
 use vectorcraft_color::Color;
 use vectorcraft_doc::{Document, Node, NodeKind};
@@ -298,3 +299,56 @@ fn thousands_of_layers_hidden_ones_included_all_come_in() {
     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)));
 }
+
+/// Import `bytes` with the scan's operator limit lowered to `n`.
+fn import_with_max_ops(bytes: &[u8], n: usize) -> ImportReport {
+    let old = crate::import_scan::TEST_MAX_OPS.replace(n);
+    let r = import_with_report(bytes, &ImportOptions::default());
+    crate::import_scan::TEST_MAX_OPS.set(old);
+    r.unwrap()
+}
+
+#[test]
+fn art_past_the_scan_limit_never_shows_a_hidden_layer() {
+    // "Shapes" draws 100 operators before its square, then "Hidden" (off, not printed) its own.
+    let (objs, catalog, ids) = groups(1, "/OFF [{B}]");
+    let filler = "q Q ".repeat(50);
+    let page = PdfPage {
+        resources: format!("/Properties << /MC0 {} 0 R /MC1 {} 0 R >>", ids[0], ids[1]),
+        ..PdfPage::new(
+            100.0,
+            100.0,
+            &format!("/OC /MC0 BDC {filler}1 0 0 rg 10 10 30 30 re f EMC /OC /MC1 BDC 0 0 1 rg 50 50 30 30 re f EMC 0 1 0 rg 0 0 5 5 re f"),
+        )
+    };
+    let bytes = pdf_with_catalog(&[page], &[&objs[0], &objs[1]], &catalog, None);
+    // Within the limit, every group is told apart.
+    assert_eq!(names(&import(&bytes).unwrap()), ["Shapes", "Hidden", "Page 1"]);
+    let r = import_with_max_ops(&bytes, 60);
+    let d = &r.document;
+    assert_eq!(names(d), ["Shapes", "Page 1 (unsorted)", "Page 1"], "{:?}", r.warnings);
+    // The art drawn past the limit in a group already open stays in it.
+    assert!(d.layers[0].visible);
+    assert_eq!(colors(&d.layers[0]), [Color::rgb(1.0, 0.0, 0.0)]);
+    // The hidden group's art, past it, can't be told apart: it neither shows nor prints.
+    let unsorted = &d.layers[1];
+    assert!(!unsorted.visible && !printable(unsorted));
+    assert_eq!(colors(unsorted), [Color::rgb(0.0, 0.0, 1.0)]);
+    // Art outside any group is the page's, as before.
+    assert!(d.layers[2].visible && printable(&d.layers[2]));
+    assert_eq!(colors(&d.layers[2]), [Color::rgb(0.0, 1.0, 0.0)]);
+    assert!(r.warnings.iter().any(|w| w.contains("more than can be read") && w.contains("hidden, non-printing")), "{:?}", r.warnings);
+}
+
+#[test]
+fn art_past_the_scan_limit_of_shown_layers_stays_shown() {
+    // Every group shows and prints: what can't be told apart goes to the page's layer, shown.
+    let bytes = three_groups([&ocg("A", ""), &ocg("B", ""), &ocg("C", "")], &[], "");
+    let r = import_with_max_ops(&bytes, 4);
+    let d = &r.document;
+    assert_eq!(names(d), ["A", "Page 1"], "{:?}", r.warnings);
+    assert_eq!(colors(&d.layers[0]), [Color::rgb(1.0, 0.0, 0.0)]);
+    assert!(d.layers[1].visible && printable(&d.layers[1]));
+    assert_eq!(colors(&d.layers[1]), [Color::rgb(0.0, 0.0, 1.0), Color::rgb(0.0, 1.0, 0.0)]);
+    assert!(r.warnings.iter().any(|w| w.contains("went to its page's layer")), "{:?}", r.warnings);
+}

crates/pdf/src/tests_realtext.rs

@@ -96,7 +96,7 @@ fn real_text_lands_within_half_a_point_of_the_outlines() {
         TextRun { text: " ok".into(), style: CharStyle { rotation: 20.0, ..style(20.0) } },
     ];
     let mut on_path = TextObject::point(Point::ZERO, "along the arc", style(18.0));
-    on_path.kind = TextKind::OnPath { path: arc(), start: 0.0 };
+    on_path.kind = TextKind::OnPath { path: arc(), start: 0.0, end: None };
     on_path.xf = Affine::IDENTITY;
     for t in [plain, turned, mixed, on_path] {
         let what = t.plain_text();

crates/svg/src/export.rs

@@ -1665,7 +1665,13 @@ impl Writer<'_> {
             self.warn("bidirectional text is outlined to preserve shaping and visual order");
             return self.text_outlines(n, t);
         }
-        if let TextKind::OnPath { path, start } = &t.kind {
+        if let TextKind::OnPath { path, start, end } = &t.kind {
+            // `<textPath>` has a start offset only: an end bracket, Align to Path and Spacing
+            // keep their look as outlines.
+            if end.is_some() || t.path_align != vectorcraft_doc::PathAlign::Baseline || t.path_spacing != 0.0 {
+                self.warn("type on a path with an end bracket, Align to Path or Spacing is outlined to keep its look");
+                return self.text_outlines(n, t);
+            }
             return self.text_on_path(n, t, path, *start);
         }
         self.note_fonts(t, &lay);

crates/svg/src/import.rs

@@ -83,8 +83,9 @@ pub(crate) fn import(svg: &str, opts: &ImportOptions) -> Result<(Document, Vec<S
     }
 
     // Top-level `<g id>` elements become layers (as in the reference app); otherwise all art goes
-    // into "Layer 1". Top-level text joins the layer below it (the first layer if none is).
-    let is_layer = |im: &Importer, c: &usvg::Node| matches!(c, usvg::Node::Group(g) if !g.id().is_empty() && !made_up(g.id()) && !im.links.contains_key(g.id()) && !im.uses.contains_key(g.id()) && is_plain(g) && im.text_slot(g).is_none());
+    // into "Layer 1". A clip path on one (as on an Inkscape layer, or our clipping layers) makes it
+    // a clipping layer. Top-level text joins the layer below it (the first layer if none is).
+    let is_layer = |im: &Importer, c: &usvg::Node| matches!(c, usvg::Node::Group(g) if !g.id().is_empty() && !made_up(g.id()) && !im.links.contains_key(g.id()) && !im.uses.contains_key(g.id()) && only_clips(g) && im.text_slot(g).is_none());
     let is_text = |im: &Importer, c: &usvg::Node| matches!(c, usvg::Node::Group(g) if im.text_slot(g).is_some());
     let layer_mode = top.children().iter().any(|c| is_layer(&im, c)) && top.children().iter().all(|c| is_layer(&im, c) || is_text(&im, c));
     if layer_mode {
@@ -93,22 +94,35 @@ pub(crate) fn import(svg: &str, opts: &ImportOptions) -> Result<(Document, Vec<S
         for c in top.children() {
             let usvg::Node::Group(g) = c else { continue };
             if !is_layer(&im, c) {
-                let n = im.node(c, base).map(Arc::new);
-                match im.doc.layers.last_mut().and_then(|l| Arc::make_mut(l).children_mut()) {
-                    Some(ch) => ch.extend(n),
+                let n: Vec<_> = im.node(c, base).map(Arc::new).into_iter().collect();
+                match im.doc.layers.pop() {
+                    Some(mut l) => {
+                        im.add_unclipped(Arc::make_mut(&mut l), usize::MAX, n);
+                        im.doc.layers.push(l);
+                    }
                     None => loose.extend(n),
                 }
                 continue;
             }
-            let mut children = std::mem::take(&mut loose);
-            children.extend(im.children(g, base * aff(g.transform())));
+            let ts = base * aff(g.transform());
+            let name = im.name_of(g.id()).to_string();
+            let mut art = im.children(g, ts);
+            // A clip path with no shape shows nothing of the layer: it stays, empty.
+            let clip = match g.clip_path() {
+                Some(cp) => {
+                    art = im.clipped(cp, ts, art, &format!("layer '{name}'")).unwrap_or_default();
+                    !art.is_empty()
+                }
+                None => false,
+            };
             let id = im.doc.alloc_id();
             let preset = (im.doc.layers.len() % vectorcraft_doc::LAYER_COLORS.len()) as u8;
-            let name = im.name_of(g.id()).to_string();
             let mut l = Node::layer(id, &name, LayerColor::Preset(preset));
+            l.set_clips(clip);
             if let Some(ch) = l.children_mut() {
-                *ch = children;
+                *ch = art;
             }
+            im.add_unclipped(&mut l, 0, std::mem::take(&mut loose));
             l.visible = !im.hidden.contains(g.id());
             im.doc.layers.push(Arc::new(l));
         }
@@ -472,7 +486,12 @@ fn aff(t: usvg::Transform) -> Affine {
 }
 
 fn is_plain(g: &usvg::Group) -> bool {
-    g.clip_path().is_none() && g.mask().is_none() && g.filters().is_empty() && g.opacity().get() >= 1.0 && g.blend_mode() == usvg::BlendMode::Normal
+    g.clip_path().is_none() && only_clips(g)
+}
+
+/// Does group `g` leave its art as it is, but for a clip path (no mask, filter, opacity or blend)?
+fn only_clips(g: &usvg::Group) -> bool {
+    g.mask().is_none() && g.filters().is_empty() && g.opacity().get() >= 1.0 && g.blend_mode() == usvg::BlendMode::Normal
 }
 
 fn blend(b: usvg::BlendMode) -> BlendMode {
@@ -758,27 +777,8 @@ impl Importer {
                 inner.appearance.effects = effects.clone();
                 children = vec![Arc::new(inner)];
             }
-            // A clip path clipped in turn (`<clipPath clip-path>`): one clip group in another, so
-            // the clips intersect.
-            let mut clips = vec![self.clip_node(cp, ts)?];
-            let mut next = cp.clip_path();
-            while let Some(c) = next {
-                if clips.len() > MAX_CLIP_NEST {
-                    self.warn(format!("clip paths nested more than {MAX_CLIP_NEST} deep on {label}: the deeper ones are ignored"));
-                    break;
-                }
-                clips.push(self.clip_node(c, ts)?);
-                next = c.clip_path();
-            }
-            let outer = clips.pop()?;
-            for clip in clips {
-                let mut ch = vec![Arc::new(clip)];
-                ch.extend(children);
-                children = vec![Arc::new(self.named("", NodeKind::Group { children: ch, clip: true }))];
-            }
-            let mut ch = vec![Arc::new(outer)];
-            ch.extend(children);
-            self.named(id, NodeKind::Group { children: ch, clip: true })
+            let children = self.clipped(cp, ts, children, &label)?;
+            self.named(id, NodeKind::Group { children, clip: true })
         } else {
             if children.is_empty() {
                 return None;
@@ -849,6 +849,49 @@ impl Importer {
         Some(Box::new(mask))
     }
 
+    /// `children` clipped by `cp` (on an element whose user space `ts` maps to the document): the
+    /// children of a clip group or clipping layer, its clipping path first. A clip path clipped in
+    /// turn (`<clipPath clip-path>`) nests one clip group in another, so the clips intersect.
+    /// `None` when the clip path has no shape (nothing shows).
+    fn clipped(&mut self, cp: &usvg::ClipPath, ts: Affine, mut children: Vec<Arc<Node>>, label: &str) -> Option<Vec<Arc<Node>>> {
+        let mut clips = vec![self.clip_node(cp, ts)?];
+        let mut next = cp.clip_path();
+        while let Some(c) = next {
+            if clips.len() > MAX_CLIP_NEST {
+                self.warn(format!("clip paths nested more than {MAX_CLIP_NEST} deep on {label}: the deeper ones are ignored"));
+                break;
+            }
+            clips.push(self.clip_node(c, ts)?);
+            next = c.clip_path();
+        }
+        let outer = clips.pop()?;
+        for clip in clips {
+            let mut ch = vec![Arc::new(clip)];
+            ch.extend(children);
+            children = vec![Arc::new(self.named("", NodeKind::Group { children: ch, clip: true }))];
+        }
+        let mut ch = vec![Arc::new(outer)];
+        ch.extend(children);
+        Some(ch)
+    }
+
+    /// Put `art` in layer `l` at `index` (at most its end) unclipped: a clipping mask on the layer
+    /// becomes a clip group in it, holding the art it clipped.
+    fn add_unclipped(&mut self, l: &mut Node, index: usize, art: Vec<Arc<Node>>) {
+        if art.is_empty() {
+            return;
+        }
+        if let NodeKind::Layer { children, clip: clip @ true, .. } = &mut l.kind {
+            *clip = false;
+            let clipped = std::mem::take(children);
+            children.push(Arc::new(self.named("", NodeKind::Group { children: clipped, clip: true })));
+        }
+        if let Some(ch) = l.children_mut() {
+            let i = index.min(ch.len());
+            ch.splice(i..i, art);
+        }
+    }
+
     fn clip_node(&mut self, cp: &usvg::ClipPath, ts: Affine) -> Option<Node> {
         let shapes = clip_shapes(cp, ts);
         if shapes.is_empty() {

crates/svg/src/import/text.rs

@@ -586,7 +586,7 @@ impl Ctx {
             let offset = tp.attribute("startOffset").and_then(|v| self.length(v, em, len)).unwrap_or(0.0) + dx[0];
             let width = if anchor > 0.0 { advance(&point_text(&cells)) } else { 0.0 };
             let start = Some((offset - anchor * width) / len).filter(|s| s.is_finite()).map_or(0.0, |s| s.clamp(0.0, 1.0));
-            obj.kind = TextKind::OnPath { path: PathData::from_bezpath(&bp), start };
+            obj.kind = TextKind::OnPath { path: PathData::from_bezpath(&bp), start, end: None };
             obj.xf = Affine::IDENTITY;
         } else if vertical {
             // Type on a vertical path: dy is extra advance, dx shifts across the column.
@@ -606,7 +606,7 @@ impl Ctx {
             let mut bp = BezPath::new();
             bp.move_to((x0, y0));
             bp.line_to((x0, y0 + width + 1.0));
-            obj.kind = TextKind::OnPath { path: PathData::from_bezpath(&bp), start: 0.0 };
+            obj.kind = TextKind::OnPath { path: PathData::from_bezpath(&bp), start: 0.0, end: None };
             obj.xf = Affine::IDENTITY;
         } else {
             let origin = Point::new(x[0].unwrap_or(0.0) + dx[0], y[0].unwrap_or(0.0) + dy[0]);

crates/svg/tests/import_text.rs

@@ -150,7 +150,7 @@ fn text_path_becomes_type_on_a_path() {
     );
     let t = texts(&d);
     assert_eq!(t.len(), 3);
-    let TextKind::OnPath { path, start } = &t[0].kind else { panic!("{:?}", t[0].kind) };
+    let TextKind::OnPath { path, start, .. } = &t[0].kind else { panic!("{:?}", t[0].kind) };
     assert!(close(*start, 0.25, 1e-9));
     let b = t[0].xf.transform_rect_bbox(path.bounds().unwrap());
     assert!(close(b.x0, 10.0, 1e-6) && close(b.x1, 210.0, 1e-6) && close(b.y0, 100.0, 1e-6), "{b:?}");
@@ -310,7 +310,7 @@ fn pattern_fill_on_text_and_shapes() {
 fn vertical_writing_mode_runs_down_a_path() {
     let d = open(r#"<text x="100" y="20" writing-mode="tb" font-size="10">Down</text>"#);
     let t = only_text(&d);
-    let TextKind::OnPath { path, start } = &t.kind else { panic!("{:?}", t.kind) };
+    let TextKind::OnPath { path, start, .. } = &t.kind else { panic!("{:?}", t.kind) };
     assert_eq!(*start, 0.0);
     let b = path.bounds().unwrap();
     assert!(close(b.x0, b.x1, 1e-9) && close(b.y0, 20.0, 1e-9) && b.height() > 20.0, "{b:?}");

crates/svg/tests/roundtrip.rs

@@ -420,19 +420,42 @@ fn text_on_path_roundtrip() {
     curve.move_to((20.0, 150.0));
     curve.curve_to((60.0, 40.0), (140.0, 40.0), (180.0, 150.0));
     let mut t = TextObject::point(Point::new(0.0, 0.0), "On a curve", CharStyle { size: 14.0, ..CharStyle::default() });
-    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&curve), start: 0.25 };
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&curve), start: 0.25, end: None };
     let id = d.alloc_id();
     let d = doc_with(vec![Node::new(id, NodeKind::Text(Box::new(t)))]);
     let r = roundtrip(&d);
     let a = art(&r);
     let NodeKind::Text(t) = &a[0].kind else { panic!() };
     assert_eq!(t.plain_text(), "On a curve");
-    let TextKind::OnPath { path, start } = &t.kind else { panic!("not type on a path: {:?}", t.kind) };
+    let TextKind::OnPath { path, start, .. } = &t.kind else { panic!("not type on a path: {:?}", t.kind) };
     assert!((start - 0.25).abs() < 1e-6, "start {start}");
     let doc_path = path.bounds().map(|b| t.xf.transform_rect_bbox(b)).unwrap();
     assert!(close_rect(doc_path, PathData::from_bezpath(&curve).bounds().unwrap(), 0.01), "{doc_path:?}");
 }
 
+/// An end bracket, Align to Path or Spacing, which `<textPath>` can't express, keep their look as
+/// outlines (#429).
+#[test]
+fn text_on_path_options_svg_cannot_express_are_outlined() {
+    let mut curve = vectorcraft_geom::BezPath::new();
+    curve.move_to((20.0, 150.0));
+    curve.curve_to((60.0, 40.0), (140.0, 40.0), (180.0, 150.0));
+    for set in [0, 1, 2] {
+        let mut d = Document::new(200.0, 200.0);
+        let mut t = TextObject::point(Point::ZERO, "On a curve", CharStyle { size: 14.0, ..CharStyle::default() });
+        t.kind = TextKind::OnPath { path: PathData::from_bezpath(&curve), start: 0.1, end: (set == 0).then_some(0.8) };
+        if set == 1 {
+            t.path_align = vectorcraft_doc::PathAlign::Center;
+        }
+        if set == 2 {
+            t.path_spacing = 4.0;
+        }
+        let id = d.alloc_id();
+        let svg = export(&doc_with(vec![Node::new(id, NodeKind::Text(Box::new(t)))]), &ExportOptions::default());
+        assert!(!svg.contains("<textPath"), "{set}: {svg}");
+    }
+}
+
 #[test]
 fn styling_modes_roundtrip() {
     for styling in [Styling::PresentationAttributes, Styling::InlineStyle, Styling::StyleEntities, Styling::InternalCss] {

crates/svg/tests/symbols_layers.rs

@@ -1,6 +1,6 @@
 //! Symbols export as one `<symbol>` def and a `<use>` per instance (instances the def can't stand
-//! for get their own art), hidden layers are kept hidden when asked and come back hidden, and the
-//! editing data notices edits made elsewhere.
+//! for get their own art), hidden layers are kept hidden when asked and come back hidden, clipped
+//! layers come in as clipping layers, and the editing data notices edits made elsewhere.
 // Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness).
 #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
@@ -205,6 +205,78 @@ fn hidden_layers_are_kept_hidden_when_asked() {
     }
 }
 
+/// Each layer's art: clipping layer or not, and the kinds of its children.
+fn layer_art(d: &Document) -> Vec<(String, bool, Vec<&'static str>)> {
+    d.layers.iter().map(|l| (l.name.clone().unwrap_or_default(), l.clips(), l.children().unwrap().iter().map(|c| c.kind_label()).collect())).collect()
+}
+
+/// Two Inkscape layers clipped to the same window (#420), in pixels so resvg draws them at our scale.
+const CLIPPED_LAYERS: &str = r##"<svg xmlns="http://www.w3.org/2000/svg" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" width="200" height="100" viewBox="0 0 200 100">
+<defs><clipPath id="window"><rect x="5" y="5" width="190" height="90"/></clipPath></defs>
+<g id="CUT" inkscape:groupmode="layer" inkscape:label="Cut lines" clip-path="url(#window)"><rect x="0" y="0" width="100" height="100" fill="#f00"/></g>
+<g id="HATCH" inkscape:groupmode="layer" inkscape:label="HATCH" clip-path="url(#window)"><rect x="100" y="0" width="100" height="100" fill="#00f"/></g>
+</svg>"##;
+
+#[test]
+fn clipped_layers_come_in_as_clipping_layers() {
+    let d = import(CLIPPED_LAYERS).unwrap();
+    assert_eq!(
+        layer_art(&d),
+        [("Cut lines".to_string(), true, vec!["Path", "Path"]), ("HATCH".to_string(), true, vec!["Path", "Path"])],
+        "{:?}",
+        d.layers
+    );
+    for l in &d.layers {
+        let clip = &l.children().unwrap()[0];
+        assert!(matches!(clip.kind, NodeKind::Path { clipping: true, .. }) && clip.name.as_deref() == Some("window"));
+        assert_eq!(clip.geometric_bounds().unwrap(), Rect::new(5.0, 5.0, 195.0, 95.0));
+    }
+    // Drawn as the SVG is: each layer cut to the window.
+    assert_similar(&render_artboard(&d), &resvg_render(CLIPPED_LAYERS, 200, 100), 24.0, 0.002);
+    // The issue's file (in points): two clipping layers, the names kept.
+    let pt = CLIPPED_LAYERS.replace("width=\"200\" height=\"100\"", "width=\"200pt\" height=\"100pt\"");
+    let d = import(&pt).unwrap();
+    assert_eq!(d.layers.iter().map(|l| (l.name.as_deref().unwrap(), l.clips())).collect::<Vec<_>>(), [("Cut lines", true), ("HATCH", true)]);
+}
+
+#[test]
+fn clipping_layers_round_trip() {
+    let mut d = import(CLIPPED_LAYERS).unwrap();
+    // A clip path clipped in turn: the layer's own clip outermost, the other one inside it.
+    let nested = CLIPPED_LAYERS.replace(
+        "<defs>",
+        "<defs><clipPath id=\"left\"><rect x=\"0\" y=\"0\" width=\"60\" height=\"100\"/></clipPath><clipPath id=\"inner\" clip-path=\"url(#left)\"><rect x=\"20\" y=\"20\" width=\"160\" height=\"60\"/></clipPath>",
+    );
+    let nested = nested.replacen("url(#window)", "url(#inner)", 1);
+    let n = import(&nested).unwrap();
+    assert_eq!(layer_art(&n)[0], ("Cut lines".to_string(), true, vec!["Path", "Clip Group"]));
+    assert_similar(&render_artboard(&n), &resvg_render(&nested, 200, 100), 24.0, 0.002);
+    d.layers.push(n.layers[0].clone());
+    let svg = export(&d, &ExportOptions::default());
+    let back = import(&svg).unwrap();
+    assert_eq!(layer_art(&back), layer_art(&d), "{svg}");
+    assert_similar(&render_artboard(&back), &render_artboard(&d), 24.0, 0.002);
+}
+
+#[test]
+fn text_joining_a_clipping_layer_stays_unclipped() {
+    // Text beside clipped layers isn't in their clip: the layer keeps its clip as a clip group.
+    let svg = CLIPPED_LAYERS
+        .replace("<g id=\"CUT\"", "<text x=\"1\" y=\"99\">Before</text><g id=\"CUT\"")
+        .replace("</svg>", "<text x=\"150\" y=\"99\">After</text></svg>");
+    let d = import(&svg).unwrap();
+    assert_eq!(
+        layer_art(&d),
+        [("Cut lines".to_string(), false, vec!["Type", "Clip Group"]), ("HATCH".to_string(), false, vec!["Clip Group", "Type"])],
+        "{:?}",
+        d.layers
+    );
+    for l in &d.layers {
+        let g = l.children().unwrap().iter().find(|c| c.clips()).unwrap();
+        assert_eq!(g.children().unwrap().iter().map(|c| c.kind_label()).collect::<Vec<_>>(), ["Path", "Path"]);
+    }
+}
+
 #[test]
 fn hidden_groups_others_use_stay_hidden() {
     // A display:none group a <use> refers to is a template, not a hidden layer.

crates/text/src/layout.rs

@@ -2,9 +2,10 @@
 
 use std::ops::Range;
 
-use kurbo::{Affine, BezPath, ParamCurve, ParamCurveArclen, PathEl, PathSeg, Point, Rect, Shape, Vec2};
+use kurbo::{Affine, BezPath, PathEl, Point, Rect, Shape, Vec2};
 use unicode_bidi::{BidiInfo, Level};
-use vectorcraft_doc::{CharStyle, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathEffect, TextKind, TextObject};
+use vectorcraft_doc::{CharStyle, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathAlign, PathEffect, TextKind, TextObject};
+use vectorcraft_geom::{ArcPath, PathData};
 
 use crate::composer::{Breakpoint, compose};
 use crate::fontdb::FontDb;
@@ -56,7 +57,7 @@ impl Ctx<'_> {
     fn emit(&mut self, g: &SGlyph, pre: Affine, origin: Point, angle: f64, advance: f64, line: usize) {
         let src = self.db.outline(&g.face, g.gid);
         // A glyph whose leading space was taken off (mojikumi) is drawn that much earlier: an
-        // upright one in vertical type by turning about a point that much higher.
+        // upright one in vertical type by moving it up the column once it stands upright.
         let upright = self.vertical && !self.on_path && g.tcy.is_none() && stands_upright(g);
         let lead = if upright { 0.0 } else { g.lead };
         let local =
@@ -79,10 +80,11 @@ impl Ctx<'_> {
             // after the cell, and must not push the glyph off the centre line).
             let em = self.style_at(g.byte).size;
             let cell = if g.adv > 0.0 { upright_cell(g) } else { advance };
-            m = Affine::rotate_about(
-                -std::f64::consts::FRAC_PI_2,
-                Point::new(origin.x + cell * 0.5 - g.lead, origin.y - upright_centre(g, cell, em)),
-            ) * m;
+            // A leading space taken off moves it up the column after the turn (moving the
+            // turning point instead would move it across the column too).
+            m = Affine::translate((-g.lead, 0.0))
+                * Affine::rotate_about(-std::f64::consts::FRAC_PI_2, Point::new(origin.x + cell * 0.5, origin.y - upright_centre(g, cell, em)))
+                * m;
         }
         // Control characters (tabs) and soft hyphens draw nothing (fonts map them to .notdef).
         let outline = if src.elements().is_empty() || g.is_soft_hyphen() || g.ch.is_control() {
@@ -183,7 +185,7 @@ pub fn layout_with(db: &FontDb, t: &TextObject, opts: &LayoutOptions) -> TextLay
             cx.out.frames = regions.iter().map(|r| line_xf.transform_rect_bbox(r.cell)).collect();
             flow(&mut cx, &paras, &t.para, Some(&regions));
         }
-        TextKind::OnPath { path, start } => on_path(&mut cx, &paras, &t.para, &path.to_bezpath(), *start, path.is_closed(), t.path_effect),
+        TextKind::OnPath { path, .. } => on_path(&mut cx, &paras, t, path),
     }
     if vertical && !is_on_path {
         // Glyph origins, outlines and transforms to text space (lines stay in line space).
@@ -281,7 +283,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()
 }
@@ -818,7 +823,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}");
     }
 }
@@ -965,6 +971,18 @@ fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Opt
             let est = if i < n { Metrics::of(&sg[i]) } else { pm };
             let first_line = li_para == 0;
             let ind_l = para.left_indent + if first_line { para.first_line_indent } else { 0.0 };
+            // Mojikumi: an opening bracket starting a wrapped line is set flush with the line's
+            // start (the space before it goes), and the line has that much more room.
+            if !first_line
+                && !rtl
+                && para.mojikumi == Mojikumi::LineEndHalf
+                && let Some(g) = sg.get_mut(i)
+                && g.lead <= 0.0
+                && let Some(h) = punct_half(g, Punct::Opening)
+            {
+                g.adv -= h;
+                g.lead += h;
+            }
             // Place, break, then settle the baseline on the line's real metrics (moving on to the
             // next row/column if it no longer fits).
             let (baseline, x0, x1, end, hyph, m) = loop {
@@ -1151,43 +1169,31 @@ fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Opt
     }
 }
 
-/// Arc-length parameterised path.
-struct ArcPath {
-    segs: Vec<(PathSeg, f64, f64)>,
-    len: f64,
-}
-
-impl ArcPath {
-    fn new(p: &BezPath) -> Self {
-        let mut segs = Vec::new();
-        let mut cum = 0.0;
-        for s in p.segments() {
-            let l = s.arclen(1e-4);
-            if l > 1e-9 {
-                segs.push((s, cum, l));
-                cum += l;
+/// The distance along type on a path each glyph takes: its advance measured `spacing` points above
+/// the path (Type on a Path Options › Spacing), so glyphs close up round the outside of a curve and
+/// open up round the inside; just the advances without spacing. Glyphs start `from` along the path.
+fn path_steps(ap: &ArcPath, glyphs: &[SGlyph], from: f64, spacing: f64) -> Vec<f64> {
+    let mut s = from;
+    glyphs
+        .iter()
+        .map(|g| {
+            let mut step = g.adv;
+            if spacing != 0.0 && g.adv > 1e-9 {
+                // How far the path turns across the glyph: positive bending away from its top.
+                let ((_, a), (_, b)) = (ap.at(s), ap.at(s + g.adv));
+                let curvature = a.cross(b).atan2(a.dot(b)) / g.adv;
+                step = g.adv / (1.0 + curvature * spacing).clamp(0.25, 4.0);
             }
-        }
-        Self { segs, len: cum }
-    }
-
-    /// Point and unit tangent at arc length `s`.
-    fn at(&self, s: f64) -> (Point, Vec2) {
-        let s = s.clamp(0.0, self.len);
-        let i = self.segs.partition_point(|(_, c, _)| *c <= s).saturating_sub(1);
-        let (seg, c, l) = self.segs[i];
-        let t = seg.inv_arclen((s - c).min(l), 1e-4).clamp(0.0, 1.0);
-        let p = seg.eval(t);
-        let (t0, t1) = ((t - 1e-4).max(0.0), (t + 1e-4).min(1.0));
-        let d = seg.eval(t1) - seg.eval(t0);
-        let len = d.hypot();
-        (p, if len > 1e-12 { d / len } else { Vec2::new(1.0, 0.0) })
-    }
+            s += step;
+            step
+        })
+        .collect()
 }
 
-#[allow(clippy::too_many_arguments)]
-fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, path: &BezPath, start: f64, closed: bool, effect: PathEffect) {
+/// Lay type on a path out along `path` (text space), between its brackets.
+fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, path: &PathData) {
     cx.out.on_path = true;
+    let para = &t.para;
     let mut sg = Vec::new();
     // The first paragraph's direction aligns the line (Auto) and sets the caret's.
     let mut rtl = None;
@@ -1209,7 +1215,7 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, path: &Be
         (s.0, s.1)
     });
     let text_len = cx.text.len();
-    if ap.segs.is_empty() {
+    if ap.is_empty() {
         cx.out.overflow = !sg.is_empty();
         cx.out.lines.push(LineInfo {
             rtl,
@@ -1226,32 +1232,43 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, path: &Be
         });
         return;
     }
-    let centre = path.bounding_box().center();
-    let s_start = start.clamp(0.0, 1.0) * ap.len;
-    let avail = if closed { ap.len } else { ap.len - s_start };
-    let w: f64 = sg.iter().map(|g| g.adv).sum();
+    let centre = path.bounds().unwrap_or_default().center();
+    let (from, to) = t.kind.path_span().unwrap_or((0.0, 1.0));
+    let s_start = from * ap.len();
+    let avail = (to - from) * ap.len();
+    let spacing = if t.path_spacing.is_finite() { t.path_spacing } else { 0.0 };
+    let mut steps = path_steps(&ap, &sg, s_start, spacing);
+    let w: f64 = steps.iter().sum();
     let s0 = match para.justify {
         Justify::Auto if rtl => s_start + (avail - w).max(0.0),
         Justify::Center | Justify::JustifyCenter => s_start + ((avail - w) * 0.5).max(0.0),
         Justify::Right | Justify::JustifyRight => s_start + (avail - w).max(0.0),
         _ => s_start,
     };
+    if spacing != 0.0 && s0 != s_start {
+        // Spaced from where the alignment puts them, the curve under them is another.
+        steps = path_steps(&ap, &sg, s0, spacing);
+    }
+    // Align to Path: how far down (glyph space) the type moves to run its ascender, centre or
+    // descender along the path instead of its baseline.
+    let rise = match t.path_align {
+        PathAlign::Baseline => 0.0,
+        PathAlign::Ascender => m.0,
+        PathAlign::Descender => -m.1,
+        PathAlign::Center => (m.0 - m.1) * 0.5,
+    };
     let mut x = 0.0;
-    for g in &sg {
+    for (g, &step) in sg.iter().zip(&steps) {
         let s = s0 + x;
-        if s + g.adv - s_start > avail + 1e-6 {
+        if s + step - s_start > avail + 1e-6 {
             cx.out.overflow = true;
             break;
         }
-        let mut mid = s + g.adv * 0.5;
-        if closed {
-            mid = mid.rem_euclid(ap.len);
-        }
-        let (p, dir) = ap.at(mid);
+        let (p, dir) = ap.at(s + step * 0.5);
         let angle = dir.y.atan2(dir.x);
-        let half = Affine::translate((-g.adv * 0.5, 0.0));
+        let half = Affine::translate((-g.adv * 0.5, rise));
         // Glyph space: x along the advance, y down from the baseline; `pre` maps it onto the path.
-        let pre = match effect {
+        let pre = match t.path_effect {
             PathEffect::Rainbow => Affine::translate(p.to_vec2()) * Affine::rotate(angle) * half,
             // x axis along the tangent, y axis stays vertical.
             PathEffect::Skew => Affine::translate(p.to_vec2()) * Affine::new([dir.x, dir.y, 0.0, 1.0, 0.0, 0.0]) * half,
@@ -1260,10 +1277,7 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, path: &Be
                 let sx = if dir.x < 0.0 { -1.0 } else { 1.0 };
                 Affine::translate(p.to_vec2()) * Affine::new([sx, 0.0, -dir.y * sx, dir.x * sx, 0.0, 0.0]) * half
             }
-            PathEffect::StairStep => {
-                let s_left = if closed { s.rem_euclid(ap.len) } else { s };
-                Affine::translate(ap.at(s_left).0.to_vec2())
-            }
+            PathEffect::StairStep => Affine::translate(ap.at(s).0.to_vec2()) * Affine::translate((0.0, rise)),
             // x axis along the tangent; vertical edges point at the path's centre (kept on the glyph's
             // up side, and never closer than ~17° to the baseline so glyphs stay legible).
             PathEffect::Gravity => {
@@ -1274,17 +1288,19 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, path: &Be
                     up = -up;
                 }
                 if up.dot(n) < 0.3 {
-                    let t = up - n * up.dot(n);
-                    up = n * 0.3 + t / t.hypot().max(1e-9) * (1.0 - 0.09f64).sqrt();
+                    let along = up - n * up.dot(n);
+                    up = n * 0.3 + along / along.hypot().max(1e-9) * (1.0 - 0.09f64).sqrt();
                 }
                 Affine::translate(p.to_vec2()) * Affine::new([dir.x, dir.y, -up.x, -up.y, 0.0, 0.0]) * half
             }
         };
-        cx.emit(g, pre, p - dir * (g.adv * 0.5), angle, g.adv, 0);
-        x += g.adv;
+        // The caret's baseline moves with the type.
+        let origin = p - dir * (g.adv * 0.5) + Vec2::new(-dir.y, dir.x) * rise;
+        cx.emit(g, pre, origin, angle, g.adv, 0);
+        x += step;
     }
-    let (ps, _) = ap.at(if closed { s0.rem_euclid(ap.len) } else { s0 });
-    let (pe, _) = ap.at(if closed { (s0 + x).rem_euclid(ap.len) } else { s0 + x });
+    let (ps, _) = ap.at(s0);
+    let (pe, _) = ap.at(s0 + x);
     cx.out.lines.push(LineInfo {
         rtl,
         baseline: ps.y,
@@ -1296,7 +1312,7 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, path: &Be
         end: text_len,
         glyph_start: 0,
         glyph_end: cx.out.glyphs.len(),
-        avail: (0.0, ap.len),
+        avail: (0.0, ap.len()),
     });
 }
 

crates/text/src/lib.rs

@@ -328,24 +328,6 @@ pub fn caret_vertical(layout: &TextLayout, byte: usize, delta: i32, goal_x: f64)
     byte_in_line(layout, li as usize, goal_x)
 }
 
-/// Nearest point on `path` to `p`: (fraction of the path's arc length 0..1, distance). Used to
-/// start type on a path where the user clicked.
-pub fn path_fraction_at(path: &BezPath, p: Point) -> (f64, f64) {
-    use kurbo::{ParamCurve, ParamCurveArclen, ParamCurveNearest};
-    let mut total = 0.0;
-    let mut best = (0.0, f64::INFINITY);
-    for seg in path.segments() {
-        let len = seg.arclen(1e-3);
-        let n = seg.nearest(p, 1e-4);
-        let d = n.distance_sq.sqrt();
-        if d < best.1 {
-            best = (total + seg.subsegment(0.0..n.t).arclen(1e-3), d);
-        }
-        total += len;
-    }
-    if total <= 0.0 { (0.0, best.1) } else { ((best.0 / total).clamp(0.0, 1.0), best.1) }
-}
-
 /// Highlight quads (text space, clockwise from top-left) covering the selected bytes `a..b`.
 pub fn selection_quads(layout: &TextLayout, a: usize, b: usize) -> Vec<[Point; 4]> {
     let (a, b) = (a.min(b), a.max(b));

crates/text/src/tests.rs

@@ -271,7 +271,7 @@ fn on_path_placement() {
     line.move_to((0.0, 50.0));
     line.line_to((500.0, 50.0));
     let mut t = point("Path", style(20.0));
-    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&line), start: 0.1 };
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&line), start: 0.1, end: None };
     let l = layout(db(), &t);
     assert!(l.on_path && !l.overflow);
     assert_eq!(l.glyphs.len(), 4);
@@ -283,7 +283,7 @@ fn on_path_placement() {
     let mut v = BezPath::new();
     v.move_to((0.0, 0.0));
     v.line_to((0.0, 300.0));
-    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&v), start: 0.0 };
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&v), start: 0.0, end: None };
     let l = layout(db(), &t);
     for g in &l.glyphs {
         assert!((g.angle - std::f64::consts::FRAC_PI_2).abs() < 1e-3);
@@ -302,7 +302,7 @@ fn on_path_effects_orient_glyphs() {
     diag.move_to((0.0, 0.0));
     diag.line_to((400.0, 400.0));
     let mut t = point("H", style(40.0));
-    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&diag), start: 0.1 };
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&diag), start: 0.1, end: None };
     let bbox = |t: &TextObject| layout(db(), t).glyphs[0].outline.bounding_box();
     let rainbow = bbox(&t);
     t.path_effect = PathEffect::StairStep;
@@ -315,7 +315,7 @@ fn on_path_effects_orient_glyphs() {
     assert!(skew.height() > stair.height() && skew.width() < rainbow.width() + 1e-6, "{skew:?}");
     // Gravity on a circle: glyphs point away from the centre (same as Rainbow on a circle).
     let circle = kurbo::Circle::new((0.0, 0.0), 100.0).to_path(0.1);
-    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&circle), start: 0.0 };
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&circle), start: 0.0, end: None };
     t.path_effect = PathEffect::Rainbow;
     let a = layout(db(), &t).glyphs[0].outline.bounding_box();
     t.path_effect = PathEffect::Gravity;
@@ -329,7 +329,7 @@ fn on_path_effects_orient_glyphs() {
 fn on_path_circle_and_overflow() {
     let circle = kurbo::Circle::new((0.0, 0.0), 100.0).to_path(0.1);
     let mut t = point("Around the circle", style(14.0));
-    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&circle), start: 0.0 };
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&circle), start: 0.0, end: None };
     let l = layout(db(), &t);
     assert!(!l.overflow);
     for g in &l.glyphs {
@@ -339,7 +339,7 @@ fn on_path_circle_and_overflow() {
     let mut short = BezPath::new();
     short.move_to((0.0, 0.0));
     short.line_to((30.0, 0.0));
-    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&short), start: 0.0 };
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&short), start: 0.0, end: None };
     let l = layout(db(), &t);
     assert!(l.overflow && l.glyphs.len() < t.plain_text().len());
 }

crates/text/src/tests_vertical.rs

@@ -76,7 +76,7 @@ fn area_type_starts_at_the_right_edge_and_wraps_to_the_left() {
 #[test]
 fn type_on_a_path_stays_horizontal() {
     let mut t = vertical("ab");
-    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&kurbo::Line::new((0.0, 0.0), (100.0, 0.0)).to_path(0.1)), start: 0.0 };
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&kurbo::Line::new((0.0, 0.0), (100.0, 0.0)).to_path(0.1)), start: 0.0, end: None };
     assert!(!layout(FontDb::global(), &t).vertical);
 }
 
@@ -325,6 +325,9 @@ fn mojikumi_halves_line_end_and_consecutive_punctuation() {
         let along = |r: Rect| if vertical_type { r.y0 } else { r.x0 };
         let moved = along(off.glyphs[1].outline.bounding_box()) - along(on.glyphs[1].outline.bounding_box());
         assert!((moved - 10.0).abs() < 0.01, "vertical {vertical_type}: the second 「 is drawn half an em earlier ({moved})");
+        let across = |r: Rect| if vertical_type { r.x0 } else { r.y0 };
+        let drift = across(off.glyphs[1].outline.bounding_box()) - across(on.glyphs[1].outline.bounding_box());
+        assert!(drift.abs() < 0.01, "vertical {vertical_type}: and not moved across the line ({drift})");
         // Text without punctuation is untouched.
         assert_eq!(adv("一二", Mojikumi::LineEndHalf), adv("一二", Mojikumi::None));
     }
@@ -364,3 +367,42 @@ fn mojikumi_spaces_japanese_from_latin_by_a_quarter_em() {
     let off = lay("第10回", Mojikumi::None, true);
     assert!(on.glyphs.iter().zip(&off.glyphs).all(|(a, b)| (a.advance - b.advance).abs() < 0.01));
 }
+
+/// Mojikumi (JLREQ 3.1.5): with Line-end Punctuation Half Width, an opening bracket starting a
+/// wrapped line is set flush with the line's start (the space before it goes), giving the line half
+/// an em more room; at the start of a paragraph it keeps its full width. Horizontal and vertical.
+/// Needs a font with full-width Japanese punctuation (skipped without one).
+#[test]
+fn mojikumi_sets_an_opening_bracket_flush_at_the_start_of_a_wrapped_line() {
+    use vectorcraft_doc::Mojikumi;
+    // 20 pt type in a frame three and a half ems across the lines.
+    let lay = |text: &str, m: Mojikumi, vertical_type: bool| {
+        let mut t = TextObject::point(Point::ZERO, text, CharStyle { size: 20.0, ..CharStyle::default() });
+        t.xf = Affine::IDENTITY;
+        t.vertical = vertical_type;
+        t.para.mojikumi = m;
+        let frame = if vertical_type { Rect::new(0.0, 0.0, 200.0, 70.0) } else { Rect::new(0.0, 0.0, 70.0, 200.0) };
+        t.kind = TextKind::Area { frame: PathData::from_bezpath(&frame.to_path(0.1)) };
+        layout(FontDb::global(), &t)
+    };
+    if (lay("一「", Mojikumi::None, false).glyphs[1].advance - 20.0).abs() > 2.0 {
+        return; // no font with full-width punctuation here
+    }
+    for vertical_type in [false, true] {
+        let along = |r: Rect| if vertical_type { r.y0 } else { r.x0 };
+        // 一二三 / 「四五六: the bracket can't end the first line, so it starts the second.
+        let (on, off) = (lay("一二三「四五六", Mojikumi::LineEndHalf, vertical_type), lay("一二三「四五六", Mojikumi::None, vertical_type));
+        let moved = along(off.glyphs[3].outline.bounding_box()) - along(on.glyphs[3].outline.bounding_box());
+        assert!((moved - 10.0).abs() < 0.01, "vertical {vertical_type}: 「 is drawn half an em earlier ({moved})");
+        let across = |r: Rect| if vertical_type { r.x0 } else { r.y0 };
+        let drift = across(off.glyphs[3].outline.bounding_box()) - across(on.glyphs[3].outline.bounding_box());
+        assert!(drift.abs() < 0.01, "vertical {vertical_type}: and not moved across the line ({drift})");
+        assert!((on.glyphs[3].advance - 10.0).abs() < 0.01, "vertical {vertical_type}: {}", on.glyphs[3].advance);
+        // The half em it gave up lets 六 stay on the line.
+        assert_eq!(on.glyphs[6].line, on.glyphs[3].line, "vertical {vertical_type}");
+        assert_ne!(off.glyphs[6].line, off.glyphs[3].line, "vertical {vertical_type}");
+        // At the start of a paragraph the bracket keeps its full width.
+        let first = lay("「一」", Mojikumi::LineEndHalf, vertical_type);
+        assert!((first.glyphs[0].advance - 20.0).abs() < 0.01, "vertical {vertical_type}: {}", first.glyphs[0].advance);
+    }
+}

crates/tools/src/corners.rs

@@ -64,12 +64,27 @@ impl CornerWidgets {
         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).
     pub fn for_tool(cx: &ToolContext) -> Option<Self> {
         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)
     }
 
     /// The centres of the widgets that show.
@@ -318,6 +333,27 @@ mod tests {
         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

@@ -1,17 +1,21 @@
 //! Direct Selection (A) and Group Selection tools.
 //!
 //! 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
+//! path's anchors on that segment, drag to move selected anchors (the one pressed on snaps to
+//! anchors, segments and Smart Guides, or with them off Snap to Point; Shift keeps the move at 45°
+//! steps), 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
 //! (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 move objects selected as a whole as the Selection tool does, snapping alike.
+//! 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.
+//! Dragging the brackets of selected type on a path moves or flips it ([`crate::pathtype`]).
 //!
 //! 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
@@ -26,15 +30,21 @@ use vectorcraft_geom::{PathData, Point, Rect};
 
 use crate::bbox::move_delta;
 use crate::corners::{self, CornerDrag, over_widget};
+use crate::guides::{PointSnap, Targets};
 use crate::meshedit::MeshEdit;
-use crate::select::{is_area_type, matrix_json};
+use crate::pathtype::{self, BracketDrag, over_bracket};
+use crate::rulerguide::GuideEdit;
+use crate::select::{MoveSnap, is_area_type, matrix_json};
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext};
 
 #[derive(Clone, Debug)]
 enum State {
     Idle,
+    /// Dragging the selected anchors, which move alike: `grab` is where the anchor pressed on (or
+    /// the pointer on a segment) was, the point that snaps.
     MoveAnchors {
         start: Point,
+        grab: Point,
         began: bool,
     },
     MoveObject {
@@ -62,6 +72,8 @@ enum State {
         add: bool,
     },
     Corner(CornerDrag),
+    /// Dragging a bracket of type on a path.
+    Bracket(BracketDrag),
     /// Dragging a point of a blend's spine from `from`.
     SpinePoint {
         id: NodeId,
@@ -93,13 +105,30 @@ pub struct DirectSelectionTool {
     /// The spine point last clicked (blend, anchor): its handles show and can be dragged.
     spine: Option<(NodeId, usize)>,
     mesh: MeshEdit,
-    /// Smart guides of the handle being dragged.
+    /// Smart guides of the handle, anchors or objects being dragged.
     guides: Vec<Overlay>,
+    /// What the dragged anchors snap to, gathered when the drag begins.
+    anchor_snap: Option<PointSnap>,
+    /// What the objects being moved snap to, gathered when the move begins.
+    move_snap: Option<MoveSnap>,
+    /// 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![],
+            anchor_snap: None,
+            move_snap: None,
+            hover: None,
+            guide: GuideEdit::default(),
+        }
     }
 }
 
@@ -166,12 +195,12 @@ fn anchor_owners(cx: &ToolContext, f: fn(&Node) -> bool) -> Vec<NodeId> {
     v
 }
 
-/// Anchor of any visible path or area type frame under `p`, topmost first.
-fn hit_anchor(cx: &ToolContext, p: Point, tol: f64) -> Option<(NodeId, usize, usize)> {
+/// Anchor of any visible path or area type frame under `p`, topmost first: (id, si, ai, where it is).
+fn hit_anchor(cx: &ToolContext, p: Point, tol: f64) -> Option<(NodeId, usize, usize, Point)> {
     let owners = anchor_owners(cx, |n| matches!(n.kind, NodeKind::Path { .. }) || is_area_type(n));
     owners.into_iter().find_map(|id| {
         let pd = cx.doc.node(id).and_then(editable_path)?;
-        pd.anchors().find(|(_, _, a)| a.p.distance(p) <= tol).map(|(si, ai, _)| (id, si, ai))
+        pd.anchors().find(|(_, _, a)| a.p.distance(p) <= tol).map(|(si, ai, a)| (id, si, ai, a.p))
     })
 }
 
@@ -185,8 +214,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 {
@@ -232,13 +270,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![];
@@ -260,11 +305,19 @@ impl Tool for DirectSelectionTool {
                 }
             }
             (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, ev) {
                     self.state = State::Corner(c);
                     return vec![];
                 }
+                if let Some(b) = BracketDrag::hit(cx, ev) {
+                    self.state = State::Bracket(b);
+                    return vec![];
+                }
                 if let Some(sel) = self.spine.filter(|(id, _)| cx.selection.contains(*id))
                     && let Some(out) = hit_spine_handle(cx, sel, p, tol)
                 {
@@ -286,12 +339,12 @@ impl Tool for DirectSelectionTool {
                     self.state = State::SpinePoint { id, anchor, from, start: p, began: false };
                     return if cx.selection.contains(id) { vec![] } else { vec![Action::Exec("select.set".into(), json!({"ids": [id.0]}))] };
                 }
-                if let Some((id, si, ai)) = hit_anchor(cx, p, tol) {
+                if let Some((id, si, ai, grab)) = hit_anchor(cx, p, tol) {
                     if cx.doc.node(id).is_some_and(is_area_type) {
                         return self.press_type_area(cx, id, vec![(si, ai)], p, ev.mods.shift);
                     }
                     let already = cx.selection.partial(id).is_some_and(|s| s.contains(&(si, ai)));
-                    self.state = State::MoveAnchors { start: p, began: false };
+                    self.state = State::MoveAnchors { start: p, grab, began: false };
                     if ev.mods.shift {
                         return vec![Action::Exec("select.anchors".into(), json!({"id": id.0, "anchors": [[si, ai]], "mode": "toggle"}))];
                     }
@@ -303,6 +356,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
@@ -318,7 +375,7 @@ impl Tool for DirectSelectionTool {
                         self.state = if s.curved {
                             State::Segment { id: h.leaf, si: s.si, seg: s.seg, t: s.t, start: p, began: false }
                         } else {
-                            State::MoveAnchors { start: p, began: false }
+                            State::MoveAnchors { start: p, grab: p, began: false }
                         };
                         if selected {
                             return vec![];
@@ -339,16 +396,25 @@ impl Tool for DirectSelectionTool {
                 self.state = State::Marquee { start: p, cur: p, add: ev.mods.shift };
                 vec![]
             }
-            (PointerKind::Drag, State::MoveAnchors { start, began }) => {
+            (PointerKind::Drag, State::MoveAnchors { start, grab, began }) => {
                 let mut out = vec![];
                 if !began {
                     if p.distance(start) < cx.tol(3.0) {
                         return out;
                     }
                     out.push(Action::Begin("Move".into()));
-                    self.state = State::MoveAnchors { start, began: true };
+                    self.state = State::MoveAnchors { start, grab, began: true };
+                    self.anchor_snap = Some(PointSnap::new(cx, || Targets::for_anchor_drag(cx.doc, cx.selection)));
+                }
+                let mut d = move_delta(start, p, ev.mods.shift);
+                // The grabbed anchor snaps and the others follow it; Shift keeps the angle instead.
+                self.guides.clear();
+                if !ev.mods.shift
+                    && let Some(snap) = &self.anchor_snap
+                {
+                    let (q, guides) = snap.snap(cx, grab + d);
+                    (d, self.guides) = (q - grab, guides);
                 }
-                let d = move_delta(start, p, ev.mods.shift);
                 out.push(Action::Preview("path.moveAnchors".into(), json!({"dx": d.x, "dy": d.y})));
                 out
             }
@@ -376,8 +442,12 @@ impl Tool for DirectSelectionTool {
                     }
                     out.push(Action::Begin("Move".into()));
                     self.state = State::MoveObject { start, began: true };
+                    self.move_snap = Some(MoveSnap::new(cx));
+                }
+                let mut d = move_delta(start, p, ev.mods.shift);
+                if let Some(snap) = &self.move_snap {
+                    (d, self.guides) = snap.snap(cx, start, d);
                 }
-                let d = move_delta(start, p, ev.mods.shift);
                 out.push(Action::Preview(
                     "object.transform".into(),
                     json!({"matrix": matrix_json(vectorcraft_geom::Affine::translate(d)), "copy": ev.mods.alt}),
@@ -440,6 +510,15 @@ impl Tool for DirectSelectionTool {
                 self.state = State::Idle;
                 c.finish()
             }
+            (PointerKind::Drag, State::Bracket(mut b)) => {
+                let out = b.drag(cx, p, ev.mods.cmd);
+                self.state = State::Bracket(b);
+                out
+            }
+            (PointerKind::Up, State::Bracket(b)) => {
+                self.state = State::Idle;
+                b.finish()
+            }
             (
                 PointerKind::Up,
                 State::MoveAnchors { began, .. }
@@ -449,6 +528,8 @@ impl Tool for DirectSelectionTool {
                 | State::TypeArea { began, .. },
             ) => {
                 self.state = State::Idle;
+                self.guides.clear();
+                (self.anchor_snap, self.move_snap) = (None, None);
                 if began { vec![Action::Commit] } else { vec![] }
             }
             (PointerKind::Up, State::Handle { .. } | State::SpineHandle { .. }) => {
@@ -488,10 +569,15 @@ impl Tool for DirectSelectionTool {
                 out.extend(self.mesh.overlays(cx));
                 if !self.group {
                     out.extend(frame_overlays(cx));
+                    out.extend(pathtype::overlays(cx));
                 }
-                if matches!(self.state, State::Handle { .. }) {
+                if matches!(self.state, State::Handle { .. } | State::MoveAnchors { .. } | State::MoveObject { .. }) {
                     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
             }
         }
@@ -500,10 +586,25 @@ impl Tool for DirectSelectionTool {
         if !self.group && (matches!(self.state, State::Corner(_)) || over_widget(cx, p)) {
             return Cursor::CornerRadius;
         }
-        Cursor::ArrowHollow
+        if !self.group && (matches!(self.state, State::Bracket(_)) || over_bracket(cx, p)) {
+            return Cursor::PathBracket;
+        }
+        // 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![];
@@ -550,6 +651,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();
@@ -564,6 +685,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();
@@ -705,4 +850,92 @@ mod tests {
         let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 150.0, 81.0));
         assert!(matches!(&a[..], [Action::Begin(_), Action::Preview(c, _)] if c == "object.transform"), "{a:?}");
     }
+
+    /// [`doc_with_rect`] (A, 100..200) and a second square B, 300..400: (A, B).
+    fn two_squares() -> (vectorcraft_doc::Document, NodeId, NodeId) {
+        let (mut d, a) = doc_with_rect();
+        let l = d.layers[0].id;
+        let b = d.alloc_id();
+        let sq = vectorcraft_geom::shapes::rectangle(Rect::new(300.0, 300.0, 400.0, 400.0));
+        d.insert(Some(l), 1, vectorcraft_doc::Node::path(b, sq, vectorcraft_doc::Appearance::default_art())).unwrap();
+        (d, a, b)
+    }
+
+    /// The anchors `anchors` of path `id` direct-selected.
+    fn anchors_of(id: NodeId, anchors: &[AnchorRef]) -> Selection {
+        let mut s = Selection::default();
+        s.set([id]);
+        s.anchors.insert(id, anchors.iter().copied().collect());
+        s
+    }
+
+    /// Press at `from`, drag to `to`: the move the drag previews, and the smart guide labels shown.
+    fn drag(t: &mut DirectSelectionTool, cx: &ToolContext, from: (f64, f64), to: (f64, f64), mods: Mods) -> (Value, Vec<String>) {
+        t.pointer(cx, &PointerEvent::new(PointerKind::Down, from.0, from.1).with_mods(mods));
+        let a = t.pointer(cx, &PointerEvent::new(PointerKind::Drag, to.0, to.1).with_mods(mods));
+        let Some(Action::Preview(_, v)) = a.last() else { panic!("{a:?}") };
+        let labels = t
+            .overlays(cx)
+            .into_iter()
+            .filter_map(|o| match o {
+                Overlay::Label { text, .. } => Some(text),
+                _ => None,
+            })
+            .collect();
+        assert_eq!(t.pointer(cx, &PointerEvent::new(PointerKind::Up, to.0, to.1).with_mods(mods)), vec![Action::Commit]);
+        assert!(t.overlays(cx).iter().all(|o| !matches!(o, Overlay::Label { .. })), "the guides go with the drag");
+        (v.clone(), labels)
+    }
+
+    /// A dragged anchor lands on another path's anchor or segment, lines up with the other anchors
+    /// of its own path, and with several selected the one pressed on snaps, the others following.
+    #[test]
+    fn dragged_anchors_snap_to_points_segments_and_smart_guides() {
+        let (d, _, b) = two_squares();
+        let p = paint();
+        let none = Mods::default();
+        let one = anchors_of(b, &[(0, 0)]);
+        let c = cx(&d, &one, &p);
+        let mut t = DirectSelectionTool::new(false);
+        // B's top-left corner, pressed 1 pt off, onto A's bottom-right one.
+        let (v, labels) = drag(&mut t, &c, (301.0, 301.0), (203.0, 199.0), none);
+        assert_eq!((v, labels), (json!({"dx": -100.0, "dy": -100.0}), vec!["anchor".to_string()]));
+        // Onto A's right side.
+        let (v, labels) = drag(&mut t, &c, (300.0, 300.0), (203.0, 150.0), none);
+        assert_eq!((v, labels), (json!({"dx": -100.0, "dy": -150.0}), vec!["path".to_string()]));
+        // In line with B's own bottom-left corner, which stays put.
+        let (v, labels) = drag(&mut t, &c, (300.0, 300.0), (303.0, 330.0), none);
+        assert_eq!((v, labels), (json!({"dx": 0.0, "dy": 30.0}), vec!["align".to_string()]));
+        // Shift keeps the move at 45° steps, unsnapped.
+        let (v, labels) = drag(&mut t, &c, (300.0, 300.0), (203.0, 199.0), Mods { shift: true, ..none });
+        let s = move_delta(Point::new(300.0, 300.0), Point::new(203.0, 199.0), true);
+        assert_eq!((v, labels), (json!({"dx": s.x, "dy": s.y}), vec![]));
+        // Two anchors: the one pressed on (B's top-right) lands on A's corner.
+        let two = anchors_of(b, &[(0, 0), (0, 1)]);
+        let c = cx(&d, &two, &p);
+        let (v, _) = drag(&mut t, &c, (400.0, 300.0), (202.0, 198.0), none);
+        assert_eq!(v, json!({"dx": -200.0, "dy": -100.0}));
+        // Smart Guides off: Snap to Point pulls within its distance (2 px) only.
+        let c = ToolContext { smart_guides: false, ..cx(&d, &one, &p) };
+        assert_eq!(drag(&mut t, &c, (300.0, 300.0), (201.0, 199.0), none).0, json!({"dx": -100.0, "dy": -100.0}));
+        assert_eq!(drag(&mut t, &c, (300.0, 300.0), (203.0, 199.0), none).0, json!({"dx": -97.0, "dy": -101.0}));
+        let c = ToolContext { smart_guides: false, snap_to_point: false, ..cx(&d, &one, &p) };
+        assert_eq!(drag(&mut t, &c, (300.0, 300.0), (201.0, 199.0), none).0, json!({"dx": -99.0, "dy": -101.0}));
+    }
+
+    /// Group Selection (and Direct Selection on a whole path) moves objects snapping as the
+    /// Selection tool does: B's left side lines up with A's right one.
+    #[test]
+    fn moved_objects_snap_with_smart_guides() {
+        let (d, _, b) = two_squares();
+        let p = paint();
+        let mut s = Selection::default();
+        s.set([b]);
+        let c = cx(&d, &s, &p);
+        for group in [true, false] {
+            let mut t = DirectSelectionTool::new(group);
+            let (v, _) = drag(&mut t, &c, (350.0, 350.0), (253.0, 351.0), Mods::default());
+            assert_eq!(v["matrix"], json!([1.0, 0.0, 0.0, 1.0, -100.0, 1.0]), "group: {group}");
+        }
+    }
 }

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

@@ -1,9 +1,11 @@
-//! Smart Guides: snapping to anchors, object bounds (edges/centres), artboards, with the magenta
-//! construction lines and labels Illustrator users expect.
+//! Smart Guides: snapping to anchors, path segments (for dragged anchors), object bounds
+//! (edges/centres), artboards, with the magenta construction lines and labels Illustrator users
+//! expect.
 
 use vectorcraft_doc::hit::{HitOptions, hit_test};
-use vectorcraft_doc::{Document, NodeId, NodeKind, OrientedBox};
-use vectorcraft_geom::{Affine, Point, Rect, Vec2};
+use vectorcraft_doc::{Document, NodeId, NodeKind, OrientedBox, Selection};
+use vectorcraft_geom::kurbo::ParamCurveNearest;
+use vectorcraft_geom::{Affine, Line, ParamCurve, PathSeg, Point, Rect, SubPath, Vec2};
 
 use crate::bbox::Handle;
 use crate::{Overlay, ToolContext};
@@ -17,6 +19,7 @@ enum Kind {
     Edge,
     Artboard,
     Bleed,
+    Guide,
 }
 
 impl Kind {
@@ -27,6 +30,7 @@ impl Kind {
             Kind::Edge => "path",
             Kind::Artboard => "artboard",
             Kind::Bleed => "bleed",
+            Kind::Guide => "guide",
         }
     }
 }
@@ -37,20 +41,67 @@ pub struct Targets {
     points: Vec<(Point, Kind)>,
     xs: Vec<(f64, Point, Kind)>,
     ys: Vec<(f64, Point, Kind)>,
+    /// Path segments and their control bounds, which a point lands on ("path"): gathered only for
+    /// dragged anchors ([`Self::for_anchor_drag`]).
+    segments: Vec<(Rect, PathSeg)>,
 }
 
+/// How many anchors, and how many segments, the targets gather at most.
+const BUDGET: usize = 20_000;
+
 impl Targets {
     pub fn collect(doc: &Document, exclude: &[NodeId], visible: Option<Rect>) -> Self {
-        Self::collect_inner(doc, exclude, None, visible)
+        Self::collect_inner(doc, exclude, None, visible, false)
     }
 
     /// Targets for dragging artboard `index`: everything except that artboard and `exclude` (the
     /// art that moves along with it).
     pub fn for_artboard(doc: &Document, index: usize, exclude: &[NodeId]) -> Self {
-        Self::collect_inner(doc, exclude, Some(index), None)
+        Self::collect_inner(doc, exclude, Some(index), None, false)
     }
 
-    fn collect_inner(doc: &Document, exclude: &[NodeId], skip_artboard: Option<usize>, visible: Option<Rect>) -> Self {
+    /// Targets for dragging the direct-selected anchors of `sel` (and its objects selected as a
+    /// whole): the other art, its path segments too, and the anchors and segments that stay put on
+    /// the paths being reshaped (their bounds move along, so they are no targets).
+    pub fn for_anchor_drag(doc: &Document, sel: &Selection) -> Self {
+        let mut t = Self::collect_inner(doc, &sel.objects, None, None, true);
+        let (mut anchors, mut segments) = (BUDGET, BUDGET);
+        for (id, set) in &sel.anchors {
+            let Some(path) = doc.node(*id).and_then(|n| n.path_data()) else { continue };
+            for (si, sp) in path.subpaths.iter().enumerate() {
+                let moving = |ai: usize| set.contains(&(si, ai));
+                for a in sp.anchors.iter().enumerate().filter(|(ai, _)| !moving(*ai)).map(|(_, a)| a.p).take(anchors) {
+                    t.points.push((a, Kind::Anchor));
+                    t.xs.push((a.x, a, Kind::Anchor));
+                    t.ys.push((a.y, a, Kind::Anchor));
+                    anchors -= 1;
+                }
+                t.push_segments(sp, moving, &mut segments);
+            }
+        }
+        t
+    }
+
+    /// The segments of `sp` that stay put while the anchors `moving` accepts move, as targets, at
+    /// most `budget` of them (counted down).
+    fn push_segments(&mut self, sp: &SubPath, moving: impl Fn(usize) -> bool, budget: &mut usize) {
+        let n = sp.anchors.len();
+        for seg in 0..sp.segment_count() {
+            if *budget == 0 {
+                return;
+            }
+            if moving(seg) || moving((seg + 1) % n) {
+                continue;
+            }
+            let c = sp.segment(seg);
+            let bounds = Rect::from_points(c.p0, c.p1).union_pt(c.p2).union_pt(c.p3);
+            // A straight one as a line, so the point lands on it exactly.
+            self.segments.push((bounds, if sp.segment_is_line(seg) { PathSeg::Line(Line::new(c.p0, c.p3)) } else { PathSeg::Cubic(c) }));
+            *budget -= 1;
+        }
+    }
+
+    fn collect_inner(doc: &Document, exclude: &[NodeId], skip_artboard: Option<usize>, visible: Option<Rect>, segments: bool) -> Self {
         let mut t = Targets::default();
         let excluded = |id: NodeId| exclude.iter().any(|e| doc.ancestry(id).is_some_and(|a| a.contains(e)));
         let add_rect = |t: &mut Targets, r: Rect, kind: Kind| {
@@ -72,7 +123,7 @@ impl Targets {
                 add_rect(&mut t, doc.setup.bleed_rect(ab.rect), Kind::Bleed);
             }
         }
-        let mut budget = 20_000usize;
+        let (mut budget, mut segment_budget) = (BUDGET, BUDGET);
         doc.walk(|n| {
             if budget == 0 || n.is_container() || !n.visible || excluded(n.id) {
                 return;
@@ -89,12 +140,39 @@ impl Targets {
                     t.points.push((a.p, Kind::Anchor));
                     budget = budget.saturating_sub(1);
                 }
+                if segments {
+                    for sp in &path.subpaths {
+                        t.push_segments(sp, |_| false, &mut segment_budget);
+                    }
+                }
             }
             add_rect(&mut t, b, Kind::Edge);
         });
         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();
+        self.segments.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 {
@@ -117,11 +195,15 @@ impl Targets {
         t
     }
 
-    /// Snap a single point. Returns the snapped point and guide overlays.
+    /// Snap a single point: onto the nearest anchor or centre, else onto the nearest segment, else
+    /// into line with targets. Returns the snapped point and guide overlays.
     pub fn snap_point(&self, p: Point, tol: f64) -> (Point, Vec<Overlay>) {
         if let Some((q, k)) = self.points.iter().filter(|(q, _)| q.distance(p) <= tol).min_by(|a, b| a.0.distance(p).total_cmp(&b.0.distance(p))) {
             return (*q, vec![Overlay::Label { p: *q, text: k.label().into(), color: MAGENTA }]);
         }
+        if let Some(q) = self.on_segment(p, tol) {
+            return (q, vec![Overlay::Label { p: q, text: Kind::Edge.label().into(), color: MAGENTA }]);
+        }
         let mut out = p;
         let mut ov = vec![];
         if let Some((x, from, _)) =
@@ -142,6 +224,34 @@ impl Targets {
         (out, ov)
     }
 
+    /// The nearest point within `tol` of `p` on a target segment.
+    fn on_segment(&self, p: Point, tol: f64) -> Option<Point> {
+        self.segments
+            .iter()
+            .filter(|(b, _)| b.inflate(tol, tol).contains(p))
+            .map(|(_, c)| (c, c.nearest(p, 1e-6)))
+            .filter(|(_, n)| n.distance_sq <= tol * tol)
+            .min_by(|a, b| a.1.distance_sq.total_cmp(&b.1.distance_sq))
+            .map(|(c, n)| c.eval(n.t))
+    }
+
+    /// 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 +402,47 @@ 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![]);
+    PointSnap::new(cx, targets).snap(cx, p)
+}
+
+/// Snapping for a dragged point, its targets gathered once (when the drag begins): what
+/// [`snap_draw`] does for a point at a time.
+pub struct PointSnap {
+    /// The smart guide targets, or with Smart Guides off those of Snap to Point, and how near (in
+    /// screen pixels) they pull; none with pixels or the grid snapping instead, or nothing on.
+    targets: Option<(Targets, f64)>,
+}
+
+impl PointSnap {
+    pub fn new(cx: &ToolContext, targets: impl FnOnce() -> Targets) -> Self {
+        let targets = if cx.snap_to_pixel || cx.snap_to_grid {
+            None
+        } else if cx.smart_guides {
+            Some((targets(), 5.0))
+        } else if cx.snap_to_point {
+            Some((targets().for_snap_to_point(cx), cx.snap_tolerance))
+        } else {
+            None
+        };
+        Self { targets }
     }
-    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![]);
+
+    /// Where `p` goes, and the guides showing why.
+    pub fn snap(&self, cx: &ToolContext, p: Point) -> (Point, Vec<Overlay>) {
+        if cx.snap_to_pixel {
+            return (Point::new(p.x.round(), p.y.round()), vec![]);
+        }
+        if cx.snap_to_grid {
+            return (vectorcraft_geom::snap::snap_point_to_grid(p, cx.grid_step()), vec![]);
+        }
+        match &self.targets {
+            Some((t, tol)) => t.snap_point(p, cx.tol(*tol)),
+            None => (p, vec![]),
+        }
     }
-    if !cx.smart_guides {
-        return (p, vec![]);
-    }
-    targets().snap_point(p, cx.tol(5.0))
 }
 
 /// Where a dragged direction handle of anchor `ai` of subpath `si` of path `id` goes for the
@@ -334,7 +472,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);
@@ -410,4 +548,20 @@ mod tests {
         assert_eq!(nr, Rect::new(250.0, 100.0, 300.0, 102.0));
         assert!(ov.is_empty());
     }
+
+    /// Dragging an anchor of a path: its other anchors and the segments not touching it stay
+    /// targets, but neither it nor the path's bounds (which move) are.
+    #[test]
+    fn anchor_drag_targets_leave_out_what_moves() {
+        let (d, id) = doc_with_rect();
+        let mut s = Selection::default();
+        s.set([id]);
+        s.anchors.insert(id, [(0, 0)].into_iter().collect());
+        let t = Targets::for_anchor_drag(&d, &s);
+        let anchors: Vec<Point> = t.points.iter().filter(|(_, k)| *k == Kind::Anchor).map(|(p, _)| *p).collect();
+        assert_eq!(anchors, [Point::new(200.0, 100.0), Point::new(200.0, 200.0), Point::new(100.0, 200.0)]);
+        assert_eq!(t.segments.len(), 2);
+        assert!(!t.points.iter().any(|(p, k)| *k == Kind::Center && *p == Point::new(150.0, 150.0)), "the rect's centre moves");
+        assert_eq!(t.snap_point(Point::new(101.0, 99.0), 4.0).0, Point::new(100.0, 100.0), "in line with its neighbours, not on itself");
+    }
 }

crates/tools/src/lib.rs

@@ -20,9 +20,11 @@ pub mod guides;
 pub mod meshblend;
 pub mod meshedit;
 pub mod params;
+pub mod pathtype;
 pub mod pen;
 pub mod place;
 pub mod printtiling;
+pub mod rulerguide;
 pub mod select;
 pub mod settings;
 pub mod shape;
@@ -201,6 +203,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 +222,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 +266,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 +324,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 }
     }
 }
 
@@ -354,6 +410,29 @@ pub enum Cursor {
     BlendObject,
     /// The Blend tool over an anchor point (the blend starts there): a crosshair with a target.
     BlendAnchor,
+    /// Over a bracket of selected type on a path (a drag moves it): the arrow with a bracket.
+    PathBracket,
+}
+
+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.
@@ -493,6 +572,21 @@ pub(crate) mod testutil {
         (d, id)
     }
 
+    /// [`doc_with_rect`] plus type on a 300 pt path from (100, 300) to the right, from 20 % on.
+    pub fn doc_with_path_type() -> (Document, NodeId) {
+        let (mut d, _) = doc_with_rect();
+        let l = d.layers[0].id;
+        let id = d.alloc_id();
+        let mut t = vectorcraft_doc::TextObject::point(Point::ZERO, "Path type", Default::default());
+        let path = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
+            vectorcraft_geom::PathEl::MoveTo(Point::new(100.0, 300.0)),
+            vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
+        ]));
+        t.kind = vectorcraft_doc::TextKind::OnPath { path, start: 0.2, end: None };
+        d.insert(Some(l), 1, Node::new(id, vectorcraft_doc::NodeKind::Text(Box::new(t)))).unwrap();
+        (d, id)
+    }
+
     pub fn paint() -> PaintDefaults {
         PaintDefaults::default()
     }
@@ -506,6 +600,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 +619,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/pathtype.rs

@@ -0,0 +1,297 @@
+//! Type on a path's brackets: selected type on a path shows a start, a centre and an end bracket
+//! with the Selection and Direct Selection tools. Dragging the start or end bracket sets where the
+//! type begins or ends along its path; dragging the centre bracket slides the type along the path
+//! (its brackets with it) and, dragged across the path, flips the type to the other side
+//! (Cmd/Ctrl held: it only slides). Each drag is one undo step of `type.pathOptions`. The tools
+//! draw the brackets from the same geometry they hit-test.
+
+use serde_json::{Map, Value, json};
+use vectorcraft_doc::{NodeId, NodeKind, TextKind};
+use vectorcraft_geom::kurbo::{Line, ParamCurveNearest};
+use vectorcraft_geom::{Affine, ArcPath, Point, Vec2};
+
+use crate::{Action, Overlay, PointerEvent, ToolContext};
+
+/// How far a bracket reaches (screen px): up from the path on the type's side, down across it,
+/// and the foot of the start and end brackets along the path, into the type's span.
+const UP_PX: f64 = 14.0;
+const DOWN_PX: f64 = 4.0;
+const FOOT_PX: f64 = 4.0;
+/// How far past the path (screen px) the centre bracket goes before the type flips.
+const FLIP_PX: f64 = 6.0;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Bracket {
+    Start,
+    Centre,
+    End,
+}
+
+impl Bracket {
+    /// Hit-test order: the centre bracket first, then the start one (a closed path's span with
+    /// no end of its own has both ends at the start).
+    const ALL: [Bracket; 3] = [Bracket::Centre, Bracket::Start, Bracket::End];
+}
+
+/// The brackets of a selected type on a path.
+#[derive(Clone, Debug)]
+pub struct Brackets {
+    pub id: NodeId,
+    /// Text space → document.
+    xf: Affine,
+    /// The path in text space.
+    arc: ArcPath,
+    /// [`TextKind::path_span`].
+    span: (f64, f64),
+    /// The end bracket was placed (not the end of the path, or once round it).
+    end_set: bool,
+}
+
+impl Brackets {
+    /// The brackets of the selected type on a path the tools can edit (outside perspective).
+    pub fn of(cx: &ToolContext) -> Vec<Self> {
+        cx.selection.objects.iter().filter_map(|id| Self::of_node(cx, *id)).collect()
+    }
+
+    fn of_node(cx: &ToolContext, id: NodeId) -> Option<Self> {
+        let n = cx.doc.node(id).filter(|n| n.perspective.is_none() && cx.doc.is_editable(id))?;
+        let NodeKind::Text(t) = &n.kind else { return None };
+        let TextKind::OnPath { path, end, .. } = &t.kind else { return None };
+        let det = t.xf.determinant();
+        let arc = ArcPath::new(path);
+        if !det.is_finite() || det.abs() < 1e-12 || arc.is_empty() {
+            return None;
+        }
+        Some(Self { id, xf: t.xf, arc, span: t.kind.path_span()?, end_set: end.is_some() })
+    }
+
+    /// Where bracket `b` stands, as a fraction of the path's length (past 1 round a closed path).
+    fn at(&self, b: Bracket) -> f64 {
+        match b {
+            Bracket::Start => self.span.0,
+            Bracket::Centre => (self.span.0 + self.span.1) * 0.5,
+            Bracket::End => self.span.1,
+        }
+    }
+
+    /// The point at fraction `f` of the path, the path's direction there and the side the type
+    /// stands on, in document space.
+    fn frame(&self, f: f64) -> (Point, Vec2, Vec2) {
+        let (p, dir) = self.arc.at(f * self.arc.len());
+        let unit = |v: Vec2| {
+            let w = self.xf * v.to_point() - self.xf * Point::ZERO;
+            w / w.hypot().max(1e-12)
+        };
+        // Glyphs stand on the left of the path's direction (y down): their top faces (dir.y, -dir.x).
+        (self.xf * p, unit(dir), unit(Vec2::new(dir.y, -dir.x)))
+    }
+
+    /// The lines that draw bracket `b` at `zoom` (screen px per point).
+    fn lines(&self, b: Bracket, zoom: f64) -> Vec<(Point, Point)> {
+        let px = 1.0 / zoom.max(1e-9);
+        let (p, dir, up) = self.frame(self.at(b));
+        let top = p + up * UP_PX * px;
+        let stem = (p - up * DOWN_PX * px, top);
+        match b {
+            Bracket::Centre => vec![stem],
+            Bracket::Start => vec![stem, (top, top + dir * FOOT_PX * px)],
+            Bracket::End => vec![stem, (top, top - dir * FOOT_PX * px)],
+        }
+    }
+
+    /// The bracket within `tol` (document units) of `p`.
+    fn hit(&self, p: Point, zoom: f64, tol: f64) -> Option<Bracket> {
+        Bracket::ALL.into_iter().find(|b| self.lines(*b, zoom).iter().any(|(a, c)| Line::new(*a, *c).nearest(p, 1e-9).distance_sq <= tol * tol))
+    }
+
+    /// The fraction of the path's length nearest document point `p`.
+    fn fraction_at(&self, p: Point) -> Option<f64> {
+        self.arc.fraction_at(self.xf.inverse() * p)
+    }
+}
+
+/// The selected type on a path's bracket under `p`, if any.
+fn bracket_at(cx: &ToolContext, p: Point) -> Option<(Brackets, Bracket)> {
+    Brackets::of(cx).into_iter().find_map(|b| {
+        let which = b.hit(p, cx.zoom, cx.tol(5.0))?;
+        Some((b, which))
+    })
+}
+
+/// Is `p` over a bracket of the selected type on a path?
+pub fn over_bracket(cx: &ToolContext, p: Point) -> bool {
+    bracket_at(cx, p).is_some()
+}
+
+/// The brackets of the selected type on a path, in their layer's colour.
+pub fn overlays(cx: &ToolContext) -> Vec<Overlay> {
+    let mut out = vec![];
+    for b in Brackets::of(cx) {
+        let color = cx.doc.layer_color(b.id);
+        for which in Bracket::ALL {
+            out.extend(b.lines(which, cx.zoom).into_iter().map(|(a, b)| Overlay::Line { a, b, color, dashed: false }));
+        }
+    }
+    out
+}
+
+/// Dragging a bracket of type on a path.
+#[derive(Clone, Debug)]
+pub struct BracketDrag {
+    brackets: Brackets,
+    which: Bracket,
+    start: Point,
+    /// Where the press was along the path (a fraction of its length).
+    grab: f64,
+    began: bool,
+}
+
+impl BracketDrag {
+    /// Start a drag when the press `ev` is on a bracket of the selected type on a path.
+    pub fn hit(cx: &ToolContext, ev: &PointerEvent) -> Option<Self> {
+        let (brackets, which) = bracket_at(cx, ev.pos)?;
+        let grab = brackets.fraction_at(ev.pos)?;
+        Some(Self { brackets, which, start: ev.pos, grab, began: false })
+    }
+
+    pub fn drag(&mut self, cx: &ToolContext, p: Point, cmd: bool) -> Vec<Action> {
+        let mut out = vec![];
+        if !self.began {
+            if p.distance(self.start) < cx.tol(3.0) {
+                return out;
+            }
+            self.began = true;
+            out.push(Action::Begin("Move Type on a Path".into()));
+        }
+        let Some(u) = self.brackets.fraction_at(p) else { return out };
+        out.push(Action::Preview("type.pathOptions".into(), self.params(cx, p, u, cmd)));
+        out
+    }
+
+    /// `type.pathOptions` params for the pointer at `p`, `u` along the path.
+    fn params(&self, cx: &ToolContext, p: Point, u: f64, cmd: bool) -> Value {
+        let b = &self.brackets;
+        let closed = b.arc.is_closed();
+        let (s, e) = b.span;
+        let mut m = Map::new();
+        m.insert("ids".into(), json!([b.id.0]));
+        match self.which {
+            // Open paths keep the start before the end.
+            Bracket::Start => {
+                m.insert("start".into(), json!(if closed { u } else { u.min(e) }));
+            }
+            Bracket::End => {
+                m.insert("end".into(), json!(if closed { u } else { u.max(s) }));
+            }
+            Bracket::Centre => {
+                let mut d = u - self.grab;
+                if closed {
+                    // The short way round.
+                    d -= d.round();
+                }
+                let place = |x: f64| if closed { x.rem_euclid(1.0) } else { x.clamp(0.0, 1.0) };
+                let start = place(s + d);
+                m.insert("start".into(), json!(start));
+                if b.end_set {
+                    m.insert("end".into(), json!(if closed { place(e + d) } else { place(e + d).max(start) }));
+                }
+                // Across the path: the type flips to the other side.
+                let (q, _, up) = b.frame(u);
+                if !cmd && (p - q).dot(up) < -cx.tol(FLIP_PX) {
+                    m.insert("flip".into(), json!(true));
+                }
+            }
+        }
+        Value::Object(m)
+    }
+
+    pub fn finish(self) -> Vec<Action> {
+        if self.began { vec![Action::Commit] } else { vec![] }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::testutil::*;
+    use crate::{Mods, PointerKind};
+    use vectorcraft_doc::Selection;
+
+    fn selected(id: NodeId) -> Selection {
+        let mut s = Selection::default();
+        s.add(id);
+        s
+    }
+
+    fn preview(a: &[Action]) -> &Value {
+        let Some(Action::Preview(c, v)) = a.last() else { panic!("no preview: {a:?}") };
+        assert_eq!(c, "type.pathOptions");
+        v
+    }
+
+    fn drag(cx: &ToolContext, from: Point, to: Point, mods: Mods) -> Vec<Action> {
+        let mut d = BracketDrag::hit(cx, &PointerEvent::new(PointerKind::Down, from.x, from.y).with_mods(mods)).expect("a bracket");
+        let a = d.drag(cx, to, mods.cmd);
+        assert_eq!(a.first(), Some(&Action::Begin("Move Type on a Path".into())));
+        assert_eq!(d.finish(), vec![Action::Commit]);
+        a
+    }
+
+    #[test]
+    fn brackets_stand_at_the_start_the_middle_and_the_end_of_the_span() {
+        // A 300 pt path from (100, 300) with the type from 20 % on.
+        let (d, id) = doc_with_path_type();
+        let s = selected(id);
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let b = Brackets::of(&cx).pop().unwrap();
+        assert_eq!(b.hit(Point::new(160.0, 290.0), 1.0, 2.0), Some(Bracket::Start));
+        assert_eq!(b.hit(Point::new(280.0, 290.0), 1.0, 2.0), Some(Bracket::Centre));
+        assert_eq!(b.hit(Point::new(400.0, 290.0), 1.0, 2.0), Some(Bracket::End));
+        assert_eq!(b.hit(Point::new(220.0, 290.0), 1.0, 2.0), None);
+        // Drawn over the type's side of the path, with feet pointing into the span.
+        let o = overlays(&cx);
+        assert_eq!(o.len(), 5);
+        assert!(o.contains(&Overlay::Line { a: Point::new(160.0, 286.0), b: Point::new(164.0, 286.0), color: d.layer_color(id), dashed: false }));
+        // Nothing for unselected or other type.
+        assert!(Brackets::of(&crate::testutil::cx(&d, &Selection::default(), &p)).is_empty());
+        let (d2, area) = doc_with_area_type();
+        let s2 = selected(area);
+        assert!(Brackets::of(&crate::testutil::cx(&d2, &s2, &p)).is_empty());
+    }
+
+    #[test]
+    fn dragging_the_centre_bracket_slides_the_type_and_across_the_path_flips_it() {
+        let (d, id) = doc_with_path_type();
+        let s = selected(id);
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let grab = Point::new(280.0, 295.0);
+        // 60 pt along: 20 % further, the end (the end of the path) left alone.
+        let v = preview(&drag(&cx, grab, Point::new(340.0, 295.0), Mods::default())).clone();
+        assert!((v["start"].as_f64().unwrap() - 0.4).abs() < 1e-6, "{v}");
+        assert!(v.get("end").is_none() && v.get("flip").is_none(), "{v}");
+        assert_eq!(v["ids"], json!([id.0]));
+        // Below the path: flipped as well.
+        let v = preview(&drag(&cx, grab, Point::new(250.0, 320.0), Mods::default())).clone();
+        assert!((v["start"].as_f64().unwrap() - 0.1).abs() < 1e-6 && v["flip"] == true, "{v}");
+        // Cmd/Ctrl held: it only slides.
+        let v = preview(&drag(&cx, grab, Point::new(250.0, 320.0), Mods { cmd: true, ..Mods::default() })).clone();
+        assert!(v.get("flip").is_none(), "{v}");
+    }
+
+    #[test]
+    fn dragging_the_start_and_end_brackets_moves_them() {
+        let (d, id) = doc_with_path_type();
+        let s = selected(id);
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let v = preview(&drag(&cx, Point::new(160.0, 295.0), Point::new(130.0, 280.0), Mods::default())).clone();
+        assert!((v["start"].as_f64().unwrap() - 0.1).abs() < 1e-6 && v.get("end").is_none(), "{v}");
+        let v = preview(&drag(&cx, Point::new(400.0, 295.0), Point::new(340.0, 310.0), Mods::default())).clone();
+        assert!((v["end"].as_f64().unwrap() - 0.8).abs() < 1e-6 && v.get("start").is_none(), "{v}");
+        // The end stops at the start.
+        let v = preview(&drag(&cx, Point::new(400.0, 295.0), Point::new(110.0, 300.0), Mods::default())).clone();
+        assert!((v["end"].as_f64().unwrap() - 0.2).abs() < 1e-6, "{v}");
+    }
+}

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,18 +1,25 @@
-//! 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 (Alt-click cycles their kind,
-//! double-click opens the Corners dialog), double-click to enter isolation mode.
+//! 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`]), drag the brackets of type on a path
+//! ([`crate::pathtype`]).
 //! 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 vectorcraft_geom::{Affine, Point, Rect, Vec2};
 
 use crate::bbox::{Handle, hit_handle, in_rotate_zone, move_delta, rotate_for_drag, scale_for_drag};
 use crate::corners::{self, CornerDrag, over_widget};
+use crate::guides::Targets;
+use crate::pathtype::{self, BracketDrag, over_bracket};
+use crate::rulerguide::GuideEdit;
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, json_ids};
 
 #[derive(Clone, Debug, Default)]
@@ -44,6 +51,8 @@ enum State {
     },
     /// Dragging a Live Corners widget.
     Corner(CornerDrag),
+    /// Dragging a bracket of type on a path.
+    Bracket(BracketDrag),
 }
 
 #[derive(Default)]
@@ -51,8 +60,52 @@ pub struct SelectionTool {
     state: State,
     measure: Option<(Point, String)>,
     guides: Vec<Overlay>,
-    targets: Option<crate::guides::Targets>,
-    start_bounds: Option<Rect>,
+    /// What a bounding-box handle being dragged snaps to.
+    targets: Option<Targets>,
+    moving: Option<MoveSnap>,
+    guide: GuideEdit,
+}
+
+/// Snapping for the selection moved as a whole, its targets gathered when the move begins: Smart
+/// Guides line its bounds up with the other art; with them off, View → Snap to Point lands the
+/// point it was grabbed by on an anchor or a ruler guide; Snap to Pixel puts its top-left on whole
+/// pixels.
+pub(crate) struct MoveSnap {
+    bounds: Option<Rect>,
+    targets: Option<Targets>,
+    points: Option<Targets>,
+}
+
+impl MoveSnap {
+    pub(crate) fn new(cx: &ToolContext) -> Self {
+        Self {
+            bounds: selection_bounds(cx),
+            targets: cx.smart_guides.then(|| Targets::collect(cx.doc, &cx.selection.objects, None)),
+            points: Targets::snap_to_point(cx, &cx.selection.objects),
+        }
+    }
+
+    /// The move by `d` of the selection grabbed at `start`, snapped, and its guides.
+    pub(crate) fn snap(&self, cx: &ToolContext, start: Point, mut d: Vec2) -> (Vec2, Vec<Overlay>) {
+        let mut guides = vec![];
+        if let Some(t) = &self.points {
+            let (q, ov) = t.snap_point(start + d, cx.tol(cx.snap_tolerance));
+            d = q - start;
+            guides = ov;
+        }
+        if let (Some(t), Some(b)) = (&self.targets, self.bounds) {
+            let (adj, ov) = t.snap_rect(b + d, cx.tol(5.0));
+            d += adj;
+            guides = ov;
+        }
+        if cx.snap_to_pixel
+            && let Some(b) = self.bounds
+        {
+            d = Vec2::new((b.x0 + d.x).round() - b.x0, (b.y0 + d.y).round() - b.y0);
+            guides.clear();
+        }
+        (d, guides)
+    }
 }
 
 pub fn matrix_json(a: Affine) -> Value {
@@ -100,10 +153,13 @@ 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()) {
@@ -112,9 +168,12 @@ impl Tool for SelectionTool {
                 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(_))) {
@@ -126,11 +185,16 @@ impl Tool for SelectionTool {
                 vec![]
             }
             (PointerKind::Down, _) => {
-                // 1. Live Corners widgets, then the bounding-box handles of the current selection.
+                // 1. Live Corners widgets and type on a path's brackets, then the bounding-box
+                // handles of the current selection.
                 if let Some(c) = CornerDrag::hit(cx, ev) {
                     self.state = State::Corner(c);
                     return vec![];
                 }
+                if let Some(b) = BracketDrag::hit(cx, ev) {
+                    self.state = State::Bracket(b);
+                    return vec![];
+                }
                 if cx.show_bbox
                     && let Some(bx) = selection_box(cx)
                 {
@@ -141,7 +205,7 @@ impl Tool for SelectionTool {
                             // Only area type: the step resizes type areas; anything else scales.
                             let label = if areas && cx.selection.objects.iter().all(is_area) { "Resize Type Area" } else { "Scale" };
                             // Smart Guides align what the handle moves with the other objects.
-                            self.targets = cx.smart_guides.then(|| crate::guides::Targets::collect(cx.doc, &cx.selection.objects, None));
+                            self.targets = cx.smart_guides.then(|| Targets::collect(cx.doc, &cx.selection.objects, None));
                             self.state = State::Scaling { handle, bx, areas };
                             return vec![Action::Begin(label.into())];
                         }
@@ -152,7 +216,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);
@@ -185,24 +261,11 @@ impl Tool for SelectionTool {
                         return out;
                     }
                     out.push(Action::Begin(if m.alt { "Copy".into() } else { "Move".into() }));
+                    self.moving = Some(MoveSnap::new(cx));
                 }
                 let mut d = move_delta(start, p, m.shift);
-                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.guides.clear();
-                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;
-                    self.guides = ov;
-                }
-                // Snap to Pixel: the moved selection's top-left lands on whole pixels.
-                if cx.snap_to_pixel
-                    && let Some(b) = self.start_bounds
-                {
-                    d = vectorcraft_geom::Vec2::new((b.x0 + d.x).round() - b.x0, (b.y0 + d.y).round() - b.y0);
-                    self.guides.clear();
+                if let Some(snap) = &self.moving {
+                    (d, self.guides) = snap.snap(cx, start, d);
                 }
                 self.state = State::Moving { start, began: true, deselect: None };
                 self.measure = Some((p, cx.offset_label(d.x, d.y)));
@@ -242,11 +305,20 @@ impl Tool for SelectionTool {
                 self.state = State::Idle;
                 c.finish()
             }
+            (PointerKind::Drag, State::Bracket(mut b)) => {
+                let out = b.drag(cx, p, m.cmd);
+                self.state = State::Bracket(b);
+                out
+            }
+            (PointerKind::Up, State::Bracket(b)) => {
+                self.state = State::Idle;
+                b.finish()
+            }
             (PointerKind::Up, State::Moving { began, deselect, .. }) => {
                 self.state = State::Idle;
                 self.measure = None;
                 self.guides.clear();
-                self.targets = None;
+                self.moving = None;
                 match (began, deselect) {
                     (true, _) => vec![Action::Commit],
                     (false, Some(id)) => vec![Action::Exec("select.toggle".into(), json!({ "id": id.0 }))],
@@ -278,13 +350,14 @@ impl Tool for SelectionTool {
     }
 
     fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
-        let mut o = vec![];
+        let mut o = pathtype::overlays(cx);
         match &self.state {
             State::Marquee { start, cur, .. } => o.push(Overlay::Marquee(Rect::from_points(*start, *cur))),
             State::Corner(c) => o.extend(c.overlays(cx)),
             _ => {}
         }
         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() });
         }
@@ -297,11 +370,18 @@ impl Tool for SelectionTool {
             State::Scaling { handle, bx, .. } => return handle_cursor(handle, bx.angle),
             State::Moving { began: true, .. } => return Cursor::Arrow,
             State::Corner(_) => return Cursor::CornerRadius,
+            State::Bracket(_) => return Cursor::PathBracket,
             _ => {}
         }
+        if self.guide.busy() {
+            return self.guide.cursor(cx, p).unwrap_or_default();
+        }
         if over_widget(cx, p) {
             return Cursor::CornerRadius;
         }
+        if over_bracket(cx, p) {
+            return Cursor::PathBracket;
+        }
         if cx.show_bbox
             && let Some(bx) = selection_box(cx)
         {
@@ -311,6 +391,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;
@@ -321,6 +404,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 {
@@ -362,6 +453,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);
@@ -391,7 +401,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
 fn cursor_icon(c: Cursor) -> egui::CursorIcon {
     use egui::CursorIcon as C;
     match c {
-        Cursor::Arrow | Cursor::ArrowHollow | Cursor::CornerRadius => C::Default,
+        Cursor::Arrow | Cursor::ArrowHollow | Cursor::CornerRadius | Cursor::PathBracket => C::Default,
         Cursor::Move => C::Move,
         Cursor::Crosshair => C::Crosshair,
         Cursor::ResizeH => C::ResizeHorizontal,
@@ -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());
@@ -861,10 +972,11 @@ fn node_outline(n: &Node) -> BezPath {
     let mut bp = BezPath::new();
     walk_drawn(n, &mut |c| match &c.kind {
         NodeKind::Path { path, .. } => bp.extend(path.to_bezpath()),
-        // Area type shows its frame: the type area Direct Selection reshapes.
-        NodeKind::Text(t) if c.perspective.is_none() && matches!(t.kind, vectorcraft_doc::TextKind::Area { .. }) => {
-            if let Some(frame) = t.area_frame() {
-                bp.extend(frame.to_bezpath());
+        // Area type shows its frame: the type area Direct Selection reshapes; type on a path its
+        // path, which the selection tools' brackets sit on.
+        NodeKind::Text(t) if c.perspective.is_none() && !matches!(t.kind, vectorcraft_doc::TextKind::Point) => {
+            if let Some(path) = t.area_frame().or_else(|| t.type_path()) {
+                bp.extend(path.to_bezpath());
             }
         }
         NodeKind::Text(_) | NodeKind::Image(_) | NodeKind::SymbolInstance { .. } => {
@@ -895,9 +1007,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 +1119,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 +1233,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 +1303,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 +1321,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,32 +1333,22 @@ 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).
+        // Point type: baseline marker (area type shows its frame instead, which may not be a
+        // rectangle, and type on a path its path).
         if let NodeKind::Text(tx) = &n.kind
-            && !matches!(tx.kind, vectorcraft_doc::TextKind::Area { .. })
+            && matches!(tx.kind, vectorcraft_doc::TextKind::Point)
         {
             let o = xf.to_screen(tx.xf * Point::ZERO);
             let b = n.geometric_bounds().unwrap_or_default();
@@ -1219,6 +1357,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,13 +1374,14 @@ 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.visible().map(|q| xf.to_screen(q)) {
@@ -1251,7 +1396,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 +1431,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 +1461,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 +1735,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 +1841,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 +2358,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/chrome.rs

@@ -217,7 +217,7 @@ pub fn control_bar(app: &mut VectorcraftApp, ui: &mut Ui) {
                         if k == "height" {
                             crate::panels::transform::constrain_link(app, ui);
                         }
-                        ui.label(egui::RichText::new(tl!(lbl)).size(12.0).color(t.text_dim));
+                        widgets::field_label(ui, egui::RichText::new(tl!(lbl)).size(12.0).color(t.text_dim));
                         if let Some(nv) = widgets::num_field(ui, ("cb", k), Some(v), units, 80.0) {
                             app.run("object.setBounds", json!({k: nv, "reference": 4, "proportional": link})).ok();
                         }

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/cursors.rs

@@ -111,6 +111,21 @@ fn corner_radius(p: &Painter, o: Pos2) {
     p.add(Shape::line(pts, Stroke::new(1.2, INK)));
 }
 
+/// Over a bracket of type on a path: the arrow with a bracket (a stem standing on a baseline,
+/// with a foot) below right.
+fn path_bracket(p: &Painter, o: Pos2) {
+    arrow(p, o, false);
+    let b = o + vec2(13.0, 13.0);
+    let stem = [b + vec2(3.0, 0.0), b + vec2(3.0, 10.0)];
+    let foot = [b + vec2(3.0, 0.0), b + vec2(7.0, 0.0)];
+    let base = [b + vec2(0.0, 8.0), b + vec2(10.0, 8.0)];
+    for (w, c) in [(3.0, HALO), (1.2, INK)] {
+        for l in [stem, foot, base] {
+            p.line_segment(l, Stroke::new(w, c));
+        }
+    }
+}
+
 /// The gradient annotator's stop cursors: the arrow with a plus (add a stop) or minus (delete it)
 /// badge.
 fn stop_badge(p: &Painter, o: Pos2, add: bool) {
@@ -221,6 +236,7 @@ pub fn paint(painter: &Painter, c: Cursor, p: Pos2) -> bool {
         Cursor::WidthAdd => width(painter, p, "+"),
         Cursor::WidthPoint => width(painter, p, "point"),
         Cursor::Blend | Cursor::BlendObject | Cursor::BlendAnchor => blend(painter, p, c),
+        Cursor::PathBracket => path_bracket(painter, p),
         _ => return false,
     }
     let _ = pos2;

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

@@ -13,35 +13,64 @@ pub(super) fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
         .collapsible(false)
         .resizable(false)
         .open(&mut open)
-        .anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
+        .pivot(egui::Align2::CENTER_CENTER)
+        .default_pos(ctx.content_rect().center())
         .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/command.rs

@@ -10,8 +10,9 @@ use crate::state::Dialog;
 pub(super) const SPEC: DialogSpec = DialogSpec {
     heading: |d| tl!(&d.str("__label")).to_string(),
     body: |app, ui, d| {
-        let lengths = lengths(&d.str("__command"));
-        form::param_fields(ui, d, &|k| lengths.contains(&k), app.session.general_unit());
+        let command = d.str("__command");
+        let lengths = lengths(&command);
+        form::param_fields(ui, d, &|k| lengths.contains(&k), &|k| choices(&command, k), app.session.general_unit());
         false
     },
     confirm,
@@ -27,10 +28,23 @@ fn lengths(command: &str) -> &'static [&'static str] {
         "perspective.grid.set" => &["cell", "distance"],
         "object.repeat.options" => &["radius", "hSpacing", "vSpacing"],
         "text.areaOptions" => &["width", "height", "gutter", "inset", "firstBaselineMin"],
+        "type.pathOptions" => &["spacing"],
         _ => &[],
     }
 }
 
+/// The parameters of the commands this dialog edits that pick one of some values.
+fn choices(command: &str, key: &str) -> Option<form::Choices> {
+    match (command, key) {
+        ("type.pathOptions", "effect") => Some(crate::menus::PATH_EFFECTS),
+        ("type.pathOptions", "alignToPath") => Some(PATH_ALIGN),
+        _ => None,
+    }
+}
+
+/// Type on a Path Options › Align to Path.
+const PATH_ALIGN: form::Choices = &[("Ascender", "ascender"), ("Descender", "descender"), ("Center", "center"), ("Baseline", "baseline")];
+
 /// Closes before running, so a dialog the command opens stays open.
 fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
     let cmd = d.str("__command");

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

@@ -180,7 +180,7 @@ fn typography(ui: &mut egui::Ui, d: &mut Dialog) {
         }
         ui.end_row();
         for (key, label) in [("superscript", tl!("Superscript:")), ("subscript", tl!("Subscript:"))] {
-            ui.label(egui::RichText::new(label).color(t.text));
+            widgets::field_label(ui, egui::RichText::new(label).color(t.text));
             for part in ["size", "position"] {
                 let v = d.fields.get(key).and_then(|m| m.get(part)).and_then(Value::as_f64).unwrap_or(0.0);
                 if let Some(n) = widgets::plain_field(ui, (key, part), v, "%", 1, 70.0) {
@@ -191,7 +191,7 @@ fn typography(ui: &mut egui::Ui, d: &mut Dialog) {
             }
             ui.end_row();
         }
-        ui.label(egui::RichText::new(tl!("Small Caps:")).color(t.text));
+        widgets::field_label(ui, egui::RichText::new(tl!("Small Caps:")).color(t.text));
         if let Some(n) = widgets::plain_field(ui, "smallCaps", d.f64("smallCapsSize", 70.0), "%", 1, 70.0) {
             d.fields.insert("smallCapsSize".into(), json!(n));
         }

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

@@ -131,7 +131,7 @@ fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
     let changed = match vectorcraft_plugins::effect::installed(&id) {
         Some(plugin) => form::schema_fields(ui, d, &plugin.manifest().params),
         None if vectorcraft_effects::is_adjustment(&id) => adjust_fields(ui, d),
-        None => form::param_fields(ui, d, &|k| vectorcraft_effects::is_length(&id, k, relative), app.session.general_unit()),
+        None => form::param_fields(ui, d, &|k| vectorcraft_effects::is_length(&id, k, relative), &|_| None, app.session.general_unit()),
     };
     ui.add_space(6.0);
     let mut pv = d.bool("preview");

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

@@ -17,16 +17,20 @@ pub(super) fn field(ui: &mut egui::Ui, d: &mut Dialog, key: &str, label: &str) {
 
 /// [`field`] `width` points wide.
 pub(super) fn field_w(ui: &mut egui::Ui, d: &mut Dialog, key: &str, label: &str, width: f32) {
-    let t = Tokens::get(ui.ctx());
-    ui.label(egui::RichText::new(tl!(label)).color(t.text_dim));
+    row_label(ui, label);
     text(ui, d, key, width);
     ui.end_row();
 }
 
-/// A labelled [`length`] field (one grid row).
-pub(super) fn length_field(ui: &mut egui::Ui, d: &mut Dialog, key: &str, label: &str, unit: Unit) {
+/// The label cell of a grid row.
+fn row_label(ui: &mut egui::Ui, label: &str) {
     let t = Tokens::get(ui.ctx());
     ui.label(egui::RichText::new(tl!(label)).color(t.text_dim));
+}
+
+/// A labelled [`length`] field (one grid row).
+pub(super) fn length_field(ui: &mut egui::Ui, d: &mut Dialog, key: &str, label: &str, unit: Unit) {
+    row_label(ui, label);
     length(ui, d, key, unit, FIELD_W);
     ui.end_row();
 }
@@ -57,6 +61,30 @@ fn lengths(kind: &str) -> &'static [&'static str] {
     }
 }
 
+/// The fields of the form dialogs ([`grid`]) that come first, in this order (the others follow by
+/// name).
+fn order(kind: &str) -> &'static [&'static str] {
+    match kind {
+        "offsetPath" => &["offset", "joins", "miterLimit"],
+        "splitIntoGrid" => &["rows", "columns", "gutter"],
+        _ => &[],
+    }
+}
+
+/// The choices of a form dialog's ([`grid`]) dropdown field, as (value, label in the UI
+/// language); empty for a field typed as text.
+fn choices(kind: &str, key: &str) -> Vec<(&'static str, &'static str)> {
+    // The axes in the "axis" context: some languages read the plain Horizontal and Vertical as
+    // type orientations.
+    let axis = |value, label| (value, crate::i18n::tr_ctx(crate::i18n::current(), "axis", label));
+    match (kind, key) {
+        ("offsetPath", "joins") => vec![("miter", tl!("Miter")), ("round", tl!("Round")), ("bevel", tl!("Bevel"))],
+        ("average", "axis") => vec![axis("horizontal", "Horizontal"), axis("vertical", "Vertical"), axis("both", "Both")],
+        ("reflect" | "shear", "axis") => vec![axis("horizontal", "Horizontal"), axis("vertical", "Vertical")],
+        _ => vec![],
+    }
+}
+
 /// A text field `width` wide bound to `d.fields[key]`. Returns true when it changed.
 pub(super) fn text(ui: &mut egui::Ui, d: &mut Dialog, key: &str, width: f32) -> bool {
     text_edit(ui, d, key, width).changed()
@@ -111,30 +139,49 @@ pub(super) fn check(ui: &mut egui::Ui, d: &mut Dialog, key: &str, label: &str) {
 /// A dropdown row bound to the string `d.fields[key]`: `label` in a column `widths.0` wide, the
 /// dropdown `widths.1` wide; `options` are (value, label).
 pub(super) fn choice(ui: &mut egui::Ui, d: &mut Dialog, key: &str, label: &str, widths: (f32, f32), options: &[(&str, &str)]) {
+    crate::widgets::label_row(ui, label, widths.0, |ui| dropdown(ui, d, key, widths.1, options, false));
+}
+
+/// A dropdown `width` wide bound to the string `d.fields[key]`; `options` are (value, label), the
+/// labels shown as they are when `translated` (else the dropdown translates them). A value that
+/// isn't among them shows as it is.
+fn dropdown(ui: &mut egui::Ui, d: &mut Dialog, key: &str, width: f32, options: &[(&str, &str)], translated: bool) {
     let cur = d.str(key);
     let shown = options.iter().find(|(v, _)| v.eq_ignore_ascii_case(&cur)).map_or(cur.as_str(), |(_, l)| l);
     let labels: Vec<&str> = options.iter().map(|(_, l)| *l).collect();
-    crate::widgets::label_row(ui, label, widths.0, |ui| {
-        if let Some((value, _)) = crate::widgets::dropdown(ui, key, shown, &labels, widths.1).and_then(|i| options.get(i)) {
-            d.fields.insert(key.into(), json!(value));
-        }
-    });
+    let chosen = if translated {
+        crate::widgets::dropdown_names(ui, key, shown, &labels, width)
+    } else {
+        crate::widgets::dropdown(ui, key, shown, &labels, width)
+    };
+    if let Some((value, _)) = chosen.and_then(|i| options.get(i)) {
+        d.fields.insert(key.into(), json!(value));
+    }
 }
 
-/// The generic dialog body: a field per non-boolean value (positions and indices hidden), the
-/// distances in `unit`.
+/// The generic dialog body: a field per non-boolean value (positions, indices and UI-only keys
+/// hidden) in the kind's [`order`], the distances in `unit`, the [`choices`] as dropdowns.
 pub(super) fn grid(ui: &mut egui::Ui, d: &mut Dialog, unit: Unit) {
-    let lengths = lengths(&d.kind);
+    let (lengths, first) = (lengths(&d.kind), order(&d.kind));
+    let mut keys: Vec<String> = d
+        .fields
+        .iter()
+        .filter(|(k, v)| !matches!(k.as_str(), "x" | "y" | "origin" | "index") && !k.starts_with("__") && !v.is_boolean())
+        .map(|(k, _)| k.clone())
+        .collect();
+    // Stable: the fields `order` doesn't name keep their order after the ones it does.
+    keys.sort_by_key(|k| first.iter().position(|f| f == k).unwrap_or(first.len()));
     egui::Grid::new("dlg").num_columns(2).spacing([10.0, 8.0]).show(ui, |ui| {
-        let keys: Vec<(String, Value)> = d.fields.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
-        for (k, v) in keys {
-            if k == "x" || k == "y" || k == "origin" || k == "index" || v.is_boolean() {
-                continue;
-            }
+        for k in keys {
+            let options = choices(&d.kind, &k);
             if lengths.contains(&k.as_str()) {
                 length_field(ui, d, &k, &humanized(&k), unit);
-            } else {
+            } else if options.is_empty() {
                 field(ui, d, &k, &humanized(&k));
+            } else {
+                row_label(ui, &humanized(&k));
+                dropdown(ui, d, &k, FIELD_W, &options, true);
+                ui.end_row();
             }
         }
     });
@@ -145,10 +192,19 @@ pub(super) fn params(d: &Dialog) -> Value {
     Value::Object(d.fields.iter().filter(|(k, _)| !k.starts_with("__") && k.as_str() != "preview").map(|(k, v)| (k.clone(), v.clone())).collect())
 }
 
+/// The (label, value) choices of a parameter that picks one of some values.
+pub(super) type Choices = &'static [(&'static str, &'static str)];
+
 /// Generic editor for command/effect parameters: numbers, booleans, strings and colours; the
-/// parameters `is_length` names are distances shown and typed in `unit`. Returns true when a
-/// value changed.
-pub(super) fn param_fields(ui: &mut egui::Ui, d: &mut Dialog, is_length: &dyn Fn(&str) -> bool, unit: Unit) -> bool {
+/// parameters `is_length` names are distances shown and typed in `unit`, those `choices` gives
+/// choices for are dropdowns. Returns true when a value changed.
+pub(super) fn param_fields(
+    ui: &mut egui::Ui,
+    d: &mut Dialog,
+    is_length: &dyn Fn(&str) -> bool,
+    choices: &dyn Fn(&str) -> Option<Choices>,
+    unit: Unit,
+) -> bool {
     let t = Tokens::get(ui.ctx());
     let mut changed = false;
     egui::Grid::new("fxgrid").num_columns(2).spacing([12.0, 8.0]).show(ui, |ui| {
@@ -169,6 +225,17 @@ pub(super) fn param_fields(ui: &mut egui::Ui, d: &mut Dialog, is_length: &dyn Fn
                 ui.end_row();
                 continue;
             }
+            if let Some(options) = choices(&k) {
+                let cur = v.as_str().unwrap_or_default();
+                let label = options.iter().find(|(_, value)| *value == cur).map_or(cur, |(l, _)| *l);
+                let labels: Vec<&str> = options.iter().map(|(l, _)| *l).collect();
+                if let Some((_, value)) = crate::widgets::dropdown(ui, ("fx-choice", &k), label, &labels, 140.0).and_then(|i| options.get(i)) {
+                    d.fields.insert(k, json!(value));
+                    changed = true;
+                }
+                ui.end_row();
+                continue;
+            }
             match v {
                 Value::Number(n) => {
                     let mut x = n.as_f64().unwrap_or(0.0);
@@ -271,6 +338,7 @@ pub(super) fn humanize(k: &str) -> String {
         "Radius1" => "Radius 1".into(),
         "Radius2" => "Radius 2".into(),
         "Include Cmy Blacks" => "Include Blacks with CMY:".into(),
+        "Align To Path" => "Align to Path:".into(),
         _ => format!("{s}:"),
     }
 }

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

@@ -40,6 +40,7 @@ pub mod layer_options;
 pub mod layers_panel_options;
 pub mod liquify;
 pub mod missing_links;
+pub(crate) mod modal;
 pub mod new_color_group;
 mod new_document;
 pub mod new_swatch;
@@ -99,7 +100,6 @@ pub use save_pdf::{open as open_save_pdf, open_preset as open_pdf_preset};
 pub use tools::open_tool_dialog;
 
 use crate::state::Dialog;
-use crate::theme::{self, Tokens};
 use crate::{VectorcraftApp, widgets};
 
 type DialogResult = Result<Value, String>;
@@ -342,62 +342,48 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
     if let Some(window) = spec.window {
         return window(app, ctx);
     }
-    let t = Tokens::get(ctx);
     let mut ok = false;
     let mut cancel = false;
     let mut discard = false;
-    egui::Area::new(egui::Id::new("modal-dim")).order(egui::Order::Middle).fixed_pos(egui::pos2(0.0, 0.0)).show(ctx, |ui| {
-        // Modal, but the canvas isn't dimmed so previews stay readable (as in the reference app).
-        ui.allocate_rect(ctx.content_rect(), egui::Sense::click());
-    });
     let heading = (spec.heading)(&d);
-    egui::Window::new(heading.as_str())
-        // One window per kind, so a dialog never inherits another dialog's size.
-        .id(egui::Id::new(("dialog", d.kind.as_str())))
-        .order(egui::Order::Foreground)
-        .collapsible(false)
-        .resizable(false)
-        .title_bar(false)
-        .anchor(egui::Align2::CENTER_CENTER, [0.0, -40.0])
-        .frame(egui::Frame::window(&ctx.global_style()).fill(t.panel).inner_margin(egui::Margin::same(MARGIN)))
-        .show(ctx, |ui| {
-            // Never wider than the window (a large UI scale in a small window): the text wraps.
-            let room = (ctx.content_rect().width() - 2.0 * (f32::from(MARGIN) + EDGE_GAP)).max(EDGE_GAP);
-            ui.set_min_width(spec.min_width.min(room));
-            ui.set_max_width(spec.max_width.map_or(room, |w| w.min(room)));
-            ui.label(egui::RichText::new(heading.as_str()).font(theme::semibold(16.0)).color(t.text));
-            ui.add_space(12.0);
-            // Just opened: its first field takes the keyboard focus, as in the reference app (type a
-            // value, press Enter). Only the body's fields can take it.
-            if focus_first {
-                ui.data_mut(|m| m.insert_temp(widgets::dialog_focus_flag(), true));
+    modal::show(ctx, &heading, egui::Id::new(("dialog", d.kind.as_str())), -40.0, MARGIN, |ui| {
+        // Never wider than the window (a large UI scale in a small window): the text wraps.
+        let room = (ctx.content_rect().width() - 2.0 * (f32::from(MARGIN) + EDGE_GAP)).max(EDGE_GAP);
+        ui.set_min_width(spec.min_width.min(room));
+        ui.set_max_width(spec.max_width.map_or(room, |w| w.min(room)));
+        modal::heading(ui, &heading);
+        ui.add_space(12.0);
+        // Just opened: its first field takes the keyboard focus, as in the reference app (type a
+        // value, press Enter). Only the body's fields can take it.
+        if focus_first {
+            ui.data_mut(|m| m.insert_temp(widgets::dialog_focus_flag(), true));
+        }
+        cancel = (spec.body)(app, ui, &mut d);
+        // Taken (the flag is gone): done. Still there (the window's measuring frame): next frame.
+        if focus_first && ui.data_mut(|m| m.remove_temp::<bool>(widgets::dialog_focus_flag())).is_none() {
+            ui.data_mut(|m| m.remove::<bool>(focus_id));
+        }
+        ui.add_space(16.0);
+        // The button row is as wide as the fields above it and as tall as the buttons: a
+        // right-to-left layout would otherwise take all the room left in the window, so the
+        // window could never shrink to its content.
+        let row = egui::vec2(ui.min_rect().width(), ui.spacing().interact_size.y);
+        ui.allocate_ui_with_layout(row, egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if let Some(label) = spec.ok.map(|ok| spec.ok_label.map_or(ok, |f| f(app)))
+                && widgets::primary_button(ui, label).clicked()
+            {
+                ok = true;
             }
-            cancel = (spec.body)(app, ui, &mut d);
-            // Taken (the flag is gone): done. Still there (the window's measuring frame): next frame.
-            if focus_first && ui.data_mut(|m| m.remove_temp::<bool>(widgets::dialog_focus_flag())).is_none() {
-                ui.data_mut(|m| m.remove::<bool>(focus_id));
+            ui.add_space(8.0);
+            if widgets::secondary_button(ui, if spec.ok.is_some() { "Cancel" } else { "Close" }).clicked() {
+                cancel = true;
+            }
+            if let Some(label) = spec.discard {
+                ui.add_space(28.0);
+                discard = widgets::secondary_button(ui, label).clicked();
             }
-            ui.add_space(16.0);
-            // The button row is as wide as the fields above it and as tall as the buttons: a
-            // right-to-left layout would otherwise take all the room left in the window, so the
-            // window could never shrink to its content.
-            let row = egui::vec2(ui.min_rect().width(), ui.spacing().interact_size.y);
-            ui.allocate_ui_with_layout(row, egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                if let Some(label) = spec.ok.map(|ok| spec.ok_label.map_or(ok, |f| f(app)))
-                    && widgets::primary_button(ui, label).clicked()
-                {
-                    ok = true;
-                }
-                ui.add_space(8.0);
-                if widgets::secondary_button(ui, if spec.ok.is_some() { "Cancel" } else { "Close" }).clicked() {
-                    cancel = true;
-                }
-                if let Some(label) = spec.discard {
-                    ui.add_space(28.0);
-                    discard = widgets::secondary_button(ui, label).clicked();
-                }
-            });
         });
+    });
     if spec.ok.is_some() && ctx.input(|i| i.key_pressed(egui::Key::Enter)) {
         ok = true;
     }
@@ -482,3 +468,6 @@ mod tests_scale;
 
 #[cfg(test)]
 mod tests_perspective;
+
+#[cfg(test)]
+mod tests_modal;

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

@@ -0,0 +1,100 @@
+//! The modal dialog window: a backdrop that keeps the rest of the app from taking clicks, and a
+//! window with no title bar that opens centred and moves by dragging its heading (the band from its
+//! top edge down to the heading), as a title bar would. Where it was moved to stays, per window, for
+//! the session, and the window never leaves the screen.
+
+use egui::{Id, Rect, Vec2};
+
+use crate::theme::{self, Tokens};
+
+/// Show the modal dialog window `id` (`title` is its accessible name), `nudge` points below the
+/// screen's centre until it is moved, with `margin` inside its frame. `add` draws the contents and
+/// should start with [`heading`] (or [`drag_band`]) so the window can be moved.
+pub(crate) fn show<R>(ctx: &egui::Context, title: &str, id: Id, nudge: f32, margin: i8, add: impl FnOnce(&mut egui::Ui) -> R) -> Option<R> {
+    let t = Tokens::get(ctx);
+    egui::Area::new(Id::new("modal-dim")).order(egui::Order::Middle).fixed_pos(egui::Pos2::ZERO).show(ctx, |ui| {
+        // Modal, but the canvas isn't dimmed so previews stay readable (as in the reference app).
+        ui.allocate_rect(ctx.content_rect(), egui::Sense::click());
+    });
+    egui::Window::new(title)
+        .id(id)
+        .order(egui::Order::Foreground)
+        .collapsible(false)
+        .resizable(false)
+        .title_bar(false)
+        .anchor(egui::Align2::CENTER_CENTER, offset(ctx, id, nudge))
+        .frame(egui::Frame::window(&ctx.global_style()).fill(t.panel).inner_margin(egui::Margin::same(margin)))
+        .show(ctx, add)
+        .and_then(|r| r.inner)
+}
+
+/// The dialog's heading, which also moves the window ([`drag_band`]).
+pub(crate) fn heading(ui: &mut egui::Ui, text: &str) {
+    let t = Tokens::get(ui.ctx());
+    // Not selectable: a drag on it moves the window instead of selecting its text.
+    let r = ui.add(egui::Label::new(egui::RichText::new(text).font(theme::semibold(16.0)).color(t.text)).selectable(false));
+    drag_band(ui, r.rect.bottom());
+}
+
+/// Make the band of the dialog window [`show`] draws `ui` in, from its top edge down to `bottom`, a
+/// handle that moves the window. Widgets added later on the band stay clickable (they sit above it).
+pub(crate) fn drag_band(ui: &mut egui::Ui, bottom: f32) {
+    let id = ui.layer_id().id;
+    // Last frame's rectangle: none while the window measures itself the first time it shows.
+    let Some(outer) = ui.ctx().memory(|m| m.area_rect(id)) else { return };
+    let band = Rect::from_x_y_ranges(outer.x_range(), outer.top()..=bottom.max(outer.top()));
+    let r = ui.interact(band, handle(id), egui::Sense::drag());
+    if r.dragged() {
+        ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing);
+    } else if r.hovered() {
+        ui.ctx().set_cursor_icon(egui::CursorIcon::Grab);
+    }
+}
+
+/// The drag handle of window `id`.
+fn handle(id: Id) -> Id {
+    id.with("modal-drag")
+}
+
+/// Where window `id` sits, from the screen's centre: `nudge` down until it is first moved. While
+/// its [`drag_band`] is dragged, where it sat when the drag began plus how far the pointer has moved
+/// since the press, kept on screen (applied before the window places itself, so it follows the
+/// pointer without a frame's lag).
+fn offset(ctx: &egui::Context, id: Id, nudge: f32) -> Vec2 {
+    let (key, start_key) = (id.with("modal-offset"), id.with("modal-drag-start"));
+    let offset = ctx.data(|m| m.get_temp::<Vec2>(key)).unwrap_or(egui::vec2(0.0, nudge));
+    let dragged = ctx.read_response(handle(id)).is_some_and(|r| r.dragged());
+    let moved = ctx.input(|i| Some(i.pointer.latest_pos()? - i.pointer.press_origin()?));
+    let (true, Some(moved), Some(rect)) = (dragged, moved, ctx.memory(|m| m.area_rect(id))) else {
+        ctx.data_mut(|m| m.remove::<Vec2>(start_key));
+        return offset;
+    };
+    let start = ctx.data_mut(|m| *m.get_temp_mut_or(start_key, offset));
+    let screen = ctx.content_rect();
+    let to = on_screen(Rect::from_center_size(screen.center() + start + moved, rect.size()), screen).center() - screen.center();
+    ctx.data_mut(|m| m.insert_temp(key, to));
+    to
+}
+
+/// `r` moved the least to lie inside `screen` (its top left inside when it is larger).
+fn on_screen(r: Rect, screen: Rect) -> Rect {
+    let x = r.left().min(screen.right() - r.width()).max(screen.left());
+    let y = r.top().min(screen.bottom() - r.height()).max(screen.top());
+    Rect::from_min_size(egui::pos2(x, y), r.size())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_moved_window_stays_on_screen() {
+        let screen = Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0));
+        let r = |x: f32, y: f32, w: f32, h: f32| Rect::from_min_size(egui::pos2(x, y), egui::vec2(w, h));
+        assert_eq!(on_screen(r(100.0, 100.0, 200.0, 100.0), screen), r(100.0, 100.0, 200.0, 100.0));
+        assert_eq!(on_screen(r(-50.0, 550.0, 200.0, 100.0), screen), r(0.0, 500.0, 200.0, 100.0));
+        assert_eq!(on_screen(r(700.0, -20.0, 200.0, 100.0), screen), r(600.0, 0.0, 200.0, 100.0));
+        // Larger than the screen: its top left stays in view.
+        assert_eq!(on_screen(r(-10.0, -10.0, 900.0, 700.0), screen), r(0.0, 0.0, 900.0, 700.0));
+    }
+}

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

@@ -151,21 +151,9 @@ fn set_layout(d: &mut Dialog, key: &str, v: Value) {
     d.fields.insert("artboardLayout".into(), l);
 }
 
-/// The dimmed backdrop and a centred dialog window in the shared dialog style.
+/// The New Document dialog window `id` in the shared modal frame.
 fn window(ctx: &egui::Context, id: &str, margin: i8, add: impl FnOnce(&mut egui::Ui)) {
-    let t = Tokens::get(ctx);
-    egui::Area::new(egui::Id::new("modal-dim")).order(egui::Order::Middle).fixed_pos(egui::pos2(0.0, 0.0)).show(ctx, |ui| {
-        ui.allocate_rect(ctx.content_rect(), egui::Sense::click());
-    });
-    egui::Window::new(id)
-        .id(egui::Id::new(("dialog", id)))
-        .order(egui::Order::Foreground)
-        .collapsible(false)
-        .resizable(false)
-        .title_bar(false)
-        .anchor(egui::Align2::CENTER_CENTER, [0.0, -20.0])
-        .frame(egui::Frame::window(&ctx.global_style()).fill(t.panel).inner_margin(egui::Margin::same(margin)))
-        .show(ctx, add);
+    super::modal::show(ctx, id, egui::Id::new(("dialog", id)), -20.0, margin, add);
 }
 
 /// What the buttons of a window asked for.
@@ -194,6 +182,9 @@ fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
     let t = Tokens::get(ctx);
     let mut b = Buttons::default();
     window(ctx, KIND, 0, |ui| {
+        // No heading: the top margin (14) and the empty part of the category tabs' row (30) move the
+        // window.
+        super::modal::drag_band(ui, ui.max_rect().top() + 44.0);
         ui.horizontal_top(|ui| {
             egui::Frame::NONE.inner_margin(egui::Margin { left: 22, right: 14, top: 14, bottom: 18 }).show(ui, |ui| {
                 ui.vertical(|ui| {
@@ -489,7 +480,7 @@ fn show_more(app: &mut VectorcraftApp, ctx: &egui::Context) {
     const L: f32 = 150.0;
     window(ctx, MORE, 22, |ui| {
         ui.set_width(560.0);
-        ui.label(egui::RichText::new(tl!("More Settings")).font(theme::semibold(16.0)).color(t.text));
+        super::modal::heading(ui, tl!("More Settings"));
         ui.add_space(12.0);
         widgets::label_row(ui, tl!("Name:"), L, |ui| {
             form::text(ui, &mut d, "name", 300.0);
@@ -533,7 +524,7 @@ fn show_more(app: &mut VectorcraftApp, ctx: &egui::Context) {
                     set_layout(&mut d, "spacing", json!(v.max(0.0)));
                 }
                 ui.add_space(20.0);
-                ui.label(egui::RichText::new(tl!("Columns:")).color(t.text));
+                widgets::field_label(ui, egui::RichText::new(tl!("Columns:")).color(t.text));
                 let grid = matches!(lay, ArtboardLayout::GridByRow | ArtboardLayout::GridByColumn);
                 ui.add_enabled_ui(grid, |ui| {
                     if let Some(v) = widgets::spin_plain(ui, "newdoc-columns", cols as f64, "", 0, 76.0, 1.0, 1.0, &[]) {

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

@@ -1,12 +1,12 @@
-//! Path dialogs: Average, Offset Path, Simplify and Split Into Grid.
+//! Path dialogs: Average, Offset Path (with Preview), Simplify and Split Into Grid.
 
 use serde_json::{Value, json};
 
-use super::{DialogSpec, run_and_close};
+use super::{DialogSpec, form, run_and_close};
 use crate::VectorcraftApp;
 use crate::state::Dialog;
 
-pub(super) const SPEC: DialogSpec = DialogSpec { heading: |d| title(&d.kind).into(), confirm, ..DialogSpec::FORM };
+pub(super) const SPEC: DialogSpec = DialogSpec { heading: |d| title(&d.kind).into(), body, confirm, preview: true, ..DialogSpec::FORM };
 
 fn title(kind: &str) -> &'static str {
     match kind {
@@ -17,14 +17,28 @@ fn title(kind: &str) -> &'static str {
     }
 }
 
-fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
-    let (id, params) = match d.kind.as_str() {
+/// The command the dialog runs and its parameters.
+fn command(d: &Dialog) -> (&'static str, Value) {
+    match d.kind.as_str() {
         "average" => ("path.average", json!({"axis": d.str("axis")})),
         "offsetPath" => {
             ("object.path.offsetPath", json!({"offset": d.f64("offset", 10.0), "joins": d.str("joins"), "miterLimit": d.f64("miterLimit", 4.0)}))
         }
         "simplify" => ("object.path.simplify", json!({"tolerance": d.f64("tolerance", 1.0)})),
         _ => ("object.path.splitIntoGrid", json!({"rows": d.f64("rows", 2.0), "columns": d.f64("columns", 2.0), "gutter": d.f64("gutter", 12.0)})),
-    };
-    run_and_close(app, id, params)
+    }
+}
+
+fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
+    form::grid(ui, d, app.session.general_unit());
+    if d.kind == "offsetPath" {
+        let (id, params) = command(d);
+        form::preview(app, ui, d, "Offset Path", id, params);
+    }
+    false
+}
+
+fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
+    let (id, params) = command(d);
+    if d.kind == "offsetPath" { form::commit_preview(app, id, params) } else { run_and_close(app, id, params) }
 }

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

@@ -813,7 +813,7 @@ fn image_size(app: &VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog, s: Option
         if let Some(v) = widgets::plain_field(ui, "sfw-w", f64::from(w), " px", 0, 80.0) {
             set(d, "width", json!(v.round().max(1.0)));
         }
-        ui.label(tl!("H:"));
+        widgets::field_label(ui, tl!("H:"));
         if let Some(v) = widgets::plain_field(ui, "sfw-h", f64::from(h), " px", 0, 80.0) {
             set(d, "height", json!(v.round().max(1.0)));
         }

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

@@ -202,7 +202,7 @@ pub(super) fn option_fields(ui: &mut egui::Ui, d: &mut Dialog, screens: bool) {
             choice(ui, d, "images", tl!("Images:"), &IMAGES, None);
         }
         choice(ui, d, "objectIds", tl!("Object IDs:"), &OBJECT_IDS, None);
-        ui.label(egui::RichText::new(tl!("Decimal:")).color(t.text_dim));
+        widgets::field_label(ui, egui::RichText::new(tl!("Decimal:")).color(t.text_dim));
         let decimals = d.f64("decimals", 3.0);
         if let Some(v) = widgets::spin_plain(ui, "svg-decimals", decimals, "", 0, 70.0, 1.0, 1.0, &[]) {
             let (lo, hi) = (*vectorcraft_svg::DECIMALS.start() as f64, *vectorcraft_svg::DECIMALS.end() as f64);

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

@@ -146,7 +146,7 @@ pub(super) fn grid<R>(ui: &mut egui::Ui, add: impl FnOnce(&mut egui::Ui) -> R) -
 
 /// A dimmed field label in the swatch dialogs' grid.
 pub(super) fn label(ui: &mut egui::Ui, s: &str) {
-    ui.label(egui::RichText::new(s).color(Tokens::get(ui.ctx()).text_dim));
+    crate::widgets::field_label(ui, egui::RichText::new(s).color(Tokens::get(ui.ctx()).text_dim));
 }
 
 /// The Swatch Name row of the grid. Returns true when it changed.

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

@@ -4,6 +4,7 @@ use serde_json::json;
 use vectorcraft_engine::Session;
 
 use super::*;
+use crate::theme;
 
 fn app() -> VectorcraftApp {
     let mut app = VectorcraftApp::new(Session::new(), Default::default());

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

@@ -9,6 +9,7 @@ use vectorcraft_engine::cmd::fileio;
 
 use super::*;
 use crate::Services;
+use crate::theme;
 
 pub(super) type Written = Rc<RefCell<Vec<(String, Vec<u8>)>>>;
 

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

@@ -7,6 +7,7 @@ use vectorcraft_testkit::pdf::{PdfPage, pdf};
 
 use super::*;
 use crate::io;
+use crate::theme;
 
 fn app() -> VectorcraftApp {
     let mut app = VectorcraftApp::new(Session::new(), Default::default());

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

@@ -0,0 +1,203 @@
+//! #423: modal dialogs move by their heading (and stay on screen and where they were moved), and
+//! the form dialogs' choice fields are dropdowns (Offset Path's Joins).
+
+use egui::{Event, Pos2, Rect, Vec2, vec2};
+use serde_json::json;
+use vectorcraft_engine::Session;
+
+use super::*;
+use crate::theme;
+
+const SCREEN: Vec2 = vec2(1280.0, 900.0);
+
+/// A context drawing the dialog layer in a 1280 × 900 window.
+fn ctx() -> egui::Context {
+    let ctx = egui::Context::default();
+    theme::install_fonts(&ctx);
+    theme::apply(&ctx, Default::default());
+    ctx
+}
+
+/// One frame of the dialog layer with `events`: every text drawn, with its screen rect.
+fn frame(ctx: &egui::Context, app: &mut VectorcraftApp, events: Vec<Event>) -> Vec<(String, Rect)> {
+    let input = egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, SCREEN)), events, ..Default::default() };
+    let mut out = ctx.run_ui(input, |ui| show(app, ui.ctx()));
+    out.textures_delta.clear();
+    fn collect(s: &egui::Shape, out: &mut Vec<(String, Rect)>) {
+        match s {
+            egui::Shape::Text(t) => out.push((t.galley.text().to_string(), t.visual_bounding_rect())),
+            egui::Shape::Vec(v) => v.iter().for_each(|s| collect(s, out)),
+            _ => {}
+        }
+    }
+    let mut texts = vec![];
+    out.shapes.iter().for_each(|c| collect(&c.shape, &mut texts));
+    texts
+}
+
+fn button(pos: Pos2, pressed: bool) -> Event {
+    Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }
+}
+
+/// Drag with the mouse from `from` by `by`, in steps, then let go.
+fn drag(ctx: &egui::Context, app: &mut VectorcraftApp, from: Pos2, by: Vec2) {
+    frame(ctx, app, vec![Event::PointerMoved(from), button(from, true)]);
+    for i in 1..=6 {
+        frame(ctx, app, vec![Event::PointerMoved(from + by * (i as f32 / 6.0))]);
+    }
+    frame(ctx, app, vec![button(from + by, false)]);
+    frame(ctx, app, vec![]);
+}
+
+fn click(ctx: &egui::Context, app: &mut VectorcraftApp, pos: Pos2) -> Vec<(String, Rect)> {
+    frame(ctx, app, vec![Event::PointerMoved(pos), button(pos, true)]);
+    frame(ctx, app, vec![button(pos, false)]);
+    frame(ctx, app, vec![])
+}
+
+/// Frames until a window that just opened has measured and placed itself.
+fn settle(ctx: &egui::Context, app: &mut VectorcraftApp) {
+    for _ in 0..6 {
+        frame(ctx, app, vec![]);
+    }
+}
+
+fn rect_of(ctx: &egui::Context, id: egui::Id) -> Rect {
+    ctx.memory(|m| m.area_rect(id)).expect("the dialog window was shown")
+}
+
+fn app_with_selection() -> VectorcraftApp {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.run("file.new", json!({"width": 400, "height": 400})).unwrap();
+    app.run("shape.rectangle", json!({"x": 100, "y": 100, "width": 80, "height": 60})).unwrap();
+    app
+}
+
+fn close_to(a: Vec2, b: Vec2) -> bool {
+    (a - b).length() < 1.5
+}
+
+/// Opens a dialog.
+type Open = fn(&mut VectorcraftApp);
+
+/// Every kind of modal window: the shared frame (Offset Path), and the ones drawing their own
+/// window (New Document without a heading, Preferences, Keyboard Shortcuts).
+#[test]
+fn dialogs_move_by_their_heading_stay_on_screen_and_where_they_were_moved() {
+    let screen = Rect::from_min_size(Pos2::ZERO, SCREEN);
+    let opens: [(&str, Open, egui::Id); 4] = [
+        ("Offset Path", |app| crate::menus::invoke(app, "object.path.offsetPath", json!({})), egui::Id::new(("dialog", "offsetPath"))),
+        ("New Document", open_new_document, egui::Id::new(("dialog", "newDocument"))),
+        ("Preferences", |app| crate::prefs_dialog::open(app, None), egui::Id::new("dialog-preferences")),
+        ("Keyboard Shortcuts", crate::shortcut_editor::open, egui::Id::new("dialog-shortcuts")),
+    ];
+    for (name, open, id) in opens {
+        let (ctx, mut app) = (ctx(), app_with_selection());
+        open(&mut app);
+        settle(&ctx, &mut app);
+        let start = rect_of(&ctx, id);
+        // Dragging the heading (the band from the top edge down to it) moves the window.
+        drag(&ctx, &mut app, start.left_top() + vec2(40.0, 10.0), vec2(-90.0, 50.0));
+        let moved = rect_of(&ctx, id);
+        assert!(close_to(moved.min - start.min, vec2(-90.0, 50.0)), "{name}: {start:?} → {moved:?}");
+        // A drag that starts below the heading (in the bottom margin) doesn't.
+        drag(&ctx, &mut app, moved.left_bottom() + vec2(6.0, -4.0), vec2(80.0, -80.0));
+        assert_eq!(rect_of(&ctx, id), moved, "{name}: dragging the body moved it");
+        // Dragged far past the window's edge, it stops at the edge.
+        drag(&ctx, &mut app, moved.left_top() + vec2(40.0, 10.0), vec2(5000.0, 5000.0));
+        let edge = rect_of(&ctx, id);
+        assert!(screen.contains_rect(edge.shrink(0.5)), "{name}: off screen at {edge:?}");
+        assert!((edge.right() - screen.right()).abs() < 1.5 && (edge.bottom() - screen.bottom()).abs() < 1.5, "{name}: {edge:?}");
+        // Closed and opened again (this session): where it was left.
+        app.ui.dialog = None;
+        frame(&ctx, &mut app, vec![]);
+        open(&mut app);
+        settle(&ctx, &mut app);
+        assert!(close_to(rect_of(&ctx, id).min - edge.min, Vec2::ZERO), "{name}: reopened at {:?}, left at {edge:?}", rect_of(&ctx, id));
+    }
+}
+
+/// Offset Path's Joins is a dropdown of Miter, Round and Bevel (it was a text field), listed after
+/// Offset; choosing Round runs the command with round joins.
+#[test]
+fn offset_path_joins_is_a_dropdown() {
+    let (ctx, mut app) = (ctx(), app_with_selection());
+    app.run("select.all", json!({})).unwrap();
+    crate::menus::invoke(&mut app, "object.path.offsetPath", json!({}));
+    frame(&ctx, &mut app, vec![]);
+    let texts = frame(&ctx, &mut app, vec![]);
+    let at = |texts: &[(String, Rect)], s: &str| texts.iter().find(|(t, _)| t == s).map(|(_, r)| *r);
+    let (offset, joins, miter) = (at(&texts, "Offset:").unwrap(), at(&texts, "Joins:").unwrap(), at(&texts, "Miter Limit:").unwrap());
+    assert!(offset.top() < joins.top() && joins.top() < miter.top(), "Offset, Joins, Miter Limit: {texts:?}");
+    let current = at(&texts, "Miter").expect("Joins shows its choice");
+    assert!(at(&texts, "miter").is_none(), "Joins is a text field: {texts:?}");
+    // The list: Miter, Round, Bevel.
+    let open = click(&ctx, &mut app, current.center());
+    for choice in ["Round", "Bevel"] {
+        assert!(at(&open, choice).is_some(), "{choice} isn't listed: {open:?}");
+    }
+    let round = at(&open, "Round").unwrap();
+    click(&ctx, &mut app, round.center());
+    assert_eq!(app.ui.dialog.as_ref().unwrap().fields["joins"], json!("round"));
+    // OK: the same result as the command with round joins (not miter).
+    confirm(&mut app).unwrap();
+    assert!(app.ui.dialog.is_none());
+    let made = |app: &VectorcraftApp| {
+        let st = app.session.doc().unwrap();
+        format!("{:?}", st.doc.node(st.selection.objects[0]).unwrap().kind)
+    };
+    let direct = |joins: &str| {
+        let mut app = app_with_selection();
+        app.run("select.all", json!({})).unwrap();
+        app.run("object.path.offsetPath", json!({"offset": 10, "joins": joins, "miterLimit": 4})).unwrap();
+        made(&app)
+    };
+    assert_eq!(made(&app), direct("round"));
+    assert_ne!(made(&app), direct("miter"));
+}
+
+/// The other form dialogs' choices are dropdowns too: Average's and Shear's axis.
+#[test]
+fn form_dialog_axes_are_dropdowns() {
+    for (id, shown) in [("path.average", "Both"), ("object.shear", "Horizontal"), ("object.reflect", "Vertical")] {
+        let (ctx, mut app) = (ctx(), app_with_selection());
+        app.run("select.all", json!({})).unwrap();
+        crate::menus::invoke(&mut app, id, json!({}));
+        frame(&ctx, &mut app, vec![]);
+        let texts = frame(&ctx, &mut app, vec![]);
+        assert!(texts.iter().any(|(t, _)| t == shown), "{id}: {texts:?}");
+        assert!(!texts.iter().any(|(t, _)| *t == shown.to_lowercase()), "{id} has a text field: {texts:?}");
+    }
+}
+
+/// The axis choices are translated in the "axis" context: in Japanese the plain Horizontal and
+/// Vertical are the type orientations (horizontal and vertical writing).
+#[test]
+fn axis_choices_read_as_axes_in_every_complete_language() {
+    use crate::i18n::{LANGUAGES, Lang, tr, tr_ctx};
+    let ja = Lang::from_code("ja").unwrap();
+    assert_eq!(tr_ctx(ja, "axis", "Horizontal"), "水平方向");
+    assert_ne!(tr_ctx(ja, "axis", "Horizontal"), tr(ja, "Horizontal"));
+    for l in LANGUAGES.iter().filter(|l| l.complete_menus) {
+        for s in ["Horizontal", "Vertical", "Both"] {
+            assert!(l.source.lines().any(|line| line.starts_with(&format!("axis\t{s}\t"))), "{}: no axis row for {s}", l.code);
+        }
+    }
+}
+
+/// Offset Path previews on the canvas; Cancel rolls the preview back.
+#[test]
+fn offset_path_previews() {
+    let (ctx, mut app) = (ctx(), app_with_selection());
+    app.run("select.all", json!({})).unwrap();
+    let count = |app: &VectorcraftApp| app.session.doc().unwrap().doc.layers.iter().map(|l| l.children().map_or(0, |c| c.len())).sum::<usize>();
+    crate::menus::invoke(&mut app, "object.path.offsetPath", json!({}));
+    let texts = frame(&ctx, &mut app, vec![]);
+    let texts = if texts.is_empty() { frame(&ctx, &mut app, vec![]) } else { texts };
+    let preview = texts.iter().find(|(t, _)| t == "Preview").map(|(_, r)| *r).expect("a Preview checkbox");
+    click(&ctx, &mut app, preview.center());
+    frame(&ctx, &mut app, vec![]);
+    assert_eq!(count(&app), 2, "previewed");
+    cancel(&mut app);
+    assert_eq!(count(&app), 1, "rolled back");
+}

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

@@ -5,6 +5,7 @@ use serde_json::json;
 use vectorcraft_engine::Session;
 
 use super::*;
+use crate::theme;
 
 /// The save prompt's rect after a few frames in a window of `physical` pixels at UI scale `zoom`.
 fn prompt(app: &mut VectorcraftApp, ctx: &egui::Context, physical: egui::Vec2, zoom: f32) -> (egui::Rect, egui::Rect) {

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

@@ -5,7 +5,7 @@ use egui::Ui;
 use serde_json::{Value, json};
 
 use crate::state::Dialog;
-use crate::theme::{self, Tokens};
+use crate::theme::Tokens;
 use crate::widgets;
 use crate::{VectorcraftApp, font_menu};
 
@@ -37,77 +37,66 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
     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| {
-        ui.allocate_rect(ctx.content_rect(), egui::Sense::click());
-    });
-    egui::Window::new(tl!("Find Font"))
-        .id(egui::Id::new("dialog-find-font"))
-        .order(egui::Order::Foreground)
-        .collapsible(false)
-        .resizable(false)
-        .title_bar(false)
-        .anchor(egui::Align2::CENTER_CENTER, [0.0, -40.0])
-        .frame(egui::Frame::window(&ctx.global_style()).fill(t.panel).inner_margin(egui::Margin::same(22)))
-        .show(ctx, |ui: &mut Ui| {
-            ui.set_width(380.0);
-            ui.label(egui::RichText::new(tl!("Find Font")).font(theme::semibold(16.0)).color(t.text));
-            ui.add_space(10.0);
-            widgets::subheader(ui, &crate::i18n::fmt(tl!("Fonts in Document: {count}"), &[("count", &list.len().to_string())]));
-            let sel = d.fields.get("selected").and_then(Value::as_u64).unwrap_or(0) as usize;
-            egui::Frame::NONE.fill(t.input).stroke(egui::Stroke::new(1.0, t.input_border)).inner_margin(egui::Margin::same(4)).show(ui, |ui| {
-                ui.set_min_height(120.0);
-                ui.set_width(ui.available_width());
-                egui::ScrollArea::vertical().max_height(160.0).show(ui, |ui| {
-                    for (i, f) in list.iter().enumerate() {
-                        let (note, color) = font_note(f);
-                        let label = format!("{} {}{note}  ({})", f["family"].as_str().unwrap_or(""), f["style"].as_str().unwrap_or(""), f["runs"]);
-                        let text = egui::RichText::new(label).color(color.unwrap_or(t.text));
-                        if ui.selectable_label(i == sel, text).clicked() {
-                            d.fields.insert("selected".into(), json!(i));
-                        }
+    crate::dialogs::modal::show(ctx, tl!("Find Font"), egui::Id::new("dialog-find-font"), -40.0, 22, |ui: &mut Ui| {
+        ui.set_width(380.0);
+        crate::dialogs::modal::heading(ui, tl!("Find Font"));
+        ui.add_space(10.0);
+        widgets::subheader(ui, &crate::i18n::fmt(tl!("Fonts in Document: {count}"), &[("count", &list.len().to_string())]));
+        let sel = d.fields.get("selected").and_then(Value::as_u64).unwrap_or(0) as usize;
+        egui::Frame::NONE.fill(t.input).stroke(egui::Stroke::new(1.0, t.input_border)).inner_margin(egui::Margin::same(4)).show(ui, |ui| {
+            ui.set_min_height(120.0);
+            ui.set_width(ui.available_width());
+            egui::ScrollArea::vertical().max_height(160.0).show(ui, |ui| {
+                for (i, f) in list.iter().enumerate() {
+                    let (note, color) = font_note(f);
+                    let label = format!("{} {}{note}  ({})", f["family"].as_str().unwrap_or(""), f["style"].as_str().unwrap_or(""), f["runs"]);
+                    let text = egui::RichText::new(label).color(color.unwrap_or(t.text));
+                    if ui.selectable_label(i == sel, text).clicked() {
+                        d.fields.insert("selected".into(), json!(i));
                     }
-                });
-            });
-            ui.add_space(10.0);
-            widgets::subheader(ui, tl!("Replace With Font"));
-            let fam = d.str("family");
-            ui.horizontal(|ui| {
-                // 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!(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.
-                let closest = tl!("(closest)");
-                let mut opts: Vec<&str> = vec![closest];
-                opts.extend(styles.iter().map(String::as_str));
-                let style = d.str("style");
-                let cur = if style.is_empty() { closest } else { style.as_str() };
-                if let Some(i) = widgets::dropdown_names(ui, "ff-style", cur, &opts, 120.0) {
-                    d.fields.insert("style".into(), json!(if i == 0 { String::new() } else { styles[i - 1].clone() }));
-                }
-            });
-            ui.add_space(14.0);
-            ui.horizontal(|ui| {
-                let has = sel < list.len();
-                if ui.add_enabled(has, egui::Button::new(tl!("Find"))).clicked() {
-                    act = Some("find");
-                }
-                if ui.add_enabled(has, egui::Button::new(tl!("Change"))).on_hover_text(tl!("In the selected objects")).clicked() {
-                    act = Some("change");
-                }
-                if ui.add_enabled(has, egui::Button::new(tl!("Change All"))).clicked() {
-                    act = Some("changeAll");
-                }
-                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                    if widgets::primary_button(ui, tl!("Done")).clicked() {
-                        close = true;
-                    }
-                });
             });
         });
+        ui.add_space(10.0);
+        widgets::subheader(ui, tl!("Replace With Font"));
+        let fam = d.str("family");
+        ui.horizontal(|ui| {
+            // 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!(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.
+            let closest = tl!("(closest)");
+            let mut opts: Vec<&str> = vec![closest];
+            opts.extend(styles.iter().map(String::as_str));
+            let style = d.str("style");
+            let cur = if style.is_empty() { closest } else { style.as_str() };
+            if let Some(i) = widgets::dropdown_names(ui, "ff-style", cur, &opts, 120.0) {
+                d.fields.insert("style".into(), json!(if i == 0 { String::new() } else { styles[i - 1].clone() }));
+            }
+        });
+        ui.add_space(14.0);
+        ui.horizontal(|ui| {
+            let has = sel < list.len();
+            if ui.add_enabled(has, egui::Button::new(tl!("Find"))).clicked() {
+                act = Some("find");
+            }
+            if ui.add_enabled(has, egui::Button::new(tl!("Change"))).on_hover_text(tl!("In the selected objects")).clicked() {
+                act = Some("change");
+            }
+            if ui.add_enabled(has, egui::Button::new(tl!("Change All"))).clicked() {
+                act = Some("changeAll");
+            }
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                if widgets::primary_button(ui, tl!("Done")).clicked() {
+                    close = true;
+                }
+            });
+        });
+    });
     let sel = d.fields.get("selected").and_then(Value::as_u64).unwrap_or(0) as usize;
     if let (Some(a), Some(from)) = (act, list.get(sel)) {
         let r = match a {
@@ -157,7 +146,7 @@ mod tests {
         app.session.execute("text.create", &json!({"x": 10, "y": 40, "text": "Hi", "font": "Missing Family"})).unwrap();
         open(&mut app);
         let ctx = egui::Context::default();
-        theme::install_fonts(&ctx);
+        crate::theme::install_fonts(&ctx);
         let mut out = ctx.run_ui(egui::RawInput::default(), |ui| show(&mut app, ui.ctx()));
         out.textures_delta.clear();
         let d = app.ui.dialog.clone().unwrap();

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

@@ -10,6 +10,7 @@
 # language names, OpenType, the built-in workspace names and the bracketed perspective grid preset
 # names.
 	About VectorCraft	O aplikaci VectorCraft
+	Align to Path	Zarovnat k cestě
 	Join Our Discord	Připojit se k našemu Discordu
 	Settings…	Nastavení…
 	Language	Jazyk
@@ -572,3 +573,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

@@ -182,6 +182,7 @@
 	Artwork Colors	Colores de la ilustración
 	As Multiple Assets	Como varios recursos
 	As Single Asset	Como un solo recurso
+	Ascender	Ascendente
 	Ask When Modified	Preguntar al modificar
 	Aspect Ratio	Proporción
 	Asset Export	Exportación de recursos
@@ -212,6 +213,7 @@
 	Background:	Fondo:
 	Backspace	Retroceso
 	Bar Graph Tool	Herramienta Gráfico de barras
+	Baseline	Línea de base
 	Baseline Shift	Desplazamiento de línea de base
 	Basic Latin	Latín básico
 	Batch	Lote
@@ -283,6 +285,7 @@
 	Cap	Extremo
 	Cap:	Extremo:
 	Cascade	Cascada
+	Center	Centro
 	Center Artwork	Centrar ilustración
 	Center on Artboard	Centrar en la mesa de trabajo
 	Center-Justified Tab	Tabulación centrada
@@ -472,6 +475,8 @@
 	Corners	Esquinas
 	Chamfer	Chaflán
 	Corners…	Esquinas…
+	Descender	Descendente
+	Flip	Voltear
 	Inverted Round	Redondeada invertida
 	Radius:	Radio:
 	Round	Redondeada
@@ -912,6 +917,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…
@@ -921,6 +927,10 @@
 	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
+	Spacing	Espaciado
+	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
@@ -1928,6 +1938,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
@@ -2268,6 +2283,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
@@ -2698,6 +2714,7 @@
 	Type becomes outlines, and strokes a CAD line can't draw become filled shapes.	El texto se convierte en contornos, y los trazos que una línea CAD no puede dibujar se convierten en formas rellenas.
 	Type Object Selection by Path Only	Selección de objetos de texto solo por trazado
 	Type on a Path	Texto en trazado
+	Type on a Path Options	Opciones de texto en trazado
 	Type on a Path Options…	Opciones de texto en trazado…
 	Type on a Path Tool	Herramienta Texto en trazado
 	Type Orientation	Orientación del texto
@@ -2870,6 +2887,7 @@
 	Zoom to Selection	Zoom a la selección
 	Zoom Tool	Herramienta Zoom
 	Zoom with Mouse Wheel	Zoom con la rueda del mouse
+	Scrub Numeric Fields by Dragging	Ajustar campos numéricos arrastrando
 	{count} file(s) in {folder}{note}. Show the package folder?	{count} archivo(s) en {folder}{note}. ¿Mostrar la carpeta del paquete?
 	{count} linked file(s) not found	No se encontraron {count} archivo(s) vinculado(s)
 	{count} linked image(s) changed since this document was saved. Show the new versions?	{count} imagen(es) vinculada(s) cambiaron desde que se guardó este documento. ¿Mostrar las versiones nuevas?
@@ -2972,3 +2990,42 @@
 # 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 +/−
+	Joins	Uniones
+	Miter	Inglete
+	Bevel	Bisel
+	Offset	Desplazamiento
+	Axis	Eje
+axis	Horizontal	Horizontal
+axis	Vertical	Vertical
+axis	Both	Ambos