Fix #439: Shape Builder erase mode deletes edges, shows what will go and follows Alt live

Alt already deleted regions and pieces of open lines, but erase mode had
no edges of closed shapes, no distinct pointer, highlighted regions in the
merge-mode grey, only noticed Alt on a mouse move, and an erase drag could
flip mode at release. Like the reference app's erase mode:

- pathops::shape_builder(shapes, edges) returns a BuilderArrangement; with
  `edges` it also cuts the outlines of closed (and filled open) paths
  wherever other paths meet them. pathops::cut_out removes such a piece
  from a path: a closed subpath opens there, an open one splits or
  shortens, a piece all the way round takes its subpath, and a filled open
  path's invisible closing edge never comes back as a visible segment.
  Specks where paths only touch cut nothing; a zero-length input is no
  longer the source of edges running through it. encloses_area is shared
  with the tool's closing of filled open paths.
- BuilderMap (with_edges) hit-tests edges like line pieces (nearest wins);
  an erase gesture that crosses an edge into a region deletes the region,
  not the edge (erased_edges).
- shapeBuilder.merge {erase}: deletes the edges touched within tolerance
  (from every shape along them), after the regions; returns `edges`.
  shapeBuilder.regions lists `edges` (bounds, source). One undo step.
- Shape Builder tool: Alt held switches to erase mode and back on release:
  red mesh/edge highlights of what will be deleted, a minus pointer
  (Cursor::ShapeBuilder / ShapeBuilderErase, a plus in merge mode); a drag
  keeps the mode it started in. The canvas re-hovers the tool when a
  modifier changes, so the highlight follows Alt without a mouse move.

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

ROADMAP.md

@@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob
 
 This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands.
 
-_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419) and Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421); see [Honest assessment](#honest-assessment-2026-10-05))._
+_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439); see [Honest assessment](#honest-assessment-2026-10-05))._
 
 ## Where we are
 
@@ -44,6 +44,7 @@ since 2026-10-01.
 | **Robustness** | good, new | ~2,840 tests, property tests, no panics in shipped code (lints, the `guard` safety net, import fuzzing), Data Recovery. Missing: a corpus of real-world files, Windows/Linux/browser QA |
 | **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); hybrid-graphics laptops render on the power-saving GPU by default (#306); web drops land in the document they were dropped on (#359); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); on Linux/Wayland the clipboard reads the compositor's own (data-control) and copied image files paste, but files can't be dropped on the window under Wayland until eframe moves to winit 0.31 (#398; the Wayland side is verified by compilation only); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) |
 | **Agent automation** | beyond Illustrator | Every command, gesture and dialog is drivable over MCP, the CLI and the control channel |
+| **Scrubby numeric fields** | beyond Illustrator | As in Photoshop, dragging a numeric field's label (`W:`, `Opacity:`, the Character panel's icons) left or right steps its value live; one undo step per drag, Escape cancels (#400) |
 
 ### Where we're lacking (in priority order)
 
@@ -94,8 +95,9 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - Headless CLI (`vectorcraft-cli run`, `convert`, `info`, `bench`, `perf`, `mcp`).
   - Actions panel that records and plays back commands.
 - **UI:** Illustrator 2026 layout restyled to measured values:
-  - Medium Dark theme, categorized and Advanced toolbars, 35 pt document tabs, 33 pt panel tabs.
+  - Medium Dark theme, categorized and Advanced toolbars (a tool group's flyout opens on a right press, a long press or a press on its corner triangle), 35 pt document tabs, 33 pt panel tabs.
   - Hint bar, contextual task bar, 19 dock panels with ≡ menus.
+  - Tool flyouts tear off: dragging or clicking the tear-off bar on a flyout's right side (or releasing the long press over it) floats its group as a strip of tool buttons, moved by the same bar and put back in the toolbar by the × at its top (`window.floatTools`). While a group floats, the presses that would open its flyout raise the strip instead. Floating strips are kept with the preferences and in user workspaces. Not done: turning a strip vertical, docking it.
   - The dock's double arrow collapses Properties, Layers and Libraries to icons at the top of the icon column, popping out like the other icon panels, and expands them again (`window.collapseDock`, kept with the preferences and in saved workspaces). The icon column's own arrow (expanding the icon panels into a full column) is not done.
   - Localised UI: menus (in-window and native), panels, dialogs, toolbar and Preferences read from per-language catalogs (`crates/ui-egui/src/i18n`, see `docs/development.md`); Traditional Chinese (Taiwan), Simplified Chinese (mainland), Japanese and Spanish ship complete, and Czech and Brazilian Portuguese cover every menu label (and more), with system-locale detection on macOS, Windows and Linux, a VectorCraft ▸ Language menu and a Language preference. Names are never translated (fonts and their styles, layers, artboards, saved presets, user libraries, custom workspaces, recent files, plug-ins).
   - Native macOS menu bar, vector tool cursors, a ⌘K command palette, middle-button panning with any tool.
@@ -104,7 +106,9 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - Save / Don't Save / Cancel before closing or quitting with unsaved documents (tabs, Close, Close All, Quit, window close).
   - Four brightness themes, persistent preferences.
   - Preferences that act (#394, in part): Show Tool Tips, Double Click To Isolate, Zoom with Mouse Wheel (the wheel zooms about the pointer, Shift-wheel scrolls up and down, Cmd/Ctrl-wheel sideways), Use Precise Cursors; Selection & Anchor Display › Tolerance (objects, anchors and handles), Object Selection by Path Only, Command Click to Select Objects Behind (cycling down the stack), Zoom to Selection, anchor Size, Highlight anchors on mouse over; Type › Number of Recent Fonts (up to 15); Guides & Grid › guide and grid Color and Style (lines or dots) and Grids In Back. Then Snap to Point (its distance, for moves, drawn points and reference points), Move Locked and Hidden Artwork with Artboard, Enable Rubber Band for the Pen and Curvature tools, Handles style, Show handles when multiple anchors are selected, Hide Corner Widget for angles greater than; General › Transform Pattern Tiles (the transforms' and dialogs' Transform Patterns) and Select Same Tint %; Type › Size/Leading, Tracking and Baseline Shift increments (`type.step`, Cmd+Shift+. and Cmd+Shift+, for the size, the Type tool's Alt+arrows), Enable Missing Glyph Protection and Fill New Type Objects With Placeholder Text. They reach agents too (`prefs.set`, then `pointer_gesture` or `press_key`; `ui.wheel` on the control channel). About 45 stored options still do nothing yet (the rest of #394: Auto Size New Area Type, Show Font Names in English, Highlight Alternate Glyphs, the smart guide display options, performance, devices…).
+  - Dialogs move by dragging their heading (the band down from the top edge, as a title bar), stay on screen and keep where they were moved for the session; the form dialogs' choices are dropdowns (Offset Path's Joins, Average's and Shear's and Reflect's axis), and Offset Path lists Offset, Joins, Miter Limit and previews (#423).
   - Dialogs open with their first field focused and its value selected: type a value and press Enter (Move, Rotate, Scale…). Number fields in panels and dialogs step with Up/Down (Shift: ten, Ctrl/Cmd: a tenth of their unit), applied at once.
+  - Scrubby labels (#400, beyond Illustrator, as in Photoshop): dragging a numeric field's label left or right (the ↔ cursor shows over it) steps the value one unit every 2 points (Shift: ten, Ctrl/Cmd: a tenth; counts stay whole), in the field's unit and within its limits, applied live as the art follows; the whole drag is one undo step and Escape puts the value back. A click on the label focuses the field; the text box itself never scrubs, and a field with no label doesn't. Text labels before a field (Transform, Properties, Control bar, Stroke, Transparency, form rows in dialogs) and the Character and Paragraph panels' icons act as labels. Preferences › General › Scrub Numeric Fields by Dragging (on by default) turns it off.
   - Tab shows and hides the panels (in the Type tool it types a tab) without moving the keyboard focus onto a field, so the next shortcut or letter still works; in dialogs and panel fields it moves between fields.
   - Cmd/Ctrl+A follows the keyboard: in a panel, dialog or search field it selects the field's text, while the Type tool edits it selects all of that text (also `select.all` over MCP), and only otherwise every object. On macOS the menu bar's Select All, Cut, Copy and Paste (keys or clicks) act on a focused field too. Not yet: Select All across threaded frames (one frame's text is selected).
   - On Windows and Linux the app bar is the window's title bar (its own minimize, maximize and close buttons, drag to move, edges to resize), with the dragon app icon as the brand mark; dialogs and menus size to their content. As on a native menu bar, once one menu is open, moving the pointer onto another title opens that one.
@@ -123,22 +127,22 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - **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, 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.
+- **Layers panel:** every layer, sublayer, group and object is a clickable row at any depth: a click highlights it and makes its layer current (new art goes there), Shift-click a range, Ctrl/Cmd-click toggles. Sublayers are no longer treated as objects: clicks, marquees, Select All and the Select menu take the art inside them, and each sublayer selects in its own colour. Selection squares on rows with selected art (click selects a row's art, Shift adds or removes; dragging the square moves the selection to another row, Alt copies), the eye and lock on every row with drag-down-the-column (one undo step), Ctrl/Cmd-click an eye for per-layer Outline, Alt-click an eye or lock to hide or lock the other layers (again: show or unlock them all), triangles with Alt to open or close everything inside, drag and drop rows above, below or into layers and groups with a drop line (Alt copies) and a dimmed copy of the row under the pointer (dropped on the trash rows are deleted, on New Layer duplicated, as in Illustrator), inline rename, Delete key on highlighted rows. Buttons and the full panel menu: New Layer/Sublayer (Alt: options, Ctrl: on top), Duplicate, Delete, Options for Selection, clipping mask, isolation, Locate Object, Merge Selected, Flatten Artwork, Collect in New Layer, Release to Layers (Sequence and Build), Reverse Order, Template, Hide/Outline/Lock Others and Show/Preview/Unlock All, Paste Remembers Layers, Panel Options (row size, thumbnails per kind, Show Layers Only). Layer Options: name, colour (presets, each with a chip of its colour, or custom), Template, Lock, Show, Print, Preview (outline drawing and clicking) and Dim Images to %. Every operation is a command (`layer.move`, `layer.highlight`, `layer.merge`…) with validation against cycles and invalid nesting.
 - **Drawing aids:** Smart Guides and snapping (moving, with the Selection, Group Selection or Direct Selection tool, and resizing by the bounding-box handles: the dragged edges align with the other objects; anchors dragged with Direct Selection: the one pressed on lands on other anchors, its own path's that stay put among them, on path segments or in line with them, the others following, Shift keeps 45° steps, and with Smart Guides off Snap to Point pulls it onto anchors; the Artboard tool snaps artboards, and their bleed, to other artboards, bleeds and art, the grid or whole pixels while moving, copying and resizing them, and the Transform panel shows and edits the active artboard's X/Y/W/H), guides dragged out of the rulers (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.
+- **Type:** Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity) and Options (Flip, Align to Path, Spacing; OK keeps the type where it is), type on a path's start, centre and end brackets (Selection and Direct Selection drag them to set where the type runs, slide it along its path and, across the path, flip it: #429), Character and Paragraph Styles (override-preserving redefine), Area Type Options (rows/columns/inset/first baseline), threaded text across any closed shapes, Fit Headline. Area type resizes like Illustrator's type areas: a bounding-box handle drag (Selection tool) or Area Type Options Width/Height size the frame and the text reflows at its size (threads too); Direct Selection drags a frame corner or edge (`text.reshapeArea`). Point type still scales. Variable fonts list every named instance as a style of their family (Figtree Light to Black and their italics, Bahnschrift, Segoe UI Variable), and the instance chosen is shaped, drawn, outlined and measured at its axis settings; PDF and SVG embed it as that instance. Variation axis sliders are not done. Hebrew and Arabic are laid out right to left with the Unicode bidirectional algorithm (embedded Latin and numbers keep their direction, lines put in visual order after wrapping) in point, area and path type, with caret, selection and arrow keys in visual order; each paragraph's direction comes from its first strong character unless Paragraph Direction sets it (Paragraph panel with Show Indic Options, `text.setFormat {direction}`), and new type aligns to the start of its direction. SVG export outlines right-to-left text.
 - **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese and Spanish (neutral international Spanish, for every `es-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech and Spanish ones from the bundled UI fonts. The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width and an opening bracket starting a wrapped line flush with its start, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline; Character panel menu › Character Alignment (with the East Asian options; `text.setFormat` or `text.setRangeStyle {charAlign}`) lines characters smaller than the largest on their line up on the Roman baseline or the em box top/right, centre or bottom/left (ICF top and bottom not yet); Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines.
 - **Transparency:** opacity masks (clip/invert/disable/link), exported as SVG `<mask>` and PDF soft masks.
-- **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder (stroke-only open paths and lines cut the regions they cross and enclose regions of their own; Alt deletes their pieces; filled open paths count as closed), Live Paint (every path an edge, open lines included), Image Trace (12 presets), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror).
+- **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder (stroke-only open paths and lines cut the regions they cross and enclose regions of their own; filled open paths count as closed; erase mode while Alt/Option is held: a minus pointer, red highlights of what will go, a click or drag deletes the regions touched, the pieces of open lines and the edges (outline pieces between the points where paths meet, opening their paths there) it passes over, one undo step, `shapeBuilder.merge {erase}` and `shapeBuilder.regions` edges over MCP), Live Paint (every path an edge, open lines included), Image Trace (12 presets), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror).
 - **Paint and appearance (M3):**
   - **Swatches:** names follow the colour model and are unique; Swatch Options (process/spot, Global, Gray/RGB/HSB/CMYK/Web, live preview); editing a global or spot swatch recolours every linked fill, stroke and text run in one undo step; multi-select and delete with confirmation; New Swatch and New Color Group dialogs (a group from the selected artwork's colours); swatches in colour groups convert, separate and count like any other. The Swatches panel selects ranges and whole groups, has a find field, and drags swatches to reorder, regroup or paint art; Add Used Colors, Select All Unused, Merge, Ungroup and Sort by Kind; a CMYK document keeps applied colours in CMYK. Swatch libraries: nine generated colour libraries and five gradient libraries in a library panel, saved and loaded as `.vcswatches`, `.gpl` or CSS. Tints of global and spot colours ("Name 40%") stay linked and separate as a percentage of their plate. Spot colours can be defined in Lab (Spot Colors options). A built-in [Registration] swatch prints on every plate.
   - **Colour:** a Color Picker (colour field, H/S/B/R/G/B channel slider, HSB/RGB/Lab/CMYK fields, hex, web-only snapping, out-of-gamut correction); the Color panel follows each colour's own model and Alt-click paints the other proxy; proxies look through groups and show "?" for mixed paint; Invert, Complement, Apply Last Color (`,`) and Apply Last Gradient (`.`) keep the colour model; every paint command feeds the recent colours. The Color Guide has 21 harmony rules, Steps and Variation options and Limit to Library. Adjust Color Balance (its Global mode shifts tints) and Saturate preview live; Edit Colors and Recolor also reach meshes, images and patterns. Recolor Artwork has colour reduction, five recolour methods, presets, Limit to Library, a colour-wheel Edit tab and Edit Color Group; a local Color Themes panel saves five-colour themes. Fill/Stroke chips open swatch and mixer popovers, panels have their shortcuts, and Eyedropper Options pick up and apply chosen attributes (Alt and Shift+Alt, image pixels). Fills and strokes can overprint (Attributes panel, Overprint Black options), and CMYK documents blend in inks on screen, in PDF and when flattening. Document Color Mode converts the art, symbols, pattern tiles and swatches through the colour settings: Gray stays Gray, RGB greys separate into four-colour greys and a rich black as Illustrator does, or go on the black plate only with `grays: "black"` (also for `document.open {colorMode}`).
   - **Gradients:** lossless, validated gradient params; gradients follow rotate, reflect, shear, non-uniform scale and distortions; the Gradient tool edits the fill or stroke of the active proxy, type included; an interactive on-canvas annotator (move, length/angle, rotate, add/move/delete/duplicate stops, midpoints, a stop popover, Delete and arrow keys). The Gradient panel has the Fill/Stroke proxy, a gradient-swatch dropdown with Save to Swatches, midpoint locations, Alt-drag to copy or swap stops, swatch drops on the ramp and a stop eyedropper; copied appearances and graphic styles place gradients on each target's own bounds; gradient handles snap and honour Constrain Angle. Gradient stops stay linked to global and spot swatches. Freeform gradients (points and lines) are edited on the canvas; radial gradients have an extent ellipse, an aspect handle and an off-centre focal point (SVG `fx`/`fy`, PDF two-point radials). A stroke's gradient runs within, along or across it. Object ▸ Expand turns gradients into N objects or a gradient mesh.
-  - **Strokes:** one stroke-geometry module shared by the canvas, SVG, PDF and Outline Stroke; dotted lines (zero-length dashes draw dots or squares); arrowheads with hollow outlines, tip-on-end or extend-past-end alignment and one opacity for line and head. SVG and PDF export arrowheads, width profiles, brushes and aligned strokes exactly as the canvas draws them; Outline Stroke and the live Outline Stroke effect outline every stroke item as drawn (dashes, heads, profiles, alignment); dashes can be fitted to corners and path ends; width profiles carry through dashes, and their corners take the join. The Stroke panel edits type's character strokes, follows the stroke units, shows mixed values blank and opens from the Control bar. A width profile library, thirty more arrowheads, and Width Point Edit with multi-select and discontinuous points. Visual bounds and clicks cover the whole painted stroke. Scale Strokes & Effects, Scale Corners and Use Preview Bounds work everywhere, and new art inherits stroke options, a graphic style or the whole last appearance.
-  - **Appearance:** the Appearance panel's selected row drives every paint, stroke, gradient and transparency edit (`item` on the commands); effects apply to one fill or stroke; per-item Opacity popups; Mixed Appearances, Layers target dots and basic-appearance rules. Effects can be reordered, moved between items and copied by dragging; Show All Hidden Attributes; clicking an effect edits it in place; the object thumbnail drags onto art; effects render on type, images, symbols, blends, envelopes, meshes and repeats, and per-item raster effects export. Groups, layers and type have their own fills, strokes and effects (Contents and Characters rows); the Layers panel's target circles target layers, groups and objects; Expand Appearance turns fills, strokes, effects and brushes into objects.
+  - **Strokes:** one stroke-geometry module shared by the canvas, SVG, PDF and Outline Stroke; dotted lines (zero-length dashes draw dots or squares); arrowheads with hollow outlines, tip-on-end or extend-past-end alignment and one opacity for line and head. SVG and PDF export arrowheads, width profiles, brushes and aligned strokes exactly as the canvas draws them; Outline Stroke and the live Outline Stroke effect outline every stroke item as drawn (dashes, heads, profiles, alignment); dashes can be fitted to corners and path ends; width profiles carry through dashes, and their corners take the join. The Stroke panel edits type's character strokes, follows the stroke units (its weight presets are round values in that unit: `0.25 mm`, `0.0625 in`, `1 px`, #426; fields show four decimals in mm, cm and inches, three in points), shows mixed values blank and opens from the Control bar. A width profile library, thirty more arrowheads, and Width Point Edit with multi-select and discontinuous points. Visual bounds and clicks cover the whole painted stroke. Scale Strokes & Effects, Scale Corners and Use Preview Bounds work everywhere, and new art inherits stroke options, a graphic style or the whole last appearance.
+  - **Appearance:** the Appearance panel's selected row drives every paint, stroke, gradient and transparency edit (`item` on the commands); effects apply to one fill or stroke; per-item Opacity popups, whose blend-mode list and opacity slider stay open inside them (#430; the Control bar's Stroke popover too); Mixed Appearances, Layers target dots and basic-appearance rules. Effects can be reordered, moved between items and copied by dragging; Show All Hidden Attributes; clicking an effect edits it in place; the object thumbnail drags onto art; effects render on type, images, symbols, blends, envelopes, meshes and repeats, and per-item raster effects export. Groups, layers and type have their own fills, strokes and effects (Contents and Characters rows); the Layers panel's target circles target layers, groups and objects; Expand Appearance turns fills, strokes, effects and brushes into objects.
   - **Masks and clipping:** opacity-mask controls work while the mask is being edited; transparency commands take ids and work without a selection; clipping sets clip by compound paths, even-odd paths, text and groups on screen and in raster export, matching SVG/PDF. Alt-click shows only the mask; SVG masks keep Clip and Invert; the transparency grid is per-document state; a clipping path's own fill and stroke paint behind and over the clipped art; layers can be clipping masks.
   - **Transparency:** three-state Knockout Group (on, neutral, off), Opacity & Mask Define Knockout Shape, Page Isolated Blending and Page Knockout Group, on screen and in SVG/PDF. Blend modes match the standard formulas on screen, in SVG and in PDF, and non-isolated groups blend with the art below. Flatten Transparency with presets, a dialog and a Flattener Preview panel.
   - **Graphic styles:** styles keep opacity and blend mode, capture groups and type, apply on top with Alt, and link to the objects using them; Redefine, Break Link, Graphic Style Options, Select All Unused, Sort by Name, and Select > Same Graphic Style / Appearance Attribute. The panel has list and thumbnail views with rendered previews, merge, reorder and drag and drop, plus a Control bar Style picker; six generated style libraries save and load as `.vcstyles`.
@@ -165,7 +169,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 | M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | ✅ done (M4.14–M4.98 on 2026-10-05): Save As/Save a Copy/Revert/templates, Data Recovery and background save, SVG import and export fidelity (units, text, symbols, filters, SVGZ, Preserve Editing, SVG Options), PDF import (colours, layers, masks, editable text, security) and export (presets, marks, bleed, ICC and output intent, raster effects, subset fonts, PDF/X-1a, X-3 and X-4, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3), Place and Links, Package, EPS and DXF in and out, EMF/WMF, TIFF/BMP/Targa/PSD/GIF/PNG-8 export, Print and print presets, slices, Save for Web, Asset Export, clipboard flavours, File Info. Left: DWG (use DXF), PSD placement as layers, overprint read back from PDF, polish | 3–6 |
 | M5 | Performance | 🟡 background render + caches + MT done; `vectorcraft-cli bench` and `vectorcraft-cli perf` (budget suite); file format v2 opens 3× faster (50k paths: 722 → 244 ms); raster effects (glows, shadows, blur, feather) no longer force the whole frame single-threaded (filtered offscreen per effect, verified equal to the single-threaded reference); effect-heavy demos need a clean-machine benchmark; dirty-region rendering, GPU backend spike pending | 15–25 |
 | M6 | Path operations (Pathfinder, Shape Builder, offset…) | ✅ mostly done (Boolean precision on almost-horizontal edges fixed and the property tests made deterministic; Shape Builder gap detection, large-offset bug open) | 3–6 |
-| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options (with Width/Height), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import, variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects, tab stops + Tabs panel, Hebrew/Arabic bidirectional text and Paragraph Direction done; tab leaders, spell check, vertical type pending | 45–60 |
+| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options (with Width/Height), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import, variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects and Options with draggable start/centre/end brackets (slide, flip), tab stops + Tabs panel, Hebrew/Arabic bidirectional text and Paragraph Direction done; tab leaders, spell check, vertical type pending | 45–60 |
 | M8 | Transform & distort (Puppet Warp, Liquify tools, Envelopes, Blends, Perspective Grid) | ✅ done (M8.1–M8.20 on 2026-10-06, fidelity pass): Liquify Tool Options with one shared brush, pen pressure, hold-to-apply, a safe scope and incremental strokes; tool options that last; Puppet Warp rotation, multi-select, Control bar and a rest-shape session that follows Undo; Width tool on compound paths; Envelope dialogs with preview, Reset with Warp/Mesh, full Envelope Options, type/images/symbols/appearance/gradients/patterns distorted on canvas and in every export, warps that keep their frame, Edit Contents, mesh handles and Control bar; Blend Options, anchor-targeted Blend tool, editable spine, keys picked on the canvas, faithful interpolation and knockout; Perspective Grid with Define Grid, presets, lock/snap/rulers, widgets, the 1–4 plane switch, movable planes, Perspective Selection scale/copy/perpendicular/Transform Again, and type and symbols truly projected with Edit Text. Left: Anti-Alias and Preserve Shape output, warp-envelope point editing, brush interpolation in blends, Free Transform/Scale/Reflect along a rotated box | 2–4 |
 | M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder and Color Adjustments; SVG Filters, Document Raster Effects Settings, 3D pending | 86–135 |
 | M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG `<pattern>`/PDF export) and live Repeat (radial/grid/mirror) done; brushes/symbols in progress | 23–37 |
@@ -193,7 +197,7 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 |---|---:|---:|---|---:|
 | 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, 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 |
+| Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 86% | Live Paint gap options, Shape Builder gap detection, options (Tool Options dialog, clicking a stroke in merge mode) and Shift-drag marquee | 3–6 |
 | Colour, swatches, gradients, patterns, mesh, recolor | 7 | 96% | freeform and mixed spot/process gradients in SVG/PDF (exported as stops or process colours), pattern fills in Expand | 2–4 |
 | Strokes, brushes, width profiles | 5 | 88% | brush options depth, brush libraries (generated in code), brushes driven by pen tilt, bearing and barrel rotation (6D art pens) | 12–20 |
 | Appearance, transparency, graphic styles, masks | 5 | 98% | raster effect reach in preview bounds (flattener presets apply in PDF, EPS and print) | 1–2 |

crates/doc/src/lib.rs

@@ -78,7 +78,7 @@ pub use setup::{Background, DocSetup, ExportText, GridSize, Quotes};
 pub use slices::{CellAlign, CellVAlign, Slice, SliceArea, SliceKind, SliceOptions, SliceSource};
 pub use style_libs::StyleLibrary;
 pub use text::{
-    AreaOptions, CharAlign, CharPosition, CharStyle, FirstBaseline, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathEffect,
+    AreaOptions, CharAlign, CharPosition, CharStyle, FirstBaseline, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathAlign, PathEffect,
     ScriptMetrics, TabAlign, TabStop, TextKind, TextObject, TextRun, TextStyleDef, TextWrap, WrapShape,
 };
 pub use vectorcraft_color as color;
@@ -191,7 +191,10 @@ impl Unit {
     }
     /// [`Unit::format`] without the suffix (`12.5`), for narrow fields.
     pub fn number(self, pt: f64) -> String {
-        let s = format!("{:.3}", self.from_pt(pt));
+        // Three decimals for the small units (`595.276 pt`), four for the large ones (`8.2677 in`,
+        // `35.2778 mm`, the `0.0078 in` stroke preset); trailing zeros are trimmed (`1 pt` is `1`).
+        let decimals = if matches!(self, Unit::Points | Unit::Pixels | Unit::Picas) { 3 } else { 4 };
+        let s = format!("{:.*}", decimals, self.from_pt(pt));
         let s = s.trim_end_matches('0').trim_end_matches('.');
         if s == "-0" { "0".into() } else { s.into() }
     }

crates/doc/src/tests_units.rs

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

crates/doc/src/text.rs

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

crates/engine/src/cmd/buildcmds.rs

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

crates/engine/src/cmd/prefscmds.rs

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

crates/engine/src/cmd/textedit.rs

@@ -453,10 +453,10 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let text = str_param(p, "text").unwrap_or("").to_string();
     let start = match point_param(p, "at") {
-        Some(at) if on_path => vectorcraft_text::path_fraction_at(&path.to_bezpath(), at).0,
+        Some(at) if on_path => vectorcraft_geom::ArcPath::new(path).fraction_at(at).unwrap_or(0.0),
         _ => 0.0,
     };
-    let kind = if on_path { TextKind::OnPath { path: path.clone(), start } } else { TextKind::Area { frame: path.clone() } };
+    let kind = if on_path { TextKind::OnPath { path: path.clone(), start, end: None } } else { TextKind::Area { frame: path.clone() } };
     let mut t = TextObject {
         vertical: p.get("vertical").and_then(Value::as_bool).unwrap_or(false),
         kind,
@@ -465,6 +465,8 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
         para: super::create::new_type_para(),
         area: Default::default(),
         path_effect: Default::default(),
+        path_align: Default::default(),
+        path_spacing: 0.0,
         wrap: Vec::new(),
         cached_bounds: None,
     };
@@ -595,6 +597,8 @@ fn headline_tracking(t: &TextObject, target: f64) -> Option<f64> {
             para: Default::default(),
             area: Default::default(),
             path_effect: Default::default(),
+            path_align: Default::default(),
+            path_spacing: 0.0,
             wrap: Vec::new(),
             cached_bounds: None,
         };

crates/engine/src/cmd/typemenu.rs

@@ -52,7 +52,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Type on a Path Options…",
             ["Type", "Type on a Path"],
             None,
-            "{start?: 0..1 (fraction of the path length), flip?: bool (reverse the path), effect?: rainbow|skew|3dRibbon|stairStep|gravity, ids?}",
+            "{ids?, start?: 0..1, end?: 0..1|null, flip?: bool, effect?: rainbow|skew|3dRibbon|stairStep|gravity, alignToPath?: ascender|descender|center|baseline, spacing?: pt} set the selected type on a path's options: start and end place its start and end brackets as fractions of the path's length (end null: the end of the path, or once round a closed path), and flip then turns the type to the other side of its path (the path runs the other way, the brackets swap ends); none given: query → the first object's {start, end, flip: false, effect, alignToPath, spacing}",
             has_selection,
             path_options
         ),
@@ -343,38 +343,95 @@ fn to_point(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(ids_json(&ids))
 }
 
+/// The options `type.pathOptions` sets; with none of them given it queries.
+const PATH_OPTIONS: [&str; 6] = ["start", "end", "flip", "effect", "alignToPath", "spacing"];
+
+/// Type on a path's text, if `n` is type on a path.
+fn path_text(n: Option<&vectorcraft_doc::Node>) -> Option<&TextObject> {
+    match n.map(|n| &n.kind) {
+        Some(NodeKind::Text(t)) if matches!(t.kind, TextKind::OnPath { .. }) => Some(t),
+        _ => None,
+    }
+}
+
+/// Type on a Path Options of `t`, as `type.pathOptions` takes them (`flip` is an action: false).
+fn path_options_of(t: &TextObject) -> Value {
+    let (start, end) = match &t.kind {
+        TextKind::OnPath { start, end, .. } => (*start, *end),
+        _ => (0.0, None),
+    };
+    json!({
+        "start": start,
+        "end": end,
+        "flip": false,
+        "effect": t.path_effect.id(),
+        "alignToPath": t.path_align.id(),
+        "spacing": t.path_spacing,
+    })
+}
+
 fn path_options(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "type.pathOptions";
-    let ids = texts(s, p, C)?;
-    let start = p.get("start").and_then(Value::as_f64);
+    let ids: Vec<NodeId> = {
+        let d = &s.doc()?.doc;
+        texts(s, p, C)?.into_iter().filter(|i| path_text(d.node(*i)).is_some()).collect()
+    };
+    let first = *ids.first().ok_or_else(|| bad(C, "select type on a path"))?;
+    let options = |s: &Session| -> Result<Value> {
+        let t = path_text(s.doc()?.doc.node(first)).ok_or_else(|| bad(C, "select type on a path"))?;
+        Ok(path_options_of(t))
+    };
+    if !PATH_OPTIONS.iter().any(|k| p.get(k).is_some()) {
+        return options(s);
+    }
+    // A bracket: a fraction of the path's length.
+    let fraction = |k: &str| -> Result<Option<f64>> {
+        match p.get(k) {
+            None | Some(Value::Null) => Ok(None),
+            Some(v) => v.as_f64().filter(|x| x.is_finite()).map(|x| Some(x.clamp(0.0, 1.0))).ok_or_else(|| bad(C, format!("`{k}` is a number 0..1"))),
+        }
+    };
+    let start = fraction("start")?;
+    // `end: null` puts the end bracket back at the end of the path.
+    let end = p.get("end").map(|_| fraction("end")).transpose()?;
     let flip = bool_or(p, "flip", false);
     let effect = match str_param(p, "effect") {
         Some(e) => Some(vectorcraft_doc::PathEffect::parse(e).ok_or_else(|| bad(C, format!("unknown effect `{e}`")))?),
         None => None,
     };
-    let n = s.edit("Type on a Path Options", |d, _| {
-        let mut n = 0;
+    let align = match str_param(p, "alignToPath") {
+        Some(a) => Some(vectorcraft_doc::PathAlign::parse(a).ok_or_else(|| bad(C, format!("unknown alignToPath `{a}`")))?),
+        None => None,
+    };
+    let spacing = p.get("spacing").and_then(Value::as_f64).filter(|x| x.is_finite()).map(|x| x.clamp(-1000.0, 1000.0));
+    s.edit("Type on a Path Options", |d, _| {
         for id in &ids {
             let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
-            let TextKind::OnPath { path, start: st } = &mut t.kind else { continue };
+            let TextKind::OnPath { start: st, end: en, .. } = &mut t.kind else { continue };
             if let Some(v) = start {
-                *st = v.clamp(0.0, 1.0);
+                *st = v;
             }
+            if let Some(v) = end {
+                *en = v;
+            }
+            // After the brackets: they are given on the path as it runs before the flip.
             if flip {
-                path.reverse();
+                t.flip_on_path();
             }
             if let Some(e) = effect {
                 t.path_effect = e;
             }
-            n += 1;
+            if let Some(a) = align {
+                t.path_align = a;
+            }
+            if let Some(v) = spacing {
+                t.path_spacing = v;
+            }
             refresh_bounds(t);
         }
-        if n == 0 {
-            return Err(bad(C, "select type on a path"));
-        }
-        Ok(n)
+        Ok(())
     })?;
-    Ok(json!({ "changed": n }))
+    options(s)
 }
 
 // ---------- placeholder / insert ----------

crates/engine/src/lib.rs

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

crates/engine/src/tests_build.rs

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

crates/engine/src/tests_journal.rs

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

crates/engine/src/tests_pathtype.rs

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

crates/engine/src/tests_strokeux.rs

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

crates/geom/src/arc.rs

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

crates/geom/src/lib.rs

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

crates/pathops/src/lib.rs

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

crates/pathops/src/planar.rs

@@ -21,7 +21,7 @@ use std::collections::HashMap;
 
 use kurbo::{Affine, BezPath, CubicBez, ParamCurve, PathSeg, Point, Shape as _};
 use linesweeper::topology::{Topology, WindingNumber};
-use vectorcraft_geom::{FillRule, PathData};
+use vectorcraft_geom::{FillRule, PathData, SubPath};
 
 use crate::boolean::{DEFAULT_PRECISION, Seg, Tidy, eps_for, is_sliver, segs_to_subpath, snap_horizontals, tidy_segments, to_seg};
 use crate::pathfinder::{Region, Shape};
@@ -102,7 +102,12 @@ struct Outlines {
 
 impl Outlines {
     fn new(inputs: &[(BezPath, usize)], eps: f64) -> Self {
-        let segs = inputs.iter().flat_map(|(bp, i)| bp.segments().map(move |s| (s.bounding_box(), s, *i))).collect();
+        // A zero-length segment (a point) is the source of no edge, even one running through it.
+        let segs = inputs
+            .iter()
+            .flat_map(|(bp, i)| bp.segments().map(move |s| (s.bounding_box(), s, *i)))
+            .filter(|(r, ..)| r.width() > 0.0 || r.height() > 0.0)
+            .collect();
         // The sweep moves points by a few `eps` at most.
         Self { segs, tol: 16.0 * eps }
     }
@@ -292,26 +297,172 @@ pub fn live_paint(shapes: &[Shape]) -> (Vec<Region>, Vec<Shape>) {
 /// than the filled areas' arrangement, so past this only the filled areas count.
 pub const SHAPE_BUILDER_MAX_SEGMENTS: usize = 4096;
 
-/// Shape Builder regions of `shapes` (back → front), and the pieces of their open paths.
+/// The Shape Builder's arrangement: see [`shape_builder`].
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct BuilderArrangement {
+    pub regions: Vec<Region>,
+    /// The pieces of the paths with no closed subpath, keyed by input index.
+    pub lines: Vec<Shape>,
+    /// The pieces of the other paths' outlines, keyed by input index (the front-most where inputs
+    /// share one); only when asked for.
+    pub edges: Vec<Shape>,
+}
+
+/// Shape Builder regions of `shapes` (back → front), the pieces of their open paths and, with
+/// `edges`, the pieces of their outlines (what erasing an edge deletes).
 ///
 /// Closed paths bound regions with their filled areas, as in [`regions`](crate::regions). Open
 /// paths (the caller closes the ones whose fill should count) are cutting edges: a line across a
 /// shape splits it, lines around an area enclose a region nothing fills (empty `sources`), and each
 /// path with no closed subpath comes back cut wherever another path meets it, as pieces keyed by
-/// its index in `shapes`. With no open path, more than [`SHAPE_BUILDER_MAX_SEGMENTS`] segments or
-/// a map that can't be built, only the filled areas count and there are no pieces.
-pub fn shape_builder(shapes: &[Shape]) -> (Vec<Region>, Vec<Shape>) {
+/// its index in `shapes`. Outlines are cut the same way. With no open path, more than
+/// [`SHAPE_BUILDER_MAX_SEGMENTS`] segments or a map that can't be built, only the filled areas
+/// count and there are no pieces.
+pub fn shape_builder(shapes: &[Shape], edges: bool) -> BuilderArrangement {
     let has_open = shapes.iter().flat_map(|s| &s.path.subpaths).any(|sp| !sp.closed && sp.anchors.len() >= 2);
     let segments: usize = shapes.iter().flat_map(|s| &s.path.subpaths).map(|sp| sp.segment_count()).sum();
-    if has_open && segments <= SHAPE_BUILDER_MAX_SEGMENTS {
-        let keyed: Vec<Shape> = shapes.iter().enumerate().map(|(i, s)| Shape::new(s.path.clone(), s.rule, i as u64)).collect();
-        let (faces, edges) = live_paint(&keyed);
-        if !faces.is_empty() || !edges.is_empty() {
-            let is_line = |i: u64| shapes.get(i as usize).is_some_and(|s| !s.path.subpaths.iter().any(|sp| sp.closed));
-            return (faces, edges.into_iter().filter(|e| is_line(e.key)).collect());
+    let planar = ((has_open || edges) && segments <= SHAPE_BUILDER_MAX_SEGMENTS)
+        .then(|| {
+            let keyed: Vec<Shape> = shapes.iter().enumerate().map(|(i, s)| Shape::new(s.path.clone(), s.rule, i as u64)).collect();
+            live_paint(&keyed)
+        })
+        .filter(|(faces, pieces)| !faces.is_empty() || !pieces.is_empty());
+    let Some((faces, pieces)) = planar else {
+        return BuilderArrangement { regions: crate::regions(shapes), ..Default::default() };
+    };
+    let is_line = |i: u64| shapes.get(i as usize).is_some_and(|s| !s.path.subpaths.iter().any(|sp| sp.closed));
+    let (lines, outline): (Vec<Shape>, Vec<Shape>) = pieces.into_iter().partition(|e| is_line(e.key));
+    BuilderArrangement {
+        regions: if has_open { faces } else { crate::regions(shapes) },
+        lines: if has_open { lines } else { Vec::new() },
+        edges: if edges { outline } else { Vec::new() },
+    }
+}
+
+/// Does `sp`, closed, enclose an area (rather than retrace itself)? The Shape Builder closes the
+/// open subpaths of filled paths that do.
+pub fn encloses_area(sp: &SubPath) -> bool {
+    let mut closed = sp.clone();
+    closed.closed = true;
+    let mut bp = BezPath::new();
+    closed.to_bezpath_into(&mut bp);
+    let size = bp.bounding_box().size();
+    bp.area().abs() > 1e-9 * (size.width * size.width + size.height * size.height)
+}
+
+/// `path` without `piece`, a run along one of its subpaths between two points (a Shape Builder
+/// edge): a closed subpath opens there, an open one splits in two (or loses an end), and a piece
+/// that runs all the way round takes its subpath. With `fill_closes`, open subpaths that enclose an
+/// area ([`encloses_area`]) run on round an invisible closing edge, as the Shape Builder sees a
+/// filled path: a piece may run over it, and it never comes back as a visible segment. None when
+/// the piece doesn't lie on `path` within `tol`.
+pub fn cut_out(path: &PathData, piece: &SubPath, fill_closes: bool, tol: f64) -> Option<PathData> {
+    let n = piece.segment_count();
+    if n == 0 {
+        return None;
+    }
+    // A point well inside the piece: the middle of its longest segment.
+    let arclen = |k: usize| kurbo::ParamCurveArclen::arclen(&piece.segment(k), 1e-3);
+    let mid = (0..n).map(|k| (arclen(k), k)).max_by(|x, y| x.0.total_cmp(&y.0)).map(|(_, k)| piece.segment(k).eval(0.5))?;
+    let (a, b) = (piece.anchors.first()?.p, piece.anchors.last()?.p);
+    let mut bp = BezPath::new();
+    piece.to_bezpath_into(&mut bp);
+    if bp.perimeter(1e-6) <= tol {
+        // A speck (where paths touch): there's nothing to cut.
+        return None;
+    }
+    // A piece that ends where it starts runs all the way round.
+    let whole = piece.closed || a.distance(b) <= tol;
+    // Each subpath as the piece may run along it: round its closing edge when it has one.
+    let ring = |sp: &SubPath| SubPath { anchors: sp.anchors.clone(), closed: sp.closed || (fill_closes && encloses_area(sp)) };
+    let (si, geom, um) = path
+        .subpaths
+        .iter()
+        .enumerate()
+        .filter_map(|(i, sp)| {
+            let g = ring(sp);
+            let (u, d) = nearest_u(&g, mid)?;
+            (d <= tol).then_some((i, g, u, d))
+        })
+        .min_by(|x, y| x.3.total_cmp(&y.3))
+        .map(|(i, g, u, _)| (i, g, u))?;
+    let len = geom.segment_count() as f64;
+    let real = path.subpaths.get(si)?.segment_count() as f64;
+    let at = |p: Point| nearest_u(&geom, p).filter(|(_, d)| *d <= tol).map(|(u, _)| u);
+    // The parameter spans of `geom` that stay (unrolled past the end of a ring).
+    let keep: Vec<(f64, f64)> = if whole {
+        Vec::new()
+    } else if geom.closed {
+        let (ua, ub) = (at(a)?, at(b)?);
+        let fwd = |from: f64, to: f64| (to - from).rem_euclid(len);
+        // The piece runs from one end through `mid` to the other; what stays runs on round.
+        let (start, end) = if fwd(ua, um) <= fwd(ua, ub) { (ub, ua) } else { (ua, ub) };
+        let rest = fwd(start, end);
+        if rest <= 1e-9 || len - rest <= 1e-9 {
+            Vec::new()
+        } else {
+            // Where the ring closes with an invisible edge (`real..len`), what stays stops at it.
+            let parts: &[(f64, f64)] = if real >= len { &[(0.0, 2.0 * len)] } else { &[(0.0, real), (len, len + real)] };
+            parts.iter().map(|&(lo, hi)| (start.max(lo), (start + rest).min(hi))).filter(|(x, y)| y - x > 1e-9).collect()
+        }
+    } else {
+        let (ua, ub) = (at(a)?, at(b)?);
+        let (lo, hi) = (ua.min(ub), ua.max(ub));
+        if !(lo - 1e-9..=hi + 1e-9).contains(&um) {
+            return None;
+        }
+        [(0.0, lo), (hi, len)].into_iter().filter(|(x, y)| y - x > 1e-9).collect()
+    };
+    let mut subpaths: Vec<SubPath> = path.subpaths.iter().take(si).cloned().collect();
+    subpaths.extend(keep.into_iter().filter_map(|(u0, u1)| span(&geom, u0, u1)).map(|sp| snap_ends(sp, [a, b], tol)));
+    subpaths.extend(path.subpaths.iter().skip(si + 1).cloned());
+    Some(PathData::new(subpaths))
+}
+
+/// The point of `sp` nearest `p`, as a parameter `segment + t`, with its distance.
+fn nearest_u(sp: &SubPath, p: Point) -> Option<(f64, f64)> {
+    use kurbo::ParamCurveNearest;
+    (0..sp.segment_count())
+        .map(|k| {
+            let n = sp.segment(k).nearest(p, 1e-9);
+            (k as f64 + n.t, n.distance_sq.sqrt())
+        })
+        .min_by(|x, y| x.1.total_cmp(&y.1))
+}
+
+/// `sp` with its end anchors within `tol` of one of `to` put exactly on it (where the planar map
+/// put the junction a piece ends at), handles moving with them.
+fn snap_ends(mut sp: SubPath, to: [Point; 2], tol: f64) -> SubPath {
+    let last = sp.anchors.len().saturating_sub(1);
+    for i in [0, last] {
+        if let Some(an) = sp.anchors.get_mut(i)
+            && let Some(q) = to.iter().find(|q| q.distance(an.p) <= tol)
+        {
+            let d = *q - an.p;
+            an.p = *q;
+            an.h_in += d;
+            an.h_out += d;
         }
     }
-    (crate::regions(shapes), Vec::new())
+    sp
+}
+
+/// The run of `sp` from parameter `u0` to `u1` (`u0 < u1`, unrolled past the end of a closed one),
+/// open.
+fn span(sp: &SubPath, u0: f64, u1: f64) -> Option<SubPath> {
+    let n = sp.segment_count();
+    if n == 0 || !(u0.is_finite() && u1.is_finite()) {
+        return None;
+    }
+    let first = u0.floor().max(0.0) as usize;
+    let last = (u1.ceil().max(0.0) as usize).min(first + 2 * n);
+    let segs: Vec<Seg> = (first..last)
+        .filter_map(|k| {
+            let (t0, t1) = ((u0 - k as f64).clamp(0.0, 1.0), (u1 - k as f64).clamp(0.0, 1.0));
+            (t1 - t0 > 1e-12).then(|| Seg { c: sp.segment(k % n).subsegment(t0..t1), line: sp.segment_is_line(k % n) })
+        })
+        .collect();
+    segs_to_subpath(&segs, false)
 }
 
 fn build(shapes: &[Shape]) -> Option<(Vec<Region>, Vec<Shape>)> {
@@ -618,7 +769,7 @@ pub fn interior_point(path: &PathData) -> Option<Point> {
 mod tests {
     use super::*;
     use proptest::prelude::*;
-    use vectorcraft_geom::{Rect, SubPath, shapes};
+    use vectorcraft_geom::{Rect, shapes};
 
     fn line(a: (f64, f64), b: (f64, f64), key: u64) -> Shape {
         Shape::new(PathData::single(SubPath::polyline(&[Point::new(a.0, a.1), Point::new(b.0, b.1)], false)), FillRule::NonZero, key)
@@ -766,14 +917,14 @@ mod tests {
     fn shape_builder_lines_cut_regions() {
         // A line across a rectangle: two regions, the line in three pieces keyed by its index.
         let s = [rect(0.0, 0.0, 100.0, 50.0, 7), line((40.0, -20.0), (60.0, 70.0), 8)];
-        let (regions, lines) = shape_builder(&s);
+        let BuilderArrangement { regions, lines, .. } = shape_builder(&s, false);
         assert_eq!(regions.len(), 2);
         assert!(regions.iter().all(|r| r.sources == [0]));
         assert_eq!(lines.len(), 3);
         assert!(lines.iter().all(|l| l.key == 1 && !l.path.is_closed()));
         // Lines alone enclose a region nothing fills.
         let s = [line((0.0, 0.0), (100.0, 100.0), 0), line((100.0, 0.0), (0.0, 100.0), 0), line((-10.0, 80.0), (110.0, 80.0), 0)];
-        let (regions, lines) = shape_builder(&s);
+        let BuilderArrangement { regions, lines, .. } = shape_builder(&s, false);
         assert_eq!(regions.len(), 1);
         assert!(regions[0].sources.is_empty() && regions[0].top().is_none());
         assert_eq!(lines.len(), 9);
@@ -782,10 +933,10 @@ mod tests {
     #[test]
     fn shape_builder_closed_only_or_degenerate_is_the_filled_arrangement() {
         let s = [rect(0.0, 0.0, 100.0, 100.0, 0), rect(50.0, 0.0, 150.0, 100.0, 1)];
-        assert_eq!(shape_builder(&s), (crate::regions(&s), vec![]));
+        assert_eq!(shape_builder(&s, false), BuilderArrangement { regions: crate::regions(&s), ..Default::default() });
         // A broken line can't be swept: what the filled areas give (nothing here, without a panic).
         let s = [rect(0.0, 0.0, 100.0, 100.0, 0), line((0.0, 0.0), (f64::NAN, 1.0), 1)];
-        assert_eq!(shape_builder(&s), (crate::regions(&s), vec![]));
+        assert_eq!(shape_builder(&s, false), BuilderArrangement { regions: crate::regions(&s), ..Default::default() });
         // Zero-length and doubled-back lines don't break it either.
         let s = [
             rect(0.0, 0.0, 100.0, 100.0, 0),
@@ -793,7 +944,7 @@ mod tests {
             line((0.0, 0.0), (100.0, 0.0), 2),
             line((50.0, 0.0), (50.0, 100.0), 3),
         ];
-        let (regions, _) = shape_builder(&s);
+        let regions = shape_builder(&s, false).regions;
         assert_eq!(regions.len(), 2);
         assert!((regions.iter().map(area).sum::<f64>() - 10000.0).abs() < 1e-6);
     }
@@ -815,14 +966,75 @@ mod tests {
             s.push(line((-150.0, y), (150.0, y + 7.0), 1));
         }
         let started = std::time::Instant::now();
-        let (regions, lines) = shape_builder(&s);
+        let BuilderArrangement { regions, lines, .. } = shape_builder(&s, false);
         assert!(regions.len() >= 5, "the ring cut in five bands at least (the waves make pockets)");
         assert!(lines.len() >= 12, "{}", lines.len());
         assert!(started.elapsed().as_secs_f64() < 5.0, "{:?}", started.elapsed());
         // Past the cap, only the filled areas count.
         s.push(line((0.0, 0.0), (1.0, 1.0), 2));
         s[0].path.subpaths[0].anchors.extend((0..16).map(|k| vectorcraft_geom::Anchor::corner(Point::new(100.0, f64::from(k)))));
-        assert!(shape_builder(&s).1.is_empty());
+        assert!(shape_builder(&s, false).lines.is_empty());
+    }
+
+    fn poly(pts: &[(f64, f64)], closed: bool) -> SubPath {
+        SubPath::polyline(&pts.iter().map(|&(x, y)| Point::new(x, y)).collect::<Vec<_>>(), closed)
+    }
+
+    fn ends(sp: &SubPath) -> (Point, Point) {
+        (sp.anchors[0].p, sp.anchors[sp.anchors.len() - 1].p)
+    }
+
+    #[test]
+    fn shape_builder_edges_are_the_outlines_cut_where_paths_meet() {
+        // Two overlapping squares: each outline in two pieces, cut where the other crosses it.
+        let s = [rect(0.0, 0.0, 100.0, 100.0, 0), rect(50.0, 50.0, 150.0, 150.0, 1)];
+        let with = shape_builder(&s, true);
+        assert_eq!(with.regions, shape_builder(&s, false).regions, "the regions don't change");
+        assert!(with.lines.is_empty() && shape_builder(&s, false).edges.is_empty());
+        assert_eq!(with.edges.len(), 4);
+        for key in [0, 1] {
+            assert_eq!(with.edges.iter().filter(|e| e.key == key && !e.path.is_closed()).count(), 2);
+        }
+        let inner = with.edges.iter().find(|e| e.key == 0 && e.path.bounds() == Some(Rect::new(50.0, 50.0, 100.0, 100.0))).expect("A inside B");
+        // Erasing it opens A there.
+        let cut = cut_out(&s[0].path, &inner.path.subpaths[0], false, 1e-3).expect("on A");
+        assert_eq!(cut.subpaths.len(), 1);
+        let sp = &cut.subpaths[0];
+        assert!(!sp.closed && sp.anchors.len() == 5, "{sp:?}");
+        let (a, b) = ends(sp);
+        assert!([a, b].contains(&Point::new(100.0, 50.0)) && [a, b].contains(&Point::new(50.0, 100.0)), "{a:?} {b:?}");
+        assert!((cut.length() - 300.0).abs() < 1e-6, "{}", cut.length());
+        // Not on B.
+        assert_eq!(cut_out(&s[1].path, &inner.path.subpaths[0], false, 1e-3), None);
+        // A lone square's edge is its whole outline: erasing it leaves nothing.
+        let lone = shape_builder(&s[..1], true);
+        assert_eq!(lone.edges.len(), 1);
+        assert!(cut_out(&s[0].path, &lone.edges[0].path.subpaths[0], false, 1e-3).unwrap().is_empty());
+    }
+
+    #[test]
+    fn cut_out_splits_open_paths_and_keeps_closing_edges_invisible() {
+        let open = PathData::single(poly(&[(0.0, 0.0), (100.0, 0.0)], false));
+        let cut = cut_out(&open, &poly(&[(60.0, 0.0), (30.0, 0.0)], false), false, 1e-3).unwrap();
+        let mut parts: Vec<(Point, Point)> = cut.subpaths.iter().map(ends).collect();
+        parts.sort_by(|a, b| a.0.x.total_cmp(&b.0.x));
+        assert_eq!(parts, vec![(Point::new(0.0, 0.0), Point::new(30.0, 0.0)), (Point::new(60.0, 0.0), Point::new(100.0, 0.0))]);
+        // An end piece only shortens it.
+        let cut = cut_out(&open, &poly(&[(70.0, 0.0), (100.0, 0.0)], false), false, 1e-3).unwrap();
+        assert_eq!(cut.subpaths.iter().map(ends).collect::<Vec<_>>(), vec![(Point::new(0.0, 0.0), Point::new(70.0, 0.0))]);
+
+        // A filled open path runs on round its invisible closing edge (100,100) → (0,0).
+        let corner = PathData::single(poly(&[(0.0, 0.0), (100.0, 0.0), (100.0, 100.0)], false));
+        let piece = poly(&[(100.0, 50.0), (100.0, 100.0), (50.0, 50.0)], false);
+        assert_eq!(cut_out(&corner, &piece, false, 1e-3), None, "without the fill it isn't on the path");
+        let cut = cut_out(&corner, &piece, true, 1e-3).unwrap();
+        assert_eq!(cut.subpaths.len(), 1);
+        assert_eq!(cut.subpaths[0].anchors.iter().map(|a| a.p).collect::<Vec<_>>(), [(0.0, 0.0), (100.0, 0.0), (100.0, 50.0)].map(Point::from));
+        // Cut elsewhere, the closing edge stays invisible: two open runs, not one through it.
+        let cut = cut_out(&corner, &poly(&[(20.0, 0.0), (60.0, 0.0)], false), true, 1e-3).unwrap();
+        assert_eq!(cut.subpaths.len(), 2);
+        assert!(cut.subpaths.iter().all(|sp| !sp.closed));
+        assert!((cut.length() - 160.0).abs() < 1e-6, "{}", cut.length());
     }
 
     fn arb_segment() -> impl Strategy<Value = Shape> {
@@ -872,6 +1084,26 @@ mod tests {
             prop_assert!((filled - regions).abs() <= 1e-9 + DEFAULT_PRECISION * outlines, "{} vs {}", filled, regions);
         }
 
+        /// Every edge and line piece cuts out of the input it is keyed by, which loses its length
+        /// and nothing else.
+        #[test]
+        fn pieces_cut_out_of_their_inputs(shapes in prop::collection::vec(arb_segment(), 1..6)) {
+            let arr = shape_builder(&shapes, true);
+            for e in arr.edges.iter().chain(&arr.lines) {
+                let (Some(s), Some(piece)) = (shapes.get(e.key as usize), e.path.subpaths.first()) else { continue };
+                let len = e.path.length();
+                let cut = cut_out(&s.path, piece, false, 0.05);
+                if len <= 0.05 {
+                    // A speck where two paths touch.
+                    prop_assert!(cut.is_none());
+                    continue;
+                }
+                prop_assert!(cut.is_some(), "{:?} not on {:?}", piece, s.path);
+                let lost = s.path.length() - cut.map_or(0.0, |c| c.length());
+                prop_assert!((lost - len).abs() <= 0.05 + 1e-3 * len, "lost {} for a piece {} long", lost, len);
+            }
+        }
+
         /// Lines anywhere (not on a grid): faces stay disjoint, and nothing panics.
         #[test]
         fn free_lines_make_disjoint_faces(pts in prop::collection::vec((-50.0..150.0f64, -50.0..150.0f64, -50.0..150.0f64, -50.0..150.0f64), 2..9)) {

crates/pdf/src/import_text.rs

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

crates/pdf/src/tests_realtext.rs

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

crates/svg/src/export.rs

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

crates/svg/src/import/text.rs

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

crates/svg/tests/import_text.rs

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

crates/svg/tests/roundtrip.rs

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

crates/text/src/layout.rs

@@ -2,9 +2,10 @@
 
 use std::ops::Range;
 
-use kurbo::{Affine, BezPath, ParamCurve, ParamCurveArclen, PathEl, PathSeg, Point, Rect, Shape, Vec2};
+use kurbo::{Affine, BezPath, PathEl, Point, Rect, Shape, Vec2};
 use unicode_bidi::{BidiInfo, Level};
-use vectorcraft_doc::{CharStyle, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathEffect, TextKind, TextObject};
+use vectorcraft_doc::{CharStyle, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathAlign, PathEffect, TextKind, TextObject};
+use vectorcraft_geom::{ArcPath, PathData};
 
 use crate::composer::{Breakpoint, compose};
 use crate::fontdb::FontDb;
@@ -184,7 +185,7 @@ pub fn layout_with(db: &FontDb, t: &TextObject, opts: &LayoutOptions) -> TextLay
             cx.out.frames = regions.iter().map(|r| line_xf.transform_rect_bbox(r.cell)).collect();
             flow(&mut cx, &paras, &t.para, Some(&regions));
         }
-        TextKind::OnPath { path, start } => on_path(&mut cx, &paras, &t.para, &path.to_bezpath(), *start, path.is_closed(), t.path_effect),
+        TextKind::OnPath { path, .. } => on_path(&mut cx, &paras, t, path),
     }
     if vertical && !is_on_path {
         // Glyph origins, outlines and transforms to text space (lines stay in line space).
@@ -1168,43 +1169,31 @@ fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Opt
     }
 }
 
-/// Arc-length parameterised path.
-struct ArcPath {
-    segs: Vec<(PathSeg, f64, f64)>,
-    len: f64,
-}
-
-impl ArcPath {
-    fn new(p: &BezPath) -> Self {
-        let mut segs = Vec::new();
-        let mut cum = 0.0;
-        for s in p.segments() {
-            let l = s.arclen(1e-4);
-            if l > 1e-9 {
-                segs.push((s, cum, l));
-                cum += l;
+/// The distance along type on a path each glyph takes: its advance measured `spacing` points above
+/// the path (Type on a Path Options › Spacing), so glyphs close up round the outside of a curve and
+/// open up round the inside; just the advances without spacing. Glyphs start `from` along the path.
+fn path_steps(ap: &ArcPath, glyphs: &[SGlyph], from: f64, spacing: f64) -> Vec<f64> {
+    let mut s = from;
+    glyphs
+        .iter()
+        .map(|g| {
+            let mut step = g.adv;
+            if spacing != 0.0 && g.adv > 1e-9 {
+                // How far the path turns across the glyph: positive bending away from its top.
+                let ((_, a), (_, b)) = (ap.at(s), ap.at(s + g.adv));
+                let curvature = a.cross(b).atan2(a.dot(b)) / g.adv;
+                step = g.adv / (1.0 + curvature * spacing).clamp(0.25, 4.0);
             }
-        }
-        Self { segs, len: cum }
-    }
-
-    /// Point and unit tangent at arc length `s`.
-    fn at(&self, s: f64) -> (Point, Vec2) {
-        let s = s.clamp(0.0, self.len);
-        let i = self.segs.partition_point(|(_, c, _)| *c <= s).saturating_sub(1);
-        let (seg, c, l) = self.segs[i];
-        let t = seg.inv_arclen((s - c).min(l), 1e-4).clamp(0.0, 1.0);
-        let p = seg.eval(t);
-        let (t0, t1) = ((t - 1e-4).max(0.0), (t + 1e-4).min(1.0));
-        let d = seg.eval(t1) - seg.eval(t0);
-        let len = d.hypot();
-        (p, if len > 1e-12 { d / len } else { Vec2::new(1.0, 0.0) })
-    }
+            s += step;
+            step
+        })
+        .collect()
 }
 
-#[allow(clippy::too_many_arguments)]
-fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, path: &BezPath, start: f64, closed: bool, effect: PathEffect) {
+/// Lay type on a path out along `path` (text space), between its brackets.
+fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, path: &PathData) {
     cx.out.on_path = true;
+    let para = &t.para;
     let mut sg = Vec::new();
     // The first paragraph's direction aligns the line (Auto) and sets the caret's.
     let mut rtl = None;
@@ -1226,7 +1215,7 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, path: &Be
         (s.0, s.1)
     });
     let text_len = cx.text.len();
-    if ap.segs.is_empty() {
+    if ap.is_empty() {
         cx.out.overflow = !sg.is_empty();
         cx.out.lines.push(LineInfo {
             rtl,
@@ -1243,32 +1232,43 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, path: &Be
         });
         return;
     }
-    let centre = path.bounding_box().center();
-    let s_start = start.clamp(0.0, 1.0) * ap.len;
-    let avail = if closed { ap.len } else { ap.len - s_start };
-    let w: f64 = sg.iter().map(|g| g.adv).sum();
+    let centre = path.bounds().unwrap_or_default().center();
+    let (from, to) = t.kind.path_span().unwrap_or((0.0, 1.0));
+    let s_start = from * ap.len();
+    let avail = (to - from) * ap.len();
+    let spacing = if t.path_spacing.is_finite() { t.path_spacing } else { 0.0 };
+    let mut steps = path_steps(&ap, &sg, s_start, spacing);
+    let w: f64 = steps.iter().sum();
     let s0 = match para.justify {
         Justify::Auto if rtl => s_start + (avail - w).max(0.0),
         Justify::Center | Justify::JustifyCenter => s_start + ((avail - w) * 0.5).max(0.0),
         Justify::Right | Justify::JustifyRight => s_start + (avail - w).max(0.0),
         _ => s_start,
     };
+    if spacing != 0.0 && s0 != s_start {
+        // Spaced from where the alignment puts them, the curve under them is another.
+        steps = path_steps(&ap, &sg, s0, spacing);
+    }
+    // Align to Path: how far down (glyph space) the type moves to run its ascender, centre or
+    // descender along the path instead of its baseline.
+    let rise = match t.path_align {
+        PathAlign::Baseline => 0.0,
+        PathAlign::Ascender => m.0,
+        PathAlign::Descender => -m.1,
+        PathAlign::Center => (m.0 - m.1) * 0.5,
+    };
     let mut x = 0.0;
-    for g in &sg {
+    for (g, &step) in sg.iter().zip(&steps) {
         let s = s0 + x;
-        if s + g.adv - s_start > avail + 1e-6 {
+        if s + step - s_start > avail + 1e-6 {
             cx.out.overflow = true;
             break;
         }
-        let mut mid = s + g.adv * 0.5;
-        if closed {
-            mid = mid.rem_euclid(ap.len);
-        }
-        let (p, dir) = ap.at(mid);
+        let (p, dir) = ap.at(s + step * 0.5);
         let angle = dir.y.atan2(dir.x);
-        let half = Affine::translate((-g.adv * 0.5, 0.0));
+        let half = Affine::translate((-g.adv * 0.5, rise));
         // Glyph space: x along the advance, y down from the baseline; `pre` maps it onto the path.
-        let pre = match effect {
+        let pre = match t.path_effect {
             PathEffect::Rainbow => Affine::translate(p.to_vec2()) * Affine::rotate(angle) * half,
             // x axis along the tangent, y axis stays vertical.
             PathEffect::Skew => Affine::translate(p.to_vec2()) * Affine::new([dir.x, dir.y, 0.0, 1.0, 0.0, 0.0]) * half,
@@ -1277,10 +1277,7 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, path: &Be
                 let sx = if dir.x < 0.0 { -1.0 } else { 1.0 };
                 Affine::translate(p.to_vec2()) * Affine::new([sx, 0.0, -dir.y * sx, dir.x * sx, 0.0, 0.0]) * half
             }
-            PathEffect::StairStep => {
-                let s_left = if closed { s.rem_euclid(ap.len) } else { s };
-                Affine::translate(ap.at(s_left).0.to_vec2())
-            }
+            PathEffect::StairStep => Affine::translate(ap.at(s).0.to_vec2()) * Affine::translate((0.0, rise)),
             // x axis along the tangent; vertical edges point at the path's centre (kept on the glyph's
             // up side, and never closer than ~17° to the baseline so glyphs stay legible).
             PathEffect::Gravity => {
@@ -1291,17 +1288,19 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, path: &Be
                     up = -up;
                 }
                 if up.dot(n) < 0.3 {
-                    let t = up - n * up.dot(n);
-                    up = n * 0.3 + t / t.hypot().max(1e-9) * (1.0 - 0.09f64).sqrt();
+                    let along = up - n * up.dot(n);
+                    up = n * 0.3 + along / along.hypot().max(1e-9) * (1.0 - 0.09f64).sqrt();
                 }
                 Affine::translate(p.to_vec2()) * Affine::new([dir.x, dir.y, -up.x, -up.y, 0.0, 0.0]) * half
             }
         };
-        cx.emit(g, pre, p - dir * (g.adv * 0.5), angle, g.adv, 0);
-        x += g.adv;
+        // The caret's baseline moves with the type.
+        let origin = p - dir * (g.adv * 0.5) + Vec2::new(-dir.y, dir.x) * rise;
+        cx.emit(g, pre, origin, angle, g.adv, 0);
+        x += step;
     }
-    let (ps, _) = ap.at(if closed { s0.rem_euclid(ap.len) } else { s0 });
-    let (pe, _) = ap.at(if closed { (s0 + x).rem_euclid(ap.len) } else { s0 + x });
+    let (ps, _) = ap.at(s0);
+    let (pe, _) = ap.at(s0 + x);
     cx.out.lines.push(LineInfo {
         rtl,
         baseline: ps.y,
@@ -1313,7 +1312,7 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, path: &Be
         end: text_len,
         glyph_start: 0,
         glyph_end: cx.out.glyphs.len(),
-        avail: (0.0, ap.len),
+        avail: (0.0, ap.len()),
     });
 }
 

crates/text/src/lib.rs

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

crates/text/src/tests.rs

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

crates/text/src/tests_vertical.rs

@@ -76,7 +76,7 @@ fn area_type_starts_at_the_right_edge_and_wraps_to_the_left() {
 #[test]
 fn type_on_a_path_stays_horizontal() {
     let mut t = vertical("ab");
-    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&kurbo::Line::new((0.0, 0.0), (100.0, 0.0)).to_path(0.1)), start: 0.0 };
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&kurbo::Line::new((0.0, 0.0), (100.0, 0.0)).to_path(0.1)), start: 0.0, end: None };
     assert!(!layout(FontDb::global(), &t).vertical);
 }
 

crates/tools/src/builder.rs

@@ -162,12 +162,7 @@ fn shape_builder_shapes<'a>(doc: &'a Document, roots: &[NodeId]) -> (Vec<po::Sha
             continue;
         }
         for sp in s.path.subpaths.iter_mut().filter(|sp| !sp.closed) {
-            let mut closed = sp.clone();
-            closed.closed = true;
-            let mut bp = BezPath::new();
-            closed.to_bezpath_into(&mut bp);
-            let size = bp.bounding_box().size();
-            sp.closed = bp.area().abs() > 1e-9 * (size.width * size.width + size.height * size.height);
+            sp.closed = po::encloses_area(sp);
         }
     }
     (shapes, leaves)
@@ -195,6 +190,9 @@ pub struct BuilderMap {
     pub regions: Vec<Face>,
     /// Pieces of the unfilled open paths, keyed by input index, with their bounds.
     pub lines: Vec<(po::Shape, Rect)>,
+    /// Pieces of the other inputs' outlines (cut wherever paths meet), keyed by input index, with
+    /// their bounds: the edges erasing deletes. Only in a map made `with_edges`.
+    pub edges: Vec<(po::Shape, Rect)>,
 }
 
 /// What a Shape Builder gesture touches at a point.
@@ -202,18 +200,43 @@ pub struct BuilderMap {
 pub enum Hit {
     Region(usize),
     Line(usize),
+    Edge(usize),
+}
+
+/// The piece of `pieces` nearest `p` within `tol`, with its distance.
+fn piece_near(pieces: &[(po::Shape, Rect)], p: Point, tol: f64) -> Option<(f64, usize)> {
+    let mut best: Option<(f64, usize)> = None;
+    for (i, (l, b)) in pieces.iter().enumerate() {
+        if b.inflate(tol, tol).contains(p)
+            && let Some((.., d)) = l.path.nearest(p)
+            && d <= tol
+            && best.is_none_or(|b| d < b.0)
+        {
+            best = Some((d, i));
+        }
+    }
+    best
 }
 
 impl BuilderMap {
-    /// The map of `roots` (sorted back → front), with the leaves the inputs came from.
-    pub fn new<'a>(doc: &'a Document, roots: &[NodeId]) -> (Self, Vec<&'a Node>) {
+    /// The map of `roots` (sorted back → front), with the leaves the inputs came from; the outline
+    /// edges only `with_edges` (they cost a planar map of their own when no open path is in).
+    pub fn new<'a>(doc: &'a Document, roots: &[NodeId], with_edges: bool) -> (Self, Vec<&'a Node>) {
         let (shapes, leaves) = shape_builder_shapes(doc, roots);
         if shapes.is_empty() {
             return (Self::default(), leaves);
         }
-        let (regions, lines) = po::shape_builder(&shapes);
-        let lines = lines.into_iter().filter_map(|l| Some((l.path.bounds()?, l))).map(|(b, l)| (l, b)).collect();
-        (Self { shapes, regions: faces_of(regions), lines }, leaves)
+        let arr = po::shape_builder(&shapes, with_edges);
+        let bounded = |pieces: Vec<po::Shape>| {
+            pieces
+                .into_iter()
+                .filter_map(|l| {
+                    let b = l.path.bounds()?;
+                    Some((l, b))
+                })
+                .collect()
+        };
+        (Self { shapes, regions: faces_of(arr.regions), lines: bounded(arr.lines), edges: bounded(arr.edges) }, leaves)
     }
 
     /// The region containing `p`.
@@ -221,53 +244,56 @@ impl BuilderMap {
         self.regions.iter().position(|(_, bp, b)| b.contains(p) && bp.winding(p) != 0)
     }
 
-    /// The line piece nearest `p`, within `tol`.
-    pub fn line_near(&self, p: Point, tol: f64) -> Option<usize> {
-        let mut best: Option<(f64, usize)> = None;
-        for (i, (l, b)) in self.lines.iter().enumerate() {
-            if b.inflate(tol, tol).contains(p)
-                && let Some((.., d)) = l.path.nearest(p)
-                && d <= tol
-                && best.is_none_or(|b| d < b.0)
-            {
-                best = Some((d, i));
-            }
-        }
-        best.map(|b| b.1)
+    /// What a gesture at `p` touches: with `piece_tol` (erasing), the line piece or edge that
+    /// close, else the region under it.
+    pub fn hit(&self, p: Point, piece_tol: Option<f64>) -> Option<Hit> {
+        let piece = piece_tol.and_then(|t| match (piece_near(&self.lines, p, t), piece_near(&self.edges, p, t)) {
+            (Some(l), Some(e)) if e.0 < l.0 => Some(Hit::Edge(e.1)),
+            (Some(l), _) => Some(Hit::Line(l.1)),
+            (None, e) => e.map(|e| Hit::Edge(e.1)),
+        });
+        piece.or_else(|| self.region_at(p).map(Hit::Region))
     }
 
-    /// What a gesture at `p` touches: with `line_tol` (erasing), a line piece that close, else the
-    /// region under it.
-    pub fn hit(&self, p: Point, line_tol: Option<f64>) -> Option<Hit> {
-        line_tol.and_then(|t| self.line_near(p, t)).map(Hit::Line).or_else(|| self.region_at(p).map(Hit::Region))
-    }
-
-    /// Does line piece `i` run between two of `regions` (an edge that merging or deleting them
-    /// removes)?
-    pub fn line_between(&self, i: usize, regions: &[usize]) -> bool {
-        let Some(sp) = self.lines.get(i).and_then(|(l, _)| l.path.subpaths.first()) else { return false };
+    /// The regions just either side of the middle of `piece` (None: outside every region).
+    fn sides(&self, piece: &po::Shape) -> [Option<usize>; 2] {
+        let Some(sp) = piece.path.subpaths.first() else { return [None; 2] };
         let n = sp.segment_count();
         if n == 0 {
-            return false;
+            return [None; 2];
         }
         let c = sp.segment(n / 2);
         use kurbo::{ParamCurve as _, ParamCurveDeriv as _};
         let (m, d) = (c.eval(0.5), c.deriv().eval(0.5).to_vec2());
         let len = d.hypot();
         if !(len.is_finite() && len > 0.0) {
-            return false;
+            return [None; 2];
         }
         // A little to each side: inside the faces next to it, which share it exactly.
         let off = d.turn_90() * (0.05f64.min(0.05 * c.p0.distance(c.p3)).max(1e-6) / len);
-        [m + off, m - off].into_iter().all(|q| self.region_at(q).is_some_and(|r| regions.contains(&r)))
+        [m + off, m - off].map(|q| self.region_at(q))
+    }
+
+    /// Does line piece `i` run between two of `regions` (an edge that merging or deleting them
+    /// removes)?
+    pub fn line_between(&self, i: usize, regions: &[usize]) -> bool {
+        self.lines.get(i).is_some_and(|(l, _)| self.sides(l).iter().all(|r| r.is_some_and(|r| regions.contains(&r))))
+    }
+
+    /// The edges `touched` deletes: those that bound none of its regions (deleting a region takes
+    /// its edges with it, so an erase drag that crosses an edge into a region deletes the region).
+    pub fn erased_edges(&self, touched: &Touched) -> Vec<usize> {
+        let bounds_one = |(e, _): &(po::Shape, Rect)| self.sides(e).iter().any(|r| r.is_some_and(|r| touched.regions.contains(&r)));
+        touched.edges.iter().copied().filter(|&k| self.edges.get(k).is_some_and(|e| !bounds_one(e))).collect()
     }
 }
 
-/// The regions and line pieces a Shape Builder gesture has touched, in the order touched.
+/// The regions, line pieces and edges a Shape Builder gesture has touched, in the order touched.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct Touched {
     pub regions: Vec<usize>,
     pub lines: Vec<usize>,
+    pub edges: Vec<usize>,
 }
 
 impl Touched {
@@ -275,6 +301,7 @@ impl Touched {
         let (list, i) = match hit {
             Some(Hit::Region(i)) => (&mut self.regions, i),
             Some(Hit::Line(i)) => (&mut self.lines, i),
+            Some(Hit::Edge(i)) => (&mut self.edges, i),
             None => return,
         };
         if !list.contains(&i) {
@@ -283,7 +310,7 @@ impl Touched {
     }
 
     pub fn is_empty(&self) -> bool {
-        self.regions.is_empty() && self.lines.is_empty()
+        self.regions.is_empty() && self.lines.is_empty() && self.edges.is_empty()
     }
 }
 
@@ -381,36 +408,42 @@ struct RegionCache {
     map: BuilderMap,
     /// Live Paint faces (every path an edge, filled or not) rather than Shape Builder regions.
     live: bool,
+    /// The map has the Shape Builder's outline edges.
+    edges: bool,
 }
 
 impl RegionCache {
     fn live_paint() -> Self {
         Self { live: true, ..Default::default() }
     }
-    fn get(&mut self, cx: &ToolContext) -> &BuilderMap {
+    /// The map, with the outline edges when `edges` (built the first time they're wanted).
+    fn get(&mut self, cx: &ToolContext, edges: bool) -> &BuilderMap {
         let key = (cx.doc as *const Document as usize, cx.selection.objects.clone());
-        if self.key.as_ref() != Some(&key) {
+        if self.key.as_ref() != Some(&key) || (edges && !self.edges) {
             let roots = sorted_roots(cx.doc, &cx.selection.objects);
             self.map = if self.live {
                 let (shapes, _) = shapes_for(cx.doc, &roots);
                 let regions = if shapes.is_empty() { vec![] } else { faces_of(po::live_paint(&shapes).0) };
                 BuilderMap { regions, ..Default::default() }
             } else {
-                BuilderMap::new(cx.doc, &roots).0
+                BuilderMap::new(cx.doc, &roots, edges).0
             };
             self.key = Some(key);
+            self.edges = edges;
         }
         &self.map
     }
     fn at(&mut self, cx: &ToolContext, p: Point) -> Option<usize> {
-        self.get(cx).region_at(p)
+        self.get(cx, false).region_at(p)
     }
 }
 
 // ---------- Shape Builder ----------
 
-/// Shape Builder tool: drag across regions to merge them, Alt-drag to delete them (and the pieces
-/// of open paths it passes over).
+/// Shape Builder tool: drag across regions to merge them. Holding Alt (Option) switches to erase
+/// mode while it is held: the pointer shows a minus, what a click or drag would delete highlights in
+/// red, and the gesture deletes the regions it touches, the pieces of open paths and the edges
+/// (outline pieces between the points where paths meet) it passes over.
 #[derive(Default)]
 pub struct ShapeBuilderTool {
     cache: RegionCache,
@@ -418,10 +451,11 @@ pub struct ShapeBuilderTool {
     points: Vec<Point>,
     touched: Touched,
     dragging: bool,
+    /// Erase mode: Alt held while hovering, or when the drag started.
     alt: bool,
 }
 
-/// How close (screen px) the pointer must come to a line piece to delete it.
+/// How close (screen px) the pointer must come to a line piece or an edge to delete it.
 const LINE_TOL_PX: f64 = 4.0;
 
 impl ShapeBuilderTool {
@@ -435,9 +469,9 @@ impl ShapeBuilderTool {
             None => vec![to],
         };
         let tol = Self::line_tol(cx, self.alt);
+        let map = self.cache.get(cx, self.alt);
         for p in pts {
-            let hit = self.cache.get(cx).hit(p, tol);
-            self.touched.add(hit);
+            self.touched.add(map.hit(p, tol));
         }
     }
 }
@@ -451,7 +485,8 @@ impl Tool for ShapeBuilderTool {
         let p = ev.pos;
         match ev.kind {
             PointerKind::Move => {
-                self.hover = self.cache.get(cx).hit(p, Self::line_tol(cx, ev.mods.alt));
+                self.alt = ev.mods.alt;
+                self.hover = self.cache.get(cx, self.alt).hit(p, Self::line_tol(cx, self.alt));
                 vec![]
             }
             PointerKind::Down => {
@@ -487,7 +522,8 @@ impl Tool for ShapeBuilderTool {
                 self.cache.key = None;
                 let roots = sorted_roots(cx.doc, &cx.selection.objects);
                 let pts: Vec<Value> = points.iter().map(|q| json!([q.x, q.y])).collect();
-                let erase = self.alt || ev.mods.alt;
+                // The mode the drag started in, which its highlight showed.
+                let erase = self.alt;
                 let mut params = json!({ "ids": json_ids(&roots), "points": pts, "erase": erase });
                 if let Some(t) = Self::line_tol(cx, erase) {
                     params["tolerance"] = json!(t);
@@ -501,9 +537,11 @@ impl Tool for ShapeBuilderTool {
     fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
         let mut out = vec![];
         let map = &self.cache.map;
-        let color = if self.dragging && self.alt { HIGHLIGHT_RED } else { HATCH };
+        let color = if self.alt { HIGHLIGHT_RED } else { HATCH };
         let show: Vec<Hit> = if self.dragging {
-            self.touched.regions.iter().map(|&i| Hit::Region(i)).chain(self.touched.lines.iter().map(|&i| Hit::Line(i))).collect()
+            let t = &self.touched;
+            let regions = t.regions.iter().map(|&i| Hit::Region(i));
+            regions.chain(t.lines.iter().map(|&i| Hit::Line(i))).chain(map.erased_edges(t).into_iter().map(Hit::Edge)).collect()
         } else {
             self.hover.into_iter().collect()
         };
@@ -515,8 +553,9 @@ impl Tool for ShapeBuilderTool {
                         out.push(Overlay::Path { path: bp.clone(), color, width: 1.0, dashed: false });
                     }
                 }
-                Hit::Line(i) => {
-                    if let Some((l, _)) = map.lines.get(i) {
+                Hit::Line(i) | Hit::Edge(i) => {
+                    let pieces = if matches!(hit, Hit::Line(_)) { &map.lines } else { &map.edges };
+                    if let Some((l, _)) = pieces.get(i) {
                         out.push(Overlay::Path { path: l.path.to_bezpath(), color: HIGHLIGHT_RED, width: 3.0, dashed: false });
                     }
                 }
@@ -533,8 +572,10 @@ impl Tool for ShapeBuilderTool {
         out
     }
 
-    fn cursor(&self, _cx: &ToolContext, _p: Point, _m: Mods) -> Cursor {
-        Cursor::Crosshair
+    fn cursor(&self, _cx: &ToolContext, _p: Point, m: Mods) -> Cursor {
+        // A drag keeps the mode it started in; hovering follows the key.
+        let erase = if self.dragging { self.alt } else { m.alt };
+        if erase { Cursor::ShapeBuilderErase } else { Cursor::ShapeBuilder }
     }
 
     fn busy(&self) -> bool {
@@ -803,6 +844,90 @@ mod tests {
         assert!(t.pointer(&cx, &ev(PointerKind::Up, 300.0, 300.0)).is_empty());
     }
 
+    /// Squares A (0..100) and B (50..150 both ways), overlapping at a corner, selected.
+    fn corner_rects() -> (Document, Selection) {
+        let mut d = Document::new(500.0, 500.0);
+        let l = d.layers[0].id;
+        let mut s = Selection::default();
+        for (k, r) in [Rect::new(0.0, 0.0, 100.0, 100.0), Rect::new(50.0, 50.0, 150.0, 150.0)].into_iter().enumerate() {
+            let id = d.alloc_id();
+            d.insert(Some(l), k, Node::path(id, shapes::rectangle(r), Appearance::default_art())).unwrap();
+            s.add(id);
+        }
+        (d, s)
+    }
+
+    fn colors(ov: &[Overlay]) -> Vec<[u8; 3]> {
+        ov.iter().map(|o| if let Overlay::Path { color, .. } = o { *color } else { panic!("{o:?}") }).collect()
+    }
+
+    #[test]
+    fn shape_builder_alt_switches_to_erase_mode_while_held() {
+        let (d, s) = corner_rects();
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let mut t = ShapeBuilderTool::default();
+        let alt = Mods { alt: true, ..Default::default() };
+        let at = Point::new(75.0, 75.0);
+        // Merge mode: a grey mesh and the plus pointer.
+        t.pointer(&cx, &ev(PointerKind::Move, at.x, at.y));
+        assert_eq!(colors(&t.overlays(&cx)), [HATCH; 2]);
+        assert_eq!(t.cursor(&cx, at, Mods::default()), Cursor::ShapeBuilder);
+        // Alt held: what would go highlights red, and the pointer shows a minus.
+        t.pointer(&cx, &ev(PointerKind::Move, at.x, at.y).with_mods(alt));
+        assert_eq!(colors(&t.overlays(&cx)), [HIGHLIGHT_RED; 2]);
+        assert_eq!(t.cursor(&cx, at, alt), Cursor::ShapeBuilderErase);
+        // Released: merge mode again.
+        t.pointer(&cx, &ev(PointerKind::Move, at.x, at.y));
+        assert_eq!(colors(&t.overlays(&cx)), [HATCH; 2]);
+        assert_eq!(t.cursor(&cx, at, Mods::default()), Cursor::ShapeBuilder);
+        // A drag keeps the mode it started in.
+        t.pointer(&cx, &ev(PointerKind::Down, at.x, at.y).with_mods(alt));
+        assert_eq!(t.cursor(&cx, at, Mods::default()), Cursor::ShapeBuilderErase);
+        let acts = t.pointer(&cx, &ev(PointerKind::Up, at.x, at.y));
+        let Action::Exec(_, v) = &acts[0] else { panic!("{acts:?}") };
+        assert_eq!(v["erase"], true);
+    }
+
+    #[test]
+    fn shape_builder_alt_on_an_edge_highlights_and_deletes_it() {
+        let (d, s) = corner_rects();
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let mut t = ShapeBuilderTool::default();
+        let alt = Mods { alt: true, ..Default::default() };
+        // A's side inside B, between the points where B's outline crosses it.
+        t.pointer(&cx, &ev(PointerKind::Move, 101.0, 75.0).with_mods(alt));
+        assert!(matches!(t.hover, Some(Hit::Edge(_))), "{:?}", t.hover);
+        let ov = t.overlays(&cx);
+        let [Overlay::Path { path, color: HIGHLIGHT_RED, width: 3.0, .. }] = ov.as_slice() else { panic!("{ov:?}") };
+        assert_eq!(path.bounding_box(), Rect::new(50.0, 50.0, 100.0, 100.0));
+        // Without Alt it's the region under the pointer.
+        t.pointer(&cx, &ev(PointerKind::Move, 101.0, 75.0));
+        assert!(matches!(t.hover, Some(Hit::Region(_))));
+        t.pointer(&cx, &ev(PointerKind::Down, 101.0, 75.0).with_mods(alt));
+        assert_eq!(t.touched.edges.len(), 1);
+        let acts = t.pointer(&cx, &ev(PointerKind::Up, 101.0, 75.0).with_mods(alt));
+        let Action::Exec(id, v) = &acts[0] else { panic!("{acts:?}") };
+        assert_eq!((id.as_str(), &v["erase"], &v["tolerance"]), ("shapeBuilder.merge", &json!(true), &json!(4.0)));
+    }
+
+    #[test]
+    fn shape_builder_erase_drag_into_regions_shows_the_regions_not_the_edges_it_crosses() {
+        let (d, s) = corner_rects();
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let mut t = ShapeBuilderTool::default();
+        let alt = Mods { alt: true, ..Default::default() };
+        t.pointer(&cx, &ev(PointerKind::Down, 25.0, 25.0).with_mods(alt));
+        t.pointer(&cx, &ev(PointerKind::Drag, 75.0, 75.0).with_mods(alt));
+        assert_eq!(t.touched.regions.len(), 2);
+        assert!(!t.touched.edges.is_empty(), "the drag crossed B's outline");
+        assert!(t.cache.map.erased_edges(&t.touched).is_empty(), "which goes with the regions");
+        // Two regions (mesh + outline each) and the drag's trail, all red.
+        assert_eq!(colors(&t.overlays(&cx)), [HIGHLIGHT_RED; 5]);
+    }
+
     #[test]
     fn hatch_stays_inside_region() {
         let bp = shapes::rectangle(Rect::new(0.0, 0.0, 40.0, 20.0)).to_bezpath();

crates/tools/src/direct.rs

@@ -15,6 +15,7 @@
 //! with it) and, once a point is clicked, its handles; and the points of selected gradient meshes
 //! and mesh envelopes and their handles ([`MeshEdit`]). Dragging a corner or an edge of area
 //! type's frame reshapes the type area (`text.reshapeArea`): the text reflows at its size.
+//! Dragging the brackets of selected type on a path moves or flips it ([`crate::pathtype`]).
 //!
 //! A press on the stroke of a path that isn't selected as a whole selects that segment's two anchors
 //! (the fill, or Alt, selects the whole path); dragging the segment bends it if it's curved, else
@@ -31,6 +32,7 @@ use crate::bbox::move_delta;
 use crate::corners::{self, CornerDrag, over_widget};
 use crate::guides::{PointSnap, Targets};
 use crate::meshedit::MeshEdit;
+use crate::pathtype::{self, BracketDrag, over_bracket};
 use crate::rulerguide::GuideEdit;
 use crate::select::{MoveSnap, is_area_type, matrix_json};
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext};
@@ -70,6 +72,8 @@ enum State {
         add: bool,
     },
     Corner(CornerDrag),
+    /// Dragging a bracket of type on a path.
+    Bracket(BracketDrag),
     /// Dragging a point of a blend's spine from `from`.
     SpinePoint {
         id: NodeId,
@@ -310,6 +314,10 @@ impl Tool for DirectSelectionTool {
                     self.state = State::Corner(c);
                     return vec![];
                 }
+                if let Some(b) = BracketDrag::hit(cx, ev) {
+                    self.state = State::Bracket(b);
+                    return vec![];
+                }
                 if let Some(sel) = self.spine.filter(|(id, _)| cx.selection.contains(*id))
                     && let Some(out) = hit_spine_handle(cx, sel, p, tol)
                 {
@@ -502,6 +510,15 @@ impl Tool for DirectSelectionTool {
                 self.state = State::Idle;
                 c.finish()
             }
+            (PointerKind::Drag, State::Bracket(mut b)) => {
+                let out = b.drag(cx, p, ev.mods.cmd);
+                self.state = State::Bracket(b);
+                out
+            }
+            (PointerKind::Up, State::Bracket(b)) => {
+                self.state = State::Idle;
+                b.finish()
+            }
             (
                 PointerKind::Up,
                 State::MoveAnchors { began, .. }
@@ -552,6 +569,7 @@ impl Tool for DirectSelectionTool {
                 out.extend(self.mesh.overlays(cx));
                 if !self.group {
                     out.extend(frame_overlays(cx));
+                    out.extend(pathtype::overlays(cx));
                 }
                 if matches!(self.state, State::Handle { .. } | State::MoveAnchors { .. } | State::MoveObject { .. }) {
                     out.extend(self.guides.iter().cloned());
@@ -568,6 +586,9 @@ impl Tool for DirectSelectionTool {
         if !self.group && (matches!(self.state, State::Corner(_)) || over_widget(cx, p)) {
             return Cursor::CornerRadius;
         }
+        if !self.group && (matches!(self.state, State::Bracket(_)) || over_bracket(cx, p)) {
+            return Cursor::PathBracket;
+        }
         // A press on the highlighted anchor picks it, not the guide.
         self.guide.cursor(cx, p).filter(|_| self.hover.is_none() || self.guide.busy()).unwrap_or(Cursor::ArrowHollow)
     }

crates/tools/src/lib.rs

@@ -20,6 +20,7 @@ pub mod guides;
 pub mod meshblend;
 pub mod meshedit;
 pub mod params;
+pub mod pathtype;
 pub mod pen;
 pub mod place;
 pub mod printtiling;
@@ -409,6 +410,12 @@ pub enum Cursor {
     BlendObject,
     /// The Blend tool over an anchor point (the blend starts there): a crosshair with a target.
     BlendAnchor,
+    /// Over a bracket of selected type on a path (a drag moves it): the arrow with a bracket.
+    PathBracket,
+    /// The Shape Builder: a crosshair with a plus (merge mode)...
+    ShapeBuilder,
+    /// ...or, with Alt held, a minus (erase mode).
+    ShapeBuilderErase,
 }
 
 impl Cursor {
@@ -426,7 +433,9 @@ impl Cursor {
             | Cursor::Slice
             | Cursor::Blend
             | Cursor::BlendObject
-            | Cursor::BlendAnchor => Cursor::Crosshair,
+            | Cursor::BlendAnchor
+            | Cursor::ShapeBuilder
+            | Cursor::ShapeBuilderErase => Cursor::Crosshair,
             c => c,
         }
     }
@@ -569,6 +578,21 @@ pub(crate) mod testutil {
         (d, id)
     }
 
+    /// [`doc_with_rect`] plus type on a 300 pt path from (100, 300) to the right, from 20 % on.
+    pub fn doc_with_path_type() -> (Document, NodeId) {
+        let (mut d, _) = doc_with_rect();
+        let l = d.layers[0].id;
+        let id = d.alloc_id();
+        let mut t = vectorcraft_doc::TextObject::point(Point::ZERO, "Path type", Default::default());
+        let path = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
+            vectorcraft_geom::PathEl::MoveTo(Point::new(100.0, 300.0)),
+            vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
+        ]));
+        t.kind = vectorcraft_doc::TextKind::OnPath { path, start: 0.2, end: None };
+        d.insert(Some(l), 1, Node::new(id, vectorcraft_doc::NodeKind::Text(Box::new(t)))).unwrap();
+        (d, id)
+    }
+
     pub fn paint() -> PaintDefaults {
         PaintDefaults::default()
     }

crates/tools/src/pathtype.rs

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

crates/tools/src/select.rs

@@ -4,7 +4,8 @@
 //! drag a live rectangle's corner widget to round its corners (Alt-click cycles their kind,
 //! double-click opens the Corners dialog), double-click to enter isolation mode (Double Click To
 //! Isolate), Cmd/Ctrl-click to select the object behind (Command Click to Select Objects Behind),
-//! click or drag a ruler guide ([`crate::rulerguide`]).
+//! click or drag a ruler guide ([`crate::rulerguide`]), drag the brackets of type on a path
+//! ([`crate::pathtype`]).
 //! The bounding box stands at the selection's own angle after a rotation, so its handles scale
 //! along the objects' axes. A handle drag resizes area type's frame (the type area) instead of
 //! scaling its type: the text reflows at its size.
@@ -17,6 +18,7 @@ use vectorcraft_geom::{Affine, Point, Rect, Vec2};
 use crate::bbox::{Handle, hit_handle, in_rotate_zone, move_delta, rotate_for_drag, scale_for_drag};
 use crate::corners::{self, CornerDrag, over_widget};
 use crate::guides::Targets;
+use crate::pathtype::{self, BracketDrag, over_bracket};
 use crate::rulerguide::GuideEdit;
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, json_ids};
 
@@ -49,6 +51,8 @@ enum State {
     },
     /// Dragging a Live Corners widget.
     Corner(CornerDrag),
+    /// Dragging a bracket of type on a path.
+    Bracket(BracketDrag),
 }
 
 #[derive(Default)]
@@ -181,11 +185,16 @@ impl Tool for SelectionTool {
                 vec![]
             }
             (PointerKind::Down, _) => {
-                // 1. Live Corners widgets, then the bounding-box handles of the current selection.
+                // 1. Live Corners widgets and type on a path's brackets, then the bounding-box
+                // handles of the current selection.
                 if let Some(c) = CornerDrag::hit(cx, ev) {
                     self.state = State::Corner(c);
                     return vec![];
                 }
+                if let Some(b) = BracketDrag::hit(cx, ev) {
+                    self.state = State::Bracket(b);
+                    return vec![];
+                }
                 if cx.show_bbox
                     && let Some(bx) = selection_box(cx)
                 {
@@ -296,6 +305,15 @@ impl Tool for SelectionTool {
                 self.state = State::Idle;
                 c.finish()
             }
+            (PointerKind::Drag, State::Bracket(mut b)) => {
+                let out = b.drag(cx, p, m.cmd);
+                self.state = State::Bracket(b);
+                out
+            }
+            (PointerKind::Up, State::Bracket(b)) => {
+                self.state = State::Idle;
+                b.finish()
+            }
             (PointerKind::Up, State::Moving { began, deselect, .. }) => {
                 self.state = State::Idle;
                 self.measure = None;
@@ -332,7 +350,7 @@ impl Tool for SelectionTool {
     }
 
     fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
-        let mut o = vec![];
+        let mut o = pathtype::overlays(cx);
         match &self.state {
             State::Marquee { start, cur, .. } => o.push(Overlay::Marquee(Rect::from_points(*start, *cur))),
             State::Corner(c) => o.extend(c.overlays(cx)),
@@ -352,6 +370,7 @@ impl Tool for SelectionTool {
             State::Scaling { handle, bx, .. } => return handle_cursor(handle, bx.angle),
             State::Moving { began: true, .. } => return Cursor::Arrow,
             State::Corner(_) => return Cursor::CornerRadius,
+            State::Bracket(_) => return Cursor::PathBracket,
             _ => {}
         }
         if self.guide.busy() {
@@ -360,6 +379,9 @@ impl Tool for SelectionTool {
         if over_widget(cx, p) {
             return Cursor::CornerRadius;
         }
+        if over_bracket(cx, p) {
+            return Cursor::PathBracket;
+        }
         if cx.show_bbox
             && let Some(bx) = selection_box(cx)
         {

crates/ui-egui/src/canvas.rs

@@ -401,7 +401,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
 fn cursor_icon(c: Cursor) -> egui::CursorIcon {
     use egui::CursorIcon as C;
     match c {
-        Cursor::Arrow | Cursor::ArrowHollow | Cursor::CornerRadius => C::Default,
+        Cursor::Arrow | Cursor::ArrowHollow | Cursor::CornerRadius | Cursor::PathBracket => C::Default,
         Cursor::Move => C::Move,
         Cursor::Crosshair => C::Crosshair,
         Cursor::ResizeH => C::ResizeHorizontal,
@@ -423,7 +423,7 @@ fn cursor_icon(c: Cursor) -> egui::CursorIcon {
         Cursor::SliceSelect => C::Default,
         Cursor::Width | Cursor::WidthAdd => C::Crosshair,
         Cursor::WidthPoint => C::Move,
-        Cursor::Blend | Cursor::BlendObject | Cursor::BlendAnchor => C::Crosshair,
+        Cursor::Blend | Cursor::BlendObject | Cursor::BlendAnchor | Cursor::ShapeBuilder | Cursor::ShapeBuilderErase => C::Crosshair,
     }
 }
 
@@ -438,6 +438,14 @@ fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect:
     app.hover_doc = hover.map(|p| xf.to_doc(p));
     let view = app.view_info();
     let drag: Option<Drag> = ui.data(|d| d.get_temp(drag_id()));
+    // A modifier pressed or released over the canvas re-hovers the tool, so what it changes shows
+    // without moving the mouse (Alt switches the Shape Builder to erase mode).
+    let mods_changed = ui.data_mut(|d| {
+        let id = egui::Id::new("canvas-mods");
+        let prev = d.get_temp::<egui::Modifiers>(id);
+        d.insert_temp(id, m);
+        prev.is_some_and(|prev| prev != m)
+    });
 
     // Zoom around the pointer, or scroll ([`wheel`]).
     if resp.hovered() {
@@ -576,7 +584,7 @@ fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect:
             }
         }
     } else if let Some(p) = hover
-        && pointer.is_moving()
+        && (pointer.is_moving() || mods_changed)
     {
         let ev = PointerEvent { kind: PointerKind::Move, pos: xf.to_doc(p), mods: mods(m, space), pressure: 1.0 };
         dispatch(app, &ev, view);
@@ -595,7 +603,7 @@ fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect:
             }
         }
     }
-    if drag.is_some() || pointer.is_moving() {
+    if drag.is_some() || pointer.is_moving() || mods_changed {
         ui.ctx().request_repaint();
     }
 }
@@ -972,10 +980,11 @@ fn node_outline(n: &Node) -> BezPath {
     let mut bp = BezPath::new();
     walk_drawn(n, &mut |c| match &c.kind {
         NodeKind::Path { path, .. } => bp.extend(path.to_bezpath()),
-        // Area type shows its frame: the type area Direct Selection reshapes.
-        NodeKind::Text(t) if c.perspective.is_none() && matches!(t.kind, vectorcraft_doc::TextKind::Area { .. }) => {
-            if let Some(frame) = t.area_frame() {
-                bp.extend(frame.to_bezpath());
+        // Area type shows its frame: the type area Direct Selection reshapes; type on a path its
+        // path, which the selection tools' brackets sit on.
+        NodeKind::Text(t) if c.perspective.is_none() && !matches!(t.kind, vectorcraft_doc::TextKind::Point) => {
+            if let Some(path) = t.area_frame().or_else(|| t.type_path()) {
+                bp.extend(path.to_bezpath());
             }
         }
         NodeKind::Text(_) | NodeKind::Image(_) | NodeKind::SymbolInstance { .. } => {
@@ -1344,9 +1353,10 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
         {
             anchor_square(p, xf.to_screen(b.center()), color, true, anchor(false));
         }
-        // Text: baseline marker (area type shows its frame instead, which may not be a rectangle).
+        // Point type: baseline marker (area type shows its frame instead, which may not be a
+        // rectangle, and type on a path its path).
         if let NodeKind::Text(tx) = &n.kind
-            && !matches!(tx.kind, vectorcraft_doc::TextKind::Area { .. })
+            && matches!(tx.kind, vectorcraft_doc::TextKind::Point)
         {
             let o = xf.to_screen(tx.xf * Point::ZERO);
             let b = n.geometric_bounds().unwrap_or_default();

crates/ui-egui/src/chrome.rs

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

crates/ui-egui/src/cursors.rs

@@ -111,6 +111,21 @@ fn corner_radius(p: &Painter, o: Pos2) {
     p.add(Shape::line(pts, Stroke::new(1.2, INK)));
 }
 
+/// Over a bracket of type on a path: the arrow with a bracket (a stem standing on a baseline,
+/// with a foot) below right.
+fn path_bracket(p: &Painter, o: Pos2) {
+    arrow(p, o, false);
+    let b = o + vec2(13.0, 13.0);
+    let stem = [b + vec2(3.0, 0.0), b + vec2(3.0, 10.0)];
+    let foot = [b + vec2(3.0, 0.0), b + vec2(7.0, 0.0)];
+    let base = [b + vec2(0.0, 8.0), b + vec2(10.0, 8.0)];
+    for (w, c) in [(3.0, HALO), (1.2, INK)] {
+        for l in [stem, foot, base] {
+            p.line_segment(l, Stroke::new(w, c));
+        }
+    }
+}
+
 /// The gradient annotator's stop cursors: the arrow with a plus (add a stop) or minus (delete it)
 /// badge.
 fn stop_badge(p: &Painter, o: Pos2, add: bool) {
@@ -186,6 +201,17 @@ fn blend(p: &Painter, o: Pos2, badge: Cursor) {
     poly(p, vec![b, b + vec2(7.0, 0.0), b + vec2(7.0, 7.0), b + vec2(0.0, 7.0)], fill, INK);
 }
 
+/// The Shape Builder: a crosshair with a plus badge below right of the hotspot (merge mode), or a
+/// minus (erase mode).
+fn shape_builder(p: &Painter, o: Pos2, erase: bool) {
+    crosshair(p, o);
+    let c = o + vec2(12.0, 12.0);
+    line(p, c - vec2(3.5, 0.0), c + vec2(3.5, 0.0));
+    if !erase {
+        line(p, c - vec2(0.0, 3.5), c + vec2(0.0, 3.5));
+    }
+}
+
 /// Paint cursor `c` at `p` on the given (foreground) painter. Returns false for cursors that should
 /// stay system cursors (hand, zoom, busy states).
 pub fn paint(painter: &Painter, c: Cursor, p: Pos2) -> bool {
@@ -221,6 +247,9 @@ pub fn paint(painter: &Painter, c: Cursor, p: Pos2) -> bool {
         Cursor::WidthAdd => width(painter, p, "+"),
         Cursor::WidthPoint => width(painter, p, "point"),
         Cursor::Blend | Cursor::BlendObject | Cursor::BlendAnchor => blend(painter, p, c),
+        Cursor::PathBracket => path_bracket(painter, p),
+        Cursor::ShapeBuilder => shape_builder(painter, p, false),
+        Cursor::ShapeBuilderErase => shape_builder(painter, p, true),
         _ => return false,
     }
     let _ = pos2;

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

@@ -13,7 +13,8 @@ pub(super) fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
         .collapsible(false)
         .resizable(false)
         .open(&mut open)
-        .anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
+        .pivot(egui::Align2::CENTER_CENTER)
+        .default_pos(ctx.content_rect().center())
         .frame(egui::Frame::window(&ctx.global_style()).inner_margin(egui::Margin::same(18)))
         .show(ctx, |ui| {
             // Tabs: About · Contributors · Models (the credits are compiled in, see `credits`).

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

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

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

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

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

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

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

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

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

@@ -103,6 +103,31 @@ fn toggle(ui: &mut egui::Ui, d: &mut Dialog, key: &str, text: &str, enabled: boo
     changed
 }
 
+/// The size of the colour chip before each name in the Color list.
+const CHIP: egui::Vec2 = egui::vec2(16.0, 10.0);
+
+/// The Color list: each preset's name after a chip of its colour, then Custom (no chip, its
+/// name aligned with the others). Returns the chosen row; Custom is `LAYER_COLORS.len()`.
+fn color_dropdown(ui: &mut egui::Ui, shown: &str) -> Option<usize> {
+    let border = crate::theme::Tokens::get(ui.ctx()).input_border;
+    let rows = LAYER_COLORS.iter().map(|(n, c)| (*n, Some(*c))).chain([("Custom", None)]);
+    widgets::combo(ui, "layer-color", tl!(shown), 140.0, false, |ui| {
+        let mut chosen = None;
+        for (i, (name, rgb)) in rows.enumerate() {
+            let chip = ui.id().with(("layer-color-chip", i));
+            let r = egui::Button::selectable(name == shown, (egui::Atom::custom(chip, CHIP), tl!(name))).atom_ui(ui);
+            if let (Some(rect), Some([cr, cg, cb])) = (r.rect(chip), rgb) {
+                ui.painter().rect_filled(rect, 1.0, egui::Color32::from_rgb(cr, cg, cb));
+                ui.painter().rect_stroke(rect, 1.0, egui::Stroke::new(1.0, border), egui::StrokeKind::Inside);
+            }
+            if r.response.clicked() {
+                chosen = Some(i);
+            }
+        }
+        chosen
+    })
+}
+
 fn body(_: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
     let layer = d.bool("layer");
     let many = d.fields.get("ids").and_then(Value::as_array).is_some_and(|a| a.len() > 1);
@@ -116,9 +141,8 @@ fn body(_: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
             label(ui, tl!("Color:"));
             ui.horizontal(|ui| {
                 let cur = d.str("color");
-                let names: Vec<&str> = LAYER_COLORS.iter().map(|(n, _)| *n).chain(["Custom"]).collect();
-                let shown = if LAYER_COLORS.iter().any(|(n, _)| n.eq_ignore_ascii_case(&cur)) { cur.clone() } else { "Custom".into() };
-                if let Some((n, _)) = widgets::dropdown(ui, "layer-color", &shown, &names, 140.0).and_then(|i| LAYER_COLORS.get(i)) {
+                let shown = LAYER_COLORS.iter().map(|(n, _)| *n).find(|n| n.eq_ignore_ascii_case(&cur)).unwrap_or("Custom");
+                if let Some((n, _)) = color_dropdown(ui, shown).and_then(|i| LAYER_COLORS.get(i)) {
                     d.fields.insert("color".into(), json!(n));
                 }
                 let [r, g, b] = LAYER_COLORS

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

crates/ui-egui/src/find_font.rs

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

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

@@ -10,6 +10,7 @@
 # language names, OpenType, the built-in workspace names and the bracketed perspective grid preset
 # names.
 	About VectorCraft	O aplikaci VectorCraft
+	Align to Path	Zarovnat k cestě
 	Join Our Discord	Připojit se k našemu Discordu
 	Settings…	Nastavení…
 	Language	Jazyk
@@ -603,3 +604,7 @@
 	Version	Verze
 	% of all commits	% všech commitů
 	Lines +/−	Řádky +/−
+	Drag to move	Přetažením přesunete
+	Drag to float as a toolbar	Přetažením vytvoříte plovoucí panel nástrojů
+	Put back in the toolbar	Vrátit do panelu nástrojů
+	Float Tool Group	Plovoucí skupina nástrojů

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

@@ -182,6 +182,7 @@
 	Artwork Colors	Colores de la ilustración
 	As Multiple Assets	Como varios recursos
 	As Single Asset	Como un solo recurso
+	Ascender	Ascendente
 	Ask When Modified	Preguntar al modificar
 	Aspect Ratio	Proporción
 	Asset Export	Exportación de recursos
@@ -212,6 +213,7 @@
 	Background:	Fondo:
 	Backspace	Retroceso
 	Bar Graph Tool	Herramienta Gráfico de barras
+	Baseline	Línea de base
 	Baseline Shift	Desplazamiento de línea de base
 	Basic Latin	Latín básico
 	Batch	Lote
@@ -283,6 +285,7 @@
 	Cap	Extremo
 	Cap:	Extremo:
 	Cascade	Cascada
+	Center	Centro
 	Center Artwork	Centrar ilustración
 	Center on Artboard	Centrar en la mesa de trabajo
 	Center-Justified Tab	Tabulación centrada
@@ -472,6 +475,8 @@
 	Corners	Esquinas
 	Chamfer	Chaflán
 	Corners…	Esquinas…
+	Descender	Descendente
+	Flip	Voltear
 	Inverted Round	Redondeada invertida
 	Radius:	Radio:
 	Round	Redondeada
@@ -924,6 +929,7 @@
 	Fit Headline	Ajustar titular
 	Decrease Font Size	Reducir tamaño de fuente
 	Increase Font Size	Aumentar tamaño de fuente
+	Spacing	Espaciado
 	Step Type	Ajustar texto por incrementos
 	Fit in View	Encajar en la vista
 	Fit in Window	Encajar en la ventana
@@ -2708,6 +2714,7 @@
 	Type becomes outlines, and strokes a CAD line can't draw become filled shapes.	El texto se convierte en contornos, y los trazos que una línea CAD no puede dibujar se convierten en formas rellenas.
 	Type Object Selection by Path Only	Selección de objetos de texto solo por trazado
 	Type on a Path	Texto en trazado
+	Type on a Path Options	Opciones de texto en trazado
 	Type on a Path Options…	Opciones de texto en trazado…
 	Type on a Path Tool	Herramienta Texto en trazado
 	Type Orientation	Orientación del texto
@@ -2880,6 +2887,7 @@
 	Zoom to Selection	Zoom a la selección
 	Zoom Tool	Herramienta Zoom
 	Zoom with Mouse Wheel	Zoom con la rueda del mouse
+	Scrub Numeric Fields by Dragging	Ajustar campos numéricos arrastrando
 	{count} file(s) in {folder}{note}. Show the package folder?	{count} archivo(s) en {folder}{note}. ¿Mostrar la carpeta del paquete?
 	{count} linked file(s) not found	No se encontraron {count} archivo(s) vinculado(s)
 	{count} linked image(s) changed since this document was saved. Show the new versions?	{count} imagen(es) vinculada(s) cambiaron desde que se guardó este documento. ¿Mostrar las versiones nuevas?
@@ -3013,3 +3021,15 @@
 	Version	Versión
 	% of all commits	% de todos los commits
 	Lines +/−	Líneas +/−
+	Joins	Uniones
+	Miter	Inglete
+	Bevel	Bisel
+	Offset	Desplazamiento
+	Axis	Eje
+axis	Horizontal	Horizontal
+axis	Vertical	Vertical
+axis	Both	Ambos
+	Drag to move	Arrastrar para mover
+	Drag to float as a toolbar	Arrastrar para flotar como barra de herramientas
+	Put back in the toolbar	Devolver a la barra de herramientas
+	Float Tool Group	Hacer flotar el grupo de herramientas

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

@@ -11,13 +11,18 @@
 	About VectorCraft	VectorCraft について
 	All Scripts	すべての文字
 	Any Kind	すべての種類
+	Ascender	アセンダ
+	Baseline	ベースライン
 	Bottom-to-Bottom Leading	欧文ベースライン基準の行送り
+	Center	中央
 	Character Alignment	文字揃え
 	Decorative	装飾
+	Descender	ディセンダ
 	Em Box Bottom/Left	仮想ボディの下 / 左
 	Em Box Center	仮想ボディの中央
 	Em Box Top/Right	仮想ボディの上 / 右
 	Favorites	お気に入り
+	Flip	反転
 	Japanese	日本語
 	Join Our Discord	Discord に参加
 	Line-end Punctuation Half Width	行末約物半角
@@ -31,7 +36,9 @@
 	Serif / Mincho	明朝・セリフ
 	Settings…	環境設定…
 	Language	表示言語
+	Spacing	間隔
 	Top-to-Top Leading	仮想ボディの上基準の行送り
+	Type on a Path Options	パス上文字オプション
 	UI Brightness	UI の明るさ
 	Dark	暗い
 	Medium Dark	やや暗い
@@ -2553,6 +2560,7 @@
 	Zoom Tool	ズームツール
 	Zoom to Selection	選択範囲にズーム
 	Zoom with Mouse Wheel	マウスホイールでズーム
+	Scrub Numeric Fields by Dragging	ドラッグで数値フィールドを調整
 	[Default] is protected: New… starts an editable copy.	[Default] は変更できません。「新規…」で編集できる複製を作ります。
 	[Unnamed]	[名称未設定]
 	above	(対象：次を超える画像)
@@ -3002,3 +3010,15 @@
 	Version	バージョン
 	% of all commits	全コミットに占める割合
 	Lines +/−	行数 +/−
+	Joins	角の形状
+	Miter	マイター
+	Bevel	ベベル
+	Offset	オフセット
+	Axis	軸
+axis	Horizontal	水平方向
+axis	Vertical	垂直方向
+axis	Both	両方
+	Drag to move	移動するにはドラッグ
+	Drag to float as a toolbar	ドラッグしてツールバーとして浮かせる
+	Put back in the toolbar	ツールバーに戻す
+	Float Tool Group	ツールグループをフローティング

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

@@ -2536,6 +2536,7 @@
 	Zoom Tool	Ferramenta Zoom
 	Zoom to Selection	Ampliar para a Seleção
 	Zoom with Mouse Wheel	Zoom com a Roda do Mouse
+	Scrub Numeric Fields by Dragging	Ajustar Campos Numéricos Arrastando
 	[Default] is protected: New… starts an editable copy.	[Padrão] é protegido: Novo… inicia uma cópia editável.
 	[Unnamed]	[Sem Nome]
 	above	acima
@@ -2620,3 +2621,7 @@
 	Version	Versão
 	% of all commits	% de todos os commits
 	Lines +/−	Linhas +/−
+	Drag to move	Arraste para mover
+	Drag to float as a toolbar	Arraste para flutuar como barra de ferramentas
+	Put back in the toolbar	Devolver à barra de ferramentas
+	Float Tool Group	Flutuar Grupo de Ferramentas

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

@@ -183,6 +183,7 @@
 	Artwork Colors	图稿颜色
 	As Multiple Assets	作为多个资源
 	As Single Asset	作为单一资源
+	Ascender	上缘
 	Ask When Modified	修改时询问
 	Aspect Ratio	长宽比
 	Asset Export	资源导出
@@ -214,6 +215,7 @@
 	Background:	背景：
 	Backspace	Backspace
 	Bar Graph Tool	条形图工具
+	Baseline	基线
 	Baseline Shift	基线偏移
 	Basic Latin	基本拉丁文
 	Batch	批处理
@@ -471,6 +473,8 @@
 	Corner Radius:	圆角半径：
 	Corner:	转角：
 	Corners	转角
+	Descender	下缘
+	Flip	翻转
 	Round	圆角
 	Inverted Round	反向圆角
 	Corners…	转角…
@@ -918,6 +922,7 @@
 	Fit Headline	适合标题
 	Decrease Font Size	减小字体大小
 	Increase Font Size	增大字体大小
+	Spacing	间距
 	Step Type	按增量调整文字
 	Fit in View	适合视图
 	Fit in Window	适合窗口
@@ -2647,6 +2652,7 @@
 	Type becomes outlines, and strokes a CAD line can't draw become filled shapes.	文字变为轮廓，CAD 无法绘制的描边变为填充形状。
 	Type Object Selection by Path Only	仅按路径选择文字对象
 	Type on a Path	路径文字
+	Type on a Path Options	路径文字选项
 	Type on a Path Options…	路径文字选项…
 	Type on a Path Tool	路径文字工具
 	Type Orientation	文字方向
@@ -2821,6 +2827,7 @@
 	Zoom to Selection	缩放到所选对象
 	Zoom Tool	缩放工具
 	Zoom with Mouse Wheel	使用鼠标滚轮缩放
+	Scrub Numeric Fields by Dragging	拖动以调整数值字段
 	{count} file(s) in {folder}{note}. Show the package folder?	{folder} 中有 {count} 个文件{note}。要显示打包文件夹吗？
 	{count} linked file(s) not found	找不到 {count} 个链接文件
 	{count} linked image(s) changed since this document was saved. Show the new versions?	自存储此文档后，有 {count} 个链接图像已更改。要显示新版本吗？
@@ -3260,3 +3267,15 @@
 	Version	版本
 	% of all commits	占全部提交的百分比
 	Lines +/−	行数 +/−
+	Joins	连接
+	Miter	斜接
+	Bevel	斜角
+	Offset	偏移
+	Axis	轴
+axis	Horizontal	水平
+axis	Vertical	垂直
+axis	Both	两者
+	Drag to move	拖动以移动
+	Drag to float as a toolbar	拖动使其浮动为工具栏
+	Put back in the toolbar	放回工具栏
+	Float Tool Group	浮动工具组

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

@@ -194,6 +194,7 @@
 	Artwork Colors	圖稿顏色
 	As Multiple Assets	作為多個資產
 	As Single Asset	作為單一資產
+	Ascender	上緣
 	Ask When Modified	修改時詢問
 	Aspect Ratio	長寬比
 	Asset Export	資產匯出
@@ -225,6 +226,7 @@
 	Background:	背景：
 	Backspace	Backspace
 	Bar Graph Tool	橫條圖工具
+	Baseline	基線
 	Baseline Shift	基線位移
 	Basic Latin	基本拉丁文
 	Batch	批次
@@ -297,6 +299,7 @@
 	Cap	端點
 	Cap:	端點：
 	Cascade	重疊顯示
+	Center	置中
 	Center Artwork	圖稿置中
 	Center on Artboard	在工作區域置中
 	Center-Justified Tab	置中對齊定位點
@@ -484,6 +487,8 @@
 	Corner Radius:	圓角半徑：
 	Corner:	轉角：
 	Corners	轉角
+	Descender	下緣
+	Flip	翻轉
 	Round	圓角
 	Radius:	半徑：
 	Inverted Round	反向圓角
@@ -940,6 +945,7 @@
 	Fit Headline	符合標題
 	Decrease Font Size	縮小字體大小
 	Increase Font Size	放大字體大小
+	Spacing	間距
 	Step Type	依增量調整文字
 	Fit in View	符合檢視
 	Fit in Window	符合視窗
@@ -2729,6 +2735,7 @@
 	Type becomes outlines, and strokes a CAD line can't draw become filled shapes.	文字會變成外框，CAD 線條無法繪製的筆畫會變成填色形狀。
 	Type Object Selection by Path Only	僅以路徑選取文字物件
 	Type on a Path	路徑文字
+	Type on a Path Options	路徑文字選項
 	Type on a Path Options…	路徑文字選項…
 	Type on a Path Tool	路徑文字工具
 	Type Orientation	文字方向
@@ -2904,6 +2911,7 @@
 	Zoom to Selection	縮放至選取範圍
 	Zoom Tool	縮放工具
 	Zoom with Mouse Wheel	使用滑鼠滾輪縮放
+	Scrub Numeric Fields by Dragging	拖曳以調整數值欄位
 	{count} file(s) in {folder}{note}. Show the package folder?	{folder} 中有 {count} 個檔案{note}。要顯示封裝資料夾嗎？
 	{count} linked file(s) not found	找不到 {count} 個連結檔案
 	{count} linked image(s) changed since this document was saved. Show the new versions?	自儲存此文件後，有 {count} 個連結影像已變更。要顯示新版本嗎？
@@ -3033,3 +3041,15 @@
 	Version	版本
 	% of all commits	佔全部提交的比例
 	Lines +/−	行數 +/−
+	Joins	轉角
+	Miter	尖角
+	Bevel	斜角
+	Offset	位移
+	Axis	軸
+axis	Horizontal	水平
+axis	Vertical	垂直
+axis	Both	兩者
+	Drag to move	拖曳以移動
+	Drag to float as a toolbar	拖曳使其浮動為工具列
+	Put back in the toolbar	放回工具列
+	Float Tool Group	浮動工具組

crates/ui-egui/src/lib.rs

@@ -38,6 +38,7 @@ pub mod prefs_dialog;
 pub mod print;
 pub mod recovery;
 pub mod render_worker;
+mod scrub;
 pub mod shortcut_editor;
 pub mod shortcuts;
 pub mod state;
@@ -85,6 +86,8 @@ mod tests_paintchips;
 #[cfg(test)]
 mod tests_pastechords;
 #[cfg(test)]
+mod tests_pathtype;
+#[cfg(test)]
 mod tests_pdfoutput;
 #[cfg(test)]
 mod tests_place;
@@ -107,6 +110,8 @@ mod tests_save;
 #[cfg(test)]
 mod tests_saveext;
 #[cfg(test)]
+mod tests_scrub;
+#[cfg(test)]
 mod tests_selectall;
 #[cfg(test)]
 mod tests_slices;
@@ -331,6 +336,9 @@ pub struct VectorcraftApp {
     pub(crate) ime_marked: Option<String>,
     /// The IME must drop its marked text (see [`Self::take_ime_discard`]).
     pub(crate) ime_discard: bool,
+    /// A numeric field is being scrubbed: the document's edits meanwhile are one undo step
+    /// ([`scrub::begin_frame`]).
+    scrub_group: bool,
 }
 
 /// Seconds between two looks at the system clipboard for [`VectorcraftApp::system_paste`].
@@ -394,6 +402,7 @@ impl VectorcraftApp {
             synthetic_modifiers: false,
             ime_marked: None,
             ime_discard: false,
+            scrub_group: false,
         }
     }
 
@@ -864,6 +873,7 @@ impl VectorcraftApp {
             return;
         }
         let t0 = now_ms();
+        scrub::begin_frame(self, &ctx);
         font_menu::end_stale_preview(self, &ctx);
         let t = theme::Tokens::get(&ctx);
         if self.ui.screen_mode < 2 {
@@ -896,6 +906,7 @@ impl VectorcraftApp {
             titlebar::resize_zones(ui);
         }
         self.ui_fonts.frame(&ctx);
+        scrub::end_frame(self, &ctx);
         self.perf.frame_ms = now_ms() - t0;
         let _ = json!(null);
     }

crates/ui-egui/src/menus.rs

@@ -199,6 +199,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
     ("window.toolbar", "Tools", "", "{}"),
     ("window.toolbarColumns", "Toolbar: Single/Double Column", "", "{}"),
     ("window.toolbarAdvanced", "Toolbar: Advanced / Basic", "", "{}"),
+    (
+        "window.floatTools",
+        "Float Tool Group",
+        "",
+        "{tool: id, floating?: bool} float the toolbar group holding `tool` (in the current Basic or Advanced layout) as its own strip of tool buttons (true), put it back in the toolbar (false) or toggle (omitted), as dragging or clicking a flyout's tear-off bar and the strip's × do; returns the new state",
+    ),
     ("window.taskBar", "Contextual Task Bar", "", "{}"),
     ("window.dock", "Panels", "Tab", "{} show/hide all panels"),
     ("window.panel", "Show Panel", "", "{panel: id} e.g. layers, swatches, stroke (case-insensitive; display labels like \"Layers\" work too)"),
@@ -980,6 +986,15 @@ pub fn run_ui_command(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<R
         "window.toolbar" => flag(&mut app.ui.toolbar),
         "window.toolbarColumns" => flag(&mut app.ui.toolbar_double),
         "window.toolbarAdvanced" => flag(&mut app.ui.toolbar_advanced),
+        "window.floatTools" => {
+            let floating = match p.get("floating") {
+                None | Some(Value::Null) => None,
+                Some(Value::Bool(b)) => Some(*b),
+                Some(_) => return Some(Err("floating must be true or false".into())),
+            };
+            let Some(tool) = s("tool") else { return Some(Err("tool (a tool id) is required".into())) };
+            crate::toolbar::float_group(app, &tool, floating).map(Value::Bool)
+        }
         "window.taskBar" => flag(&mut app.ui.task_bar),
         "window.dock" => {
             let on = !(app.ui.dock && app.ui.toolbar);
@@ -1302,6 +1317,10 @@ pub fn checked(app: &VectorcraftApp, id: &str, p: &Value) -> Option<bool> {
         "window.control" => app.ui.control_bar,
         "window.toolbar" => app.ui.toolbar,
         "window.toolbarAdvanced" => app.ui.toolbar_advanced,
+        "window.floatTools" => {
+            let tool = p.get("tool").and_then(Value::as_str).unwrap_or("");
+            app.ui.floating_flyouts.iter().any(|f| f.tools.iter().any(|id| id == tool))
+        }
         "window.taskBar" => app.ui.task_bar,
         "window.panel" => {
             let panel = p.get("panel").and_then(Value::as_str).unwrap_or("");
@@ -2075,15 +2094,11 @@ pub fn menu_tree() -> Vec<(&'static str, Vec<Item>)> {
                 c("Area Type Options…", "text.areaOptions"),
                 sub(
                     "Type on a Path",
-                    vec![
-                        cp("Rainbow", "type.pathOptions", json!({"effect": "rainbow"})),
-                        cp("Skew", "type.pathOptions", json!({"effect": "skew"})),
-                        cp("3D Ribbon", "type.pathOptions", json!({"effect": "3dRibbon"})),
-                        cp("Stair Step", "type.pathOptions", json!({"effect": "stairStep"})),
-                        cp("Gravity", "type.pathOptions", json!({"effect": "gravity"})),
-                        Sep,
-                        cp("Type on a Path Options…", "type.pathOptions", json!({"start": 0})),
-                    ],
+                    PATH_EFFECTS
+                        .iter()
+                        .map(|&(label, effect)| cp(label, "type.pathOptions", json!({ "effect": effect })))
+                        .chain([Sep, c("Type on a Path Options…", "type.pathOptions")])
+                        .collect(),
                 ),
                 sub(
                     "Threaded Text",
@@ -2658,6 +2673,17 @@ pub fn click_target(label: &str, id: &str, p: &Value) -> (String, Value) {
     (id.to_string(), if p.is_null() { json!({}) } else { p.clone() })
 }
 
+/// The dialog of command `id` that shows the selection's current values (its query): its heading
+/// and the queried values it doesn't show. Type on a Path Options leaves the brackets where they
+/// are.
+fn queried_dialog(id: &str) -> Option<(&'static str, &'static [&'static str])> {
+    Some(match id {
+        "text.areaOptions" => ("Area Type Options", &[]),
+        "type.pathOptions" => ("Type on a Path Options", &["start", "end"]),
+        _ => return None,
+    })
+}
+
 /// The dialog (kind, fields) the menu item of command `id` opens, as the reference app's does.
 fn menu_dialog(id: &str) -> Option<(&'static str, Value)> {
     Some(match id {
@@ -2728,11 +2754,17 @@ pub fn invoke(app: &mut VectorcraftApp, id: &str, p: Value) {
         let _ = app.run("ui.paramDialog", json!({"command": id, "label": "Repeat Options", "params": fields}));
         return;
     }
-    // Area Type Options: a dialog with the selected area type's current values.
-    if id == "text.areaOptions" && p.as_object().is_none_or(|o| o.is_empty()) {
+    // Area Type Options and Type on a Path Options: dialogs with the selected type's current
+    // values (the command's query), less those the dialog leaves alone.
+    if let Some((label, hidden)) = queried_dialog(id)
+        && p.as_object().is_none_or(|o| o.is_empty())
+    {
         match app.session.execute(id, &json!({})) {
-            Ok(fields) => {
-                let _ = app.run("ui.paramDialog", json!({"command": id, "label": "Area Type Options", "params": fields}));
+            Ok(mut fields) => {
+                if let Some(o) = fields.as_object_mut() {
+                    o.retain(|k, _| !hidden.contains(&k.as_str()));
+                }
+                let _ = app.run("ui.paramDialog", json!({"command": id, "label": label, "params": fields}));
             }
             Err(e) => app.status(e.to_string()),
         }
@@ -2937,6 +2969,11 @@ const TYPE_SIZES: [(&str, u32); 14] = [
     ("72 pt", 72),
 ];
 
+/// Type → Type on a Path effects (label, `type.pathOptions` effect), also the choices of its
+/// Options dialog.
+pub(crate) const PATH_EFFECTS: &[(&str, &str)] =
+    &[("Rainbow", "rainbow"), ("Skew", "skew"), ("3D Ribbon", "3dRibbon"), ("Stair Step", "stairStep"), ("Gravity", "gravity")];
+
 const INSERT_SPECIAL: &[(&str, &str)] = &[
     ("Bullet", "bullet"),
     ("Copyright Symbol", "copyright"),

crates/ui-egui/src/panels/appearance.rs

@@ -668,16 +668,13 @@ fn opacity_row(app: &mut VectorcraftApp, ui: &mut Ui, item: Option<usize>, opaci
     let lx = r.left() + EYE_W + 24.0 + if item.is_some() { 12.0 } else { 0.0 };
     let clicked = link(ui, pos2(lx, r.center().y), ("ap-op-link", item), tl!("Opacity:")) || resp.clicked();
     text(ui, pos2(lx + 56.0, r.center().y), &opacity_text(opacity, blend), false);
-    egui::Popup::menu(&resp)
-        .open_memory(clicked.then_some(egui::SetOpenCommand::Toggle))
-        .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
-        .show(|ui| match widgets::opacity_blend(ui, ("ap-op", item), Some(opacity), Some(blend), true) {
-            Some(TransparencyEdit::Blend(b)) => {
-                app.run("transparency.set", json!({"item": item, "blend": b.label()})).ok();
-            }
-            Some(TransparencyEdit::Opacity(o, phase)) => live_run(app, "Opacity", "transparency.set", json!({"item": item, "opacity": o}), phase),
-            None => {}
-        });
+    widgets::popover(&resp, clicked, |ui| match widgets::opacity_blend(ui, ("ap-op", item), Some(opacity), Some(blend), true) {
+        Some(TransparencyEdit::Blend(b)) => {
+            app.run("transparency.set", json!({"item": item, "blend": b.label()})).ok();
+        }
+        Some(TransparencyEdit::Opacity(o, phase)) => live_run(app, "Opacity", "transparency.set", json!({"item": item, "opacity": o}), phase),
+        None => {}
+    });
     r
 }
 

crates/ui-egui/src/panels/character.rs

@@ -227,7 +227,9 @@ pub(crate) fn route_type_input(app: &mut VectorcraftApp, ctx: &egui::Context) {
 fn cell(ui: &mut Ui, label: &str, tip: &str, add: impl FnOnce(&mut Ui)) {
     let t = Tokens::get(ui.ctx());
     ui.horizontal(|ui| {
-        ui.add_sized(vec2(22.0, 24.0), egui::Label::new(egui::RichText::new(label).size(11.5).strong().color(t.text))).on_hover_text(tl!(tip));
+        let l =
+            ui.add_sized(vec2(22.0, 24.0), egui::Label::new(egui::RichText::new(label).size(11.5).strong().color(t.text))).on_hover_text(tl!(tip));
+        crate::scrub::note_label(ui, l.rect);
         add(ui);
     });
 }

crates/ui-egui/src/panels/layers.rs

@@ -15,7 +15,8 @@
 //!   shows every layer when they are hidden (`layer.showAll`); Alt-click a lock does the same with
 //!   `layer.lockOthers` and `layer.unlockAll`.
 //! - Dragging rows moves them above, below or into a layer or group (`layer.move`, a drop line or
-//!   a box shows where); Alt copies them; dropped on the trash they are deleted.
+//!   a box shows where); Alt copies them. A dimmed copy of the row follows the pointer. Dropped on
+//!   the trash they are deleted, on New Layer duplicated.
 //! - The triangle opens or closes a row; Alt-click does the same to everything inside it.
 //! - Double-clicking a name renames it; double-clicking elsewhere on a row opens its options.
 //! - A target circle targets its layer, group or object (`layer.target`); dragging it onto another
@@ -109,6 +110,57 @@ fn rename_id() -> egui::Id {
     egui::Id::new("layers-rename")
 }
 
+/// Ghost rows are drawn at this opacity.
+const GHOST_OPACITY: f32 = 0.5;
+
+/// The colour of the layer holding `id`.
+fn layer_colour(doc: &Document, id: NodeId) -> Color32 {
+    let [r, g, b] = doc.layer_color(id);
+    Color32::from_rgb(r, g, b)
+}
+
+/// The layer colour bar of row `n` (rect `r`) at `x`: wider on layers.
+fn colour_bar(ui: &Ui, n: &Node, r: egui::Rect, x: f32, colour: Color32) {
+    let w = if n.is_layer() { 4.0 } else { 2.0 };
+    ui.painter().rect_filled(egui::Rect::from_min_size(egui::pos2(x - 1.0, r.top()), vec2(w, r.height())), 0.0, colour);
+}
+
+/// The thumbnail of row `n` (rect `r`) at `x`; returns where it went.
+fn row_thumb(ui: &Ui, view: &View, n: &Node, r: egui::Rect, x: f32) -> egui::Rect {
+    let s = (view.h - 4.0).min(40.0);
+    let th = egui::Rect::from_min_size(egui::pos2(x, r.center().y - s / 2.0), vec2(s, s));
+    ui.painter().rect_filled(th, 0.0, Color32::WHITE);
+    ui.painter().rect_stroke(th, 0.0, Stroke::new(1.0, view.t.border), StrokeKind::Outside);
+    if !real_thumb(ui, view.doc, n, th) {
+        thumb(ui, n, th);
+    }
+    th
+}
+
+/// The dragged row `src`, dimmed, following the pointer at `pos` above everything else: its
+/// colour bar, thumbnail and name.
+fn drag_ghost(ui: &Ui, view: &View, src: NodeId, pos: egui::Pos2) {
+    let (doc, t, h) = (view.doc, &view.t, view.h);
+    let Some(n) = doc.node(src) else { return };
+    let (grab, width, depth) = ui.data(|d| d.get_temp::<(egui::Vec2, f32, usize)>(key("grab"))).unwrap_or((vec2(h, h / 2.0), 240.0, 0));
+    // A plain Ui on the tooltip layer, not an Area: a new Area is invisible for a frame and fades in.
+    let r = egui::Rect::from_min_size(pos - grab, vec2(width, h));
+    let id = key("ghost");
+    let mut ui = Ui::new(ui.ctx().clone(), id, egui::UiBuilder::new().layer_id(egui::LayerId::new(egui::Order::Tooltip, id)).max_rect(r));
+    ui.set_opacity(GHOST_OPACITY);
+    let p = ui.painter();
+    p.rect_filled(r, 0.0, t.row_selected);
+    p.rect_stroke(r, 0.0, Stroke::new(1.0, t.accent), StrokeKind::Inside);
+    let mut x = r.left() + 2.0 * COLUMN + 2.0;
+    colour_bar(&ui, n, r, x, layer_colour(doc, src));
+    x += 22.0 + depth as f32 * INDENT;
+    if view.opts.thumb(n) {
+        x = row_thumb(&ui, view, n, r, x).right() + 4.0;
+    }
+    let name = painted_name(n, &n.display_name(), crate::i18n::current());
+    ui.painter().text(egui::pos2(x, r.center().y), egui::Align2::LEFT_CENTER, name, egui::FontId::proportional(13.0), t.text);
+}
+
 /// Where a dragged row goes relative to the row it is dropped on.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum Place {
@@ -268,6 +320,15 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
     if released {
         ui.data_mut(|d| d.remove::<u64>(egui::Id::new("layers-drag")));
     }
+    // Dragged rows show as a dimmed row under the pointer.
+    if !released
+        && let Some(drag) = egui::DragAndDrop::payload::<LayersDrag>(ui.ctx())
+        && let LayersDrag::Rows(ids) = &*drag
+        && let Some(src) = ids.first()
+        && let Some(pos) = ui.input(|i| i.pointer.latest_pos())
+    {
+        drag_ghost(ui, &view, *src, pos);
+    }
     // Keyboard: Delete removes the highlighted rows while the panel has the keyboard (a row was
     // clicked last, not the canvas).
     let pressed_outside = ui.input(|i| i.pointer.any_pressed() && i.pointer.interact_pos().is_some_and(|p| !list_rect.contains(p)));
@@ -304,15 +365,13 @@ fn bottom_bar(app: &mut VectorcraftApp, ui: &mut Ui, view: &View, doc: &Document
     let m = ui.input(|i| i.modifiers);
     let mut child = ui.new_child(egui::UiBuilder::new().max_rect(bar).layout(egui::Layout::right_to_left(egui::Align::Center)));
     let trash = widgets::icon_button(&mut child, "trash-2", tl!("Delete Selection"), false, 24.0);
-    // A target circle dropped on the trash clears that appearance; dragged rows are deleted.
-    if let Some(d) = trash.dnd_release_payload::<PanelDrag>()
+    // A target circle dropped on the trash clears that appearance (dragged rows: below). Peek at
+    // the payload's type before taking it: egui's take drops a payload of another type.
+    if trash.dnd_hover_payload::<PanelDrag>().is_some()
+        && let Some(d) = trash.dnd_release_payload::<PanelDrag>()
         && let PanelDrag::Appearance(id) = *d
     {
         actions.push(("appearance.clear".into(), json!({"ids": [id.0]})));
-    } else if let Some(d) = trash.dnd_release_payload::<LayersDrag>()
-        && let LayersDrag::Rows(ids) = &*d
-    {
-        actions.push(("layer.delete".into(), json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()})));
     } else if trash.clicked() {
         if view.rows.is_empty() && app.session.active().is_some_and(|d| !d.selection.is_empty()) {
             actions.push(("edit.clear".into(), json!({})));
@@ -321,13 +380,28 @@ fn bottom_bar(app: &mut VectorcraftApp, ui: &mut Ui, view: &View, doc: &Document
         }
     }
     // Create New Layer: Alt asks for its options first, Ctrl/Cmd puts it on top of every layer.
-    if widgets::icon_button(&mut child, "file-plus", tl!("Create New Layer"), false, 24.0).clicked() {
+    let new_layer = widgets::icon_button(&mut child, "file-plus", tl!("Create New Layer"), false, 24.0);
+    if new_layer.clicked() {
         if m.alt {
             actions.push(("ui.newLayer".into(), json!({})));
         } else {
             actions.push(("layer.new".into(), json!({"top": m.command})));
         }
     }
+    // Rows dropped on the trash are deleted, on New Layer duplicated, as in Illustrator. Both are
+    // outlined while rows (or, on the trash, a target circle) hang over them.
+    for (button, cmd) in [(&trash, "layer.delete"), (&new_layer, "layer.duplicate")] {
+        if let Some(d) = button.dnd_release_payload::<LayersDrag>()
+            && let LayersDrag::Rows(ids) = &*d
+        {
+            actions.push((cmd.into(), json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()})));
+        }
+        let over = button.dnd_hover_payload::<LayersDrag>().is_some_and(|d| matches!(*d, LayersDrag::Rows(_)))
+            || (cmd == "layer.delete" && button.dnd_hover_payload::<PanelDrag>().is_some_and(|d| matches!(*d, PanelDrag::Appearance(_))));
+        if over {
+            child.painter().rect_stroke(button.rect, 3.0, Stroke::new(1.5, t.accent), StrokeKind::Inside);
+        }
+    }
     if widgets::icon_button(&mut child, "plus", tl!("Create New Sublayer"), false, 24.0).clicked() {
         actions.push(if m.alt { ("ui.newLayer".into(), json!({"sublayer": true})) } else { ("layer.newSublayer".into(), json!({})) });
     }
@@ -396,10 +470,7 @@ fn row(ui: &mut Ui, view: &View, n: &Node, depth: usize, clip_path: bool, expand
             n.walk(&mut |c| any |= c.id != n.id && view.sel.contains(&c.id));
             any
         });
-    let color = {
-        let c = doc.layer_color(n.id);
-        Color32::from_rgb(c[0], c[1], c[2])
-    };
+    let color = layer_colour(doc, n.id);
     // Highlighted rows (else the current layer's).
     let highlighted = if view.rows.is_empty() { n.is_layer() && Some(n.id) == view.current } else { view.rows.contains(&n.id) };
     if highlighted {
@@ -416,7 +487,7 @@ fn row(ui: &mut Ui, view: &View, n: &Node, depth: usize, clip_path: bool, expand
     eye_and_lock(ui, view, n, r, out);
     // Layer colour bar (every row shows the colour of its layer).
     let mut x = r.left() + 2.0 * COLUMN + 2.0;
-    ui.painter().rect_filled(egui::Rect::from_min_size(egui::pos2(x - 1.0, r.top()), vec2(if n.is_layer() { 4.0 } else { 2.0 }, h)), 0.0, color);
+    colour_bar(ui, n, r, x, color);
     x += 6.0 + depth as f32 * INDENT;
     // Disclosure triangle; Alt opens or closes everything inside too.
     let searching = !view.query.is_empty();
@@ -440,14 +511,8 @@ fn row(ui: &mut Ui, view: &View, n: &Node, depth: usize, clip_path: bool, expand
     x += 16.0;
     // Thumbnail.
     let thumb_rect = view.opts.thumb(n).then(|| {
-        let s = (h - 4.0).min(40.0);
-        let th = egui::Rect::from_min_size(egui::pos2(x, r.center().y - s / 2.0), vec2(s, s));
-        ui.painter().rect_filled(th, 0.0, Color32::WHITE);
-        ui.painter().rect_stroke(th, 0.0, Stroke::new(1.0, t.border), StrokeKind::Outside);
-        if !real_thumb(ui, doc, n, th) {
-            thumb(ui, n, th);
-        }
-        x += s + 4.0;
+        let th = row_thumb(ui, view, n, r, x);
+        x = th.right() + 4.0;
         th
     });
     // Name.
@@ -533,6 +598,8 @@ fn row(ui: &mut Ui, view: &View, n: &Node, depth: usize, clip_path: bool, expand
     if resp.drag_started() && view.column.is_none() {
         let ids = if view.rows.contains(&n.id) { view.rows.clone() } else { vec![n.id] };
         egui::DragAndDrop::set_payload(ui.ctx(), LayersDrag::Rows(ids));
+        let grab = resp.interact_pointer_pos().map_or(vec2(h, h / 2.0), |p| p - r.min);
+        ui.data_mut(|d| d.insert_temp(key("grab"), (grab, r.width(), depth)));
     }
     if resp.dragged() {
         ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing);
@@ -1116,23 +1183,34 @@ mod tests {
         // Dropped on the trash, the layer's appearance is cleared (and nothing is deleted).
         let st = app.session.active().unwrap();
         let count = st.doc.node_count();
-        let trash = {
-            let mut out = ctx.run_ui(egui::RawInput::default(), |ui| show(&mut app, ui));
-            out.textures_delta.clear();
-            // The bottom bar's rightmost button, under the right end of its top divider.
-            let divider = Tokens::get(&ctx).divider;
-            let corner = out.shapes.iter().rev().find_map(|c| match &c.shape {
-                egui::Shape::LineSegment { points, stroke } if stroke.color == divider => Some(points[1]),
-                _ => None,
-            });
-            corner.unwrap() + vec2(-12.0, 15.0)
-        };
+        let trash = trash_pos(&mut app, &ctx);
         drag(&mut app, &ctx, c[0], trash, false);
         let st = app.session.active().unwrap();
         assert_eq!(st.doc.node(layer).unwrap().opacity, 1.0);
         assert_eq!(st.doc.node_count(), count);
     }
 
+    /// The trash button: the bottom bar's rightmost button.
+    fn trash_pos(app: &mut VectorcraftApp, ctx: &egui::Context) -> egui::Pos2 {
+        bar_buttons(app, ctx)[0]
+    }
+
+    #[test]
+    fn dragging_rows_onto_the_trash_deletes_them() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
+        app.session.execute("layer.new", &json!({})).unwrap();
+        let ctx = egui::Context::default();
+        // Rows top first: Layer 2, Layer 1. Grab Layer 2 by its name, left of its target circle.
+        let (c, _) = frame(&mut app, &ctx, vec![], false);
+        let top = app.session.active().unwrap().doc.layers[1].id;
+        let trash = trash_pos(&mut app, &ctx);
+        drag(&mut app, &ctx, c[0] - vec2(100.0, 0.0), trash, false);
+        let doc = &app.session.active().unwrap().doc;
+        assert_eq!(doc.layers.len(), 1);
+        assert!(doc.node(top).is_none());
+    }
+
     #[test]
     fn renaming_a_layer_commits_on_enter_and_escape_cancels() {
         let mut app = VectorcraftApp::new(Session::new(), Default::default());
@@ -1396,6 +1474,70 @@ mod tests {
         let _ = (layer, c);
     }
 
+    /// The centres of the bottom bar's buttons, right to left from under the right end of its top
+    /// divider: Delete, New Layer, New Sublayer, Make/Release Clipping Mask, Locate Object.
+    fn bar_buttons(app: &mut VectorcraftApp, ctx: &egui::Context) -> Vec<egui::Pos2> {
+        let mut out = ctx.run_ui(egui::RawInput::default(), |ui| show(app, ui));
+        out.textures_delta.clear();
+        let divider = Tokens::get(ctx).divider;
+        let corner = out
+            .shapes
+            .iter()
+            .rev()
+            .find_map(|c| match &c.shape {
+                egui::Shape::LineSegment { points, stroke } if stroke.color == divider => Some(points[1]),
+                _ => None,
+            })
+            .unwrap();
+        let step = 24.0 + ctx.global_style().spacing.item_spacing.x;
+        (0..5).map(|k| corner + vec2(-12.0 - k as f32 * step, 15.0)).collect()
+    }
+
+    /// How many texts reading `s` the frame after `events` paints.
+    fn texts(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>, s: &str) -> usize {
+        let mut out = ctx.run_ui(egui::RawInput { events, ..Default::default() }, |ui| show(app, ui));
+        out.textures_delta.clear();
+        out.shapes.iter().filter(|c| matches!(&c.shape, egui::Shape::Text(t) if t.galley.text() == s)).count()
+    }
+
+    /// Drag the row at `a` to `b` and drop it there. Returns how many times its `name` was painted
+    /// while it hung over `b`.
+    fn drag_row(app: &mut VectorcraftApp, ctx: &egui::Context, a: egui::Pos2, b: egui::Pos2, name: &str) -> usize {
+        frame(app, ctx, vec![egui::Event::PointerMoved(a)], false);
+        frame(app, ctx, vec![button(a, true)], false);
+        frame(app, ctx, vec![egui::Event::PointerMoved(a + vec2(0.0, 6.0))], false);
+        let shown = texts(app, ctx, vec![egui::Event::PointerMoved(b)], name);
+        frame(app, ctx, vec![button(b, false)], false);
+        frame(app, ctx, vec![], false);
+        shown
+    }
+
+    #[test]
+    fn dropping_rows_on_new_layer_duplicates_them() {
+        let (mut app, first, _) = two_rects();
+        let second = app.session.execute("layer.new", &json!({"name": "Top"})).unwrap()["id"].as_u64().map(NodeId).unwrap();
+        let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx);
+        let layers = |app: &VectorcraftApp| app.session.active().unwrap().doc.layers.iter().map(|l| l.id).collect::<Vec<_>>();
+        // Rows top down: Top, Layer 1 (expanded: its two rectangles).
+        let (c, _) = frame(&mut app, &ctx, vec![], false);
+        let buttons = bar_buttons(&mut app, &ctx);
+        // Layer 1 dropped on New Layer: a copy of it right above it.
+        let shown = drag_row(&mut app, &ctx, egui::pos2(150.0, c[1].y), buttons[1], "Layer 1");
+        assert_eq!(shown, 2, "the row and its ghost under the pointer");
+        let after = layers(&app);
+        assert_eq!(after.len(), 3);
+        assert_eq!((after[0], after[2]), (first, second));
+        assert_eq!(app.session.active().unwrap().doc.node(after[1]).unwrap().children().map(Vec::len), Some(2));
+        assert_eq!(texts(&mut app, &ctx, vec![], "Layer 1"), 1, "the ghost is gone after the drop");
+        // One undo step takes the copy away.
+        app.session.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(layers(&app), vec![first, second]);
+        // The other bottom-bar buttons are no drop targets.
+        drag_row(&mut app, &ctx, egui::pos2(150.0, c[0].y), buttons[2], "Top");
+        assert_eq!(layers(&app), vec![first, second]);
+    }
+
     #[test]
     fn the_selected_art_square_drags_the_selection_to_another_layer() {
         let (mut app, [_, sub, g, _, a, c]) = nested();

crates/ui-egui/src/panels/paragraph.rs

@@ -89,7 +89,8 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
     // Indents and paragraph spacing are distances (General); type sizes follow Units ▸ Type.
     let unit = app.session.general_unit();
     let label = |ui: &mut Ui, s: &str, tip: &str| {
-        ui.add_sized(vec2(22.0, 24.0), egui::Label::new(egui::RichText::new(s).size(11.5).strong().color(t.text))).on_hover_text(tip);
+        let l = ui.add_sized(vec2(22.0, 24.0), egui::Label::new(egui::RichText::new(s).size(11.5).strong().color(t.text))).on_hover_text(tip);
+        crate::scrub::note_label(ui, l.rect);
     };
     egui::Grid::new("para-grid").num_columns(4).spacing([4.0, 4.0]).show(ui, |ui| {
         label(ui, "→|", tl!("Left Indent"));

crates/ui-egui/src/panels/properties.rs

@@ -299,7 +299,8 @@ pub fn transform_section(app: &mut VectorcraftApp, ui: &mut Ui) {
         super::transform::constrain_link(app, ui);
     });
     ui.horizontal(|ui| {
-        icons::icon(ui, "rotate-ccw", 16.0, Tokens::get(ui.ctx()).icon);
+        let icon = icons::icon(ui, "rotate-ccw", 16.0, Tokens::get(ui.ctx()).icon);
+        crate::scrub::note_label(ui, icon.rect);
         // The bounding box's angle: a new value turns the selection to it.
         if let Some(a) = widgets::plain_field(ui, "rot", bx.angle, "°", 2, 70.0) {
             app.run("object.rotate", json!({"angle": a, "absolute": true})).ok();
@@ -345,7 +346,7 @@ fn appearance_section(app: &mut VectorcraftApp, ui: &mut Ui) {
     for (label, is_fill) in [(tl!("Fill"), true), (tl!("Stroke"), false)] {
         ui.horizontal(|ui| {
             super::paint_chip(app, ui, !is_fill, 22.0, false);
-            ui.label(egui::RichText::new(label).size(12.0));
+            widgets::field_label(ui, egui::RichText::new(label).size(12.0));
             if !is_fill {
                 ui.add_space(8.0);
                 if let Some(w) = widgets::num_field(ui, "ap-w", weight, app.session.stroke_unit(), 70.0) {
@@ -357,7 +358,7 @@ fn appearance_section(app: &mut VectorcraftApp, ui: &mut Ui) {
         });
     }
     ui.horizontal(|ui| {
-        ui.label(egui::RichText::new(tl!("Opacity")).size(12.0));
+        widgets::field_label(ui, egui::RichText::new(tl!("Opacity")).size(12.0));
         ui.add_space(8.0);
         if let Some(o) = widgets::plain_field(ui, "ap-op", n.opacity as f64 * 100.0, "%", 0, 64.0) {
             app.run("object.setProps", json!({"opacity": o.clamp(0.0, 100.0)})).ok();

crates/ui-egui/src/panels/stroke.rs

@@ -4,7 +4,7 @@
 use egui::{Color32, Rect, Sense, Stroke, StrokeKind, Ui, pos2, vec2};
 use serde_json::{Value, json};
 use vectorcraft_color::{Color, Paint};
-use vectorcraft_doc::{Appearance, ArrowAlign, Arrowhead, Dash, Document, LineCap, LineJoin, Node, StrokeAlign, StrokeLayer, WidthProfile};
+use vectorcraft_doc::{Appearance, ArrowAlign, Arrowhead, Dash, Document, LineCap, LineJoin, Node, StrokeAlign, StrokeLayer, Unit, WidthProfile};
 use vectorcraft_engine::inspect::StrokeMixed;
 
 use super::{character, current_stroke, pstate, set_pstate, stroke_mixed};
@@ -12,8 +12,34 @@ use crate::theme::Tokens;
 use crate::widgets::{self, menu_item};
 use crate::{VectorcraftApp, icons};
 
-pub const WEIGHT_PRESETS: [f64; 22] =
+/// Stroke weight dropdown presets in points, from the ladder of `unit` (Units > Stroke): each
+/// unit has its own ladder of round values in that unit, so the dropdown reads `0.25 mm`, not the
+/// `0.088 mm` a converted pt ladder gives. Feet, yards and meters, which no stroke is measured
+/// in, keep the pt ladder.
+pub fn weight_presets(unit: Unit) -> [f64; 22] {
+    let native = match unit {
+        Unit::Millimeters => MM_PRESETS,
+        Unit::Centimeters => CM_PRESETS,
+        Unit::Inches => IN_PRESETS,
+        Unit::Pixels => PX_PRESETS,
+        Unit::Picas => return PC_PRESETS,
+        Unit::Points | Unit::FeetInches | Unit::Feet | Unit::Meters | Unit::Yards => return PT_PRESETS,
+    };
+    native.map(|v| unit.to_pt(v))
+}
+
+const PT_PRESETS: [f64; 22] =
     [0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0];
+const MM_PRESETS: [f64; 22] = [0.1, 0.25, 0.35, 0.5, 0.75, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 15.0, 20.0, 25.0, 30.0];
+const CM_PRESETS: [f64; 22] = [0.01, 0.02, 0.03, 0.05, 0.06, 0.07, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0];
+const IN_PRESETS: [f64; 22] =
+    [0.0078, 0.0156, 0.0313, 0.0625, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0, 1.25, 1.5, 1.75, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0];
+const PX_PRESETS: [f64; 22] =
+    [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 30.0, 40.0];
+/// The pica ladder (0p1 … 5p) in points, so every entry is an exact pt weight. The dropdown shows
+/// them as decimal picas (`0.083 p`) until [`Unit::number`] writes `0p1` notation.
+const PC_PRESETS: [f64; 22] =
+    [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 15.0, 18.0, 21.0, 24.0, 27.0, 30.0, 33.0, 36.0, 48.0, 60.0];
 
 /// A profile's points as its silhouette: none (the plain bar) for the uniform stroke.
 fn silhouette(points: &[(f64, f64, f64)]) -> Option<&[(f64, f64, f64)]> {
@@ -87,7 +113,8 @@ pub(crate) fn shown_weight(app: &VectorcraftApp, st: Option<&StrokeLayer>, mixed
 
 /// The weight spinner (Stroke panel, Control bar): Units > Stroke, presets, blank when mixed.
 pub(crate) fn weight_field(app: &mut VectorcraftApp, ui: &mut Ui, id: &str, weight: Option<f64>, width: f32) {
-    if let Some(w) = widgets::spin_field(ui, id, weight, app.session.stroke_unit(), width, 1.0, 0.0, &WEIGHT_PRESETS) {
+    let unit = app.session.stroke_unit();
+    if let Some(w) = widgets::spin_field(ui, id, weight, unit, width, 1.0, 0.0, &weight_presets(unit)) {
         set(app, json!({"weight": w}));
     }
 }
@@ -95,7 +122,7 @@ pub(crate) fn weight_field(app: &mut VectorcraftApp, ui: &mut Ui, id: &str, weig
 /// The Stroke panel in a popover anchored to `resp` (the Control bar's and the Properties
 /// panel's Stroke links), which a click on it toggles.
 pub(crate) fn popover(app: &mut VectorcraftApp, resp: &egui::Response) {
-    egui::Popup::menu(resp).close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside).show(|ui| {
+    widgets::popover(resp, resp.clicked(), |ui| {
         ui.set_width(260.0);
         show(app, ui);
     });
@@ -110,7 +137,8 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
     let hidden: bool = pstate(ui.ctx(), "stroke-hide-options");
     let label_w = 64.0;
     let row_label = |ui: &mut Ui, s: &str| {
-        ui.add_sized(vec2(label_w, 24.0), egui::Label::new(egui::RichText::new(s).size(12.5).color(t.text)).halign(egui::Align::RIGHT));
+        let l = ui.add_sized(vec2(label_w, 24.0), egui::Label::new(egui::RichText::new(s).size(12.5).color(t.text)).halign(egui::Align::RIGHT));
+        crate::scrub::note_label(ui, l.rect);
     };
     ui.horizontal(|ui| {
         row_label(ui, tl!("Weight:"));

crates/ui-egui/src/panels/tests_appearance.rs

@@ -168,6 +168,29 @@ fn item_opacity_popup_sets_the_items_opacity() {
     assert_eq!((n.appearance.items[0].opacity(), n.opacity), (1.0, 1.0));
 }
 
+#[test]
+fn opacity_popup_blend_dropdown_sets_the_blend_mode() {
+    let mut app = app_with_rect();
+    let ctx = egui::Context::default();
+    let texts = frame_events(&ctx, &mut app, vec![], appearance::show);
+    // The object's own Opacity row (the last one).
+    let link = texts.iter().rev().find(|(t, _)| t == "Opacity:").expect("object opacity row").1;
+    click(&ctx, &mut app, link.center(), appearance::show);
+    let texts = frame_events(&ctx, &mut app, vec![], appearance::show);
+    // Opening the dropdown inside the popup keeps the popup open: the list shows.
+    click(&ctx, &mut app, text_rect(&texts, "Normal").center(), appearance::show);
+    let texts = frame_events(&ctx, &mut app, vec![], appearance::show);
+    click(&ctx, &mut app, text_rect(&texts, "Multiply").center(), appearance::show);
+    assert_eq!(first_selected(&app).unwrap().blend, vectorcraft_color::BlendMode::Multiply);
+    // The popup is still open after choosing.
+    let texts = frame_events(&ctx, &mut app, vec![], appearance::show);
+    assert!(texts.iter().any(|(t, _)| t == "Multiply"), "{texts:?}");
+    // A frame without the panel closes it, as egui closes the popups it remembers.
+    frame_events(&ctx, &mut app, vec![], |_, _| {});
+    let texts = frame_events(&ctx, &mut app, vec![], appearance::show);
+    assert!(!texts.iter().any(|(t, _)| t == "Multiply"), "{texts:?}");
+}
+
 #[test]
 fn object_row_names_the_selection_like_the_control_bar() {
     let mut app = app_with_rect();

crates/ui-egui/src/panels/tests_strokeux.rs

@@ -32,10 +32,10 @@ fn weights_and_dashes_show_in_the_stroke_unit_everywhere() {
     app.session.prefs.units_stroke = "millimeters".into();
     run(&mut app, "stroke.set", json!({"dash": [12, 6]}));
     let mm = vectorcraft_doc::Unit::Millimeters.format(1.0);
-    assert_eq!(mm, "0.353 mm");
+    assert_eq!(mm, "0.3528 mm");
     let t = texts(&ctx, &mut app, stroke::show);
     assert!(shows(&t, &mm), "Stroke panel: {t:?}");
-    assert!(shows(&t, "4.233") && shows(&t, "2.117"), "dash and gap in mm: {t:?}");
+    assert!(shows(&t, "4.2333") && shows(&t, "2.1167"), "dash and gap in mm: {t:?}");
     assert!(shows(&texts(&ctx, &mut app, properties::show), &mm), "Properties panel");
     assert!(shows(&texts(&ctx, &mut app, crate::chrome::control_bar), &mm), "Control bar");
 }
@@ -75,7 +75,8 @@ fn inside_and_outside_are_off_for_open_paths_and_type() {
 
 #[test]
 fn the_weight_presets_run_from_a_quarter_point_to_a_hundred() {
-    assert!(stroke::WEIGHT_PRESETS.contains(&0.25) && stroke::WEIGHT_PRESETS.contains(&100.0));
+    let pt = stroke::weight_presets(vectorcraft_doc::Unit::Points);
+    assert!(pt.contains(&0.25) && pt.contains(&100.0));
     let ctx = egui::Context::default();
     let mut app = app_with_rect();
     // The chevron at the right end of the 120 px weight spinner opens them.
@@ -86,3 +87,28 @@ fn the_weight_presets_run_from_a_quarter_point_to_a_hundred() {
     let t = texts(&ctx, &mut app, stroke::show);
     assert!(shows(&t, "0.25 pt") && shows(&t, "100 pt"), "{t:?}");
 }
+
+#[test]
+fn weight_presets_display_cleanly_in_their_native_unit() {
+    use vectorcraft_doc::Unit;
+    // Round-tripping a native-unit value through to_pt → from_pt → number() must give the same
+    // string the ladder was authored with: no "0.353 mm" surprises in the dropdown.
+    for (unit, want) in [
+        (Unit::Millimeters, ["0.1", "0.25", "0.35", "0.5", "0.75", "1", "30"].as_slice()),
+        (Unit::Centimeters, ["0.01", "0.05", "0.1", "0.5", "1", "5"].as_slice()),
+        (Unit::Pixels, ["1", "10", "20", "40"].as_slice()),
+        (Unit::Inches, ["0.0078", "0.0313", "0.375", "1", "5"].as_slice()),
+        (Unit::Points, ["0.25", "0.5", "1", "50", "100"].as_slice()),
+    ] {
+        let presets = stroke::weight_presets(unit);
+        let shown: Vec<String> = presets.iter().map(|pt| unit.number(*pt)).collect();
+        for w in want {
+            assert!(shown.iter().any(|s| s == w), "{unit:?} preset {w:?} missing from {shown:?}");
+        }
+    }
+    // Picas are exact pt weights (0p1 = 1 pt, 1p = 12 pt, 5p = 60 pt).
+    let pc = stroke::weight_presets(Unit::Picas);
+    assert!([1.0, 12.0, 60.0].iter().all(|w| pc.contains(w)), "{pc:?}");
+    // Units no stroke is measured in keep the pt ladder, in points.
+    assert_eq!(stroke::weight_presets(Unit::Meters), stroke::weight_presets(Unit::Points));
+}

crates/ui-egui/src/panels/tests_units.rs

@@ -37,7 +37,7 @@ fn general_mm(app: &mut VectorcraftApp) {
 #[test]
 fn panels_show_millimetres_after_the_preference_changes() {
     let mut app = app_with_rect();
-    assert_eq!(side_mm(), "35.278 mm");
+    assert_eq!(side_mm(), "35.2778 mm");
     assert!(shows(&texts(&mut app, transform::show), "100 pt"), "points first");
     general_mm(&mut app);
     // The next frame: no restart, nothing cached.

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

@@ -139,7 +139,8 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
     let origin = rp.map(|p| json!([p.x, p.y]));
     ui.horizontal(|ui| {
         ui.add_enabled_ui(has, |ui| {
-            icons::icon(ui, "rotate-ccw", 16.0, t.icon).on_hover_text(tl!("Rotate"));
+            let icon = icons::icon(ui, "rotate-ccw", 16.0, t.icon).on_hover_text(tl!("Rotate"));
+            crate::scrub::note_label(ui, icon.rect);
             // The bounding box's angle: a new value turns the selection to it.
             let angle = bx.map_or(0.0, |b| b.angle);
             if let Some(a) = widgets::spin_plain(ui, "xfp-rot", angle, "°", 2, 96.0, 15.0, -360.0, &ANGLE_PRESETS)
@@ -148,7 +149,8 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
                 app.run("object.rotate", json!({"angle": a, "absolute": true, "origin": origin})).ok();
             }
             ui.add_space(4.0);
-            icons::icon(ui, "dc-shear", 16.0, t.icon).on_hover_text(tl!("Shear"));
+            let icon = icons::icon(ui, "dc-shear", 16.0, t.icon).on_hover_text(tl!("Shear"));
+            crate::scrub::note_label(ui, icon.rect);
             if let Some(a) = widgets::plain_field(ui, "xfp-shear", 0.0, "°", 1, 56.0)
                 && a != 0.0
             {

crates/ui-egui/src/prefs_dialog.rs

@@ -78,6 +78,7 @@ struct Applied {
     white_canvas: bool,
     threads: i32,
     tool_tips: bool,
+    scrub: bool,
 }
 
 /// Per frame: push UI-side preferences into egui / the renderer when they change.
@@ -88,8 +89,13 @@ 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, tool_tips: p.show_tool_tips };
+    let want = Applied {
+        brightness: app.ui.brightness,
+        white_canvas: p.canvas_color == "white",
+        threads: p.render_threads,
+        tool_tips: p.show_tool_tips,
+        scrub: p.scrub_numeric_fields,
+    };
     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) {
@@ -98,6 +104,7 @@ pub fn apply_runtime(app: &mut VectorcraftApp, ctx: &egui::Context) {
         // 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);
+        crate::scrub::set_enabled(ctx, want.scrub);
         if want.white_canvas {
             let mut t = Tokens::get(ctx);
             t.pasteboard = egui::Color32::WHITE;
@@ -122,81 +129,67 @@ 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 (mut ok, mut cancel, mut reset) = (false, false, false);
-    egui::Area::new(egui::Id::new("modal-dim")).order(egui::Order::Middle).fixed_pos(egui::pos2(0.0, 0.0)).show(ctx, |ui| {
-        ui.allocate_rect(ctx.content_rect(), egui::Sense::click());
-    });
     let cat = d.str("__category");
     let cat = PREF_CATEGORIES.iter().find(|c| **c == cat).copied().unwrap_or(PREF_CATEGORIES[0]);
-    egui::Window::new(tl!("Preferences"))
-        .id(egui::Id::new("dialog-preferences"))
-        .order(egui::Order::Foreground)
-        .collapsible(false)
-        .resizable(false)
-        .title_bar(false)
-        .anchor(egui::Align2::CENTER_CENTER, [0.0, -20.0])
-        .frame(egui::Frame::window(&ctx.global_style()).fill(t.panel).inner_margin(egui::Margin::same(20)))
-        .show(ctx, |ui| {
-            ui.set_width(760.0);
-            ui.label(egui::RichText::new(tl!("Preferences")).font(theme::semibold(16.0)).color(t.text));
-            ui.add_space(12.0);
-            ui.horizontal_top(|ui| {
-                // Category list.
-                egui::Frame::NONE.fill(t.panel_darker).corner_radius(egui::CornerRadius::same(4)).inner_margin(egui::Margin::same(6)).show(
-                    ui,
-                    |ui| {
-                        ui.set_width(196.0);
-                        ui.set_min_height(430.0);
-                        ui.vertical(|ui| {
-                            ui.spacing_mut().item_spacing.y = 1.0;
-                            for c in PREF_CATEGORIES {
-                                let sel = *c == cat;
-                                let text = egui::RichText::new(tl!(*c)).size(12.5).color(if sel { t.text_strong } else { t.text });
-                                let b = egui::Button::selectable(sel, text).frame_when_inactive(false).min_size(egui::vec2(184.0, 24.0));
-                                if ui.add(b).clicked() {
-                                    d.fields.insert("__category".into(), json!(c));
-                                }
-                            }
-                        });
-                    },
-                );
-                ui.add_space(14.0);
-                // Fields.
+    crate::dialogs::modal::show(ctx, tl!("Preferences"), egui::Id::new("dialog-preferences"), -20.0, 20, |ui| {
+        ui.set_width(760.0);
+        crate::dialogs::modal::heading(ui, tl!("Preferences"));
+        ui.add_space(12.0);
+        ui.horizontal_top(|ui| {
+            // Category list.
+            egui::Frame::NONE.fill(t.panel_darker).corner_radius(egui::CornerRadius::same(4)).inner_margin(egui::Margin::same(6)).show(ui, |ui| {
+                ui.set_width(196.0);
+                ui.set_min_height(430.0);
                 ui.vertical(|ui| {
-                    ui.set_width(530.0);
-                    ui.label(egui::RichText::new(tl!(cat)).font(theme::semibold(14.0)).color(t.text_strong));
-                    ui.add_space(8.0);
-                    egui::ScrollArea::vertical().id_salt(("prefs", cat)).max_height(400.0).auto_shrink([false, false]).show(ui, |ui| {
-                        category_fields(ui, &mut d, cat);
-                    });
+                    ui.spacing_mut().item_spacing.y = 1.0;
+                    for c in PREF_CATEGORIES {
+                        let sel = *c == cat;
+                        let text = egui::RichText::new(tl!(*c)).size(12.5).color(if sel { t.text_strong } else { t.text });
+                        let b = egui::Button::selectable(sel, text).frame_when_inactive(false).min_size(egui::vec2(184.0, 24.0));
+                        if ui.add(b).clicked() {
+                            d.fields.insert("__category".into(), json!(c));
+                        }
+                    }
                 });
             });
             ui.add_space(14.0);
-            ui.horizontal(|ui| {
-                if widgets::secondary_button(ui, tl!("Reset Preferences"))
-                    .on_hover_text(tl!("Restore every preference to its default (applied on OK)"))
-                    .clicked()
-                {
-                    reset = true;
-                }
-                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                    if widgets::primary_button(ui, tl!("OK")).clicked() {
-                        ok = true;
-                    }
-                    ui.add_space(8.0);
-                    if widgets::secondary_button(ui, tl!("Cancel")).clicked() {
-                        cancel = true;
-                    }
-                    ui.add_space(16.0);
-                    let i = PREF_CATEGORIES.iter().position(|c| *c == cat).unwrap_or(0);
-                    if ui.add_enabled(i + 1 < PREF_CATEGORIES.len(), egui::Button::new(tl!("Next"))).clicked() {
-                        d.fields.insert("__category".into(), json!(PREF_CATEGORIES[i + 1]));
-                    }
-                    if ui.add_enabled(i > 0, egui::Button::new(tl!("Previous"))).clicked() {
-                        d.fields.insert("__category".into(), json!(PREF_CATEGORIES[i - 1]));
-                    }
+            // Fields.
+            ui.vertical(|ui| {
+                ui.set_width(530.0);
+                ui.label(egui::RichText::new(tl!(cat)).font(theme::semibold(14.0)).color(t.text_strong));
+                ui.add_space(8.0);
+                egui::ScrollArea::vertical().id_salt(("prefs", cat)).max_height(400.0).auto_shrink([false, false]).show(ui, |ui| {
+                    category_fields(ui, &mut d, cat);
                 });
             });
         });
+        ui.add_space(14.0);
+        ui.horizontal(|ui| {
+            if widgets::secondary_button(ui, tl!("Reset Preferences"))
+                .on_hover_text(tl!("Restore every preference to its default (applied on OK)"))
+                .clicked()
+            {
+                reset = true;
+            }
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                if widgets::primary_button(ui, tl!("OK")).clicked() {
+                    ok = true;
+                }
+                ui.add_space(8.0);
+                if widgets::secondary_button(ui, tl!("Cancel")).clicked() {
+                    cancel = true;
+                }
+                ui.add_space(16.0);
+                let i = PREF_CATEGORIES.iter().position(|c| *c == cat).unwrap_or(0);
+                if ui.add_enabled(i + 1 < PREF_CATEGORIES.len(), egui::Button::new(tl!("Next"))).clicked() {
+                    d.fields.insert("__category".into(), json!(PREF_CATEGORIES[i + 1]));
+                }
+                if ui.add_enabled(i > 0, egui::Button::new(tl!("Previous"))).clicked() {
+                    d.fields.insert("__category".into(), json!(PREF_CATEGORIES[i - 1]));
+                }
+            });
+        });
+    });
     if reset {
         for (k, v) in Prefs::default().to_json().as_object().cloned().unwrap_or_default() {
             d.fields.insert(k, v);

crates/ui-egui/src/scrub.rs

@@ -0,0 +1,205 @@
+//! Scrubbing numeric fields (#400, beyond Illustrator; Photoshop's scrubby labels): a horizontal
+//! drag on a numeric field's label (`W:`, `Opacity:`, the Character panel's size icon) steps the
+//! field's value by one unit every [`PX_PER_STEP`] points, ten with Shift and a tenth with
+//! Ctrl/Cmd, as the arrow keys step a focused field; a click on the label focuses the field. The
+//! text box itself never scrubs, and a field without a label doesn't.
+//!
+//! The panels apply each value the drag passes as they apply a typed one, so the art follows the
+//! drag live; the app holds an undo group open meanwhile ([`begin_frame`], [`end_frame`]), so the
+//! drag is one undo step and Escape takes it back. Preferences › General › Scrub Numeric Fields by
+//! Dragging turns it off.
+
+use egui::{Context, CursorIcon, Id, Key, Rect, Response, Sense, Ui};
+
+use crate::VectorcraftApp;
+
+/// Points of horizontal drag per step.
+pub const PX_PER_STEP: f32 = 2.0;
+/// The widest gap between a label and the field it names.
+const LABEL_GAP: f32 = 64.0;
+
+/// Where the scrub in progress is kept (egui memory).
+fn state_id() -> Id {
+    Id::new("numeric-field-scrub")
+}
+
+/// Where the last label drawn waits for its field.
+fn label_id() -> Id {
+    Id::new("numeric-field-label")
+}
+
+fn enabled_id() -> Id {
+    Id::new("numeric-field-scrub-enabled")
+}
+
+/// Turn scrubbing on or off (General › Scrub Numeric Fields by Dragging; on until set).
+pub(crate) fn set_enabled(ctx: &Context, on: bool) {
+    ctx.data_mut(|d| d.insert_temp(enabled_id(), on));
+}
+
+fn enabled(ctx: &Context) -> bool {
+    ctx.data(|d| d.get_temp(enabled_id())).unwrap_or(true)
+}
+
+/// The scrub in progress.
+#[derive(Clone, Copy, Debug)]
+struct Scrub {
+    /// The zone dragged: a field or its label.
+    zone: Id,
+    /// The field's value when the drag started (in its units), which Escape puts back.
+    start: f64,
+    /// Drag not applied yet, in the field's units.
+    pending: f64,
+    /// The step `pending` counts in (it changes with Shift and Ctrl/Cmd).
+    step: f64,
+    /// A value was applied.
+    moved: bool,
+    /// Escape ended the drag.
+    cancelled: bool,
+}
+
+/// Where the scrub of a numeric field stands this frame.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Phase {
+    Idle,
+    Dragging,
+    /// Released this frame.
+    Released,
+    /// Escape ended it this frame.
+    Cancelled,
+}
+
+pub(crate) fn phase(ctx: &Context) -> Phase {
+    let Some(s) = ctx.data(|d| d.get_temp::<Scrub>(state_id())) else { return Phase::Idle };
+    if ctx.drag_stopped_id() == Some(s.zone) {
+        if s.cancelled { Phase::Cancelled } else { Phase::Released }
+    } else if ctx.is_being_dragged(s.zone) {
+        Phase::Dragging
+    } else {
+        Phase::Idle
+    }
+}
+
+/// Before the panels draw: while a field is scrubbed, the edits its values make are one undo step.
+/// (The drag's first frame applies nothing, so the group is open before its first value.)
+pub(crate) fn begin_frame(app: &mut VectorcraftApp, ctx: &Context) {
+    if !app.scrub_group && matches!(phase(ctx), Phase::Dragging | Phase::Released) {
+        app.session.begin_undo_group();
+        app.scrub_group = true;
+    }
+}
+
+/// After the panels: a finished drag closes its undo group; Escape undoes it.
+pub(crate) fn end_frame(app: &mut VectorcraftApp, ctx: &Context) {
+    let phase = phase(ctx);
+    if !app.scrub_group || phase == Phase::Dragging {
+        return;
+    }
+    app.scrub_group = false;
+    app.session.end_undo_group(phase == Phase::Cancelled);
+    app.sync_views();
+}
+
+/// A field's label drawn this pass, waiting for the field after it.
+#[derive(Clone, Copy, Debug)]
+struct Label {
+    rect: Rect,
+    pass: u64,
+}
+
+/// Note the label (text or icon) drawn at `rect`: a numeric field drawn right after it on the
+/// same line takes it as its label, which scrubs the field.
+pub(crate) fn note_label(ui: &Ui, rect: Rect) {
+    let pass = ui.ctx().cumulative_pass_nr();
+    ui.data_mut(|d| d.insert_temp(label_id(), Label { rect, pass }));
+}
+
+/// The label noted just before the field at `field`, on its line.
+fn take_label(ui: &Ui, field: Rect) -> Option<Rect> {
+    let l = ui.data_mut(|d| {
+        let l = d.get_temp::<Label>(label_id());
+        d.remove::<Label>(label_id());
+        l
+    })?;
+    let gap = field.left() - l.rect.right();
+    (l.pass == ui.ctx().cumulative_pass_nr() && (-1.0..=LABEL_GAP).contains(&gap) && field.y_range().contains(l.rect.center().y)).then_some(l.rect)
+}
+
+/// Scrub numeric field `field`, its box at `rect`, showing `text`: `value` in its units, rounded
+/// to `decimals` places. → The value a drag on the field's label steps it to, or the value it
+/// started at when Escape cancels the drag. A click on the label (or a press held without
+/// stepping) focuses the field with all of `text` selected. Nothing for a field without a label,
+/// disabled or showing no value (objects that differ).
+pub(crate) fn field(ui: &Ui, field: Id, rect: Rect, text: &str, value: Option<f64>, decimals: i32) -> Option<f64> {
+    let label = take_label(ui, rect)?;
+    let value = value.filter(|v| v.is_finite())?;
+    if !enabled(ui.ctx()) || !ui.is_enabled() {
+        return None;
+    }
+    // On top of the label, which may sense clicks itself (selectable text).
+    let resp = ui.interact(label, field.with("scrub-label"), Sense::click_and_drag());
+    drag(ui, &resp, field, text, value, decimals)
+}
+
+/// What a drag on `resp`, the label of field `field`, does this frame.
+fn drag(ui: &Ui, resp: &Response, field: Id, text: &str, value: f64, decimals: i32) -> Option<f64> {
+    if resp.hovered() || resp.dragged() {
+        ui.ctx().set_cursor_icon(CursorIcon::ResizeHorizontal);
+    }
+    if resp.clicked() {
+        crate::widgets::focus_field(ui, field, text);
+        return None;
+    }
+    if resp.drag_started() {
+        // Typing elsewhere ends, as a click elsewhere ends it.
+        ui.memory_mut(|m| m.stop_text_input());
+        let s = Scrub { zone: resp.id, start: value, pending: 0.0, step: 0.0, moved: false, cancelled: false };
+        ui.data_mut(|d| d.insert_temp(state_id(), s));
+    }
+    if !(resp.dragged() || resp.drag_stopped()) {
+        return None;
+    }
+    let mut s = ui.data(|d| d.get_temp::<Scrub>(state_id())).filter(|s| s.zone == resp.id && !s.cancelled)?;
+    // egui ends the drag on Escape: the field goes back to where it started.
+    let out = if ui.input_mut(|i| i.consume_key(i.modifiers, Key::Escape)) {
+        s.cancelled = true;
+        s.moved.then_some(s.start)
+    } else if resp.drag_stopped() {
+        // Held without stepping: a slow click.
+        if !s.moved {
+            crate::widgets::focus_field(ui, field, text);
+        }
+        None
+    } else {
+        step(ui, resp, &mut s, value, decimals)
+    };
+    ui.data_mut(|d| d.insert_temp(state_id(), s));
+    out
+}
+
+/// The value this frame's drag steps `value` to, if it makes a whole step.
+fn step(ui: &Ui, resp: &Response, s: &mut Scrub, value: f64, decimals: i32) -> Option<f64> {
+    let mods = ui.input(|i| i.modifiers);
+    let size = if mods.command {
+        0.1
+    } else if mods.shift {
+        10.0
+    } else {
+        1.0
+    };
+    // A count steps by whole numbers: Ctrl/Cmd makes it slower instead.
+    let step = f64::max(size, 10f64.powi(-decimals));
+    if step != s.step {
+        (s.step, s.pending) = (step, 0.0);
+    }
+    s.pending += f64::from(resp.drag_delta().x / PX_PER_STEP) * size;
+    // (Nudged off the float error of summed tenths.)
+    let n = (s.pending / step + s.pending.signum() * 1e-9).trunc();
+    // The drag's first frame only starts it: the app opens its undo group on the next.
+    if n == 0.0 || resp.drag_started() {
+        return None;
+    }
+    s.pending -= n * step;
+    s.moved = true;
+    Some(crate::widgets::round_to(value + n * step, decimals))
+}

crates/ui-egui/src/shortcut_editor.rs

@@ -521,178 +521,167 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
             }
         }
     }
-    egui::Area::new(egui::Id::new("modal-dim")).order(egui::Order::Middle).fixed_pos(egui::pos2(0.0, 0.0)).show(ctx, |ui| {
-        ui.allocate_rect(ctx.content_rect(), egui::Sense::click());
-    });
-    egui::Window::new(tl!("Keyboard Shortcuts"))
-        .id(egui::Id::new("dialog-shortcuts"))
-        .order(egui::Order::Foreground)
-        .collapsible(false)
-        .resizable(false)
-        .title_bar(false)
-        .anchor(egui::Align2::CENTER_CENTER, [0.0, -20.0])
-        .frame(egui::Frame::window(&ctx.global_style()).fill(t.panel).inner_margin(egui::Margin::same(20)))
-        .show(ctx, |ui| {
-            ui.set_width(640.0);
-            ui.label(egui::RichText::new(tl!("Keyboard Shortcuts")).font(theme::semibold(16.0)).color(t.text));
-            ui.add_space(10.0);
-            // Set row.
-            ui.horizontal(|ui| {
-                ui.label(egui::RichText::new(tl!("Set:")).color(t.text_dim));
-                let cur = d.str("set");
-                let mut opts: Vec<&str> = PRESETS.to_vec();
-                if !PRESETS.contains(&cur.as_str()) {
-                    opts.push(CUSTOM);
-                }
-                // The sets listed are ours (translated); a set read from an imported file shows
-                // its name as it is.
-                if let Some(&name) = crate::dialogs::mixed_dropdown(ui, "kbset", &cur, &opts, 200.0, |_| true).and_then(|i| opts.get(i))
-                    && let Some(p) = preset(name)
-                {
-                    ov = p;
-                    d.fields.insert("set".into(), json!(name));
-                    d.fields.insert("__message".into(), json!(""));
-                }
-                ui.add_space(12.0);
-                if ui.button(tl!("Import…")).clicked() {
-                    d.fields.insert("__import".into(), json!(true));
-                }
-                if ui.button(tl!("Export…")).clicked() {
-                    d.fields.insert("__export".into(), json!(true));
-                }
-                if ui.button(tl!("Reset to Defaults")).clicked() {
-                    ov.clear();
-                    d.fields.insert("set".into(), json!(PRESETS[0]));
-                    d.fields.insert("__message".into(), json!(tl!("All shortcuts reset to defaults.")));
-                }
-            });
-            ui.add_space(8.0);
-            // Tabs + search.
-            ui.horizontal(|ui| {
-                let tab = d.str("tab");
-                for (id, label) in [("tools", "Tools"), ("menu", "Menu Commands")] {
-                    if ui.selectable_label(tab == id, egui::RichText::new(tl!(label)).font(theme::semibold(12.5))).clicked() {
-                        d.fields.insert("tab".into(), json!(id));
-                    }
-                }
-                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                    let mut q = d.str("query");
-                    if ui.add(egui::TextEdit::singleline(&mut q).hint_text(tl!("Search")).desired_width(200.0)).changed() {
-                        d.fields.insert("query".into(), json!(q));
-                    }
-                });
-            });
-            ui.add_space(6.0);
-            let tools = d.str("tab") != "menu";
-            let q = d.str("query").to_lowercase();
-            let selected = d.str("__selected");
-            let rec = d.str("__recording");
-            let scroll_to = d.fields.remove("__scrollTo").and_then(|v| v.as_str().map(str::to_string));
-            egui::Frame::NONE.fill(t.input).stroke(egui::Stroke::new(1.0, t.input_border)).inner_margin(egui::Margin::same(4)).show(ui, |ui| {
-                ui.horizontal(|ui| {
-                    ui.allocate_ui_with_layout(egui::vec2(360.0, 16.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
-                        ui.set_min_width(360.0);
-                        ui.label(egui::RichText::new(if tools { tl!("Tool") } else { tl!("Command") }).color(t.text_dim).size(11.0));
-                    });
-                    ui.label(egui::RichText::new(tl!("Shortcut")).color(t.text_dim).size(11.0));
-                });
-                egui::ScrollArea::vertical().max_height(360.0).auto_shrink([false, false]).show(ui, |ui| {
-                    for e in entries().iter().filter(|e| e.is_tool == tools) {
-                        let sc = effective_in(&ov, &e.key);
-                        let matches = e.label.to_lowercase().contains(&q)
-                            || tl!(&e.label).to_lowercase().contains(&q)
-                            || e.group.to_lowercase().contains(&q)
-                            || tl!(&e.group).to_lowercase().contains(&q)
-                            || sc.as_deref().is_some_and(|s| s.to_lowercase().contains(&q));
-                        if !q.is_empty() && !matches {
-                            continue;
-                        }
-                        let row = ui.horizontal(|ui| {
-                            let name = if e.is_tool || e.group.is_empty() {
-                                tl!(&e.label).to_string()
-                            } else {
-                                format!("{} › {}", tl!(&e.group), tl!(&e.label))
-                            };
-                            let r = ui
-                                .allocate_ui_with_layout(egui::vec2(360.0, 20.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
-                                    ui.set_min_width(360.0);
-                                    ui.add(egui::Button::selectable(selected == e.key, egui::RichText::new(name).color(t.text)).truncate())
-                                })
-                                .inner;
-                            if r.clicked() {
-                                d.fields.insert("__selected".into(), json!(e.key));
-                            }
-                            let label = if rec == e.key {
-                                tl!("Press keys…").to_string()
-                            } else {
-                                sc.as_deref().map(menus::pretty_shortcut).unwrap_or_else(|| "—".into())
-                            };
-                            let changed = ov.contains_key(&e.key);
-                            let txt = egui::RichText::new(label).color(if changed { t.accent } else { t.text });
-                            let b = ui
-                                .add_sized([150.0, 20.0], egui::Button::new(txt).selected(rec == e.key))
-                                .on_hover_text(tl!("Click, then press the new shortcut (Esc cancels)"));
-                            if b.clicked() {
-                                d.fields.insert("__recording".into(), json!(e.key));
-                                d.fields.insert("__selected".into(), json!(e.key));
-                            }
-                        });
-                        if scroll_to.as_deref() == Some(e.key.as_str()) {
-                            row.response.scroll_to_me(Some(egui::Align::Center));
-                        }
-                    }
-                });
-            });
-            ui.add_space(6.0);
-            // Selected-row actions + message.
-            ui.horizontal(|ui| {
-                let sel = d.str("__selected");
-                ui.add_enabled_ui(!sel.is_empty(), |ui| {
-                    if ui.button(tl!("Clear")).on_hover_text(tl!("Remove the shortcut")).clicked() {
-                        let _ = assign(&mut ov, &sel, None, true);
-                        d.fields.insert("set".into(), json!(CUSTOM));
-                    }
-                    if ui.button(tl!("Use Default")).clicked() {
-                        reset_one(&mut ov, &sel);
-                    }
-                });
-                let conflict = d.str("__conflict");
-                if !conflict.is_empty() && ui.button(tl!("Go to Conflict")).clicked() {
-                    let tab = if conflict.starts_with("tool:") { "tools" } else { "menu" };
-                    d.fields.insert("tab".into(), json!(tab));
-                    d.fields.insert("query".into(), json!(""));
-                    d.fields.insert("__selected".into(), json!(conflict));
-                    d.fields.insert("__scrollTo".into(), json!(conflict));
-                    d.fields.insert("__conflict".into(), json!(""));
-                }
-            });
-            let msg = d.str("__message");
-            if !msg.is_empty() {
-                ui.label(egui::RichText::new(msg).color(t.accent_strong).size(11.5));
+    crate::dialogs::modal::show(ctx, tl!("Keyboard Shortcuts"), egui::Id::new("dialog-shortcuts"), -20.0, 20, |ui| {
+        ui.set_width(640.0);
+        crate::dialogs::modal::heading(ui, tl!("Keyboard Shortcuts"));
+        ui.add_space(10.0);
+        // Set row.
+        ui.horizontal(|ui| {
+            ui.label(egui::RichText::new(tl!("Set:")).color(t.text_dim));
+            let cur = d.str("set");
+            let mut opts: Vec<&str> = PRESETS.to_vec();
+            if !PRESETS.contains(&cur.as_str()) {
+                opts.push(CUSTOM);
             }
-            let n = all_conflicts(&ov).len();
-            if n > 0 {
-                ui.label(
-                    egui::RichText::new(crate::i18n::tn(
-                        n as u64,
-                        "{n} shortcut is assigned more than once",
-                        "{n} shortcuts are assigned more than once",
-                    ))
-                    .color(t.text_dim)
-                    .size(11.0),
-                );
+            // The sets listed are ours (translated); a set read from an imported file shows
+            // its name as it is.
+            if let Some(&name) = crate::dialogs::mixed_dropdown(ui, "kbset", &cur, &opts, 200.0, |_| true).and_then(|i| opts.get(i))
+                && let Some(p) = preset(name)
+            {
+                ov = p;
+                d.fields.insert("set".into(), json!(name));
+                d.fields.insert("__message".into(), json!(""));
             }
             ui.add_space(12.0);
-            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                if widgets::primary_button(ui, tl!("OK")).clicked() {
-                    ok = true;
+            if ui.button(tl!("Import…")).clicked() {
+                d.fields.insert("__import".into(), json!(true));
+            }
+            if ui.button(tl!("Export…")).clicked() {
+                d.fields.insert("__export".into(), json!(true));
+            }
+            if ui.button(tl!("Reset to Defaults")).clicked() {
+                ov.clear();
+                d.fields.insert("set".into(), json!(PRESETS[0]));
+                d.fields.insert("__message".into(), json!(tl!("All shortcuts reset to defaults.")));
+            }
+        });
+        ui.add_space(8.0);
+        // Tabs + search.
+        ui.horizontal(|ui| {
+            let tab = d.str("tab");
+            for (id, label) in [("tools", "Tools"), ("menu", "Menu Commands")] {
+                if ui.selectable_label(tab == id, egui::RichText::new(tl!(label)).font(theme::semibold(12.5))).clicked() {
+                    d.fields.insert("tab".into(), json!(id));
                 }
-                ui.add_space(8.0);
-                if widgets::secondary_button(ui, tl!("Cancel")).clicked() {
-                    cancel = true;
+            }
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                let mut q = d.str("query");
+                if ui.add(egui::TextEdit::singleline(&mut q).hint_text(tl!("Search")).desired_width(200.0)).changed() {
+                    d.fields.insert("query".into(), json!(q));
                 }
             });
         });
+        ui.add_space(6.0);
+        let tools = d.str("tab") != "menu";
+        let q = d.str("query").to_lowercase();
+        let selected = d.str("__selected");
+        let rec = d.str("__recording");
+        let scroll_to = d.fields.remove("__scrollTo").and_then(|v| v.as_str().map(str::to_string));
+        egui::Frame::NONE.fill(t.input).stroke(egui::Stroke::new(1.0, t.input_border)).inner_margin(egui::Margin::same(4)).show(ui, |ui| {
+            ui.horizontal(|ui| {
+                ui.allocate_ui_with_layout(egui::vec2(360.0, 16.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
+                    ui.set_min_width(360.0);
+                    ui.label(egui::RichText::new(if tools { tl!("Tool") } else { tl!("Command") }).color(t.text_dim).size(11.0));
+                });
+                ui.label(egui::RichText::new(tl!("Shortcut")).color(t.text_dim).size(11.0));
+            });
+            egui::ScrollArea::vertical().max_height(360.0).auto_shrink([false, false]).show(ui, |ui| {
+                for e in entries().iter().filter(|e| e.is_tool == tools) {
+                    let sc = effective_in(&ov, &e.key);
+                    let matches = e.label.to_lowercase().contains(&q)
+                        || tl!(&e.label).to_lowercase().contains(&q)
+                        || e.group.to_lowercase().contains(&q)
+                        || tl!(&e.group).to_lowercase().contains(&q)
+                        || sc.as_deref().is_some_and(|s| s.to_lowercase().contains(&q));
+                    if !q.is_empty() && !matches {
+                        continue;
+                    }
+                    let row = ui.horizontal(|ui| {
+                        let name = if e.is_tool || e.group.is_empty() {
+                            tl!(&e.label).to_string()
+                        } else {
+                            format!("{} › {}", tl!(&e.group), tl!(&e.label))
+                        };
+                        let r = ui
+                            .allocate_ui_with_layout(egui::vec2(360.0, 20.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
+                                ui.set_min_width(360.0);
+                                ui.add(egui::Button::selectable(selected == e.key, egui::RichText::new(name).color(t.text)).truncate())
+                            })
+                            .inner;
+                        if r.clicked() {
+                            d.fields.insert("__selected".into(), json!(e.key));
+                        }
+                        let label = if rec == e.key {
+                            tl!("Press keys…").to_string()
+                        } else {
+                            sc.as_deref().map(menus::pretty_shortcut).unwrap_or_else(|| "—".into())
+                        };
+                        let changed = ov.contains_key(&e.key);
+                        let txt = egui::RichText::new(label).color(if changed { t.accent } else { t.text });
+                        let b = ui
+                            .add_sized([150.0, 20.0], egui::Button::new(txt).selected(rec == e.key))
+                            .on_hover_text(tl!("Click, then press the new shortcut (Esc cancels)"));
+                        if b.clicked() {
+                            d.fields.insert("__recording".into(), json!(e.key));
+                            d.fields.insert("__selected".into(), json!(e.key));
+                        }
+                    });
+                    if scroll_to.as_deref() == Some(e.key.as_str()) {
+                        row.response.scroll_to_me(Some(egui::Align::Center));
+                    }
+                }
+            });
+        });
+        ui.add_space(6.0);
+        // Selected-row actions + message.
+        ui.horizontal(|ui| {
+            let sel = d.str("__selected");
+            ui.add_enabled_ui(!sel.is_empty(), |ui| {
+                if ui.button(tl!("Clear")).on_hover_text(tl!("Remove the shortcut")).clicked() {
+                    let _ = assign(&mut ov, &sel, None, true);
+                    d.fields.insert("set".into(), json!(CUSTOM));
+                }
+                if ui.button(tl!("Use Default")).clicked() {
+                    reset_one(&mut ov, &sel);
+                }
+            });
+            let conflict = d.str("__conflict");
+            if !conflict.is_empty() && ui.button(tl!("Go to Conflict")).clicked() {
+                let tab = if conflict.starts_with("tool:") { "tools" } else { "menu" };
+                d.fields.insert("tab".into(), json!(tab));
+                d.fields.insert("query".into(), json!(""));
+                d.fields.insert("__selected".into(), json!(conflict));
+                d.fields.insert("__scrollTo".into(), json!(conflict));
+                d.fields.insert("__conflict".into(), json!(""));
+            }
+        });
+        let msg = d.str("__message");
+        if !msg.is_empty() {
+            ui.label(egui::RichText::new(msg).color(t.accent_strong).size(11.5));
+        }
+        let n = all_conflicts(&ov).len();
+        if n > 0 {
+            ui.label(
+                egui::RichText::new(crate::i18n::tn(
+                    n as u64,
+                    "{n} shortcut is assigned more than once",
+                    "{n} shortcuts are assigned more than once",
+                ))
+                .color(t.text_dim)
+                .size(11.0),
+            );
+        }
+        ui.add_space(12.0);
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if widgets::primary_button(ui, tl!("OK")).clicked() {
+                ok = true;
+            }
+            ui.add_space(8.0);
+            if widgets::secondary_button(ui, tl!("Cancel")).clicked() {
+                cancel = true;
+            }
+        });
+    });
     d.fields.insert("overrides".into(), serde_json::to_value(&ov).unwrap_or(json!({})));
     let import = d.fields.remove("__import").is_some();
     let export = d.fields.remove("__export").is_some();

crates/ui-egui/src/shortcuts.rs

@@ -190,6 +190,10 @@ fn type_text(app: &mut VectorcraftApp, ctx: &egui::Context) {
 pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
     // Followed before anything returns, so a key typed in a field isn't taken for a paste.
     let textless_paste = ctx.input(|i| app.paste_chord.textless_paste(&i.events));
+    // A numeric field being scrubbed has the keyboard: Escape cancels the drag.
+    if crate::scrub::phase(ctx) != crate::scrub::Phase::Idle {
+        return;
+    }
     if app.ui.dialog.is_some() || app.ui.palette_open {
         if crate::shortcut_editor::is_recording(app) {
             return;

crates/ui-egui/src/state.rs

@@ -255,6 +255,9 @@ pub struct UiState {
     /// Last tool shown in each toolbar slot (keyed by the slot's first tool id).
     #[serde(default)]
     pub slot_tool: std::collections::BTreeMap<String, String>,
+    /// Tool flyouts torn off the toolbar into floating panels.
+    #[serde(default)]
+    pub floating_flyouts: Vec<FloatingFlyout>,
     pub status_bar: bool,
     pub dock: bool,
     pub view: ViewFlags,
@@ -368,6 +371,15 @@ pub struct WindowGeometry {
     pub maximized: bool,
 }
 
+/// A tool group's flyout torn off the toolbar: it floats as its own panel until its × puts it back.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FloatingFlyout {
+    /// The group's tools in flyout order; the first one names the toolbar slot.
+    pub tools: Vec<String>,
+    /// Top-left corner in screen points.
+    pub pos: [f32; 2],
+}
+
 impl UiState {
     /// Clear transient state after loading saved preferences.
     pub fn sanitized(mut self) -> Self {
@@ -380,6 +392,12 @@ impl UiState {
         if self.group_tool.len() != vectorcraft_tools::TOOL_GROUPS.len() {
             self.group_tool = UiState::default().group_tool;
         }
+        // One strip per group, of known tools (a hand-edited preferences file).
+        let mut seen = std::collections::BTreeSet::new();
+        self.floating_flyouts.retain_mut(|f| {
+            f.tools.retain(|id| vectorcraft_tools::tool_info(id).is_some());
+            f.tools.first().is_some_and(|k| seen.insert(k.clone()))
+        });
         self
     }
 }
@@ -398,6 +416,7 @@ impl Default for UiState {
             toolbar_advanced: false,
             task_bar: true,
             slot_tool: Default::default(),
+            floating_flyouts: vec![],
             status_bar: true,
             dock: true,
             view: ViewFlags::default(),

crates/ui-egui/src/tests_pathtype.rs

@@ -0,0 +1,69 @@
+//! Type → Type on a Path → Type on a Path Options… (#429): the dialog shows the selected type's
+//! options (Effect, Flip, Align to Path, Spacing) and OK leaves its brackets where they are.
+
+use serde_json::{Value, json};
+use vectorcraft_doc::{NodeId, NodeKind, TextKind};
+use vectorcraft_engine::Session;
+
+use crate::{VectorcraftApp, dialogs, menus};
+
+/// The start and end brackets of type on a path `id`.
+fn brackets(app: &VectorcraftApp, id: NodeId) -> (f64, Option<f64>) {
+    match app.session.doc().unwrap().doc.node(id).map(|n| &n.kind) {
+        Some(NodeKind::Text(t)) => match t.kind {
+            TextKind::OnPath { start, end, .. } => (start, end),
+            ref k => panic!("not type on a path: {k:?}"),
+        },
+        k => panic!("not text: {k:?}"),
+    }
+}
+
+/// Open Type on a Path Options… from its menu item.
+fn open_options(app: &mut VectorcraftApp) {
+    let entry = menus::menu_entries(app).into_iter().find(|e| e.label == "Type on a Path Options…").expect("menu item");
+    assert_eq!(entry.path, ["Type", "Type on a Path"]);
+    assert!(entry.enabled);
+    let (cmd, params) = menus::click_target(&entry.label, entry.command.as_deref().unwrap(), &entry.params);
+    menus::invoke(app, &cmd, params);
+}
+
+#[test]
+fn type_on_a_path_options_keep_the_type_where_it_is() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.run("file.new", json!({"width": 600, "height": 400})).unwrap();
+    let path = app.run("path.create", json!({"d": "M100 200 L500 200"})).unwrap()["id"].as_u64().unwrap();
+    let r = app.run("text.createInPath", json!({"path": path, "mode": "onPath", "text": "Along", "at": [300, 210]})).unwrap();
+    let id = NodeId(r["id"].as_u64().unwrap());
+    app.run("select.set", json!({"ids": [id.0]})).unwrap();
+    let (start, _) = brackets(&app, id);
+    assert!((start - 0.5).abs() < 1e-3, "{start}");
+
+    open_options(&mut app);
+    let d = app.ui.dialog.as_ref().expect("a dialog opens");
+    assert_eq!((d.str("__command"), d.str("__label")), ("type.pathOptions".to_string(), "Type on a Path Options".to_string()));
+    for (k, v) in [("effect", json!("rainbow")), ("flip", json!(false)), ("alignToPath", json!("baseline")), ("spacing", json!(0.0))] {
+        assert_eq!(d.fields.get(k), Some(&v), "{k}");
+    }
+    assert!(!d.fields.contains_key("start") && !d.fields.contains_key("end"), "the brackets aren't the dialog's");
+    // It draws headlessly: the choices by name.
+    let text = crate::tests_labels::painted_text(&mut app, |app, ui| dialogs::show(app, ui.ctx()));
+    for label in ["Type on a Path Options", "Effect:", "Rainbow", "Flip:", "Align to Path:", "Baseline", "Spacing:"] {
+        assert!(text.contains(label), "{label} in {text}");
+    }
+    // OK as it opened: nothing moves.
+    dialogs::confirm(&mut app).unwrap();
+    assert_eq!(brackets(&app, id), (start, None));
+
+    // Flip and Align to Path: the type turns to the other side of the same stretch of its path.
+    open_options(&mut app);
+    let d = app.ui.dialog.as_mut().unwrap();
+    d.fields.insert("flip".into(), Value::Bool(true));
+    d.fields.insert("alignToPath".into(), json!("center"));
+    dialogs::confirm(&mut app).unwrap();
+    let (s, e) = brackets(&app, id);
+    assert!(s.abs() < 1e-9 && e.is_some_and(|e| (e - (1.0 - start)).abs() < 1e-9), "{s} {e:?}");
+    // The dialog shows the new alignment, and Flip is unchecked again (it flips once more).
+    open_options(&mut app);
+    let d = app.ui.dialog.as_ref().unwrap();
+    assert_eq!((d.fields.get("alignToPath"), d.fields.get("flip")), (Some(&json!("center")), Some(&json!(false))));
+}

crates/ui-egui/src/tests_scrub.rs

@@ -0,0 +1,282 @@
+//! Scrubbing numeric fields by dragging their label (#400): steps, modifiers, clamps, Escape, the
+//! preference, and one undo step in the app.
+
+use std::cell::Cell;
+
+use egui::{CursorIcon, Event, Key, Modifiers, PointerButton, Pos2, Rect, vec2};
+use serde_json::json;
+use vectorcraft_doc::Unit;
+use vectorcraft_engine::Session;
+
+use crate::{VectorcraftApp, scrub, widgets};
+
+/// Headless frames of one labelled field: where its label and its box were last drawn.
+struct Row {
+    ctx: egui::Context,
+    time: f64,
+    label: Cell<Rect>,
+    field: Cell<Rect>,
+}
+
+impl Row {
+    fn new() -> Self {
+        let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx);
+        Self { ctx, time: 0.0, label: Cell::new(Rect::NOTHING), field: Cell::new(Rect::NOTHING) }
+    }
+
+    /// One frame with `events`, the keyboard holding `modifiers`; `draw` draws the field after
+    /// the label "W:". → What the field returned and the pointer's cursor.
+    fn frame(&mut self, events: Vec<Event>, modifiers: Modifiers, draw: &dyn Fn(&mut egui::Ui) -> Option<f64>) -> (Option<f64>, CursorIcon) {
+        self.time += 0.05;
+        let screen_rect = Some(Rect::from_min_size(Pos2::ZERO, vec2(400.0, 200.0)));
+        let events = std::iter::once(Event::ModifiersChanged(modifiers)).chain(events).collect();
+        let input = egui::RawInput { events, time: Some(self.time), screen_rect, focused: true, ..Default::default() };
+        let mut got = None;
+        let mut out = self.ctx.run_ui(input, |ui| {
+            ui.horizontal(|ui| {
+                self.label.set(widgets::dim_label(ui, "W:").rect);
+                let before = ui.cursor().min;
+                got = draw(ui);
+                self.field.set(Rect::from_min_max(before, ui.min_rect().max));
+            });
+        });
+        out.textures_delta.clear();
+        (got, out.platform_output.cursor_icon)
+    }
+
+    /// Drag from `from` by `dx` points in `steps` moves (a frame each) with `modifiers` held, then
+    /// release (`escape`: press Escape before releasing). → The values the field returned.
+    fn drag(
+        &mut self,
+        from: Pos2,
+        dx: f32,
+        steps: usize,
+        modifiers: Modifiers,
+        escape: bool,
+        draw: &dyn Fn(&mut egui::Ui) -> Option<f64>,
+    ) -> Vec<f64> {
+        let button = |pos, pressed| Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers };
+        let mut got = vec![];
+        let mut push = |r: (Option<f64>, CursorIcon)| got.extend(r.0);
+        push(self.frame(vec![Event::PointerMoved(from)], modifiers, draw));
+        push(self.frame(vec![button(from, true)], modifiers, draw));
+        let mut at = from;
+        for _ in 0..steps {
+            at.x += dx / steps as f32;
+            push(self.frame(vec![Event::PointerMoved(at)], modifiers, draw));
+        }
+        if escape {
+            let esc = Event::Key { key: Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers };
+            push(self.frame(vec![esc], modifiers, draw));
+        }
+        push(self.frame(vec![button(at, false)], modifiers, draw));
+        push(self.frame(vec![], Modifiers::NONE, draw));
+        got
+    }
+}
+
+/// A W field in points over `width`, applying what it returns (as the panels do).
+fn w_field(width: &Cell<f64>) -> impl Fn(&mut egui::Ui) -> Option<f64> + '_ {
+    |ui| widgets::num_field(ui, "w", Some(width.get()), Unit::Points, 80.0).inspect(|&v| width.set(v))
+}
+
+#[test]
+fn dragging_the_label_steps_the_field_with_shift_and_ctrl() {
+    for (mods, dx, want) in [
+        // One unit per PX_PER_STEP points, ten with Shift, a tenth with Ctrl/Cmd; left goes down.
+        (Modifiers::NONE, 40.0, 100.0 + 40.0 / scrub::PX_PER_STEP as f64),
+        (Modifiers::NONE, -40.0, 100.0 - 40.0 / scrub::PX_PER_STEP as f64),
+        (Modifiers::SHIFT, 40.0, 100.0 + 400.0 / scrub::PX_PER_STEP as f64),
+        (Modifiers::COMMAND, 40.0, 100.0 + 4.0 / scrub::PX_PER_STEP as f64),
+    ] {
+        let mut row = Row::new();
+        let width = Cell::new(100.0);
+        let draw = w_field(&width);
+        row.frame(vec![], Modifiers::NONE, &draw);
+        let got = row.drag(row.label.get().center(), dx, 4, mods, false, &draw);
+        assert!((width.get() - want).abs() < 1e-9, "{mods:?} {dx}: {} (values {got:?})", width.get());
+        assert!(got.len() > 1, "the values come live while dragging: {got:?}");
+    }
+}
+
+#[test]
+fn hovering_the_label_shows_the_resize_cursor_and_clicking_it_focuses_the_field() {
+    let mut row = Row::new();
+    let width = Cell::new(100.0);
+    let draw = w_field(&width);
+    row.frame(vec![], Modifiers::NONE, &draw);
+    let (_, cursor) = row.frame(vec![Event::PointerMoved(row.label.get().center())], Modifiers::NONE, &draw);
+    assert_eq!(cursor, CursorIcon::ResizeHorizontal);
+    // The text box keeps the text cursor.
+    let (_, cursor) = row.frame(vec![Event::PointerMoved(row.field.get().center())], Modifiers::NONE, &draw);
+    assert_eq!(cursor, CursorIcon::Text);
+    // A click on the label (no drag) focuses the field, its text all selected.
+    let at = row.label.get().center();
+    let button = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
+    row.frame(vec![Event::PointerMoved(at), button(true), button(false)], Modifiers::NONE, &draw);
+    row.frame(vec![], Modifiers::NONE, &draw);
+    let id = row.ctx.memory(|m| m.focused());
+    assert!(id.is_some(), "the field has the focus");
+    let st = egui::TextEdit::load_state(&row.ctx, id.unwrap()).unwrap();
+    let r = st.cursor.char_range().unwrap().as_sorted_char_range();
+    assert_eq!((r.start.0, r.end.0), (0, "100 pt".len()));
+    assert_eq!(width.get(), 100.0);
+}
+
+#[test]
+fn dragging_the_text_box_does_not_scrub() {
+    let mut row = Row::new();
+    let width = Cell::new(100.0);
+    let draw = w_field(&width);
+    row.frame(vec![], Modifiers::NONE, &draw);
+    let got = row.drag(row.field.get().center(), 40.0, 4, Modifiers::NONE, false, &draw);
+    assert_eq!(width.get(), 100.0, "{got:?}");
+}
+
+#[test]
+fn a_field_without_a_label_does_not_scrub() {
+    let mut row = Row::new();
+    let width = Cell::new(100.0);
+    // The label is there, but the field is far from it: not its label.
+    let draw = |ui: &mut egui::Ui| {
+        ui.add_space(120.0);
+        widgets::num_field(ui, "w", Some(width.get()), Unit::Points, 80.0).inspect(|&v| width.set(v))
+    };
+    row.frame(vec![], Modifiers::NONE, &draw);
+    let (_, cursor) = row.frame(vec![Event::PointerMoved(row.label.get().center())], Modifiers::NONE, &draw);
+    assert_ne!(cursor, CursorIcon::ResizeHorizontal);
+    row.drag(row.label.get().center(), 40.0, 4, Modifiers::NONE, false, &draw);
+    assert_eq!(width.get(), 100.0);
+}
+
+/// The caller's limits hold, and dragging back changes the value at once (no dead zone past the
+/// limit); counts step by whole numbers, Ctrl/Cmd only slows them.
+#[test]
+fn scrubbing_respects_limits_and_precision() {
+    let mut row = Row::new();
+    let opacity = Cell::new(95.0);
+    let draw = |ui: &mut egui::Ui| widgets::plain_field(ui, "o", opacity.get(), "%", 0, 60.0).inspect(|&v| opacity.set(v.clamp(0.0, 100.0)));
+    row.frame(vec![], Modifiers::NONE, &draw);
+    let at = row.label.get().center();
+    let button = |pos, pressed| Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
+    row.frame(vec![Event::PointerMoved(at), button(at, true)], Modifiers::NONE, &draw);
+    for x in [10.0, 20.0, 30.0, 40.0] {
+        row.frame(vec![Event::PointerMoved(at + vec2(x, 0.0))], Modifiers::NONE, &draw);
+    }
+    assert_eq!(opacity.get(), 100.0, "clamped");
+    row.frame(vec![Event::PointerMoved(at + vec2(36.0, 0.0))], Modifiers::NONE, &draw);
+    assert_eq!(opacity.get(), 98.0, "back down at once");
+    row.frame(vec![button(at + vec2(36.0, 0.0), false)], Modifiers::NONE, &draw);
+
+    let mut row = Row::new();
+    let count = Cell::new(3.0);
+    let draw = |ui: &mut egui::Ui| widgets::plain_field(ui, "n", count.get(), "", 0, 60.0).inspect(|&v| count.set(v));
+    row.frame(vec![], Modifiers::NONE, &draw);
+    let got = row.drag(row.label.get().center(), 40.0, 4, Modifiers::COMMAND, false, &draw);
+    assert_eq!(count.get(), 5.0, "{got:?}");
+    assert!(got.iter().all(|v| v.fract() == 0.0), "{got:?}");
+
+    // Units: a millimetre field steps whole millimetres.
+    let mut row = Row::new();
+    let pt = Cell::new(Unit::Millimeters.to_pt(10.0));
+    let draw = |ui: &mut egui::Ui| widgets::num_field(ui, "mm", Some(pt.get()), Unit::Millimeters, 80.0).inspect(|&v| pt.set(v));
+    row.frame(vec![], Modifiers::NONE, &draw);
+    row.drag(row.label.get().center(), 20.0, 2, Modifiers::NONE, false, &draw);
+    assert!((Unit::Millimeters.from_pt(pt.get()) - 20.0).abs() < 1e-9, "{}", Unit::Millimeters.from_pt(pt.get()));
+}
+
+#[test]
+fn escape_puts_the_value_back_and_the_preference_turns_scrubbing_off() {
+    let mut row = Row::new();
+    let width = Cell::new(100.0);
+    let draw = w_field(&width);
+    row.frame(vec![], Modifiers::NONE, &draw);
+    let got = row.drag(row.label.get().center(), 40.0, 4, Modifiers::NONE, true, &draw);
+    assert_eq!(width.get(), 100.0, "{got:?}");
+    assert!(got.len() > 1 && got.last() == Some(&100.0), "{got:?}");
+    assert_eq!(scrub::phase(&row.ctx), scrub::Phase::Idle);
+
+    scrub::set_enabled(&row.ctx, false);
+    let (_, cursor) = row.frame(vec![Event::PointerMoved(row.label.get().center())], Modifiers::NONE, &draw);
+    assert_ne!(cursor, CursorIcon::ResizeHorizontal);
+    row.drag(row.label.get().center(), 40.0, 4, Modifiers::NONE, false, &draw);
+    assert_eq!(width.get(), 100.0);
+}
+
+// ---------- in the app ----------
+
+/// One frame of the whole window with `events`. → The rect of the first text drawn as `text`.
+fn app_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<Event>, text: &str) -> Option<Rect> {
+    let screen_rect = Some(Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 900.0)));
+    let mut out = ctx.run_ui(egui::RawInput { events, screen_rect, ..Default::default() }, |ui| {
+        app.logic(ui.ctx());
+        app.ui(ui);
+    });
+    out.textures_delta.clear();
+    fn find(shape: &egui::Shape, text: &str) -> Option<Rect> {
+        match shape {
+            egui::Shape::Text(t) if t.galley.text() == text => Some(t.galley.rect.translate(t.pos.to_vec2())),
+            egui::Shape::Vec(v) => v.iter().find_map(|s| find(s, text)),
+            _ => None,
+        }
+    }
+    out.shapes.iter().find_map(|s| find(&s.shape, text))
+}
+
+fn app_with_rect() -> (VectorcraftApp, egui::Context) {
+    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": 10, "y": 10, "width": 100, "height": 50})).unwrap();
+    (app, egui::Context::default())
+}
+
+fn width(app: &VectorcraftApp) -> f64 {
+    app.session.transform_box(&app.session.doc().unwrap().selection.objects).unwrap().rect.width()
+}
+
+fn undo_len(app: &VectorcraftApp) -> usize {
+    app.session.doc().unwrap().history.undo.len()
+}
+
+/// Drag the W label by `dx` in four moves (`escape`: Escape before the release).
+fn drag_w(app: &mut VectorcraftApp, ctx: &egui::Context, dx: f32, escape: bool) {
+    let mut w = None;
+    for _ in 0..4 {
+        w = app_frame(app, ctx, vec![], "W:");
+    }
+    let at = w.expect("the W label is shown").center();
+    let button = |pos, pressed| Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
+    app_frame(app, ctx, vec![Event::PointerMoved(at)], "");
+    app_frame(app, ctx, vec![button(at, true)], "");
+    for i in 1..=4 {
+        app_frame(app, ctx, vec![Event::PointerMoved(at + vec2(dx * i as f32 / 4.0, 0.0))], "");
+    }
+    if escape {
+        app_frame(app, ctx, vec![Event::Key { key: Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }], "");
+    }
+    app_frame(app, ctx, vec![button(at + vec2(dx, 0.0), false)], "");
+    app_frame(app, ctx, vec![], "");
+}
+
+/// A scrub of the W label resizes the selection live and is one undo step; Escape takes it back
+/// without a step (and without deselecting); with the preference off the label doesn't scrub.
+#[test]
+fn scrubbing_w_in_the_app_is_one_undo_step() {
+    let (mut app, ctx) = app_with_rect();
+    let undo = undo_len(&app);
+    drag_w(&mut app, &ctx, 40.0, false);
+    assert!((width(&app) - (100.0 + 40.0 / scrub::PX_PER_STEP as f64)).abs() < 1e-6, "{}", width(&app));
+    assert_eq!(undo_len(&app), undo + 1, "one undo step for the drag");
+    app.run("edit.undo", json!({})).unwrap();
+    assert!((width(&app) - 100.0).abs() < 1e-6);
+
+    drag_w(&mut app, &ctx, 40.0, true);
+    assert!((width(&app) - 100.0).abs() < 1e-6, "Escape: {}", width(&app));
+    assert_eq!(undo_len(&app), undo, "no step");
+    assert!(!app.session.doc().unwrap().selection.objects.is_empty(), "Escape didn't deselect");
+
+    app.run("prefs.set", json!({"key": "scrubNumericFields", "value": false})).unwrap();
+    drag_w(&mut app, &ctx, 40.0, false);
+    assert!((width(&app) - 100.0).abs() < 1e-6, "off: {}", width(&app));
+}

crates/ui-egui/src/toolbar.rs

@@ -12,6 +12,18 @@ use crate::{VectorcraftApp, icons, widgets};
 
 const PITCH: f32 = 30.0;
 const WIDTH: f32 = 48.0;
+/// Seconds a press on a tool group's button is held before its flyout opens.
+const LONG_PRESS: f64 = 0.35;
+/// Width of the grab bar down a flyout's right side: dragging it tears the flyout off.
+const BAR: f32 = 10.0;
+/// Height of the × at the top of a floating flyout's bar.
+const CLOSE: f32 = 14.0;
+/// Points the pointer travels on a flyout's bar before the flyout tears off.
+const TEAR: f32 = 3.0;
+/// Seconds a floating flyout flashes when a press that would open its flyout raises it.
+const FLASH: f64 = 0.4;
+/// Size of a tool button in a floating flyout's strip.
+const STRIP_BUTTON: egui::Vec2 = vec2(32.0, PITCH);
 
 /// The Basic toolbar: (category, slots); each slot is a flyout group (first = default).
 pub const BASIC: &[(&str, &[&[&str]])] = &[
@@ -116,6 +128,8 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
                 }
                 let held: Option<egui::Id> = ui.data(|d| d.get_temp(held_id));
                 let mut open_flyout: Option<(Vec<&'static str>, egui::Rect)> = None;
+                // A group torn off into a floating flyout is raised instead of opening its flyout.
+                let mut raise: Option<&'static str> = None;
                 let mut i = 0;
                 while i < all.len() {
                     if let Some(cat) = all[i].0 {
@@ -167,21 +181,15 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
                                     Stroke::NONE,
                                 ));
                             }
-                            let held_for = resp
-                                .is_pointer_button_down_on()
-                                .then(|| ui.input(|inp| inp.pointer.press_start_time().map(|s| inp.time - s)))
-                                .flatten();
-                            if slot.len() > 1
-                                && let Some(seconds) = held_for
-                                && seconds < 0.35
-                            {
-                                ui.ctx().request_repaint_after(std::time::Duration::from_secs_f64(0.35 - seconds));
-                            }
-                            let long_press = held_for.is_some_and(|seconds| seconds >= 0.35);
+                            let press = if slot.len() > 1 { flyout_press(ui, &resp, rect) } else { None };
                             let alt = ui.input(|inp| inp.modifiers.alt);
-                            if (resp.secondary_clicked() || long_press) && slot.len() > 1 {
-                                open_flyout = Some((slot.clone(), rect));
-                                if long_press {
+                            if press.is_some() {
+                                if is_floating(app, slot[0]) {
+                                    raise = Some(slot[0]);
+                                } else {
+                                    open_flyout = Some((slot.clone(), rect));
+                                }
+                                if press == Some(FlyoutPress::Primary) {
                                     ui.data_mut(|d| d.insert_temp(held_id, resp.id));
                                 }
                             } else if resp.clicked() && held == Some(resp.id) {
@@ -200,6 +208,9 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
                     });
                     i += row.len();
                 }
+                if let Some(key) = raise {
+                    raise_floating(ui.ctx(), key);
+                }
                 if let Some((slot, rect)) = open_flyout {
                     app.ui.flyout = Some(0);
                     ui.data_mut(|d| {
@@ -211,9 +222,46 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
                 bottom_controls(app, ui, &t);
             });
         });
+    // Before the flyout: one torn off this frame floats from the next (its bar mustn't be in two
+    // layers in one frame).
+    floating(app, ui.ctx());
     flyout(app, ui.ctx());
 }
 
+/// How a press on a tool group's button opens its flyout.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+enum FlyoutPress {
+    /// A right press (it opens at once, before the release).
+    Secondary,
+    /// A primary press on the corner triangle, or one held [`LONG_PRESS`] seconds: its release
+    /// mustn't pick the button's tool.
+    Primary,
+}
+
+/// Whether this frame's pointer state on a tool button opens its group's flyout. A primary press
+/// still short of a long one asks for the frame where it becomes long: egui draws only on input,
+/// so a still mouse would otherwise never get there.
+fn flyout_press(ui: &Ui, resp: &egui::Response, rect: egui::Rect) -> Option<FlyoutPress> {
+    if resp.hovered() && ui.input(|inp| inp.pointer.button_pressed(egui::PointerButton::Secondary)) {
+        return Some(FlyoutPress::Secondary);
+    }
+    if !resp.is_pointer_button_down_on() || !ui.input(|inp| inp.pointer.primary_down()) {
+        return None;
+    }
+    // The triangle's corner: the bottom-right third of the button.
+    let corner = egui::Rect::from_min_max(rect.center() + vec2(6.0, 4.0), rect.max);
+    let (origin, held) = ui.input(|inp| (inp.pointer.press_origin(), inp.pointer.press_start_time().map(|s| inp.time - s)));
+    if origin.is_some_and(|p| corner.contains(p)) {
+        return Some(FlyoutPress::Primary);
+    }
+    let held = held.unwrap_or(0.0);
+    if held >= LONG_PRESS {
+        return Some(FlyoutPress::Primary);
+    }
+    ui.ctx().request_repaint_after_secs((LONG_PRESS - held) as f32);
+    None
+}
+
 /// Open a tool's options (`tool.options`, a double-click on its button): the Gradient tool's are
 /// the Gradient panel, the Eyedropper's the Eyedropper Options dialog, a Liquify tool's its Tool
 /// Options dialog, the Blend tool's Blend
@@ -334,6 +382,183 @@ fn bottom_controls(app: &mut VectorcraftApp, ui: &mut Ui, t: &Tokens) {
     let _ = t;
 }
 
+/// Where `window.floatTools` puts a strip (the next one a row lower), right of the toolbar; it's
+/// kept on screen and moved by its bar.
+const FLOAT_AT: [f32; 2] = [90.0, 100.0];
+
+/// Float the toolbar group (of the current layout) holding `tool` as a strip of tool buttons, put
+/// it back in the toolbar, or toggle (`floating` omitted), as a flyout's tear-off bar and the
+/// strip's × do (`window.floatTools`). Returns the new state.
+pub fn float_group(app: &mut VectorcraftApp, tool: &str, floating: Option<bool>) -> Result<bool, String> {
+    let Some((_, group)) = slots(app).into_iter().find(|(_, s)| s.len() > 1 && s.contains(&tool)) else {
+        return Err(format!("{tool} isn't in a toolbar group of several tools"));
+    };
+    let key = group.first().copied().unwrap_or_default();
+    let was = is_floating(app, key);
+    let on = floating.unwrap_or(!was);
+    if on && !was {
+        let n = app.ui.floating_flyouts.len() as f32;
+        let tools = group.iter().map(|id| id.to_string()).collect();
+        app.ui.floating_flyouts.push(crate::state::FloatingFlyout { tools, pos: [FLOAT_AT[0], FLOAT_AT[1] + n * (PITCH + 12.0)] });
+        app.ui.flyout = None;
+    } else if !on {
+        app.ui.floating_flyouts.retain(|f| f.tools.first().is_none_or(|k| k != key));
+    }
+    Ok(on)
+}
+
+/// Whether the group whose first tool is `key` floats as its own panel.
+fn is_floating(app: &VectorcraftApp, key: &str) -> bool {
+    app.ui.floating_flyouts.iter().any(|f| f.tools.first().is_some_and(|k| k == key))
+}
+
+/// The area of the floating flyout of the group whose first tool is `key`.
+fn floating_area(key: &str) -> egui::Id {
+    egui::Id::new(("tool-floating", key))
+}
+
+/// Bring a floating flyout to the front and flash its border.
+fn raise_floating(ctx: &egui::Context, key: &str) {
+    let id = floating_area(key);
+    ctx.move_to_top(egui::LayerId::new(egui::Order::Middle, id));
+    let now = ctx.input(|i| i.time);
+    ctx.data_mut(|d| d.insert_temp(id, now));
+}
+
+/// A flyout's frame: drop shadow and border (the accent while it flashes).
+fn flyout_frame(t: &Tokens, flash: bool) -> egui::Frame {
+    egui::Frame::NONE
+        .fill(t.panel)
+        .stroke(if flash { Stroke::new(1.5, t.accent) } else { Stroke::new(1.0, t.input_border) })
+        .shadow(egui::epaint::Shadow { offset: [0, 3], blur: 10, spread: 0, color: Color32::from_black_alpha(90) })
+}
+
+/// What a press on a flyout did.
+#[derive(Default)]
+struct FlyoutInput {
+    /// The tool row clicked.
+    chosen: Option<&'static str>,
+    /// The grab bar's response (its drag tears off or moves the flyout).
+    bar: Option<egui::Response>,
+    /// A floating flyout's × was clicked.
+    close: bool,
+}
+
+/// A flyout's tool rows (a floating flyout's strip of tool buttons) with the grab bar down their
+/// right side; a floating flyout's bar has a × at its top. The bar's id is the group's, so a drag
+/// that tears a flyout off carries on moving the floating flyout it becomes.
+fn flyout_body(ui: &mut Ui, t: &Tokens, active: &str, tools: &[String], floating: bool) -> FlyoutInput {
+    let mut out = FlyoutInput::default();
+    let key = tools.first().map_or("", String::as_str);
+    ui.spacing_mut().item_spacing = vec2(0.0, 0.0);
+    ui.horizontal(|ui| {
+        let rows = if floating { ui.horizontal(|ui| tool_strip(ui, t, active, tools)) } else { ui.vertical(|ui| tool_rows(ui, t, active, tools)) };
+        out.chosen = rows.inner;
+        let (bar, _) = ui.allocate_exact_size(vec2(BAR, rows.response.rect.height()), Sense::hover());
+        ui.painter().rect_filled(bar, 0.0, t.tab_strip);
+        let grip = if floating {
+            let x = egui::Rect::from_min_size(bar.min, vec2(BAR, CLOSE));
+            let xr = ui.interact(x, egui::Id::new(("tool-flyout-close", key)), Sense::click());
+            icons::paint(ui, "x", x.shrink2(vec2(1.0, 3.0)), if xr.hovered() { t.text_strong } else { t.text });
+            out.close = xr.on_hover_text(tl!("Put back in the toolbar")).clicked();
+            egui::Rect::from_min_max(bar.min + vec2(0.0, CLOSE), bar.max)
+        } else {
+            bar
+        };
+        let resp = ui.interact(grip, bar_id(key), Sense::drag());
+        let half = (grip.height() / 2.0 - 3.0).clamp(0.0, 9.0);
+        for k in 0..3 {
+            let x = grip.center().x - 2.0 + k as f32 * 2.0;
+            ui.painter().line_segment([pos2(x, grip.center().y - half), pos2(x, grip.center().y + half)], Stroke::new(0.6, t.text_disabled));
+        }
+        let resp = if resp.dragged() {
+            ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing);
+            resp
+        } else {
+            let tip = if floating { tl!("Drag to move") } else { tl!("Drag to float as a toolbar") };
+            resp.on_hover_cursor(egui::CursorIcon::Grab).on_hover_text(tip)
+        };
+        out.bar = Some(resp);
+    });
+    out
+}
+
+/// One row per tool: icon, name and shortcut, with a dot by the active tool. Returns the tool clicked.
+fn tool_rows(ui: &mut Ui, t: &Tokens, active: &str, tools: &[String]) -> Option<&'static str> {
+    let mut chosen = None;
+    let w = 250.0;
+    for id in tools {
+        let Some(tool) = tool_info(id) else { continue };
+        let is_active = active == tool.id;
+        let (r, resp) = ui.allocate_exact_size(vec2(w, 30.0), Sense::click());
+        if resp.hovered() {
+            ui.painter().rect_filled(r, 0.0, t.hover);
+        }
+        if is_active {
+            ui.painter().rect_filled(egui::Rect::from_center_size(r.left_center() + vec2(12.0, 0.0), vec2(5.0, 5.0)), 0.0, t.text);
+        }
+        let ir = egui::Rect::from_min_size(r.min + vec2(24.0, 6.0), vec2(18.0, 18.0));
+        icons::paint(ui, icons::tool_icon(tool.icon), ir, t.icon);
+        let color = if is_active { t.flyout_active } else { t.text_strong };
+        ui.painter().text(r.left_center() + vec2(52.0, 0.0), egui::Align2::LEFT_CENTER, tl!(tool.label), egui::FontId::proportional(13.0), color);
+        if let Some(sc) = crate::shortcut_editor::tool_shortcut(tool.id) {
+            ui.painter().text(
+                r.right_center() - vec2(18.0, 0.0),
+                egui::Align2::RIGHT_CENTER,
+                format!("({sc})"),
+                egui::FontId::proportional(13.0),
+                color,
+            );
+        }
+        if resp.clicked() {
+            chosen = Some(tool.id);
+        }
+    }
+    chosen
+}
+
+/// The grab bar of the group whose first tool is `key` (one id, flyout or floating, so a drag
+/// that tears the flyout off carries on moving it).
+fn bar_id(key: &str) -> egui::Id {
+    egui::Id::new(("tool-flyout-bar", key))
+}
+
+/// Where the pointer holds a floating flyout's bar, from the flyout's corner, while it's dragged.
+fn grab_id(key: &str) -> egui::Id {
+    bar_id(key).with("grab")
+}
+
+/// One icon button per tool, the active one lit, with its name and shortcut on hover. Returns the
+/// tool clicked.
+fn tool_strip(ui: &mut Ui, t: &Tokens, active: &str, tools: &[String]) -> Option<&'static str> {
+    let mut chosen = None;
+    for tool in tools.iter().filter_map(|id| tool_info(id)) {
+        let (r, resp) = ui.allocate_exact_size(STRIP_BUTTON, Sense::click());
+        let well = r.shrink(1.0);
+        if active == tool.id {
+            ui.painter().rect_filled(well, CornerRadius::same(1), t.tool_active);
+        } else if resp.hovered() {
+            ui.painter().rect_filled(well, CornerRadius::same(1), t.hover);
+        }
+        let ir = egui::Rect::from_center_size(r.center(), vec2(18.0, 18.0));
+        icons::paint(ui, icons::tool_icon(tool.icon), ir, if active == tool.id { t.text_strong } else { t.icon });
+        if resp.on_hover_text(tip(tool)).clicked() {
+            chosen = Some(tool.id);
+        }
+    }
+    chosen
+}
+
+/// The width of a floating flyout's strip of `tools`, its bar included.
+fn strip_width(tools: &[String]) -> f32 {
+    tools.iter().filter(|id| tool_info(id).is_some()).count() as f32 * STRIP_BUTTON.x + BAR
+}
+
+/// How far the pointer has moved since the press that's down, if one is.
+fn press_travel(ctx: &egui::Context) -> Option<egui::Vec2> {
+    ctx.input(|i| i.pointer.press_origin().zip(i.pointer.interact_pos()).map(|(a, b)| b - a))
+}
+
 fn flyout(app: &mut VectorcraftApp, ctx: &egui::Context) {
     if app.ui.flyout.is_none() {
         return;
@@ -346,54 +571,33 @@ fn flyout(app: &mut VectorcraftApp, ctx: &egui::Context) {
     let anchor: egui::Rect =
         ctx.data(|d| d.get_temp(egui::Id::new("flyout-anchor"))).unwrap_or(egui::Rect::from_min_size(pos2(40.0, 100.0), vec2(32.0, 32.0)));
     let t = Tokens::get(ctx);
-    let mut chosen = None;
+    let active = app.session.tool_id();
+    let mut input = FlyoutInput::default();
     let resp = egui::Area::new(egui::Id::new("tool-flyout")).order(egui::Order::Foreground).fixed_pos(anchor.right_top() + vec2(8.0, -1.0)).show(
         ctx,
         |ui| {
-            egui::Frame::NONE
-                .fill(t.panel)
-                .stroke(Stroke::new(1.0, t.input_border))
-                .shadow(egui::epaint::Shadow { offset: [0, 3], blur: 10, spread: 0, color: Color32::from_black_alpha(90) })
-                .show(ui, |ui| {
-                    ui.spacing_mut().item_spacing = vec2(0.0, 0.0);
-                    let w = 250.0;
-                    for id in &tools {
-                        let Some(tool) = tool_info(id) else { continue };
-                        let active = app.session.tool_id() == tool.id;
-                        let (r, resp) = ui.allocate_exact_size(vec2(w, 30.0), Sense::click());
-                        if resp.hovered() {
-                            ui.painter().rect_filled(r, 0.0, t.hover);
-                        }
-                        if active {
-                            ui.painter().rect_filled(egui::Rect::from_center_size(r.left_center() + vec2(12.0, 0.0), vec2(5.0, 5.0)), 0.0, t.text);
-                        }
-                        let ir = egui::Rect::from_min_size(r.min + vec2(24.0, 6.0), vec2(18.0, 18.0));
-                        icons::paint(ui, icons::tool_icon(tool.icon), ir, t.icon);
-                        let color = if active { t.flyout_active } else { t.text_strong };
-                        ui.painter().text(
-                            r.left_center() + vec2(52.0, 0.0),
-                            egui::Align2::LEFT_CENTER,
-                            tl!(tool.label),
-                            egui::FontId::proportional(13.0),
-                            color,
-                        );
-                        if let Some(sc) = crate::shortcut_editor::tool_shortcut(tool.id) {
-                            ui.painter().text(
-                                r.right_center() - vec2(18.0, 0.0),
-                                egui::Align2::RIGHT_CENTER,
-                                format!("({sc})"),
-                                egui::FontId::proportional(13.0),
-                                color,
-                            );
-                        }
-                        if resp.clicked() {
-                            chosen = Some(tool.id);
-                        }
-                    }
-                });
+            flyout_frame(&t, false).show(ui, |ui| input = flyout_body(ui, &t, active, &tools, false));
         },
     );
-    if let Some(id) = chosen {
+    // Dragging the bar tears the flyout off, and so does releasing a press over it (a click, or the
+    // end of the long press that opened the flyout): it floats where the pointer is.
+    let at = ctx.input(|i| i.pointer.interact_pos());
+    let released_on_bar = input.bar.as_ref().is_some_and(|b| ctx.input(|i| i.pointer.primary_released()) && at.is_some_and(|p| b.rect.contains(p)));
+    let dragged_off = input.bar.as_ref().is_some_and(egui::Response::dragged) && press_travel(ctx).is_some_and(|d| d.length() > TEAR);
+    if released_on_bar || dragged_off {
+        // The strip is far narrower than the flyout: it floats with its bar under the pointer.
+        let at = at.unwrap_or(resp.response.rect.right_center());
+        // (Past the frame's 1 pt border.)
+        let grab = vec2(1.0 + strip_width(&tools) - BAR / 2.0, 1.0 + CLOSE + 4.0);
+        let p = at - grab;
+        if let Some(key) = tools.first() {
+            ctx.data_mut(|m| m.insert_temp(grab_id(key), grab));
+        }
+        app.ui.floating_flyouts.push(crate::state::FloatingFlyout { tools, pos: [p.x, p.y] });
+        app.ui.flyout = None;
+        return;
+    }
+    if let Some(id) = input.chosen {
         app.select_tool(id);
     } else if resp.response.clicked_elsewhere() && !ctx.input(|i| i.pointer.interact_pos().is_some_and(|p| anchor.contains(p))) {
         // A click on the flyout's own tool button (the right-click that opened it, or the end of a
@@ -403,6 +607,61 @@ fn flyout(app: &mut VectorcraftApp, ctx: &egui::Context) {
     let _ = theme::semibold;
 }
 
+/// The flyouts torn off the toolbar, each floating where its bar was dragged; its × puts it back.
+fn floating(app: &mut VectorcraftApp, ctx: &egui::Context) {
+    if app.ui.floating_flyouts.is_empty() {
+        return;
+    }
+    let t = Tokens::get(ctx);
+    let screen = ctx.content_rect();
+    let now = ctx.input(|i| i.time);
+    let active = app.session.tool_id();
+    let mut chosen = None;
+    let mut closed = None;
+    for (k, f) in app.ui.floating_flyouts.iter_mut().enumerate() {
+        let Some(key) = f.tools.first() else { continue };
+        let id = floating_area(key);
+        let since = ctx.data(|d| d.get_temp::<f64>(id)).map(|t0| now - t0);
+        let flash = since.is_some_and(|s| (0.0..FLASH).contains(&s));
+        if let Some(s) = since.filter(|_| flash) {
+            ctx.request_repaint_after_secs((FLASH - s) as f32);
+        }
+        // Kept on screen (a smaller window, or a position saved on a bigger one).
+        let size = ctx.memory(|m| m.area_rect(id)).map_or(vec2(strip_width(&f.tools), PITCH), |r| r.size());
+        let [x, y] = f.pos;
+        let (x, y) = if x.is_finite() && y.is_finite() { (x, y) } else { (screen.left() + 60.0, screen.top() + 100.0) };
+        let pos = pos2(x.min(screen.right() - size.x).max(screen.left()), y.min(screen.bottom() - size.y).max(screen.top()));
+        let mut input = FlyoutInput::default();
+        egui::Area::new(id).order(egui::Order::Middle).fixed_pos(pos).show(ctx, |ui| {
+            flyout_frame(&t, flash).show(ui, |ui| input = flyout_body(ui, &t, active, &f.tools, true));
+        });
+        // Dragging the bar keeps the flyout where the pointer holds it (by an offset rather than
+        // each frame's motion, which a just torn-off flyout's first, unseen frame would drop).
+        let grab = grab_id(key);
+        if ctx.is_being_dragged(bar_id(key))
+            && let Some(at) = ctx.input(|i| i.pointer.interact_pos())
+        {
+            let off = ctx.data_mut(|m| *m.get_temp_mut_or_insert_with(grab, || at - pos));
+            let p = at - off;
+            if p.x.is_finite() && p.y.is_finite() {
+                f.pos = [p.x, p.y];
+            }
+        } else if !ctx.input(|i| i.pointer.any_down()) {
+            ctx.data_mut(|m| m.remove::<egui::Vec2>(grab));
+        }
+        if input.close {
+            closed = Some(k);
+        }
+        chosen = chosen.or(input.chosen);
+    }
+    if let Some(k) = closed.filter(|k| *k < app.ui.floating_flyouts.len()) {
+        app.ui.floating_flyouts.remove(k);
+    }
+    if let Some(id) = chosen {
+        app.select_tool(id);
+    }
+}
+
 /// The Puppet Warp tool's Control bar: Expand (how far the mesh reaches past the art), Show Mesh
 /// and Select All Pins.
 fn puppet_warp_options(app: &mut VectorcraftApp, ui: &mut Ui) {
@@ -607,6 +866,78 @@ pub(crate) mod tests {
         frame(&mut app, &ctx, 4.05, vec![c(false)]);
         assert_eq!((app.session.tool_id(), app.ui.flyout), ("roundedRectangle", None));
     }
+
+    /// The Shapes group's button (Selection, Direct Selection, Lasso, then Rectangle).
+    fn shapes_button(app: &mut VectorcraftApp, ctx: &egui::Context) -> egui::Rect {
+        app.run("file.new", json!({"width": 300, "height": 300})).unwrap();
+        frame(app, ctx, 0.0, vec![])[3]
+    }
+
+    #[test]
+    fn a_held_press_asks_for_the_frame_that_opens_the_flyout() {
+        // egui draws only on input: a still press must schedule the frame where it becomes long.
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        let ctx = egui::Context::default();
+        let at = shapes_button(&mut app, &ctx).center();
+        let p = Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: true, modifiers: Default::default() };
+        frame(&mut app, &ctx, 1.0, vec![Event::PointerMoved(at), p]);
+        // The frames egui runs after the input settle; then nothing moves.
+        frame(&mut app, &ctx, 1.02, vec![]);
+        let input =
+            egui::RawInput { time: Some(1.04), screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(400.0, 1200.0))), ..Default::default() };
+        let out = ctx.run_ui(input, |ui| show(&mut app, ui));
+        let delay = out.viewport_output.get(&egui::ViewportId::ROOT).unwrap().repaint_delay;
+        assert!(delay <= std::time::Duration::from_secs_f64(LONG_PRESS), "repaint in {delay:?}");
+        assert!(app.ui.flyout.is_none(), "not open before the press is long");
+    }
+
+    #[test]
+    fn pressing_the_corner_triangle_opens_the_flyout_at_once() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        let ctx = egui::Context::default();
+        let button = shapes_button(&mut app, &ctx);
+        let at = button.right_bottom() - vec2(4.0, 4.0);
+        let p = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
+        frame(&mut app, &ctx, 1.0, vec![Event::PointerMoved(at), p(true)]);
+        assert!(app.ui.flyout.is_some(), "the press on the triangle opens it");
+        frame(&mut app, &ctx, 1.05, vec![p(false)]);
+        frame(&mut app, &ctx, 1.1, vec![]);
+        assert_eq!((app.session.tool_id(), app.ui.flyout.is_some()), ("selection", true), "the release neither closes it nor picks the tool");
+        // A plain click in the middle of the button still just picks its tool.
+        let mid = button.center();
+        let c = |pressed| Event::PointerButton { pos: mid, button: PointerButton::Primary, pressed, modifiers: Default::default() };
+        frame(&mut app, &ctx, 2.0, vec![Event::PointerMoved(mid), c(true)]);
+        frame(&mut app, &ctx, 2.05, vec![c(false)]);
+        assert_eq!((app.session.tool_id(), app.ui.flyout), ("rectangle", None));
+    }
+
+    #[test]
+    fn the_flyout_opens_on_the_right_press_even_when_its_tool_is_active() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        let ctx = egui::Context::default();
+        let at = shapes_button(&mut app, &ctx).center();
+        app.select_tool("rectangle");
+        for (k, t0) in [1.0, 3.0, 5.0].into_iter().enumerate() {
+            let r = |pressed| Event::PointerButton { pos: at, button: PointerButton::Secondary, pressed, modifiers: Default::default() };
+            frame(&mut app, &ctx, t0, vec![Event::PointerMoved(at), r(true)]);
+            assert!(app.ui.flyout.is_some(), "right press #{k} opens it before the release");
+            frame(&mut app, &ctx, t0 + 0.05, vec![r(false)]);
+            assert!(app.ui.flyout.is_some(), "right press #{k} leaves it open");
+            // A click away closes it; then try again.
+            let away = egui::pos2(300.0, 1000.0);
+            let c = |pressed| Event::PointerButton { pos: away, button: PointerButton::Primary, pressed, modifiers: Default::default() };
+            frame(&mut app, &ctx, t0 + 1.0, vec![Event::PointerMoved(away), c(true)]);
+            frame(&mut app, &ctx, t0 + 1.05, vec![c(false)]);
+            assert!(app.ui.flyout.is_none());
+        }
+        // A long press on the active tool's button opens it too.
+        let p = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
+        frame(&mut app, &ctx, 8.0, vec![Event::PointerMoved(at), p(true)]);
+        frame(&mut app, &ctx, 8.0 + LONG_PRESS + 0.01, vec![]);
+        assert!(app.ui.flyout.is_some(), "a long press on the active tool opens it");
+        assert_eq!(app.session.tool_id(), "rectangle");
+    }
+
     #[test]
     fn type_button_long_press_selects_vertical_type_in_both_layouts() {
         for advanced in [false, true] {
@@ -636,4 +967,227 @@ pub(crate) mod tests {
             assert_eq!(app.ui.flyout, None);
         }
     }
+
+    /// A press at `from`, dragged through `to` (one frame each), then released.
+    fn drag(app: &mut VectorcraftApp, ctx: &egui::Context, time: f64, from: Pos2, to: &[Pos2]) {
+        let b = |pos, pressed| Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Default::default() };
+        frame(app, ctx, time, vec![Event::PointerMoved(from), b(from, true)]);
+        for (k, p) in to.iter().enumerate() {
+            frame(app, ctx, time + 0.05 * (k + 1) as f64, vec![Event::PointerMoved(*p)]);
+        }
+        let end = to.last().copied().unwrap_or(from);
+        frame(app, ctx, time + 0.05 * (to.len() + 1) as f64, vec![b(end, false)]);
+        frame(app, ctx, time + 0.05 * (to.len() + 2) as f64, vec![]);
+    }
+
+    /// A click at `at`.
+    fn click(app: &mut VectorcraftApp, ctx: &egui::Context, time: f64, at: Pos2, button: PointerButton) {
+        let b = |pressed| Event::PointerButton { pos: at, button, pressed, modifiers: Default::default() };
+        frame(app, ctx, time, vec![Event::PointerMoved(at), b(true)]);
+        frame(app, ctx, time + 0.05, vec![b(false)]);
+        frame(app, ctx, time + 0.1, vec![]);
+    }
+
+    #[test]
+    fn a_flyout_dragged_by_its_bar_floats_until_its_close_box_puts_it_back() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        let ctx = egui::Context::default();
+        let at = shapes_button(&mut app, &ctx).center();
+        click(&mut app, &ctx, 1.0, at, PointerButton::Secondary);
+        let menu = ctx.memory(|m| m.area_rect(egui::Id::new("tool-flyout"))).expect("the flyout is shown");
+        // Its grab bar runs down its right side: dragging it tears the flyout off.
+        let bar = pos2(menu.right() - BAR / 2.0, menu.center().y);
+        drag(&mut app, &ctx, 2.0, bar, &[bar + vec2(20.0, 0.0), bar + vec2(60.0, 40.0)]);
+        assert_eq!(app.ui.flyout, None, "the flyout became the floating one");
+        let [f] = app.ui.floating_flyouts.as_slice() else { panic!("one floating flyout: {:?}", app.ui.floating_flyouts) };
+        assert_eq!(f.tools.first().map(String::as_str), Some("rectangle"));
+        let float = ctx.memory(|m| m.area_rect(floating_area("rectangle"))).expect("the floating flyout is shown");
+        // A strip of its nine tools' buttons, its bar under the pointer.
+        let drop = bar + vec2(60.0, 40.0);
+        assert!(float.height() < 40.0 && float.width() > 9.0 * STRIP_BUTTON.x, "a one-row strip: {float:?}");
+        assert!(
+            (float.right() - 1.0 - BAR / 2.0 - drop.x).abs() < 1.0 && float.y_range().contains(drop.y),
+            "its bar is under the pointer: {float:?}"
+        );
+        // The same bar moves it.
+        let bar = pos2(float.right() - 1.0 - BAR / 2.0, float.bottom() - 6.0);
+        drag(&mut app, &ctx, 3.0, bar, &[bar + vec2(0.0, 20.0), bar + vec2(-10.0, 100.0)]);
+        let moved = ctx.memory(|m| m.area_rect(floating_area("rectangle"))).unwrap();
+        assert!((moved.min - (float.min + vec2(-10.0, 100.0))).length() < 2.0, "moved to {moved:?} from {float:?}");
+        // Picking a tool in it leaves it open.
+        click(&mut app, &ctx, 4.0, pos2(moved.left() + STRIP_BUTTON.x * 1.5, moved.center().y), PointerButton::Primary);
+        assert_eq!((app.session.tool_id(), app.ui.floating_flyouts.len()), ("roundedRectangle", 1));
+        // While it floats, the presses that open the group's flyout raise it instead.
+        click(&mut app, &ctx, 5.0, at, PointerButton::Secondary);
+        assert_eq!(app.ui.flyout, None, "no flyout beside the floating one");
+        assert!(ctx.data(|d| d.get_temp::<f64>(floating_area("rectangle"))).is_some(), "the floating flyout was raised");
+        let p = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
+        frame(&mut app, &ctx, 6.0, vec![Event::PointerMoved(at), p(true)]);
+        frame(&mut app, &ctx, 6.0 + LONG_PRESS + 0.01, vec![]);
+        frame(&mut app, &ctx, 6.5, vec![p(false)]);
+        assert_eq!((app.ui.flyout, app.session.tool_id()), (None, "roundedRectangle"), "a long press neither opens the flyout nor picks the tool");
+        // The × at the top of the bar puts it back: the group opens as a flyout again.
+        click(&mut app, &ctx, 7.0, pos2(moved.right() - BAR / 2.0, moved.top() + CLOSE / 2.0), PointerButton::Primary);
+        assert!(app.ui.floating_flyouts.is_empty());
+        click(&mut app, &ctx, 8.0, at, PointerButton::Secondary);
+        assert!(app.ui.flyout.is_some());
+    }
+
+    #[test]
+    fn a_click_on_a_flyouts_bar_tears_it_off() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        let ctx = egui::Context::default();
+        let at = shapes_button(&mut app, &ctx).center();
+        click(&mut app, &ctx, 1.0, at, PointerButton::Secondary);
+        let menu = ctx.memory(|m| m.area_rect(egui::Id::new("tool-flyout"))).unwrap();
+        let bar = pos2(menu.right() - BAR / 2.0, menu.center().y);
+        click(&mut app, &ctx, 2.0, bar, PointerButton::Primary);
+        frame(&mut app, &ctx, 2.2, vec![]);
+        assert_eq!(app.ui.flyout, None);
+        assert_eq!(app.ui.floating_flyouts.iter().map(|f| f.tools[0].as_str()).collect::<Vec<_>>(), ["rectangle"]);
+        let float = ctx.memory(|m| m.area_rect(floating_area("rectangle"))).expect("the floating flyout is shown");
+        assert!(float.contains(bar), "its bar is under the pointer: {float:?}");
+        assert_eq!(app.session.tool_id(), "selection", "no tool picked");
+    }
+
+    #[test]
+    fn releasing_a_long_press_over_the_flyouts_bar_tears_it_off() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        let ctx = egui::Context::default();
+        let at = shapes_button(&mut app, &ctx).center();
+        let b = |pos, pressed| Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Default::default() };
+        frame(&mut app, &ctx, 1.0, vec![Event::PointerMoved(at), b(at, true)]);
+        frame(&mut app, &ctx, 1.0 + LONG_PRESS + 0.01, vec![]);
+        frame(&mut app, &ctx, 1.45, vec![]);
+        let menu = ctx.memory(|m| m.area_rect(egui::Id::new("tool-flyout"))).expect("the long press opens the flyout");
+        let bar = pos2(menu.right() - BAR / 2.0, menu.center().y);
+        frame(&mut app, &ctx, 1.5, vec![Event::PointerMoved(bar)]);
+        frame(&mut app, &ctx, 1.55, vec![b(bar, false)]);
+        frame(&mut app, &ctx, 1.6, vec![]);
+        assert_eq!((app.ui.flyout, app.ui.floating_flyouts.len(), app.session.tool_id()), (None, 1, "selection"));
+    }
+
+    #[test]
+    fn window_float_tools_floats_and_puts_back_a_group() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        let check = |app: &VectorcraftApp| crate::menus::checked(app, "window.floatTools", &json!({"tool": "star"}));
+        assert_eq!(app.run("window.floatTools", json!({"tool": "star"})).unwrap(), json!(true));
+        let [f] = app.ui.floating_flyouts.as_slice() else { panic!("one strip: {:?}", app.ui.floating_flyouts) };
+        assert_eq!(f.tools.first().map(String::as_str), Some("rectangle"), "the Basic toolbar's Shapes group");
+        assert_eq!(check(&app), Some(true));
+        // Already floating: stays where it is.
+        app.ui.floating_flyouts[0].pos = [300.0, 400.0];
+        assert_eq!(app.run("window.floatTools", json!({"tool": "rectangle", "floating": true})).unwrap(), json!(true));
+        assert_eq!(app.ui.floating_flyouts.iter().map(|f| f.pos).collect::<Vec<_>>(), [[300.0, 400.0]]);
+        // Omitted toggles it back.
+        assert_eq!(app.run("window.floatTools", json!({"tool": "star"})).unwrap(), json!(false));
+        assert!(app.ui.floating_flyouts.is_empty() && check(&app) == Some(false));
+        assert_eq!(app.run("window.floatTools", json!({"tool": "pen", "floating": false})).unwrap(), json!(false));
+        // A tool alone in its slot, an unknown tool, a bad flag.
+        assert!(app.run("window.floatTools", json!({"tool": "ellipse"})).is_err());
+        assert!(app.run("window.floatTools", json!({"tool": "nope"})).is_err());
+        assert!(app.run("window.floatTools", json!({})).is_err());
+        assert!(app.run("window.floatTools", json!({"tool": "pen", "floating": "yes"})).is_err());
+        assert!(app.ui.floating_flyouts.is_empty());
+    }
+
+    #[test]
+    fn workspaces_keep_floating_flyouts_and_reset_puts_them_back() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("window.floatTools", json!({"tool": "pen"})).unwrap();
+        app.run("window.workspace.new", json!({"name": "Strips"})).unwrap();
+        app.run("window.workspace", json!({"name": "Essentials"})).unwrap();
+        assert!(app.ui.floating_flyouts.is_empty(), "the built-in workspaces float none");
+        app.run("window.workspace", json!({"name": "Strips"})).unwrap();
+        assert_eq!(app.ui.floating_flyouts.iter().map(|f| f.tools[0].as_str()).collect::<Vec<_>>(), ["pen"]);
+        // Workspaces saved before floating strips load without any.
+        let mut old = serde_json::to_value(crate::workspaces::Workspace::default()).unwrap();
+        old.as_object_mut().unwrap().remove("floatingFlyouts");
+        assert!(serde_json::from_value::<crate::workspaces::Workspace>(old).unwrap().floating_flyouts.is_empty());
+    }
+
+    #[test]
+    fn loaded_floating_flyouts_keep_known_tools_one_strip_per_group() {
+        let f = |tools: &[&str]| crate::state::FloatingFlyout { tools: tools.iter().map(|s| s.to_string()).collect(), pos: [0.0, 0.0] };
+        let ui = crate::state::UiState {
+            floating_flyouts: vec![f(&["pen", "nope", "addAnchor"]), f(&["pen", "addAnchor"]), f(&["nope"]), f(&[])],
+            ..Default::default()
+        };
+        let ui = ui.sanitized();
+        assert_eq!(ui.floating_flyouts.iter().map(|f| f.tools.join(",")).collect::<Vec<_>>(), ["pen,addAnchor"]);
+    }
+
+    #[test]
+    fn floating_flyouts_survive_saved_preferences_and_stay_on_screen() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.ui.floating_flyouts.push(crate::state::FloatingFlyout { tools: vec!["pen".into(), "addAnchor".into()], pos: [5000.0, 10.0] });
+        let saved = serde_json::to_value(&app.ui).unwrap();
+        let back: crate::state::UiState = serde_json::from_value(saved.clone()).unwrap();
+        assert_eq!(back.floating_flyouts.len(), 1);
+        // Preferences saved before floating flyouts load without any.
+        let mut old = saved;
+        old.as_object_mut().unwrap().remove("floating_flyouts");
+        assert!(serde_json::from_value::<crate::state::UiState>(old).unwrap().floating_flyouts.is_empty());
+        let ctx = egui::Context::default();
+        shapes_button(&mut app, &ctx);
+        frame(&mut app, &ctx, 1.0, vec![]);
+        let r = ctx.memory(|m| m.area_rect(floating_area("pen"))).unwrap();
+        assert!(r.right() <= 400.5 && r.left() >= 0.0 && r.top() >= 0.0, "on screen: {r:?}");
+        // A position that isn't a number puts it near the toolbar.
+        app.ui.floating_flyouts[0].pos = [f32::NAN, f32::INFINITY];
+        frame(&mut app, &ctx, 2.0, vec![]);
+        let r = ctx.memory(|m| m.area_rect(floating_area("pen"))).unwrap();
+        assert!(r.min.x.is_finite() && r.min.y.is_finite() && r.left() >= 0.0, "on screen: {r:?}");
+    }
+
+    /// Hover `at` for two seconds, coming from elsewhere: the texts painted meanwhile.
+    fn hovered_texts(app: &mut VectorcraftApp, ctx: &egui::Context, t0: f64, at: Pos2) -> Vec<String> {
+        fn texts(s: &egui::Shape, out: &mut Vec<String>) {
+            match s {
+                egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
+                egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
+                _ => {}
+            }
+        }
+        let mut shown = vec![];
+        for i in 0..20 {
+            let events = match i {
+                0 => vec![Event::PointerGone],
+                1 => vec![Event::PointerMoved(at)],
+                _ => vec![],
+            };
+            let time = t0 + f64::from(i) * 0.1;
+            let raw = egui::RawInput {
+                events,
+                time: Some(time),
+                screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(400.0, 1200.0))),
+                ..Default::default()
+            };
+            let mut out = ctx.run_ui(raw, |ui| {
+                crate::prefs_dialog::apply_runtime(app, ui.ctx());
+                show(app, ui);
+            });
+            out.textures_delta.clear();
+            out.shapes.iter().for_each(|c| texts(&c.shape, &mut shown));
+        }
+        shown
+    }
+
+    #[test]
+    fn a_floating_flyouts_buttons_have_tool_tips_when_tool_tips_are_on() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        let tools: Vec<String> = ["rectangle", "roundedRectangle", "star"].map(String::from).to_vec();
+        app.ui.floating_flyouts.push(crate::state::FloatingFlyout { tools, pos: [150.0, 600.0] });
+        let ctx = egui::Context::default();
+        shapes_button(&mut app, &ctx);
+        frame(&mut app, &ctx, 1.0, vec![]);
+        let strip = ctx.memory(|m| m.area_rect(floating_area("rectangle"))).unwrap();
+        let star = pos2(strip.left() + STRIP_BUTTON.x * 2.5, strip.center().y);
+        let tip = tl!("Star Tool").to_string();
+        assert!(hovered_texts(&mut app, &ctx, 10.0, star).contains(&tip), "on by default");
+        app.session.prefs.show_tool_tips = false;
+        assert!(!hovered_texts(&mut app, &ctx, 20.0, star).contains(&tip), "off: no tool tip");
+        app.session.prefs.show_tool_tips = true;
+        assert!(hovered_texts(&mut app, &ctx, 30.0, star).contains(&tip), "on again");
+    }
 }

crates/ui-egui/src/widgets.rs

@@ -4,8 +4,8 @@ use egui::{Color32, CornerRadius, Pos2, Rect, Response, Sense, Stroke, StrokeKin
 use vectorcraft_color::{BlendMode, Color, Paint};
 use vectorcraft_doc::Unit;
 
-use crate::icons;
 use crate::theme::{self, Tokens};
+use crate::{icons, scrub};
 
 /// Square icon button; `selected` draws the pressed well.
 pub fn icon_button(ui: &mut Ui, icon: &str, tip: &str, selected: bool, size: f32) -> Response {
@@ -87,8 +87,20 @@ pub fn divider(ui: &mut Ui) {
     ui.add_space(6.0);
 }
 
+/// A label in the panels' text colour; before a numeric field it scrubs the field
+/// ([`scrub`]).
 pub fn dim_label(ui: &mut Ui, text: &str) -> Response {
-    dim_name(ui, tl!(text))
+    let resp = dim_name(ui, tl!(text));
+    scrub::note_label(ui, resp.rect);
+    resp
+}
+
+/// A field's label in other styles (`text` as given): before a numeric field it scrubs the field
+/// ([`scrub`]).
+pub fn field_label(ui: &mut Ui, text: impl Into<egui::WidgetText>) -> Response {
+    let resp = ui.label(text);
+    scrub::note_label(ui, resp.rect);
+    resp
 }
 
 /// [`dim_label`] for a name that is user or file data (a swatch, style, artboard or font name):
@@ -110,10 +122,10 @@ pub fn num_field(ui: &mut Ui, id: impl std::hash::Hash + std::fmt::Debug, value:
         buf = shown.clone();
     }
     take_dialog_focus(ui, id, &buf);
-    let resp = ui
+    let (rect, resp) = ui
         .allocate_ui_with_layout(vec2(width, 26.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
             ui.set_min_width(width);
-            egui::Frame::NONE
+            let framed = egui::Frame::NONE
                 .fill(t.input)
                 .stroke(Stroke::new(1.0, if editing { t.accent } else { t.input_border }))
                 .corner_radius(CornerRadius::same(2))
@@ -128,16 +140,26 @@ pub fn num_field(ui: &mut Ui, id: impl std::hash::Hash + std::fmt::Debug, value:
                             .font(egui::FontId::proportional(12.5))
                             .text_color(t.text_strong),
                     )
-                })
-                .inner
+                });
+            (framed.response.rect, framed.inner)
         })
         .inner;
     select_all_on_focus(ui, &resp, &buf);
-    // ↑/↓ step in the field's unit.
+    // ↑/↓ step in the field's unit; a drag on its label scrubs it.
     let stepped = step_with_arrows(ui, &resp, &mut buf, |b| Some(unit.from_pt(unit.parse(b)?)), |v| unit.format(unit.to_pt(v)));
+    let scrubbed = scrub::field(ui, id, rect, &buf, value.map(|v| unit.from_pt(v)), STEP_DECIMALS);
     let commit = resp.lost_focus() && buf != shown;
     ui.data_mut(|d| d.insert_temp(id, buf.clone()));
-    if commit { unit.parse(&buf) } else { stepped.map(|v| unit.to_pt(v)) }
+    if commit { unit.parse(&buf) } else { stepped.or(scrubbed).map(|v| unit.to_pt(v)) }
+}
+
+/// The places a stepped value in a unit field keeps (no 12.300000001).
+const STEP_DECIMALS: i32 = 3;
+
+/// `v` rounded to `decimals` places.
+pub(crate) fn round_to(v: f64, decimals: i32) -> f64 {
+    let scale = 10f64.powi(decimals.clamp(0, 6));
+    (v * scale).round() / scale
 }
 
 /// ↑/↓ in focused numeric field `resp` step the number `buf` shows (`read` parses it, `show`
@@ -163,8 +185,8 @@ fn step_with_arrows(ui: &Ui, resp: &Response, buf: &mut String, read: impl Fn(&s
     if steps == 0.0 {
         return None;
     }
-    // Rounded as fields show it (no 12.300000001).
-    let v = ((read(buf)? + steps) * 1000.0).round() / 1000.0;
+    // Rounded as fields show it.
+    let v = round_to(read(buf)? + steps, STEP_DECIMALS);
     *buf = show(v);
     ui.data_mut(|d| d.insert_temp(resp.id, buf.clone()));
     select_all(ui, resp.id, buf);
@@ -184,6 +206,11 @@ pub(crate) fn take_dialog_focus(ui: &Ui, id: egui::Id, text: &str) {
     if ui.is_sizing_pass() || ui.data_mut(|d| d.remove_temp::<bool>(dialog_focus_flag())).is_none() {
         return;
     }
+    focus_field(ui, id, text);
+}
+
+/// Give text field `id` the keyboard focus with all of `text` selected.
+pub(crate) fn focus_field(ui: &Ui, id: egui::Id, text: &str) {
     select_all(ui, id, text);
     ui.memory_mut(|m| m.request_focus(id));
 }
@@ -209,16 +236,17 @@ fn select_all_on_focus(ui: &Ui, resp: &Response, text: &str) {
 }
 
 /// The recessed text box of the panel fields showing `shown`, `rows` lines tall (1: single line),
-/// its text kept under `id` while it has focus. Returns the text (as edited) and the response.
-fn recessed_text(ui: &mut Ui, id: egui::Id, shown: &str, width: f32, rows: usize) -> (String, Response) {
+/// its text kept under `id` while it has focus. Returns the text (as edited), the text edit's
+/// response and the box.
+fn recessed_text(ui: &mut Ui, id: egui::Id, shown: &str, width: f32, rows: usize) -> (String, Response, Rect) {
     let t = Tokens::get(ui.ctx());
     let editing = ui.memory(|m| m.has_focus(id));
     let mut buf: String = if editing { ui.data_mut(|d| d.get_temp::<String>(id)).unwrap_or_else(|| shown.to_string()) } else { shown.to_string() };
     let height = 26.0 + 16.0 * (rows.max(1) - 1) as f32;
-    let resp = ui
+    let (rect, resp) = ui
         .allocate_ui_with_layout(vec2(width, height), egui::Layout::left_to_right(egui::Align::Center), |ui| {
             ui.set_min_width(width);
-            egui::Frame::NONE
+            let framed = egui::Frame::NONE
                 .fill(t.input)
                 .stroke(Stroke::new(1.0, if editing { t.accent } else { t.input_border }))
                 .corner_radius(CornerRadius::same(2))
@@ -233,12 +261,12 @@ fn recessed_text(ui: &mut Ui, id: egui::Id, shown: &str, width: f32, rows: usize
                             .font(egui::FontId::proportional(12.5))
                             .text_color(t.text_strong),
                     )
-                })
-                .inner
+                });
+            (framed.response.rect, framed.inner)
         })
         .inner;
     ui.data_mut(|d| d.insert_temp(id, buf.clone()));
-    (buf, resp)
+    (buf, resp, rect)
 }
 
 /// A recessed text field showing `value` (blank when `None`: the selection's values differ),
@@ -247,7 +275,7 @@ fn recessed_text(ui: &mut Ui, id: egui::Id, shown: &str, width: f32, rows: usize
 pub fn text_field(ui: &mut Ui, id: impl std::hash::Hash + std::fmt::Debug, value: Option<&str>, width: f32, rows: usize) -> Option<String> {
     let id = ui.id().with(id);
     let shown = value.unwrap_or_default();
-    let (buf, resp) = recessed_text(ui, id, shown, width, rows);
+    let (buf, resp, _) = recessed_text(ui, id, shown, width, rows);
     (resp.lost_focus() && buf.trim() != shown).then(|| buf.trim().to_string())
 }
 
@@ -257,6 +285,7 @@ pub fn label_row(ui: &mut Ui, label: &str, label_width: f32, add: impl FnOnce(&m
         let (r, _) = ui.allocate_exact_size(vec2(label_width, 24.0), Sense::hover());
         let t = Tokens::get(ui.ctx());
         ui.painter().text(r.left_center(), egui::Align2::LEFT_CENTER, tl!(label), egui::FontId::proportional(12.5), t.text);
+        scrub::note_label(ui, r);
         add(ui);
     });
 }
@@ -288,14 +317,14 @@ pub fn mixed_field(
         vectorcraft_doc::parse_number(&bare.replace(['%', '°'], ""))
     };
     let shown = value.map(show).unwrap_or_default();
-    let (mut buf, resp) = recessed_text(ui, id, &shown, width, 1);
+    let (mut buf, resp, rect) = recessed_text(ui, id, &shown, width, 1);
     select_all_on_focus(ui, &resp, &buf);
-    // ↑/↓ step at the field's precision (a count ignores Ctrl/Cmd's tenth).
-    let stepped = step_with_arrows(ui, &resp, &mut buf, read, show).map(|v| {
-        let scale = 10f64.powi(decimals.min(6) as i32);
-        (v * scale).round() / scale
-    });
-    if resp.lost_focus() && buf != shown { read(&buf) } else { stepped.filter(|&v| Some(v) != value) }
+    // ↑/↓ step at the field's precision (a count ignores Ctrl/Cmd's tenth); a drag on its label
+    // scrubs it.
+    let decimals = decimals.min(6) as i32;
+    let stepped = step_with_arrows(ui, &resp, &mut buf, read, show).map(|v| round_to(v, decimals));
+    let scrubbed = scrub::field(ui, id, rect, &buf, value, decimals);
+    if resp.lost_focus() && buf != shown { read(&buf) } else { stepped.or(scrubbed).filter(|&v| Some(v) != value) }
 }
 
 /// Draw a paint preview (swatch chip) into `rect`.
@@ -530,6 +559,39 @@ pub(crate) fn combo<R>(
         .inner
 }
 
+/// A popover anchored to `resp`, opened and closed by `toggle` (usually `resp.clicked()`), and
+/// closed by Escape, a click outside it and outside any popup it opened, or a frame in which its
+/// anchor isn't shown. Use it instead of `egui::Popup::menu` when the popover holds dropdowns or
+/// popups of its own: egui remembers one open popup at a time, so opening a dropdown inside a
+/// remembered popup would close the popup (and the dropdown with it). This one keeps its open
+/// state itself: the last frame it was open in.
+pub fn popover<R>(resp: &Response, toggle: bool, content: impl FnOnce(&mut Ui) -> R) -> Option<R> {
+    let ctx = &resp.ctx;
+    let id = resp.id.with("popover");
+    let frame = ctx.cumulative_frame_nr();
+    let was_open = ctx.data(|d| d.get_temp::<u64>(id)).is_some_and(|f| f + 1 >= frame);
+    let mut open = if toggle {
+        !was_open
+    } else {
+        // Popups (this one and those it opened) are on foreground layers; a click anywhere
+        // else closes it.
+        let clicked_elsewhere = ctx
+            .input(|i| i.pointer.any_click().then(|| i.pointer.interact_pos()).flatten())
+            .is_some_and(|pos| ctx.layer_id_at(pos).is_none_or(|l| l.order != egui::Order::Foreground));
+        was_open && !clicked_elsewhere
+    };
+    let inner =
+        egui::Popup::menu(resp).id(id).open_bool(&mut open).close_behavior(egui::PopupCloseBehavior::IgnoreClicks).show(content).map(|r| r.inner);
+    ctx.data_mut(|d| {
+        if open {
+            d.insert_temp(id, frame);
+        } else {
+            d.remove::<u64>(id);
+        }
+    });
+    inner
+}
+
 /// 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.
@@ -1102,7 +1164,7 @@ pub fn opt_field(ui: &mut Ui, id: impl std::hash::Hash + std::fmt::Debug, value:
     let editing = ui.memory(|m| m.has_focus(id));
     let mut buf: String = if editing { ui.data_mut(|d| d.get_temp::<String>(id)).unwrap_or_else(|| shown.clone()) } else { shown.clone() };
     let enabled = ui.is_enabled();
-    let resp = egui::Frame::NONE
+    let framed = egui::Frame::NONE
         .fill(t.input)
         .stroke(Stroke::new(1.0, if editing { t.accent } else { t.input_border }))
         .corner_radius(CornerRadius::same(2))
@@ -1116,15 +1178,16 @@ pub fn opt_field(ui: &mut Ui, id: impl std::hash::Hash + std::fmt::Debug, value:
                     .font(egui::FontId::proportional(12.5))
                     .text_color(if enabled { t.text_strong } else { t.text_disabled }),
             )
-        })
-        .inner;
+        });
+    let resp = framed.inner;
     select_all_on_focus(ui, &resp, &buf);
+    let scrubbed = scrub::field(ui, id, framed.response.rect, &buf, value.map(|v| unit.from_pt(v)), STEP_DECIMALS);
     ui.data_mut(|d| d.insert_temp(id, buf.clone()));
     if resp.lost_focus() && buf != shown {
         let s = buf.trim();
         if s.is_empty() { Some(None) } else { unit.parse(s).map(Some) }
     } else {
-        None
+        scrubbed.map(|v| Some(unit.to_pt(v)))
     }
 }
 

crates/ui-egui/src/workspaces.rs

@@ -7,8 +7,8 @@ use std::sync::atomic::Ordering;
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 
-use crate::state::{Dialog, DockTab, UiState};
-use crate::theme::{self, Tokens};
+use crate::state::{Dialog, DockTab, FloatingFlyout, UiState};
+use crate::theme::Tokens;
 use crate::{VectorcraftApp, widgets};
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -27,6 +27,8 @@ pub struct Workspace {
     pub dock_collapsed: bool,
     pub open_panel: Option<String>,
     pub status_bar: bool,
+    /// Tool groups torn off the toolbar into floating strips (built-in workspaces: none).
+    pub floating_flyouts: Vec<FloatingFlyout>,
 }
 
 impl Default for Workspace {
@@ -120,6 +122,7 @@ pub fn capture(ui: &UiState, name: &str) -> Workspace {
         dock_collapsed: ui.dock_collapsed,
         open_panel: ui.open_panel.clone(),
         status_bar: ui.status_bar,
+        floating_flyouts: ui.floating_flyouts.clone(),
     }
 }
 
@@ -136,6 +139,7 @@ pub fn apply(ui: &mut UiState, w: &Workspace) {
     ui.dock_collapsed = w.dock_collapsed;
     ui.open_panel = w.open_panel.clone();
     ui.status_bar = w.status_bar;
+    ui.floating_flyouts = w.floating_flyouts.clone();
     ui.flyout = None;
     ui.workspace = w.name.clone();
 }
@@ -318,79 +322,66 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
     let t = Tokens::get(ctx);
     let (mut ok, mut cancel) = (false, false);
     let mut action: Option<(&str, Value)> = None;
-    egui::Area::new(egui::Id::new("modal-dim")).order(egui::Order::Middle).fixed_pos(egui::pos2(0.0, 0.0)).show(ctx, |ui| {
-        ui.allocate_rect(ctx.content_rect(), egui::Sense::click());
-    });
     let manage = d.kind == "manageWorkspaces";
-    egui::Window::new("Workspace")
-        .id(egui::Id::new("dialog-workspace"))
-        .order(egui::Order::Foreground)
-        .collapsible(false)
-        .resizable(false)
-        .title_bar(false)
-        .anchor(egui::Align2::CENTER_CENTER, [0.0, -40.0])
-        .frame(egui::Frame::window(&ctx.global_style()).fill(t.panel).inner_margin(egui::Margin::same(22)))
-        .show(ctx, |ui| {
-            ui.set_width(340.0);
-            ui.label(
-                egui::RichText::new(if manage { tl!("Manage Workspaces") } else { tl!("New Workspace") }).font(theme::semibold(16.0)).color(t.text),
-            );
-            ui.add_space(12.0);
-            if manage {
-                egui::Frame::NONE.fill(t.input).stroke(egui::Stroke::new(1.0, t.input_border)).inner_margin(egui::Margin::same(4)).show(ui, |ui| {
-                    ui.set_min_height(140.0);
-                    ui.set_width(ui.available_width());
-                    for n in names(&app.ui) {
-                        let builtin = is_builtin(&n);
-                        let shown = crate::panels::label_or_name(&n, builtin);
-                        let text = if builtin { egui::RichText::new(shown).color(t.text_dim) } else { egui::RichText::new(shown).color(t.text) };
-                        if ui.selectable_label(d.str("selected") == n, text).clicked() && !builtin {
-                            d.fields.insert("selected".into(), json!(n));
-                            d.fields.insert("name".into(), json!(n));
-                        }
+    crate::dialogs::modal::show(ctx, "Workspace", egui::Id::new("dialog-workspace"), -40.0, 22, |ui| {
+        ui.set_width(340.0);
+        crate::dialogs::modal::heading(ui, if manage { tl!("Manage Workspaces") } else { tl!("New Workspace") });
+        ui.add_space(12.0);
+        if manage {
+            egui::Frame::NONE.fill(t.input).stroke(egui::Stroke::new(1.0, t.input_border)).inner_margin(egui::Margin::same(4)).show(ui, |ui| {
+                ui.set_min_height(140.0);
+                ui.set_width(ui.available_width());
+                for n in names(&app.ui) {
+                    let builtin = is_builtin(&n);
+                    let shown = crate::panels::label_or_name(&n, builtin);
+                    let text = if builtin { egui::RichText::new(shown).color(t.text_dim) } else { egui::RichText::new(shown).color(t.text) };
+                    if ui.selectable_label(d.str("selected") == n, text).clicked() && !builtin {
+                        d.fields.insert("selected".into(), json!(n));
+                        d.fields.insert("name".into(), json!(n));
                     }
-                });
-                ui.add_space(8.0);
-                let sel = d.str("selected");
-                ui.horizontal(|ui| {
-                    let mut name = d.str("name");
-                    if ui.add(egui::TextEdit::singleline(&mut name).desired_width(180.0)).changed() {
-                        d.fields.insert("name".into(), json!(name));
-                    }
-                    if ui.button(tl!("New")).on_hover_text(tl!("Save the current layout under this name")).clicked() {
-                        action = Some(("window.workspace.new", json!({"name": d.str("name")})));
-                    }
-                    ui.add_enabled_ui(!sel.is_empty(), |ui| {
-                        if ui.button(tl!("Rename")).clicked() {
-                            action = Some(("window.workspace.rename", json!({"name": sel, "to": d.str("name")})));
-                        }
-                        if ui.button(tl!("Delete")).clicked() {
-                            action = Some(("window.workspace.delete", json!({"name": sel})));
-                        }
-                    });
-                });
-            } else {
-                ui.horizontal(|ui| {
-                    ui.label(egui::RichText::new(tl!("Name:")).color(t.text_dim));
-                    let mut name = d.str("name");
-                    let r = ui.add(egui::TextEdit::singleline(&mut name).desired_width(240.0));
-                    if r.changed() {
-                        d.fields.insert("name".into(), json!(name));
-                    }
-                });
-                ui.label(egui::RichText::new(tl!("Saves the current bars, toolbar and panel layout.")).color(t.text_dim).size(11.0));
-            }
-            ui.add_space(16.0);
-            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-                if widgets::primary_button(ui, tl!("OK")).clicked() {
-                    ok = true;
-                }
-                ui.add_space(8.0);
-                if !manage && widgets::secondary_button(ui, tl!("Cancel")).clicked() {
-                    cancel = true;
                 }
             });
+            ui.add_space(8.0);
+            let sel = d.str("selected");
+            ui.horizontal(|ui| {
+                let mut name = d.str("name");
+                if ui.add(egui::TextEdit::singleline(&mut name).desired_width(180.0)).changed() {
+                    d.fields.insert("name".into(), json!(name));
+                }
+                if ui.button(tl!("New")).on_hover_text(tl!("Save the current layout under this name")).clicked() {
+                    action = Some(("window.workspace.new", json!({"name": d.str("name")})));
+                }
+                ui.add_enabled_ui(!sel.is_empty(), |ui| {
+                    if ui.button(tl!("Rename")).clicked() {
+                        action = Some(("window.workspace.rename", json!({"name": sel, "to": d.str("name")})));
+                    }
+                    if ui.button(tl!("Delete")).clicked() {
+                        action = Some(("window.workspace.delete", json!({"name": sel})));
+                    }
+                });
+            });
+        } else {
+            ui.horizontal(|ui| {
+                ui.label(egui::RichText::new(tl!("Name:")).color(t.text_dim));
+                let mut name = d.str("name");
+                let r = ui.add(egui::TextEdit::singleline(&mut name).desired_width(240.0));
+                if r.changed() {
+                    d.fields.insert("name".into(), json!(name));
+                }
+            });
+            ui.label(egui::RichText::new(tl!("Saves the current bars, toolbar and panel layout.")).color(t.text_dim).size(11.0));
+        }
+        ui.add_space(16.0);
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if widgets::primary_button(ui, tl!("OK")).clicked() {
+                ok = true;
+            }
+            ui.add_space(8.0);
+            if !manage && widgets::secondary_button(ui, tl!("Cancel")).clicked() {
+                cancel = true;
+            }
         });
+    });
     if !manage && ctx.input(|i| i.key_pressed(egui::Key::Enter)) {
         ok = true;
     }

docs/control-protocol.md

@@ -192,6 +192,14 @@ pop the panel out next to the column like the other icon panels (`ui.dock_collap
 `ui.inspect`); expanding with one popped out shows its tab. The state is saved with the preferences and in user
 workspaces; the built-in workspaces expand the dock.
 
+Floating tool groups: dragging or clicking the tear-off bar down a tool group's flyout (or releasing the long press
+that opened it over the bar) floats the group as a strip of tool buttons, moved by the same bar and put back in the
+toolbar by the × at its top; `window.floatTools {tool, floating?}` does the same for the group of the current
+layout holding `tool` (omitted toggles; a tool alone in its slot is an error). While a group floats, the presses
+that open its flyout raise the strip instead. The strips (`ui.floating_flyouts` in `ui.inspect`: the group's tools
+and the strip's top-left corner) are saved with the preferences and in user workspaces; the built-in workspaces
+float none.
+
 Flatten Transparency: `ui.flattenTransparencyDialog` opens the `flattenTransparency` dialog for the selection
 (fields `preset`: a preset name, setting it loads that preset's options; the option keys of
 `object.flattenTransparency`: `balance` 0–100, `lineArtPpi` and `gradientPpi` 1–2400, `textToOutlines`,

docs/mcp.md

@@ -1147,7 +1147,9 @@ The Selection & Anchor Display and General preferences apply to `pointer_gesture
 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`.
+`anchorSize` (1–7), `gridColor`, `gridStyle`, `gridsInBack`, `guideColor`, `guideStyle`, `recentFontsCount` and
+`scrubNumericFields` (on: a horizontal drag on a numeric field's label steps the field, one undo step per drag; the
+control channel's `ui.drag` scrubs).
 
 ## Type preferences
 
@@ -2027,6 +2029,25 @@ undo step. Object › Transform › Scale, the Scale tool and the Transform pane
 {"name":"run_command","arguments":{"command":"text.reshapeArea","params":{"id":42,"anchors":[[0,2]],"dx":40,"dy":60}}}
 ```
 
+## Moving and flipping type on a path
+
+Type on a path flows between a start and an end bracket, stored as fractions of its path's length.
+`type.pathOptions {start?, end?, flip?, effect?, alignToPath?, spacing?, ids?}` sets them and the rest of Type on a
+Path Options: `end: null` puts the end bracket back at the end of the path (or once round a closed one); `flip`
+then turns the type to the other side of its path, the path running the other way and the brackets swapping ends so
+the type keeps its stretch of the path; `alignToPath` runs the `ascender`, `descender`, `center` or `baseline` (the
+default) along the path; `spacing` (points) closes glyphs up round the outside of curves and opens them up round the
+inside. With none of them it queries the first selected type on a path:
+`{start, end, flip: false, effect, alignToPath, spacing}`. The Options dialog shows Effect, Flip, Align to Path and
+Spacing and leaves the brackets where they are. As in the reference app, the Selection and Direct Selection tools
+show selected type on a path's brackets: dragging the start or end bracket (`pointer_gesture`) sets where the type
+begins or ends, dragging the centre bracket slides the type along its path and, dragged across the path, flips it
+(with Cmd/Ctrl held it only slides). Each is one undo step.
+
+```json
+{"name":"run_command","arguments":{"command":"type.pathOptions","params":{"start":0.25,"end":0.75,"flip":true}}}
+```
+
 ## Constrain proportions
 
 The link between W and H in the Transform panel, the Properties panel and the Control bar is the