Fix #444: tool cursors are OS cursors, so the pointer no longer trails over the canvas

Over the canvas the window hid the system cursor and painted the tool's
cursor glyph into its own frame. That glyph reached the screen only after
the frame was rendered, queued (two frames by default) and composited, so
on Windows it visibly trailed the real pointer, on any GPU: the "sluggish
mouse" of the report. Frame times were not the cause (0.4 ms empty,
1.5 ms median on a 20 000-path document, and no repaints while idle).

- cursors: the glyphs are collected as shapes, tessellated by egui and
  rasterized into straight-alpha RGBA bitmaps (anti-aliased, hotspot on a
  pixel corner), cached per cursor and display scale so the same Arc is
  handed over every frame and egui-winit keeps its OS cursor.
- canvas: on Windows and Linux the tool cursor goes to the OS through
  ctx.set_cursor_image; the system moves it itself. macOS (bitmaps sized
  in points) and the web (no bitmap cursors in eframe) keep painting it.
- app: the wgpu surface queues one frame instead of two (LOW_LATENCY):
  the GPU only composites the CPU-rendered canvas, so everything drawn in
  the window follows the pointer a frame sooner.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

Cargo.lock

@@ -4649,6 +4649,7 @@ dependencies = [
  "unicode-script",
  "vectorcraft-doc",
  "vectorcraft-geom",
+ "windows-registry",
  "write-fonts",
 ]
 
@@ -5421,6 +5422,17 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-registry"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
+dependencies = [
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
 [[package]]
 name = "windows-result"
 version = "0.4.1"

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), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429); see [Honest assessment](#honest-assessment-2026-10-05))._
+_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444); see [Honest assessment](#honest-assessment-2026-10-05))._
 
 ## Where we are
 
@@ -95,10 +95,11 @@ 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).
+  - Localised UI: menus (in-window and native), panels, dialogs, toolbar and Preferences read from per-language catalogs (`crates/ui-egui/src/i18n`, see `docs/development.md`); Traditional Chinese (Taiwan), Simplified Chinese (mainland), Japanese and Spanish ship complete, and Czech and Brazilian Portuguese cover every menu label (and more), with system-locale detection on macOS, Windows, Linux and the web (the browser's languages, or `?lang=`), a VectorCraft ▸ Language menu and a Language preference. Names are never translated (fonts and their styles, layers, artboards, saved presets, user libraries, custom workspaces, recent files, plug-ins).
   - Native macOS menu bar, vector tool cursors, a ⌘K command palette, middle-button panning with any tool.
   - macOS: Finder opens every format File › Open reads with VectorCraft (double-click, Open With, a drop on the Dock icon, `open -a`), at launch or while it runs; the release and `cargo xtask bundle` apps share one `Info.plist` that declares those document types, owning only VectorCraft's own formats.
   - A canvas context menu: right-click selects the object under the pointer and lists what applies to the selection (Undo/Redo, clipboard, group, isolation, join, Remove Anchor Points when anchors are selected, masks, compound paths, guides, Transform, Arrange, Select, Export Selection), or the view commands on empty canvas.
@@ -118,7 +119,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers).
   - **Cutting:** Eraser, Scissors, Knife, Mirror & Cut, Line Cut and Rectangle Cut (real geometry, compound paths keep their holes).
   - **Transform:** Rotate, Reflect, Scale, Shear (click or Alt-click snaps the reference point to anchors and centres; Alt-click opens the tool's dialog, and a drag with Alt down at the release, from the press or pressed mid-drag, transforms a copy), Reshape, Free Transform (free and perspective distort and shear, switched by the keys held during a handle drag).
-  - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout; with Direct Selection, select corner anchors to show and round just those corners (#381). Each corner keeps its own radius and kind (Round, Inverted Round, Chamfer): Alt-click a widget to cycle the kind, double-click it for the Corners dialog, and the Properties and Transform radius fields set the selected corners (`object.setLiveShape {corners, radius, kind}`). Corners stay circular when the rectangle is scaled unevenly or along its own sides when rotated (the radius keeps its size, or scales by the mean scale with Scale Corners on); only a shear distorts them.
+  - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout; with Direct Selection, select corner anchors to show and round just those corners (#381). Each corner keeps its own radius and kind (Round, Inverted Round, Chamfer): Alt-click a widget to cycle the kind, double-click it for the Corners dialog, and the Properties and Transform radius fields set the selected corners (`object.setLiveShape {corners, radius, kind}`). Corners stay circular when the rectangle is scaled unevenly or along its own sides when rotated (the radius keeps its size, or scales by the mean scale with Scale Corners on); only a shear distorts them. On a rectangle that isn't square every corner is the same circle: a radius past half the shorter side stops there for all of them, the widgets sit on the corners as drawn and turn the edited corners red at that limit, CSS export writes the drawn radii, and rectangles saved stretched by older versions get circular corners when their corners are next set (#442).
   - **Pen:** Alt pressed in the middle of dragging out an anchor splits its handles and keeps the curve already shaped into it (only the outgoing handle follows the pointer); Space held while dragging out an anchor moves it, handles and all. Clicking the last anchor of the path being drawn retracts its outgoing handle (convert cursor), and dragging from it pulls out a new one on its own. Auto Add/Delete: over a selected path, a click on a segment adds an anchor and a click on an anchor deletes it (add and delete cursors); Shift held, or Preferences › General › Disable Auto Add/Delete, starts a new path instead.
   - **Graphs:** Column, Stacked Column, Bar, Stacked Bar, Line, Area, Scatter, Pie and Radar graph tools with Graph Data and Graph Type.
   - **Other:** Eyedropper, Gradient annotator, Artboard (Alt-drag duplicates an artboard, and its art with Move/Copy Artwork with Artboard on), Measure, Type, Hand, Zoom, Rotate View.
@@ -126,16 +127,16 @@ 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) 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.
+- **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese and Spanish (neutral international Spanish, for every `es-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); Spanish also translates status-bar and error messages as they are shown (`@msg` templates, every message literal tested; the messages themselves stay English for agents); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech and Spanish ones from the bundled UI fonts. The web app follows the browser's languages (or `?lang=`). The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width and an opening bracket starting a wrapped line flush with its start, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline; 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}`).
@@ -154,7 +155,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs Illustrator's AGM/CoolType prologs (resource categories, `resourceforall`, `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters, `cshow`, metadata skipped with `flushfile`), so Illustrator 30 EPS files open as vectors, and falls back to its palette TIFF preview. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole).
   - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours; files copied in a file manager paste as art (SVG, PDF, EMF/WMF, bitmaps) on every desktop platform, and Linux/Wayland reads the compositor's clipboard (#398).
 - **Performance:** 20k shapes + 1k texts render in 27 ms per full-retina frame (7.8 ms zoomed), 7× faster than the first version. The UI thread never blocks. The web build is 7.1 MB gzipped.
-- **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so the desktop app asks for the power-saving GPU by default (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306). Preferences › Performance › Graphics Processor (`gpuPreference`) or `WGPU_POWER_PREF` picks the discrete one; Help › About and `ui.inspect` name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369).
+- **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so the desktop app asks for the power-saving GPU by default (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306). Preferences › Performance › Graphics Processor (`gpuPreference`) or `WGPU_POWER_PREF` picks the discrete one; Help › About and `ui.inspect` name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369). On Windows and Linux the tools' cursors are OS cursors (bitmaps rasterized once per display scale), which the system moves itself: painted into the window, they trailed the pointer by the frames waiting to be shown, and the window now queues one frame instead of two (#444). macOS and the web still paint them (macOS sizes cursor bitmaps in points, eframe has no bitmap cursors on the web).
 - **Tests and robustness:** ~2,840 automated tests: model-based property tests, a junk-parameter sweep over every command, import fuzzing (SVG, PDF, libraries), golden renders, and MCP end-to-end tests over stdio. Shipped code never panics (workspace lints and a rollback safety net; see `docs/development.md`).
 
 ## Milestones and estimates
@@ -168,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 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 |
+| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options (with Width/Height), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (fonts registered with Windows outside its font folders, the XDG and Flatpak host font folders on Linux, and fonts installed while the app runs, listed when it comes back to the front; searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import, variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects and Options with draggable start/centre/end brackets (slide, flip), tab stops + Tabs panel, Hebrew/Arabic bidirectional text and Paragraph Direction done; tab leaders, spell check, vertical type pending | 45–60 |
 | M8 | Transform & distort (Puppet Warp, Liquify tools, Envelopes, Blends, Perspective Grid) | ✅ done (M8.1–M8.20 on 2026-10-06, fidelity pass): Liquify Tool Options with one shared brush, pen pressure, hold-to-apply, a safe scope and incremental strokes; tool options that last; Puppet Warp rotation, multi-select, Control bar and a rest-shape session that follows Undo; Width tool on compound paths; Envelope dialogs with preview, Reset with Warp/Mesh, full Envelope Options, type/images/symbols/appearance/gradients/patterns distorted on canvas and in every export, warps that keep their frame, Edit Contents, mesh handles and Control bar; Blend Options, anchor-targeted Blend tool, editable spine, keys picked on the canvas, faithful interpolation and knockout; Perspective Grid with Define Grid, presets, lock/snap/rulers, widgets, the 1–4 plane switch, movable planes, Perspective Selection scale/copy/perpendicular/Transform Again, and type and symbols truly projected with Edit Text. Left: Anti-Alias and Preserve Shape output, warp-envelope point editing, brush interpolation in blends, Free Transform/Scale/Reflect along a rotated box | 2–4 |
 | M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder and Color Adjustments; SVG Filters, Document Raster Effects Settings, 3D pending | 86–135 |
 | M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG `<pattern>`/PDF export) and live Repeat (radial/grid/mirror) done; brushes/symbols in progress | 23–37 |
@@ -196,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 |

apps/vectorcraft-web/src/main.rs

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

apps/vectorcraft-web/src/web.rs

@@ -9,6 +9,7 @@ use vectorcraft_engine::Session;
 use vectorcraft_engine::cmd::fileio;
 use vectorcraft_engine::cmd::recovery::{self, Hold, RecoveryStore};
 use vectorcraft_ui_egui::graphics::GraphicsLoss;
+use vectorcraft_ui_egui::i18n;
 use vectorcraft_ui_egui::place::{DropTarget, PlaceArrival, PlaceInbox};
 use vectorcraft_ui_egui::print::{PrintJob, PrintService, Printer};
 use vectorcraft_ui_egui::{Services, VectorcraftApp};
@@ -49,6 +50,7 @@ pub fn start() {
         log::error!("missing <canvas id=\"{CANVAS_ID}\">");
         return;
     };
+    detect_language();
     wasm_bindgen_futures::spawn_local(async move {
         // Before the first frame, which looks for copies a crash left behind.
         let locks = WebLocks::start(RECOVERY_PREFIX).await;
@@ -131,6 +133,27 @@ fn web_options() -> eframe::WebOptions {
     options
 }
 
+/// Tell the UI the browser's languages (`?lang=es` in the address first, as `VECTORCRAFT_LOCALE`
+/// does on the desktop) before the first frame, so the Automatic interface language follows the
+/// browser; and show the loading text in that language.
+fn detect_language() {
+    let mut tags: Vec<String> = query_param("lang").into_iter().collect();
+    if let Some(navigator) = web_sys::window().map(|w| w.navigator()) {
+        tags.extend(navigator.languages().iter().filter_map(|v| v.as_string()));
+        tags.extend(navigator.language());
+    }
+    i18n::set_system_locales(tags.as_slice());
+    if let Some(el) = element(LOADING_ID) {
+        el.set_text_content(Some(i18n::message(i18n::system_lang(), "Loading VectorCraft…").as_str()));
+    }
+}
+
+/// The value of `name=` in the address's query, if given.
+fn query_param(name: &str) -> Option<String> {
+    let query = query();
+    query.trim_start_matches('?').split('&').find_map(|kv| kv.strip_prefix(name)?.strip_prefix('=').map(str::to_string)).filter(|v| !v.is_empty())
+}
+
 fn query() -> String {
     web_sys::window().and_then(|w| w.location().search().ok()).unwrap_or_default()
 }
@@ -215,7 +238,7 @@ fn notice(lines: &[&str]) {
     el.set_text_content(None);
     for line in lines {
         if let Ok(p) = document.create_element("p") {
-            p.set_text_content(Some(line));
+            p.set_text_content(Some(i18n::message(i18n::system_lang(), line).as_str()));
             // Best effort: the log has the message too.
             el.append_child(&p).ok();
         }

apps/vectorcraft/src/main.rs

@@ -358,6 +358,9 @@ fn main() -> eframe::Result {
     #[cfg(feature = "wgpu")]
     let options = {
         let mut options = options;
+        // One frame queued, not two: the canvas is rasterized on the CPU and the GPU only
+        // composites it, so the window answers the pointer a frame sooner (#444).
+        options.wgpu_options.surface = eframe::egui_wgpu::SurfaceConfig::LOW_LATENCY;
         if let eframe::egui_wgpu::WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup {
             create.power_preference = power;
         }

crates/doc/src/node.rs

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

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

@@ -1038,6 +1038,9 @@ fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
     s.edit("Live Shape", |d, sel| {
         for id in &ids {
             let Some(NodeKind::Path { path, live: Some(live), .. }) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
+            // Radii are document lengths and corners circular, also on a rectangle from a file
+            // that kept an uneven scale in its transform (#442).
+            live.fold_scale();
             let partial = sel.anchors.get_mut(id);
             let picked = corners.unwrap_or_else(|| live.picked_corners(partial.as_deref()));
             let (layout, selected) = (live.anchor_corners(), partial.as_deref().map(|a| live.corners_of(a)));

crates/engine/src/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_livecorners.rs

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

crates/geom/src/shapes.rs

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

crates/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/svg/src/css.rs

@@ -10,7 +10,7 @@ use serde::{Deserialize, Serialize};
 use vectorcraft_color::{BlendMode, Color, GradientKind, GradientPaint, Paint};
 use vectorcraft_doc::{AppearanceItem, CharStyle, Document, Justify, LineCap, LiveShape, Node, NodeId, NodeKind, StrokeAlign, StrokeLayer, TextKind};
 use vectorcraft_effects::RasterFx;
-use vectorcraft_geom::shapes::CornerKind;
+use vectorcraft_geom::shapes::{self, CornerKind};
 use vectorcraft_geom::{Affine, PathData, Point, Rect};
 
 use crate::export::sanitize_id;
@@ -600,19 +600,21 @@ fn corners(path: &PathData, live: Option<&LiveShape>) -> Option<Corners> {
         let [_, b, c, _, _, _] = xf.as_coeffs();
         b.abs() < 1e-9 && c.abs() < 1e-9
     };
-    match live {
+    // Sizes and radii in document units.
+    match live.map(LiveShape::folded).as_ref() {
         // CSS rounds corners only: an inverted round or chamfered corner has no border radius.
-        Some(LiveShape::Rectangle { radii, kinds, xf, .. })
+        Some(LiveShape::Rectangle { w, h, radii, kinds, xf })
             if upright(xf) && radii.iter().zip(kinds).all(|(r, k)| *r <= 0.0 || *k == CornerKind::Round) =>
         {
-            let [a, _, _, d, _, _] = xf.as_coeffs();
-            let s = (a * d).abs().sqrt();
+            // The radii as drawn, none past half the shorter side (CSS draws one further when its
+            // neighbours leave room).
+            let radii = radii.map(|r| shapes::fitted_corner_radius(*w, *h, r));
             if radii.iter().all(|r| *r <= 0.0) {
                 Some(Corners::Square)
             } else if radii.iter().all(|r| (r - radii[0]).abs() < 1e-9) {
-                Some(Corners::Round(vec![radii[0] * s]))
+                Some(Corners::Round(vec![radii[0]]))
             } else {
-                Some(Corners::Round(radii.iter().map(|r| r.max(0.0) * s).collect()))
+                Some(Corners::Round(radii.to_vec()))
             }
         }
         Some(LiveShape::Ellipse { pie, xf, .. }) if upright(xf) => {

crates/svg/tests/css_rules.rs

@@ -84,6 +84,13 @@ fn live_corners_give_per_corner_radii_and_only_round_ones() {
         kinds[1] = CornerKind::InvertedRound;
     }
     assert!(prop(&one(&d, id, &CssOptions::default()), "border-radius").is_none(), "CSS can't cut a corner in");
+    // A radius past half the shorter side is drawn at half of it (#442), and exported so: CSS
+    // would draw it larger, its neighbours leaving room.
+    if let Some(NodeKind::Path { live: Some(LiveShape::Rectangle { radii, kinds, .. }), .. }) = d.node_mut(id).map(|n| &mut n.kind) {
+        *radii = [60.0, 8.0, 0.0, 4.0];
+        *kinds = Default::default();
+    }
+    assert_eq!(prop(&one(&d, id, &CssOptions::default()), "border-radius"), Some("25px 8px 0 4px"));
 }
 
 #[test]

crates/text/Cargo.toml

@@ -31,3 +31,8 @@ test-fonts = ["dep:write-fonts"]
 
 [dev-dependencies]
 write-fonts = "0.48"
+
+# Fonts registered with Windows outside its font folders ("install as shortcut", installers);
+# MIT OR Apache-2.0, a safe wrapper of the registry API from the windows-rs project.
+[target.'cfg(windows)'.dependencies]
+windows-registry = "0.6"

crates/text/src/fontdb.rs

@@ -238,9 +238,9 @@ pub struct FontDb {
     catalog: RwLock<Catalog>,
     /// The installed faces by PostScript name (documents name fonts so: PDF, EPS, .ai).
     postscript: RwLock<PostScriptNames>,
-    /// The folders the system font scan reads (the platform's font folders for [`FontDb::global`]).
+    /// Where the system font scan looks.
     #[cfg_attr(target_arch = "wasm32", allow(dead_code))]
-    font_dirs: Vec<PathBuf>,
+    font_paths: FontPaths,
     /// The installed fonts' other names (localized, legacy, PostScript) by normalized name.
     aliases: RwLock<HashMap<String, Vec<Alias>>>,
     /// Set once the font folders have been scanned. Lookups by family name wait for the first
@@ -254,6 +254,41 @@ pub struct FontDb {
     /// System fallback state: characters no system font covers.
     #[cfg(not(target_arch = "wasm32"))]
     sys: Mutex<SysFallback>,
+    /// What the last scan read, to tell when fonts were installed or removed since.
+    #[cfg(not(target_arch = "wasm32"))]
+    stamp: Mutex<Option<ScanStamp>>,
+}
+
+/// Where a database's system font scan looks: folders (read with their subfolders) and font files.
+#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
+enum FontPaths {
+    Fixed(Vec<PathBuf>),
+    /// The platform's ([`system_font_dirs`]), looked up again by each scan: fonts registered and
+    /// font folders added since count too.
+    System,
+}
+
+#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
+impl FontPaths {
+    fn get(&self) -> Vec<PathBuf> {
+        match self {
+            FontPaths::Fixed(paths) => paths.clone(),
+            FontPaths::System => system_font_dirs(),
+        }
+    }
+}
+
+/// What a system font scan read: the paths it started from, and when each folder it listed (and
+/// font file named by itself) last changed. Installing or removing a font changes its folder's.
+#[cfg(not(target_arch = "wasm32"))]
+struct ScanStamp {
+    paths: Vec<PathBuf>,
+    modified: Vec<(PathBuf, Option<std::time::SystemTime>)>,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn modified(path: &Path) -> Option<std::time::SystemTime> {
+    std::fs::metadata(path).and_then(|m| m.modified()).ok()
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -747,7 +782,8 @@ pub(crate) fn sfnt_of(tables: &[(&[u8; 4], &[u8])]) -> Option<Vec<u8>> {
     Some(font)
 }
 
-/// The platform's font folders (the system's and the user's), scanned by [`FontDb::global`].
+/// The platform's font folders (the system's and the user's) and, on Windows, the font files
+/// registered with it outside them, scanned by [`FontDb::global`].
 pub fn system_font_dirs() -> Vec<PathBuf> {
     let mut dirs: Vec<PathBuf> = Vec::new();
     if cfg!(target_arch = "wasm32") {
@@ -755,7 +791,7 @@ pub fn system_font_dirs() -> Vec<PathBuf> {
     }
     let home = std::env::var_os("HOME").map(PathBuf::from);
     if cfg!(target_os = "macos") {
-        dirs.extend(["/System/Library/Fonts", "/Library/Fonts"].map(Into::into));
+        dirs.extend(["/System/Library/Fonts", "/Library/Fonts", "/Network/Library/Fonts"].map(Into::into));
         if let Some(h) = &home {
             dirs.push(h.join("Library/Fonts"));
         }
@@ -769,19 +805,65 @@ pub fn system_font_dirs() -> Vec<PathBuf> {
     } else if cfg!(windows) {
         let root = std::env::var_os("WINDIR").map(PathBuf::from).unwrap_or_else(|| "C:\\Windows".into());
         dirs.push(root.join("Fonts"));
+        // Fonts installed for the current user only (what Install does without administrator rights).
         if let Some(l) = std::env::var_os("LOCALAPPDATA") {
             dirs.push(PathBuf::from(l).join("Microsoft\\Windows\\Fonts"));
         }
+        #[cfg(windows)]
+        dirs.extend(registered_font_files(&dirs));
     } else {
         dirs.extend(["/usr/share/fonts", "/usr/local/share/fonts"].map(Into::into));
+        // The XDG data folders' `fonts` (fontconfig's user folder; Flatpak, Snap, NixOS and Guix
+        // list their own data folders), relative paths ignored as the XDG spec says.
+        let xdg = |var| std::env::var_os(var).map(|v| std::env::split_paths(&v).filter(|p| p.is_absolute()).collect::<Vec<_>>()).unwrap_or_default();
+        let data_home = xdg("XDG_DATA_HOME").into_iter().next().or_else(|| home.as_ref().map(|h| h.join(".local/share")));
+        dirs.extend(data_home.into_iter().chain(xdg("XDG_DATA_DIRS")).map(|d| d.join("fonts")));
         if let Some(h) = &home {
             dirs.push(h.join(".fonts"));
-            dirs.push(h.join(".local/share/fonts"));
         }
+        // In a Flatpak sandbox, the host's fonts (system, local and the user's).
+        dirs.extend(["/run/host/fonts", "/run/host/local-fonts", "/run/host/user-fonts"].map(Into::into));
     }
     dirs
 }
 
+/// The registry key listing the fonts installed on Windows (for all users under the local
+/// machine's key, for the current user under theirs): one value per face, holding its file's
+/// name in the Windows font folder or its full path.
+#[cfg(windows)]
+const REGISTERED_FONTS: &str = r"Software\Microsoft\Windows NT\CurrentVersion\Fonts";
+
+/// The font files registered with Windows outside `font_dirs` (fonts installed as shortcuts to
+/// where they are, or by programs into their own folders), which apps find by the registry.
+#[cfg(windows)]
+fn registered_font_files(font_dirs: &[PathBuf]) -> Vec<PathBuf> {
+    use windows_registry::{CURRENT_USER, LOCAL_MACHINE};
+    let values = [LOCAL_MACHINE, CURRENT_USER].into_iter().filter_map(|root| root.open(REGISTERED_FONTS).ok()).flat_map(|key| {
+        // A value that isn't a string isn't a font file.
+        key.values().map(|vs| vs.filter_map(|(_, v)| String::try_from(v).ok()).collect::<Vec<_>>()).unwrap_or_default()
+    });
+    fonts_outside(values, font_dirs)
+}
+
+/// The full paths among `registered` (font registrations' data) that aren't in `font_dirs`
+/// (ignoring case, as Windows paths do), sorted and deduplicated. File names alone are files in
+/// the Windows font folder, which is scanned anyway. The count is capped.
+#[cfg(any(windows, test))]
+pub(crate) fn fonts_outside(registered: impl IntoIterator<Item = String>, font_dirs: &[PathBuf]) -> Vec<PathBuf> {
+    const MAX_REGISTERED: usize = 1 << 16;
+    let lower = |p: &Path| PathBuf::from(p.to_string_lossy().to_lowercase());
+    let dirs: Vec<PathBuf> = font_dirs.iter().map(|d| lower(d)).collect();
+    let mut files: Vec<PathBuf> = registered
+        .into_iter()
+        .take(MAX_REGISTERED)
+        .map(PathBuf::from)
+        .filter(|p| p.is_absolute() && !dirs.iter().any(|d| lower(p).starts_with(d)))
+        .collect();
+    files.sort();
+    files.dedup();
+    files
+}
+
 fn make_face(bytes: FontBytes, index: u32, spec: FaceStyle, path: Option<std::path::PathBuf>) -> Option<FontFace> {
     let data: &[u8] = match &bytes {
         FontBytes::Static(b) => b,
@@ -860,8 +942,13 @@ fn style_italic(style: &str) -> bool {
 type MenuFamilies = (Arc<[String]>, Arc<[String]>);
 
 impl FontDb {
-    /// A database holding the bundled fonts, whose system font scan reads `font_dirs`.
+    /// A database holding the bundled fonts, whose system font scan reads `font_dirs` (folders,
+    /// read with their subfolders, and font files).
     pub fn with_font_dirs(font_dirs: Vec<PathBuf>) -> Self {
+        Self::new(FontPaths::Fixed(font_dirs))
+    }
+
+    fn new(font_paths: FontPaths) -> Self {
         let mut faces = Vec::new();
         // The bundled fonts, then the Japanese craft-fonts faces (when built with them), Mincho
         // first: fallbacks for Japanese text after the requested and bundled fonts.
@@ -878,7 +965,7 @@ impl FontDb {
             outlines: Mutex::new(HashMap::new()),
             catalog: RwLock::new(Catalog::new()),
             postscript: RwLock::new(PostScriptNames::new()),
-            font_dirs,
+            font_paths,
             aliases: RwLock::new(HashMap::new()),
             #[cfg(not(target_arch = "wasm32"))]
             cataloged: std::sync::OnceLock::new(),
@@ -887,6 +974,8 @@ impl FontDb {
             generation: AtomicU64::new(0),
             #[cfg(not(target_arch = "wasm32"))]
             sys: Mutex::new(SysFallback { enabled: true, ..Default::default() }),
+            #[cfg(not(target_arch = "wasm32"))]
+            stamp: Mutex::new(None),
         }
     }
 
@@ -906,7 +995,7 @@ impl FontDb {
     /// [`FontDb::scan_in_background`]).
     pub fn global() -> &'static FontDb {
         static DB: std::sync::OnceLock<FontDb> = std::sync::OnceLock::new();
-        DB.get_or_init(|| FontDb::with_font_dirs(system_font_dirs()))
+        DB.get_or_init(|| FontDb::new(FontPaths::System))
     }
 
     fn read_faces(&self) -> std::sync::RwLockReadGuard<'_, Vec<Arc<FontFace>>> {
@@ -1042,50 +1131,78 @@ impl FontDb {
         first.unwrap_or_else(|| self.scan_font_dirs())
     }
 
+    /// Whether fonts were installed or removed since the last scan (a font folder or font file it
+    /// read changed, or a new one is to be read), for [`FontDb::load_system_fonts`] to catalog
+    /// them. Costs a look at each folder the scan read, not a scan. `false` before the first scan
+    /// and on wasm.
+    pub fn installed_fonts_changed(&self) -> bool {
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            let paths = self.font_paths.get();
+            let stamp = self.stamp.lock().unwrap_or_else(|e| e.into_inner());
+            stamp.as_ref().is_some_and(|s| s.paths != paths || s.modified.iter().any(|(p, t)| modified(p) != *t))
+        }
+        #[cfg(target_arch = "wasm32")]
+        false
+    }
+
     #[cfg(not(target_arch = "wasm32"))]
     fn scan_font_dirs(&self) -> usize {
         let mut catalog = Catalog::new();
         let mut aliases: HashMap<String, Vec<Alias>> = HashMap::new();
         let mut postscript = PostScriptNames::new();
         let mut n = 0;
-        let mut stack = self.font_dirs.clone();
+        let paths = self.font_paths.get();
+        let mut modified_at = Vec::new();
+        let mut files = Vec::new();
+        let mut stack = paths.clone();
         // Each folder once, however links lead back to it.
         let mut visited = std::collections::HashSet::new();
         while let Some(d) = stack.pop() {
             if !visited.insert(std::fs::canonicalize(&d).unwrap_or_else(|_| d.clone())) {
                 continue;
             }
-            let Ok(rd) = std::fs::read_dir(&d) else { continue };
+            // Before listing it: a font installed meanwhile changes it after this.
+            modified_at.push((d.clone(), modified(&d)));
+            // Not a folder: a font file named by itself (or nothing, yet).
+            let Ok(rd) = std::fs::read_dir(&d) else {
+                files.push(d);
+                continue;
+            };
             for e in rd.flatten() {
                 let p = e.path();
                 if p.is_dir() {
                     stack.push(p);
-                    continue;
-                }
-                let ext = p.extension().and_then(|e| e.to_str()).map(|e| e.to_ascii_lowercase());
-                if !matches!(ext.as_deref(), Some("ttf" | "otf" | "ttc" | "otc")) {
-                    continue;
-                }
-                for FaceStyle { family, style, keys, weight, italic, traits, .. } in file_face_names(&p) {
-                    for (k, a) in Alias::of(&family, &style, &keys) {
-                        aliases.entry(k).or_default().push(a);
-                    }
-                    // `keys.postscript` is normalized ([`norm`]), as `by_postscript_name` looks it up.
-                    for ps in &keys.postscript {
-                        postscript.insert(ps.clone(), (family.clone(), style.clone()));
-                    }
-                    let entry = catalog.entry(family.to_ascii_lowercase()).or_default();
-                    entry.traits.get_or_insert(traits);
-                    if entry.name.is_empty() {
-                        entry.name = family;
-                    }
-                    let (weight, italic) = (weight.unwrap_or_else(|| style_weight(&style)), italic || style_italic(&style));
-                    entry.faces.push(CatalogFace { style, path: p.clone(), weight, italic });
-                    n += 1;
+                } else {
+                    files.push(p);
                 }
             }
         }
+        for p in files {
+            let ext = p.extension().and_then(|e| e.to_str()).map(|e| e.to_ascii_lowercase());
+            if !matches!(ext.as_deref(), Some("ttf" | "otf" | "ttc" | "otc")) {
+                continue;
+            }
+            for FaceStyle { family, style, keys, weight, italic, traits, .. } in file_face_names(&p) {
+                for (k, a) in Alias::of(&family, &style, &keys) {
+                    aliases.entry(k).or_default().push(a);
+                }
+                // `keys.postscript` is normalized ([`norm`]), as `by_postscript_name` looks it up.
+                for ps in &keys.postscript {
+                    postscript.insert(ps.clone(), (family.clone(), style.clone()));
+                }
+                let entry = catalog.entry(family.to_ascii_lowercase()).or_default();
+                entry.traits.get_or_insert(traits);
+                if entry.name.is_empty() {
+                    entry.name = family;
+                }
+                let (weight, italic) = (weight.unwrap_or_else(|| style_weight(&style)), italic || style_italic(&style));
+                entry.faces.push(CatalogFace { style, path: p.clone(), weight, italic });
+                n += 1;
+            }
+        }
         log::debug!("cataloged {n} system font faces");
+        *self.stamp.lock().unwrap_or_else(|e| e.into_inner()) = Some(ScanStamp { paths, modified: modified_at });
         *self.catalog.write().unwrap_or_else(|e| e.into_inner()) = catalog;
         *self.aliases.write().unwrap_or_else(|e| e.into_inner()) = aliases;
         *self.postscript.write().unwrap_or_else(|e| e.into_inner()) = postscript;

crates/text/src/tests_sysfonts.rs

@@ -4,6 +4,7 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 use super::*;
+use crate::fontdb::fonts_outside;
 
 const FAMILY: &str = "Sysfont Sans3";
 
@@ -184,3 +185,55 @@ fn installed_faces_are_found_by_postscript_name() {
     assert_eq!(db.by_postscript_name("sourcesans3-regular"), Some((FAMILY.to_string(), "Regular".to_string())), "any case");
     assert_eq!(db.by_postscript_name("Rounded-X-Mplus-1c-black"), None);
 }
+
+/// Windows lists fonts installed as shortcuts, or by programs into their own folders, by their
+/// files' full paths: those files are scanned too (#443).
+#[test]
+fn a_font_file_named_by_itself_is_scanned() {
+    let dir = font_dir("file");
+    let db = FontDb::with_font_dirs(vec![dir.join("Sub/Sysfont-Bold.TTF"), dir.join("No Such Font.ttf")]);
+    assert_eq!(db.styles(FAMILY), ["Bold"]);
+    assert_eq!(db.load_system_fonts(), 1);
+}
+
+#[test]
+fn registered_fonts_outside_the_font_folders_are_their_full_paths() {
+    let dir = std::env::temp_dir().join("Fonts");
+    let elsewhere = std::env::temp_dir().join("Downloads").join("Montserrat-Regular.ttf");
+    let registered = [
+        // A file in the Windows font folder, by name.
+        "arial.ttf".into(),
+        // A file in a font folder (ignoring case).
+        dir.join("Lato-Regular.ttf").to_string_lossy().to_uppercase(),
+        elsewhere.to_string_lossy().into_owned(),
+        elsewhere.to_string_lossy().into_owned(),
+    ];
+    assert_eq!(fonts_outside(registered, &[dir]), [elsewhere]);
+}
+
+/// Fonts installed while the app runs are found when it comes back to the front, without
+/// scanning every time (#443).
+#[test]
+fn the_database_tells_when_fonts_were_installed_or_removed_since_its_scan() {
+    let dir = font_dir("changed");
+    let db = FontDb::with_font_dirs(vec![dir.clone(), dir.join("Later")]);
+    assert!(!db.installed_fonts_changed(), "nothing to compare with before the first scan");
+    assert!(!db.has_family("Other Sans 33"));
+    assert!(!db.installed_fonts_changed());
+    // Past the file system's clock tick, so the folders' times differ from the scan's.
+    let tick = || std::thread::sleep(std::time::Duration::from_millis(50));
+    tick();
+    std::fs::write(dir.join("Sub/Other.ttf"), renamed_to("SourceSans3-Regular.ttf", "Other Sans 33")).unwrap();
+    assert!(db.installed_fonts_changed(), "a font installed into a subfolder");
+    assert_eq!(db.load_system_fonts(), 3);
+    assert!(db.has_family("Other Sans 33") && !db.installed_fonts_changed());
+    tick();
+    std::fs::create_dir_all(dir.join("Later")).unwrap();
+    assert!(db.installed_fonts_changed(), "a font folder that didn't exist");
+    db.load_system_fonts();
+    tick();
+    std::fs::remove_file(dir.join("Sysfont-Regular.ttf")).unwrap();
+    assert!(db.installed_fonts_changed(), "a font removed");
+    assert_eq!(db.load_system_fonts(), 2);
+    assert_eq!(db.styles(FAMILY), ["Bold"]);
+}

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

@@ -7,8 +7,8 @@
 
 use serde_json::{Map, Value, json};
 use vectorcraft_doc::{Document, LiveShape, NodeId, NodeKind, Selection};
-use vectorcraft_geom::shapes::CornerKind;
-use vectorcraft_geom::{Affine, Point, Vec2};
+use vectorcraft_geom::shapes::{self, CornerKind};
+use vectorcraft_geom::{Affine, BezPath, Point, Rect, Vec2};
 
 use crate::{Action, Overlay, PointerEvent, ToolContext};
 
@@ -47,18 +47,20 @@ impl CornerWidgets {
             return None;
         }
         let Some(NodeKind::Path { live: Some(live), .. }) = doc.node(id).map(|n| &n.kind) else { return None };
-        let LiveShape::Rectangle { w, h, radii, kinds, xf } = live else { return None };
-        let (w, h, radii, kinds, xf) = (*w, *h, *radii, *kinds, *xf);
+        // In document units, as `object.setLiveShape` edits them.
+        let LiveShape::Rectangle { w, h, radii, kinds, xf } = live.folded() else { return None };
         // Screen pixels per shape unit along each side (the shape may be scaled or skewed).
         let c = xf.as_coeffs();
         let (px, py) = (Vec2::new(c[0], c[1]).hypot() * zoom, Vec2::new(c[2], c[3]).hypot() * zoom);
         if xf.determinant().abs() < 1e-12 || (w * px).min(h * py) < MIN_SIDE_PX {
             return None;
         }
+        // Each widget sits on its corner's diagonal, at the centre of the arc as drawn.
         let points = std::array::from_fn(|k| {
             let ((fx, fy), (sx, sy)) = CORNERS[k];
-            let ix = radii[k].max(MIN_INSET_PX / px).min(w / 2.0);
-            let iy = radii[k].max(MIN_INSET_PX / py).min(h / 2.0);
+            let r = shapes::fitted_corner_radius(w, h, radii[k]);
+            let ix = r.max(MIN_INSET_PX / px).min(w / 2.0);
+            let iy = r.max(MIN_INSET_PX / py).min(h / 2.0);
             xf * Point::new(fx * w + sx * ix, fy * h + sy * iy)
         });
         Some(Self { id, w, h, radii, kinds, xf, points, shown: live.picked_corners(selection.partial(id)) })
@@ -138,6 +140,8 @@ pub struct CornerDrag {
     began: bool,
     alt: bool,
     radius: f64,
+    /// The pointer went past fully round: the corners are at their largest radius.
+    at_limit: bool,
     at: Point,
 }
 
@@ -146,18 +150,41 @@ impl CornerDrag {
     pub fn hit(cx: &ToolContext, ev: &PointerEvent) -> Option<Self> {
         let (widgets, p) = (CornerWidgets::for_tool(cx)?, ev.pos);
         let corner = widgets.hit(p, cx.tol(5.0))?;
-        Some(Self { widgets, corner, start: p, began: false, alt: ev.mods.alt, radius: widgets.radii[corner], at: p })
+        Some(Self { widgets, corner, start: p, began: false, alt: ev.mods.alt, radius: widgets.radii[corner], at_limit: false, at: p })
     }
 
     /// The start radius (as drawn: no larger than fits) plus the pointer's travel along the
-    /// corner's inward diagonal (in the shape's own units), from square to fully round.
-    fn radius_at(&self, p: Point) -> f64 {
+    /// corner's inward diagonal (in the shape's own units), from square to fully round; and
+    /// whether the travel reached fully round (the limit every corner shares).
+    fn radius_at(&self, p: Point) -> (f64, bool) {
         let w = &self.widgets;
         let inv = w.xf.inverse();
         let d = inv * p - inv * self.start;
         let (_, (sx, sy)) = CORNERS[self.corner];
-        let max = (w.w.abs().min(w.h.abs()) / 2.0).max(0.0);
-        (w.radii[self.corner].min(max) + (d.x * sx + d.y * sy) / 2.0).clamp(0.0, max)
+        let max = shapes::max_corner_radius(w.w, w.h);
+        let r = shapes::fitted_corner_radius(w.w, w.h, w.radii[self.corner]) + (d.x * sx + d.y * sy) / 2.0;
+        (r.min(max).max(0.0), max > 0.0 && r >= max)
+    }
+
+    /// The edited corners' cuts at the dragged radius, in document coordinates.
+    fn edited_corners(&self) -> BezPath {
+        let w = &self.widgets;
+        let rect = Rect::new(0.0, 0.0, w.w, w.h);
+        let radii = std::array::from_fn(|k| if w.shown[k] { self.radius } else { w.radii[k] });
+        let corner_of = shapes::rectangle_anchor_corners(rect, radii);
+        let path = shapes::rectangle_with_corners(rect, radii, w.kinds).transformed(w.xf);
+        let mut out = BezPath::new();
+        let Some(sp) = path.subpaths.first() else { return out };
+        // A corner's cut is the segment between its two anchors (the last one, for the top-left).
+        for i in 0..sp.segment_count() {
+            let (a, b) = (corner_of.get(i), corner_of.get(i + 1).or(corner_of.first()));
+            if a == b && a.is_some_and(|k| w.shown.get(*k) == Some(&true)) {
+                let c = sp.segment(i);
+                out.move_to(c.p0);
+                out.curve_to(c.p1, c.p2, c.p3);
+            }
+        }
+        out
     }
 
     pub fn drag(&mut self, cx: &ToolContext, p: Point) -> Vec<Action> {
@@ -169,7 +196,7 @@ impl CornerDrag {
             self.began = true;
             out.push(Action::Begin("Corner Radius".into()));
         }
-        self.radius = self.radius_at(p);
+        (self.radius, self.at_limit) = self.radius_at(p);
         self.at = p;
         out.push(Action::Preview("object.setLiveShape".into(), self.widgets.command("radius", json!(self.radius))));
         out
@@ -186,12 +213,16 @@ impl CornerDrag {
         }
     }
 
-    /// The radius readout next to the pointer.
+    /// The radius readout next to the pointer; at the largest radius, the edited corners in red.
     pub fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
         if !self.began {
             return vec![];
         }
-        vec![Overlay::Measure { p: self.at, text: format!("Radius: {}", cx.len(self.radius)) }]
+        let mut out = vec![Overlay::Measure { p: self.at, text: format!("Radius: {}", cx.len(self.radius)) }];
+        if self.at_limit {
+            out.push(Overlay::Path { path: self.edited_corners(), color: crate::builder::HIGHLIGHT_RED, width: 2.0, dashed: false });
+        }
+        out
     }
 }
 
@@ -204,10 +235,15 @@ mod tests {
 
     /// A live 100 × 100 rectangle at (100, 100) with corner radius `r`.
     fn live_rect(r: f64, xf: Affine) -> (Document, NodeId) {
+        live_shape(100.0, 100.0, r, xf)
+    }
+
+    /// A live `w` × `h` rectangle with corner radius `r`.
+    fn live_shape(w: f64, h: f64, r: f64, xf: Affine) -> (Document, NodeId) {
         let mut d = Document::new(500.0, 500.0);
         let l = d.layers[0].id;
         let id = d.alloc_id();
-        let live = LiveShape::Rectangle { w: 100.0, h: 100.0, radii: [r; 4], kinds: Default::default(), xf };
+        let live = LiveShape::Rectangle { w, h, radii: [r; 4], kinds: Default::default(), xf };
         let mut n = Node::path(id, live.to_path(), Appearance::default_art());
         if let NodeKind::Path { live: slot, .. } = &mut n.kind {
             *slot = Some(live);
@@ -264,6 +300,55 @@ mod tests {
         }
     }
 
+    /// #442: on a 200 × 80 rectangle the widgets sit at the centres of the corners as drawn, also
+    /// with a radius past half the shorter side; a drag past fully round stops every corner there
+    /// and outlines them in red.
+    #[test]
+    fn widgets_of_a_non_square_rectangle_follow_the_drawn_corners() {
+        let (d, id) = live_shape(200.0, 80.0, 60.0, Affine::translate((100.0, 100.0)));
+        let s = selected(id);
+        let w = CornerWidgets::of(&d, &s, 1.0).unwrap();
+        let centres = [Point::new(140.0, 140.0), Point::new(260.0, 140.0), Point::new(260.0, 140.0), Point::new(140.0, 140.0)];
+        assert_eq!(w.points, centres);
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let red = |t: &dyn crate::Tool| {
+            t.overlays(&cx).into_iter().find_map(|o| match o {
+                Overlay::Path { path, color, .. } if color == crate::builder::HIGHLIGHT_RED => Some(path),
+                _ => None,
+            })
+        };
+        let mut t = crate::create("selection");
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 140.0, 140.0));
+        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 200.0, 200.0));
+        assert_eq!(radius(&a[1]), 40.0);
+        // The four arcs, each a quarter circle of radius 40 starting on a side.
+        let arcs = red(t.as_ref()).expect("the limit shows");
+        let starts: Vec<_> =
+            arcs.elements().iter().filter_map(|e| if let vectorcraft_geom::PathEl::MoveTo(p) = e { Some(*p) } else { None }).collect();
+        assert_eq!(starts, [Point::new(260.0, 100.0), Point::new(300.0, 140.0), Point::new(140.0, 180.0), Point::new(100.0, 140.0)]);
+        // Back below the limit, the outline goes.
+        assert_eq!(radius(&t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 130.0, 130.0))[0]), 30.0);
+        assert!(red(t.as_ref()).is_none());
+    }
+
+    /// #442: a rectangle saved stretched (an uneven scale in its transform, before #291) shows its
+    /// widgets and drags its radius in document units, as `object.setLiveShape` sets it.
+    #[test]
+    fn a_stretched_rectangle_drags_its_radius_in_document_units() {
+        // 50 × 80 with 10 pt corners stretched 4 × 1: drawn 200 × 80, a mean radius of 20.
+        let (d, id) = live_shape(50.0, 80.0, 10.0, Affine::translate((100.0, 100.0)) * Affine::scale_non_uniform(4.0, 1.0));
+        let s = selected(id);
+        let w = CornerWidgets::of(&d, &s, 1.0).unwrap();
+        assert_eq!(w.points[0], Point::new(120.0, 120.0));
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let mut t = crate::create("directSelection");
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 120.0, 120.0));
+        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 110.0, 110.0));
+        assert!((radius(&a[1]) - 10.0).abs() < 1e-9, "{a:?}");
+    }
+
     #[test]
     fn drag_follows_a_rotated_shape_and_a_click_does_nothing() {
         // Rotated 90°: the shape's top-left corner is at document (200, 100).

crates/tools/src/lib.rs

@@ -412,6 +412,10 @@ pub enum Cursor {
     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 {
@@ -429,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,
         }
     }

crates/ui-egui/src/canvas.rs

@@ -388,6 +388,13 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
             // Caps Lock gives precise (crosshair) cursors, like Illustrator; env opt-out for system cursors.
             let custom = std::env::var_os("VECTORCRAFT_SYSTEM_CURSORS").is_none();
             match ui.input(|i| i.pointer.hover_pos()) {
+                // An OS cursor: the system moves it at once, where a painted one trails the pointer
+                // (#444). The system cursor stands in for cursors without a glyph.
+                Some(_) if custom && crate::cursors::OS_CURSORS => {
+                    let ppp = ui.ctx().native_pixels_per_point().unwrap_or_else(|| ui.ctx().pixels_per_point());
+                    ui.ctx().set_cursor_image(app.canvas.cursors.get(c, ppp));
+                    cursor_icon(c)
+                }
                 Some(hp) if custom && crate::cursors::paint(&painter, c, hp) => egui::CursorIcon::None,
                 _ => cursor_icon(c),
             }
@@ -423,7 +430,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 +445,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 +591,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 +610,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();
     }
 }

crates/ui-egui/src/chrome.rs

@@ -422,11 +422,13 @@ pub fn status_bar(app: &mut VectorcraftApp, ui: &mut Ui) {
                     // Background saves and exports in progress, else the last message.
                     if let Some(job) = app.background.jobs.first() {
                         let more = app.background.jobs.len() - 1;
-                        let text = if more > 0 { format!("{}… (+{more})", job.label) } else { format!("{}…", job.label) };
+                        let label = crate::i18n::msg(&job.label);
+                        let text = if more > 0 { format!("{label}… (+{more})") } else { format!("{label}…") };
                         ui.label(egui::RichText::new(text).size(11.0).color(t.text));
                         ui.add(egui::Spinner::new().size(12.0).color(t.accent));
                     } else if !app.ui.status.is_empty() {
-                        ui.label(egui::RichText::new(&app.ui.status).size(11.0).color(t.text));
+                        // The message stays English in `ui.status` (agents and tests read it).
+                        ui.label(egui::RichText::new(crate::i18n::msg(&app.ui.status)).size(11.0).color(t.text));
                     }
                 });
             });

crates/ui-egui/src/cursors.rs

@@ -1,21 +1,44 @@
 //! Tool cursors drawn as vector glyphs (egui only offers system cursors). Black shapes with a white
 //! halo, hotspot at `p`, Illustrator's visual grammar: solid arrow (Selection), hollow arrow (Direct
 //! Selection), pen nib with state badges, crosshair for drawing tools, curved arrows for rotate.
+//!
+//! The desktop app shows them as OS cursors ([`Images`]): the system moves those itself, at once,
+//! while a cursor painted into the window follows the pointer a few frames late (#444).
 
-use egui::{Color32, Painter, Pos2, Shape, Stroke, pos2, vec2};
+use egui::epaint::{Mesh, TessellationOptions, Tessellator, Vertex};
+use egui::{Color32, CustomCursorImage, Painter, Pos2, Shape, Stroke, Vec2, pos2, vec2};
 use vectorcraft_tools::Cursor;
 
 const INK: Color32 = Color32::BLACK;
 const HALO: Color32 = Color32::WHITE;
 
-fn poly(p: &Painter, pts: Vec<Pos2>, fill: Color32, stroke: Color32) {
+/// The shapes of one cursor glyph.
+#[derive(Default)]
+struct Ink(Vec<Shape>);
+
+impl Ink {
+    fn add(&mut self, s: Shape) {
+        self.0.push(s);
+    }
+    fn line_segment(&mut self, pts: [Pos2; 2], stroke: Stroke) {
+        self.add(Shape::line_segment(pts, stroke));
+    }
+    fn circle_stroke(&mut self, c: Pos2, r: f32, stroke: Stroke) {
+        self.add(Shape::circle_stroke(c, r, stroke));
+    }
+    fn circle_filled(&mut self, c: Pos2, r: f32, fill: Color32) {
+        self.add(Shape::circle_filled(c, r, fill));
+    }
+}
+
+fn poly(p: &mut Ink, pts: Vec<Pos2>, fill: Color32, stroke: Color32) {
     // Halo first (thicker white outline), then the glyph.
     p.add(Shape::closed_line(pts.clone(), Stroke::new(3.0, HALO)));
     p.add(Shape::convex_polygon(pts.clone(), fill, Stroke::NONE));
     p.add(Shape::closed_line(pts, Stroke::new(1.0, stroke)));
 }
 
-fn line(p: &Painter, a: Pos2, b: Pos2) {
+fn line(p: &mut Ink, a: Pos2, b: Pos2) {
     p.line_segment([a, b], Stroke::new(3.0, HALO));
     p.line_segment([a, b], Stroke::new(1.2, INK));
 }
@@ -25,7 +48,7 @@ fn arrow_points(o: Pos2) -> Vec<Pos2> {
     [(0.0, 0.0), (0.0, 15.0), (3.8, 11.4), (6.4, 17.0), (8.6, 16.0), (6.1, 10.6), (11.0, 10.6)].iter().map(|(x, y)| o + vec2(*x, *y)).collect()
 }
 
-fn arrow(p: &Painter, o: Pos2, hollow: bool) {
+fn arrow(p: &mut Ink, o: Pos2, hollow: bool) {
     let pts = arrow_points(o);
     // The arrow is concave: draw as a filled mesh of two convex parts, then outline.
     p.add(Shape::closed_line(pts.clone(), Stroke::new(3.0, HALO)));
@@ -35,7 +58,7 @@ fn arrow(p: &Painter, o: Pos2, hollow: bool) {
     p.add(Shape::closed_line(pts, Stroke::new(1.0, INK)));
 }
 
-fn crosshair(p: &Painter, o: Pos2) {
+fn crosshair(p: &mut Ink, o: Pos2) {
     for (a, b) in
         [(vec2(-9.0, 0.0), vec2(-2.0, 0.0)), (vec2(2.0, 0.0), vec2(9.0, 0.0)), (vec2(0.0, -9.0), vec2(0.0, -2.0)), (vec2(0.0, 2.0), vec2(0.0, 9.0))]
     {
@@ -43,7 +66,7 @@ fn crosshair(p: &Painter, o: Pos2) {
     }
 }
 
-fn pen(p: &Painter, o: Pos2, badge: &str) {
+fn pen(p: &mut Ink, o: Pos2, badge: &str) {
     // Nib pointing to the top-left hotspot.
     let pts = vec![o, o + vec2(4.0, 12.0), o + vec2(8.0, 16.0), o + vec2(16.0, 8.0), o + vec2(12.0, 4.0)];
     poly(p, pts, INK, INK);
@@ -74,7 +97,7 @@ fn pen(p: &Painter, o: Pos2, badge: &str) {
     }
 }
 
-fn double_arrow(p: &Painter, o: Pos2, dir: egui::Vec2) {
+fn double_arrow(p: &mut Ink, o: Pos2, dir: egui::Vec2) {
     let d = dir.normalized() * 8.0;
     let n = vec2(-d.y, d.x) * 0.45;
     line(p, o - d, o + d);
@@ -83,7 +106,7 @@ fn double_arrow(p: &Painter, o: Pos2, dir: egui::Vec2) {
     }
 }
 
-fn rotate(p: &Painter, o: Pos2) {
+fn rotate(p: &mut Ink, o: Pos2) {
     let pts: Vec<Pos2> = (0..=10)
         .map(|i| {
             let a = std::f32::consts::PI * (0.15 + 0.7 * i as f32 / 10.0);
@@ -98,7 +121,7 @@ fn rotate(p: &Painter, o: Pos2) {
 }
 
 /// Live Corners: the hollow arrow with a rounded-corner badge.
-fn corner_radius(p: &Painter, o: Pos2) {
+fn corner_radius(p: &mut Ink, o: Pos2) {
     arrow(p, o, true);
     let b = o + vec2(12.0, 13.0);
     let mut pts = vec![b + vec2(0.0, 10.0)];
@@ -113,7 +136,7 @@ fn corner_radius(p: &Painter, o: Pos2) {
 
 /// 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) {
+fn path_bracket(p: &mut Ink, 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)];
@@ -128,7 +151,7 @@ fn path_bracket(p: &Painter, o: Pos2) {
 
 /// 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) {
+fn stop_badge(p: &mut Ink, o: Pos2, add: bool) {
     arrow(p, o, false);
     let b = o + vec2(13.0, 13.0);
     line(p, b, b + vec2(6.0, 0.0));
@@ -138,14 +161,14 @@ fn stop_badge(p: &Painter, o: Pos2, add: bool) {
 }
 
 /// A slice badge: a small rectangle cut by a line, at `b` (its top left).
-fn slice_badge(p: &Painter, b: Pos2) {
+fn slice_badge(p: &mut Ink, b: Pos2) {
     let pts = vec![b, b + vec2(8.0, 0.0), b + vec2(8.0, 6.0), b + vec2(0.0, 6.0)];
     poly(p, pts, HALO, INK);
     line(p, b + vec2(4.0, 0.0), b + vec2(4.0, 6.0));
 }
 
 /// The Slice tool: a crosshair with a blade below right of the hotspot.
-fn slice(p: &Painter, o: Pos2) {
+fn slice(p: &mut Ink, o: Pos2) {
     crosshair(p, o);
     let b = o + vec2(7.0, 7.0);
     poly(p, vec![b, b + vec2(9.0, 4.0), b + vec2(10.0, 7.0), b + vec2(3.0, 6.0)], HALO, INK);
@@ -155,7 +178,7 @@ fn slice(p: &Painter, o: Pos2) {
 /// The Width tool: the hollow arrow with a stroke that swells in the middle (a width point),
 /// plus a badge: `+` over a stroke (a drag adds a point), a bar across the swell over a width point
 /// (a drag moves or widens it).
-fn width(p: &Painter, o: Pos2, badge: &str) {
+fn width(p: &mut Ink, o: Pos2, badge: &str) {
     arrow(p, o, true);
     let b = o + vec2(11.0, 18.0);
     let top: Vec<Pos2> = (0..=8)
@@ -179,7 +202,7 @@ fn width(p: &Painter, o: Pos2, badge: &str) {
     }
 }
 
-fn ibeam(p: &Painter, o: Pos2) {
+fn ibeam(p: &mut Ink, o: Pos2) {
     line(p, o + vec2(0.0, -8.0), o + vec2(0.0, 8.0));
     line(p, o + vec2(-3.0, -8.0), o + vec2(3.0, -8.0));
     line(p, o + vec2(-3.0, 8.0), o + vec2(3.0, 8.0));
@@ -188,7 +211,7 @@ fn ibeam(p: &Painter, o: Pos2) {
 
 /// The Blend tool: a crosshair with a square below right of the hotspot, hollow away from art,
 /// filled over an object; over an anchor point a ringed dot (the blend starts there).
-fn blend(p: &Painter, o: Pos2, badge: Cursor) {
+fn blend(p: &mut Ink, o: Pos2, badge: Cursor) {
     crosshair(p, o);
     let b = o + vec2(9.0, 9.0);
     if badge == Cursor::BlendAnchor {
@@ -201,51 +224,327 @@ 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);
 }
 
-/// 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 {
+/// 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: &mut Ink, 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));
+    }
+}
+
+/// The shapes of cursor `c` with its hotspot at `p`; `None` for cursors that stay system cursors
+/// (hand, zoom, busy states).
+fn glyph(c: Cursor, p: Pos2) -> Option<Vec<Shape>> {
+    let ink = &mut Ink::default();
     match c {
-        Cursor::Arrow => arrow(painter, p, false),
-        Cursor::ArrowHollow => arrow(painter, p, true),
+        Cursor::Arrow => arrow(ink, p, false),
+        Cursor::ArrowHollow => arrow(ink, p, true),
         Cursor::Move => {
-            arrow(painter, p, false);
-            double_arrow(painter, p + vec2(15.0, 18.0), vec2(1.0, 0.0));
+            arrow(ink, p, false);
+            double_arrow(ink, p + vec2(15.0, 18.0), vec2(1.0, 0.0));
         }
-        Cursor::Crosshair | Cursor::Eyedropper => crosshair(painter, p),
-        Cursor::ResizeH => double_arrow(painter, p, vec2(1.0, 0.0)),
-        Cursor::ResizeV => double_arrow(painter, p, vec2(0.0, 1.0)),
-        Cursor::ResizeNwSe => double_arrow(painter, p, vec2(1.0, 1.0)),
-        Cursor::ResizeNeSw => double_arrow(painter, p, vec2(1.0, -1.0)),
-        Cursor::Rotate => rotate(painter, p),
-        Cursor::CornerRadius => corner_radius(painter, p),
-        Cursor::Pen => pen(painter, p, "*"),
-        Cursor::PenAdd => pen(painter, p, "+"),
-        Cursor::PenDelete => pen(painter, p, "-"),
-        Cursor::PenClose => pen(painter, p, "o"),
-        Cursor::PenContinue => pen(painter, p, "/"),
-        Cursor::PenConvert => pen(painter, p, "^"),
-        Cursor::Text => ibeam(painter, p),
-        Cursor::AddStop => stop_badge(painter, p, true),
-        Cursor::RemoveStop => stop_badge(painter, p, false),
-        Cursor::Slice => slice(painter, p),
+        Cursor::Crosshair | Cursor::Eyedropper => crosshair(ink, p),
+        Cursor::ResizeH => double_arrow(ink, p, vec2(1.0, 0.0)),
+        Cursor::ResizeV => double_arrow(ink, p, vec2(0.0, 1.0)),
+        Cursor::ResizeNwSe => double_arrow(ink, p, vec2(1.0, 1.0)),
+        Cursor::ResizeNeSw => double_arrow(ink, p, vec2(1.0, -1.0)),
+        Cursor::Rotate => rotate(ink, p),
+        Cursor::CornerRadius => corner_radius(ink, p),
+        Cursor::Pen => pen(ink, p, "*"),
+        Cursor::PenAdd => pen(ink, p, "+"),
+        Cursor::PenDelete => pen(ink, p, "-"),
+        Cursor::PenClose => pen(ink, p, "o"),
+        Cursor::PenContinue => pen(ink, p, "/"),
+        Cursor::PenConvert => pen(ink, p, "^"),
+        Cursor::Text => ibeam(ink, p),
+        Cursor::AddStop => stop_badge(ink, p, true),
+        Cursor::RemoveStop => stop_badge(ink, p, false),
+        Cursor::Slice => slice(ink, p),
         Cursor::SliceSelect => {
-            arrow(painter, p, false);
-            slice_badge(painter, p + vec2(11.0, 14.0));
+            arrow(ink, p, false);
+            slice_badge(ink, p + vec2(11.0, 14.0));
+        }
+        Cursor::Width => width(ink, p, ""),
+        Cursor::WidthAdd => width(ink, p, "+"),
+        Cursor::WidthPoint => width(ink, p, "point"),
+        Cursor::Blend | Cursor::BlendObject | Cursor::BlendAnchor => blend(ink, p, c),
+        Cursor::PathBracket => path_bracket(ink, p),
+        Cursor::ShapeBuilder => shape_builder(ink, p, false),
+        Cursor::ShapeBuilderErase => shape_builder(ink, p, true),
+        _ => return None,
+    }
+    Some(std::mem::take(&mut ink.0))
+}
+
+/// Paint cursor `c` at `p` on the given (foreground) painter, where the window can't show it as an
+/// OS cursor ([`OS_CURSORS`]). Returns false for cursors that stay system cursors.
+pub fn paint(painter: &Painter, c: Cursor, p: Pos2) -> bool {
+    glyph(c, p).map(|shapes| painter.extend(shapes)).is_some()
+}
+
+/// Does the window show the glyphs as OS cursors ([`Images`])? Not on macOS, which sizes a cursor
+/// bitmap in points (a Retina one would show twice as big, or blurred), nor on the web (eframe has no
+/// bitmap cursors there): those paint them into the window ([`paint`]).
+pub const OS_CURSORS: bool = !cfg!(any(target_os = "macos", target_arch = "wasm32"));
+
+/// The cursor bitmaps handed to the OS, by (cursor, pixels per point): each glyph is rasterized
+/// once, and handing the same `Arc` every frame keeps the window's OS cursor instead of making a
+/// new one.
+#[derive(Default)]
+pub struct Images(Vec<(Cursor, f32, CustomCursorImage)>);
+
+impl Images {
+    /// Cursor `c` for a display of `ppp` physical pixels per point; `None` for cursors that stay
+    /// system cursors.
+    pub fn get(&mut self, c: Cursor, ppp: f32) -> Option<CustomCursorImage> {
+        if let Some((.., image)) = self.0.iter().find(|(k, s, _)| *k == c && *s == ppp) {
+            return Some(image.clone());
+        }
+        let image = rasterize(c, ppp)?;
+        // A few dozen glyphs at the scales of the displays the window visited.
+        if self.0.len() >= 128 {
+            self.0.clear();
+        }
+        self.0.push((c, ppp, image.clone()));
+        Some(image)
+    }
+}
+
+/// The largest side of a cursor bitmap, in pixels (the glyphs span under 50 points).
+const MAX_SIDE: f32 = 256.0;
+
+/// Cursor `c` as a straight-alpha RGBA bitmap at `ppp` pixels per point, tessellated (anti-aliased)
+/// as egui would paint it, the hotspot on a pixel corner.
+fn rasterize(c: Cursor, ppp: f32) -> Option<CustomCursorImage> {
+    if !(ppp.is_finite() && ppp > 0.0) {
+        return None;
+    }
+    let shapes = glyph(c, Pos2::ZERO)?;
+    let mut tessellator = Tessellator::new(ppp, TessellationOptions::default(), [1, 1], vec![]);
+    let mut mesh = Mesh::default();
+    for shape in shapes {
+        tessellator.tessellate_shape(shape, &mut mesh);
+    }
+    let bounds = mesh.calc_bounds();
+    // The hotspot must lie inside the bitmap.
+    let min = (bounds.min.to_vec2() * ppp).floor().min(Vec2::ZERO);
+    let max = (bounds.max.to_vec2() * ppp).ceil().max(Vec2::splat(1.0));
+    let size = max - min;
+    if !(size.x <= MAX_SIDE && size.y <= MAX_SIDE) {
+        return None;
+    }
+    let (w, h) = (size.x as usize, size.y as usize);
+    let mut px = vec![[0.0; 4]; w * h];
+    let corner = |v: &Vertex| (v.pos.to_vec2() * ppp - min, v.color);
+    for tri in mesh.indices.chunks_exact(3) {
+        let &[i, j, k] = tri else { continue };
+        if let (Some(a), Some(b), Some(c)) = (mesh.vertices.get(i as usize), mesh.vertices.get(j as usize), mesh.vertices.get(k as usize)) {
+            fill_triangle(&mut px, w, [corner(a), corner(b), corner(c)]);
+        }
+    }
+    let rgba: Vec<u8> = px
+        .iter()
+        .flat_map(|&[r, g, b, a]| {
+            let k = if a > 0.0 { 1.0 / a } else { 0.0 };
+            [r * k, g * k, b * k, a].map(|x| (x * 255.0).round().clamp(0.0, 255.0) as u8)
+        })
+        .collect();
+    Some(CustomCursorImage { rgba: rgba.into(), size: [w as u16, h as u16], hotspot: [-min.x as u16, -min.y as u16] })
+}
+
+/// Blend triangle `t` (pixel positions and premultiplied colours, interpolated across it) over `px`
+/// (premultiplied RGBA, `w` pixels a row) at the pixel centres it covers, as the GPU blends egui's
+/// meshes. A centre on an edge goes to one of the two triangles sharing it, so seams aren't doubled.
+fn fill_triangle(px: &mut [[f32; 4]], w: usize, t: [(Vec2, Color32); 3]) {
+    let edge = |a: Vec2, b: Vec2, p: Vec2| (b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x);
+    let [a, mut b, mut c] = t;
+    let mut area = edge(a.0, b.0, c.0);
+    if area < 0.0 {
+        std::mem::swap(&mut b, &mut c);
+        area = -area;
+    }
+    if area.is_nan() || area <= 1e-6 || w == 0 {
+        return;
+    }
+    // Of the two triangles sharing an edge (walking it in opposite directions), one owns it.
+    let owns = |u: Vec2, v: Vec2| v.y > u.y || (v.y == u.y && v.x > u.x);
+    let h = px.len() / w;
+    let lo = a.0.min(b.0).min(c.0).max(Vec2::ZERO);
+    let hi = a.0.max(b.0).max(c.0).min(vec2(w as f32, h as f32));
+    for y in lo.y.floor() as usize..hi.y.ceil() as usize {
+        for x in lo.x.floor() as usize..hi.x.ceil() as usize {
+            let p = vec2(x as f32 + 0.5, y as f32 + 0.5);
+            let weights = [(b.0, c.0), (c.0, a.0), (a.0, b.0)].map(|(u, v)| (edge(u, v, p), owns(u, v)));
+            if !weights.iter().all(|&(e, own)| e > 0.0 || (e == 0.0 && own)) {
+                continue;
+            }
+            let Some(dst) = px.get_mut(y * w + x) else { continue };
+            let [wa, wb, wc] = weights.map(|(e, _)| e / area);
+            let src: [f32; 4] = std::array::from_fn(|i| {
+                let channel = |col: Color32| f32::from(col.to_array()[i]);
+                (wa * channel(a.1) + wb * channel(b.1) + wc * channel(c.1)) / 255.0
+            });
+            let keep = 1.0 - src[3];
+            *dst = std::array::from_fn(|i| src[i] + dst[i] * keep);
         }
-        Cursor::Width => width(painter, p, ""),
-        Cursor::WidthAdd => width(painter, p, "+"),
-        Cursor::WidthPoint => width(painter, p, "point"),
-        Cursor::Blend | Cursor::BlendObject | Cursor::BlendAnchor => blend(painter, p, c),
-        Cursor::PathBracket => path_bracket(painter, p),
-        _ => return false,
     }
-    let _ = pos2;
-    true
 }
 
 #[cfg(test)]
 mod tests {
+    use std::sync::Arc;
+
     use super::*;
+    use serde_json::json;
+    use vectorcraft_engine::Session;
+
+    use crate::VectorcraftApp;
+
+    /// Every cursor with a glyph.
+    const GLYPHS: [Cursor; 31] = [
+        Cursor::Arrow,
+        Cursor::ArrowHollow,
+        Cursor::Move,
+        Cursor::Crosshair,
+        Cursor::ResizeH,
+        Cursor::ResizeV,
+        Cursor::ResizeNwSe,
+        Cursor::ResizeNeSw,
+        Cursor::Rotate,
+        Cursor::CornerRadius,
+        Cursor::Pen,
+        Cursor::PenAdd,
+        Cursor::PenDelete,
+        Cursor::PenClose,
+        Cursor::PenContinue,
+        Cursor::PenConvert,
+        Cursor::Text,
+        Cursor::Eyedropper,
+        Cursor::AddStop,
+        Cursor::RemoveStop,
+        Cursor::Slice,
+        Cursor::SliceSelect,
+        Cursor::Width,
+        Cursor::WidthAdd,
+        Cursor::WidthPoint,
+        Cursor::Blend,
+        Cursor::BlendObject,
+        Cursor::BlendAnchor,
+        Cursor::PathBracket,
+        Cursor::ShapeBuilder,
+        Cursor::ShapeBuilderErase,
+    ];
+
+    /// The straight RGBA of pixel (x, y).
+    fn pixel(img: &CustomCursorImage, x: usize, y: usize) -> [u8; 4] {
+        let i = (y * img.size[0] as usize + x) * 4;
+        [img.rgba[i], img.rgba[i + 1], img.rgba[i + 2], img.rgba[i + 3]]
+    }
+
+    #[test]
+    fn every_glyph_becomes_a_bitmap_with_its_hotspot_inside() {
+        for ppp in [1.0, 1.25, 1.5, 2.0, 3.0] {
+            for c in GLYPHS {
+                let img = rasterize(c, ppp).unwrap_or_else(|| panic!("{c:?} at {ppp}"));
+                let [w, h] = img.size.map(usize::from);
+                assert_eq!(img.rgba.len(), w * h * 4, "{c:?}");
+                assert!(img.hotspot[0] < img.size[0] && img.hotspot[1] < img.size[1], "{c:?} at {ppp}: {img:?}");
+                assert!(w as f32 <= 50.0 * ppp && h as f32 <= 50.0 * ppp, "{c:?} at {ppp}: {img:?}");
+                assert!(img.rgba.chunks_exact(4).any(|p| p[3] == 255), "{c:?}: nothing opaque");
+            }
+        }
+        for c in [Cursor::Hand, Cursor::HandGrab, Cursor::ZoomIn, Cursor::ZoomOut, Cursor::NotAllowed] {
+            assert!(rasterize(c, 1.0).is_none(), "{c:?} stays a system cursor");
+        }
+        for ppp in [0.0, -1.0, f32::NAN, f32::INFINITY, 1e9] {
+            assert!(rasterize(Cursor::Arrow, ppp).is_none(), "{ppp}");
+        }
+    }
+
+    #[test]
+    fn the_arrow_bitmap_is_black_in_a_white_halo_with_the_tip_on_the_hotspot() {
+        let img = rasterize(Cursor::Arrow, 1.0).unwrap();
+        let [hx, hy] = img.hotspot.map(usize::from);
+        // The tip covers the hotspot's pixel; the body is solid black, the outline's halo white.
+        assert!(pixel(&img, hx, hy)[3] > 0, "{:?}", pixel(&img, hx, hy));
+        let body = pixel(&img, hx + 2, hy + 8);
+        assert!(body[3] == 255 && body[..3].iter().all(|&c| c < 40), "{body:?}");
+        assert!(img.rgba.chunks_exact(4).any(|p| p[3] == 255 && p[..3].iter().all(|&c| c > 215)), "no white halo");
+        // Nothing left of or above the tip but the halo.
+        assert!((0..img.size[1] as usize).all(|y| pixel(&img, 0, y)[..3].iter().all(|&c| c > 100) || pixel(&img, 0, y)[3] < 128));
+        // At twice the pixels per point, twice the pixels.
+        let big = rasterize(Cursor::Arrow, 2.0).unwrap();
+        for i in 0..2 {
+            let ratio = f32::from(big.size[i]) / f32::from(img.size[i]);
+            assert!((1.8..=2.2).contains(&ratio), "{:?} vs {:?}", big.size, img.size);
+        }
+        let [bx, by] = big.hotspot.map(usize::from);
+        let body = pixel(&big, bx + 4, by + 16);
+        assert!(body[3] == 255 && body[..3].iter().all(|&c| c < 40), "{body:?}");
+    }
+
+    #[test]
+    fn each_bitmap_is_made_once_so_the_os_cursor_is_kept() {
+        let mut images = Images::default();
+        let a = images.get(Cursor::Pen, 1.5).unwrap();
+        let b = images.get(Cursor::Pen, 1.5).unwrap();
+        assert!(Arc::ptr_eq(&a.rgba, &b.rgba));
+        assert!(!Arc::ptr_eq(&a.rgba, &images.get(Cursor::Pen, 2.0).unwrap().rgba));
+        assert!(images.get(Cursor::Hand, 1.5).is_none());
+        assert!(images.get(Cursor::Arrow, f32::NAN).is_none());
+        assert_eq!(images.0.len(), 2);
+    }
+
+    /// One headless 800×600 frame of the whole window, a tenth of a second after the last.
+    fn frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>) -> egui::FullOutput {
+        let time = Some(ctx.input(|i| i.time) + 0.1);
+        let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0))), time, events, ..Default::default() };
+        let mut out = ctx.run_ui(raw, |ui| {
+            app.logic(ui.ctx());
+            app.ui(ui);
+        });
+        out.textures_delta.clear();
+        out
+    }
+
+    #[test]
+    fn the_canvas_hands_the_tool_cursor_to_the_os_and_idles_while_the_pointer_rests() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+        let ctx = egui::Context::default();
+        for _ in 0..3 {
+            frame(&mut app, &ctx, vec![]);
+        }
+        let canvas = app.canvas_rect.unwrap();
+        let over = canvas.center();
+        let out = frame(&mut app, &ctx, vec![egui::Event::PointerMoved(over)]);
+        if OS_CURSORS {
+            let img = out.platform_output.cursor_image.as_ref().expect("the Selection tool's arrow as an OS cursor");
+            assert_eq!(img, &app.canvas.cursors.get(Cursor::Arrow, 1.0).unwrap());
+            // Where the OS can't show the bitmap, its system cursor.
+            assert_eq!(out.platform_output.cursor_icon, egui::CursorIcon::Default);
+        } else {
+            assert_eq!(out.platform_output.cursor_icon, egui::CursorIcon::None);
+        }
+        // The same bitmap while the pointer moves (the OS keeps its cursor), and an idle window
+        // once it rests: no frame is asked for.
+        let next = frame(&mut app, &ctx, vec![egui::Event::PointerMoved(over + vec2(5.0, 3.0))]);
+        if OS_CURSORS {
+            assert!(Arc::ptr_eq(&next.platform_output.cursor_image.unwrap().rgba, &out.platform_output.cursor_image.unwrap().rgba));
+        }
+        let mut idle = frame(&mut app, &ctx, vec![]);
+        for _ in 0..3 {
+            idle = frame(&mut app, &ctx, vec![]);
+        }
+        let delay = idle.viewport_output.get(&egui::ViewportId::ROOT).map(|v| v.repaint_delay).unwrap();
+        assert!(delay > std::time::Duration::from_millis(100), "{delay:?} {:?}", ctx.repaint_causes());
+        // Off the canvas, the panels' cursors.
+        let off = frame(&mut app, &ctx, vec![egui::Event::PointerMoved(Pos2::new(canvas.left() - 20.0, canvas.center().y))]);
+        assert!(off.platform_output.cursor_image.is_none());
+    }
 
     #[test]
     fn arrow_hotspot_is_tip() {

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/i18n/catalog.rs

@@ -13,6 +13,92 @@ pub struct Catalog {
     ids: HashMap<String, String>,
     /// plural messages: `one|other` → forms
     plurals: HashMap<String, Vec<String>>,
+    /// status and error messages without placeholders (`@msg`): English → translation
+    messages: HashMap<String, String>,
+    /// status and error messages with `{name}` placeholders (`@msg`), most specific first
+    templates: Vec<Template>,
+}
+
+/// A piece of a message template: literal text or a `{name}` placeholder.
+#[derive(Debug)]
+enum Piece {
+    Text(String),
+    Hole(String),
+}
+
+/// A message template (`Couldn't open {name}: {e}`) and its translation.
+#[derive(Debug)]
+struct Template {
+    pieces: Vec<Piece>,
+    /// Bytes of literal text: a template with more of it is the more specific match.
+    literal: usize,
+    translation: String,
+}
+
+/// Messages longer than this are shown as they are (template matching backtracks).
+const MAX_MESSAGE_LEN: usize = 2000;
+
+impl Template {
+    /// `None` for a template that can't be matched reliably: no literal text, or two placeholders
+    /// in a row (where one ends and the next begins is unknowable).
+    fn parse(source: &str, translation: String) -> Option<Template> {
+        let mut pieces = Vec::new();
+        let mut rest = source;
+        while let Some(a) = rest.find('{') {
+            let after = rest.get(a + 1..)?;
+            let b = after.find('}')?;
+            if a > 0 {
+                pieces.push(Piece::Text(rest.get(..a)?.to_string()));
+            } else if matches!(pieces.last(), Some(Piece::Hole(_))) {
+                return None;
+            }
+            pieces.push(Piece::Hole(after.get(..b)?.to_string()));
+            rest = after.get(b + 1..)?;
+        }
+        if !rest.is_empty() {
+            pieces.push(Piece::Text(rest.to_string()));
+        }
+        let literal = pieces.iter().map(|p| if let Piece::Text(t) = p { t.len() } else { 0 }).sum();
+        (literal > 0).then_some(Template { pieces, literal, translation })
+    }
+
+    /// The placeholder values if `s` is an instance of this template.
+    fn captures<'a>(&self, s: &'a str) -> Option<Vec<(&str, &'a str)>> {
+        let mut out = Vec::new();
+        match_pieces(&self.pieces, s, &mut out).then_some(out)
+    }
+}
+
+/// Match `s` against `pieces`, a placeholder taking the shortest non-empty text that lets the
+/// rest match (the last one takes what remains).
+fn match_pieces<'p, 'a>(pieces: &'p [Piece], s: &'a str, out: &mut Vec<(&'p str, &'a str)>) -> bool {
+    let Some((first, rest)) = pieces.split_first() else { return s.is_empty() };
+    match first {
+        Piece::Text(t) => s.strip_prefix(t.as_str()).is_some_and(|tail| match_pieces(rest, tail, out)),
+        Piece::Hole(name) => {
+            let Some((next, after)) = rest.split_first() else {
+                if s.is_empty() {
+                    return false;
+                }
+                out.push((name.as_str(), s));
+                return true;
+            };
+            let Piece::Text(next) = next else { return false };
+            // Every place the next literal occurs, nearest first (the hole is never empty).
+            let mut from = s.chars().next().map_or(1, char::len_utf8);
+            while let Some(at) = s.get(from..).and_then(|tail| tail.find(next.as_str())).map(|i| i + from) {
+                let (Some(value), Some(tail)) = (s.get(..at), s.get(at + next.len()..)) else { return false };
+                let mark = out.len();
+                out.push((name.as_str(), value));
+                if match_pieces(after, tail, out) {
+                    return true;
+                }
+                out.truncate(mark);
+                from = at + next.chars().next().map_or(1, char::len_utf8);
+            }
+            false
+        }
+    }
 }
 
 /// A catalog entry as read from the file: (context, source, translation).
@@ -74,11 +160,20 @@ impl Catalog {
                 "@plural" => {
                     c.plurals.insert(src, tr.split('|').map(str::to_string).collect());
                 }
+                "@msg" => {
+                    if src.contains('{') {
+                        c.templates.extend(Template::parse(&src, tr));
+                    } else {
+                        c.messages.insert(src, tr);
+                    }
+                }
                 _ => {
                     c.contextual.insert(format!("{ctx}\u{1}{src}"), tr);
                 }
             }
         }
+        // Most literal text first, so `Couldn't open {name}: {e}` wins over `{path}: {e}`.
+        c.templates.sort_by_key(|t| std::cmp::Reverse(t.literal));
         c
     }
 
@@ -94,6 +189,19 @@ impl Catalog {
         self.ids.get(id).map(String::as_str)
     }
 
+    /// A status or error message: an exact `@msg` entry, else the first template it is an instance
+    /// of, with the placeholder values filled in. The values are returned for the caller to
+    /// translate (a reason after `…: {e}` is often a message of its own).
+    pub fn message<'a>(&self, s: &'a str) -> Option<(&str, Vec<(&str, &'a str)>)> {
+        if let Some(tr) = self.messages.get(s) {
+            return Some((tr.as_str(), Vec::new()));
+        }
+        if s.len() > MAX_MESSAGE_LEN {
+            return None;
+        }
+        self.templates.iter().find_map(|t| t.captures(s).map(|caps| (t.translation.as_str(), caps)))
+    }
+
     /// The plural form `index` of the message whose English forms are `one|other`.
     pub fn plural(&self, one: &str, other: &str, index: usize) -> Option<&str> {
         let forms = self.plurals.get(&format!("{one}|{other}"))?;

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

@@ -604,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

@@ -11,6 +11,7 @@
 # Coverage: the whole interface — every menu string and every `tl!` literal (`complete_menus`,
 # tested). Left in English on purpose (`MENU_KEEP_AS_IS` in the tests): the product name, language
 # names, OpenType, the built-in workspace names and the bracketed perspective grid preset names.
+# Status and error messages too (`@msg` rows at the end, `COMPLETE_MESSAGES` in the tests).
 # A native speaker's review is welcome: keep the placeholders ({name}), the trailing "…" and the
 # leading/trailing spaces of fragments exactly as they are.
 
@@ -3029,3 +3030,510 @@
 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
+
+# Status and error messages (`@msg`), translated where the status bar shows them; the message itself
+# stays English for agents and tests. `{_1}`, `{_2}` … stand for the `{}` of the format string, in order
+# (`complete_languages_translate_every_message` lists any that are missing). Command ids, parameter
+# names and values in backticks or code (`colorModel rgb`, `document.export`) stay as they are.
+@msg	BMP files are RGB or grayscale: colorModel rgb or gray	los archivos BMP son RGB o en escala de grises: colorModel rgb o gray
+@msg	Blend colors: select at least three objects with filled colours	Fusionar colores: selecciona al menos tres objetos con relleno de color
+@msg	Combine Slices: the slices have no bounds	Combinar sectores: los sectores no tienen límites
+@msg	Convert to Artboards: selection has no area	Convertir en mesas de trabajo: la selección no tiene área
+@msg	Convert to Shape: no rectangles or ellipses selected	Convertir en forma: no hay rectángulos ni elipses seleccionados
+@msg	Copied the CSS of {rules} object(s)	Se copió el CSS de {rules} objeto(s)
+@msg	Corners edits a live rectangle	Esquinas edita un rectángulo interactivo
+@msg	Couldn't copy to the system clipboard: {e}	No se pudo copiar al portapapeles del sistema: {e}
+@msg	Couldn't open {name}: {e}	No se pudo abrir {name}: {e}
+@msg	Couldn't place {_1}: the document it was dropped on was closed	No se pudo colocar {_1}: se cerró el documento en el que se soltó
+@msg	Couldn't read {name}: {e}	No se pudo leer {name}: {e}
+@msg	Couldn't save recovery data: {e}	No se pudieron guardar los datos de recuperación: {e}
+@msg	Create Outlines: select text objects	Crear contornos: selecciona objetos de texto
+@msg	Create from Guides: the document has no artboard	Crear a partir de guías: el documento no tiene mesa de trabajo
+@msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Crear a partir de guías: las guías forman más de {MAX_PIECES} sectores
+@msg	Create from Selection: the selection has no area	Crear a partir de la selección: la selección no tiene área
+@msg	Data Recovery has nowhere to keep copies: set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Recuperación de datos no tiene dónde guardar copias: configura Preferencias → Manejo de archivos → Recuperación de datos → Carpeta (recoveryFolder)
+@msg	Divide Objects Below: select a path	Dividir objetos inferiores: selecciona un trazado
+@msg	Divide Objects Below: select exactly one path	Dividir objetos inferiores: selecciona exactamente un trazado
+@msg	Downloaded {_1} file(s)	Se descargaron {_1} archivo(s)
+@msg	Downloaded {what}	Se descargó {what}
+@msg	Expand Appearance: the selection has a basic appearance	Expandir apariencia: la selección tiene una apariencia básica
+@msg	Expand: no brush strokes selected	Expandir: no hay trazos de pincel seleccionados
+@msg	Expand: no gradient fills	Expandir: no hay rellenos de degradado
+@msg	Expand: nothing to expand	Expandir: no hay nada que expandir
+@msg	Exported {count} file(s) to {folder}	Se exportaron {count} archivo(s) a {folder}
+@msg	Exported {path}	Se exportó {path}
+@msg	Flatten Transparency: select objects to flatten	Acoplar transparencia: selecciona los objetos que quieres acoplar
+@msg	Flatten Transparency: {e}	Acoplar transparencia: {e}
+@msg	Image Trace: the traced image is missing	Calco de imagen: falta la imagen calcada
+@msg	Imported {what}: {_1}	Se importó {what}: {_1}
+@msg	Installed plug-in {_1}	Se instaló el plugin {_1}
+@msg	Internal error: {msg} (please report this bug)	Error interno: {msg} (por favor, informa de este error)
+@msg	Live Paint Merge: select a Live Paint group and the paths to add	Combinar pintura interactiva: selecciona un grupo de pintura interactiva y los trazados que quieres agregar
+@msg	Live Paint: select paths or compound paths	Pintura interactiva: selecciona trazados o trazados compuestos
+@msg	Live Paint: these paths are too degenerate to paint	Pintura interactiva: estos trazados están demasiado degenerados para pintarlos
+@msg	Make Guides: select paths	Crear guías: selecciona trazados
+@msg	No saved selections (Select → Save Selection…)	No hay selecciones guardadas (Selección → Guardar selección…)
+@msg	No saved views (View → New View…)	No hay vistas guardadas (Ver → Nueva vista…)
+@msg	Offset Path: select paths	Desplazar trazado: selecciona trazados
+@msg	Opened with {_1} note(s): {_2}	Se abrió con {_1} nota(s): {_2}
+@msg	Opened {url}	Se abrió {url}
+@msg	Outline Stroke: no stroked paths selected	Contornear trazo: no hay trazados con trazo seleccionados
+@msg	PDF settings are not an object	los ajustes de PDF no son un objeto
+@msg	PDF writer error: {0}	error del escritor de PDF: {0}
+@msg	Packaged {n} file(s) in {folder}{note}	Se empaquetaron {n} archivo(s) en {folder}{note}
+@msg	Packaged {n} file(s){note}	Se empaquetaron {n} archivo(s){note}
+@msg	Preview in Browser needs the desktop app (the web downloads files instead)	Previsualizar en el navegador requiere la aplicación de escritorio (la versión web descarga los archivos)
+@msg	Release Guides: no guides	Soltar guías: no hay guías
+@msg	Release: no layer to put the rectangle in	Soltar: no hay ninguna capa donde poner el rectángulo
+@msg	Replace Spine: select a blend and a path	Reemplazar eje: selecciona una fusión y un trazado
+@msg	SVG parse error: {0}	error al analizar el SVG: {0}
+@msg	Save for Web: the image is empty	Guardar para web: la imagen está vacía
+@msg	Save writes {_1}, not {_2}: use document.export for other formats	Guardar escribe {_1}, no {_2}: usa document.export para otros formatos
+@msg	Saved recovery data for {title}	Se guardaron los datos de recuperación de {title}
+@msg	Saved to User Defined: {_1}	Se guardó en Definido por el usuario: {_1}
+@msg	Saved {path}	Se guardó {path}
+@msg	Select text or click into text with the Type tool to insert glyphs	Selecciona texto o haz clic dentro del texto con la herramienta Texto para insertar glifos
+@msg	Shape Builder: no region under the pointer	Generador de formas: no hay ninguna región bajo el puntero
+@msg	Shape Builder: select paths or compound paths	Generador de formas: selecciona trazados o trazados compuestos
+@msg	Show All Hidden Attributes: nothing is hidden	Mostrar todos los atributos ocultos: no hay nada oculto
+@msg	Split Into Grid: select paths large enough for the grid	Dividir en cuadrícula: selecciona trazados lo bastante grandes para la cuadrícula
+@msg	Targa files are RGB: colorModel rgb	los archivos Targa son RGB: colorModel rgb
+@msg	Text Wrap: select a wrap object	Ceñir texto: selecciona un objeto para ceñir
+@msg	`aspect` must be a number (%)	`aspect` debe ser un número (%)
+@msg	`at` must be [x, y]	`at` debe ser [x, y]
+@msg	`color` must be a colour	`color` debe ser un color
+@msg	`command` must be a command whose menu item opens a dialog (see ui.menuDialog)	`command` debe ser un comando cuyo elemento de menú abra un cuadro de diálogo (consulta ui.menuDialog)
+@msg	`freeform.points` must be an array	`freeform.points` debe ser una lista
+@msg	`gradient` must be an object	`gradient` debe ser un objeto
+@msg	`library` is a library id or name (see {list})	`library` es el id o el nombre de una biblioteca (consulta {list})
+@msg	`mode` applies to freeform gradients	`mode` se aplica a los degradados de forma libre
+@msg	`sampleSize` must be 1, 3 or 5	`sampleSize` debe ser 1, 3 o 5
+@msg	`stops` must be an array	`stops` debe ser una lista
+@msg	`svg` must be an object of SVG options (see document.formats)	`svg` debe ser un objeto con opciones de SVG (consulta document.formats)
+@msg	`{_1}` is no save command	`{_1}` no es un comando de guardado
+@msg	`{area}` is no recovery area name	`{area}` no es el nombre de un área de recuperación
+@msg	`{color}` is not a colour (#rrggbb or a preset name)	`{color}` no es un color (#rrggbb o el nombre de un preajuste)
+@msg	`{id}` has no envelope dialog	`{id}` no tiene cuadro de diálogo de envolvente
+@msg	`{keep}` is not a side of this axis	`{keep}` no es un lado de este eje
+@msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` debe ser `auto` o un código de idioma como `en` o `zh-hant`
+@msg	`{key}` must be a #rrggbb colour	`{key}` debe ser un color #rrggbb
+@msg	`{key}` must be a number	`{key}` debe ser un número
+@msg	`{key}` must be a string	`{key}` debe ser un texto
+@msg	`{key}` must be a whole number	`{key}` debe ser un número entero
+@msg	`{key}` must be a whole number between {min} and {max} (got {x})	`{key}` debe ser un número entero entre {min} y {max} (se recibió {x})
+@msg	`{key}` must be between {min} and {max} (got {x})	`{key}` debe estar entre {min} y {max} (se recibió {x})
+@msg	`{key}` must be one of {_1}	`{key}` debe ser uno de estos: {_1}
+@msg	`{key}` must be true or false	`{key}` debe ser true o false
+@msg	`{k}` must be [x, y]	`{k}` debe ser [x, y]
+@msg	`{name}` has no options	`{name}` no tiene opciones
+@msg	`{name}` is a built-in workspace; choose another name	`{name}` es un espacio de trabajo integrado; elige otro nombre
+@msg	`{name}` is a process colour: tints apply to global and spot colours	`{name}` es un color de cuatricromía: los matices se aplican a colores globales y planos
+@msg	`{name}` is no recovery entry name	`{name}` no es el nombre de una entrada de recuperación
+@msg	`{name}` isn't a colour swatch	`{name}` no es una muestra de color
+@msg	`{path}` must be a bool or an object of bools	`{path}` debe ser un booleano o un objeto de booleanos
+@msg	`{s}` is not a colour (#rrggbb or a preset name)	`{s}` no es un color (#rrggbb o el nombre de un preajuste)
+@msg	`{tool}` isn't a Liquify tool	`{tool}` no es una herramienta de Licuar
+@msg	`{tool}` isn't a freehand tool	`{tool}` no es una herramienta de dibujo a mano alzada
+@msg	`{to}` is not an available name	`{to}` no es un nombre disponible
+@msg	a bitmap is empty	un mapa de bits está vacío
+@msg	a bitmap is too large to read	un mapa de bits es demasiado grande para leerlo
+@msg	a colour index is 0 to {_1}, not {n}	un índice de color va de 0 a {_1}, no {n}
+@msg	a colour is an index, #rrggbb or a preset name, not {v}	un color es un índice, #rrggbb o el nombre de un preajuste, no {v}
+@msg	a document needs at least one artboard	un documento necesita al menos una mesa de trabajo
+@msg	a document needs at least one layer	un documento necesita al menos una capa
+@msg	a freeform gradient keeps at least one point	un degradado de forma libre conserva al menos un punto
+@msg	a gradient needs at least two stops	un degradado necesita al menos dos paradas
+@msg	a graphic style named `{to}` already exists	ya existe un estilo gráfico llamado `{to}`
+@msg	a page is missing	falta una página
+@msg	a page out of range	una página fuera de rango
+@msg	a page tree kid isn't a reference	un hijo del árbol de páginas no es una referencia
+@msg	a page tree node has no kids	un nodo del árbol de páginas no tiene hijos
+@msg	a page's placement is not finite	la posición de una página no es finita
+@msg	a preset named `{_1}` exists	ya existe un preajuste llamado `{_1}`
+@msg	a slice size must be a positive number of points	el tamaño de un sector debe ser un número positivo de puntos
+@msg	a stream runs past the end	un flujo se extiende más allá del final
+@msg	a stream's length is wrong	la longitud de un flujo es incorrecta
+@msg	a stream's length isn't a number	la longitud de un flujo no es un número
+@msg	add a format to export	agrega un formato para exportar
+@msg	already editing a pattern	ya se está editando un motivo
+@msg	an object can't be read	no se puede leer un objeto
+@msg	an object in perspective would leave the edited grid	un objeto en perspectiva saldría de la cuadrícula editada
+@msg	antiAlias `{id}`: none, art or type	antiAlias `{id}`: none, art o type
+@msg	artboard {0} does not exist	la mesa de trabajo {0} no existe
+@msg	at this scale the drawing is {w} × {h} pt, more than the canvas holds: choose a smaller scale or fit it to the artboard	a esta escala el dibujo mide {w} × {h} pt, más de lo que cabe en el lienzo: elige una escala menor o ajústalo a la mesa de trabajo
+@msg	background {other}: transparent, white, black or a colour such as "#ff8800"	fondo {other}: transparent, white, black o un color como "#ff8800"
+@msg	bad color {v}	color no válido {v}
+@msg	bad colour `{hex}` (#rrggbb)	color no válido `{hex}` (#rrggbb)
+@msg	bad page tree	árbol de páginas no válido
+@msg	bad shortcut	atajo no válido
+@msg	bad stream length	longitud de flujo no válida
+@msg	bad trailer	trailer no válido
+@msg	balance must be between 0 and 100	el equilibrio debe estar entre 0 y 100
+@msg	batch step {_1} (`{id}`) failed: {e}	falló el paso {_1} del lote (`{id}`): {e}
+@msg	brightness must be dark|mediumDark|mediumLight|light	el brillo debe ser dark|mediumDark|mediumLight|light
+@msg	can't encode the document: {0}	no se puede codificar el documento: {0}
+@msg	can't parse shortcut `{c}`	no se puede interpretar el atajo `{c}`
+@msg	can't parse shortcut `{s}` for `{k}`	no se puede interpretar el atajo `{s}` de `{k}`
+@msg	can't save version {0}: VectorCraft writes versions {MIN_VERSION} to {VERSION}	no se puede guardar la versión {0}: VectorCraft escribe las versiones {MIN_VERSION} a {VERSION}
+@msg	can't write .{ext} images	no se pueden escribir imágenes .{ext}
+@msg	cannot distort a zero-size bounding box	no se puede distorsionar un cuadro delimitador de tamaño cero
+@msg	cannot read PDF: {0}	no se puede leer el PDF: {0}
+@msg	cannot split an open path at its end point	no se puede dividir un trazado abierto en su punto final
+@msg	check an asset to export	marca un recurso para exportar
+@msg	choice must be "merge" or "add", not `{choice}`	choice debe ser "merge" o "add", no `{choice}`
+@msg	choose a direction to divide in	elige una dirección en la que dividir
+@msg	choose a folder to export to	elige una carpeta a la que exportar
+@msg	choose a location for the package	elige una ubicación para el paquete
+@msg	clipboard is empty	el portapapeles está vacío
+@msg	collapsed must be true or false	collapsed debe ser true o false
+@msg	colorTable.{what}: `{h}` is not a colour such as "#ff8800"	colorTable.{what}: `{h}` no es un color como "#ff8800"
+@msg	colorTable.{what}: at most {MAX_TABLE} colours	colorTable.{what}: como máximo {MAX_TABLE} colores
+@msg	command `{0}` is not available right now: {1}	el comando `{0}` no está disponible ahora: {1}
+@msg	compound paths can only contain paths	los trazados compuestos solo pueden contener trazados
+@msg	compressed (RLE) bitmaps can't be read yet	todavía no se pueden leer mapas de bits comprimidos (RLE)
+@msg	damaged	dañado
+@msg	decimals must be {_1}–{_2} (got {_3})	los decimales deben ser {_1}–{_2} (se recibió {_3})
+@msg	divide into 1 to {MAX_PIECES} slices	divide en 1 a {MAX_PIECES} sectores
+@msg	effect {k} is `{_1}`, not `{id}`	el efecto {k} es `{_1}`, no `{id}`
+@msg	empty brush stroke	trazo de pincel vacío
+@msg	empty cutter	cortador vacío
+@msg	empty path	trazado vacío
+@msg	file version {0} is newer than this VectorCraft supports ({VERSION})	la versión de archivo {0} es más reciente de lo que admite este VectorCraft ({VERSION})
+@msg	freeform point {i} needs `at` [x, y] and a valid `color`	el punto de forma libre {i} necesita `at` [x, y] y un `color` válido
+@msg	give both `start` and `end` [x, y] (or neither)	indica `start` y `end` [x, y] (o ninguno de los dos)
+@msg	give corners 0–3	indica esquinas de 0 a 3
+@msg	give the path `id` and the width point `index`	indica el `id` del trazado y el `index` del punto de anchura
+@msg	guides are locked	las guías están bloqueadas
+@msg	image '{key}' has no pixels and was left out	la imagen '{key}' no tiene píxeles y se omitió
+@msg	image data `{_1}` is missing	faltan los datos de imagen `{_1}`
+@msg	image would be too large; lower the resolution	la imagen sería demasiado grande; baja la resolución
+@msg	index must be a number or first, previous, next or last	index debe ser un número o first, previous, next o last
+@msg	index must be a number or first, previous, next or last, not `{other}`	index debe ser un número o first, previous, next o last, no `{other}`
+@msg	installing from a path is not available on the web; pass the module as `dataBase64`	en la web no se puede instalar desde una ruta; pasa el módulo como `dataBase64`
+@msg	internal error in `{cmd}`: {msg} (the document was left as it was before; please report this bug)	error interno en `{cmd}`: {msg} (el documento quedó como estaba; por favor, informa de este error)
+@msg	internal error: {msg} (please report this bug)	error interno: {msg} (por favor, informa de este error)
+@msg	invalid PDF setting: {0}	ajuste de PDF no válido: {0}
+@msg	invalid image data for `{0}`	datos de imagen no válidos para `{0}`
+@msg	invalid parameters for `{cmd}`: {msg}	parámetros no válidos para `{cmd}`: {msg}
+@msg	is not an image VectorCraft reads	no es una imagen que VectorCraft pueda leer
+@msg	join needs open paths	unir necesita trazados abiertos
+@msg	lang must be one of {_1}	lang debe ser uno de estos: {_1}
+@msg	layers can't be wrap objects	las capas no pueden ser objetos para ceñir
+@msg	missing `folder`	falta `folder`
+@msg	missing `id` (see plugin.list)	falta `id` (consulta plugin.list)
+@msg	missing `name`	falta `name`
+@msg	missing `tool`	falta `tool`
+@msg	missing index	falta index
+@msg	multiple windows land with M11.5	las ventanas múltiples llegan con M11.5
+@msg	name the file	ponle nombre al archivo
+@msg	no CSS to copy: select objects with CSS of their own	no hay CSS que copiar: selecciona objetos con CSS propio
+@msg	no Live Paint edge near that point	no hay ningún borde de pintura interactiva cerca de ese punto
+@msg	no Live Paint face at that point	no hay ninguna cara de pintura interactiva en ese punto
+@msg	no PNG encoder	no hay codificador PNG
+@msg	no active document	no hay ningún documento activo
+@msg	no active perspective plane	no hay ningún plano de perspectiva activo
+@msg	no anchor points selected	no hay puntos de ancla seleccionados
+@msg	no app to open files here	aquí no hay ninguna aplicación para abrir archivos
+@msg	no artboard	no hay mesa de trabajo
+@msg	no artboard {i} (0-based; the document has {_1})	no existe la mesa de trabajo {i} (contando desde 0; el documento tiene {_1})
+@msg	no artboard {i} (0-based; the document has {count})	no existe la mesa de trabajo {i} (contando desde 0; el documento tiene {count})
+@msg	no artboards named	no se indicaron mesas de trabajo
+@msg	no artwork	no hay ilustración
+@msg	no blend options	no hay opciones de fusión
+@msg	no bounds	sin límites
+@msg	no brush named `{name}`	no hay ningún pincel llamado `{name}`
+@msg	no catalog	no hay catálogo
+@msg	no changes since the last save	no hay cambios desde la última vez que se guardó
+@msg	no clock to keep a heartbeat by	no hay reloj para mantener la señal de actividad
+@msg	no colour group `{g}`	no existe el grupo de colores `{g}`
+@msg	no cross-reference table	no hay tabla de referencias cruzadas
+@msg	no current layer	no hay capa actual
+@msg	no data	no hay datos
+@msg	no dialog open	no hay ningún cuadro de diálogo abierto
+@msg	no document	no hay documento
+@msg	no document open	no hay ningún documento abierto
+@msg	no effect applied yet	todavía no se aplicó ningún efecto
+@msg	no effect at index {k}	no hay ningún efecto en el índice {k}
+@msg	no end record	no hay registro final
+@msg	no file manager here	aquí no hay administrador de archivos
+@msg	no file reader	no hay lector de archivos
+@msg	no file system here	aquí no hay sistema de archivos
+@msg	no file writer	no hay escritor de archivos
+@msg	no files to place	no hay archivos para colocar
+@msg	no format to export to	no hay formato al que exportar
+@msg	no free recovery area	no hay ningún área de recuperación libre
+@msg	no gradient stop or freeform point is selected	no hay ninguna parada de degradado ni punto de forma libre seleccionado
+@msg	no graphic style `{name}`	no existe el estilo gráfico `{name}`
+@msg	no graphic style `{n}`	no existe el estilo gráfico `{n}`
+@msg	no interaction in progress	no hay ninguna interacción en curso
+@msg	no key object	no hay objeto clave
+@msg	no library `{key}` (see {list})	no existe la biblioteca `{key}` (consulta {list})
+@msg	no native format	no hay formato nativo
+@msg	no pages	no hay páginas
+@msg	no pattern `{name}`	no existe el motivo `{name}`
+@msg	no perspective grid preset named `{name}`	no hay ningún preajuste de cuadrícula de perspectiva llamado `{name}`
+@msg	no plug-in {0} is installed	no hay ningún plugin {0} instalado
+@msg	no plug-in {id} is installed	no hay ningún plugin {id} instalado
+@msg	no point {i} (the gradient has {_1})	no existe el punto {i} (el degradado tiene {_1})
+@msg	no preset editor	no hay editor de preajustes
+@msg	no previous transform	no hay transformación anterior
+@msg	no print preset named `{base}`	no hay ningún preajuste de impresión llamado `{base}`
+@msg	no print preset named `{name}`	no hay ningún preajuste de impresión llamado `{name}`
+@msg	no print service	no hay servicio de impresión
+@msg	no revert command	no hay comando para volver a la versión guardada
+@msg	no saved PDF preset named `{name}` (built-in presets are read-only: start a new one from them)	no hay ningún preajuste de PDF guardado llamado `{name}` (los preajustes integrados son de solo lectura: crea uno nuevo a partir de ellos)
+@msg	no saved presets	no hay preajustes guardados
+@msg	no saved print preset named `{name}` ({DEFAULT_PRESET} is protected: start a new one from it)	no hay ningún preajuste de impresión guardado llamado `{name}` ({DEFAULT_PRESET} está protegido: crea uno nuevo a partir de él)
+@msg	no saved profiles	no hay perfiles guardados
+@msg	no saved selections	no hay selecciones guardadas
+@msg	no saved themes	no hay temas guardados
+@msg	no segment {segment} on line {line}	no existe el segmento {segment} en la línea {line}
+@msg	no selected slice in the image: select slices, or save all of them	no hay ningún sector seleccionado en la imagen: selecciona sectores o guárdalos todos
+@msg	no selection bounds	la selección no tiene límites
+@msg	no slice selected	no hay ningún sector seleccionado
+@msg	no such action	no existe esa acción
+@msg	no such anchor	no existe ese punto de ancla
+@msg	no such artboard	no existe esa mesa de trabajo
+@msg	no such document	no existe ese documento
+@msg	no such layer or object	no existe esa capa u objeto
+@msg	no such object {0}	no existe el objeto {0}
+@msg	no such perspective grid preset	no existe ese preajuste de cuadrícula de perspectiva
+@msg	no such recent file	no existe ese archivo reciente
+@msg	no such recent font	no existe esa fuente reciente
+@msg	no such saved selection	no existe esa selección guardada
+@msg	no such segment	no existe ese segmento
+@msg	no such subpath	no existe ese subtrazado
+@msg	no such user library	no existe esa biblioteca de usuario
+@msg	no such view	no existe esa vista
+@msg	no such width point	no existe ese punto de anchura
+@msg	no swatch `{name}`	no existe la muestra `{name}`
+@msg	no swatch library `{l}` (see swatch.library.list)	no existe la biblioteca de muestras `{l}` (consulta swatch.library.list)
+@msg	no symbol instances selected	no hay instancias de símbolo seleccionadas
+@msg	no target object has an opacity mask: select one or give `id`	ningún objeto de destino tiene máscara de opacidad: selecciona uno o indica `id`
+@msg	no threaded text selected	no hay texto enlazado seleccionado
+@msg	no user workspace `{from}`	no existe el espacio de trabajo de usuario `{from}`
+@msg	node {_1} is not text	el nodo {_1} no es texto
+@msg	not a DXF drawing	no es un dibujo DXF
+@msg	not a VectorCraft file: {0}	no es un archivo de VectorCraft: {0}
+@msg	not a VectorCraft shortcut set (missing `overrides`)	no es un conjunto de atajos de VectorCraft (falta `overrides`)
+@msg	not a graphic style library (format `{_1}`)	no es una biblioteca de estilos gráficos (formato `{_1}`)
+@msg	not a stored central record	no es un registro central almacenado
+@msg	not a valid plug-in module: {0}	no es un módulo de plugin válido: {0}
+@msg	not an EMF or WMF file	no es un archivo EMF ni WMF
+@msg	not found	no se encontró
+@msg	not in pattern editing mode	no está en el modo de edición de motivos
+@msg	nothing encoded	no se codificó nada
+@msg	nothing selected	no hay nada seleccionado
+@msg	nothing to align	no hay nada que alinear
+@msg	nothing to distort	no hay nada que distorsionar
+@msg	nothing to export: the document has no visible art (or turn on Use Artboards)	no hay nada que exportar: el documento no tiene ilustración visible (o activa Usar mesas de trabajo)
+@msg	nothing to preview	no hay nada que previsualizar
+@msg	nothing to print	no hay nada que imprimir
+@msg	nothing to redo	no hay nada que rehacer
+@msg	nothing to save: the document has no visible art	no hay nada que guardar: el documento no tiene ilustración visible
+@msg	nothing to undo	no hay nada que deshacer
+@msg	nothing to warp	no hay nada que deformar
+@msg	nothing to wrap	no hay nada que envolver
+@msg	object {0} cannot have children	el objeto {0} no puede tener hijos
+@msg	object {id} is not a path	el objeto {id} no es un trazado
+@msg	page size {w} × {h}	tamaño de página {w} × {h}
+@msg	page {0} does not exist (the PDF has {1})	la página {0} no existe (el PDF tiene {1})
+@msg	paste unavailable	pegar no está disponible
+@msg	path is already closed	el trazado ya está cerrado
+@msg	paths contain invalid coordinates	los trazados contienen coordenadas no válidas
+@msg	paths: give at least one file	paths: indica al menos un archivo
+@msg	pattern missing	falta el motivo
+@msg	percent must be above 0 and at most 6400, not {p}	el porcentaje debe ser mayor que 0 y como máximo 6400, no {p}
+@msg	pick a colour, gradient or pattern to save as a swatch	elige un color, degradado o motivo para guardarlo como muestra
+@msg	plane must be left, right or ground	plane debe ser left, right o ground
+@msg	plug-in ABI: {0}	ABI del plugin: {0}
+@msg	plug-in exceeded its {0}	el plugin superó su {0}
+@msg	plug-in failed: {0}	el plugin falló: {0}
+@msg	plug-in manifest: {0}	manifiesto del plugin: {0}
+@msg	plug-in output: {0}	salida del plugin: {0}
+@msg	plug-in parameters: {0}	parámetros del plugin: {0}
+@msg	plug-in trapped: {0}	el plugin se detuvo con un error: {0}
+@msg	print settings are not an object	los ajustes de impresión no son un objeto
+@msg	printing isn't available here	aquí no se puede imprimir
+@msg	range `{s}` is empty	el rango `{s}` está vacío
+@msg	range `{s}`: `{part}` names no number	rango `{s}`: `{part}` no indica ningún número
+@msg	range `{s}`: `{part}` runs backwards	rango `{s}`: `{part}` va hacia atrás
+@msg	range `{s}`: `{t}` is not a number from 1 to {count}	rango `{s}`: `{t}` no es un número de 1 a {count}
+@msg	recovery copy `{file}`: {e}	copia de recuperación `{file}`: {e}
+@msg	resolutions must be between 1 and 2400 ppi	las resoluciones deben estar entre 1 y 2400 ppi
+@msg	result would exceed the canvas (coordinates out of range)	el resultado excedería el lienzo (coordenadas fuera de rango)
+@msg	scale must be a number from {_1} to {_2}, not {_3}	la escala debe ser un número de {_1} a {_2}, no {_3}
+@msg	scale must be a number from {_1} to {_2}, not {s}	la escala debe ser un número de {_1} a {_2}, no {s}
+@msg	select (or target) objects whose appearance isn't basic	selecciona (o apunta a) objetos cuya apariencia no sea básica
+@msg	select a Live Paint group	selecciona un grupo de pintura interactiva
+@msg	select a blend	selecciona una fusión
+@msg	select a clip group	selecciona un grupo de recorte
+@msg	select a gradient mesh	selecciona una malla de degradado
+@msg	select a linked image: an embedded one has no file	selecciona una imagen vinculada: una incrustada no tiene archivo
+@msg	select a repeat	selecciona una repetición
+@msg	select a stroke with a variable width	selecciona un trazo con anchura variable
+@msg	select a symbol instance	selecciona una instancia de símbolo
+@msg	select an Image Trace object	selecciona un objeto de calco de imagen
+@msg	select an envelope	selecciona una envolvente
+@msg	select an image	selecciona una imagen
+@msg	select an object in perspective	selecciona un objeto en perspectiva
+@msg	select artwork (or a colour group) to recolor	selecciona la ilustración (o un grupo de colores) que quieres volver a colorear
+@msg	select at least two objects	selecciona al menos dos objetos
+@msg	select objects, not layers	selecciona objetos, no capas
+@msg	select one live rectangle, or give its `id`	selecciona un rectángulo interactivo o indica su `id`
+@msg	select paths to join	selecciona los trazados que quieres unir
+@msg	select the art to repeat	selecciona la ilustración que quieres repetir
+@msg	select the artwork to warp	selecciona la ilustración que quieres deformar
+@msg	select the objects to transform in perspective	selecciona los objetos que quieres transformar en perspectiva
+@msg	select two or more graphic styles to merge	selecciona dos o más estilos gráficos para combinarlos
+@msg	select type in perspective	selecciona texto en perspectiva
+@msg	selection has no bounds	la selección no tiene límites
+@msg	shortcut for `{k}` must be a string	el atajo de `{k}` debe ser un texto
+@msg	stop {i} needs `offset`	la parada {i} necesita `offset`
+@msg	stop {i} needs a valid `color`	la parada {i} necesita un `color` válido
+@msg	stop {i}: `{k}` must be a number	parada {i}: `{k}` debe ser un número
+@msg	the EMF header is damaged	el encabezado EMF está dañado
+@msg	the PDF has no pages	el PDF no tiene páginas
+@msg	the PDF is no longer loaded	el PDF ya no está cargado
+@msg	the PDF is password-protected: give its password	el PDF está protegido con contraseña: indica su contraseña
+@msg	the PDF password is wrong	la contraseña del PDF es incorrecta
+@msg	the Save PDF dialog didn't open	el cuadro de diálogo Guardar PDF no se abrió
+@msg	the WMF header is damaged	el encabezado WMF está dañado
+@msg	the art could not be sampled	no se pudo muestrear la ilustración
+@msg	the art has no bounds	la ilustración no tiene límites
+@msg	the art is too light for any dots	la ilustración es demasiado clara para generar puntos
+@msg	the artboard to fit must be a positive size up to {_1} pt	la mesa de trabajo a la que ajustar debe tener un tamaño positivo de hasta {_1} pt
+@msg	the background worker stopped	el proceso en segundo plano se detuvo
+@msg	the compressed file unpacks to more than {_1} MB	el archivo comprimido ocupa más de {_1} MB al descomprimirse
+@msg	the document has never been saved	el documento nunca se guardó
+@msg	the document has no artboard	el documento no tiene mesa de trabajo
+@msg	the document has no artboards	el documento no tiene mesas de trabajo
+@msg	the document has no patterns	el documento no tiene motivos
+@msg	the document has no slices	el documento no tiene sectores
+@msg	the document has no symbols	el documento no tiene símbolos
+@msg	the drawing has no layout `{_1}` (it has {_2})	el dibujo no tiene la presentación `{_1}` (tiene {_2})
+@msg	the drawing is no longer loaded	el dibujo ya no está cargado
+@msg	the drawing is too large to open	el dibujo es demasiado grande para abrirlo
+@msg	the export region is empty	la región de exportación está vacía
+@msg	the export region is not finite	la región de exportación no es finita
+@msg	the export returned unreadable data	la exportación devolvió datos ilegibles
+@msg	the export wrote no file	la exportación no escribió ningún archivo
+@msg	the file holds only a placeholder page, not its art (it was saved without PDF compatibility): save it again with PDF compatibility on, or as PDF or SVG	el archivo solo contiene una página provisional, no su ilustración (se guardó sin compatibilidad con PDF): vuelve a guardarlo con la compatibilidad con PDF activada, o como PDF o SVG
+@msg	the file's preview header points outside the file	el encabezado de previsualización del archivo apunta fuera del archivo
+@msg	the image's pixels don't match its size	los píxeles de la imagen no coinciden con su tamaño
+@msg	the layer has no objects to clip by	la capa no tiene objetos con los que recortar
+@msg	the layer or group is locked	la capa o el grupo está bloqueado
+@msg	the layer to flatten into is hidden	la capa en la que acoplar está oculta
+@msg	the object already has an opacity mask	el objeto ya tiene una máscara de opacidad
+@msg	the object has no geometry	el objeto no tiene geometría
+@msg	the object has no opacity mask	el objeto no tiene máscara de opacidad
+@msg	the object has no stroke	el objeto no tiene trazo
+@msg	the object is beyond the plane's horizon	el objeto está más allá del horizonte del plano
+@msg	the object isn't in perspective	el objeto no está en perspectiva
+@msg	the object isn't on a perspective plane	el objeto no está en un plano de perspectiva
+@msg	the object would cross the horizon of the perspective plane	el objeto cruzaría el horizonte del plano de perspectiva
+@msg	the objects would leave the grid	los objetos saldrían de la cuadrícula
+@msg	the package came back damaged	el paquete llegó dañado
+@msg	the pointer is beyond the plane's horizon	el puntero está más allá del horizonte del plano
+@msg	the preview image is empty	la imagen de previsualización está vacía
+@msg	the print job has no data	el trabajo de impresión no tiene datos
+@msg	the scale is not a usable number	la escala no es un número utilizable
+@msg	the selected stroke's profile is already listed as {_1}	el perfil del trazo seleccionado ya figura como {_1}
+@msg	the selection has no URL (or they differ)	la selección no tiene URL (o son distintas)
+@msg	the selection isn't in perspective	la selección no está en perspectiva
+@msg	the stroke has no weight	el trazo no tiene grosor
+@msg	the thumbnail image is malformed	la miniatura está mal formada
+@msg	the top object must be a path, compound path or text object to use as a clipping mask	el objeto superior debe ser un trazado, un trazado compuesto o un objeto de texto para usarlo como máscara de recorte
+@msg	the {tool} tool has no options	la herramienta {tool} no tiene opciones
+@msg	there are no objects to release	no hay objetos que soltar
+@msg	there are no printer settings to open here	aquí no hay ajustes de impresora que abrir
+@msg	this PostScript file can't be read ({_1}): save it as PDF or SVG in the app that made it	no se puede leer este archivo PostScript ({_1}): guárdalo como PDF o SVG en la aplicación que lo creó
+@msg	this format holds one artboard: export several as PDF or with document.exportForScreens	este formato admite una sola mesa de trabajo: exporta varias como PDF o con document.exportForScreens
+@msg	this is a DWG drawing, which can't be read: save it from the CAD app as an ASCII DXF and open that	este es un dibujo DWG, que no se puede leer: guárdalo desde la aplicación de CAD como DXF ASCII y abre ese archivo
+@msg	this is a PostScript file (an .ai saved in an older format or without PDF compatibility, or an EPS file), which can't be opened yet: save it as PDF, PDF-compatible .ai or SVG	este es un archivo PostScript (un .ai guardado en un formato antiguo o sin compatibilidad con PDF, o un archivo EPS), que todavía no se puede abrir: guárdalo como PDF, .ai compatible con PDF o SVG
+@msg	this is not a PostScript file	este no es un archivo PostScript
+@msg	tool shortcuts must be a single key (optionally with Shift)	los atajos de herramientas deben ser una sola tecla (opcionalmente con Shift)
+@msg	truncated	truncado
+@msg	unknown command `{0}`	comando desconocido `{0}`
+@msg	unknown effect `{id}`	efecto desconocido `{id}`
+@msg	unknown format	formato desconocido
+@msg	unknown format `{f}` (Save writes {_1})	formato desconocido `{f}` (Guardar escribe {_1})
+@msg	unknown freeform mode `{m}` (points, lines)	modo de forma libre desconocido `{m}` (points, lines)
+@msg	unknown gradient kind `{k}` (linear, radial, freeform)	tipo de degradado desconocido `{k}` (linear, radial, freeform)
+@msg	unknown highlight `{h}`	resaltado desconocido `{h}`
+@msg	unknown option `{path}.{k}`	opción desconocida `{path}.{k}`
+@msg	unknown overprints `{o}` (preserve, simulate or discard)	sobreimpresiones desconocidas `{o}` (preserve, simulate o discard)
+@msg	unknown panel `{raw}`	panel desconocido `{raw}`
+@msg	unknown preference `{key}`	preferencia desconocida `{key}`
+@msg	unknown preset (one of {_1})	preajuste desconocido (uno de estos: {_1})
+@msg	unknown preset `{name}` (high, medium, low or a saved one: see flattener.presets.list)	preajuste desconocido `{name}` (high, medium, low o uno guardado: consulta flattener.presets.list)
+@msg	unknown preset `{name}` (see flattener.presets.list)	preajuste desconocido `{name}` (consulta flattener.presets.list)
+@msg	unknown preset `{name}` (see webExport.presets.list)	preajuste desconocido `{name}` (consulta webExport.presets.list)
+@msg	unknown side `{other}` (left|right|top|bottom)	lado desconocido `{other}` (left|right|top|bottom)
+@msg	unknown tool `{tool}`	herramienta desconocida `{tool}`
+@msg	unknown tool `{t}`	herramienta desconocida `{t}`
+@msg	unknown tool or command `{key}`	herramienta o comando desconocido `{key}`
+@msg	unknown workspace (one of {_1})	espacio de trabajo desconocido (uno de estos: {_1})
+@msg	unsupported: {0}	no compatible: {0}
+@msg	version {0} files can't be compressed: only version {COMPRESSED_SINCE} and later open compressed files	los archivos de la versión {0} no se pueden comprimir: solo la versión {COMPRESSED_SINCE} y posteriores abren archivos comprimidos
+@msg	width and height are at least 1 pixel	el ancho y el alto son de al menos 1 píxel
+@msg	workspace name can't be empty	el nombre del espacio de trabajo no puede estar vacío
+@msg	{C}: no effect at index {from}	{C}: no hay ningún efecto en el índice {from}
+@msg	{_1} failed: {e}	{_1} falló: {e}
+@msg	{_1} files can be opened but not written (see document.formats)	los archivos {_1} se pueden abrir pero no escribir (consulta document.formats)
+@msg	{_1} font families available	{_1} familias de fuentes disponibles
+@msg	{_1} is a live effect (Effect › Plug-ins)	{_1} es un efecto interactivo (Efecto › Plugins)
+@msg	{_1} is already used by {_2}	{_1} ya lo usa {_2}
+@msg	{_1} linked file(s) can't be read here: their previews show	aquí no se pueden leer {_1} archivo(s) vinculado(s): se muestran sus previsualizaciones
+@msg	{_1} linked image(s) changed on disk: Update Links shows the new versions	{_1} imagen(es) vinculada(s) cambiaron en el disco: Actualizar vínculos muestra las versiones nuevas
+@msg	{_1}: not saved, so not closed	{_1}: no se guardó, así que no se cerró
+@msg	{bpp}-bit bitmaps can't be read	no se pueden leer mapas de bits de {bpp} bits
+@msg	{command} didn't create an object	{command} no creó ningún objeto
+@msg	{label} produced an empty result	{label} produjo un resultado vacío
+@msg	{label}: lost track of a shape's style	{label}: se perdió el estilo de una forma
+@msg	{label}: select paths	{label}: selecciona trazados
+@msg	{label}: select paths, compound paths, groups or text	{label}: selecciona trazados, trazados compuestos, grupos o texto
+@msg	{label}…	{label}…
+@msg	{name}: CRC mismatch	{name}: el CRC no coincide
+@msg	{name}: no local header	{name}: no hay encabezado local
+@msg	{name}: no such recovery entry	{name}: no existe esa entrada de recuperación
+@msg	{path} can't be found: relink it first	no se encuentra {path}: vuelve a vincularlo primero
+@msg	{path}: no file system here (pass dataBase64 to open; omit the path to get dataBase64)	{path}: aquí no hay sistema de archivos (pasa dataBase64 para abrir; omite la ruta para obtener dataBase64)
+@msg	{path}: {e}	{path}: {e}
+@msg	{status} ({e})	{status} ({e})
+@msg	Couldn't place {name}: {e}	No se pudo colocar {name}: {e}
+@msg	Couldn't paste from the clipboard: {e}	No se pudo pegar desde el portapapeles: {e}
+@msg	Saved {path} with {_1} note(s): {first}	Se guardó {path} con {_1} nota(s): {first}
+@msg	Exported {what} with {_1} note(s): {first}	Se exportó {what} con {_1} nota(s): {first}
+@msg	Exported {what}	Se exportó {what}
+@msg	Saved {n} files beside {path}	Se guardaron {n} archivos junto a {path}
+@msg	Saving	Guardando
+@msg	Saving {_1}	Guardando {_1}
+@msg	Exporting {_1}	Exportando {_1}
+@msg	Saving recovery data for {_1}	Guardando datos de recuperación de {_1}
+@msg	Discarded {_1} recovered document(s)	Se descartaron {_1} documento(s) recuperado(s)
+@msg	Restored {_1} recovered document(s): save them to keep them	Se restauraron {_1} documento(s) recuperado(s): guárdalos para conservarlos
+@msg	Embedded {n} image(s); {missing} missing: relink them first	Se incrustaron {n} imagen(es); faltan {missing}: vuelve a vincularlas primero
+@msg	Embedded {n} image(s)	Se incrustaron {n} imagen(es)
+@msg	Relinked {_1} image(s)	Se volvieron a vincular {_1} imagen(es)
+@msg	Relinked {n} image(s)	Se volvieron a vincular {n} imagen(es)
+@msg	Relinked {n} image(s); not in that folder: {_1}	Se volvieron a vincular {n} imagen(es); no están en esa carpeta: {_1}
+@msg	Updated {_1} image(s)	Se actualizaron {_1} imagen(es)
+@msg	Unembedded to {_1}	Se desincrustó en {_1}
+@msg	Reset {_1}	Se restableció {_1}
+@msg	Sent to {_1}	Se envió a {_1}
+@msg	{_1} files	{_1} archivos
+@msg	The graphics were lost and have been restarted	Se perdieron los gráficos y se reiniciaron
+@msg	Loading VectorCraft…	Cargando VectorCraft…
+@msg	VectorCraft failed to start: {e}	VectorCraft no pudo iniciarse: {e}
+@msg	A browser with WebGPU or WebGL2 is required.	Se necesita un navegador con WebGPU o WebGL2.
+@msg	The graphics were lost and couldn't be restarted.	Se perdieron los gráficos y no se pudieron reiniciar.
+@msg	Your unsaved changes are kept in this browser: reload the page to get them back.	Tus cambios sin guardar se conservan en este navegador: vuelve a cargar la página para recuperarlos.
+@msg	Reload the page to go on (changes not saved yet may be lost).	Vuelve a cargar la página para continuar (los cambios que aún no se guardaron podrían perderse).
+@msg	floating must be true or false	floating debe ser true o false
+@msg	tool (a tool id) is required	se requiere tool (un id de herramienta)
+@msg	{tool} isn't in a toolbar group of several tools	{tool} no está en un grupo de la barra de herramientas con varias herramientas

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

@@ -3018,3 +3018,7 @@
 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/mod.rs

@@ -19,6 +19,10 @@
 //!   translation survives rewording of the English text and can differ per command.
 //! - [`trn`]: plural-aware (`{n}` is filled in). [`fmt`]: fill `{name}` placeholders after [`tr`];
 //!   translators may reorder placeholders freely.
+//! - [`message`] / [`msg`]: a status or error message, translated only where it is shown. The
+//!   message itself stays English (the control channel, MCP and tests read it); `@msg` catalog
+//!   rows hold whole messages or templates such as `Couldn't open {name}: {e}`, and the values in
+//!   the placeholders are translated in turn (the reason after `: {e}` is often a message too).
 
 mod catalog;
 
@@ -212,16 +216,28 @@ pub fn detect_system_lang_in_background() {
     }
 }
 
+/// The system language, worked out once.
+static SYSTEM: OnceLock<Lang> = OnceLock::new();
+
 /// The system language (cached). English when it can't be determined.
 pub fn system_lang() -> Lang {
     // Tests drive the UI by its English labels whatever the developer's locale is.
     if cfg!(test) {
         return Lang::EN;
     }
-    static SYSTEM: OnceLock<Lang> = OnceLock::new();
     *SYSTEM.get_or_init(detect_system_lang)
 }
 
+/// Tell the UI the system's preferred languages, most preferred first, where it can't find them
+/// itself: the web shell passes the browser's (`navigator.languages`). The first supported one is
+/// the system language (English if none is); call it before the first frame. Has no effect once
+/// the system language is known.
+pub fn set_system_locales<S: AsRef<str>>(tags: &[S]) {
+    let lang = tags.iter().find_map(|t| lang_from_tag(t.as_ref())).unwrap_or(Lang::EN);
+    // Already set means already detected (or reported): the first answer stands.
+    let _ = SYSTEM.set(lang);
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 fn detect_system_lang() -> Lang {
     // `VECTORCRAFT_LOCALE` overrides everything (also handy for screenshots); then the POSIX
@@ -277,6 +293,7 @@ fn registry_locale(text: &str) -> Option<String> {
     text.lines().find(|l| l.contains("LocaleName")).and_then(|l| l.split_whitespace().last()).map(str::to_string)
 }
 
+/// The browser's languages arrive through [`set_system_locales`]; without them, English.
 #[cfg(target_arch = "wasm32")]
 fn detect_system_lang() -> Lang {
     Lang::EN
@@ -351,6 +368,40 @@ pub fn label_or_name(lang: Lang, s: &str, built_in: bool) -> &str {
     if built_in { tr(lang, s) } else { s }
 }
 
+/// How deep [`message`] translates placeholder values that are messages themselves.
+const MESSAGE_DEPTH: usize = 3;
+
+/// Translate a status or error message for display (see the module docs). Unknown messages, and
+/// parts of them (file names, numbers, a reason with no entry), stay as they are.
+pub fn message(lang: Lang, s: &str) -> String {
+    message_at(lang, s, MESSAGE_DEPTH)
+}
+
+fn message_at(lang: Lang, s: &str, depth: usize) -> String {
+    let Some((template, caps)) = lang.catalog().message(s) else { return s.to_string() };
+    let values: Vec<(&str, String)> =
+        caps.into_iter().map(|(k, v)| (k, if depth > 1 { message_at(lang, v, depth - 1) } else { v.to_string() })).collect();
+    let args: Vec<(&str, &str)> = values.iter().map(|(k, v)| (*k, v.as_str())).collect();
+    fmt(template, &args)
+}
+
+/// [`message`] in the current language, remembering the last answer: the status bar asks for the
+/// same message every frame.
+pub fn msg(s: &str) -> String {
+    static LAST: std::sync::Mutex<Option<(&'static str, String, String)>> = std::sync::Mutex::new(None);
+    let lang = current();
+    let mut last = LAST.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    if let Some((code, src, out)) = last.as_ref()
+        && *code == lang.code()
+        && src == s
+    {
+        return out.clone();
+    }
+    let out = message(lang, s);
+    *last = Some((lang.code(), s.to_string(), out.clone()));
+    out
+}
+
 /// [`trn`] in the current language.
 pub fn tn(n: u64, one: &str, other: &str) -> String {
     trn(current(), n, one, other)

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

@@ -2621,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/tests.rs

@@ -601,3 +601,150 @@ fn a_language_saved_by_an_older_version_carries_over() {
     crate::prefs_dialog::restore(&mut app);
     assert_eq!(app.session.prefs.interface_language, "cs");
 }
+
+#[test]
+fn messages_translate_by_template_and_their_parts() {
+    let c = Catalog::parse(concat!(
+        "@msg\tnothing selected\tnada seleccionado\n",
+        "@msg\t{path}: {e}\t{path}: {e}\n",
+        "@msg\tCouldn't open {name}: {e}\tNo se pudo abrir {name}: {e}\n",
+        "@msg\tcommand `{0}` is not available right now: {1}\tel comando `{0}` no está disponible ahora: {1}\n",
+        "@msg\t{a}{b}\tnever\n",
+        "@msg\t{n} of {total}\t{total} contiene {n}\n",
+    ));
+    assert_eq!(c.message("nothing selected").map(|m| m.0), Some("nada seleccionado"));
+    // The template with the most literal text wins over the generic `{path}: {e}`.
+    let (tr, caps) = c.message("Couldn't open a: b.svg: damaged").unwrap();
+    assert_eq!(tr, "No se pudo abrir {name}: {e}");
+    assert_eq!(caps, [("name", "a"), ("e", "b.svg: damaged")], "a placeholder takes the shortest text that lets the rest match");
+    assert_eq!(c.message("x of y").unwrap().1, [("n", "x"), ("total", "y")]);
+    assert!(c.message("of y").is_none(), "a placeholder is never empty");
+    assert!(c.message("something else").is_none());
+    assert!(c.message(&"x".repeat(5000)).is_none());
+
+    let es = Lang::from_code("es").unwrap();
+    assert_eq!(message(es, "no such message"), "no such message");
+    // A reason inside a message is translated too, and parts without entries stay as they are.
+    let nested = "command `object.group` is not available right now: nothing selected";
+    let shown = message(es, nested);
+    assert!(shown.contains("`object.group`") && !shown.contains("nothing selected") && !shown.contains("not available"), "{shown}");
+    assert_eq!(message(Lang::EN, nested), nested);
+}
+
+/// Each language that translates status and error messages ([`COMPLETE_MESSAGES`]) has an `@msg`
+/// row for every message in the sources that reach the status bar, so a new one can't ship
+/// untranslated by accident (`VECTORCRAFT_I18N_DUMP_MESSAGES=<file>` lists them).
+#[test]
+fn complete_languages_translate_every_message() {
+    let messages = message_literals();
+    assert!(messages.len() > 300, "scan found only {} messages", messages.len());
+    if let Ok(path) = std::env::var("VECTORCRAFT_I18N_DUMP_MESSAGES") {
+        std::fs::write(path, messages.iter().map(|m| format!("{m}\n")).collect::<String>()).expect("write dump");
+    }
+    for code in COMPLETE_MESSAGES {
+        let lang = Lang::from_code(code).expect("registered");
+        let (entries, _) = parse_entries(lang.0.source);
+        let rows: std::collections::HashSet<&str> = entries.iter().filter(|(ctx, _, _)| ctx == "@msg").map(|(_, src, _)| src.as_str()).collect();
+        let missing: Vec<_> = messages.iter().filter(|m| !rows.contains(m.as_str())).collect();
+        assert!(missing.is_empty(), "{code}: {} untranslated messages: {missing:#?}", missing.len());
+    }
+}
+
+/// Languages whose catalogs cover every status and error message.
+const COMPLETE_MESSAGES: &[&str] = &["es"];
+
+/// Crates whose error and status messages reach the status bar.
+const MESSAGE_CRATES: &[&str] = &["ui-egui", "engine", "doc", "format", "svg", "pdf", "eps", "text", "plugins", "metafile", "cad"];
+
+/// Where a message literal starts: a status, an error value, a `thiserror` message.
+const MESSAGE_MARKERS: &[&str] = &[".status(", "ui.status = ", "status = ", "Other(", "Err(", "ok_or(", "ok_or_else(|| ", "#[error("];
+
+/// Messages that are signals, not text for people.
+const NOT_MESSAGES: &[&str] = &["quit", "cancelled"];
+
+/// Every status and error message literal in [`MESSAGE_CRATES`] (test modules aside), as catalog
+/// templates: `{}` becomes `{_1}`, `{_2}` … and format specs are dropped (`{n:?}` → `{n}`).
+pub fn message_literals() -> std::collections::BTreeSet<String> {
+    let crates = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
+    let mut out = std::collections::BTreeSet::new();
+    let mut stack: Vec<_> = MESSAGE_CRATES.iter().map(|c| crates.join(c).join("src")).collect();
+    while let Some(d) = stack.pop() {
+        for entry in std::fs::read_dir(&d).into_iter().flatten().flatten() {
+            let path = entry.path();
+            let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
+            if path.is_dir() {
+                if name != "tests" {
+                    stack.push(path);
+                }
+            } else if name.ends_with(".rs") && !name.starts_with("tests") {
+                let text = std::fs::read_to_string(&path).unwrap_or_default();
+                let code = without_test_module(&text);
+                for marker in MESSAGE_MARKERS {
+                    for (at, _) in code.match_indices(marker) {
+                        let rest = code[at + marker.len()..].trim_start();
+                        let rest = rest.strip_prefix("format!(").map_or(rest, str::trim_start);
+                        let Some(lit) = rest.strip_prefix('"').and_then(string_literal) else { continue };
+                        let has_word = lit.as_bytes().windows(3).any(|w| w.iter().all(u8::is_ascii_lowercase));
+                        if has_word && !NOT_MESSAGES.contains(&lit.as_str()) {
+                            out.insert(as_template(&lit));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    out
+}
+
+/// Source up to its inline test module (`#[cfg(test)] mod tests {`); declarations of test files
+/// (`#[cfg(test)] mod tests_x;`) don't end it.
+fn without_test_module(text: &str) -> &str {
+    for (at, m) in text.match_indices("#[cfg(test)]") {
+        let after = text[at + m.len()..].trim_start();
+        if let Some(rest) = after.strip_prefix("mod ")
+            && rest.trim_start_matches(|c: char| c.is_alphanumeric() || c == '_').trim_start().starts_with('{')
+        {
+            return &text[..at];
+        }
+    }
+    text
+}
+
+/// The text of a string literal whose opening quote was just read, escapes resolved.
+fn string_literal(s: &str) -> Option<String> {
+    let mut out = String::new();
+    let mut it = s.chars();
+    loop {
+        match it.next()? {
+            '"' => return Some(out),
+            '\\' => match it.next()? {
+                'n' => out.push('\n'),
+                't' => out.push('\t'),
+                c => out.push(c),
+            },
+            c => out.push(c),
+        }
+    }
+}
+
+/// A format string as a catalog template (see [`message_literals`]).
+fn as_template(s: &str) -> String {
+    let mut out = String::new();
+    let mut unnamed = 0;
+    let mut rest = s;
+    while let Some(a) = rest.find('{') {
+        out.push_str(&rest[..a]);
+        let after = &rest[a + 1..];
+        let Some(b) = after.find('}') else { break };
+        let name = after[..b].split(':').next().unwrap_or("");
+        if name.is_empty() {
+            unnamed += 1;
+            out.push_str(&format!("{{_{unnamed}}}"));
+        } else {
+            out.push_str(&format!("{{{name}}}"));
+        }
+        rest = &after[b + 1..];
+    }
+    out.push_str(rest);
+    out
+}

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

@@ -3275,3 +3275,7 @@
 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

@@ -3049,3 +3049,7 @@
 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

@@ -234,6 +234,8 @@ pub struct CanvasCache {
     pub print_tiling: Option<PrintTilingCache>,
     /// [`VectorcraftApp::selection_box`] for (document uid, revision, Use Preview Bounds).
     pub selection_box: Option<((u64, u64, bool), Option<vectorcraft_doc::OrientedBox>)>,
+    /// The tools' cursors as OS cursor bitmaps.
+    pub cursors: cursors::Images,
 }
 
 /// [`CanvasCache::slices`]: the layout of the slices of (document uid, revision).
@@ -367,6 +369,7 @@ impl VectorcraftApp {
                 slices: None,
                 print_tiling: None,
                 selection_box: None,
+                cursors: Default::default(),
             },
             perf: Perf::default(),
             integrated_titlebar: false,
@@ -808,6 +811,15 @@ impl VectorcraftApp {
         place::drop_files(self, files, target);
     }
 
+    /// Fonts installed or removed while the app was in the background are listed when it comes
+    /// back (Refresh Font List by itself): a look at the font folders, a scan only when they changed.
+    fn refresh_installed_fonts(&mut self) {
+        if vectorcraft_text::FontDb::global().installed_fonts_changed() {
+            // A failure shows in the status bar, as the menu item's does.
+            let _ = self.run("text.rescanFonts", json!({}));
+        }
+    }
+
     /// Inject synthetic events (one press/release step or wheel turn per frame). Handlers read the
     /// modifiers egui holds (`i.modifiers`), so a synthetic key, button or wheel turn holds its own
     /// for the frames it spans (a drag's moves included); the keyboard's come back after.
@@ -816,6 +828,7 @@ impl VectorcraftApp {
             match e {
                 egui::Event::ModifiersChanged(m) => self.host_modifiers = *m,
                 egui::Event::WindowFocused(false) => self.host_modifiers = egui::Modifiers::NONE,
+                egui::Event::WindowFocused(true) => self.refresh_installed_fonts(),
                 _ => {}
             }
         }

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

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

@@ -325,7 +325,7 @@ pub fn drop_files(app: &mut VectorcraftApp, files: Vec<(String, Option<String>,
             }),
         };
         if let Err(e) = r {
-            app.status(format!("Couldn't {} {name}: {e}", if target == DropTarget::Open { "open" } else { "place" }));
+            app.status(if target == DropTarget::Open { format!("Couldn't open {name}: {e}") } else { format!("Couldn't place {name}: {e}") });
         }
     }
 }

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

@@ -7,7 +7,7 @@ use std::sync::atomic::Ordering;
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 
-use crate::state::{Dialog, DockTab, UiState};
+use crate::state::{Dialog, DockTab, FloatingFlyout, UiState};
 use crate::theme::Tokens;
 use crate::{VectorcraftApp, widgets};
 
@@ -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();
 }

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/development.md

@@ -109,8 +109,8 @@ international Spanish; every `es-*` locale such as `es-ES`, `es-MX`, `es-AR` or
 - The language is VectorCraft › Language (the `app.language` UI command, `{lang: auto|<code>}`) or Edit ›
   Preferences › User Interface › Language; both set the `interfaceLanguage` preference (`auto` or a language
   code; `auto` follows the system locale: `VECTORCRAFT_LOCALE`, then `LC_ALL`/`LC_MESSAGES`/`LANG`/`LANGUAGE`,
-  the macOS preferred languages, the Windows user locale). The web build has no locale detection yet and
-  starts in English. The Preferences dialog previews the chosen language before OK.
+  the macOS preferred languages, the Windows user locale; on the web, `?lang=<code>` in the address, then
+  the browser's `navigator.languages`). The Preferences dialog previews the chosen language before OK.
 - To add a language: add `<code>.tsv` and one row in `i18n::LANGUAGES` (code, native name, catalog, plural
   rule). The Language menu, the dropdown, locale matching and the catalog tests (well-formed, no duplicates,
   placeholders and ellipses agree, command ids exist, every row of a partial catalog is a string the UI
@@ -119,9 +119,19 @@ international Spanish; every `es-*` locale such as `es-ES`, `es-MX`, `es-AR` or
   (`VECTORCRAFT_I18N_DUMP=strings.txt cargo test -p vectorcraft-ui-egui dump_source_strings` lists them).
 - Translations are clean-room: written from the meaning of the English text in ordinary vocabulary, never
   from another product's localisation resources. Product and technology names stay in Latin letters.
-- Not translated on purpose: status-bar messages and errors (agents and tests read them), names that are
-  user data (layers, swatches, fonts, documents), the tab title's colour mode. Not done yet: locale-aware
-  number and date formats, right-to-left layout, locale detection on the web. Chinese and Japanese UI text
+- Status-bar messages and errors stay English where they are made (`app.ui.status`, `EngineError`: the
+  control channel, MCP and tests read them) and are translated only where the status bar draws them
+  (`i18n::msg`). `@msg` catalog rows hold a whole message or a template such as
+  `Couldn't open {name}: {e}`; `{_1}`, `{_2}` … stand for the format string's `{}`, and the values in the
+  placeholders are translated in turn (the reason after `: {e}` is often a message too). Spanish covers every
+  message literal the test scan finds (`complete_languages_translate_every_message`, languages listed in
+  `COMPLETE_MESSAGES`): a new `Err("…")`, `Other(…)`, `#[error(…)]` or `status(…)` message needs an `es.tsv`
+  row (`VECTORCRAFT_I18N_DUMP_MESSAGES=messages.txt cargo test -p vectorcraft-ui-egui
+  complete_languages_translate_every_message` lists them all). Other languages show messages in English
+  until they add `@msg` rows.
+- Not translated on purpose: names that are user data (layers, swatches, fonts, documents), the tab
+  title's colour mode, command ids and parameter names inside messages. Not done yet: locale-aware number
+  and date formats, right-to-left layout. Chinese and Japanese UI text
   is drawn with craft-fonts' BIZ UDPGothic when the build embeds it (see Fonts above), else with an installed
   system font; the glyph test checks Latin-script catalogs always and the CJK ones only with craft-fonts.
   A Traditional Chinese UI font is still to be added to craft-fonts for the web build.

docs/mcp.md

@@ -1088,9 +1088,12 @@ size. The journal entry of a scaling command records the `strokes` and `corners`
 2 bottom-right, 3 bottom-left), else to the corners holding a Direct-Selected anchor (`select.anchors`), else to all
 four. Each corner keeps its own radius and kind (the shape's `live` in queries has `radii` and, when a corner isn't
 round, `kinds`); a corner with no radius is one anchor, a cut one two, and Direct-Selected corners stay selected as
-that changes. With the Selection or Direct Selection tool, dragging a corner widget rounds the corners whose widgets
-show (all four, or the Direct-Selected ones), Alt-clicking one cycles their kind and double-clicking one opens Corners
-(`ui.corners {id?, corners?}`, dialog `corners`: `kind`, `radius`; OK runs `object.setLiveShape`).
+that changes. Every corner is a circular arc, whatever the rectangle's proportions: a radius past half the shorter
+side draws at half of it (the same limit for every corner), and a rectangle from a file that kept an uneven scale in its
+transform (elliptical corners) gets circular ones in document units when its corners are next set. With the Selection or
+Direct Selection tool, dragging a corner widget rounds the corners whose widgets show (all four, or the Direct-Selected
+ones), outlining them in red once they reach that limit; Alt-clicking one cycles their kind and double-clicking one
+opens Corners (`ui.corners {id?, corners?}`, dialog `corners`: `kind`, `radius`; OK runs `object.setLiveShape`).
 
 ```json
 {"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"id":12,"corners":[1],"radius":16}}}
@@ -2096,15 +2099,20 @@ tone (mono, or CMYK screens multiplied over each other), clipped to the art's ou
 
 ## Fonts
 
-Type can use the bundled fonts, fonts added to the session and the fonts installed on the system (none on the web).
-The installed fonts are cataloged once per session (in the background when the app starts, else on the first lookup
+Type can use the bundled fonts, fonts added to the session and the fonts installed on the system (none on the web):
+the system's and the user's font folders (Windows: `Fonts` and `%LOCALAPPDATA%\Microsoft\Windows\Fonts`, plus fonts
+registered outside them, such as fonts installed as shortcuts; macOS: `/System/Library/Fonts`, `/Library/Fonts`,
+`/Network/Library/Fonts`, `~/Library/Fonts` and downloaded system fonts; Linux and BSD: `/usr/share/fonts`,
+`/usr/local/share/fonts`, `~/.fonts` and the XDG data folders' `fonts`, `~/.local/share/fonts` among them, and in a
+Flatpak sandbox the host's fonts). The installed fonts are cataloged once per session (in the background when the app starts, else on the first lookup
 by family name), so opening, placing, pasting and importing files find them whatever ran before. `text.fontList`
 lists every family available, the installed ones included, as the font menus do: without the system's hidden
 families, whose names start with "." (macOS's ".SF NS", ".LastResort"), which still resolve when a document names
 them. With `family` it gives that family's styles (upright by weight, then italics) and fails when the family isn't
 available. `text.rescanFonts` (Character panel menu ›
 Refresh Font List) scans the font folders again, for fonts installed or removed since the app started: type set in a
-font that became available redraws in it, without editing the document.
+font that became available redraws in it, without editing the document. The app does so by itself when its window
+comes to the front and a font folder changed meanwhile.
 
 ```json
 {"name":"run_command","arguments":{"command":"text.fontList","params":{}}}