Fix #414 : select, move and delete ruler guides with the selection tools

Guides dragged out of the rulers could not be touched again: no tool hit-tested them, so a click on a guide went to the art under it. - The Selection, Direct Selection and Group Selection tools pick a ruler guide within the selection tolerance (over the art; Direct Selection takes an anchor on it first) through a shared tools::rulerguide::GuideEdit. A drag moves the selected guides in one undo step (Alt copies them, Shift snaps the dragged one to the ruler's ticks, otherwise it snaps to 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 can't be picked; the pointer shows which way a guide moves. - Selection::guides holds the selected guides (on their own, like slices); the canvas draws them in the selection colour. Delete/Backspace (edit.clear) delete them, the arrow keys (object.nudge) nudge them, Lock Guides and Hide Guides deselect them. - Commands for agents: guide.list, guide.select {indexes, toggle?}, guide.move {dx?, dy?, copy?} (besides {index, pos}) and guide.remove {index?}; guide positions out of range are refused. Documented in docs/mcp.md. - Shift while dragging a new guide out of a ruler snaps it to the ticks too (Unit::ruler_step, shared with the rulers' drawing). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Release CI: macOS job on the org macos-release runner
2026-10-08 08:55:51 +07:00 · 2026-10-07 21:54:52 -04:00 · 2026-10-08 08:36:36 +07:00 · 2026-10-08 08:29:07 +07:00 · 2026-10-08 08:28:32 +07:00 · 2026-10-08 08:22:24 +07:00
78 changed files with 3963 additions and 363 deletions
@@ -63,7 +63,7 @@ jobs:
  macos:
    name: macOS universal
    needs: version
-    runs-on: macos-15
+    runs-on: macos-release  # org larger runner (M2 Pro), release.yml@release only; capped by the actions_macos_xl budget
    environment: release
    env:
      VECTORCRAFT_VERSION: ${{ needs.version.outputs.version }}
@@ -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).
@@ -217,6 +217,7 @@ dependencies = [
 "parking_lot",
 "percent-encoding",
 "windows-sys 0.60.2",
+ "wl-clipboard-rs",
 "x11rb",
 ]

@@ -1242,6 +1243,12 @@ version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"

+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
 [[package]]
 name = "flate2"
 version = "1.1.10"
@@ -2367,6 +2374,15 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"

+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -2754,6 +2770,16 @@ dependencies = [
 "pin-project-lite",
 ]

+[[package]]
+name = "os_pipe"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "parking"
 version = "2.2.1"
@@ -2814,6 +2840,17 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"

+[[package]]
+name = "petgraph"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
+dependencies = [
+ "fixedbitset",
+ "hashbrown 0.15.5",
+ "indexmap",
+]
+
 [[package]]
 name = "phf"
 version = "0.13.1"
@@ -4067,6 +4104,17 @@ dependencies = [
 "once_cell",
 ]

+[[package]]
+name = "tree_magic_mini"
+version = "3.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
+dependencies = [
+ "memchr",
+ "nom",
+ "petgraph",
+]
+
 [[package]]
 name = "ttf-parser"
 version = "0.25.1"
@@ -4642,6 +4690,7 @@ dependencies = [
 "log",
 "serde",
 "serde_json",
+ "toml",
 "vectorcraft-cad",
 "vectorcraft-color",
 "vectorcraft-doc",
@@ -5640,6 +5689,24 @@ version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"

+[[package]]
+name = "wl-clipboard-rs"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d7888ccd4896447b2d14d3a9350a85df2aeb6f181e2e7a31349d104ac46cac1"
+dependencies = [
+ "libc",
+ "log",
+ "os_pipe",
+ "rustix 1.1.5",
+ "thiserror 2.0.21",
+ "tree_magic_mini",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-protocols-wlr",
+]
+
 [[package]]
 name = "write-fonts"
 version = "0.48.1"
@@ -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) and SVG type opening at the size it draws at (#396); 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) and the first Preferences options that were stored but unused (#394); see [Honest assessment](#honest-assessment-2026-10-05))._

 ## Where we are

@@ -42,7 +42,7 @@ since 2026-10-01.
 | **Bundled content:** brush, symbol, style and swatch libraries | ~30% | Ours are original and generated in code, and far fewer than Illustrator ships; brush and symbol libraries are still missing |
 | **Performance** | unverified | Multithreaded, off-thread rendering and caches are in place. The last budget run (2026-10-01, loaded machine) measured 290 ms for a 50k-path fit against a 16 ms budget. Re-run `vectorcraft-cli perf` on an idle machine |
 | **Robustness** | good, new | ~2,840 tests, property tests, no panics in shipped code (lints, the `guard` safety net, import fuzzing), Data Recovery. Missing: a corpus of real-world files, Windows/Linux/browser QA |
-| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); hybrid-graphics laptops render on the power-saving GPU by default (#306); web drops land in the document they were dropped on (#359); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) |
+| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); hybrid-graphics laptops render on the power-saving GPU by default (#306); web drops land in the document they were dropped on (#359); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); on Linux/Wayland the clipboard reads the compositor's own (data-control) and copied image files paste, but files can't be dropped on the window under Wayland until eframe moves to winit 0.31 (#398; the Wayland side is verified by compilation only); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) |
 | **Agent automation** | beyond Illustrator | Every command, gesture and dialog is drivable over MCP, the CLI and the control channel |

 ### Where we're lacking (in priority order)
@@ -90,7 +90,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
  - Actions panel (record/playback, persisted), generic parameter dialogs for every "…" command.
  - JSON-lines control channel with real egui pointer and keyboard injection.
  - MCP server with 25 tools (drawing, text, effects, Pathfinder, transforms, graphs, text wrap, export, screenshots, any command), attached to the running app or headless. Tool descriptions and replies agree with the engine: format lists come from its format table, `save_file` says it keeps the document's own format, `inspect_document` reports the paint type's characters show, and selection exports report the encoder's warnings.
-  - MCP protocol: five prompts (`prompts/list` / `prompts/get`: poster, icon set, recolour, trace-and-style, export set), `completion/complete` for prompt arguments and template variables read from the live catalogues (formats, effect ids, command ids, trace presets, swatch and object ids), four resource templates (`vectorcraft://object/{id}`, `//command/{id}`, `//effect/{id}`, `//swatch/{name}`) so an agent reads one thing instead of the whole document, and `logging/setLevel` with `notifications/message`. `window.panel` ids are case-insensitive (display labels work too), `vectorcraft://object/{id}` reads through `document.node {summary: true}` (the same reply bytes from one lookup instead of summarizing the whole document: a leaf read on a 2,000-object document drops from ~20 ms to ~0.06 ms), and the CLI sweeps the protocol surface over stdio against the compiled binary. `docs/mcp.md` has a Protocol section covering the capability table and what is deliberately absent (subscriptions, progress, cancellation, sampling, elicitation, Streamable HTTP — all of which need the transport to interleave reads).
+  - MCP protocol: five prompts (`prompts/list` / `prompts/get`: poster, icon set, recolour, trace-and-style, export set), `completion/complete` for prompt arguments and template variables read from the live catalogues (formats, effect ids, command ids, trace presets, swatch and object ids), four resource templates (`vectorcraft://object/{id}`, `//command/{id}`, `//effect/{id}`, `//swatch/{name}`) so an agent reads one thing instead of the whole document, and `logging/setLevel` with `notifications/message`. `window.panel` ids are case-insensitive (display labels work too), `vectorcraft://object/{id}` reads through `document.node {summary: true}` (the same reply bytes from one lookup instead of summarizing the whole document: a leaf read on a 2,000-object document drops from ~20 ms to ~0.06 ms), large containers slice with `document.node {depth?, childLimit?}` (truncated levels report `childCount`), 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,8 +103,10 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
  - A canvas context menu: right-click selects the object under the pointer and lists what applies to the selection (Undo/Redo, clipboard, group, isolation, join, Remove Anchor Points when anchors are selected, masks, compound paths, guides, Transform, Arrange, Select, Export Selection), or the view commands on empty canvas.
  - Save / Don't Save / Cancel before closing or quitting with unsaved documents (tabs, Close, Close All, Quit, window close).
  - Four brightness themes, persistent preferences.
+  - Preferences that act (#394, in part): Show Tool Tips, Double Click To Isolate, Zoom with Mouse Wheel (the wheel zooms about the pointer, Shift-wheel scrolls up and down, Cmd/Ctrl-wheel sideways), Use Precise Cursors; Selection & Anchor Display › Tolerance (objects, anchors and handles), Object Selection by Path Only, Command Click to Select Objects Behind (cycling down the stack), Zoom to Selection, anchor Size, Highlight anchors on mouse over; Type › Number of Recent Fonts (up to 15); Guides & Grid › guide and grid Color and Style (lines or dots) and Grids In Back. They reach agents too (`prefs.set`, then `pointer_gesture`; `ui.wheel` on the control channel). About 55 stored options still do nothing yet (the rest of #394).
  - Dialogs open with their first field focused and its value selected: type a value and press Enter (Move, Rotate, Scale…). Number fields in panels and dialogs step with Up/Down (Shift: ten, Ctrl/Cmd: a tenth of their unit), applied at once.
  - Tab shows and hides the panels (in the Type tool it types a tab) without moving the keyboard focus onto a field, so the next shortcut or letter still works; in dialogs and panel fields it moves between fields.
+  - Cmd/Ctrl+A follows the keyboard: in a panel, dialog or search field it selects the field's text, while the Type tool edits it selects all of that text (also `select.all` over MCP), and only otherwise every object. On macOS the menu bar's Select All, Cut, Copy and Paste (keys or clicks) act on a focused field too. Not yet: Select All across threaded frames (one frame's text is selected).
  - On Windows and Linux the app bar is the window's title bar (its own minimize, maximize and close buttons, drag to move, edges to resize), with the dragon app icon as the brand mark; dialogs and menus size to their content. As on a native menu bar, once one menu is open, moving the pointer onto another title opens that one.
 - **Tools:**
  - **Selection:** Selection, Direct/Group Selection, Magic Wand, Lasso. Dragging a path segment with Direct Selection bends it when it's curved (its anchors stay) and moves its two anchors when it's straight, one undo step; the fill, Shift or Alt still pick the whole path (Alt-drag copies it).
@@ -120,15 +122,15 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
  - **Editing type:** double-clicking type with a selection tool switches to the Type tool with the caret where it was clicked.
  - **Temporary tools:** Cmd with any other tool drags with the selection tool used last (Selection, Direct Selection or Group Selection). Held Space pans and Cmd+Space zooms (Cmd+Alt+Space out) whatever the tool.
  - **Panel drag and drop:** art dragged off the canvas onto the Symbols panel becomes a symbol, onto the Swatches panel a pattern swatch and onto the Brushes panel an Art brush; a symbol dragged onto the canvas places an instance where it is dropped, and a brush dragged onto a path is applied to it.
-  - **Tool double-clicks:** double-clicking a tool's button opens its options: Hand fits the artboard in the window, Zoom shows 100 %, Rotate, Scale, Reflect and Shear open their Object › Transform dialogs, the Selection, Direct Selection and Group Selection tools the Move dialog (Enter opens these seven tools' dialogs too), Gradient, Eyedropper, Blend and the Liquify tools their panels or options.
+  - **Tool double-clicks:** double-clicking a tool's button opens its options: Hand fits the artboard in the window, Zoom shows 100 %, Rotate, Scale, Reflect and Shear open their Object › Transform dialogs, the Selection, Direct Selection and Group Selection tools the Move dialog (Enter opens these seven tools' dialogs too), Gradient, Eyedropper, Blend and the Liquify tools their panels or options, and the Pencil, Paintbrush, Smooth, Blob Brush and Eraser tools their Tool Options (Fidelity, fill, the tolerances, the brush size).
 - **Layers panel:** every layer, sublayer, group and object is a clickable row at any depth: a click highlights it and makes its layer current (new art goes there), Shift-click a range, Ctrl/Cmd-click toggles. Sublayers are no longer treated as objects: clicks, marquees, Select All and the Select menu take the art inside them, and each sublayer selects in its own colour. Selection squares on rows with selected art (click selects a row's art, Shift adds or removes; dragging the square moves the selection to another row, Alt copies), the eye and lock on every row with drag-down-the-column (one undo step), Ctrl/Cmd-click an eye for per-layer Outline, Alt-click an eye or lock to hide or lock the other layers (again: show or unlock them all), triangles with Alt to open or close everything inside, drag and drop rows above, below or into layers and groups with a drop line (Alt copies, the trash deletes), inline rename, Delete key on highlighted rows. Buttons and the full panel menu: New Layer/Sublayer (Alt: options, Ctrl: on top), Duplicate, Delete, Options for Selection, clipping mask, isolation, Locate Object, Merge Selected, Flatten Artwork, Collect in New Layer, Release to Layers (Sequence and Build), Reverse Order, Template, Hide/Outline/Lock Others and Show/Preview/Unlock All, Paste Remembers Layers, Panel Options (row size, thumbnails per kind, Show Layers Only). Layer Options: name, colour (presets or custom), Template, Lock, Show, Print, Preview (outline drawing and clicking) and Dim Images to %. Every operation is a command (`layer.move`, `layer.highlight`, `layer.merge`…) with validation against cycles and invalid nesting.
- **Drawing aids:** Smart Guides and snapping (moving, and resizing by the bounding-box handles: the dragged edges align with the other objects; the Artboard tool snaps artboards, and their bleed, to other artboards, bleeds and art, the grid or whole pixels while moving, copying and resizing them, and the Transform panel shows and edits the active artboard's X/Y/W/H), guides dragged out of the rulers, and Draw Normal / Behind / Inside modes.
+- **Drawing aids:** Smart Guides and snapping (moving, and resizing by the bounding-box handles: the dragged edges align with the other objects; the Artboard tool snaps artboards, and their bleed, to other artboards, bleeds and art, the grid or whole pixels while moving, copying and resizing them, and the Transform panel shows and edits the active artboard's X/Y/W/H), guides dragged out of the rulers (Shift snaps them to the ruler's ticks) that the Selection, Direct Selection and Group Selection tools then pick and drag (#414: the selected guides highlight and move together, Alt copies them, Shift snaps the dragged one to the ticks, otherwise it snaps to pixels, the grid or the art's edges, centres and anchors; the arrow keys nudge them, Delete deletes them, dragging one back onto its ruler deletes it, Lock Guides and Hide Guides leave them alone; `guide.list`, `guide.select`, `guide.move` and `guide.remove` reach agents), and Draw Normal / Behind / Inside modes.
 - **Views:** the status bar's artboard navigator (first, previous, next, last; `view.goToArtboard`) goes to an artboard and fits it, and Fit Artboard in Window and Actual Size show the navigator's artboard. The Artboards panel highlights that active artboard: clicking a row makes it active (the Artboard tool's too, while it is chosen) as does clicking an artboard with the Artboard tool, double-clicking its number also fits it in the window and double-clicking its name renames it.
 - **Geometry and effects:**
  - Pathfinder (10 exact curve booleans), Offset, Outline Stroke, Simplify, Clean Up, Split Into Grid, Divide Objects Below. Object › Path › Remove Anchor Points (`path.removeAnchors`) removes the direct-selected anchors without opening their paths (the Delete key still deletes them with their segments): the neighbours keep their handle directions and their facing handles are refitted so one cubic follows the two old segments, and straight sides stay straight. The Delete Anchor Point tool uses the same refit. The Control bar, the contextual task bar, the Properties quick actions and the canvas context menu offer it when anchors are selected.
  - Live effects with previewing dialogs: Distort & Transform, Path, Convert to Shape, 15 Warp styles, Round Corners, Scribble, Effect → Pathfinder (all 10 operations, live on groups; several loose objects are grouped first, in one undo step), Color Adjustments (Brightness/Contrast, Curves, Levels, Hue/Saturation, Shift to Color, Temperature/Tint, on vectors, live type and embedded images), and raster drop shadow, glows and feather. SVG and PDF export keep live effects (geometry baked; SVG raster effects as filters).
 - **Type:** Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity), Character and Paragraph Styles (override-preserving redefine), Area Type Options (rows/columns/inset/first baseline), threaded text across any closed shapes, Fit Headline. Area type resizes like Illustrator's type areas: a bounding-box handle drag (Selection tool) or Area Type Options Width/Height size the frame and the text reflows at its size (threads too); Direct Selection drags a frame corner or edge (`text.reshapeArea`). Point type still scales. Variable fonts list every named instance as a style of their family (Figtree Light to Black and their italics, Bahnschrift, Segoe UI Variable), and the instance chosen is shaped, drawn, outlined and measured at its axis settings; PDF and SVG embed it as that instance. Variation axis sliders are not done. Hebrew and Arabic are laid out right to left with the Unicode bidirectional algorithm (embedded Latin and numbers keep their direction, lines put in visual order after wrapping) in point, area and path type, with caret, selection and arrow keys in visual order; each paragraph's direction comes from its first strong character unless Paragraph Direction sets it (Paragraph panel with Show Indic Options, `text.setFormat {direction}`), and new type aligns to the start of its direction. SVG export outlines right-to-left text.
- **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese and Spanish (neutral international Spanish, for every `es-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech and Spanish ones from the bundled UI fonts. The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline; Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines.
+- **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese and Spanish (neutral international Spanish, for every `es-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech and Spanish ones from the bundled UI fonts. The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline; Character panel menu › Character Alignment (with the East Asian options; `text.setFormat` or `text.setRangeStyle {charAlign}`) lines characters smaller than the largest on their line up on the Roman baseline or the em box top/right, centre or bottom/left (ICF top and bottom not yet); Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines.
 - **Transparency:** opacity masks (clip/invert/disable/link), exported as SVG `<mask>` and PDF soft masks.
 - **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder (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):**
@@ -147,7 +149,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
  - `.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).
  - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs Illustrator's AGM/CoolType prologs (resource categories, `resourceforall`, `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters, `cshow`, metadata skipped with `flushfile`), so Illustrator 30 EPS files open as vectors, and falls back to its palette TIFF preview. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole).
-  - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours.
+  - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours; files copied in a file manager paste as art (SVG, PDF, EMF/WMF, bitmaps) on every desktop platform, and Linux/Wayland reads the compositor's clipboard (#398).
 - **Performance:** 20k shapes + 1k texts render in 27 ms per full-retina frame (7.8 ms zoomed), 7× faster than the first version. The UI thread never blocks. The web build is 7.1 MB gzipped.
 - **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so the desktop app asks for the power-saving GPU by default (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306). Preferences › Performance › Graphics Processor (`gpuPreference`) or `WGPU_POWER_PREF` picks the discrete one; Help › About and `ui.inspect` name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369).
 - **Tests and robustness:** ~2,840 automated tests: model-based property tests, a junk-parameter sweep over every command, import fuzzing (SVG, PDF, libraries), golden renders, and MCP end-to-end tests over stdio. Shipped code never panics (workspace lints and a rollback safety net; see `docs/development.md`).
@@ -163,7 +165,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 | M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | ✅ done (M4.14–M4.98 on 2026-10-05): Save As/Save a Copy/Revert/templates, Data Recovery and background save, SVG import and export fidelity (units, text, symbols, filters, SVGZ, Preserve Editing, SVG Options), PDF import (colours, layers, masks, editable text, security) and export (presets, marks, bleed, ICC and output intent, raster effects, subset fonts, PDF/X-1a, X-3 and X-4, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3), Place and Links, Package, EPS and DXF in and out, EMF/WMF, TIFF/BMP/Targa/PSD/GIF/PNG-8 export, Print and print presets, slices, Save for Web, Asset Export, clipboard flavours, File Info. Left: DWG (use DXF), PSD placement as layers, overprint read back from PDF, polish | 3–6 |
 | M5 | Performance | 🟡 background render + caches + MT done; `vectorcraft-cli bench` and `vectorcraft-cli perf` (budget suite); file format v2 opens 3× faster (50k paths: 722 → 244 ms); raster effects (glows, shadows, blur, feather) no longer force the whole frame single-threaded (filtered offscreen per effect, verified equal to the single-threaded reference); effect-heavy demos need a clean-machine benchmark; dirty-region rendering, GPU backend spike pending | 15–25 |
 | M6 | Path operations (Pathfinder, Shape Builder, offset…) | ✅ mostly done (Boolean precision on almost-horizontal edges fixed and the property tests made deterministic; Shape Builder gap detection, large-offset bug open) | 3–6 |
-| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options (with Width/Height), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, filter by script and kind, list a family's styles, and star favourites) and found by name on open/import, variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects, tab stops + Tabs panel, Hebrew/Arabic bidirectional text and Paragraph Direction done; tab leaders, spell check, vertical type pending | 45–60 |
+| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options (with Width/Height), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import, variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects, tab stops + Tabs panel, Hebrew/Arabic bidirectional text and Paragraph Direction done; tab leaders, spell check, vertical type pending | 45–60 |
 | M8 | Transform & distort (Puppet Warp, Liquify tools, Envelopes, Blends, Perspective Grid) | ✅ done (M8.1–M8.20 on 2026-10-06, fidelity pass): Liquify Tool Options with one shared brush, pen pressure, hold-to-apply, a safe scope and incremental strokes; tool options that last; Puppet Warp rotation, multi-select, Control bar and a rest-shape session that follows Undo; Width tool on compound paths; Envelope dialogs with preview, Reset with Warp/Mesh, full Envelope Options, type/images/symbols/appearance/gradients/patterns distorted on canvas and in every export, warps that keep their frame, Edit Contents, mesh handles and Control bar; Blend Options, anchor-targeted Blend tool, editable spine, keys picked on the canvas, faithful interpolation and knockout; Perspective Grid with Define Grid, presets, lock/snap/rulers, widgets, the 1–4 plane switch, movable planes, Perspective Selection scale/copy/perpendicular/Transform Again, and type and symbols truly projected with Edit Text. Left: Anti-Alias and Preserve Shape output, warp-envelope point editing, brush interpolation in blends, Free Transform/Scale/Reflect along a rotated box | 2–4 |
 | M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder and Color Adjustments; SVG Filters, Document Raster Effects Settings, 3D pending | 86–135 |
 | M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG `<pattern>`/PDF export) and live Repeat (radial/grid/mirror) done; brushes/symbols in progress | 23–37 |
@@ -190,7 +192,7 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Area | Weight | Done | Missing (main items) | One agent (h) |
 |---|---:|---:|---|---:|
 | Selection, transform & align tools | 6 | 85% | Free Transform/Scale/Reflect along a rotated box, Start Global Edit, transform nuances (the rotated persistent bounding box is done) | 4–6 |
-| Drawing tools | 7 | 85% | Shaper Groups (merge/punch overlapping shapes), pencil and the remaining pen modifier nuances, Touch Type, Live Corners on plain paths and polygons (and Relative rounding) | 10–15 |
+| Drawing tools | 7 | 85% | Shaper Groups (merge/punch overlapping shapes), pencil and the remaining pen modifier nuances, the freehand Tool Options' Keep selected, Alt to the Smooth tool, Blob Brush Merge Only with Selection and brush angle/roundness, Touch Type, Live Corners on plain paths and polygons (and Relative rounding) | 10–15 |
 | Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 86% | Live Paint gap options, Shape Builder gap detection and options | 3–6 |
 | Colour, swatches, gradients, patterns, mesh, recolor | 7 | 96% | freeform and mixed spot/process gradients in SVG/PDF (exported as stops or process colours), pattern fills in Expand | 2–4 |
 | Strokes, brushes, width profiles | 5 | 88% | brush options depth, brush libraries (generated in code), brushes driven by pen tilt, bearing and barrel rotation (6D art pens) | 12–20 |
@@ -199,17 +201,17 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Raster effects (Effect Gallery, Document Raster Effects Settings) | 4 | 20% | ~55 Photoshop-style filters (Artistic, Brush Strokes, Distort, Pixelate, Sketch, Stylize, Texture, Video) and the Effect Gallery; Document Raster Effects Settings and raster effects in PDF are done | 28–42 |
 | 3D and Materials | 4 | 0% | Extrude & Bevel, Revolve, Inflate, Rotate, lighting, materials (software renderer) | 50–80 |
 | Type core | 9 | 79% | Middle Eastern features beyond bidi layout and Paragraph Direction (Character Direction, digit types, kashidas, the Middle Eastern composers, editable bidirectional SVG text, a split caret where directions meet); composer/hyphenation options, Optical Margin Alignment, hidden characters, Transform Again after a type-area resize (it scales the type), partial selection of type-area anchors by marquee | 15–20 |
-| Type advanced | 4 | 50% | CJK composition for vertical type (ruby, mojikumi beyond Line-end Punctuation Half Width — hanging punctuation, line-start brackets, kinsoku sets and the Mojikumi Settings dialog —, proportional vertical metrics, manual tate-chu-yoko), variable font axis sliders (named instances are styles), tab leaders, spell check (open dictionary), Touch Type, Retype; vertical point/area/path type and Type Orientation have initial support | 20–28 |
+| Type advanced | 4 | 50% | CJK composition for vertical type (ruby, mojikumi beyond Line-end Punctuation Half Width — hanging punctuation, line-start brackets, kinsoku sets and the Mojikumi Settings dialog —, proportional vertical metrics, manual tate-chu-yoko, Character Alignment on the ICF top and bottom), variable font axis sliders (named instances are styles), tab leaders, spell check (open dictionary), Touch Type, Retype; vertical point/area/path type and Type Orientation have initial support | 20–28 |
 | Symbols, blends, envelopes, Repeat, perspective | 5 | 88% | symbol libraries (original), dynamic symbols, envelope Anti-Alias/Preserve Shape output and warp point editing, brush interpolation in blends (M8 fidelity pass done) | 5–8 |
 | Image Trace, graphs, image tools | 3 | 70% | graph Design/Column/Marker, Create Object Mosaic, Crop Image polish (Vector Halftone is done) | 6–10 |
 | Layers, artboards, document setup | 5 | 82% | Layers panel: a confirmation before deleting layers that hold art, Collect for Export, row context menus, the Layer Options dialog for several rows with mixed values, Paste Remembers Layers for sublayers, drag-scrolling a long panel while dragging rows; artboard presets/rearrange polish (Document Setup, New Document and the rest of the Layers panel are done) | 4–7 |
 | View & navigation | 3 | 70% | New View/Edit Views, multiple windows/arrange, Snap to Pixel/Glyph (print tiling is done) | 9–14 |
-| Guides, grids, smart guides, snapping, rulers | 3 | 75% | global/video rulers, smart-guide preference depth, ruler-drag modifiers (Shift snaps to ticks, Alt swaps orientation) and dragging existing guides | 4–8 |
+| Guides, grids, smart guides, snapping, rulers | 3 | 80% | global/video rulers, smart-guide preference depth, Alt swapping a ruler guide's orientation, ruler guides selected together with art (marquee, Shift-click) and on layers (dragging existing guides is done, #414) | 3–6 |
 | File formats | 6 | 85% | DWG (no open spec: DXF instead), PSD placement as layers, Illustrator EPS checked against more real files (two Illustrator 30 files open as vectors so far), the remaining fidelity polish; EPS, DXF, EMF/WMF, TIFF, BMP, Targa, PSD export, SVGZ, PDF security, PDF/X, PDF layers and presets are done | 6–10 |
 | Export for Screens, Asset Export, slices, Save for Web | 3 | 85% | polish only (all four are done) | 2–4 |
 | Print, colour management, separations, flattener | 3 | 80% | print preview fidelity (flattener presets in PDF and print, overprint in PDF and composite print, Print dialog, presets, PostScript, marks, separations, Print Tiling, print overprint/flattener/bitmap options and printer profile are done) | 1–2 |
 | Automation | 3 | 60% | Variables (data merge), scripting surface, batch | 8–12 |
-| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 78% | Variables, SVG Interactivity, Properties per context, Consolidate All Windows, context menus beyond the canvas (Links, Asset Export, CSS Properties, Attributes and the canvas context menu are done) | 15–25 |
+| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 78% | Variables, SVG Interactivity, Properties per context, Consolidate All Windows, context menus beyond the canvas (Links, Asset Export, CSS Properties, Attributes and the canvas context menu are done), about 55 Preferences options stored but not yet acted on (#394: smart guide display options, type increments and options, units, Show Pixel Grid, Snap to Point, rubber band, handle style, performance, devices…) | 18–28 |
 | 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 |
@@ -160,6 +160,27 @@ fn mcp_protocol_over_stdio() {
    send(&mut stdin, json!({"jsonrpc":"2.0","id":10,"method":"resources/read","params":{"uri":"vectorcraft://object/"}}));
    assert_eq!(recv(&mut lines, &mut notes, 10)["error"]["code"], -32602);

+    // Large containers slice through run_command document.node: a truncated level reports
+    // childCount, and a bad limit is a tool error, not a crash or a full read.
+    send(
+        &mut stdin,
+        json!({"jsonrpc":"2.0","id":20,"method":"tools/call","params":{"name":"draw_shape","arguments":{"shape":"ellipse","x":90,"y":10,"width":30,"height":30}}}),
+    );
+    assert_eq!(recv(&mut lines, &mut notes, 20)["result"]["isError"], false);
+    let run = |id: u64, command: &str, params: Value| json!({"jsonrpc":"2.0","id":id,"method":"tools/call","params":{"name":"run_command","arguments":{"command":command,"params":params}}});
+    send(&mut stdin, run(21, "select.all", json!({})));
+    recv(&mut lines, &mut notes, 21);
+    send(&mut stdin, run(22, "object.group", json!({})));
+    let r = recv(&mut lines, &mut notes, 22);
+    let group = serde_json::from_str::<Value>(r["result"]["content"][0]["text"].as_str().unwrap()).unwrap()["id"].clone();
+    send(&mut stdin, run(23, "document.node", json!({"id": group, "summary": true, "childLimit": 1})));
+    let r = recv(&mut lines, &mut notes, 23);
+    let sliced: Value = serde_json::from_str(r["result"]["content"][0]["text"].as_str().unwrap()).unwrap();
+    assert_eq!(sliced["children"].as_array().map(Vec::len), Some(1), "{sliced}");
+    assert_eq!(sliced["childCount"], 2, "{sliced}");
+    send(&mut stdin, run(24, "document.node", json!({"id": group, "summary": true, "depth": -1})));
+    assert_eq!(recv(&mut lines, &mut notes, 24)["result"]["isError"], true);
+
    // 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"}}));
@@ -26,7 +26,8 @@ log = { workspace = true }

 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 rfd = { workspace = true }
-arboard = { workspace = true, features = ["image-data"] }
+# wayland-data-control: native Wayland clipboard (Linux; X11 through XWayland only sees what X11 apps copied).
+arboard = { workspace = true, features = ["image-data", "wayland-data-control"] }
 image = { workspace = true }
 webbrowser = { workspace = true }
 # The window's monitors, size and position (the same winit eframe runs on).
@@ -4,11 +4,16 @@
 //! - Windows: text, SVG, PDF, PNG and an opaque bitmap (for apps that don't read PNG) in one go;
 //!   Paste reads each of them.
 //! - macOS and Linux: one format at a time, the text (a type-only copy's text or the SVG markup),
-//!   else the PNG as a bitmap; Paste reads text and bitmaps.
+//!   else the PNG as a bitmap; Paste reads text and bitmaps. On Wayland, arboard's data-control
+//!   backend reads the compositor's clipboard (X11 through XWayland only sees what X11 apps
+//!   copied), falling back to X11 where the compositor lacks the protocol.
+//! - Everywhere: files copied in a file manager paste as the first one that is art (SVG, PDF, a
+//!   metafile or a bitmap), before the clipboard's other formats (the files' paths as text).

-use std::io::Cursor;
+use std::io::{Cursor, Read};
+use std::path::PathBuf;

-use vectorcraft_engine::cmd::clipboard::{BITMAP, Flavour, PNG, TEXT};
+use vectorcraft_engine::cmd::clipboard::{BITMAP, FILE_HEAD, Flavour, PNG, TEXT, file_flavour};
 use vectorcraft_ui_egui::SystemClipboard;

 /// This platform's system clipboard.
@@ -29,6 +34,23 @@ fn decode_png(png: &[u8]) -> Option<image::RgbaImage> {
    Some(image::load_from_memory_with_format(png, image::ImageFormat::Png).ok()?.to_rgba8())
 }

+/// The first of `paths` (files copied in a file manager) that pastes as one of `mimes`, read
+/// whole. Only its first bytes are read to tell, so other files cost little.
+fn copied_file(paths: Vec<PathBuf>, mimes: &[&'static str]) -> Option<Flavour> {
+    paths.into_iter().find_map(|path| {
+        // text/uri-list lines end in CRLF (RFC 2483), but arboard splits them on LF only.
+        let path = match path.to_str() {
+            Some(p) if p.ends_with('\r') => PathBuf::from(p.trim_end_matches('\r')),
+            _ => path,
+        };
+        let mut head = Vec::with_capacity(FILE_HEAD);
+        std::fs::File::open(&path).ok()?.take(FILE_HEAD as u64).read_to_end(&mut head).ok()?;
+        let mime = file_flavour(&path.to_string_lossy(), &head, mimes)?;
+        let data = std::fs::read(&path).ok()?;
+        (!data.is_empty()).then_some(Flavour { mime, data })
+    })
+}
+
 #[cfg(windows)]
 mod win {
    use std::num::NonZeroU32;
@@ -123,16 +145,26 @@ mod win {
        }

        fn read(&mut self, mimes: &[&'static str]) -> Option<Flavour> {
-            let _open = clipboard_win::Clipboard::new_attempts(10).ok()?;
-            mimes.iter().find_map(|m| read_one(m))
+            let mut files = vec![];
+            {
+                let _open = clipboard_win::Clipboard::new_attempts(10).ok()?;
+                // None copied when the clipboard holds no file list.
+                let _ = raw::get_file_list_path(&mut files);
+            }
+            // The files are read with the clipboard closed again, not keeping other apps waiting.
+            copied_file(files, mimes).or_else(|| {
+                let _open = clipboard_win::Clipboard::new_attempts(10).ok()?;
+                mimes.iter().find_map(|m| read_one(m))
+            })
        }

        fn has(&mut self, mimes: &[&'static str]) -> bool {
-            mimes.iter().any(|m| match *m {
-                TEXT => raw::is_format_avail(formats::CF_UNICODETEXT),
-                BITMAP => raw::is_format_avail(formats::CF_BITMAP) || formats_of(PNG).any(raw::is_format_avail),
-                m => formats_of(m).any(raw::is_format_avail),
-            })
+            raw::is_format_avail(formats::CF_HDROP)
+                || mimes.iter().any(|m| match *m {
+                    TEXT => raw::is_format_avail(formats::CF_UNICODETEXT),
+                    BITMAP => raw::is_format_avail(formats::CF_BITMAP) || formats_of(PNG).any(raw::is_format_avail),
+                    m => formats_of(m).any(raw::is_format_avail),
+                })
        }
    }

@@ -245,6 +277,9 @@ mod portable {

        fn read(&mut self, mimes: &[&'static str]) -> Option<Flavour> {
            let cb = self.cb().ok()?;
+            if let Some(f) = cb.get().file_list().ok().and_then(|paths| copied_file(paths, mimes)) {
+                return Some(f);
+            }
            mimes.iter().find_map(|m| match *m {
                TEXT => cb.get_text().ok().filter(|t| !t.is_empty()).map(|t| Flavour { mime: TEXT, data: t.into_bytes() }),
                BITMAP => {
@@ -262,3 +297,48 @@ mod portable {
        }
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use vectorcraft_engine::cmd::clipboard::{PASTE_ORDER, SVG};
+
+    use super::*;
+
+    fn dir(name: &str) -> PathBuf {
+        let d = std::env::temp_dir().join(format!("vectorcraft-clipboard-{name}-{}", std::process::id()));
+        std::fs::create_dir_all(&d).unwrap();
+        d
+    }
+
+    fn png(w: u32, h: u32) -> Vec<u8> {
+        let mut out = vec![];
+        image::RgbaImage::new(w, h).write_to(&mut Cursor::new(&mut out), image::ImageFormat::Png).unwrap();
+        out
+    }
+
+    #[test]
+    fn the_first_copied_file_that_is_art_pastes() {
+        let d = dir("art");
+        let (notes, red, art) = (d.join("notes.txt"), d.join("red image.png"), d.join("art.svg"));
+        std::fs::write(&notes, "not art").unwrap();
+        std::fs::write(&red, png(3, 2)).unwrap();
+        std::fs::write(&art, "<svg xmlns=\"http://www.w3.org/2000/svg\"/>").unwrap();
+        // Missing files, folders and text are skipped.
+        let f = copied_file(vec![d.join("gone.png"), d.clone(), notes.clone(), red.clone(), art.clone()], &PASTE_ORDER).unwrap();
+        assert_eq!((f.mime, f.data), (PNG, png(3, 2)));
+        assert_eq!(copied_file(vec![art.clone(), red.clone()], &PASTE_ORDER).map(|f| f.mime), Some(SVG));
+        // Only what Paste asks for.
+        assert_eq!(copied_file(vec![art, red.clone()], &[BITMAP]).map(|f| f.mime), Some(PNG));
+        assert!(copied_file(vec![red], &[TEXT]).is_none());
+        assert!(copied_file(vec![notes], &PASTE_ORDER).is_none());
+        assert!(copied_file(vec![], &PASTE_ORDER).is_none());
+    }
+
+    #[test]
+    fn a_crlf_left_by_the_uri_list_is_ignored() {
+        let red = dir("crlf").join("red.png");
+        std::fs::write(&red, png(2, 2)).unwrap();
+        let with_cr = PathBuf::from(format!("{}\r", red.display()));
+        assert_eq!(copied_file(vec![with_cr], &PASTE_ORDER).map(|f| f.mime), Some(PNG));
+    }
+}
@@ -61,7 +61,7 @@ impl eframe::App for App {
                self.menu = Some(native_menu::NativeMenu::install(&mut self.app));
            }
            if let Some(m) = &mut self.menu {
-                m.poll(&mut self.app);
+                m.poll(&mut self.app, ctx);
            }
            open_files(&mut self.app, open_documents::take());
        }
@@ -33,7 +33,7 @@ pub struct NativeMenu {
 }

 /// Accelerator for a shortcut like "Cmd+Shift+]" (modifier-less shortcuts stay in the app so they
-/// don't steal keys from text fields).
+/// don't steal keys from text fields; a focused field still gets Cmd+A/X/C/V, see [`NativeMenu::poll`]).
 fn accel(sc: &str) -> Option<Accelerator> {
    if !(sc.contains("Cmd") || sc.contains("Ctrl") || sc.contains("Alt") || sc.starts_with('F')) {
        return None;
@@ -72,12 +72,13 @@ impl NativeMenu {
        }
    }

-    /// Dispatch clicked items and refresh state.
-    pub fn poll(&mut self, app: &mut VectorcraftApp) {
+    /// Dispatch chosen items (a focused text field takes Select All and the clipboard) and refresh
+    /// state.
+    pub fn poll(&mut self, app: &mut VectorcraftApp, ctx: &egui::Context) {
        while let Ok(ev) = MenuEvent::receiver().try_recv() {
            if let Some((cmd, params, _, _)) = self.items.get(ev.id.as_ref()) {
                let p = if params.is_null() { serde_json::json!({}) } else { params.clone() };
-                menus::invoke(app, cmd, p);
+                menus::invoke_from_system_menu(app, ctx, cmd, p);
            }
        }
        let now = vectorcraft_ui_egui::now_ms();
@@ -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
+    }
+  ]
+}
@@ -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
@@ -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);
@@ -78,8 +78,8 @@ pub use setup::{Background, DocSetup, ExportText, GridSize, Quotes};
 pub use slices::{CellAlign, CellVAlign, Slice, SliceArea, SliceKind, SliceOptions, SliceSource};
 pub use style_libs::StyleLibrary;
 pub use text::{
-    AreaOptions, CharPosition, CharStyle, FirstBaseline, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathEffect, ScriptMetrics,
-    TabAlign, TabStop, TextKind, TextObject, TextRun, TextStyleDef, TextWrap, WrapShape,
+    AreaOptions, CharAlign, CharPosition, CharStyle, FirstBaseline, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathEffect,
+    ScriptMetrics, TabAlign, TabStop, TextKind, TextObject, TextRun, TextStyleDef, TextWrap, WrapShape,
 };
 pub use vectorcraft_color as color;
 pub use vectorcraft_geom as geom;
@@ -167,6 +167,18 @@ impl Unit {
            Unit::Feet => "Feet",
        }
    }
+    /// The rulers' label step at `zoom` (screen pixels per point), in this unit: the first of
+    /// 1, 2, 5 × 10ⁿ that puts labels at least 50 pixels apart. Ticks mark every tenth of it.
+    pub fn ruler_step(self, zoom: f64) -> f64 {
+        const STEPS: [f64; 19] =
+            [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 25.0, 50.0, 100.0, 200.0, 500.0, 1000.0, 2000.0, 5000.0, 10000.0];
+        STEPS.iter().copied().find(|s| s * self.points() * zoom >= 50.0).unwrap_or(10000.0)
+    }
+    /// `v` (points) on the nearest ruler tick at `zoom` ([`Self::ruler_step`]).
+    pub fn snap_to_ruler_tick(self, v: f64, zoom: f64) -> f64 {
+        let tick = self.ruler_step(zoom) / 10.0 * self.points();
+        (v / tick).round() * tick
+    }
    pub fn from_pt(self, v: f64) -> f64 {
        v / self.points()
    }
@@ -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();
@@ -86,6 +86,23 @@ pub struct CharStyle {
    /// size (Document Setup → Type → Small Caps); None = off.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub small_caps: Option<f64>,
+    /// Character Alignment (Character panel menu): where characters smaller than the largest on
+    /// their line line up with it.
+    #[serde(default, rename = "charAlign", skip_serializing_if = "crate::skip::is_default")]
+    pub char_align: CharAlign,
+}
+
+/// Where a character smaller than the largest on its line lines up with it: on the Roman
+/// baseline, or at the top (right, in vertical type), centre or bottom (left) of the ideographic
+/// em boxes.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum CharAlign {
+    #[default]
+    RomanBaseline,
+    EmBoxTop,
+    EmBoxCenter,
+    EmBoxBottom,
 }

 /// Superscript or subscript proportions in percent of the font size (Document Setup → Type).
@@ -178,6 +195,7 @@ impl Default for CharStyle {
            stroke_miter_limit: 10.0,
            stroke_dash: None,
            position: CharPosition::Normal,
+            char_align: CharAlign::RomanBaseline,
            small_caps: None,
        }
    }
@@ -21,7 +21,7 @@ use vectorcraft_color::Swatch;
 use vectorcraft_doc::{Document, GraphicStyle, ImageBlob, Node, NodeId, PatternDef, Symbol, TextStyleDef};
 use vectorcraft_geom::Rect;

-pub use flavours::{BITMAP, EMF, Flavour, PASTE_ORDER, PDF, PNG, SVG, TEXT};
+pub use flavours::{BITMAP, EMF, FILE_HEAD, Flavour, PASTE_ORDER, PDF, PNG, SVG, TEXT, file_flavour};
 pub(crate) use resources::SwatchChoices;

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

 /// One representation of the clipboard's contents.
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -155,8 +155,34 @@ pub fn specs() -> Vec<CommandSpec> {
            clear_guides
        ),
        cmd!("guide.add", "Add Guide", [], None, "{vertical: bool, pos: pt (x for vertical, y for horizontal)} → {index}", has_doc, guide_add),
-        cmd!("guide.remove", "Remove Guide", [], None, "{index}", guides_unlocked, guide_remove),
-        cmd!("guide.move", "Move Guide", [], None, "{index, pos: pt}", guides_unlocked, guide_move),
+        cmd!(query "guide.list", "Guides", [], None, "{} → [{index, vertical, pos, selected}…] the ruler guides", has_doc, guide_list),
+        cmd!(
+            "guide.select",
+            "Select Guides",
+            [],
+            None,
+            "{indexes: [index…], toggle?: bool} select ruler guides on their own (deselecting the art); toggle adds or removes them instead → {selected: [index…]}",
+            guides_unlocked,
+            guide_select
+        ),
+        cmd!(
+            "guide.remove",
+            "Remove Guide",
+            [],
+            None,
+            "{index?} delete ruler guide `index`, else the selected ones (as Delete / edit.clear does) → {count}",
+            guides_unlocked,
+            guide_remove
+        ),
+        cmd!(
+            "guide.move",
+            "Move Guide",
+            [],
+            None,
+            "{index, pos: pt} put ruler guide `index` at `pos` | {dx?, dy?: pt, copy?: bool} move the selected guides (vertical ones by dx, horizontal ones by dy); copy leaves them and selects the moved copies",
+            guides_unlocked,
+            guide_move
+        ),
        cmd!("file.closeAll", "Close All", ["File"], Some("Cmd+Alt+W"), "{} → {closed}", has_doc, close_all),
        cmd!(
            "file.documentColorMode",
@@ -428,6 +454,10 @@ fn release_guides(s: &mut Session, _: &Value) -> Result<Value> {
 fn lock_guides(s: &mut Session, p: &Value) -> Result<Value> {
    let v = p.get("locked").and_then(Value::as_bool).unwrap_or(!s.menu.guides_locked);
    s.menu.guides_locked = v;
+    // Locked guides can't stay selected.
+    if v && !s.doc()?.selection.guides.is_empty() {
+        s.select(|_, sel| sel.guides.clear())?;
+    }
    Ok(json!({ "locked": v }))
 }

@@ -458,28 +488,95 @@ fn guide_add(s: &mut Session, p: &Value) -> Result<Value> {
    Ok(json!({ "index": i }))
 }

-fn guide_index(s: &Session, p: &Value, cmd: &str) -> Result<usize> {
-    let i = p.get("index").and_then(Value::as_u64).ok_or_else(|| bad(cmd, "missing index"))? as usize;
+fn guide_list(s: &mut Session, _: &Value) -> Result<Value> {
+    let st = s.doc()?;
+    let row = |(i, g): (usize, &Guide)| json!({ "index": i, "vertical": g.vertical, "pos": g.pos, "selected": st.selection.guides.contains(&i) });
+    Ok(Value::Array(st.doc.guides.iter().enumerate().map(row).collect()))
+}
+
+/// Ruler guide `index` of the active document (`index` validated).
+fn guide_index(s: &Session, v: Option<&Value>, cmd: &str) -> Result<usize> {
+    let i = v.and_then(Value::as_u64).and_then(|i| usize::try_from(i).ok()).ok_or_else(|| bad(cmd, "an index must be a whole number"))?;
    if i >= s.doc()?.doc.guides.len() {
-        return Err(bad(cmd, "no such guide"));
+        return Err(bad(cmd, format!("no guide {i}")));
    }
    Ok(i)
 }

-fn guide_remove(s: &mut Session, p: &Value) -> Result<Value> {
-    let i = guide_index(s, p, "guide.remove")?;
-    s.edit("Delete Guide", |d, _| {
-        d.guides.remove(i);
-        Ok(())
-    })?;
-    ok()
+fn guide_select(s: &mut Session, p: &Value) -> Result<Value> {
+    let list = p.get("indexes").and_then(Value::as_array).ok_or_else(|| bad("guide.select", "missing indexes"))?;
+    let picked = list.iter().map(|v| guide_index(s, Some(v), "guide.select")).collect::<Result<Vec<_>>>()?;
+    if bool_or(p, "toggle", false) {
+        let mut now = s.doc()?.selection.guides.clone();
+        for i in picked {
+            if let Some(k) = now.iter().position(|g| *g == i) {
+                now.remove(k);
+            } else {
+                now.push(i);
+            }
+        }
+        s.select(|_, sel| sel.set_guides(now))?;
+    } else {
+        s.select(|_, sel| sel.set_guides(picked))?;
+    }
+    Ok(json!({ "selected": s.doc()?.selection.guides }))
 }

-fn guide_move(s: &mut Session, p: &Value) -> Result<Value> {
-    let i = guide_index(s, p, "guide.move")?;
-    let pos = f64_req(p, "pos", "guide.move")?;
-    s.edit("Move Guide", |d, _| {
-        d.guides[i].pos = pos;
+/// Delete ruler guide `index`, else the selected guides, in one undo step → {count}.
+pub(crate) fn guide_remove(s: &mut Session, p: &Value) -> Result<Value> {
+    let gone: Vec<usize> = match p.get("index") {
+        Some(v) => vec![guide_index(s, Some(v), "guide.remove")?],
+        None => s.doc()?.selection.guides.clone(),
+    };
+    if gone.is_empty() {
+        return Err(bad("guide.remove", "no guide selected"));
+    }
+    let label = if gone.len() == 1 { "Delete Guide" } else { "Delete Guides" };
+    s.edit(label, |d, sel| {
+        let kept = |i: &usize| !gone.contains(i);
+        // The guides left selected keep their place among the rest.
+        let left: Vec<usize> = sel.guides.iter().filter(|i| kept(i)).map(|i| i - gone.iter().filter(|g| *g < i).count()).collect();
+        d.guides = std::mem::take(&mut d.guides).into_iter().enumerate().filter(|(i, _)| kept(i)).map(|(_, g)| g).collect();
+        sel.set_guides(left);
+        Ok(())
+    })?;
+    Ok(json!({ "count": gone.len() }))
+}
+
+/// Put ruler guide `index` at `pos`, else move (or copy) the selected guides, in one undo step.
+pub(crate) fn guide_move(s: &mut Session, p: &Value) -> Result<Value> {
+    if let Some(v) = p.get("index") {
+        let i = guide_index(s, Some(v), "guide.move")?;
+        let pos = f64_req(p, "pos", "guide.move")?;
+        s.edit("Move Guide", |d, _| {
+            if let Some(g) = d.guides.get_mut(i) {
+                g.pos = pos;
+            }
+            Ok(())
+        })?;
+        return ok();
+    }
+    let moving = s.doc()?.selection.guides.clone();
+    if moving.is_empty() {
+        return Err(bad("guide.move", "no guide selected (or give an index)"));
+    }
+    let (dx, dy, copy) = (f64_or(p, "dx", 0.0), f64_or(p, "dy", 0.0), bool_or(p, "copy", false));
+    s.edit(if copy { "Copy Guide" } else { "Move Guide" }, |d, sel| {
+        let mut copies = vec![];
+        for &i in &moving {
+            let Some(g) = d.guides.get_mut(i) else { continue };
+            let moved = Guide { vertical: g.vertical, pos: g.pos + if g.vertical { dx } else { dy } };
+            if copy {
+                copies.push(moved);
+            } else {
+                *g = moved;
+            }
+        }
+        if copy {
+            let first = d.guides.len();
+            d.guides.extend(copies);
+            sel.set_guides(first..d.guides.len());
+        }
        Ok(())
    })?;
    ok()
@@ -25,7 +25,7 @@ pub fn specs() -> Vec<CommandSpec> {
        cmd!("file.close", "Close", ["File"], Some("Cmd+W"), "{index?}", has_doc, file_close),
        cmd!("document.activate", "Activate Document", [], None, "{index}", always, doc_activate),
        cmd!(query "document.inspect", "Inspect Document", [], None, "{} → layer tree, artboards, selection, history", has_doc, |s, _| Ok(inspect::document(s))),
-        cmd!(query "document.node", "Inspect Object", [], None, "{id, summary?: the compact document.inspect-style summary instead of the full object JSON} → one object", has_doc, doc_node),
+        cmd!(query "document.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.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 +85,15 @@ pub fn specs() -> Vec<CommandSpec> {
            has_clipboard,
            |s, p| paste(s, p, PasteMode::AllArtboards)
        ),
-        cmd!("edit.clear", "Clear", ["Edit"], Some("Delete"), "{ids?}", has_selection, clear),
+        cmd!(
+            "edit.clear",
+            "Clear",
+            ["Edit"],
+            Some("Delete"),
+            "{ids?} delete the objects `ids`, else the selection (direct-selected anchors, else objects, else ruler guides)",
+            has_selection_or_guides,
+            clear
+        ),
        cmd!("edit.duplicate", "Duplicate", [], None, "{dx?, dy?} duplicate the selection in place (offset optional)", has_selection, duplicate),
    ]
 }
@@ -105,8 +113,26 @@ 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 summary = bool_or(p, "summary", false);
+    if !summary && (opts.depth.is_some() || opts.child_limit.is_some()) {
+        // The full object JSON is never truncated: a slice without `summary` would
+        // otherwise silently return the whole subtree.
+        return Err(bad("document.node", "`depth` and `childLimit` slice the summary: pass `summary: true`"));
+    }
    let n = s.doc()?.doc.node(id).ok_or(EngineError::NoNode(id))?;
-    if bool_or(p, "summary", false) { Ok(inspect::node_summary(n)) } else { Ok(serde_json::to_value(n).unwrap_or(Value::Null)) }
+    if summary { Ok(inspect::node_summary_opts(n, opts)) } else { Ok(serde_json::to_value(n).unwrap_or(Value::Null)) }
+}
+
+/// `depth` / `childLimit` for a summary read: absent (or null) means no limit.
+/// 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) {
+        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"))),
+    };
+    Ok(inspect::SummaryOpts { depth: opt("depth")?, child_limit: opt("childLimit")? })
 }

 /// Document Setup's units (also `document.setup {units}`).
@@ -206,6 +232,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)?,
@@ -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(()) }
@@ -68,8 +68,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(
@@ -268,6 +268,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)
 }
@@ -24,7 +24,7 @@ pub fn specs() -> Vec<CommandSpec> {
            "Character / Paragraph",
            [],
            None,
-            "{ids?|id?, kerning?: 1/1000 em|\"auto\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg, underline?, strikethrough?, allCaps?, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), leftIndent?, rightIndent?, firstLineIndent?, spaceBefore?, spaceAfter?: pt, hyphenate?: bool, mojikumi?: \"none\"|\"lineEndHalf\" (Japanese punctuation spacing), direction?: \"auto\"|\"leftToRight\"|\"rightToLeft\" (paragraph direction; auto: from each paragraph's first strong character), leadingModel?: \"romanBaseline\"|\"emBoxTop\" (leading measured baseline to baseline, or em box top to top)}",
+            "{ids?|id?, kerning?: 1/1000 em|\"auto\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg, underline?, strikethrough?, allCaps?, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), leftIndent?, rightIndent?, firstLineIndent?, spaceBefore?, spaceAfter?: pt, hyphenate?: bool, mojikumi?: \"none\"|\"lineEndHalf\" (Japanese punctuation spacing), direction?: \"auto\"|\"leftToRight\"|\"rightToLeft\" (paragraph direction; auto: from each paragraph's first strong character), leadingModel?: \"romanBaseline\"|\"emBoxTop\" (leading measured baseline to baseline, or em box top to top), charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\" (where characters smaller than the largest on their line line up with it)}",
            has_doc,
            set_format
        ),
@@ -114,11 +114,13 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
        "mojikumi",
        "direction",
        "leadingModel",
+        "charAlign",
    ];
    if !keys.iter().any(|k| p.get(*k).is_some()) {
        return Err(bad(C, "nothing to change"));
    }
    let (position, small_caps) = super::docsetup::script_params(p, &s.doc()?.doc.setup, C)?;
+    let char_align = super::textedit::char_align_param(p, C)?;
    let mojikumi = match p.get("mojikumi") {
        None => None,
        Some(v) => Some(match v.as_str() {
@@ -179,6 +181,9 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
                if let Some(v) = small_caps {
                    st.small_caps = v;
                }
+                if let Some(v) = char_align {
+                    st.char_align = v;
+                }
            }
            let para = &mut t.para;
            if let Some(v) = num("leftIndent") {
@@ -9,7 +9,15 @@ use super::*;

 pub fn specs() -> Vec<CommandSpec> {
    vec![
-        cmd!("select.all", "All", ["Select"], Some("Cmd+A"), "{}", has_doc, all),
+        cmd!(
+            "select.all",
+            "All",
+            ["Select"],
+            Some("Cmd+A"),
+            "{} → {count}; while the Type tool edits text, all of that text instead → {editing, start, end} (byte offsets)",
+            has_doc,
+            all
+        ),
        cmd!("select.allOnArtboard", "All on Active Artboard", ["Select"], Some("Cmd+Alt+A"), "{artboard?: index}", has_doc, all_on_artboard),
        cmd!("select.none", "Deselect", ["Select"], Some("Cmd+Shift+A"), "{}", has_doc, none),
        cmd!("select.reselect", "Reselect", ["Select"], Some("Cmd+6"), "{}", has_doc, reselect),
@@ -107,6 +115,18 @@ fn selectable(d: &Document, iso: Option<NodeId>) -> Vec<NodeId> {
 }

 fn all(s: &mut Session, _: &Value) -> Result<Value> {
+    // While the Type tool edits text, Select All takes all of that text and leaves the art
+    // selection as it is (Illustrator: text cursor in a text object).
+    if s.tool_wants_text() {
+        s.set_tool_option("selectAll", &json!(true));
+        let editing = s.tool_options()["editing"].clone();
+        let id = editing.as_u64().map(NodeId);
+        let end = id.and_then(|id| match &s.doc().ok()?.doc.node(id)?.kind {
+            NodeKind::Text(t) => Some(t.plain_text().len()),
+            _ => None,
+        });
+        return Ok(json!({ "editing": editing, "start": 0, "end": end.unwrap_or(0) }));
+    }
    let st = s.doc()?;
    let ids = selectable(&st.doc, st.isolation);
    s.select(|_, sel| sel.set(ids.iter().copied()))?;
@@ -27,7 +27,7 @@ pub fn specs() -> Vec<CommandSpec> {
            "Character",
            [],
            None,
-            "{id, start?: byte, end?: byte (default: all text), font?, style?, size?: pt, leading?: pt|\"auto\", tracking?, kerning?: 1/1000 em|\"auto\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg, fill?: colour|\"none\", stroke?: colour|\"none\", strokeWidth?: pt, strokeOptions?: {weight?, cap?, join?, miterLimit?, dash?, dashOffset?, alignDashes?} (as stroke.set: the character stroke), underline?, strikethrough?, allCaps?: bool, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), features?: [\"dlig\", \"-liga\", …]} style a character range (runs are split at the range ends) → {id, runs}",
+            "{id, start?: byte, end?: byte (default: all text), font?, style?, size?: pt, leading?: pt|\"auto\", tracking?, kerning?: 1/1000 em|\"auto\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg, fill?: colour|\"none\", stroke?: colour|\"none\", strokeWidth?: pt, strokeOptions?: {weight?, cap?, join?, miterLimit?, dash?, dashOffset?, alignDashes?} (as stroke.set: the character stroke), underline?, strikethrough?, allCaps?: bool, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), features?: [\"dlig\", \"-liga\", …], charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\"} style a character range (runs are split at the range ends) → {id, runs}",
            has_doc,
            set_range_style
        ),
@@ -151,6 +151,7 @@ pub(crate) struct CharChange {
    features: Option<Vec<String>>,
    position: Option<vectorcraft_doc::CharPosition>,
    small_caps: Option<Option<f64>>,
+    char_align: Option<vectorcraft_doc::CharAlign>,
 }

 /// `features: ["dlig", "-liga", …]` → the canonical tag list (differences from the defaults).
@@ -163,6 +164,19 @@ pub(crate) fn features_param(p: &Value, cmd: &str) -> Result<Option<Vec<String>>
    Ok(Some(vectorcraft_text::OtFeatures::default().with_tags(tags).to_tags()))
 }

+/// `charAlign: "romanBaseline"|"emBoxTop"|"emBoxCenter"|"emBoxBottom"` (Character Alignment).
+pub(crate) fn char_align_param(p: &Value, cmd: &str) -> Result<Option<vectorcraft_doc::CharAlign>> {
+    use vectorcraft_doc::CharAlign;
+    let Some(v) = p.get("charAlign").filter(|v| !v.is_null()) else { return Ok(None) };
+    Ok(Some(match v.as_str() {
+        Some("romanBaseline") => CharAlign::RomanBaseline,
+        Some("emBoxTop") => CharAlign::EmBoxTop,
+        Some("emBoxCenter") => CharAlign::EmBoxCenter,
+        Some("emBoxBottom") => CharAlign::EmBoxBottom,
+        _ => return Err(bad(cmd, "`charAlign` must be \"romanBaseline\", \"emBoxTop\", \"emBoxCenter\" or \"emBoxBottom\"")),
+    }))
+}
+
 fn paint_param(p: &Value, k: &str, cmd: &str) -> Result<Option<Paint>> {
    match p.get(k) {
        None | Some(Value::Null) => Ok(None),
@@ -213,6 +227,7 @@ impl CharChange {
            features: features_param(p, cmd)?,
            position,
            small_caps,
+            char_align: char_align_param(p, cmd)?,
        };
        if c.size.is_some_and(|v| v <= 0.0) {
            return Err(bad(cmd, "size must be positive"));
@@ -240,6 +255,7 @@ impl CharChange {
            && self.features.is_none()
            && self.position.is_none()
            && self.small_caps.is_none()
+            && self.char_align.is_none()
    }

    pub(crate) fn apply(&self, st: &mut CharStyle) {
@@ -310,6 +326,9 @@ impl CharChange {
        if let Some(v) = self.small_caps {
            st.small_caps = v;
        }
+        if let Some(v) = self.char_align {
+            st.char_align = v;
+        }
    }
 }

@@ -433,6 +433,32 @@ mod area_tests {
        assert!(serde_json::to_value(&text(&s).para).unwrap().get("leading_model").is_none());
    }

+    #[test]
+    fn character_alignment_is_a_character_attribute_saved_only_when_set() {
+        use vectorcraft_doc::CharAlign;
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+        let id = s.execute("text.create", &json!({"x": 10, "y": 50, "text": "雅楽"})).unwrap()["id"].as_u64().unwrap();
+        let runs = |s: &Session| match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
+            NodeKind::Text(t) => t.runs.clone(),
+            _ => panic!("text"),
+        };
+        assert_eq!(runs(&s)[0].style.char_align, CharAlign::RomanBaseline);
+        assert!(serde_json::to_value(&runs(&s)[0].style).unwrap().get("charAlign").is_none());
+        s.execute("select.set", &json!({"ids": [id]})).unwrap();
+        assert!(s.execute("text.setFormat", &json!({"charAlign": "middle"})).is_err());
+        s.execute("text.setFormat", &json!({"charAlign": "emBoxCenter"})).unwrap();
+        assert!(runs(&s).iter().all(|r| r.style.char_align == CharAlign::EmBoxCenter));
+        assert_eq!(serde_json::to_value(&runs(&s)[0].style).unwrap()["charAlign"], "emBoxCenter");
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(runs(&s)[0].style.char_align, CharAlign::RomanBaseline);
+        // Characters selected with the Type tool: only the range takes it (雅 is 3 bytes).
+        assert!(s.execute("text.setRangeStyle", &json!({"id": id, "start": 3, "end": 6, "charAlign": "top"})).is_err());
+        s.execute("text.setRangeStyle", &json!({"id": id, "start": 3, "end": 6, "charAlign": "emBoxTop"})).unwrap();
+        let aligns: Vec<_> = runs(&s).iter().map(|r| (r.text.clone(), r.style.char_align)).collect();
+        assert_eq!(aligns, [("雅".to_string(), CharAlign::RomanBaseline), ("楽".to_string(), CharAlign::EmBoxTop)]);
+    }
+
    #[test]
    fn new_type_is_composed_with_line_end_half_width_punctuation() {
        use vectorcraft_doc::Mojikumi;
@@ -12,8 +12,23 @@ fn rect_json(r: Option<vectorcraft_geom::Rect>) -> Value {
    }
 }

-/// Compact tree summary of a node (for `document.inspect`).
+/// How much of the subtree a node summary carries.
+#[derive(Clone, Copy, Default)]
+pub struct SummaryOpts {
+    /// Child levels to include (`None`: the whole subtree). `0` is the node alone.
+    pub depth: Option<u64>,
+    /// Children shown per node (`None`: all, top of the stack first). A level that shows
+    /// fewer children than it has reports `childCount`, so truncation is never silent.
+    pub child_limit: Option<u64>,
+}
+
+/// Compact tree summary of a node (for `document.inspect`): the whole subtree.
 pub fn node_summary(n: &Node) -> Value {
+    node_summary_opts(n, SummaryOpts::default())
+}
+
+/// The same summary with [`SummaryOpts`] applied.
+pub fn node_summary_opts(n: &Node, opts: SummaryOpts) -> Value {
    let mut v = json!({
        "id": n.id.0,
        "name": n.display_name(),
@@ -69,7 +84,15 @@ pub fn node_summary(n: &Node) -> Value {
        _ => {}
    }
    if let Some(ch) = n.children() {
-        v["children"] = Value::Array(ch.iter().rev().map(|c| node_summary(c)).collect());
+        let total = ch.len();
+        let take_n = opts.child_limit.map_or(total, |l| l.min(total as u64) as usize);
+        if opts.depth.is_none_or(|d| d > 0) {
+            let next = SummaryOpts { depth: opts.depth.map(|d| d.saturating_sub(1)), child_limit: opts.child_limit };
+            v["children"] = Value::Array(ch.iter().rev().take(take_n).map(|c| node_summary_opts(c, next)).collect());
+        }
+        if take_n < total || v.get("children").is_none() {
+            v["childCount"] = json!(total);
+        }
    }
    v
 }
@@ -293,7 +293,9 @@ fn strip_replay_only(id: &str, p: &mut Value) {
 /// have finite, in-range geometry, so saved files always reload and renderers never see NaN/∞.
 fn doc_sane(d: &Document, sel: &Selection) -> bool {
    let ok = |r: vectorcraft_geom::Rect| [r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite() && v.abs() <= MAX_COORD);
-    d.artboards.iter().all(|a| ok(a.rect)) && sel.objects.iter().all(|id| d.node(*id).and_then(|n| n.geometric_bounds()).is_none_or(ok))
+    d.artboards.iter().all(|a| ok(a.rect))
+        && d.guides.iter().all(|g| g.pos.is_finite() && g.pos.abs() <= MAX_COORD)
+        && sel.objects.iter().all(|id| d.node(*id).and_then(|n| n.geometric_bounds()).is_none_or(ok))
 }

 /// Where new art goes (Illustrator's drawing modes, Shift+D cycles).
@@ -364,6 +364,56 @@ fn document_node_summary_matches_inspect() {
    assert!(s.execute("document.node", &json!({"id": 999999, "summary": true})).is_err());
 }

+/// `depth` and `childLimit` slice a summary read; a level that shows fewer children
+/// than it has reports `childCount`, and invalid values are rejected, not reinterpreted.
+#[test]
+fn document_node_summary_slices_with_depth_and_limit() {
+    let mut s = session();
+    rect(&mut s, 0.0, 0.0, 10.0, 10.0);
+    rect(&mut s, 20.0, 0.0, 10.0, 10.0);
+    s.execute("select.all", &json!({})).unwrap();
+    let inner = s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap();
+    rect(&mut s, 40.0, 0.0, 10.0, 10.0);
+    s.execute("select.all", &json!({})).unwrap();
+    let outer = s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap();
+    let mut read = |p: Value| s.execute("document.node", &p).unwrap();
+
+    let g = read(json!({"id": outer, "summary": true}));
+    assert_eq!(g["children"].as_array().map(Vec::len), Some(2));
+    assert!(g.get("childCount").is_none(), "nothing truncated: {g}");
+    // Limits beyond the tree are the whole tree, byte for byte.
+    assert_eq!(read(json!({"id": outer, "summary": true, "depth": u64::MAX, "childLimit": u64::MAX})), g);
+
+    let one = read(json!({"id": outer, "summary": true, "childLimit": 1}));
+    assert_eq!(one["children"].as_array().map(Vec::len), Some(1));
+    assert_eq!(one["childCount"], 2);
+
+    let flat = read(json!({"id": outer, "summary": true, "depth": 0}));
+    assert!(flat.get("children").is_none(), "{flat}");
+    assert_eq!(flat["childCount"], 2);
+
+    // Limits compose per level: the outer children show; the inner group's own
+    // children don't, and it says so.
+    let shallow = read(json!({"id": outer, "summary": true, "depth": 1}));
+    let kids = shallow["children"].as_array().unwrap();
+    assert_eq!(kids.len(), 2);
+    assert!(shallow.get("childCount").is_none(), "{shallow}");
+    let nested = kids.iter().find(|n| n["id"] == inner).unwrap();
+    assert!(nested.get("children").is_none(), "{nested}");
+    assert_eq!(nested["childCount"], 2);
+
+    for bad in [
+        json!({"id": outer, "summary": true, "depth": -1}),
+        json!({"id": outer, "summary": true, "depth": 1.5}),
+        json!({"id": outer, "summary": true, "childLimit": "many"}),
+        // A slice of the full object JSON would silently be the whole subtree.
+        json!({"id": outer, "depth": 0}),
+        json!({"id": outer, "summary": false, "childLimit": 1}),
+    ] {
+        assert!(s.execute("document.node", &bad).is_err(), "{bad}");
+    }
+}
+
 /// 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() {
@@ -7,7 +7,7 @@ use vectorcraft_geom::Point;
 use vectorcraft_tools::{Mods, PointerEvent, PointerKind, ToolKey};

 use super::*;
-use crate::cmd::clipboard::{PDF, PNG, SVG, TEXT};
+use crate::cmd::clipboard::{BITMAP, FILE_HEAD, PASTE_ORDER, PDF, PNG, SVG, TEXT, file_flavour};

 fn session() -> Session {
    let mut s = Session::new();
@@ -118,6 +118,29 @@ fn import_image_then_paste_gives_an_image() {
    assert!(s.execute("clipboard.importImage", &json!({"dataBase64": "!!"})).is_err());
 }

+#[test]
+fn copied_files_paste_by_their_content() {
+    let mut s = session();
+    copy_red_square(&mut s);
+    let png = decode(&run(&mut s, "clipboard.exportPng", json!({})));
+    let pdf = decode(&run(&mut s, "clipboard.exportPdf", json!({})));
+    let mut jpeg = vec![];
+    image::RgbImage::new(2, 2).write_to(&mut std::io::Cursor::new(&mut jpeg), image::ImageFormat::Jpeg).unwrap();
+    let svg = b"<svg xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"4\" height=\"4\"/></svg>";
+    let of = |name: &str, bytes: &[u8]| file_flavour(name, &bytes[..bytes.len().min(FILE_HEAD)], &PASTE_ORDER);
+    assert_eq!(of("red.png", &png), Some(PNG));
+    // The content tells, whatever the name says; bitmaps keep their own type.
+    assert_eq!(of("photo.txt", &jpeg), Some("image/jpeg"));
+    assert_eq!(of("art.svg", svg), Some(SVG));
+    assert_eq!(of("doc.pdf", &pdf), Some(PDF));
+    // Files that aren't art paste as nothing (not as their path).
+    assert_eq!(of("notes.txt", b"hello"), None);
+    assert_eq!(of("archive.zip", b"PK\x03\x04"), None);
+    // Only what was asked for.
+    assert_eq!(file_flavour("red.png", &png, &[TEXT, SVG]), None);
+    assert_eq!(file_flavour("art.svg", svg, &[BITMAP]), None);
+}
+
 #[test]
 fn import_text_then_paste_gives_point_text() {
    let mut s = session();
@@ -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]
@@ -152,3 +152,78 @@ 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);
+}
@@ -310,15 +310,18 @@ fn character_panel_flow_styles_the_selected_range_while_editing() {
 fn select_all_and_cut_like_ui() {
    let mut s = session();
    let v = ViewInfo::default();
+    s.execute("shape.rectangle", &json!({"x": 300, "y": 300, "width": 10, "height": 10})).unwrap();
    let id = text(&mut s, "abc def");
    s.select_tool("type", v).unwrap();
    let t = obj(&s, id);
    let p = t.xf * Point::new(2.0, -5.0);
    click(&mut s, p.x, p.y);
-    s.set_tool_option("selectAll", &json!(true));
-    let o = s.tool_options();
-    let len = obj(&s, id).plain_text().len() as u64;
-    let r = s.execute("text.getRange", &json!({"id": o["editing"], "start": o["start"], "end": o["end"].as_u64().unwrap().min(len)})).unwrap();
+    // Select All while editing takes the text, not the art (the rectangle stays unselected).
+    assert!(s.tool_wants_text());
+    let o = s.execute("select.all", &json!({})).unwrap();
+    assert_eq!(o, json!({"editing": id.0, "start": 0, "end": 7}));
+    assert_eq!(s.doc().unwrap().selection.objects, [id]);
+    let r = s.execute("text.getRange", &json!({"id": o["editing"], "start": o["start"], "end": o["end"]})).unwrap();
    assert_eq!(r["text"], json!("abc def"));
    s.set_tool_option("copy", &r["runs"]);
    key(&mut s, ToolKey::Delete, Mods::default());
@@ -326,6 +329,10 @@ fn select_all_and_cut_like_ui() {
    s.tool_text("abc def", v).unwrap();
    s.tool_text("abc def", v).unwrap();
    assert_eq!(obj(&s, id).plain_text(), "abc defabc def");
+    // Not editing: Select All selects the art again.
+    key(&mut s, ToolKey::Escape, Mods::default());
+    assert!(!s.tool_wants_text());
+    assert_eq!(s.execute("select.all", &json!({})).unwrap(), json!({"count": 2}));
 }

 #[test]
@@ -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,11 @@ 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,
            screen: view.screen,
            plane_widget: self.prefs.perspective_widget.show.then_some(self.prefs.perspective_widget.position),
        };
@@ -265,8 +274,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 {
@@ -44,7 +44,7 @@ pub static TEMPLATES: &[Template] = &[
        uri: "vectorcraft://object/{id}",
        name: "object",
        title: "One layer or object",
-        description: "The layer or object with this id, with its children, bounds and paint (document.node {summary: true})",
+        description: "The layer or object with this id, with its children, bounds and paint (document.node {summary: true}). Large containers can be sliced with run_command document.node {id, summary, depth, childLimit}: truncated levels report childCount",
        mime: "application/json",
        live: Live::Objects,
    },
@@ -504,3 +504,28 @@ 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");
+}
@@ -1,5 +1,6 @@
 //! `press_key` with the Width and Puppet Warp tools: Delete and Backspace reach the selected width
-//! point or pin, and clear the selected art when the tool has nothing selected.
+//! point or pin, and clear the selected art when the tool has nothing selected. Cmd+A while the
+//! Type tool edits selects the text, not the art.

 use serde_json::{Value, json};

@@ -64,3 +65,15 @@ fn delete_and_backspace_reach_the_puppet_warp_tool() {
        assert!(!exists(&h, id), "{key} cleared the art");
    }
 }
+
+#[test]
+fn cmd_a_while_the_type_tool_edits_selects_the_text() {
+    let mut h = session();
+    run(&mut h, "shape.rectangle", json!({"x": 300, "y": 300, "width": 20, "height": 20}));
+    let id = run(&mut h, "text.create", json!({"x": 100, "y": 100, "text": "Hello", "size": 20}))["id"].as_u64().unwrap();
+    click(&mut h, "type", 102.0, 95.0);
+    let r = ok(&mut h, "press_key", json!({"key": "A", "mods": {"cmd": true}}));
+    assert_eq!(r["command"], "select.all");
+    assert_eq!(r["result"], json!({"editing": id, "start": 0, "end": 5}));
+    assert_eq!(h.session.doc().unwrap().selection.objects, [vectorcraft_doc::NodeId(id)], "the art selection stays");
+}
@@ -281,7 +281,10 @@ fn is_japanese_letter(c: char) -> bool {
        return true;
    }
    is_cjk(c)
-        && !matches!(c as u32, 0x3000..=0x303F | 0xAC00..=0xD7AF | 0xFF01..=0xFF0F | 0xFF1A..=0xFF20 | 0xFF3B..=0xFF40 | 0xFF5B..=0xFF65)
+        && !matches!(
+            c as u32,
+            0x3000..=0x303F | 0x3130..=0x318F | 0xAC00..=0xD7AF | 0xFF01..=0xFF0F | 0xFF1A..=0xFF20 | 0xFF3B..=0xFF40 | 0xFF5B..=0xFF65 | 0xFFA0..=0xFFDC
+        )
        && c != '・'
        && punct(c).is_none()
 }
@@ -320,6 +323,26 @@ fn space_japanese_and_latin(sg: &mut [SGlyph]) -> Vec<f64> {
    added
 }

+/// The size of `g`'s em, in points.
+fn glyph_em(g: &SGlyph) -> f64 {
+    g.face.units_per_em() * g.sy
+}
+
+/// How far up (line space) Character Alignment `a` moves glyph `g` on a line whose largest em is
+/// `line_em`: the glyph's em box top, centre or bottom onto the line's (the em box running from
+/// its centre less half an em to its centre plus half an em above the baseline). Nothing on the
+/// Roman baseline, or for the line's largest characters.
+fn align_shift(g: &SGlyph, a: vectorcraft_doc::CharAlign, line_em: f64) -> f64 {
+    use vectorcraft_doc::CharAlign;
+    let k = match a {
+        CharAlign::RomanBaseline => return 0.0,
+        CharAlign::EmBoxTop => 0.5,
+        CharAlign::EmBoxCenter => 0.0,
+        CharAlign::EmBoxBottom => -0.5,
+    };
+    (g.face.ideographic_centre() + k) * (line_em - glyph_em(g)).max(0.0)
+}
+
 /// The length an upright glyph takes down the column before tracking and justification: its
 /// vertical advance (the font's vertical metrics), else its advance, at least one em.
 fn upright_cell(g: &SGlyph) -> f64 {
@@ -798,7 +821,8 @@ fn japanese_letters_for_the_latin_space_are_kana_kanji_and_marks_not_hangul_or_p
    for c in ['あ', 'カ', '漢', '々', '〆', '〇', 'Ａ'] {
        assert!(is_japanese_letter(c), "{c}");
    }
-    for c in ['한', '。', '「', '・', '、', 'a'] {
+    // Hangul in every form: syllables, compatibility jamo (ㄱ ㅏ), half-width jamo (ﾡ).
+    for c in ['한', 'ㄱ', 'ㅏ', '\u{FFA1}', '。', '「', '・', '、', 'a'] {
        assert!(!is_japanese_letter(c), "{c}");
    }
 }
@@ -1056,6 +1080,8 @@ fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Opt
            };
            let li = cx.out.lines.len();
            let glyph_start = cx.out.glyphs.len();
+            // Character Alignment lines smaller characters up with the line's largest em box.
+            let line_em = sg.get(i..end).map_or(0.0, |line| line.iter().map(glyph_em).fold(0.0, f64::max));
            let mut x_end = start_x;
            // Tab stops are measured from the frame's left edge (point type: the origin).
            let tab_origin = if regions.is_some() { x0 } else { 0.0 };
@@ -1088,7 +1114,8 @@ fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Opt
                        adv += per_gap;
                    }
                }
-                cx.emit(g, Affine::translate((x, baseline)), Point::new(x, baseline), 0.0, adv, li);
+                let y = baseline - align_shift(g, cx.style_at(g.byte).char_align, line_em);
+                cx.emit(g, Affine::translate((x, y)), Point::new(x, y), 0.0, adv, li);
                x += adv;
                if j < trimmed {
                    x_end = x;
@@ -557,3 +557,31 @@ fn em_box_top_leading_hangs_lines_from_the_line_above() {
        em.lines[1].baseline - em.lines[0].baseline
    );
 }
+
+/// Character Alignment: a 20 pt character next to a 40 pt one lines its em box top, centre or
+/// bottom up with the big one's (the em box from 0.12 em below the baseline to 0.88 em above it,
+/// in fonts without vertical metrics), or stays on the baseline; in vertical type the same across
+/// the column (top → right).
+#[test]
+fn character_alignment_lines_small_characters_up_with_the_largest_em_box() {
+    use vectorcraft_doc::{CharAlign, TextRun};
+    for vertical_type in [false, true] {
+        let place = |a: CharAlign| {
+            let mut t = point("", style(40.0));
+            t.vertical = vertical_type;
+            t.runs = vec![
+                TextRun { text: "大".into(), style: style(40.0) },
+                TextRun { text: "小".into(), style: CharStyle { char_align: a, ..style(20.0) } },
+            ];
+            let l = layout(db(), &t);
+            // How far the small character's origin sits above the big one's (to the right, vertical).
+            let (big, small) = (l.glyphs[0].origin, l.glyphs[1].origin);
+            if vertical_type { small.x - big.x } else { big.y - small.y }
+        };
+        let near = |a: f64, b: f64| (a - b).abs() < 0.01;
+        assert!(near(place(CharAlign::RomanBaseline), 0.0), "vertical {vertical_type}");
+        assert!(near(place(CharAlign::EmBoxTop), 0.88 * 20.0), "top: {}", place(CharAlign::EmBoxTop));
+        assert!(near(place(CharAlign::EmBoxCenter), 0.38 * 20.0), "centre: {}", place(CharAlign::EmBoxCenter));
+        assert!(near(place(CharAlign::EmBoxBottom), -0.12 * 20.0), "bottom: {}", place(CharAlign::EmBoxBottom));
+    }
+}
@@ -7,11 +7,11 @@
 //! (the selected ones when anchors are selected; Alt-click cycles their kind, double-click opens
 //! the Corners dialog).
 //! Group Selection: click selects the leaf; each further click on it adds the next enclosing group.
-//! Both pick the key objects of a blend. Direct Selection also edits a blend's spine: drag its
-//! points (a key object on a point moves with it) and, once a point is clicked, its handles; and
-//! the points of selected gradient meshes and mesh envelopes and their handles ([`MeshEdit`]).
-//! Dragging a corner or an edge of area type's frame reshapes the type area (`text.reshapeArea`):
-//! the text reflows at its size.
+//! Both pick the key objects of a blend, and click or drag ruler guides ([`crate::rulerguide`]).
+//! Direct Selection also edits a blend's spine: drag its points (a key object on a point moves
+//! with it) and, once a point is clicked, its handles; and the points of selected gradient meshes
+//! and mesh envelopes and their handles ([`MeshEdit`]). Dragging a corner or an edge of area
+//! type's frame reshapes the type area (`text.reshapeArea`): the text reflows at its size.
 //!
 //! A press on the stroke of a path that isn't selected as a whole selects that segment's two anchors
 //! (the fill, or Alt, selects the whole path); dragging the segment bends it if it's curved, else
@@ -27,6 +27,7 @@ use vectorcraft_geom::{PathData, Point, Rect};
 use crate::bbox::move_delta;
 use crate::corners::{self, CornerDrag, over_widget};
 use crate::meshedit::MeshEdit;
+use crate::rulerguide::GuideEdit;
 use crate::select::{is_area_type, matrix_json};
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext};

@@ -95,11 +96,14 @@ pub struct DirectSelectionTool {
    mesh: MeshEdit,
    /// Smart guides of the handle being dragged.
    guides: Vec<Overlay>,
+    /// The anchor under the pointer (Highlight anchors on mouse over): its path, where it is.
+    hover: Option<(NodeId, Point)>,
+    guide: GuideEdit,
 }

 impl DirectSelectionTool {
    pub fn new(group: bool) -> Self {
-        Self { group, state: State::Idle, spine: None, mesh: MeshEdit::default(), guides: vec![] }
+        Self { group, state: State::Idle, spine: None, mesh: MeshEdit::default(), guides: vec![], hover: None, guide: GuideEdit::default() }
    }
 }

@@ -232,13 +236,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,6 +271,10 @@ 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);
@@ -303,6 +318,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
@@ -492,6 +511,10 @@ impl Tool for DirectSelectionTool {
                if matches!(self.state, State::Handle { .. }) {
                    out.extend(self.guides.iter().cloned());
                }
+                if let Some((id, p)) = self.hover.filter(|_| matches!(self.state, State::Idle)) {
+                    out.push(Overlay::Anchor { p, color: cx.doc.layer_color(id), filled: false, size: 8.0 });
+                }
+                out.extend(self.guide.overlays(cx));
                out
            }
        }
@@ -500,10 +523,22 @@ impl Tool for DirectSelectionTool {
        if !self.group && (matches!(self.state, State::Corner(_)) || over_widget(cx, p)) {
            return Cursor::CornerRadius;
        }
-        Cursor::ArrowHollow
+        // A press on the highlighted anchor picks it, not the guide.
+        self.guide.cursor(cx, p).filter(|_| self.hover.is_none() || self.guide.busy()).unwrap_or(Cursor::ArrowHollow)
    }
 }

+/// The anchor within the selection tolerance of `p`, of a selected path or the path under `p`:
+/// what Highlight anchors on mouse over marks (a press there picks it).
+fn hovered_anchor(cx: &ToolContext, p: Point) -> Option<(NodeId, Point)> {
+    let under = hit_test(cx.doc, p, cx.hit_options()).map(|h| h.leaf);
+    let tol = cx.pick_tol();
+    cx.selection.objects.iter().copied().chain(under).find_map(|id| {
+        let path = cx.doc.node(id).and_then(editable_path)?;
+        path.anchors().find(|(_, _, a)| a.p.distance(p) <= tol).map(|(_, _, a)| (id, a.p))
+    })
+}
+
 /// The frame anchors of the selected area type, which Direct Selection drags.
 fn frame_overlays(cx: &ToolContext) -> Vec<Overlay> {
    let mut out = vec![];
@@ -550,6 +585,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 +619,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();
@@ -142,6 +142,23 @@ impl Targets {
        (out, ov)
    }

+    /// Snap a ruler guide at `v` (the x of a vertical one, the y of a horizontal one) into line
+    /// with the nearest edge, centre or anchor within `tol`: where it goes, and a label there.
+    pub fn snap_guide(&self, vertical: bool, v: f64, tol: f64) -> (f64, Vec<Overlay>) {
+        let along = |q: &Point| if vertical { q.x } else { q.y };
+        let lines = if vertical { &self.xs } else { &self.ys };
+        let best = lines
+            .iter()
+            .map(|(t, from, k)| (*t, *from, *k))
+            .chain(self.points.iter().map(|(q, k)| (along(q), *q, *k)))
+            .filter(|(t, ..)| (t - v).abs() <= tol)
+            .min_by(|a, b| (a.0 - v).abs().total_cmp(&(b.0 - v).abs()));
+        match best {
+            Some((t, from, k)) => (t, vec![Overlay::Label { p: from, text: k.label().into(), color: MAGENTA }]),
+            None => (v, vec![]),
+        }
+    }
+
    /// Snap a dragged point that carries others along at `offsets` (a resize handle and the
    /// bleed edge beyond it): onto an anchor or centre near the point itself, otherwise into line
    /// with targets, each axis on whichever of them comes nearest.
@@ -298,8 +315,7 @@ fn snap_with(cx: &ToolContext, p: Point, targets: impl FnOnce() -> Targets) -> (
        return (Point::new(p.x.round(), p.y.round()), vec![]);
    }
    if cx.snap_to_grid {
-        let s = cx.doc.grid.spacing / cx.doc.grid.subdivisions.max(1) as f64;
-        return (vectorcraft_geom::snap::snap_point_to_grid(p, s), vec![]);
+        return (vectorcraft_geom::snap::snap_point_to_grid(p, cx.grid_step()), vec![]);
    }
    if !cx.smart_guides {
        return (p, vec![]);
@@ -23,6 +23,7 @@ pub mod params;
 pub mod pen;
 pub mod place;
 pub mod printtiling;
+pub mod rulerguide;
 pub mod select;
 pub mod settings;
 pub mod shape;
@@ -201,6 +202,13 @@ impl ScreenFrame {
    pub fn at(&self, x: f64, y: f64) -> Point {
        self.origin + self.right * x + self.down * y
    }
+    /// Where the document point `p` is, in screen pixels from the window's top-left corner (the
+    /// inverse of [`Self::at`]); none for a degenerate frame.
+    pub fn to_screen(&self, p: Point) -> Option<(f64, f64)> {
+        let (r, d, v) = (self.right, self.down, p - self.origin);
+        let det = r.x * d.y - d.x * r.y;
+        (det.is_finite() && det.abs() > 1e-12).then(|| ((v.x * d.y - d.x * v.y) / det, (r.x * v.y - v.x * r.y) / det))
+    }
 }

 /// Read-only context a tool sees.
@@ -213,6 +221,8 @@ 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,
@@ -253,6 +263,22 @@ 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,
    /// 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 +302,16 @@ impl ToolContext<'_> {
    pub fn offset_label(&self, dx: f64, dy: f64) -> String {
        format!("dX: {}\ndY: {}", self.len(dx), self.len(dy))
    }
+    /// What Snap to Grid snaps to: the grid's subdivisions (or its lines without any).
+    pub fn grid_step(&self) -> f64 {
+        self.doc.grid.spacing / self.doc.grid.subdivisions.max(1) as f64
+    }
+    /// The selection tolerance in document units ([`Self::selection_tolerance`]).
+    pub fn pick_tol(&self) -> f64 {
+        self.tol(self.selection_tolerance)
+    }
    pub fn hit_options(&self) -> vectorcraft_doc::hit::HitOptions {
-        vectorcraft_doc::hit::HitOptions { tol: self.tol(3.0), outline: self.outline, path_only: false }
+        vectorcraft_doc::hit::HitOptions { tol: self.pick_tol(), outline: self.outline, path_only: self.path_only }
    }
 }

@@ -356,6 +390,27 @@ pub enum Cursor {
    BlendAnchor,
 }

+impl Cursor {
+    /// General › Use Precise Cursors: the drawing tools' pointers (the Pen's in every state, the
+    /// Eyedropper's, the Slice and Blend tools') become a plain crosshair at the hotspot.
+    pub fn precise(self) -> Self {
+        match self {
+            Cursor::Pen
+            | Cursor::PenAdd
+            | Cursor::PenDelete
+            | Cursor::PenClose
+            | Cursor::PenContinue
+            | Cursor::PenConvert
+            | Cursor::Eyedropper
+            | Cursor::Slice
+            | Cursor::Blend
+            | Cursor::BlendObject
+            | Cursor::BlendAnchor => Cursor::Crosshair,
+            c => c,
+        }
+    }
+}
+
 /// A tool state machine.
 pub trait Tool: Send {
    fn id(&self) -> &'static str;
@@ -506,6 +561,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 +580,11 @@ 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,
            screen: None,
            plane_widget: Some(Default::default()),
        }
@@ -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]));
+    }
+}
@@ -1,18 +1,21 @@
 //! The Selection tool (V): click/shift-click, marquee, move (Alt copies, Shift constrains),
 //! 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`]).
 //! The bounding box stands at the selection's own angle after a rotation, so its handles scale
 //! along the objects' axes. A handle drag resizes area type's frame (the type area) instead of
 //! scaling its type: the text reflows at its size.

 use serde_json::{Value, json};
-use vectorcraft_doc::hit::{hit_test, marquee};
+use vectorcraft_doc::hit::{hit_test, marquee, objects_at};
 use vectorcraft_doc::{NodeId, OrientedBox};
 use vectorcraft_geom::{Affine, Point, Rect};

 use crate::bbox::{Handle, hit_handle, in_rotate_zone, move_delta, rotate_for_drag, scale_for_drag};
 use crate::corners::{self, CornerDrag, over_widget};
+use crate::rulerguide::GuideEdit;
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, json_ids};

 #[derive(Clone, Debug, Default)]
@@ -53,6 +56,7 @@ pub struct SelectionTool {
    guides: Vec<Overlay>,
    targets: Option<crate::guides::Targets>,
    start_bounds: Option<Rect>,
+    guide: GuideEdit,
 }

 pub fn matrix_json(a: Affine) -> Value {
@@ -100,10 +104,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 +119,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(_))) {
@@ -152,7 +162,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);
@@ -285,6 +307,7 @@ impl Tool for SelectionTool {
            _ => {}
        }
        o.extend(self.guides.iter().cloned());
+        o.extend(self.guide.overlays(cx));
        if let Some((p, t)) = &self.measure {
            o.push(Overlay::Measure { p: *p, text: t.clone() });
        }
@@ -299,6 +322,9 @@ impl Tool for SelectionTool {
            State::Corner(_) => return Cursor::CornerRadius,
            _ => {}
        }
+        if self.guide.busy() {
+            return self.guide.cursor(cx, p).unwrap_or_default();
+        }
        if over_widget(cx, p) {
            return Cursor::CornerRadius;
        }
@@ -311,6 +337,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 +350,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 +399,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();
@@ -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"
@@ -33,3 +33,7 @@ log = { workspace = true }
 [dev-dependencies]
 vectorcraft-testkit = { workspace = true }
 wat = { workspace = true }
+
+[build-dependencies]
+serde_json = { workspace = true }
+toml = "1"
@@ -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
+}
@@ -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);
        }
    }

@@ -418,8 +428,10 @@ fn cursor_icon(c: Cursor) -> egui::CursorIcon {
 }

 fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect: egui::Rect) {
-    let (pointer, m, space, scroll, zoom_delta) =
-        ui.input(|i| (i.pointer.clone(), i.modifiers, i.key_down(egui::Key::Space), i.smooth_scroll_delta, i.zoom_delta()));
+    let line = ui.ctx().options(|o| o.input_options.line_scroll_speed);
+    let wheel_zooms = app.session.prefs.zoom_with_mouse_wheel;
+    let (pointer, m, space, (factor, scroll)) =
+        ui.input(|i| (i.pointer.clone(), i.modifiers, i.key_down(egui::Key::Space), wheel(i, wheel_zooms, line, rect.height())));
    let v = *app.view().unwrap_or(&View::default());
    let xf = Xf::new(rect, &v);
    let hover = pointer.hover_pos().filter(|p| rect.contains(*p));
@@ -427,12 +439,8 @@ fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect:
    let view = app.view_info();
    let drag: Option<Drag> = ui.data(|d| d.get_temp(drag_id()));

-    // Zoom: pinch / Cmd-scroll / Alt-scroll around the pointer. Plain scroll pans.
+    // Zoom around the pointer, or scroll ([`wheel`]).
    if resp.hovered() {
-        let mut factor = zoom_delta as f64;
-        if m.alt && scroll.y != 0.0 {
-            factor *= (scroll.y as f64 * 0.01).exp();
-        }
        if (factor - 1.0).abs() > 1e-6 {
            if let (Some(p), Some(vm)) = (hover, app.view_mut()) {
                let before = xf.to_doc(p);
@@ -441,8 +449,7 @@ fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect:
                let after = nx.to_doc(p);
                vm.center += before - after;
            }
-        } else if (scroll.x != 0.0 || scroll.y != 0.0)
-            && !m.alt
+        } else if scroll != egui::Vec2::ZERO
            && let Some(vm) = app.view_mut()
        {
            let d = Xf { rect, zoom: vm.zoom, center: vm.center, rot: vm.rotation.to_radians() }.delta_to_doc(scroll);
@@ -481,7 +488,9 @@ fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect:
                app.select_tool(if is_selection_tool(&last) { &last } else { "selection" });
                kind = Drag::TempSelect;
            }
-            let ev = PointerEvent { kind: PointerKind::Down, pos: xf.to_doc(p), mods: mods(m, space), pressure: pen_pressure(ui, true) };
+            // Cmd only brought the selection tool: its click is a plain one, not Select Behind.
+            let mods = Mods { cmd: m.command && kind != Drag::TempSelect, ..mods(m, space) };
+            let ev = PointerEvent { kind: PointerKind::Down, pos: xf.to_doc(p), mods, pressure: pen_pressure(ui, true) };
            dispatch(app, &ev, view);
            kind
        };
@@ -591,6 +600,46 @@ fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect:
    }
 }

+/// How much one point of wheel motion zooms (as `exp(points × WHEEL_ZOOM)`).
+const WHEEL_ZOOM: f64 = 0.01;
+
+/// What the wheel and a pinch did over the canvas this frame: a zoom factor (about the pointer)
+/// and a scroll (screen points the content moves). The wheel scrolls, Cmd- and Alt-wheel zoom.
+/// With General › Zoom with Mouse Wheel (`wheel_zooms`) the wheel zooms, Shift-wheel scrolls up
+/// and down and Cmd/Ctrl-wheel sideways. `line` and `page`: points per wheel line and page.
+fn wheel(i: &egui::InputState, wheel_zooms: bool, line: f32, page: f32) -> (f64, egui::Vec2) {
+    if !wheel_zooms {
+        // egui makes Cmd-wheel (and a pinch) its zoom and the rest a smoothed scroll.
+        let (zoom, scroll) = (f64::from(i.zoom_delta()), i.smooth_scroll_delta);
+        return if i.modifiers.alt && scroll.y != 0.0 { (zoom * (f64::from(scroll.y) * WHEEL_ZOOM).exp(), egui::Vec2::ZERO) } else { (zoom, scroll) };
+    }
+    // The wheel events themselves: egui's own handling turns Cmd-wheel into a zoom.
+    let mut zoom = i.multi_touch().map_or(1.0, |t| f64::from(t.zoom_delta));
+    let mut scroll = egui::Vec2::ZERO;
+    for e in &i.events {
+        match e {
+            egui::Event::MouseWheel { unit, delta, modifiers, .. } => {
+                let d = match unit {
+                    egui::MouseWheelUnit::Point => *delta,
+                    egui::MouseWheelUnit::Line => *delta * line,
+                    egui::MouseWheelUnit::Page => *delta * page,
+                };
+                if modifiers.command {
+                    scroll.x += d.x + d.y;
+                } else if modifiers.shift {
+                    scroll.y += d.x + d.y;
+                } else {
+                    zoom *= (f64::from(d.y) * WHEEL_ZOOM).exp();
+                    scroll.x += d.x;
+                }
+            }
+            egui::Event::Zoom(f) => zoom *= f64::from(*f),
+            _ => {}
+        }
+    }
+    (zoom, scroll)
+}
+
 /// A Selection tool move dragged off the canvas (to `p`, over a panel) turns into a panel drag of
 /// the selected art ([`widgets::PanelDrag::Art`]): the move is dropped, so the art stays where it
 /// was, and the panel it is released on takes it (the Graphic Styles panel makes a style of it).
@@ -675,28 +724,82 @@ fn checker(p: &egui::Painter, quad: &[Pos2], ab: Rect, zoom: f64, tex: egui::Tex
    p.add(Shape::mesh(mesh));
 }

-fn grid(p: &egui::Painter, xf: &Xf, spacing: f64, subdiv: u32) {
+/// The look of the grid or of the guides (Preferences › Guides & Grid › Color and Style).
+#[derive(Clone, Copy)]
+struct LineLook {
+    color: Color32,
+    dots: bool,
+}
+
+impl LineLook {
+    fn grid(prefs: &vectorcraft_engine::Prefs) -> Self {
+        Self { color: pref_color(&prefs.grid_color, Color32::from_gray(200)), dots: prefs.grid_style == "dots" }
+    }
+
+    fn guides(prefs: &vectorcraft_engine::Prefs, t: &Tokens) -> Self {
+        Self { color: pref_color(&prefs.guide_color, t.guide), dots: prefs.guide_style == "dots" }
+    }
+
+    /// A guide from `a` to `b`: a line, or dots.
+    fn guide(self, p: &egui::Painter, a: Pos2, b: Pos2) {
+        if self.dots {
+            p.extend(Shape::dotted_line(&[a, b], self.color, 4.0, 0.75));
+        } else {
+            p.line_segment([a, b], Stroke::new(1.0, self.color));
+        }
+    }
+}
+
+/// A `#rrggbb` colour preference, `fallback` when it doesn't parse.
+fn pref_color(hex: &str, fallback: Color32) -> Color32 {
+    vectorcraft_color::Color::from_hex(hex).map_or(fallback, |c| crate::panels::c32(&c))
+}
+
+/// The grid (View → Show Grid): a gridline every `spacing` and `subdiv` lighter lines between
+/// (left out when they would crowd). In the Dots style, a dot where gridlines cross the
+/// subdivisions instead.
+fn grid(p: &egui::Painter, xf: &Xf, spacing: f64, subdiv: u32, look: LineLook) {
    let r = xf.rect;
    let a = xf.to_doc(r.min);
    let b = xf.to_doc(r.max);
    let sub = spacing / subdiv.max(1) as f64;
    let step = if sub * xf.zoom >= 6.0 { sub } else { spacing };
-    if step * xf.zoom < 4.0 {
+    // Dots crowd sooner than lines.
+    if step * xf.zoom < 4.0 || (look.dots && spacing * xf.zoom < 8.0) {
        return;
    }
-    let mut x = (a.x / step).floor() * step;
-    while x <= b.x {
-        let major = (x / spacing).round() * spacing == x || (x / spacing - (x / spacing).round()).abs() < 1e-6;
-        let sx = xf.to_screen(Point::new(x, 0.0)).x;
-        p.line_segment([pos2(sx, r.top()), pos2(sx, r.bottom())], Stroke::new(1.0, Color32::from_black_alpha(if major { 60 } else { 22 })));
-        x += step;
+    let major = |v: f64| (v / spacing - (v / spacing).round()).abs() < 1e-6;
+    // The lines across the view, on screen, each with whether it is a gridline.
+    let lines = |from: f64, to: f64, screen: &dyn Fn(f64) -> f32| {
+        let mut v = (from / step).floor() * step;
+        let mut out = vec![];
+        while v <= to {
+            out.push((screen(v), major(v)));
+            v += step;
+        }
+        out
+    };
+    let xs = lines(a.x, b.x, &|x| xf.to_screen(Point::new(x, 0.0)).x);
+    let ys = lines(a.y, b.y, &|y| xf.to_screen(Point::new(0.0, y)).y);
+    if look.dots {
+        let mut mesh = egui::Mesh::default();
+        for &(x, mx) in &xs {
+            for &(y, my) in &ys {
+                if mx || my {
+                    mesh.add_colored_rect(egui::Rect::from_center_size(pos2(x, y), vec2(1.5, 1.5)), look.color);
+                }
+            }
+        }
+        p.add(Shape::mesh(mesh));
+        return;
    }
-    let mut y = (a.y / step).floor() * step;
-    while y <= b.y {
-        let major = (y / spacing - (y / spacing).round()).abs() < 1e-6;
-        let sy = xf.to_screen(Point::new(0.0, y)).y;
-        p.line_segment([pos2(r.left(), sy), pos2(r.right(), sy)], Stroke::new(1.0, Color32::from_black_alpha(if major { 60 } else { 22 })));
-        y += step;
+    let minor = look.color.gamma_multiply(0.4);
+    let stroke = |major: bool| Stroke::new(1.0, if major { look.color } else { minor });
+    for (x, m) in xs {
+        p.line_segment([pos2(x, r.top()), pos2(x, r.bottom())], stroke(m));
+    }
+    for (y, m) in ys {
+        p.line_segment([pos2(r.left(), y), pos2(r.right(), y)], stroke(m));
    }
 }

@@ -717,24 +820,33 @@ fn ruler_rects(full: egui::Rect) -> [egui::Rect; 3] {
 }

 /// A drag from a ruler onto the canvas makes a guide where the button is released: a horizontal
-/// one from the top ruler, a vertical one from the left ruler. Released anywhere else, it makes
-/// none.
+/// one from the top ruler, a vertical one from the left ruler; with Shift on the nearest ruler
+/// tick. Released anywhere else, it makes none.
 fn ruler_guides(app: &mut VectorcraftApp, ui: &Ui, full: egui::Rect, canvas: egui::Rect, xf: &Xf, t: &Tokens) {
    let [top, left, _] = ruler_rects(full);
+    let shift = ui.input(|i| i.modifiers.shift);
    for (r, vertical, id) in [(top, false, "ruler-top"), (left, true, "ruler-left")] {
        let resp = ui.interact(r, egui::Id::new(id), Sense::drag());
        let Some(p) = resp.interact_pointer_pos().filter(|p| canvas.contains(*p)) else { continue };
+        let d = xf.to_doc(p);
+        let mut pos = if vertical { d.x } else { d.y };
+        if shift {
+            pos = app.session.general_unit().snap_to_ruler_tick(pos, xf.zoom);
+        }
        if resp.drag_stopped() {
-            let d = xf.to_doc(p);
            // The new guide shows even if guides were hidden.
            app.ui.view.guides = true;
-            if let Err(e) = app.run("guide.add", json!({ "vertical": vertical, "pos": if vertical { d.x } else { d.y } })) {
+            if let Err(e) = app.run("guide.add", json!({ "vertical": vertical, "pos": pos })) {
                app.status(e);
            }
        } else if resp.dragged() {
-            let line =
-                if vertical { [pos2(p.x, canvas.top()), pos2(p.x, canvas.bottom())] } else { [pos2(canvas.left(), p.y), pos2(canvas.right(), p.y)] };
-            ui.painter_at(canvas).line_segment(line, Stroke::new(1.0, t.guide));
+            let at = xf.to_screen(if vertical { Point::new(pos, d.y) } else { Point::new(d.x, pos) });
+            let (a, b) = if vertical {
+                (pos2(at.x, canvas.top()), pos2(at.x, canvas.bottom()))
+            } else {
+                (pos2(canvas.left(), at.y), pos2(canvas.right(), at.y))
+            };
+            LineLook::guides(&app.session.prefs, t).guide(&ui.painter_at(canvas), a, b);
        }
    }
 }
@@ -753,8 +865,7 @@ fn rulers(ui: &Ui, full: egui::Rect, xf: &Xf, hover: Option<Point>, unit: Unit,
    // Pick a label step (in `unit`) that gives ≥ 50 px between labels; positions below are in `unit`
    // (`per` points each).
    let per = unit.points();
-    let steps = [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 25.0, 50.0, 100.0, 200.0, 500.0, 1000.0, 2000.0, 5000.0, 10000.0];
-    let step = steps.iter().copied().find(|s| s * per * xf.zoom >= 50.0).unwrap_or(10000.0);
+    let step = unit.ruler_step(xf.zoom);
    let minor = step / 10.0;
    let font = egui::FontId::proportional(9.5);
    let a = xf.to_doc(top.left_top());
@@ -895,9 +1006,15 @@ fn walk_drawn<'a>(n: &'a Node, f: &mut impl FnMut(&'a Node)) {
    }
 }

-/// The topmost editable object under document point `p` at `zoom` (3 px tolerance).
+/// The topmost editable object under document point `p` at `zoom`, as the selection tools pick it
+/// (Selection & Anchor Display › Tolerance and Object Selection by Path Only).
 fn hit_at(app: &VectorcraftApp, p: Point, zoom: f64) -> Option<vectorcraft_doc::hit::Hit> {
-    let opt = vectorcraft_doc::hit::HitOptions { tol: 3.0 / zoom, outline: app.ui.view.outline, path_only: false };
+    let prefs = &app.session.prefs;
+    let opt = vectorcraft_doc::hit::HitOptions {
+        tol: prefs.selection_tolerance / zoom,
+        outline: app.ui.view.outline,
+        path_only: prefs.object_selection_by_path_only,
+    };
    vectorcraft_doc::hit::hit_test(&app.session.active()?.doc, p, opt)
 }

@@ -1090,10 +1207,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 +1277,10 @@ 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 grow = app.session.prefs.anchor_size.clamp(1, 7) as f32 - 3.0;
+    let anchor = |direct: bool| grow + if direct { 5.0 } else { 4.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 +1291,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;
            }
@@ -1189,24 +1307,18 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
                        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);
+                            p.circle_filled(hp, 2.75 + grow / 2.0, color);
                        }
                    }
                }
-                anchor_square(
-                    p,
-                    sp,
-                    if sel && partial.is_some() { selected_anchor(color) } else { color },
-                    sel,
-                    if partial.is_some() || direct { 5.0 } else { 4.0 },
-                );
+                anchor_square(p, sp, if sel && partial.is_some() { selected_anchor(color) } else { color }, sel, anchor(partial.is_some() || direct));
            }
        });
        // Centre point (Attributes panel → Show Center).
        if n.shows_center()
            && let Some(b) = n.geometric_bounds()
        {
-            anchor_square(p, xf.to_screen(b.center()), color, true, 4.0);
+            anchor_square(p, xf.to_screen(b.center()), color, true, anchor(false));
        }
        // Text: baseline marker (area type shows its frame instead, which may not be a rectangle).
        if let NodeKind::Text(tx) = &n.kind
@@ -1230,7 +1342,7 @@ 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).
@@ -1251,7 +1363,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);
        }
@@ -1592,6 +1704,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 +1810,120 @@ 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:?}");
+    }
+
+    /// 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};
@@ -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);
@@ -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();
@@ -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(""), "—");
+    }
+}
@@ -16,32 +16,60 @@ pub(super) fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
        .anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
        .frame(egui::Frame::window(&ctx.global_style()).inner_margin(egui::Margin::same(18)))
        .show(ctx, |ui| {
-            ui.set_width(380.0);
+            // Tabs: About · Contributors · Models (the credits are compiled in, see `credits`).
+            let tab_id = egui::Id::new("about_tab");
+            let mut tab = ui.data_mut(|d| d.get_temp::<u8>(tab_id)).unwrap_or(0);
            ui.horizontal(|ui| {
-                let (r, _) = ui.allocate_exact_size(egui::vec2(44.0, 44.0), egui::Sense::hover());
-                crate::brand::paint_mark(ui, r);
-                ui.vertical(|ui| {
-                    ui.label(egui::RichText::new("VectorCraft").font(theme::semibold(22.0)));
-                    ui.label(crate::i18n::fmt(
-                        tl!("Version {version} — open-source vector illustration in pure Rust."),
-                        &[("version", env!("CARGO_PKG_VERSION"))],
-                    ));
-                });
+                for (i, label) in [tl!("About"), tl!("Contributors"), tl!("Models")].into_iter().enumerate() {
+                    let i = i as u8;
+                    if ui.selectable_label(tab == i, label).clicked() {
+                        tab = i;
+                    }
+                }
            });
-            ui.add_space(12.0);
-            crate::community::links(app, ui);
-            ui.add_space(12.0);
-            ui.label(
-                egui::RichText::new(tl!(
-                    "Part of ArtCraft. MIT OR Apache-2.0. Fonts: Source Sans 3, Inter, JetBrains Mono (OFL). Icons: Lucide (ISC) + VectorCraft."
-                ))
-                .size(11.0),
-            );
-            // The GPU the window renders with, for bug reports (Preferences › Performance picks it).
-            if let Some(adapter) = &app.graphics_adapter {
-                ui.add_space(6.0);
-                ui.label(egui::RichText::new(crate::i18n::fmt(tl!("Graphics: {adapter}"), &[("adapter", adapter.as_str())])).size(11.0));
+            ui.data_mut(|d| d.insert_temp(tab_id, tab));
+            ui.separator();
+            match tab {
+                1 => {
+                    ui.set_width(660.0);
+                    crate::credits::contributors_ui(ui);
+                }
+                2 => {
+                    ui.set_width(660.0);
+                    crate::credits::models_ui(ui);
+                }
+                _ => about_tab(app, ui),
            }
        });
    app.ui.about = open;
 }
+
+/// The About tab: mark, version, community links, licences and the GPU in use.
+fn about_tab(app: &mut VectorcraftApp, ui: &mut egui::Ui) {
+    ui.set_width(380.0);
+    ui.horizontal(|ui| {
+        let (r, _) = ui.allocate_exact_size(egui::vec2(44.0, 44.0), egui::Sense::hover());
+        crate::brand::paint_mark(ui, r);
+        ui.vertical(|ui| {
+            ui.label(egui::RichText::new("VectorCraft").font(theme::semibold(22.0)));
+            ui.label(crate::i18n::fmt(
+                tl!("Version {version} — open-source vector illustration in pure Rust."),
+                &[("version", env!("CARGO_PKG_VERSION"))],
+            ));
+        });
+    });
+    ui.add_space(12.0);
+    crate::community::links(app, ui);
+    ui.add_space(12.0);
+    ui.label(
+        egui::RichText::new(tl!(
+            "Part of ArtCraft. MIT OR Apache-2.0. Fonts: Source Sans 3, Inter, JetBrains Mono (OFL). Icons: Lucide (ISC) + VectorCraft."
+        ))
+        .size(11.0),
+    );
+    // The GPU the window renders with, for bug reports (Preferences › Performance picks it).
+    if let Some(adapter) = &app.graphics_adapter {
+        ui.add_space(6.0);
+        ui.label(egui::RichText::new(crate::i18n::fmt(tl!("Graphics: {adapter}"), &[("adapter", adapter.as_str())])).size(11.0));
+    }
+}
@@ -41,13 +41,7 @@ fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
    };
    form::slider(ui, d, "steps", tl!("Steps:"), 1.0..=max, "", &ramp);
    form::slider(ui, d, "amount", tl!("Variation:"), 0.0..=100.0, "%", &ramp);
-    ui.horizontal(|ui| {
-        ui.add_space(form::SLIDER_LABEL + ui.spacing().item_spacing.x);
-        let (r, _) = ui.allocate_exact_size(vec2(form::SLIDER_WIDTH, 14.0), Sense::hover());
-        let font = egui::FontId::proportional(11.0);
-        ui.painter().text(r.left_center(), egui::Align2::LEFT_CENTER, tl!("Less"), font.clone(), t.text_dim);
-        ui.painter().text(r.right_center(), egui::Align2::RIGHT_CENTER, tl!("More"), font, t.text_dim);
-    });
+    form::slider_ends(ui, form::SLIDER_LABEL, (tl!("Less"), tl!("More")));
    ui.add_space(10.0);
    // Preview: the base colour's row of variations.
    let o = options(app, d);
@@ -329,6 +329,19 @@ pub(super) fn slider_w(
    }
 }

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

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

-use crate::VectorcraftApp;
 use crate::state::Dialog;
 use crate::theme::{self, Tokens};
 use crate::widgets;
+use crate::{VectorcraftApp, font_menu};

 /// Open the dialog.
 pub fn open(app: &mut VectorcraftApp) {
@@ -34,6 +34,7 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
    let Some(mut d) = app.ui.dialog.clone() else { return };
    let t = Tokens::get(ctx);
    let list = fonts(app);
+    let sample = font_menu::sample_text(app);
    let mut close = false;
    let mut act: Option<&str> = None;
    egui::Area::new(egui::Id::new("modal-dim")).order(egui::Order::Middle).fixed_pos(egui::pos2(0.0, 0.0)).show(ctx, |ui| {
@@ -71,9 +72,11 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
            widgets::subheader(ui, tl!("Replace With Font"));
            let fam = d.str("family");
            ui.horizontal(|ui| {
-                if let Some(f) = widgets::font_dropdown(ui, "ff-family", &fam, 220.0) {
+                // Picks the font only: nothing is previewed on the document.
+                let pick = font_menu::font_menu(ui, "ff-family", &fam, 220.0, sample.as_deref(), font_menu::MenuLook::of(app));
+                if let Some((f, style)) = font_menu::picked(app, pick) {
                    d.fields.insert("family".into(), json!(f));
-                    d.fields.insert("style".into(), json!(""));
+                    d.fields.insert("style".into(), json!(style.unwrap_or_default()));
                }
                let styles = vectorcraft_text::FontDb::global().styles(&d.str("family"));
                // "(closest)" is ours; the font's style names are shown as they are.
@@ -1,10 +1,12 @@
-//! The font family menu of the Character and Properties panels: a search field over every family
-//! available, each row the family's name and a sample of the selected text set in it. The row
-//! under the pointer or reached with ↑/↓ previews its font on the selected text (one live
-//! interaction, nothing in the history); a click or Enter applies it as one step, Escape or
-//! closing the menu puts the text back. A star marks a favourite family, and the ★ filter lists
-//! only those. Preferences › Type › Enable in-menu font previews and Font Preview Size turn the
-//! samples off or size the rows.
+//! The font family menu of the Character, Properties and Glyphs panels and Find Font's Replace
+//! With: a search field over every family available, each row the family's name and a sample of
+//! the selected text set in it. In the Character and Properties panels the row under the pointer
+//! or reached with ↑/↓ previews its font on the selected text (one live interaction, nothing in
+//! the history); a click or Enter applies it as one step, Escape or closing the menu puts the text
+//! back. The Glyphs panel and Find Font only pick a font ([`picked`]): nothing is previewed on the
+//! document. A star marks a favourite family, and the ★ filter lists only those. Preferences ›
+//! Type › Enable in-menu font previews and Font Preview Size turn the samples off or size the
+//! rows.

 use std::collections::HashMap;
 use std::sync::Arc;
@@ -637,15 +639,7 @@ pub(crate) fn apply(app: &mut VectorcraftApp, ctx: &egui::Context, pick: FontPic
                app.sync_views();
            }
        }
-        FontPick::Favorite(f) => {
-            let favs = &mut app.ui.favorite_fonts;
-            match favs.iter().position(|x| x.eq_ignore_ascii_case(&f)) {
-                Some(i) => {
-                    favs.remove(i);
-                }
-                None => favs.push(f),
-            }
-        }
+        FontPick::Favorite(f) => toggle_favorite(app, f),
        FontPick::Chosen(f, style) => {
            if previewing {
                app.session.cancel_interaction().ok();
@@ -658,6 +652,31 @@ pub(crate) fn apply(app: &mut VectorcraftApp, ctx: &egui::Context, pick: FontPic
    }
 }

+/// Star `family`, or take its star off (any case).
+fn toggle_favorite(app: &mut VectorcraftApp, family: String) {
+    let favs = &mut app.ui.favorite_fonts;
+    match favs.iter().position(|x| x.eq_ignore_ascii_case(&family)) {
+        Some(i) => {
+            favs.remove(i);
+        }
+        None => favs.push(family),
+    }
+}
+
+/// For a font menu that only picks a font and never changes the document (Find Font's Replace
+/// With, the Glyphs panel): the family (and style) chosen, if any. A star is toggled here; the
+/// highlighted row is not previewed.
+pub(crate) fn picked(app: &mut VectorcraftApp, pick: Option<FontPick>) -> Option<(String, Option<String>)> {
+    match pick? {
+        FontPick::Chosen(f, style) => Some((f, style)),
+        FontPick::Favorite(f) => {
+            toggle_favorite(app, f);
+            None
+        }
+        FontPick::Preview(..) | FontPick::EndPreview => None,
+    }
+}
+
 /// The command that sets font `family` (and `style`, else the closest the family has) on what the
 /// menus act on.
 fn font_command(app: &VectorcraftApp, family: &str, style: Option<&str>) -> (&'static str, serde_json::Value) {
@@ -572,3 +572,34 @@
 	Collapse Panels to Icons	Sbalit panely na ikony
 	Collapse to Icons	Sbalit na ikony
 	Expand Panels	Rozbalit panely
+
+# About › Contributors / Models (credits.rs)
+	About	O aplikaci
+	Contributors	Přispěvatelé
+	Models	Modely
+	Username	Uživatelské jméno
+	Display name	Zobrazované jméno
+	Real name	Skutečné jméno
+	Sort	Řadit
+	Reverse the order	Obrátit pořadí
+	Grab bag	Volný seznam
+	Table	Tabulka
+	Name (A–Z)	Jméno (A–Z)
+	Merged PRs	Sloučené PR
+	Commits	Commity
+	Lines added	Přidané řádky
+	Lines deleted	Odstraněné řádky
+	Line delta	Rozdíl řádků
+	Binary assets added	Přidané binární soubory
+	Binary assets removed	Odstraněné binární soubory
+	First commit	První commit
+	Last commit	Poslední commit
+	First	První
+	Last	Poslední
+	{people} contributors · {commits} commits	Přispěvatelé: {people} · Commity: {commits}
+	No contributor data was built into this copy.	Tato kopie neobsahuje údaje o přispěvatelích.
+	No model credits were built into this copy.	Tato kopie neobsahuje uvedení modelů.
+	Company	Společnost
+	Version	Verze
+	% of all commits	% všech commitů
+	Lines +/−	Řádky +/−
@@ -36,11 +36,13 @@
 	[Default] is protected: New… starts an editable copy.	[Predeterminado] está protegido: Nuevo… crea una copia editable.
 	[Unnamed]	[Sin nombre]
 	A File…	Un archivo…
+	A lower value follows the stroke closely; a higher one gives fewer points and smoother curves.	Un valor menor sigue el trazo de cerca; uno mayor da menos puntos y curvas más suaves.
 	A new preset starting from the selected one	Un preajuste nuevo a partir del seleccionado
 	A saved copy of the selected preset	Una copia guardada del preajuste seleccionado
 	About VectorCraft	Acerca de VectorCraft
 	above	arriba
 	Absolute Position	Posición absoluta
+	Accurate	Preciso
 	Abutting	Contiguo
 	Action {n}	Acción {n}
 	Actions	Acciones
@@ -297,6 +299,7 @@
 	Changing these settings changes how raster effects look when exported, flattened or expanded.	Cambiar estos ajustes modifica el aspecto de los efectos ráster al exportar, acoplar o expandir.
 	Channel	Canal
 	Character	Carácter
+	Character Alignment	Alineación de caracteres
 	Character / Paragraph	Carácter / Párrafo
 	Character Rotation	Rotación de caracteres
 	Character Set:	Juego de caracteres:
@@ -347,6 +350,7 @@
 	Close All	Cerrar todo
 	Close Library	Cerrar biblioteca
 	Close Path	Cerrar trazado
+	Close paths when ends are within:	Cerrar trazados cuando los extremos estén a menos de:
 	Cmd	Cmd
 	CMYK	CMYK
 	CMYK Color	Color CMYK
@@ -726,6 +730,7 @@
 	Edit Pattern	Editar motivo
 	Edit PDF Preset	Editar preajuste de PDF
 	Edit Print Preset	Editar preajuste de impresión
+	Edit selected paths within:	Editar trazados seleccionados a menos de:
 	Edit Selection	Editar selección
 	Edit Selection…	Editar selección…
 	Edit Symbol	Editar símbolo
@@ -748,6 +753,9 @@
 	Ellipse Tool	Herramienta Elipse
 	Ellipse…	Elipse…
 	Ellipsis	Puntos suspensivos
+	Em Box Bottom/Left	Abajo/izquierda del cuadro eme
+	Em Box Center	Centro del cuadro eme
+	Em Box Top/Right	Arriba/derecha del cuadro eme
 	Em Dash	Raya
 	Em Space	Espacio eme
 	Embed	Incrustar
@@ -892,6 +900,7 @@
 	Fill & Stroke	Relleno y trazo
 	Fill (X), double-click for the Color Picker	Relleno (X), doble clic para el selector de color
 	Fill and Stroke	Relleno y trazo
+	Fill new strokes	Rellenar trazos nuevos
 	Fill Color	Color de relleno
 	Fill New Type Objects With Placeholder Text	Rellenar nuevos objetos de texto con texto de muestra
 	Fill Rule	Regla de relleno
@@ -1919,6 +1928,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
@@ -2076,6 +2090,7 @@
 	Right-to-Left Paragraph Direction	Dirección de párrafo de derecha a izquierda
 	Right:	Derecha:
 	Rise…	Ascenso…
+	Roman Baseline	Línea de base latina
 	Roman Hanging Punctuation	Puntuación colgante romana
 	Rotate	Rotar
 	Rotate 90° CW	Rotar 90° en sentido horario
@@ -2258,6 +2273,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
@@ -2962,3 +2978,34 @@
 # Leading model (Paragraph panel menu, East Asian options).
 	Top-to-Top Leading	Interlineado de superior a superior
 	Bottom-to-Bottom Leading	Interlineado de inferior a inferior
+
+# About › Contributors / Models (credits.rs)
+	About	Acerca de
+	Contributors	Colaboradores
+	Models	Modelos
+	Username	Nombre de usuario
+	Display name	Nombre visible
+	Real name	Nombre real
+	Sort	Ordenar
+	Reverse the order	Invertir el orden
+	Grab bag	Lista libre
+	Table	Tabla
+	Name (A–Z)	Nombre (A–Z)
+	Merged PRs	PR fusionadas
+	Commits	Commits
+	Lines added	Líneas agregadas
+	Lines deleted	Líneas eliminadas
+	Line delta	Diferencia de líneas
+	Binary assets added	Recursos binarios agregados
+	Binary assets removed	Recursos binarios eliminados
+	First commit	Primer commit
+	Last commit	Último commit
+	First	Primero
+	Last	Último
+	{people} contributors · {commits} commits	{people} colaboradores · {commits} commits
+	No contributor data was built into this copy.	Esta copia no incluye datos de colaboradores.
+	No model credits were built into this copy.	Esta copia no incluye créditos de modelos.
+	Company	Empresa
+	Version	Versión
+	% of all commits	% de todos los commits
+	Lines +/−	Líneas +/−
@@ -12,7 +12,11 @@
 	All Scripts	すべての文字
 	Any Kind	すべての種類
 	Bottom-to-Bottom Leading	欧文ベースライン基準の行送り
+	Character Alignment	文字揃え
 	Decorative	装飾
+	Em Box Bottom/Left	仮想ボディの下 / 左
+	Em Box Center	仮想ボディの中央
+	Em Box Top/Right	仮想ボディの上 / 右
 	Favorites	お気に入り
 	Japanese	日本語
 	Join Our Discord	Discord に参加
@@ -20,6 +24,7 @@
 	Mojikumi Set	文字組み
 	Latin	欧文
 	Monospaced	等幅
+	Roman Baseline	欧文ベースライン
 	Rounded	丸ゴシック
 	Sans Serif / Gothic	ゴシック・サンセリフ
 	Script / Brush	筆書体・スクリプト
@@ -660,9 +665,11 @@
 	< 1 sec	1 秒未満
 	<Opacity Mask>	<不透明マスク>
 	A File…	ファイル…
+	A lower value follows the stroke closely; a higher one gives fewer points and smoother curves.	値を小さくするとストロークに忠実に、大きくするとポイントが少なく滑らかな曲線になります。
 	A new preset starting from the selected one	選択したプリセットをもとにした新しいプリセット
 	A saved copy of the selected preset	選択したプリセットの保存済みの複製
 	Absolute Position	絶対位置
+	Accurate	精細
 	Abutting	隣接
 	Activate Document	ドキュメントをアクティブにする
 	Active Perspective Plane	アクティブな遠近面
@@ -869,6 +876,7 @@
 	Clipboard as Text	クリップボードをテキストとして取得
 	Close Library	ライブラリを閉じる
 	Close Path	パスを閉じる
+	Close paths when ends are within:	端点が次の距離以内のとき、パスを閉じる：
 	Collate	部単位で印刷
 	Collect in New Layer	新規レイヤーに集める
 	Color Burn	焼き込みカラー
@@ -1123,6 +1131,7 @@
 	Edit Print Preset	プリントプリセットを編集
 	Edit Symbol	シンボルを編集
 	Edit Theme	テーマを編集
+	Edit selected paths within:	選択したパスを次の距離以内で編集：
 	Edit or Apply Color Group	カラーグループを編集または適用
 	Edit or Apply Color Group…	カラーグループを編集または適用…
 	Edit or Apply Colors	カラーを編集／適用
@@ -1241,6 +1250,7 @@
 	Fill New Type Objects With Placeholder Text	新規テキストオブジェクトをダミーテキストで埋める
 	Fill Rule	塗りのルール
 	Fill and Stroke	塗りと線
+	Fill new strokes	新しいストロークに塗りを適用
 	Fill:	塗り:
 	Find	検索
 	Find Font	フォントを検索
@@ -1938,6 +1948,11 @@
 	Recent Files	最近使ったファイル
 	Recent Font 1	最近使ったフォント 1
 	Recent Font 10	最近使ったフォント 10
+	Recent Font 11	最近使ったフォント 11
+	Recent Font 12	最近使ったフォント 12
+	Recent Font 13	最近使ったフォント 13
+	Recent Font 14	最近使ったフォント 14
+	Recent Font 15	最近使ったフォント 15
 	Recent Font 2	最近使ったフォント 2
 	Recent Font 3	最近使ったフォント 3
 	Recent Font 4	最近使ったフォント 4
@@ -2829,6 +2844,7 @@
 	Search	検索
 	Security	セキュリティ
 	Select All Pins	すべてのピンを選択
+	Select Guides	ガイドを選択
 	Select text or click into text with the Type tool to insert glyphs	字形を挿入するには、テキストを選択するか、文字ツールでテキスト内をクリックしてください
 	Server-side (.map)	サーバーサイド (.map)
 	Set 1	セット 1
@@ -2951,3 +2967,34 @@
 	Saved Selection 25	保存した選択範囲 25
 	Left-to-Right Paragraph Direction	左から右への段落方向
 	Right-to-Left Paragraph Direction	右から左への段落方向
+
+# About › Contributors / Models (credits.rs)
+	About	情報
+	Contributors	コントリビューター
+	Models	モデル
+	Username	ユーザー名
+	Display name	表示名
+	Real name	本名
+	Sort	並べ替え
+	Reverse the order	順序を逆にする
+	Grab bag	まとめて表示
+	Table	表
+	Name (A–Z)	名前 (A–Z)
+	Merged PRs	マージされた PR
+	Commits	コミット
+	Lines added	追加した行数
+	Lines deleted	削除した行数
+	Line delta	行数の増減
+	Binary assets added	追加したバイナリアセット
+	Binary assets removed	削除したバイナリアセット
+	First commit	最初のコミット
+	Last commit	最後のコミット
+	First	最初
+	Last	最後
+	{people} contributors · {commits} commits	コントリビューター {people} 人 · コミット {commits} 件
+	No contributor data was built into this copy.	このビルドには貢献者のデータが含まれていません。
+	No model credits were built into this copy.	このビルドにはモデルのクレジットが含まれていません。
+	Company	企業
+	Version	バージョン
+	% of all commits	全コミットに占める割合
+	Lines +/−	行数 +/−
@@ -99,10 +99,12 @@
 	< 1 sec	< 1 segundo
 	<Opacity Mask>	<máscara de opacidade>
 	A File…	Um arquivo…
+	A lower value follows the stroke closely; a higher one gives fewer points and smoother curves.	Um valor menor segue o traço de perto; um valor maior gera menos pontos e curvas mais suaves.
 	A new preset starting from the selected one	Um novo predefinido a partir do selecionado
 	A saved copy of the selected preset	Uma cópia salva do predefinido selecionado
 	About VectorCraft	Sobre o VectorCraft
 	Absolute Position	Posição Absoluta
+	Accurate	Preciso
 	Abutting	Contíguo
 	Actions	Ações
 	Activate Document	Ativar Documento
@@ -334,6 +336,7 @@
 	Changing these settings changes how raster effects look when exported, flattened or expanded.	Alterar estas configurações muda a aparência dos efeitos de raster ao exportar, achatar ou expandir.
 	Channel	Canal
 	Character	Caractere
+	Character Alignment	Alinhamento de Caracteres
 	Character / Paragraph	Caractere / Parágrafo
 	Character Rotation	Rotação de Caractere
 	Character Set:	Conjunto de Caracteres:
@@ -381,6 +384,7 @@
 	Close All	Fechar Tudo
 	Close Library	Fechar Biblioteca
 	Close Path	Fechar Caminho
+	Close paths when ends are within:	Fechar caminhos quando as extremidades estiverem a menos de:
 	Collapse Panels to Icons	Recolher Painéis em Ícones
 	Collapse to Icons	Recolher em Ícones
 	Collate	Agrupar
@@ -695,6 +699,7 @@
 	Edit PDF Preset	Editar Predefinido de PDF
 	Edit Pattern	Editar Padrão
 	Edit Print Preset	Editar Predefinido de Impressão
+	Edit selected paths within:	Editar caminhos selecionados a menos de:
 	Edit Selection…	Editar Seleção…
 	Edit Symbol	Editar Símbolo
 	Edit Text	Editar Texto
@@ -717,6 +722,9 @@
 	Ellipse Tool	Ferramenta Elipse
 	Ellipse…	Elipse…
 	Ellipsis	Reticências
+	Em Box Bottom/Left	Base/Esquerda da Caixa Eme
+	Em Box Center	Centro da Caixa Eme
+	Em Box Top/Right	Topo/Direita da Caixa Eme
 	Em Dash	Travessão
 	Em Space	Espaço Em
 	Embed	Incorporar
@@ -848,6 +856,7 @@
 	Fill New Type Objects With Placeholder Text	Preencher Novos Objetos de Texto com Texto de Placeholder
 	Fill Rule	Regra de Preenchimento
 	Fill and Stroke	Preenchimento e Traçado
+	Fill new strokes	Preencher novos traçados
 	Fill with Placeholder Text	Preencher com Texto de Placeholder
 	Fill:	Preenchimento:
 	Find	Localizar
@@ -1730,6 +1739,11 @@
 	Recent Files	Arquivos Recentes
 	Recent Font 1	Fonte Recente 1
 	Recent Font 10	Fonte Recente 10
+	Recent Font 11	Fonte Recente 11
+	Recent Font 12	Fonte Recente 12
+	Recent Font 13	Fonte Recente 13
+	Recent Font 14	Fonte Recente 14
+	Recent Font 15	Fonte Recente 15
 	Recent Font 2	Fonte Recente 2
 	Recent Font 3	Fonte Recente 3
 	Recent Font 4	Fonte Recente 4
@@ -1868,6 +1882,7 @@
 	Right Plane	Plano Direito
 	Right:	Direita:
 	Rise…	Rise…
+	Roman Baseline	Linha de Base Romana
 	Roman Hanging Punctuation	Pontuação Pendurada Romana
 	Rotate	Girar
 	Rotate Tool	Ferramenta Girar
@@ -1998,6 +2013,7 @@
 	Select Appearance Item	Selecionar Item de Aparência
 	Select Freeform Point	Selecionar Ponto Livre
 	Select Gradient Stop	Selecionar Parada de Gradiente
+	Select Guides	Selecionar Guias
 	Select Objects	Selecionar Objetos
 	Select Same Tint %	Selecionar Mesmo Tom %
 	Select Slices	Selecionar Fatias
@@ -2570,3 +2586,34 @@
@plural	{n} star|{n} stars	{n} estrela|{n} estrelas
@plural	{n} step|{n} steps	{n} passo|{n} passos
@plural	{n} stroke|{n} strokes	{n} traçado|{n} traçados
+
+# About › Contributors / Models (credits.rs)
+	About	Sobre
+	Contributors	Colaboradores
+	Models	Modelos
+	Username	Nome de usuário
+	Display name	Nome de exibição
+	Real name	Nome real
+	Sort	Ordenar
+	Reverse the order	Inverter a ordem
+	Grab bag	Todos juntos
+	Table	Tabela
+	Name (A–Z)	Nome (A–Z)
+	Merged PRs	PRs mesclados
+	Commits	Commits
+	Lines added	Linhas adicionadas
+	Lines deleted	Linhas removidas
+	Line delta	Saldo de linhas
+	Binary assets added	Arquivos binários adicionados
+	Binary assets removed	Arquivos binários removidos
+	First commit	Primeiro commit
+	Last commit	Último commit
+	First	Primeiro
+	Last	Último
+	{people} contributors · {commits} commits	{people} colaboradores · {commits} commits
+	No contributor data was built into this copy.	Esta cópia foi compilada sem dados de colaboradores.
+	No model credits were built into this copy.	Esta cópia foi compilada sem créditos de modelos.
+	Company	Empresa
+	Version	Versão
+	% of all commits	% de todos os commits
+	Lines +/−	Linhas +/−
@@ -40,11 +40,13 @@
 	[Default] is protected: New… starts an editable copy.	[默认] 受保护：“新建…”会创建可编辑的副本。
 	[Unnamed]	[未命名]
 	A File…	文件…
+	A lower value follows the stroke closely; a higher one gives fewer points and smoother curves.	数值较小时紧贴所绘线条，较大时锚点较少、曲线更平滑。
 	A new preset starting from the selected one	以所选预设为基础的新预设
 	A saved copy of the selected preset	所选预设的副本
 	About VectorCraft	关于 VectorCraft
 	above	以上
 	Absolute Position	绝对位置
+	Accurate	精确
 	Abutting	相邻
 	Action {n}	动作 {n}
 	Actions	动作
@@ -300,6 +302,7 @@
 	Changing these settings changes how raster effects look when exported, flattened or expanded.	更改这些设置会改变栅格效果在导出、拼合或扩展时的外观。
 	Channel	色版
 	Character	字符
+	Character Alignment	字符对齐
 	Character / Paragraph	字符/段落
 	Character Rotation	字符旋转
 	Character Set:	字符集：
@@ -350,6 +353,7 @@
 	Close All	全部关闭
 	Close Library	关闭库
 	Close Path	闭合路径
+	Close paths when ends are within:	端点相距在以下范围内时闭合路径：
 	Cmd	Cmd
 	CMYK	CMYK
 	CMYK Color	CMYK 颜色
@@ -722,6 +726,7 @@
 	Edit Pattern	编辑图案
 	Edit PDF Preset	编辑 PDF 预设
 	Edit Print Preset	编辑打印预设
+	Edit selected paths within:	在以下范围内编辑所选路径：
 	Edit Selection…	编辑所选对象…
 	Edit Symbol	编辑符号
 	Edit Text	编辑文字
@@ -743,6 +748,9 @@
 	Ellipse Tool	椭圆工具
 	Ellipse…	椭圆形…
 	Ellipsis	删节号
+	Em Box Bottom/Left	全角字框下 / 左
+	Em Box Center	全角字框居中
+	Em Box Top/Right	全角字框上 / 右
 	Em Dash	长破折号
 	Em Space	全角空格
 	Embed	嵌入
@@ -886,6 +894,7 @@
 	Fill & Stroke	填色和描边
 	Fill (X), double-click for the Color Picker	填色 (X)，双击打开拾色器
 	Fill and Stroke	填色和描边
+	Fill new strokes	为新描边应用填色
 	Fill Color	填色
 	Fill New Type Objects With Placeholder Text	用占位文本填充新文字对象
 	Fill Rule	填充规则
@@ -1894,6 +1903,11 @@
 	Recent Font	最近字体
 	Recent Font 1	最近使用的字体 1
 	Recent Font 10	最近使用的字体 10
+	Recent Font 11	最近使用的字体 11
+	Recent Font 12	最近使用的字体 12
+	Recent Font 13	最近使用的字体 13
+	Recent Font 14	最近使用的字体 14
+	Recent Font 15	最近使用的字体 15
 	Recent Font 2	最近使用的字体 2
 	Recent Font 3	最近使用的字体 3
 	Recent Font 4	最近使用的字体 4
@@ -2048,6 +2062,7 @@
 	Right-Justified Tab	右对齐制表位
 	Right:	右：
 	Rise…	上升…
+	Roman Baseline	罗马基线
 	Roman Hanging Punctuation	西文悬挂标点
 	Rotate	旋转
 	Rotate 90° CW	顺时针旋转 90°
@@ -3174,6 +3189,7 @@
 	Release to Layers (Build)	释放到图层 (累积)
 	Release to Layers (Sequence)	释放到图层 (顺序)
 	Select Art	选择图稿
+	Select Guides	选择参考线
 	Show All Layers	显示所有图层
 	Unlock All Layers	解锁所有图层

@@ -3209,3 +3225,34 @@
 	Saved Selection 23	已保存的选区 23
 	Saved Selection 24	已保存的选区 24
 	Saved Selection 25	已保存的选区 25
+
+# About › Contributors / Models (credits.rs)
+	About	关于
+	Contributors	贡献者
+	Models	模型
+	Username	用户名
+	Display name	显示名称
+	Real name	真实姓名
+	Sort	排序
+	Reverse the order	反转顺序
+	Grab bag	名单
+	Table	表格
+	Name (A–Z)	名称 (A–Z)
+	Merged PRs	已合并的 PR
+	Commits	提交
+	Lines added	新增行数
+	Lines deleted	删除行数
+	Line delta	行数变化
+	Binary assets added	新增二进制资源
+	Binary assets removed	删除二进制资源
+	First commit	首次提交
+	Last commit	最近提交
+	First	首次
+	Last	最近
+	{people} contributors · {commits} commits	{people} 位贡献者 · {commits} 次提交
+	No contributor data was built into this copy.	此版本未包含贡献者数据。
+	No model credits were built into this copy.	此版本未包含模型致谢。
+	Company	公司
+	Version	版本
+	% of all commits	占全部提交的百分比
+	Lines +/−	行数 +/−
@@ -48,11 +48,13 @@
 	[Default] is protected: New… starts an editable copy.	[預設] 受到保護：「新增…」會開始一份可編輯的複本。
 	[Unnamed]	[未命名]
 	A File…	一個檔案…
+	A lower value follows the stroke closely; a higher one gives fewer points and smoother curves.	數值較小時會貼近筆畫，較大時則錨點較少、曲線較平滑。
 	A new preset starting from the selected one	以所選預設集為基礎建立新預設集
 	A saved copy of the selected preset	所選預設集的已儲存拷貝
 	About VectorCraft	關於 VectorCraft
 	above	以上
 	Absolute Position	絕對位置
+	Accurate	精確
 	Abutting	相鄰
 	Action {n}	動作 {n}
 	Actions	動作
@@ -312,6 +314,7 @@
 	Channel	色版
 	Character	字元
 	Character / Paragraph	字元／段落
+	Character Alignment	字元對齊
 	Character Rotation	字元旋轉
 	Character Set:	字元集：
 	Character Style	字元樣式
@@ -361,6 +364,7 @@
 	Close All	全部關閉
 	Close Library	關閉資料庫
 	Close Path	封閉路徑
+	Close paths when ends are within:	端點相距在以下範圍內時封閉路徑：
 	Cmd	Cmd
 	CMYK	CMYK
 	CMYK Color	CMYK 色彩
@@ -740,6 +744,7 @@
 	Edit Pattern	編輯圖樣
 	Edit PDF Preset	編輯 PDF 預設集
 	Edit Print Preset	編輯列印預設集
+	Edit selected paths within:	在以下範圍內編輯選取的路徑：
 	Edit Selection	編輯選取範圍
 	Edit Selection…	編輯選取範圍…
 	Edit Symbol	編輯符號
@@ -762,6 +767,9 @@
 	Ellipse Tool	橢圓工具
 	Ellipse…	橢圓形…
 	Ellipsis	刪節號
+	Em Box Bottom/Left	全形字框下 / 左
+	Em Box Center	全形字框中央
+	Em Box Top/Right	全形字框上 / 右
 	Em Dash	長破折號
 	Em Space	全形空格
 	Embed	嵌入
@@ -909,6 +917,7 @@
 	Fill (X), double-click for the Color Picker	填色 (X)，按兩下開啟檢色器
 	Fill and Stroke	填色與筆畫
 	Fill Color	填色顏色
+	Fill new strokes	為新筆畫套用填色
 	Fill New Type Objects With Placeholder Text	以預留位置文字填滿新文字物件
 	Fill Rule	填色規則
 	Fill with Placeholder Text	以預留位置文字填滿
@@ -1938,6 +1947,11 @@
 	Recent Font	最近使用的字體
 	Recent Font 1	最近使用的字體 1
 	Recent Font 10	最近使用的字體 10
+	Recent Font 11	最近使用的字體 11
+	Recent Font 12	最近使用的字體 12
+	Recent Font 13	最近使用的字體 13
+	Recent Font 14	最近使用的字體 14
+	Recent Font 15	最近使用的字體 15
 	Recent Font 2	最近使用的字體 2
 	Recent Font 3	最近使用的字體 3
 	Recent Font 4	最近使用的字體 4
@@ -2095,6 +2109,7 @@
 	Right-to-Left Paragraph Direction	從右至左段落方向
 	Right:	右：
 	Rise…	上升…
+	Roman Baseline	羅馬基線
 	Roman Hanging Punctuation	羅馬懸掛標點
 	Rotate	旋轉
 	Rotate 90° CW	順時針旋轉 90°
@@ -2277,6 +2292,7 @@
 	Select art and use New Brush to make one.	選取圖稿，然後使用「新增筆刷」來製作。
 	Select Freeform Point	選取任意形狀點
 	Select Gradient Stop	選取漸層色標
+	Select Guides	選取參考線
 	Select Objects	選取物件
 	Select objects to see their CSS, or Generate CSS for the whole document.	選取物件以檢視其 CSS，或對整份文件「產生 CSS」。
 	Select Same Tint %	選取相同色調 %
@@ -2982,3 +2998,34 @@
 	  — {n} characters from another font	  — {n} 個字符來自其他字體
 	[Normal Character Style]	[正常字元樣式]
 	[Normal Paragraph Style]	[正常段落樣式]
+
+# About › Contributors / Models (credits.rs)
+	About	關於
+	Contributors	貢獻者
+	Models	模型
+	Username	使用者名稱
+	Display name	顯示名稱
+	Real name	真實姓名
+	Sort	排序
+	Reverse the order	反轉順序
+	Grab bag	全部列出
+	Table	表格
+	Name (A–Z)	名稱 (A–Z)
+	Merged PRs	已合併的 PR
+	Commits	提交
+	Lines added	新增行數
+	Lines deleted	刪除行數
+	Line delta	行數增減
+	Binary assets added	新增的二進位資產
+	Binary assets removed	移除的二進位資產
+	First commit	首次提交
+	Last commit	最近一次提交
+	First	首次
+	Last	最近
+	{people} contributors · {commits} commits	{people} 位貢獻者 · {commits} 次提交
+	No contributor data was built into this copy.	此版本未內建貢獻者資料。
+	No model credits were built into this copy.	此版本未內建模型致謝資料。
+	Company	公司
+	Version	版本
+	% of all commits	佔全部提交的比例
+	Lines +/−	行數 +/−
@@ -19,6 +19,7 @@ pub mod canvas;
 pub mod chrome;
 pub mod community;
 pub mod control;
+pub mod credits;
 pub mod cursors;
 pub mod dialogs;
 pub mod dock;
@@ -106,6 +107,8 @@ mod tests_save;
 #[cfg(test)]
 mod tests_saveext;
 #[cfg(test)]
+mod tests_selectall;
+#[cfg(test)]
 mod tests_slices;
 #[cfg(test)]
 mod tests_svg;
@@ -420,6 +423,7 @@ impl VectorcraftApp {
            zoom: self.view().map(|v| v.zoom).unwrap_or(1.0),
            outline: self.ui.view.outline,
            smart_guides: self.ui.view.smart_guides,
+            guides: self.ui.view.guides,
            snap_to_grid: self.ui.view.snap_to_grid,
            snap_to_pixel: self.ui.view.snap_to_pixel,
            show_bbox: self.ui.view.bounding_box,
@@ -490,7 +494,7 @@ impl VectorcraftApp {
                    let r = &mut self.ui.recent_fonts;
                    r.retain(|f| f != font);
                    r.insert(0, font.to_string());
-                    r.truncate(10);
+                    r.truncate(MAX_RECENT_FONTS);
                }
            }
        }
@@ -656,7 +660,17 @@ pub fn now_ms() -> f64 {
    }
 }

+/// The most fonts Type › Recent Fonts lists (Preferences › Type › Number of Recent Fonts).
+pub const MAX_RECENT_FONTS: usize = 15;
+
 impl VectorcraftApp {
+    /// Type › Recent Fonts: the fonts used last, newest first, as many as Preferences › Type ›
+    /// Number of Recent Fonts says.
+    pub fn recent_fonts(&self) -> &[String] {
+        let n = usize::try_from(self.session.prefs.recent_fonts_count).unwrap_or(MAX_RECENT_FONTS).clamp(1, MAX_RECENT_FONTS);
+        self.ui.recent_fonts.get(..n).unwrap_or(&self.ui.recent_fonts)
+    }
+
    /// The selection's bounding box, rotated with rotated objects ([`Session::transform_box`]). The
    /// canvas and the transform fields read it every frame: it is measured once per revision.
    pub fn selection_box(&mut self) -> Option<vectorcraft_doc::OrientedBox> {
@@ -785,9 +799,9 @@ impl VectorcraftApp {
        place::drop_files(self, files, target);
    }

-    /// Inject synthetic events (one press/release step per frame). Handlers read the modifiers
-    /// egui holds (`i.modifiers`), so a synthetic key or button holds its own for the frames it
-    /// spans (a drag's moves included); the keyboard's come back after.
+    /// Inject synthetic events (one press/release step or wheel turn per frame). Handlers read the
+    /// modifiers egui holds (`i.modifiers`), so a synthetic key, button or wheel turn holds its own
+    /// for the frames it spans (a drag's moves included); the keyboard's come back after.
    pub fn raw_input_hook(&mut self, raw: &mut egui::RawInput) {
        for e in &raw.events {
            match e {
@@ -805,7 +819,7 @@ impl VectorcraftApp {
        // Pointer events go one per frame so egui sees presses, drags and releases as real input;
        // keyboard sequences go up to the key release.
        let n = match first {
-            egui::Event::PointerMoved(_) | egui::Event::PointerButton { .. } => 1,
+            egui::Event::PointerMoved(_) | egui::Event::PointerButton { .. } | egui::Event::MouseWheel { .. } => 1,
            _ => self.synthetic.iter().position(|e| matches!(e, egui::Event::Key { pressed: false, .. })).map_or(self.synthetic.len(), |i| i + 1),
        };
        if let egui::Event::PointerMoved(p) | egui::Event::PointerButton { pos: p, .. } = first {
@@ -816,7 +830,9 @@ impl VectorcraftApp {
        let held = now
            .iter()
            .find_map(|e| match e {
-                egui::Event::Key { modifiers, .. } | egui::Event::PointerButton { modifiers, .. } => Some(*modifiers),
+                egui::Event::Key { modifiers, .. } | egui::Event::PointerButton { modifiers, .. } | egui::Event::MouseWheel { modifiers, .. } => {
+                    Some(*modifiers)
+                }
                _ => None,
            })
            .or_else(|| match later.iter().find(|e| matches!(e, egui::Event::PointerButton { .. })) {
@@ -124,6 +124,11 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
    ("type.recentFont8", "Recent Font 8", "", "{} apply the 8. most recently used font"),
    ("type.recentFont9", "Recent Font 9", "", "{} apply the 9. most recently used font"),
    ("type.recentFont10", "Recent Font 10", "", "{} apply the 10. most recently used font"),
+    ("type.recentFont11", "Recent Font 11", "", "{} apply the 11. most recently used font"),
+    ("type.recentFont12", "Recent Font 12", "", "{} apply the 12. most recently used font"),
+    ("type.recentFont13", "Recent Font 13", "", "{} apply the 13. most recently used font"),
+    ("type.recentFont14", "Recent Font 14", "", "{} apply the 14. most recently used font"),
+    ("type.recentFont15", "Recent Font 15", "", "{} apply the 15. most recently used font"),
    ("file.clearRecent", "Clear Recent Files", "", "{}"),
    ("type.findFont", "Find Font…", "", "{} open the Find Font dialog (engine: text.fonts / text.replaceFont / select.font)"),
    ("file.recentFiles", "Recent Files", "", "{} → [path…] most recent first"),
@@ -276,7 +281,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
        "tool.options",
        "Tool Options…",
        "",
-        "{tool: id} what double-clicking a tool button opens: hand → fits the artboard in the window (view.fitArtboard), zoom → 100% (view.actualSize), rotate|scale|reflect|shear → that Object › Transform dialog (dialog `rotate`, `scale`, `reflect` or `shear`; error `nothing selected` without a selection), selection|directSelection|groupSelection → the Move dialog (dialog `move`; the same error), gradient → the Gradient panel (window.panel), eyedropper → Eyedropper Options (dialog `eyedropperOptions`, fields sampleSize, pickUp, apply; OK runs eyedropper.setOptions), printTiling → resets the print tiling (print.tiling.set {reset: true}), warp|twirl|pucker|bloat|scallop|crystallize|wrinkle → that tool's Tool Options (dialog `liquifyOptions`, fields tool, width, height, angle, intensity %, usePressure, detail, simplify, simplifyOn, rate, complexity, horizontal %, vertical %, affectAnchors, affectIn, affectOut, showBrush; OK runs tool.setOption {tool, values})",
+        "{tool: id} what double-clicking a tool button opens: hand → fits the artboard in the window (view.fitArtboard), zoom → 100% (view.actualSize), rotate|scale|reflect|shear → that Object › Transform dialog (dialog `rotate`, `scale`, `reflect` or `shear`; error `nothing selected` without a selection), selection|directSelection|groupSelection → the Move dialog (dialog `move`; the same error), gradient → the Gradient panel (window.panel), eyedropper → Eyedropper Options (dialog `eyedropperOptions`, fields sampleSize, pickUp, apply; OK runs eyedropper.setOptions), printTiling → resets the print tiling (print.tiling.set {reset: true}), warp|twirl|pucker|bloat|scallop|crystallize|wrinkle → that tool's Tool Options (dialog `liquifyOptions`, fields tool, width, height, angle, intensity %, usePressure, detail, simplify, simplifyOn, rate, complexity, horizontal %, vertical %, affectAnchors, affectIn, affectOut, showBrush; OK runs tool.setOption {tool, values}), pencil|paintbrush|smooth|blobBrush|eraser → that tool's Tool Options (dialog `freehandOptions`, fields tool and the options the tool keeps: fidelity (pt), fill, closeWithin and editWithin (px, 0 is off), size (pt); OK runs tool.setOption {tool, values})",
    ),
    (
        "ui.colorGuideOptions",
@@ -896,7 +901,7 @@ pub fn run_ui_command(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<R
        },
        id if id.starts_with("type.recentFont") => {
            let n: usize = id["type.recentFont".len()..].parse().unwrap_or(0);
-            match n.checked_sub(1).and_then(|i| app.ui.recent_fonts.get(i)).cloned() {
+            match n.checked_sub(1).and_then(|i| app.recent_fonts().get(i)).cloned() {
                Some(font) => app.run("text.setStyle", json!({ "font": font })),
                None => Err("no such recent font".into()),
            }
@@ -905,16 +910,29 @@ pub fn run_ui_command(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<R
        "view.artboards" => flag(&mut app.ui.view.artboards),
        "view.rulers" => flag(&mut app.ui.view.rulers),
        "view.boundingBox" => flag(&mut app.ui.view.bounding_box),
-        "view.guides" => flag(&mut app.ui.view.guides),
+        "view.guides" => {
+            let r = flag(&mut app.ui.view.guides);
+            // Hidden guides can't stay selected (selected, they are all that is).
+            if !app.ui.view.guides && app.session.active().is_some_and(|d| !d.selection.guides.is_empty()) {
+                // Deselecting a document that is open can't fail.
+                let _ = app.run("select.none", json!({}));
+            }
+            r
+        }
        "view.smartGuides" => flag(&mut app.ui.view.smart_guides),
        "view.grid" => flag(&mut app.ui.view.grid),
        "view.snapToGrid" => flag(&mut app.ui.view.snap_to_grid),
        "view.snapToPoint" => flag(&mut app.ui.view.snap_to_point),
        "view.zoomIn" | "view.zoomOut" => {
            let up = id == "view.zoomIn";
+            // Selection & Anchor Display › Zoom to Selection: the selection comes to the middle.
+            let focus = if app.session.prefs.zoom_to_selection { app.selection_box().map(|b| b.center()) } else { None };
            match app.view_mut() {
                Some(v) => {
                    v.zoom = next_zoom(v.zoom, up);
+                    if let Some(c) = focus {
+                        v.center = c;
+                    }
                    Ok(json!({"zoom": v.zoom * 100.0}))
                }
                None => Err("no document".into()),
@@ -1333,7 +1351,7 @@ pub fn dynamic_label(app: &VectorcraftApp, id: &str, label: &str) -> String {
        },
        id if id.starts_with("type.recentFont") => {
            let n: usize = id["type.recentFont".len()..].parse().unwrap_or(0);
-            n.checked_sub(1).and_then(|i| app.ui.recent_fonts.get(i)).cloned().unwrap_or_else(|| "—".into())
+            n.checked_sub(1).and_then(|i| app.recent_fonts().get(i)).cloned().unwrap_or_else(|| "—".into())
        }
        id if id.starts_with("view.goto") => {
            let n: usize = id["view.goto".len()..].parse().unwrap_or(0);
@@ -1590,8 +1608,8 @@ fn saved_selection_slot(id: &str) -> Option<usize> {
    id.strip_prefix("select.recall")?.parse().ok()
 }

-/// Type → Recent Fonts slots.
-const RECENT_FONT_IDS: [&str; 10] = [
+/// Type → Recent Fonts slots (Preferences › Type › Number of Recent Fonts shows up to 15).
+const RECENT_FONT_IDS: [&str; crate::MAX_RECENT_FONTS] = [
    "type.recentFont1",
    "type.recentFont2",
    "type.recentFont3",
@@ -1602,6 +1620,11 @@ const RECENT_FONT_IDS: [&str; 10] = [
    "type.recentFont8",
    "type.recentFont9",
    "type.recentFont10",
+    "type.recentFont11",
+    "type.recentFont12",
+    "type.recentFont13",
+    "type.recentFont14",
+    "type.recentFont15",
 ];

 /// Effective shortcut of a command: the user's override (Edit → Keyboard Shortcuts) or the default.
@@ -1647,7 +1670,7 @@ pub fn enabled(app: &VectorcraftApp, id: &str) -> bool {
        id if id.starts_with("file.openRecent") => recent_slot(app, id).is_some(),
        "file.clearRecent" => !app.ui.recent_files.is_empty(),
        id if id.starts_with("type.recentFont") => {
-            id["type.recentFont".len()..].parse::<usize>().is_ok_and(|n| n >= 1 && n <= app.ui.recent_fonts.len()) && app.session.active().is_some()
+            id["type.recentFont".len()..].parse::<usize>().is_ok_and(|n| n >= 1 && n <= app.recent_fonts().len()) && app.session.active().is_some()
        }
        id if saved_selection_slot(id).is_some() => saved_selection_name(app, id).is_some(),
        id if id.starts_with("view.goto") => {
@@ -2653,6 +2676,32 @@ fn menu_dialog(id: &str) -> Option<(&'static str, Value)> {
    })
 }

+/// The event a focused text field takes for Edit-menu command `id` (Select All, Cut, Copy,
+/// Paste), as the same keys would send it.
+fn field_event(app: &mut VectorcraftApp, id: &str) -> Option<egui::Event> {
+    Some(match id {
+        "select.all" => egui::Event::Key { key: egui::Key::A, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::COMMAND },
+        "edit.copy" => egui::Event::Copy,
+        "edit.cut" => egui::Event::Cut,
+        "edit.paste" | "edit.pasteWithoutFormatting" => egui::Event::Paste(app.system_clipboard_text()?),
+        _ => return None,
+    })
+}
+
+/// Invoke an item of the system menu bar (macOS), chosen by a click or by its key equivalent: the
+/// system takes those keys before the window sees them. While a text field has the keyboard,
+/// Select All, Cut, Copy and Paste act on the field's text, as their keys do in the window;
+/// everything else (and those commands with no field focused) goes to [`invoke`].
+pub fn invoke_from_system_menu(app: &mut VectorcraftApp, ctx: &egui::Context, id: &str, p: Value) {
+    if ctx.text_edit_focused()
+        && let Some(e) = field_event(app, id)
+    {
+        ctx.input_mut(|i| i.events.push(e));
+        return;
+    }
+    invoke(app, id, p);
+}
+
 /// Invoke a menu/command id with UI side effects (dialogs for "…" commands that need input).
 pub fn invoke(app: &mut VectorcraftApp, id: &str, p: Value) {
    if waits_for_ime(app, id) {
@@ -3429,6 +3478,39 @@ mod tests {
        assert_eq!(dynamic_label(&app, "view.cornerWidget", ""), "Show Corner Widget");
    }

+    /// Selection & Anchor Display › Zoom to Selection (#394): Zoom In and Zoom Out bring the
+    /// selection to the middle; off, they keep the view's centre.
+    #[test]
+    fn zoom_to_selection_centres_the_selection() {
+        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+        app.run("shape.rectangle", json!({"x": 10, "y": 20, "width": 40, "height": 20})).unwrap();
+        let center = |app: &VectorcraftApp| app.view().unwrap().center;
+        let start = center(&app);
+        app.run("prefs.set", json!({"key": "zoomToSelection", "value": false})).unwrap();
+        app.run("view.zoomIn", json!({})).unwrap();
+        assert_eq!(center(&app), start, "off: the view's centre stays");
+        app.run("prefs.set", json!({"key": "zoomToSelection", "value": true})).unwrap();
+        app.run("view.zoomOut", json!({})).unwrap();
+        assert_eq!(center(&app), vectorcraft_geom::Point::new(30.0, 30.0), "on: the selection's centre");
+    }
+
+    /// Preferences › Type › Number of Recent Fonts (#394): Type › Recent Fonts lists that many.
+    #[test]
+    fn number_of_recent_fonts_sets_how_many_are_listed() {
+        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), crate::Services::default());
+        app.run("file.new", json!({})).unwrap();
+        app.ui.recent_fonts = (1..=15).map(|i| format!("Font {i}")).collect();
+        let listed = |app: &VectorcraftApp| RECENT_FONT_IDS.iter().filter(|id| enabled(app, id)).count();
+        assert_eq!(listed(&app), 10, "10 by default");
+        for n in [15, 2] {
+            app.run("prefs.set", json!({"key": "recentFontsCount", "value": n})).unwrap();
+            assert_eq!(listed(&app), n);
+        }
+        assert_eq!(dynamic_label(&app, "type.recentFont2", "Recent Font"), "Font 2");
+        assert!(app.run("type.recentFont3", json!({})).is_err(), "past the count");
+    }
+
    #[test]
    fn recent_files_track_opens_and_saves() {
        let dir = std::env::temp_dir().join(format!("dc-recent-{}", std::process::id()));
@@ -123,8 +123,8 @@ fn text_paste(app: &mut VectorcraftApp, s: Option<String>) {
    }
 }

-/// Edit-menu commands while the Type tool edits text act on the text (Cut/Copy/Paste/Select
-/// All/Clear). `None` = not intercepted.
+/// Edit-menu commands while the Type tool edits text act on the text (Cut/Copy/Paste/Clear;
+/// Select All is the engine's `select.all`). `None` = not intercepted.
 pub(crate) fn intercept_text_command(app: &mut VectorcraftApp, id: &str) -> Option<Result<Value, String>> {
    if !app.session.tool_wants_text() {
        return None;
@@ -139,7 +139,6 @@ pub(crate) fn intercept_text_command(app: &mut VectorcraftApp, id: &str) -> Opti
            }
        }
        "edit.paste" | "edit.pasteWithoutFormatting" => text_paste(app, None),
-        "select.all" => app.session.set_tool_option("selectAll", &json!(true)),
        "edit.clear" => text_key(app, ToolKey::Delete, Mods::default()),
        _ => return None,
    }
@@ -152,10 +151,10 @@ enum TextInput {
    Copy,
    Cut,
    Paste(Option<String>),
-    SelectAll,
 }

-/// Route editing keys (with modifiers), clipboard events and Cmd+A/C/X/V to the Type tool.
+/// Route editing keys (with modifiers), clipboard events and Cmd+C/X/V to the Type tool (Cmd+A is
+/// left to the Select All shortcut, which selects the text being edited).
 pub(crate) fn route_type_input(app: &mut VectorcraftApp, ctx: &egui::Context) {
    CTX.get_or_init(|| ctx.clone());
    let mut todo = vec![];
@@ -193,10 +192,9 @@ pub(crate) fn route_type_input(app: &mut VectorcraftApp, ctx: &egui::Context) {
                    }
                    return false;
                }
-                if m.command && !m.shift && !m.alt && matches!(key, Key::A | Key::C | Key::X | Key::V) {
+                if m.command && !m.shift && !m.alt && matches!(key, Key::C | Key::X | Key::V) {
                    if *pressed {
                        todo.push(match key {
-                            Key::A => TextInput::SelectAll,
                            Key::C => TextInput::Copy,
                            Key::X => TextInput::Cut,
                            _ => TextInput::Paste(None),
@@ -221,7 +219,6 @@ pub(crate) fn route_type_input(app: &mut VectorcraftApp, ctx: &egui::Context) {
                }
            }
            TextInput::Paste(s) => text_paste(app, s),
-            TextInput::SelectAll => app.session.set_tool_option("selectAll", &json!(true)),
        }
    }
 }
@@ -398,6 +395,28 @@ pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
        menu_item(ui, tl!(l), false, false);
    }
    ui.separator();
+    // Character Alignment: where characters smaller than the largest on their line line up, with
+    // the East Asian options.
+    if app.session.prefs.show_east_asian_options {
+        let align = s.as_ref().map(|s| s.char_align);
+        ui.add_enabled_ui(has, |ui| {
+            // Indented like the items beside it (their check column).
+            ui.menu_button(format!("   {}", tl!("Character Alignment")), |ui| {
+                use vectorcraft_doc::CharAlign;
+                for (label, a, key) in [
+                    (tl!("Roman Baseline"), CharAlign::RomanBaseline, "romanBaseline"),
+                    (tl!("Em Box Top/Right"), CharAlign::EmBoxTop, "emBoxTop"),
+                    (tl!("Em Box Center"), CharAlign::EmBoxCenter, "emBoxCenter"),
+                    (tl!("Em Box Bottom/Left"), CharAlign::EmBoxBottom, "emBoxBottom"),
+                ] {
+                    if menu_item(ui, label, true, align == Some(a)) {
+                        format(app, json!({"charAlign": key}));
+                    }
+                }
+            });
+        });
+        ui.separator();
+    }
    for l in ["Standard Vertical Roman Alignment", "Tate-chu-yoko", "Fractional Widths", "System Layout", "No Break"] {
        menu_item(ui, tl!(l), false, l == "Fractional Widths");
    }
@@ -417,3 +436,23 @@ pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
        );
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use vectorcraft_engine::Session;
+
+    /// Character Alignment is in the panel menu with the East Asian options only (as Mojikumi Set
+    /// and Top-to-Top Leading are in the Paragraph panel).
+    #[test]
+    fn character_alignment_shows_with_the_east_asian_options() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 300, "height": 200})).unwrap();
+        let id = app.session.execute("text.create", &json!({"x": 20, "y": 50, "text": "雅楽"})).unwrap()["id"].clone();
+        app.session.execute("select.set", &json!({"ids": [id]})).unwrap();
+        let shown = |app: &mut VectorcraftApp| crate::tests_labels::painted_text(app, menu).contains("Character Alignment");
+        assert!(!shown(&mut app));
+        app.session.prefs.show_east_asian_options = true;
+        assert!(shown(&mut app));
+    }
+}
@@ -198,8 +198,12 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
        .color(t.text_dim),
    );
    ui.horizontal(|ui| {
-        if let Some(f) = widgets::font_dropdown(ui, "gl-family", &family, (w * 0.6).max(80.0)) {
-            let st = db.face(&f, "Regular").map_or_else(|| "Regular".into(), |face| face.style.clone());
+        // Picks the font the panel browses only: nothing is previewed on the document.
+        let sample = crate::font_menu::sample_text(app);
+        let look = crate::font_menu::MenuLook::of(app);
+        let pick = crate::font_menu::font_menu(ui, "gl-family", &family, (w * 0.6).max(80.0), sample.as_deref(), look);
+        if let Some((f, style)) = crate::font_menu::picked(app, pick) {
+            let st = style.unwrap_or_else(|| db.face(&f, "Regular").map_or_else(|| "Regular".into(), |face| face.style.clone()));
            set_pstate(ui.ctx(), "gl-font", Some((f, st)));
        }
        let styles = db.styles(&family);
@@ -77,6 +77,7 @@ struct Applied {
    brightness: Brightness,
    white_canvas: bool,
    threads: i32,
+    tool_tips: bool,
 }

 /// Per frame: push UI-side preferences into egui / the renderer when they change.
@@ -87,11 +88,16 @@ pub fn apply_runtime(app: &mut VectorcraftApp, ctx: &egui::Context) {
    {
        app.ui.brightness = b;
    }
-    let want = Applied { brightness: app.ui.brightness, white_canvas: p.canvas_color == "white", threads: p.render_threads };
+    let want =
+        Applied { brightness: app.ui.brightness, white_canvas: p.canvas_color == "white", threads: p.render_threads, tool_tips: p.show_tool_tips };
    let id = egui::Id::new("dc-applied-prefs");
    let prev: Option<Applied> = ctx.data(|d| d.get_temp::<Option<Applied>>(id)).flatten();
    if prev != Some(want) {
        theme::apply(ctx, want.brightness);
+        // General › Show Tool Tips: off, no button or field shows its tool tip (they never come
+        // due), whichever widget asks for one.
+        let delay = if want.tool_tips { egui::style::Interaction::default().tooltip_delay } else { f32::INFINITY };
+        ctx.global_style_mut(|s| s.interaction.tooltip_delay = delay);
        if want.white_canvas {
            let mut t = Tokens::get(ctx);
            t.pasteboard = egui::Color32::WHITE;
@@ -366,6 +372,52 @@ mod tests {
        assert_eq!(a.ui.engine_prefs["keyboardIncrement"], json!(4.0));
    }

+    /// General › Show Tool Tips: off, a button held under the pointer shows no tool tip; back on,
+    /// it does again (#394).
+    #[test]
+    fn show_tool_tips_off_hides_tool_tips() {
+        fn texts(s: &egui::Shape, out: &mut Vec<String>) {
+            match s {
+                egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
+                egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
+                _ => {}
+            }
+        }
+        let mut a = app();
+        let ctx = egui::Context::default();
+        let mut time = 0.0;
+        // Come from elsewhere and hover the button for two seconds: did its tool tip show?
+        let mut hover = |a: &mut VectorcraftApp| {
+            let mut shown = vec![];
+            for i in 0..20 {
+                time += 0.1;
+                let events = match i {
+                    0 => vec![egui::Event::PointerGone],
+                    1 => vec![egui::Event::PointerMoved(egui::pos2(20.0, 12.0))],
+                    _ => vec![],
+                };
+                let raw = egui::RawInput {
+                    events,
+                    time: Some(time),
+                    screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(400.0, 300.0))),
+                    ..Default::default()
+                };
+                let mut out = ctx.run_ui(raw, |ui| {
+                    apply_runtime(a, ui.ctx());
+                    ui.button("Button").on_hover_text("The tool tip");
+                });
+                out.textures_delta.clear();
+                out.shapes.iter().for_each(|c| texts(&c.shape, &mut shown));
+            }
+            shown.iter().any(|t| t == "The tool tip")
+        };
+        assert!(hover(&mut a), "on by default");
+        a.run("prefs.set", json!({"key": "showToolTips", "value": false})).unwrap();
+        assert!(!hover(&mut a), "off: no tool tip");
+        a.run("prefs.set", json!({"key": "showToolTips", "value": true})).unwrap();
+        assert!(hover(&mut a), "on again");
+    }
+
    #[test]
    fn dialog_ok_with_invalid_value_keeps_dialog_and_prefs() {
        let mut a = app();
@@ -261,7 +261,7 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
            });
            return;
        }
-        // Editing keys with modifiers, clipboard and Cmd+A.
+        // Editing keys with modifiers and the clipboard (Cmd+A is Select All's, below: the text).
        crate::panels::character::route_type_input(app, ctx);
        // Enter was already delivered above as ToolKey::Enter (newline).
        let fire = all_shortcuts().into_iter().filter(|(sc, ..)| sc.modifiers.command).find(|(sc, ..)| ctx.input_mut(|i| consume(i, sc, false)));
@@ -386,12 +386,13 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
    let arrows = [(Key::ArrowLeft, -1.0, 0.0), (Key::ArrowRight, 1.0, 0.0), (Key::ArrowUp, 0.0, -1.0), (Key::ArrowDown, 0.0, 1.0)];
    for (k, dx, dy) in arrows {
        let m = ctx.input(|i| i.modifiers);
-        if ctx.input_mut(|i| i.consume_key(m, k)) && app.session.active().is_some_and(|d| !d.selection.is_empty()) {
+        if ctx.input_mut(|i| i.consume_key(m, k)) && app.session.active().is_some_and(|d| d.selection.has_objects_or_guides()) {
            let _ = app.run("object.nudge", json!({"dx": dx, "dy": dy, "big": m.shift, "copy": m.alt}));
        }
    }
    // Delete / Backspace clear the selection.
-    if ctx.input_mut(|i| i.consume_key(Modifiers::NONE, Key::Backspace)) && app.session.active().is_some_and(|d| !d.selection.is_empty()) {
+    if ctx.input_mut(|i| i.consume_key(Modifiers::NONE, Key::Backspace)) && app.session.active().is_some_and(|d| d.selection.has_objects_or_guides())
+    {
        let _ = app.run("edit.clear", json!({}));
    }
    // Single-key tool shortcuts (no Cmd/Ctrl/Alt).
@@ -1,9 +1,10 @@
 //! The system clipboard's formats: Copy and Cut publish every flavour the engine makes
 //! ([`Session::clipboard_flavours`](vectorcraft_engine::Session::clipboard_flavours): text, SVG,
-//! PDF, PNG), and a Paste first turns what another app copied (SVG, PDF, an EMF, text, a bitmap)
-//! into the internal clipboard with the `clipboard.import*` commands. The host installs the
-//! platform side as [`Services::system_clipboard`](crate::Services::system_clipboard); without it
-//! (the web) Copy publishes SVG text through egui and Paste takes SVG text only.
+//! PDF, PNG), and a Paste first turns what another app copied (SVG, PDF, an EMF, text, a bitmap,
+//! or a copied file that is one of them) into the internal clipboard with the `clipboard.import*`
+//! commands. The host installs the platform side as
+//! [`Services::system_clipboard`](crate::Services::system_clipboard); without it (the web) Copy
+//! publishes SVG text through egui and Paste takes SVG text only.

 use serde_json::{Value, json};
 use vectorcraft_engine::cmd::clipboard::{EMF, Flavour, PASTE_ORDER, PDF, SVG, TEXT, looks_like_svg};
@@ -89,6 +90,14 @@ impl VectorcraftApp {
        })
    }

+    /// The text on the system clipboard, if any.
+    pub(crate) fn system_clipboard_text(&mut self) -> Option<String> {
+        match self.services.system_clipboard.as_mut() {
+            Some(cb) => cb.read(&[TEXT]).map(|f| String::from_utf8_lossy(&f.data).into_owned()),
+            None => self.services.clipboard_read.as_mut().and_then(|read| read()),
+        }
+    }
+
    /// Does the system clipboard hold something Paste can take (with nothing copied in the app)?
    pub(crate) fn system_clipboard_pasteable(&mut self) -> bool {
        match self.services.system_clipboard.as_mut() {
@@ -241,3 +241,32 @@ fn stars_mark_favourites_and_the_preferences_size_the_rows() {
    let look = MenuLook::of(&app);
    assert!(!look.samples && look.row > 24.0, "Font Preview Size and Enable in-menu font previews");
 }
+
+/// Find Font's Replace With and the Glyphs panel only pick a font: their menu's highlight never
+/// previews on the document, a choice is just returned, and a star is still toggled.
+#[test]
+fn menus_that_only_pick_a_font_leave_the_document_alone() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.run("file.new", json!({"width": 300, "height": 200})).unwrap();
+    let id = app.session.execute("text.create", &json!({"x": 20, "y": 50, "text": "Gagaku", "font": "Inter"})).unwrap()["id"].as_u64().unwrap();
+    app.session.execute("select.set", &json!({"ids": [id]})).unwrap();
+    let font = |app: &VectorcraftApp| match &app.session.active().unwrap().doc.node(vectorcraft_doc::NodeId(id)).unwrap().kind {
+        NodeKind::Text(t) => t.first_style().font_family,
+        _ => String::new(),
+    };
+    let steps = |app: &VectorcraftApp| app.session.active().unwrap().history.undo.len();
+    let before = steps(&app);
+    use crate::font_menu::picked;
+    assert_eq!(picked(&mut app, None), None);
+    assert_eq!(picked(&mut app, Some(FontPick::Preview("Source Serif 4".into(), None))), None);
+    assert_eq!(picked(&mut app, Some(FontPick::EndPreview)), None);
+    assert_eq!(
+        picked(&mut app, Some(FontPick::Chosen("Source Serif 4".into(), Some("Bold".into())))),
+        Some(("Source Serif 4".to_string(), Some("Bold".to_string())))
+    );
+    assert_eq!((font(&app), steps(&app)), ("Inter".to_string(), before), "nothing previewed or applied on the text");
+    assert_eq!(picked(&mut app, Some(FontPick::Favorite("Inter".into()))), None);
+    assert_eq!(app.ui.favorite_fonts, ["Inter"], "a star is still toggled");
+    assert_eq!(picked(&mut app, Some(FontPick::Favorite("inter".into()))), None);
+    assert!(app.ui.favorite_fonts.is_empty());
+}
@@ -1,12 +1,10 @@
-//! The font menus list the installed fonts without asking for them (#36), and the font dropdown
-//! searches them.
+//! The font menus list the installed fonts without asking for them (#36).

 use serde_json::json;
 use vectorcraft_engine::Session;
 use vectorcraft_text::{FontDb, system_font_dirs};

-use crate::tests_labels::shapes_text;
-use crate::{VectorcraftApp, menus, widgets};
+use crate::{VectorcraftApp, menus};

 #[test]
 fn type_font_menu_lists_every_available_family() {
@@ -25,51 +23,6 @@ fn type_font_menu_lists_every_available_family() {
    assert_eq!(fonts(&app), labels);
 }

-#[test]
-fn the_font_dropdown_searches_the_families_and_enter_picks_the_first_match() {
-    let ctx = egui::Context::default();
-    crate::theme::install_fonts(&ctx);
-    // Each frame: what it painted, where the dropdown is and what it picked.
-    let frame = |events: Vec<egui::Event>| {
-        let input =
-            egui::RawInput { events, screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(600.0, 800.0))), ..Default::default() };
-        let (mut at, mut picked) = (egui::Pos2::ZERO, None);
-        let mut out = ctx.run_ui(input, |ui| {
-            at = ui.next_widget_position();
-            picked = widgets::font_dropdown(ui, "test-font", "Inter", 220.0);
-        });
-        out.textures_delta.clear();
-        (shapes_text(&out), at, picked)
-    };
-    let (closed, at, _) = frame(vec![]);
-    assert_eq!(closed.trim(), "Inter");
-    let click = at + egui::vec2(40.0, 10.0);
-    let button = |pressed| egui::Event::PointerButton { pos: click, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
-    frame(vec![egui::Event::PointerMoved(click), button(true)]);
-    frame(vec![button(false)]);
-    // The popup sizes itself invisibly in its first frame, then the list scrolls (animated).
-    for _ in 0..30 {
-        frame(vec![]);
-    }
-    // The families painted in the list (the button shows the current one, Inter).
-    let families = FontDb::global().families();
-    let listed = |text: &str| -> Vec<String> { text.lines().skip(1).filter(|l| families.iter().any(|f| f == l)).map(str::to_string).collect() };
-    let (open, ..) = frame(vec![]);
-    assert!(listed(&open).len() >= families.len().min(5), "{open}");
-    assert!(listed(&open).iter().any(|f| f == "Inter"), "the current font in view: {open}");
-    // The search field has the focus: typing filters the list.
-    frame(vec![egui::Event::Text("source serif".into())]);
-    let (filtered, ..) = frame(vec![]);
-    let shown = listed(&filtered);
-    assert!(shown.iter().any(|f| f == "Source Serif 4"), "{filtered}");
-    assert!(shown.iter().all(|f| f.to_lowercase().contains("source serif")), "{shown:?}");
-    let enter = |pressed| egui::Event::Key { key: egui::Key::Enter, physical_key: None, pressed, repeat: false, modifiers: Default::default() };
-    let (_, _, picked) = frame(vec![enter(true), enter(false)]);
-    assert_eq!(picked.as_deref(), Some("Source Serif 4"));
-    let (closed, ..) = frame(vec![]);
-    assert_eq!(closed.trim(), "Inter", "the list closes");
-}
-
 #[test]
 fn the_character_panel_menu_refreshes_the_font_list() {
    let mut app = VectorcraftApp::new(Session::new(), Default::default());
@@ -0,0 +1,173 @@
+//! Select All (Cmd+A) follows the keyboard, from the window and from the system menu bar (macOS):
+//! a focused text field selects its own text, the Type tool editing selects the text being edited,
+//! and only otherwise are all the objects selected.
+
+use egui::{Event, Key, Modifiers, PointerButton, Pos2, Rect, vec2};
+use serde_json::json;
+use vectorcraft_engine::Session;
+use vectorcraft_tools::{PointerEvent, PointerKind};
+
+use crate::{VectorcraftApp, menus};
+
+struct App {
+    app: VectorcraftApp,
+    ctx: egui::Context,
+    time: f64,
+}
+
+impl App {
+    /// A document with a 37 pt wide rectangle (selected) and a second, unselected one.
+    fn new() -> Self {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+        app.run("shape.rectangle", json!({"x": 200, "y": 150, "width": 20, "height": 20})).unwrap();
+        app.run("shape.rectangle", json!({"x": 20, "y": 20, "width": 37, "height": 40})).unwrap();
+        let mut a = Self { app, ctx: egui::Context::default(), time: 0.0 };
+        for _ in 0..3 {
+            a.frame(vec![]);
+        }
+        a
+    }
+
+    /// One whole app frame with `events`; `menu`: a system menu item chosen first, as the macOS
+    /// host dispatches it before the app's logic.
+    fn frame_with(&mut self, events: Vec<Event>, menu: Option<&str>) -> egui::FullOutput {
+        self.time += 0.1;
+        let raw = egui::RawInput {
+            events,
+            time: Some(self.time),
+            screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 850.0))),
+            ..Default::default()
+        };
+        let app = &mut self.app;
+        let mut out = self.ctx.run_ui(raw, |ui| {
+            if let Some(id) = menu {
+                menus::invoke_from_system_menu(app, ui.ctx(), id, json!({}));
+            }
+            app.logic(ui.ctx());
+            app.ui(ui);
+        });
+        out.textures_delta.clear();
+        out
+    }
+
+    fn frame(&mut self, events: Vec<Event>) -> egui::FullOutput {
+        self.frame_with(events, None)
+    }
+
+    fn menu(&mut self, id: &str) -> egui::FullOutput {
+        self.frame_with(vec![], Some(id))
+    }
+
+    fn selected(&self) -> usize {
+        self.app.session.active().unwrap().selection.objects.len()
+    }
+
+    /// The panel number field showing `text` (the field keeps its text under its id): id, rect.
+    fn field(&self, text: &str) -> (egui::Id, Rect) {
+        let widgets: Vec<(egui::Id, Rect)> =
+            self.ctx.viewport(|vp| vp.prev_pass.widgets.layers().flat_map(|(_, w)| w.iter()).map(|w| (w.id, w.rect)).collect());
+        widgets
+            .into_iter()
+            .find(|&(id, _)| {
+                self.ctx.data(|d| d.get_temp::<String>(id)).is_some_and(|t| t == text) && egui::TextEdit::load_state(&self.ctx, id).is_some()
+            })
+            .unwrap_or_else(|| panic!("no field shows {text:?}"))
+    }
+
+    /// The selected character range of text field `id`.
+    fn field_selection(&self, id: egui::Id) -> Option<(usize, usize)> {
+        let r = egui::TextEdit::load_state(&self.ctx, id)?.cursor.char_range()?;
+        let (a, b) = (r.primary.index, r.secondary.index);
+        Some((a.min(b).into(), a.max(b).into()))
+    }
+}
+
+fn press(key: Key, modifiers: Modifiers) -> Event {
+    Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }
+}
+
+fn click(at: Pos2, pressed: bool) -> Event {
+    Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }
+}
+
+#[test]
+fn cmd_a_in_a_panel_field_selects_its_text_and_leaves_the_art() {
+    let mut a = App::new();
+    assert_eq!(a.selected(), 1);
+    let (id, rect) = a.field("37 pt");
+    a.frame(vec![Event::PointerMoved(rect.center()), click(rect.center(), true)]);
+    a.frame(vec![click(rect.center(), false)]);
+    a.frame(vec![]);
+    assert!(a.ctx.text_edit_focused(), "the W field has the keyboard");
+    let all = Some((0, "37 pt".chars().count()));
+    // The window's Cmd+A (Windows, Linux, the web, macOS without the system menu).
+    a.frame(vec![press(Key::End, Modifiers::NONE)]);
+    assert_eq!(a.field_selection(id), Some((5, 5)), "End collapses the selection");
+    a.frame(vec![press(Key::A, Modifiers::COMMAND)]);
+    assert_eq!(a.field_selection(id), all, "Cmd+A selects the field's text");
+    assert_eq!(a.selected(), 1, "and not the art");
+    // Select All from the macOS menu bar (its key equivalent or a click): the same.
+    a.frame(vec![press(Key::End, Modifiers::NONE)]);
+    a.menu("select.all");
+    a.frame(vec![]);
+    assert_eq!(a.field_selection(id), all, "the menu's Select All selects the field's text");
+    assert_eq!(a.selected(), 1, "and not the art");
+    // The menu's Copy copies the field's text, not the art.
+    let out = a.menu("edit.copy");
+    let copied: Vec<_> = out
+        .platform_output
+        .commands
+        .iter()
+        .filter_map(|c| match c {
+            egui::OutputCommand::CopyText(t) => Some(t.as_str()),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(copied, ["37 pt"]);
+    assert!(a.app.session.clipboard.is_empty(), "no art copied");
+    assert!(a.ctx.text_edit_focused(), "the field keeps the keyboard");
+}
+
+#[test]
+fn cmd_a_while_editing_type_selects_all_of_its_text() {
+    let mut a = App::new();
+    a.app.select_tool("type");
+    let view = a.app.view_info();
+    for kind in [PointerKind::Down, PointerKind::Up] {
+        a.app.session.pointer(&PointerEvent::new(kind, 100.0, 200.0), view).unwrap();
+    }
+    a.frame(vec![Event::Text("abc".into())]);
+    let text = a.app.session.active().unwrap().selection.objects.clone();
+    let range = |a: &App| {
+        let o = a.app.session.tool_options();
+        (o["start"].as_u64().unwrap(), o["end"].as_u64().unwrap().min(3))
+    };
+    assert_eq!(range(&a), (3, 3), "the caret after the text");
+    // The window's Cmd+A.
+    a.frame(vec![press(Key::A, Modifiers::COMMAND)]);
+    assert_eq!(range(&a), (0, 3), "Cmd+A selects the text being edited");
+    assert_eq!(a.app.session.active().unwrap().selection.objects, text, "and not the art");
+    a.frame(vec![press(Key::End, Modifiers::NONE)]);
+    assert_eq!(range(&a), (3, 3));
+    // The macOS menu bar's Select All.
+    a.menu("select.all");
+    assert_eq!(range(&a), (0, 3), "the menu's Select All selects the text being edited");
+    assert_eq!(a.app.session.active().unwrap().selection.objects, text);
+    // Typing replaces it.
+    a.frame(vec![Event::Text("Z".into())]);
+    let doc = a.app.session.execute("document.inspect", &json!({})).unwrap();
+    let names: Vec<_> = doc["layers"][0]["children"].as_array().unwrap().iter().map(|c| c["name"].clone()).collect();
+    assert!(names.contains(&json!("Z")), "{names:?}");
+}
+
+#[test]
+fn cmd_a_on_the_canvas_selects_all_objects() {
+    let mut a = App::new();
+    assert!(!a.ctx.egui_wants_keyboard_input());
+    a.frame(vec![press(Key::A, Modifiers::COMMAND)]);
+    assert_eq!(a.selected(), 2, "Cmd+A selects every object");
+    a.app.run("select.none", json!({})).unwrap();
+    a.menu("select.all");
+    assert_eq!(a.selected(), 2, "so does the menu's Select All");
+}
@@ -219,8 +219,9 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
 /// Options dialog, the Blend tool's Blend
 /// Options; the Print Tiling tool's resets the print tiling. As in the reference app, the Hand
 /// tool's fits the artboard in the window, the Zoom tool's shows it at 100%, the Rotate, Scale,
-/// Reflect and Shear tools' are their Object › Transform dialogs, and the selection tools' are the
-/// Move dialog.
+/// Reflect and Shear tools' are their Object › Transform dialogs, the selection tools' are the
+/// Move dialog, and the Pencil, Paintbrush, Smooth, Blob Brush and Eraser tools' are their Tool
+/// Options.
 pub fn open_options(app: &mut VectorcraftApp, tool: &str) -> Result<serde_json::Value, String> {
    match tool {
        "hand" => app.run("view.fitArtboard", json!({})),
@@ -252,6 +253,8 @@ pub fn open_options(app: &mut VectorcraftApp, tool: &str) -> Result<serde_json::
        "printTiling" => app.run("print.tiling.set", json!({ "reset": true })),
        // The Liquify tools: their Tool Options (the Global Brush Dimensions and the tool's own).
        _ if vectorcraft_tools::settings::LIQUIFY.contains(&tool) => crate::dialogs::liquify::open(app, tool),
+        // The freehand tools: their Tool Options (Fidelity, fill, the tolerances, the brush size).
+        _ if crate::dialogs::freehand::TOOLS.contains(&tool) => crate::dialogs::freehand::open(app, tool),
        _ if vectorcraft_tools::tool_info(tool).is_none() => Err(format!("unknown tool `{tool}`")),
        _ => Err(format!("the {tool} tool has no options")),
    }
@@ -530,61 +530,6 @@ pub(crate) fn combo<R>(
        .inner
 }

-/// The font family dropdown: every family available (the installed fonts included), with a search
-/// field over the list that filters it as you type (Enter picks the first match). Returns the
-/// chosen family.
-pub fn font_dropdown(ui: &mut Ui, id: impl std::hash::Hash + std::fmt::Debug, current: &str, width: f32) -> Option<String> {
-    let state = ui.id().with(&id).with("font-search");
-    combo(ui, id, current, width, true, |ui| {
-        // Each time the list opens: unfiltered, with the current font in view. Typing goes to the
-        // search field.
-        let pass = ui.ctx().cumulative_pass_nr();
-        // (the last pass the list was drawn in, the pass it opened in)
-        let (last, opened) = ui.data(|d| d.get_temp::<(u64, u64)>(state)).unwrap_or_default();
-        let opened = if last + 1 < pass || last == 0 { pass } else { opened };
-        let field = state.with("query");
-        ui.data_mut(|d| {
-            d.insert_temp(state, (pass, opened));
-            if opened == pass {
-                d.insert_temp(field, String::new());
-            }
-        });
-        // Its first two passes: a popup sizes itself in the first, invisibly.
-        let opening = pass <= opened + 1;
-        if ui.memory(|m| m.focused().is_none()) {
-            ui.memory_mut(|m| m.request_focus(field.with("edit")));
-        }
-        let query = search_field(ui, field, "Search").to_lowercase();
-        let enter = ui.input(|i| i.key_pressed(egui::Key::Enter));
-        let families = vectorcraft_text::FontDb::global().menu_family_list();
-        let (mut chosen, mut first) = (None, None);
-        // The search field stays put over the list as it scrolls.
-        menu_scroll(ui, |ui| {
-            for f in families.iter().filter(|f| query.is_empty() || f.to_lowercase().contains(&query)) {
-                first.get_or_insert(f);
-                let r = ui.add(egui::Button::selectable(f == current, f.as_str()));
-                if opening && f == current {
-                    r.scroll_to_me(Some(egui::Align::Center));
-                }
-                if r.clicked() {
-                    chosen = Some(f.clone());
-                }
-            }
-        });
-        match first {
-            None => {
-                dim_label(ui, "No matching fonts");
-            }
-            Some(f) if enter && chosen.is_none() => chosen = Some(f.clone()),
-            _ => {}
-        }
-        if chosen.is_some() {
-            ui.close();
-        }
-        chosen
-    })
-}
-
 /// The body of a menu or popup list: as tall as its items up to the bottom of the window, and
 /// scrolling only past that, so long menus (Window, Effect, a panel's menu) stay reachable on
 /// small windows.
@@ -0,0 +1,56 @@
+# Contributors in the About window
+
+**About ▸ Contributors** credits everyone who contributed to VectorCraft, and **About ▸ Models** credits
+the AI models named in `Co-Authored-By` trailers. This follows the shared craftrules standard
+[`standards/contributors.md`](https://github.com/storytold/craftrules/blob/main/standards/contributors.md);
+this page is the local copy of the decision.
+
+## Decision
+
+- Two files, both **compiled into the binary** by the UI crate's `build.rs` (nothing is read from
+  disk or the network at run time; the web build has them too):
+  - [`contributors/contributors.json`](../contributors/contributors.json): commit stats per GitHub
+    username. **Generated** by `craftrules/scripts/contributors.py`; never hand-edit.
+  - [`contributors/people.toml`](../contributors/people.toml): the names people chose for
+    themselves. **Each contributor adds only their own entry**, in their own PR.
+- Each contributor gets one line: GitHub username (always), display name (opt-in, or their synced
+  GitHub profile name), real name (only if they told us), merged PRs, commits, lines added, lines
+  deleted, binary assets added, binary assets removed, first and last commit date.
+- The list is shown as a **grab bag** (names flowing as text) or a **table**, in the same order. It
+  sorts by name, PRs, commits, lines added, lines deleted, line delta, binary assets added/removed,
+  first or last commit date. The name toggle cycles **Username → Display name → Real name**; a
+  missing name falls back to `@username`. Alphabetical sorting is case-insensitive and ignores the `@`.
+
+## In VectorCraft
+
+- The About window is `crates/ui-egui/src/dialogs/about.rs` (Help ▸ About VectorCraft). The labels are
+  translated like the rest of the UI (`tl!`, `crates/ui-egui/src/i18n`); names and numbers are data.
+
+## Credit yourself
+
+Add your entry to `contributors/people.toml` in a PR you commit yourself (every field optional):
+
+```toml
+[people.your-github-username]
+real_name = "Your Name"
+display_name = "Nickname"
+sync_github_name = true   # use the name on your public GitHub profile as display name
+```
+
+or, with craftrules checked out next to `craft-apps/`:
+
+```sh
+python3 ../../craftrules/scripts/contributors.py --add-me . --real-name "Your Name" --sync-github-name
+```
+
+Names show after the next refresh: the script checks that each entry was committed by its own
+user (or by a maintainer with a `consent_source`). Delete your entry to remove your names.
+
+## Refreshing (maintainers)
+
+```sh
+python3 ../../craftrules/scripts/contributors.py .           # regenerate + verify; needs git, Python 3.11+, gh
+python3 ../../craftrules/scripts/contributors.py --check .   # verify people.toml only
+```
+
+Commit the updated `contributors/contributors.json`. Git author names and emails are never recorded.
@@ -24,6 +24,7 @@ so only enable it while you use it. Transport: `apps/vectorcraft/src/control_ser
 | `ui.tool.select` / `ui.tool.list` | `{tool}` | |
 | `ui.pointer` | `{events:[{kind: down|drag|up|move|doubleclick, x, y, space?: "doc"|"screen", mods?}]}` | drive the active tool exactly like the mouse |
 | `ui.key` / `ui.text` | `{key, shift?, alt?, cmd?}` / `{text}` | synthetic keyboard input |
+| `ui.wheel` | `{x, y, dy?, dx?, unit?: "line"\|"point", shift?, alt?, cmd?}` | a mouse wheel turn over screen point (x, y): `dy` notches up (+) or down, `dx` sideways. Over the canvas the wheel scrolls and Cmd- or Alt-wheel zooms; with the `zoomWithMouseWheel` preference the wheel zooms about the pointer, Shift-wheel scrolls up and down and Cmd-wheel (Ctrl on Windows and Linux) sideways |
 | `ui.set` | `{brightness?, panel?, rulers?, outline?, grid?, smartGuides?, boundingBox?, controlBar?}` | |
 | `ui.dialog.set` / `.confirm` / `.cancel` | `{field, value}` | fill and submit the open dialog |
 | `ui.screenshot` | `{path?}` | capture the window (PNG). Needs a presented frame: with the screen locked or the window minimized/covered it fails after ~8 s with an explanatory error |
@@ -462,7 +463,7 @@ from)}` opens too: dialog `printPreset`, the Print dialog's settings fields plus
 Export… are `print.presets.delete`, `print.presets.import` and `print.presets.export`; `ui.dialog.confirm` closes.
 Opening a `.vcprintpresets` file with `app.open` imports its presets.

-Modifiers on synthetic input: `ui.key`, `ui.click` and `ui.drag` take `shift`, `alt`, `ctrl` and `cmd` (Command on
+Modifiers on synthetic input: `ui.key`, `ui.click`, `ui.drag` and `ui.wheel` take `shift`, `alt`, `ctrl` and `cmd` (Command on
 macOS, Ctrl elsewhere), and the app holds them for the frames the input spans, as if the keys were down: a key's
 press, its `text` and its release; a click's press and release; a drag from the press through every move to the
 release. Every handler sees them (Shift+arrow nudges by the big increment, Alt+arrow nudges a copy, Shift-clicking a
@@ -523,6 +524,12 @@ then the tool's options `detail`, `simplify` and `simplifyOn` (Warp, Twirl, Puck
 `vertical` (Wrinkle, %), and `showBrush`. `ui.dialog.confirm` runs `tool.setOption {tool, values}`. `ui.pointer`
 events take `pressure` (0..1, default 1): it is the Liquify intensity while Use Pressure Pen is on.

+Freehand Tool Options: double-clicking the Pencil, Paintbrush, Smooth, Blob Brush or Eraser tool
+(`tool.options {tool: "pencil"}`) opens a `freehandOptions` dialog. Its fields are `tool` and the options the tool
+keeps: `fidelity` (pt; Pencil, Paintbrush, Smooth), `fill` (Pencil, Paintbrush), `closeWithin` and `editWithin` (screen
+pixels, 0 turns it off; Pencil, Paintbrush) and `size` (pt; Blob Brush, Eraser). `ui.dialog.confirm` runs
+`tool.setOption {tool, values}`.
+
 `ui.pointer` events also take `holdMs` (0..60000): the pointer then holds still that long, button down, before the
 next event. Twirl, Pucker and Bloat keep applying while held (a repeat of the last point every 0.1 s), exactly as
 for the same time held with the mouse. Liquify leaves type, symbols, images, graphs, meshes, envelopes, repeats and
@@ -42,6 +42,14 @@ The canvas is rasterized on the CPU (`vectorcraft-render`, vello_cpu); the GPU (
 - The `WGPU_POWER_PREF` environment variable (`low`, `high` or `none`) overrides the preference.
 - Help › About and the control channel's `ui.inspect` (`graphicsAdapter`) show the adapter in use, and the app logs it at startup.

+## Linux: Wayland and X11
+
+The window runs natively on Wayland (eframe's `wayland` feature) and on X11. The system clipboard (`apps/vectorcraft/src/clipboard.rs`) is arboard with its `wayland-data-control` feature:
+
+- **Clipboard:** under Wayland arboard talks to the compositor through the data-control protocol (wlroots compositors such as Sway and Hyprland, KDE Plasma), so bitmaps (`image/png`), SVG markup and text copied in any app paste (#398). Where the compositor lacks the protocol (GNOME's Mutter, [arboard#223](https://github.com/1Password/arboard/issues/223)), arboard falls back to the X11 clipboard through XWayland, which only holds what X11 apps copied. egui's own text paste into fields goes through smithay-clipboard and works either way.
+- **Copied files:** files copied in a file manager (`text/uri-list`; `CF_HDROP` on Windows, file URLs on macOS) paste as the first one that is art (SVG, PDF, EMF/WMF or a bitmap), before the clipboard's other formats (which include the files' paths as text).
+- **Dropping files on the window does not work under Wayland:** winit 0.30, which eframe 0.36 runs on, has no Wayland drag and drop ([winit#1881](https://github.com/rust-windowing/winit/issues/1881), added in winit 0.31; [egui#1563](https://github.com/emilk/egui/issues/1563)), so no `dropped_files` arrive. Until eframe moves to winit 0.31: copy the files in the file manager and paste them, use File › Place or Open, or run the app under XWayland, where drops work (`WAYLAND_DISPLAY= vectorcraft`).
+
 ## Fonts: craft-fonts (optional build input)

 Font files are never committed to this repository. Fonts shared by the Crafting Apps live in
@@ -75,7 +75,7 @@ is thousands of lines an agent pays for again on every change.

 | `uriTemplate` | Reads |
 |---|---|
-| `vectorcraft://object/{id}` | One layer or object with its children, bounds and paint: `document.node {id, summary: true}`, the node as `document.inspect` lists it |
+| `vectorcraft://object/{id}` | One layer or object with its children, bounds and paint: `document.node {id, summary: true}`, the node as `document.inspect` lists it. A large container can be sliced with `run_command document.node {id, summary: true, depth?, childLimit?}` (a level that shows fewer children reports `childCount`) |
 | `vectorcraft://command/{id}` | One command: label, menu path, shortcut, parameter description, enablement |
 | `vectorcraft://effect/{id}` | One live effect with its parameters and defaults |
 | `vectorcraft://swatch/{name}` | One swatch, colour, gradient or pattern swatch (percent-encode spaces) |
@@ -85,7 +85,11 @@ An unknown URI is `-32002`; a template with no value, or a value that names noth
 The same reads work as query commands through `run_command`: `document.node {id}` returns the object's full model
 JSON (geometry, appearance, every attribute) and `document.node {id, summary: true}` the compact summary
 `document.inspect` gives for it (id, name, kind, bounds, paint labels, children), without summarizing the whole
-document.
+document. A summary read slices a large container: `depth` is how many child levels it includes (`0`: the node
+alone) and `childLimit` how many children each node shows, top of the stack first (both default to all). A level
+that shows fewer children than it has reports their total as `childCount`, so truncation is never silent; with
+nothing truncated the reply is the plain summary. Both must be non-negative integers and need `summary: true`
+(the full object JSON is never truncated); anything else is an error.

 ### Completions

@@ -545,6 +549,29 @@ names must stay unique. In the desktop app the saved selections are listed at th
 (`select.recall1` … `select.recall25`). A file's saved selections are checked when it opens: past 25, blank or
 repeated names, and ids the document doesn't have are dropped.

+## Ruler guides
+
+Ruler guides are numbered in the order they were made. `guide.add {vertical, pos}` makes one (the x of a vertical
+guide, the y of a horizontal one, in points) → `{index}`; `guide.list` → `[{index, vertical, pos, selected}…]`.
+`guide.select {indexes: [index…], toggle?}` selects guides on their own (the art is deselected; `toggle` adds or
+removes them) → `{selected}`. `guide.move {index, pos}` puts one guide somewhere, `guide.move {dx?, dy?, copy?}`
+moves the selected ones (vertical guides by `dx`, horizontal ones by `dy`; `copy` leaves them and selects the
+moved copies), and `guide.remove {index?}` deletes one guide or the selected ones → `{count}`; each is one undo
+step. With guides selected, `edit.clear` (Delete) deletes them and `object.nudge` (the arrow keys) nudges them.
+View › Guides › Lock Guides (`view.guides.lock`) deselects them and refuses these commands until unlocked.
+
+The Selection, Direct Selection and Group Selection tools pick a guide within the selection tolerance, over the art
+(an anchor on it comes first with Direct Selection), and drag the selected guides: `mods.alt` copies them,
+`mods.shift` snaps the dragged guide to the ruler's ticks, and otherwise it snaps to whole pixels, the grid or, with
+Smart Guides, the art's edges, centres and anchors. In the desktop app a guide dropped off the canvas onto its
+ruler is deleted, and hidden guides (View › Guides › Hide Guides) can't be picked.
+
+```json
+{"name":"run_command","arguments":{"command":"guide.add","params":{"vertical":true,"pos":100}}}
+{"name":"pointer_gesture","arguments":{"tool":"selection","events":[{"kind":"down","x":100,"y":50},{"kind":"drag","x":140,"y":50},{"kind":"up","x":140,"y":50}]}}
+{"name":"run_command","arguments":{"command":"guide.list","params":{}}}
+```
+
 ## Graphic styles

 A graphic style holds an appearance (fills, strokes, effects) plus opacity, blend mode, isolate and knockout.
@@ -1068,6 +1095,29 @@ Effects off a 100 pt wide rectangle with a 10 pt stroke set to `width: 220` gets
 {"name":"run_command","arguments":{"command":"object.align","params":{"horizontal":"left","bounds":"preview"}}}
 ```

+## Selection preferences
+
+The Selection & Anchor Display and General preferences apply to `pointer_gesture` as they do to the mouse:
+
+- `selectionTolerance` (1–8 px, 3 by default): how near a click must be to a path to pick it, and to an anchor or
+  handle for Direct Selection.
+- `objectSelectionByPathOnly`: a click inside a filled path or compound path doesn't select it, one on its path does.
+- `ctrlClickSelectsBehind` (on by default): a Selection tool click with `mods: {cmd: true}` (Command on macOS, Ctrl
+  elsewhere) selects the object under the selected one there, the next such click the one under that, then the
+  topmost again. Cmd held to borrow the selection tool from another tool clicks as usual.
+- `doubleClickToIsolate` (on by default): off, a `doubleclick` on a group with the Selection tool no longer isolates it.
+- `usePreciseCursors`: the Pen, Eyedropper, Slice and Blend tools' pointers are a crosshair.
+
+```json
+{"name":"run_command","arguments":{"command":"prefs.set","params":{"key":"objectSelectionByPathOnly","value":true}}}
+{"name":"pointer_gesture","arguments":{"tool":"selection","mods":{"cmd":true},"events":[{"kind":"down","x":175,"y":125},{"kind":"up","x":175,"y":125}]}}
+```
+
+The preferences for the view need the desktop app (`vectorcraft-cli mcp --connect`): `zoomWithMouseWheel` (the
+wheel zooms about the pointer, Shift-wheel scrolls up and down, Cmd/Ctrl-wheel sideways; the control channel's
+`ui.wheel` turns the wheel), `zoomToSelection` (on: Zoom In and Zoom Out centre the selection), `showToolTips`,
+`anchorSize` (1–7), `gridColor`, `gridStyle`, `gridsInBack`, `guideColor`, `guideStyle` and `recentFontsCount`.
+
 ## Width points

 `stroke.widthPoint.set {id, t, left, right, index?, adjustAdjoining?}` adds a width point (side widths in points) or,
@@ -1890,6 +1940,18 @@ square to the page. `object.resetBoundingBox` squares the box again without movi
 {"name":"run_command","arguments":{"command":"object.rotate","params":{"angle":45,"absolute":true}}}
 ```

+## Select All while editing type
+
+While the Type tool edits text (a click into type, `pointer_gesture` with `"tool":"type"`), `select.all` (Cmd+A,
+`press_key {key: "A", mods: {cmd: true}}`) selects all of that text instead of the art, as in the reference app, and
+returns `{editing, start, end}` (the text's id and the selected byte range, which `text.getRange` and
+`text.setRangeStyle` take); the art selection stays as it is. Without text being edited it selects every object and
+returns `{count}`. Text in threaded frames is selected one frame at a time.
+
+```json
+{"name":"press_key","arguments":{"key":"A","mods":{"cmd":true}}}
+```
+
 ## Empty point type

 Point type the Type tool places with a click and leaves empty is discarded when editing ends: Escape, another tool,
Author	SHA1	Message	Date
bflatasticandClaude Opus 5.5	2f710d3acc	Fix #414 : select, move and delete ruler guides with the selection tools Guides dragged out of the rulers could not be touched again: no tool hit-tested them, so a click on a guide went to the art under it. - The Selection, Direct Selection and Group Selection tools pick a ruler guide within the selection tolerance (over the art; Direct Selection takes an anchor on it first) through a shared tools::rulerguide::GuideEdit. A drag moves the selected guides in one undo step (Alt copies them, Shift snaps the dragged one to the ruler's ticks, otherwise it snaps to 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 can't be picked; the pointer shows which way a guide moves. - Selection::guides holds the selected guides (on their own, like slices); the canvas draws them in the selection colour. Delete/Backspace (edit.clear) delete them, the arrow keys (object.nudge) nudge them, Lock Guides and Hide Guides deselect them. - Commands for agents: guide.list, guide.select {indexes, toggle?}, guide.move {dx?, dy?, copy?} (besides {index, pos}) and guide.remove {index?}; guide positions out of range are refused. Documented in docs/mcp.md. - Shift while dragging a new guide out of a ruler snaps it to the ticks too (Unit::ruler_step, shared with the rulers' drawing). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 08:55:51 +07:00
Brandon ThomasandClaude Opus 5.5	2bcaf08dbd	Release CI: macOS job on the org macos-release runner The standard macOS runners are shared with all CI and queue for an hour or more. The macos-release runner (GitHub-hosted M2 Pro) is in a runner group usable only by release.yml on the release branch, with a monthly spend cap on the actions_macos_xl SKU. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 21:54:52 -04:00
BFlat	e1de706245	Merge pull request #412 from imachus/pr/ja-hangul-jamo Type: no Japanese–Latin space next to Hangul compatibility or half-width jamo	2026-10-08 08:36:36 +07:00
imachusandClaude Opus 5.5	6952780c1f	Type: no Japanese–Latin space next to Hangul compatibility or half-width jamo Follow-up to #370: Hangul Compatibility Jamo (U+3130–318F, ㄱ ㅏ) and half-width Hangul (U+FFA0–FFDC) counted as Japanese letters, so a Latin letter next to them took the quarter em. They are left out like Hangul syllables; the test covers both. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 08:29:07 +07:00
BFlat	f5183da3dd	Merge pull request #413 from storytold/fix/issue-394 Part of #394: Preferences that act on selection, the wheel, tool tips and the grid	2026-10-08 08:28:32 +07:00
bflatasticandClaude Opus 5.5	47bed05ff4	Part of #394 : Preferences that act on selection, the wheel, tool tips and the grid Fifteen Preferences options were stored but read by nothing. They now act, through the existing plumbing (ToolContext for the tools, the prefs read by the canvas for the view), and reach agents through prefs.set: - General: Show Tool Tips (off: no widget's tool tip comes due), 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 (Pen, Eyedropper, Slice and Blend pointers become a crosshair). - Selection & Anchor Display: Tolerance (objects, anchors and handles, in place of the fixed 3 and 4 px), Object Selection by Path Only (compound paths too), Command Click to Select Objects Behind (cycles down the objects under the pointer; not when Cmd only borrows the selection tool), Zoom to Selection (Zoom In/Out centre the selection), anchor Size, Highlight anchors on mouse over (Direct Selection). - Type: Number of Recent Fonts (up to 15 Recent Fonts slots). - Guides & Grid: guide and grid Color and Style (lines or dots), Grids In Back. The canvas's context menu, panel drops and hover highlight pick objects like the selection tools. The control channel gets ui.wheel (with modifiers held like ui.click) so agents can turn the wheel. The rest of #394 stays open. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 08:22:24 +07:00
Brandon ThomasandClaude Opus 5.5	f7a03160d6	About: contributor and model credits compiled in (grab bag + table, self-submitted names) (#411 ) * About: contributors compiled in from contributors.json (grab bag + table, sortable, name toggle) Help > About VectorCraft gains Contributors and Models tabs next to the existing About content, following the craftrules standard (standards/contributors.md): contributors/contributors.json is generated by craftrules/scripts/contributors.py and baked into the binary by crates/ui-egui/build.rs as static tables (credits.rs). Each contributor line: @username, opt-in display/real name, PRs, commits, lines +/-/delta, binary assets +/-, first/last commit. Sortable by every column; alphabetical ignores case and the leading @. Labels are translated (ja, zh-hant, pt-br catalog rows). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Contributors docs: craftrules is two levels up (../../craftrules) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Contributors: self-submitted names in contributors/people.toml; AGENTS.md credit-yourself section build.rs reads contributors/people.toml next to the generated contributors.json and shows a name only for entries the generator verified as written by that person (craftrules standards/contributors.md). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Contributors: regenerate (verified people.toml entries) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * i18n: credits labels for catalogs added on main since this branch Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Contributors: regenerate after rebase onto main Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Contributors: regenerate (verified people.toml entries) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 21:22:04 -04:00
BFlat	fe9f3afcb7	Merge pull request #410 from storytold/fix/issue-398 Fix #398: Linux/Wayland bitmap paste, copied files paste as art	2026-10-08 07:51:16 +07:00
BFlat	c5f0859302	Merge pull request #405 from fahrim/mcp-pagination MCP: Slice summary reads with document.node depth and childLimit	2026-10-08 07:51:00 +07:00
bflatasticandClaude Opus 5.5	4767ec7113	Fix #398 : Linux/Wayland bitmap paste, copied files paste as art Under Wayland the window is native but arboard was built without its data-control backend, so it read the X11 clipboard through XWayland, which only holds what X11 apps copied: Paste found nothing and reported an empty clipboard (egui's text paste into fields uses smithay-clipboard, which is why that worked). arboard now has `wayland-data-control`, the same as PhotoCraft; it falls back to X11 where the compositor lacks the protocol (GNOME's Mutter). The reporter's clipboard also held text/uri-list: with a file copied in a file manager, Paste would have taken the path as text before the bitmap. Copied files now paste first, as the first one that is art (SVG, PDF, EMF/WMF or a bitmap), told from its first 4 KiB by the engine's format detection (`clipboard::file_flavour`): text/uri-list through arboard on Linux and macOS (a trailing CR from CRLF lists trimmed), CF_HDROP on Windows, read with the clipboard closed again. Dropping files on the window can't work under Wayland yet: winit 0.30, which eframe 0.36 runs on, has no Wayland drag and drop (winit#1881, added in 0.31), so no dropped_files arrive. docs/development.md documents it and the workarounds (copy and paste the files, File > Place, or run under XWayland with `WAYLAND_DISPLAY=`). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 07:44:23 +07:00
bflatasticandClaude Opus 5.5	526fc2e157	MCP: reject document.node slices without summary, document and sweep them (review of #405 ) `depth` / `childLimit` without `summary: true` used to return the whole full-JSON subtree silently; it is now an invalid-params error. docs/mcp.md describes the slice parameters and childCount, the engine test covers fractional values, unsliced reads and limits past the tree, and the CLI stdio sweep reads a sliced group through run_command. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 07:43:07 +07:00
Fahri Meral	81ab5cb3b0	MCP: slice summary reads with document.node depth and childLimit	2026-10-08 07:43:07 +07:00
BFlat	8221b73729	Merge pull request #397 from DWAA1660/fix/font-menu-find-font-glyphs #358: Find Font's Replace With and the Glyphs panel use the font menu	2026-10-08 07:42:27 +07:00
BFlat	c8155e9d69	Merge pull request #389 from imachus/pr/ja-charalign Type: Character Alignment — where smaller characters line up with a line's largest	2026-10-08 07:42:07 +07:00
BFlat	52f4fb38f2	Merge pull request #390 from theironchef/fix/freehand-tool-options Pencil, Paintbrush, Smooth, Blob Brush and Eraser: Tool Options on double-click	2026-10-08 07:41:25 +07:00
bflatasticandClaude Opus 5.5	d324138bc1	Fonts: drop the plain font dropdown now that no picker uses it (review of #397 ) Find Font and the Glyphs panel were widgets::font_dropdown's last callers; the font menu's own tests cover searching and Enter. ROADMAP: the Glyphs panel and Find Font's Replace With use the font menu, without its live preview. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 07:32:12 +07:00
bflatasticandClaude Opus 5.5	18cbe007b8	Character Alignment: on a character range too, with the East Asian options (review of #389 ) text.setRangeStyle takes charAlign, so the panel menu works on the characters selected with the Type tool (it routes there while text is edited, and charAlign alone was answered with "nothing to change"). One char_align_param parses it for both commands. The menu shows with Preferences › Type › Show East Asian Options, like Mojikumi Set and Top-to-Top Leading. Rows in the Simplified Chinese, Spanish and Brazilian Portuguese catalogs; the Japanese Em Box Center names the em box. ROADMAP: the gating, the range command, and ICF top/bottom still missing. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 07:32:11 +07:00
DWAA1660andClaude Opus 5.5	1d5e9cb239	Find Font and Glyphs: pick fonts from the font menu (#358 follow-up) Both switch from widgets::font_dropdown to font_menu::font_menu, so they get the same samples, favourites and filters as the Character and Properties panels. They only pick a font: the new font_menu::picked returns the choice and toggles stars, and never previews on the document. Follow-up to #339 as suggested in #364. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01BRE8ZD3p8QgYctENhnJDz3	2026-10-08 07:32:11 +07:00
imachusandClaude Opus 5.5	178ca03eba	Type: Character Alignment — where smaller characters line up with a line's largest Characters of different sizes on one line all sat on the Roman baseline. Japanese layout usually lines them up by their ideographic em boxes instead (a 16 pt 第一回 next to 32 pt 雅楽 centred on it, not sitting on its baseline). The Character panel menu now has Character Alignment: - `CharStyle.char_align`: Roman Baseline (as before, the default), or the em box Top/Right, Center or Bottom/Left: a character smaller than the line's largest moves so that its em box top, centre or bottom lines up with the largest's (the em box from the font's vertical metrics, else 0.12 em below the baseline to 0.88 em above it). Vertical type the same across the column (top → right). Written only when not Roman Baseline. - `text.setFormat {charAlign: "romanBaseline"\|"emBoxTop"\|"emBoxCenter"\| "emBoxBottom"}`; the menu shows the selection's setting; catalog rows in ja and zh-hant. - Not yet: aligning on the ICF (average character face) top and bottom. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 07:32:10 +07:00
bflatasticandClaude Opus 5.5	505f3bd7ae	Freehand Tool Options: Accurate/Smooth ends on the Fidelity slider, Spanish rows (review of #390 ) The Fidelity slider names its ends, Accurate and Smooth, through a shared form::slider_ends that the Color Guide Options' Less/More now use too. The dialog's strings get Spanish rows (complete catalog), and Accurate rows in every catalog. ROADMAP: the Drawing tools row lists what the freehand Tool Options still lack (Keep selected, Alt to the Smooth tool, Blob Brush Merge Only with Selection, brush angle and roundness). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 07:32:09 +07:00
theironchefandClaude Sonnet 5.5	02582f318d	Fix #388 : Pencil, Paintbrush, Smooth, Blob Brush and Eraser Tool Options on double-click The five freehand tools keep options (Fidelity, fill, the two tolerances, the brush size) that last across tool switches and are saved with the preferences, but nothing in the window showed or changed them: a double-click on the tool's button answered "the pencil tool has no options", which the toolbar drops. It now opens a Tool Options dialog with the options the tool has, and OK sets them with tool.setOption. The dialog's strings are in the Japanese, Chinese (both scripts) and Brazilian Portuguese catalogs. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>	2026-10-08 07:32:09 +07:00
BFlat	a80d9b8195	Merge pull request #409 from storytold/fix/issue-392 Fix #392: Cmd+A selects a focused field's text or the type being edited	2026-10-08 07:31:45 +07:00
BFlat	2a434190f2	Merge pull request #408 from storytold/fix/issue-396 Fix #396: SVG type opens at the size it draws at	2026-10-08 07:31:29 +07:00
BFlat	d036a6d613	Merge pull request #403 from storytold/fix/issue-369 Fix #369: restart the web build's graphics after a lost device or context	2026-10-08 07:31:13 +07:00
bflatasticandClaude Opus 5.5	0916534db9	Fix #392 : Cmd+A selects a focused field's text or the type being edited Select All (Cmd/Ctrl+A) now follows the keyboard, as in Illustrator: - macOS menu bar: the system menu takes Cmd+A/X/C/V before the window sees them, so a focused panel, dialog or search field got the document command. `menus::invoke_from_system_menu` (used by `NativeMenu::poll`) hands Select All, Cut, Copy and Paste to a focused text field as the events its keys would send; clicks on those menu items follow the same rule. Other commands, and these with no field focused, run as before. - Type tool: `select.all` itself selects all of the text being edited while the Type tool edits (returns {editing, start, end}), so the menu, the shortcut, the control channel and headless MCP (`press_key`) agree. The UI's own Select All interception and the Type tool's hard-wired Cmd+A are gone; Cmd+A reaches it through the Select All shortcut. - Windows, Linux and the web already left Cmd+A to a focused field; now covered by headless app-frame tests (field, Type tool, canvas). Docs: docs/mcp.md (Select All while editing type), ROADMAP. Not yet: Select All across threaded frames (one frame's text is selected). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 07:18:52 +07:00