Part of gap 5: Scatter, Art and Pattern Brush Options

Double-clicking a Scatter, Art or Pattern brush in the Brushes panel (or the
panel menu's Brush Options...) now opens its options dialog, as Calligraphic
and Bristle brushes already did. OK runs brush.options and every stroke
painted with the brush redraws.

- Scatter Brush Options: Name; Size (10-1000 %), Spacing (10-10000 %),
  Scatter (-1000-1000 %) and Rotation (-180-180 deg), each Fixed (the first
  value), Random (between the two values) or Pressure (the first value at
  the lightest pen pressure, the second at the heaviest); Rotation relative
  to Page or Path. Scatter brushes now keep these modes (`modes`); brushes
  saved before keep their look (Random where the two values differ).
- Art Brush Options: Name; Width (1-1000 %); Scale Proportionately, Stretch
  to Fit Stroke Length or Stretch Between Guides with the guides' Start and
  End (% of the art length); the four Directions; Flip Along and Across.
- Pattern Brush Options: Name; Scale (1-10000 %), Spacing (0-10000 %); the
  five tiles (Outer Corner, Side, Inner Corner, Start, End) drawn with their
  art or None; Flip Along and Across; Stretch to fit, Add space to fit or
  Approximate path.
- All three: Colorization (None, Tints, Tints and Shades, Hue Shift with its
  Key Color picked from the art's colours, the most used one by default) and
  a live preview of a stroke painted with the edited brush.

Brush definitions from files and commands are now kept within these ranges
(Brush::sanitize, also for Calligraphic and Bristle values); unknown modes,
directions, fits or colorization methods are refused. The brush.options and
ui.brushOptions docs list the new params and fields. Tests: the brush model
(modes, pressure, sanitizing, art colours), engine params reaching the
brush and strokes redrawing, junk params in command_sweep, and headless
dialog tests for each dialog.

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

README.md

@@ -201,10 +201,10 @@ For the experimental, unsupported 64-bit Windows 7 build, see [Windows 7 instruc
 VectorCraft is under active development. [**ROADMAP.md**](ROADMAP.md) covers what ships today, the
 milestones, and honest time-to-parity estimates.
 
-**Where we are (2026-10-09):** roughly 69–75% of Illustrator's features exist and work, and about 40–55% of
+**Where we are (2026-10-10):** roughly 69–75% of Illustrator's features exist and work, and about 40–55% of
 "a power user can't tell the difference". Everyday vector illustration is close to usable: drawing and path tools,
 Pathfinder and Shape Builder, paint, gradients, appearance and transparency, type with styles, threading and Hebrew/Arabic bidirectional layout, and
-files (SVG, PDF and PDF-compatible `.ai` with PDF/X, EPS, DXF, EMF/WMF, raster formats and PSD, Print, Package).
+files (SVG, PDF and PDF-compatible `.ai` with PDF/X, EPS, DXF, EMF/WMF, raster formats, PSD out and PSD/PSB in as their merged image, Print, Package).
 Affinity documents (`.af` from Affinity 3, `.afdesign`, `.afpub` and, by their content, `.afphoto` from Affinity 1 and 2) open
 and place natively: layers, groups, artboards and pages, curves and shapes, fills, gradients and strokes, clipping
 and masks, text and images, with what didn't come in (effects, adjustments, brushes, master pages…) listed in the

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-10 (after placed documents (File › Place of a `.vectorcraft` file, linked), 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), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG windoLine truncated
+_Last updated: 2026-10-10 (after placed documents (File › Place of a `.vectorcraft` file, linked), 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), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG windoLine truncated
 
 ## Where we are
 
@@ -35,7 +35,7 @@ since 2026-10-01.
 |---|---|---|
 | **Breadth:** menus, tools and panels exist | ~90% | 13 menu items still stubbed; every tool implemented except Touch Type; 51 panel modules |
 | **Depth:** each feature behaves like Illustrator | ~69–75% | Strong: paint, appearance and colour (M3), Pathfinder and booleans, selection, drawing, files (M4). Weak: advanced type (~45%; inline symbols in text are beyond parity and don't raise it), brushes and symbols (in progress), raster effects (~20%) |
-| **Large missing subsystems** | 0–20% | 3D & Materials (0%), Photoshop-style raster effects and the Effect Gallery (~8 of ~56 filters), SVG Filters, CJK composition (vertical type with kinsoku, tate-chu-yoko and the font's vertical metrics; ruby, mojikumi and proportional vertical metrics open), Variables (data merge), scripting |
+| **Large missing subsystems** | 0–20% | 3D & Materials (0%), Photoshop-style raster effects and the Effect Gallery (~10 of ~56 filters), SVG Filters, CJK composition (vertical type with kinsoku, tate-chu-yoko and the font's vertical metrics; ruby, mojikumi and proportional vertical metrics open), Variables (data merge), scripting |
 | **Interaction fidelity:** modifiers, cursors, small behaviours | ~30–40% | The dedicated pass hasn't started, and there has been no side-by-side session with Illustrator yet. A power user notices this first |
 | **Look & feel** | ~75–80% | Measured against Illustrator 2026 screenshots (2026-10-02); the panels added since haven't been re-measured |
 | **File interop** | ~85% | SVG/SVGZ, PDF and PDF-compatible `.ai`, EPS, DXF, EMF/WMF, raster formats, PSD export and PSD/PSB placement (merged image), Place and Links, Package, Print, clipboard flavours. Affinity documents (Affinity 1–3) open natively as editable art, checked against 51 pinned public files (33 current `.af`), with selected saved-thumbnail comparisons and every-board native/SVG/PDF/PSD checks for current files; Affinity export is missing and effects, adjustments and brushes don't import. Affinity isn't an Illustrator feature, so this doesn't raise the parity score. The editing copy inside an Illustrator EPS or `.ai` is read for its structure: layers, groups, names, hidden objects and type, colours, gradients, transparency, images and every artboard (see Out of scope for what it doesn't read yet); DWG has no open spec |
@@ -53,13 +53,13 @@ Ordered by how much each gap blocks someone from switching. Sizes are one-agent
 1. **Interaction fidelity:** go tool by tool and panel by panel against `plan/illustrator/05-tools.md`,
    `06-panels.md` and `09-shortcuts.md`, covering modifier keys, cursors, the Properties panel per context and
    isolation mode. The Shaper’s rough-square recognition and shape orientation steps are corrected; Shaper Groups now retain editable originals for region merges/punches and separate fill/stroke edits; their construction-mode widget and gesture refinements remain. 60–90 h.
-2. **Photoshop-style raster effects and the Effect Gallery:** about 47 filters (Artistic, Brush Strokes, Distort,
-   Sketch, Stylize, Texture, Video) and the Effect Gallery. The pixel-filter pipeline is in place
+2. **Photoshop-style raster effects and the Effect Gallery:** about 45 filters (Artistic, Brush Strokes, Distort,
+   Sketch, Stylize, Texture) and the Effect Gallery. The pixel-filter pipeline is in place
    (`vectorcraft_effects::pixel`: the object rendered offscreen, filtered in stack order with Gaussian Blur and
    Feather, cached while panning, images in PDF/SVG/Expand Appearance) with Blur › Radial Blur and Smart Blur
-   (Normal mode only), Pixelate › Color Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask and
-   Stylize › Glowing Edges; each new filter is now one function, a catalogue row, menu and translations. Parallelizes
-   well across agents. 24–37 h.
+   (Normal mode only), Pixelate › Color Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask,
+   Stylize › Glowing Edges and Video › De-Interlace and NTSC Colors; each new filter is now one function, a catalogue row, menu and translations. Parallelizes
+   well across agents. 23–36 h.
 3. **3D and Materials:** Extrude & Bevel, Revolve, Inflate and Rotate with lighting and materials, using a software
    renderer in its own crate (layering allows it below L6), with output in SVG/PDF as rasters or projected vectors.
    The largest single gap. 50–80 h.
@@ -68,10 +68,12 @@ Ordered by how much each gap blocks someone from switching. Sizes are one-agent
    composer choice is done), tab leaders, a
    spell-check dictionary (open licence), Touch Type and Snap to Glyph. Vertical point, area and path type have
    initial support. 34–47 h across type core and advanced.
-5. **Brushes, symbols and libraries:** brush options depth (Scatter, Art and Pattern Brush Options; Calligraphic
-   and Bristle are done, Calligraphic with pen pressure); original brush, symbol and graphic-style libraries
-   generated in code (never Adobe's); dynamic symbols; Start Global Edit; brushes driven by pen tilt, bearing and
-   barrel rotation (6D art pens, #372), which needs tablet input beyond pressure on every platform. 20–32 h.
+5. **Brushes, symbols and libraries:** brush options depth (Brush Options exist for every brush type, Calligraphic
+   and Scatter with pen pressure; still missing are the Art brush's Overlap, auto-generated Pattern brush corners,
+   new tile art picked in Pattern Brush Options and the Key Color eyedropper); original brush, symbol and
+   graphic-style libraries generated in code (never Adobe's); dynamic symbols; Start Global Edit; brushes driven by
+   pen tilt, bearing and barrel rotation (6D art pens, #372), which needs tablet input beyond pressure on every
+   platform. 17–28 h.
 6. **Automation:** Variables (data merge), a scripting surface over the command registry, batch. 8–12 h.
 7. **Views and windows:** multiple windows and arrange, Consolidate All Windows, video
    rulers. 15–25 h.
@@ -138,7 +140,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - **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). Live Corners work on any path's corners too, as on a rectangle's (#511): a star's, a live polygon's (which also shows them to the Selection tool, has a Corner Radius field in the Properties and Transform panels and keeps its radius as its sides change) and a pen path's, wherever two straight sides meet at an anchor. Direct Selection shows the widgets of every corner, or of the corners holding selected anchors; each corner is a circle tangent to both sides, drawn no larger than takes its cut halfway along its shorter side; a path keeps its uncut outline so its corners stay editable, and the same command, dialog, angle preference and View › Hide Corner Widget apply.
   - **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. A press on the first anchor of the path being drawn closes it whatever the drag then does: the drag shapes the closing curve (symmetric handles, Alt breaks them) and the release closes the path wherever it ends (#501). 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. Alt held over a handle end or an anchor of a selected path (the one being drawn too) works as the Anchor Point tool, with its convert cursor: dragging a handle moves it alone, clicking a smooth anchor makes it a corner, dragging an anchor pulls out new symmetric handles, dragging a segment reshapes it; drawing then goes on. Cmd (Ctrl) held drags with the selection tool chosen last, Direct Selection until one is (handles, anchors and segments of the path being drawn or another), and the Pen then goes on drawing its path while that stays selected; the pointer shows that tool's while Cmd is held. The same holds for agents (`pointer_gesture` with `mods.cmd`), as the borrowing now lives in the engine (#494).
   - **Path editing (#494):** the handles shown are the handles that drag: Direct Selection drags those of a path selected as a whole (as the Pen leaves it), the Anchor Point tool and Pen+Alt no longer grab handles that Show handles when multiple anchors are selected hides, a handle shorter than the tolerance leaves its anchor to be picked, and the anchor tools pick within Selection & Anchor Display › Tolerance. A dragged segment keeps a smooth anchor at either end smooth. With Direct Selection, the Pen, the Curvature and the anchor tools, a path selected as a whole shows all its anchors selected, and the Control bar and the Properties panel offer Convert (corner, smooth) for them too; Remove and Cut wait for anchors direct-selected (#504). A handle drag gathers its snap targets once per drag (it took 21 ms per pointer move on a 20,000-path document, now 1 ms; `vectorcraft-cli perf` measures handle and segment drags on a 5,000-anchor path).
-  - **Graphs:** Column, Stacked Column, Bar, Stacked Bar, Line, Area, Scatter, Pie and Radar graph tools with Graph Data and Graph Type. A series starts in greyscale; Group Selection's fill and stroke are kept separately on the graph and reapplied when its data, type or size changes, and through save, open and undo. Graph Design, Column and Marker artwork remain open.
+  - **Graphs:** Column, Stacked Column, Bar, Stacked Bar, Line, Area, Scatter, Pie and Radar graph tools with Graph Data and Graph Type. A series starts in greyscale; Group Selection's fill and stroke are kept separately on the graph and reapplied when its data, type or size changes, and through save, open and undo. Graph Type's Override Calculated Values (both `axisMin` and `axisMax`) uses exactly that value-axis range, split into the tick count (5 when automatic). Line graphs take Edge-to-Edge Lines (off by default: the points sit at the centres of their categories; graphs saved before the option keep their edge-to-edge lines), and radar graphs follow Mark Data Points and Connect Data Points. Graph Design, Column and Marker artwork remain open.
   - **Other:** Eyedropper, Gradient annotator, Artboard (Alt-drag duplicates an artboard, and its art with Move/Copy Artwork with Artboard on; Copy, Cut and Paste take the artboard with its art, Paste right of the last artboard, Paste in Place where it was, into this or another document, #446; Object › Artboards › Rearrange All Artboards lays them out in a grid by row or by column, in one row or one column, left to right or right to left, from the menu, the Artboards panel or Properties' Rearrange All, #681; Scale Artwork with Artboard, in the Control bar and Properties beside Move Artwork with Artboard, resizes the artboard proportionally with the art fully inside it and its guides, strokes and corners per the Scale preferences, #602), Measure, Type, Hand, Zoom, Rotate View.
   - **Editing type:** double-clicking type with a selection tool switches to the Type tool with the caret where it was clicked.
   - **Temporary tools:** Cmd with any other tool drags with the selection tool used last (Selection, Direct Selection or Group Selection). Held Space pans and Cmd+Space zooms (Cmd+Alt+Space out) whatever the tool.
@@ -160,7 +162,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - **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 (the Properties panel has the Control bar's Fill and Stroke chips, Stroke link and weight spinner, with nothing selected too), panels have Illustrator's Window menu keys (Align Shift+F7, Transform Shift+F8, Pathfinder Cmd+Shift+F9, Layers F7, Character Cmd+T…; every panel can be given one in Edit › Keyboard Shortcuts), and Eyedropper Options pick up and apply chosen attributes (Alt and Shift+Alt, image pixels). An ICC CMYK profile converts straight into the RGB working space (not through sRGB, so a wider space such as Wide Gamut RGB keeps colours sRGB can't hold) with the colour settings' black-point compensation, on the canvas and in RGB exports alike. Fills and strokes can overprint (Attributes panel, Overprint Black options), and CMYK documents blend in inks on screen, in PDF and when flattening. Document Color Mode converts the art, symbols, pattern tiles and swatches through the colour settings: Gray stays Gray, RGB greys separate into four-colour greys and a rich black as Illustrator does, or go on the black plate only with `grays: "black"` (also for `document.open {colorMode}`).
   - **Gradients:** lossless, validated gradient params; gradients follow rotate, reflect, shear, non-uniform scale and distortions; the Gradient tool edits the fill or stroke of the active proxy, type included; an interactive on-canvas annotator (move, length/angle, rotate, add/move/delete/duplicate stops, midpoints, a stop popover, Delete and arrow keys). The Gradient panel has the Fill/Stroke proxy, a gradient-swatch dropdown with Save to Swatches, midpoint locations, Alt-drag to copy or swap stops, swatch drops on the ramp and a stop eyedropper; copied appearances and graphic styles place gradients on each target's own bounds; gradient handles snap and honour Constrain Angle. Gradient stops stay linked to global and spot swatches. Freeform gradients (points and lines) are edited on the canvas; radial gradients have an extent ellipse, an aspect handle and an off-centre focal point (SVG `fx`/`fy`, PDF two-point radials). A stroke's gradient runs within, along or across it. Object ▸ Expand turns gradients into N objects or a gradient mesh.
   - **Strokes:** one stroke-geometry module shared by the canvas, SVG, PDF and Outline Stroke; dotted lines (zero-length dashes draw dots or squares); arrowheads with hollow outlines, tip-on-end or extend-past-end alignment and one opacity for line and head. SVG and PDF export arrowheads, width profiles, brushes and aligned strokes exactly as the canvas draws them; Outline Stroke and the live Outline Stroke effect outline every stroke item as drawn (dashes, heads, profiles, alignment); dashes can be fitted to corners and path ends; width profiles carry through dashes, and their corners take the join. The Stroke panel edits type's character strokes, follows the stroke units (its weight presets are round values in that unit: `0.25 mm`, `0.0625 in`, `1 px`, #426; fields show four decimals in mm, cm and inches, three in points), shows mixed values blank and opens from the Control bar. A width profile library, thirty more arrowheads, and Width Point Edit with multi-select and discontinuous points. Visual bounds and clicks cover the whole painted stroke. Scale Strokes & Effects, Scale Corners and Use Preview Bounds work everywhere, and new art inherits stroke options, a graphic style or the whole last appearance.
-  - **Brushes (part of #852):** double-clicking a brush in the Brushes panel (or the panel menu's Brush Options…) opens Calligraphic Brush Options (Name; Angle, Roundness and Size, each Fixed, Random or Pressure with its Variation; live previews of the nib and of a light–heavy–light stroke) or Bristle Brush Options (Shape and the bristle sliders); OK edits the brush and every stroke painted with it. The Paintbrush records the pen pressure along each stroke (kept with the path, saved, and joined when a stroke continues a path); a Calligraphic value on Pressure goes from value − variation at the lightest pressure to value + variation at the heaviest, on the canvas and in SVG, PDF and the other exports. Brushes saved before keep their look. Still to come: Scatter, Art and Pattern Brush Options, Stylus Wheel, Tilt, Bearing and Rotation, and pen pressure on macOS.
+  - **Brushes (part of #852):** double-clicking a brush in the Brushes panel (or the panel menu's Brush Options…) opens Calligraphic Brush Options (Name; Angle, Roundness and Size, each Fixed, Random or Pressure with its Variation; live previews of the nib and of a light–heavy–light stroke) or Bristle Brush Options (Shape and the bristle sliders); OK edits the brush and every stroke painted with it. The Paintbrush records the pen pressure along each stroke (kept with the path, saved, and joined when a stroke continues a path); a Calligraphic value on Pressure goes from value − variation at the lightest pressure to value + variation at the heaviest, on the canvas and in SVG, PDF and the other exports. Brushes saved before keep their look. Scatter Brush Options (Size, Spacing, Scatter and Rotation, each Fixed, Random between two values or Pressure from the first at the lightest pressure to the second at the heaviest; Rotation relative to Page or Path), Art Brush Options (Width, Scale Proportionately, Stretch to Fit Stroke Length or Stretch Between Guides with the guides' start and end, the four Directions, Flip Along and Across) and Pattern Brush Options (Scale, Spacing, the five tiles shown, Flip Along and Across, Stretch to fit, Add space to fit or Approximate path) each have Colorization (None, Tints, Tints and Shades, Hue Shift with its Key Color picked from the art's colours) and a live stroke preview; values from files and commands are clamped to their ranges. Still to come: the Art brush's Overlap, auto-generated Pattern brush corners, new tile art picked in Pattern Brush Options, Stylus Wheel, Tilt, Bearing and Rotation, and pen pressure on macOS.
   - **Appearance:** the Appearance panel's selected row drives every paint, stroke, gradient and transparency edit (`item` on the commands); effects apply to one fill or stroke; per-item Opacity popups, whose blend-mode list and opacity slider stay open inside them (#430; the Control bar's Stroke popover too); Mixed Appearances, Layers target dots and basic-appearance rules. Effects can be reordered, moved between items and copied by dragging; Show All Hidden Attributes; clicking an effect edits it in place; the object thumbnail drags onto art; effects render on type, images, symbols, blends, envelopes, meshes and repeats, and per-item raster effects export. Groups, layers and type have their own fills, strokes and effects (Contents and Characters rows); the Layers panel's target circles target layers, groups and objects; Expand Appearance turns fills, strokes, effects and brushes into objects.
   - **Masks and clipping:** opacity-mask controls work while the mask is being edited; transparency commands take ids and work without a selection; clipping sets clip by compound paths, even-odd paths, text and groups on screen and in raster export, matching SVG/PDF. Alt-click shows only the mask; SVG masks keep Clip and Invert; the transparency grid is per-document state; a clipping path's own fill and stroke paint behind and over the clipped art; layers can be clipping masks.
   - **Transparency:** three-state Knockout Group (on, neutral, off), Opacity & Mask Define Knockout Shape, Page Isolated Blending and Page Knockout Group, on screen and in SVG/PDF. Blend modes match the standard formulas on screen, in SVG and in PDF, and non-isolated groups blend with the art below. Flatten Transparency with presets, a dialog and a Flattener Preview panel.
@@ -220,10 +222,10 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Drawing tools | 7 | 85% | rough-square Shaper recognition and orientation steps corrected; editable Shaper Groups landed; remaining: Shaper construction widget/gesture refinements, 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 corners between curved sides (and Relative rounding) | 8–13 |
 | 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 | 89% | Scatter, Art and Pattern Brush Options (Calligraphic and Bristle done), brush libraries (generated in code), pen pressure on macOS (the windowing layer reports none there), brushes driven by pen tilt, bearing and barrel rotation (6D art pens) | 10–18 |
+| Strokes, brushes, width profiles | 5 | 90% | the Art brush's Overlap, auto-generated Pattern brush corners and new tile art in Pattern Brush Options (Brush Options for every brush type done), brush libraries (generated in code), pen pressure on macOS (the windowing layer reports none there), brushes driven by pen tilt, bearing and barrel rotation (6D art pens) | 8–15 |
 | Appearance, transparency, graphic styles, masks | 5 | 98% | raster effect reach in preview bounds (flattener presets apply in PDF, EPS and print) | 1–2 |
 | Live vector effects | 5 | 85% | Outline Object, Pathfinder Hard/Soft Mix and Trap, SVG Filters, the Transform effect's Transform Objects/Patterns and Scale Strokes & Effects options | 6–10 |
-| Raster effects (Effect Gallery, Document Raster Effects Settings) | 4 | 28% | ~47 Photoshop-style filters (Artistic, Brush Strokes, Distort, Sketch, Stylize, Texture, Video), Smart Blur's Edge Only / Overlay Edge modes and the Effect Gallery; Document Raster Effects Settings, raster effects in PDF, the pixel-filter pipeline, Radial Blur, Smart Blur, Unsharp Mask, Glowing Edges and Pixelate (Color Halftone, Crystallize, Mezzotint, Pointillize) are done | 24–37 |
+| Raster effects (Effect Gallery, Document Raster Effects Settings) | 4 | 29% | ~45 Photoshop-style filters (Artistic, Brush Strokes, Distort, Sketch, Stylize, Texture), Smart Blur's Edge Only / Overlay Edge modes and the Effect Gallery; Document Raster Effects Settings, raster effects in PDF, the pixel-filter pipeline, Radial Blur, Smart Blur, Unsharp Mask, Glowing Edges, Pixelate (Color Halftone, Crystallize, Mezzotint, Pointillize) and Video (De-Interlace, NTSC Colors) are done | 23–36 |
 | 3D and Materials | 4 | 0% | Extrude & Bevel, Revolve, Inflate, Rotate, lighting, materials (software renderer) | 50–80 |
 | Type core | 9 | 80% | Middle Eastern features beyond bidi layout and Paragraph Direction (Character Direction, digit types, kashidas, the Middle Eastern composers, editable bidirectional SVG text, a split caret where directions meet); Hyphenation… and Justification… options (Every-line Composer for justified and ragged text, per object, is done; it is tuned by eye, not yet compared side by side with Illustrator; mixed type sizes in a paragraph still break single-line), Optical Margin Alignment, paragraph spacing limit for vertically justified area type, hidden characters, paragraph attributes in the Type tool's copy and paste (the characters keep their styles, the paragraphs take the destination's), mixed-value display in the Paragraph panel for a selection across differing paragraphs, Transform Again after a type-area resize (it scales the type), partial selection of type-area anchors by marquee | 14–19 |
 | Type advanced | 4 | 50% | CJK composition for vertical type (ruby, mojikumi beyond Line-end Punctuation Half Width — the other sets (and their paragraph-start bracket and indent rules), custom kinsoku sets (beyond Hard, Soft and None) and the Mojikumi Settings dialog —, proportional vertical metrics, manual tate-chu-yoko), variable font axis sliders (named instances are styles), tab leaders, spell check (open dictionary), Touch Type, Retype; vertical point/area/path type and Type Orientation have initial support (beyond parity, not scored: inline symbols in text) | 20–28 |
@@ -237,7 +239,7 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Print, colour management, separations, flattener | 3 | 80% | print preview fidelity (flattener presets in PDF and print, overprint in PDF and composite print, Print dialog, presets, PostScript, marks, separations, Print Tiling, print overprint/flattener/bitmap options and printer profile are done) | 1–2 |
 | Automation | 3 | 60% | Variables (data merge), scripting surface, batch | 8–12 |
 | UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 78% | macOS native menu dismissal fixed (M14.8); remaining: Variables, SVG Interactivity, Properties per context, Consolidate All Windows, floating panels outside the app window and docked into any group, context menus beyond the canvas (Links, Asset Export, CSS Properties, Attributes and the canvas context menu are done), about 17 Preferences options stored but not yet acted on (#394: Highlight Alternate Glyphs, Open Documents As Tabs, Real-time Drawing, hyphenation language, Appearance of Black, devices…) | 14–22 |
-| Libraries, Links, Package | 2 | 80% | the Libraries panel is local only (no cloud by design: libraries are files on this machine) and has no shared libraries, linked graphics or gradients and patterns as items yet; its graphics, colours and text styles are done (#745); Links and Package are done; placed VectorCraft documents are done (linked by default, vectors in every output, previews, Break Link, Expand, Edit Original, refresh on save) | 2–3 |
+| Libraries, Links, Package | 2 | 82% | the Libraries panel is local only (no cloud by design: libraries are files on this machine) and has no shared libraries, linked graphics or gradients and patterns as items yet; its graphics, colours and text styles (#745) and its search, groups and library export/import as `.vclibrary` files (#926) are done; Links and Package are done; placed VectorCraft documents are done (linked by default, vectors in every output, previews, Break Link, Expand, Edit Original, refresh on save) | 2–3 |
 | **Feature parity** | **103** | **~75%** | | **~210–330** |
 | Interaction-fidelity pass (side by side with Illustrator: every tool modifier, cursor, dialog, Properties context) | | | | 60–90 |
 | Hardening (big-file corpus, fuzzing, cross-platform and browser QA, accessibility, packaging) | | | | 50–80 |

crates/brush/src/colorize.rs

@@ -115,3 +115,31 @@ pub fn instance_art(art: &Node, inst: &Node) -> Node {
     }
     a
 }
+
+/// The solid colours of the fills and strokes under `nodes`, most used first (then in the order
+/// they first appear): the colours Brush Options offers as Hue Shift's key colour, the first being
+/// its default.
+pub fn art_colors<'a>(nodes: impl IntoIterator<Item = &'a Node>) -> Vec<Color> {
+    fn walk(n: &Node, seen: &mut std::collections::HashMap<String, (usize, usize, Color)>) {
+        for it in &n.appearance.items {
+            let (visible, paint) = match it {
+                AppearanceItem::Fill(f) => (f.visible, &f.paint),
+                AppearanceItem::Stroke(s) => (s.visible, &s.paint),
+            };
+            if let (true, Some(c)) = (visible, paint.color()) {
+                let order = seen.len();
+                seen.entry(c.to_hex()).or_insert((0, order, c)).0 += 1;
+            }
+        }
+        for c in n.children().into_iter().flatten() {
+            walk(c, seen);
+        }
+    }
+    let mut seen = std::collections::HashMap::new();
+    for n in nodes {
+        walk(n, &mut seen);
+    }
+    let mut v: Vec<(usize, usize, Color)> = seen.into_values().collect();
+    v.sort_by(|a, b| b.0.cmp(&a.0).then(a.1.cmp(&b.1)));
+    v.into_iter().map(|(.., c)| c).collect()
+}

crates/brush/src/defaults.rs

@@ -172,6 +172,7 @@ pub fn defaults() -> &'static [Brush] {
                     rotation: (-180.0, 180.0),
                     rotation_relative_to_path: false,
                     colorization: Colorization::Tints,
+                    modes: None,
                 }),
             },
             Brush {
@@ -184,6 +185,7 @@ pub fn defaults() -> &'static [Brush] {
                     rotation: (-35.0, 35.0),
                     rotation_relative_to_path: true,
                     colorization: Colorization::None,
+                    modes: None,
                 }),
             },
             Brush {

crates/brush/src/lib.rs

@@ -23,7 +23,7 @@ use vectorcraft_color::Paint;
 use vectorcraft_doc::{Appearance, AppearanceItem, Document, FillLayer, Node, NodeId, NodeKind, StrokeLayer};
 use vectorcraft_geom::{BezPath, Rect};
 
-pub use colorize::{colorize, instance_art, stain, tint_node};
+pub use colorize::{art_colors, colorize, instance_art, stain, tint_node};
 pub use defaults::defaults;
 pub use serde_json;
 
@@ -71,6 +71,15 @@ impl BrushKind {
             BrushKind::Bristle(_) => "bristle",
         }
     }
+    /// How the brush's art takes the stroke colour (Calligraphic and Bristle brushes paint with it).
+    pub fn colorization(&self) -> Colorization {
+        match self {
+            BrushKind::Art(a) => a.colorization,
+            BrushKind::Scatter(s) => s.colorization,
+            BrushKind::Pattern(p) => p.colorization,
+            BrushKind::Calligraphic(_) | BrushKind::Bristle(_) => Colorization::None,
+        }
+    }
 }
 
 /// How brush art takes the stroke colour.
@@ -88,6 +97,29 @@ pub enum Colorization {
     HueShift { key: vectorcraft_color::Color },
 }
 
+impl Colorization {
+    pub const IDS: [&'static str; 4] = ["none", "tints", "tintsAndShades", "hueShift"];
+    /// The name brush definitions use (`method`).
+    pub fn id(&self) -> &'static str {
+        match self {
+            Colorization::None => "none",
+            Colorization::Tints => "tints",
+            Colorization::TintsAndShades => "tintsAndShades",
+            Colorization::HueShift { .. } => "hueShift",
+        }
+    }
+    /// The method named `id` (`key`: the key colour of Hue Shift).
+    pub fn parse(id: &str, key: vectorcraft_color::Color) -> Option<Self> {
+        Some(match id {
+            "none" => Colorization::None,
+            "tints" => Colorization::Tints,
+            "tintsAndShades" => Colorization::TintsAndShades,
+            "hueShift" => Colorization::HueShift { key },
+            _ => return None,
+        })
+    }
+}
+
 /// Calligraphic brush: an elliptical nib swept along the path. Sizes are at 1 pt stroke weight
 /// (the stroke weight scales the brush).
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -181,6 +213,12 @@ pub struct Scatter {
     /// Rotation relative to the path direction (else to the page).
     pub rotation_relative_to_path: bool,
     pub colorization: Colorization,
+    /// How size, spacing, scatter and rotation vary between their two values: Fixed takes the
+    /// first, Random any value between them, Pressure the first at the lightest pen pressure and
+    /// the second at the heaviest. `None` (brushes saved before there were modes): Random where
+    /// the two differ, else Fixed — see [`Scatter::modes`].
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub modes: Option<[Variation; 4]>,
 }
 
 impl Default for Scatter {
@@ -193,10 +231,25 @@ impl Default for Scatter {
             rotation: (0.0, 0.0),
             rotation_relative_to_path: false,
             colorization: Colorization::None,
+            modes: None,
         }
     }
 }
 
+impl Scatter {
+    /// The ranges of size (%), spacing (%), scatter (%) and rotation (°).
+    pub const RANGES: [(f64, f64); 4] = [(1.0, 10000.0), (1.0, 10000.0), (-1000.0, 1000.0), (-180.0, 180.0)];
+
+    /// Size, spacing, scatter and rotation, each as its (first, second) values.
+    pub fn values(&self) -> [(f64, f64); 4] {
+        [self.size, self.spacing, self.scatter, self.rotation]
+    }
+    /// How size, spacing, scatter and rotation vary.
+    pub fn modes(&self) -> [Variation; 4] {
+        self.modes.unwrap_or_else(|| self.values().map(|(a, b)| if a != b { Variation::Random } else { Variation::Fixed }))
+    }
+}
+
 /// Direction the art runs in the brush definition.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -236,6 +289,11 @@ pub struct ArtBrush {
     pub colorization: Colorization,
 }
 
+impl ArtBrush {
+    /// The range of the width (%).
+    pub const WIDTH_RANGE: (f64, f64) = (1.0, 1000.0);
+}
+
 impl Default for ArtBrush {
     fn default() -> Self {
         Self {
@@ -286,6 +344,12 @@ pub struct PatternBrush {
     pub colorization: Colorization,
 }
 
+impl PatternBrush {
+    /// The ranges of the scale and of the spacing (%).
+    pub const SCALE_RANGE: (f64, f64) = (1.0, 10000.0);
+    pub const SPACING_RANGE: (f64, f64) = (0.0, 10000.0);
+}
+
 impl Default for PatternBrush {
     fn default() -> Self {
         Self {
@@ -340,12 +404,104 @@ pub struct Bristle {
     pub stiffness: f64,
 }
 
+impl Bristle {
+    /// The ranges of the size (pt), the bristle length (%) and the other percentages.
+    pub const SIZE_RANGE: (f64, f64) = (0.1, 1296.0);
+    pub const LENGTH_RANGE: (f64, f64) = (25.0, 300.0);
+    pub const PERCENT_RANGE: (f64, f64) = (1.0, 100.0);
+}
+
 impl Default for Bristle {
     fn default() -> Self {
         Self { shape: BristleShape::RoundPoint, size: 6.0, length: 100.0, density: 50.0, thickness: 40.0, opacity: 75.0, stiffness: 50.0 }
     }
 }
 
+// ---------- validation ----------
+
+/// `v` within `(lo, hi)`; `fallback` (kept within too) when it isn't a number.
+fn within(v: f64, (lo, hi): (f64, f64), fallback: f64) -> f64 {
+    if v.is_finite() { v.clamp(lo, hi) } else { fallback.clamp(lo, hi) }
+}
+
+fn within_pair((a, b): (f64, f64), range: (f64, f64), fallback: f64) -> (f64, f64) {
+    (within(a, range, fallback), within(b, range, fallback))
+}
+
+impl Colorization {
+    /// A Hue Shift key colour that isn't a colour (components out of reach) becomes black.
+    fn sanitize(&mut self) {
+        if let Colorization::HueShift { key } = self
+            && !key.to_rgb().iter().all(|c| c.is_finite())
+        {
+            *key = vectorcraft_color::Color::BLACK;
+        }
+    }
+}
+
+impl Brush {
+    /// The art the brush is made of: a scatter or art brush's art, a pattern brush's tiles.
+    pub fn art(&self) -> Vec<&Node> {
+        match &self.kind {
+            BrushKind::Scatter(s) => vec![&s.art],
+            BrushKind::Art(a) => vec![&a.art],
+            BrushKind::Pattern(p) => {
+                std::iter::once(&p.side).chain([&p.outer_corner, &p.inner_corner, &p.start, &p.end].into_iter().flatten()).collect()
+            }
+            BrushKind::Calligraphic(_) | BrushKind::Bristle(_) => vec![],
+        }
+    }
+
+    /// Keep every value of the definition within its range (definitions come from files and
+    /// commands, so they are untrusted): numbers are clamped, non-numbers take the default.
+    pub fn sanitize(&mut self) {
+        match &mut self.kind {
+            BrushKind::Calligraphic(c) => {
+                let d = Calligraphic::default();
+                let [angle, roundness, size] = Calligraphic::RANGES;
+                c.angle = within(c.angle, angle, d.angle);
+                c.roundness = within(c.roundness, roundness, d.roundness);
+                c.size = within(c.size, size, d.size);
+                for (v, max) in c.variation.iter_mut().zip(Calligraphic::MAX_VARIATION) {
+                    *v = within(*v, (0.0, max), 0.0);
+                }
+            }
+            BrushKind::Scatter(s) => {
+                let d = Scatter::default();
+                let [size, spacing, scatter, rotation] = Scatter::RANGES;
+                s.size = within_pair(s.size, size, d.size.0);
+                s.spacing = within_pair(s.spacing, spacing, d.spacing.0);
+                s.scatter = within_pair(s.scatter, scatter, 0.0);
+                s.rotation = within_pair(s.rotation, rotation, 0.0);
+                s.colorization.sanitize();
+            }
+            BrushKind::Art(a) => {
+                a.width = within(a.width, ArtBrush::WIDTH_RANGE, 100.0);
+                if let ArtScale::BetweenGuides { start, end } = &mut a.scale {
+                    *start = within(*start, (0.0, 1.0), 0.0);
+                    *end = within(*end, (0.0, 1.0), 1.0);
+                }
+                a.colorization.sanitize();
+            }
+            BrushKind::Pattern(p) => {
+                p.scale = within(p.scale, PatternBrush::SCALE_RANGE, 100.0);
+                p.spacing = within(p.spacing, PatternBrush::SPACING_RANGE, 0.0);
+                p.colorization.sanitize();
+            }
+            BrushKind::Bristle(b) => {
+                let d = Bristle::default();
+                b.size = within(b.size, Bristle::SIZE_RANGE, d.size);
+                b.length = within(b.length, Bristle::LENGTH_RANGE, d.length);
+                for (v, fallback) in
+                    [(&mut b.density, d.density), (&mut b.thickness, d.thickness), (&mut b.opacity, d.opacity), (&mut b.stiffness, d.stiffness)]
+                {
+                    *v = within(*v, Bristle::PERCENT_RANGE, fallback);
+                }
+            }
+        }
+    }
+}
+
 // ---------- library ----------
 
 /// The brush library of `doc`: its stored brushes, or the defaults when it has none.
@@ -356,9 +512,15 @@ pub fn library(doc: &Document) -> Vec<Brush> {
     }
 }
 
-/// Parse a stored library value (malformed entries are skipped).
+/// Parse a stored library value (malformed entries are skipped, values kept within their
+/// ranges — see [`Brush::sanitize`]).
 pub fn parse_library(v: &serde_json::Value) -> Vec<Brush> {
-    v.as_array().map(|a| a.iter().filter_map(|b| serde_json::from_value(b.clone()).ok()).collect()).unwrap_or_default()
+    let parse = |b: &serde_json::Value| {
+        let mut b: Brush = serde_json::from_value(b.clone()).ok()?;
+        b.sanitize();
+        Some(b)
+    };
+    v.as_array().map(|a| a.iter().filter_map(parse).collect()).unwrap_or_default()
 }
 
 /// Store `lib` as the document's brush library.
@@ -404,15 +566,10 @@ pub fn stroke_pieces(brush: &Brush, bp: &BezPath, stroke: &StrokeLayer) -> Vec<N
         BrushKind::Calligraphic(c) => calli::calligraphic(c, bp, w, stroke, &brush.name),
         BrushKind::Bristle(b) => calli::bristle(b, bp, w, &stroke.paint, &brush.name),
         BrushKind::Art(a) => warp::art(a, bp, w),
-        BrushKind::Scatter(s) => warp::scatter(s, bp, w, &brush.name),
+        BrushKind::Scatter(s) => warp::scatter(s, bp, w, stroke.pressure.as_ref(), &brush.name),
         BrushKind::Pattern(p) => warp::pattern(p, bp, w),
     };
-    let colorization = match &brush.kind {
-        BrushKind::Art(a) => a.colorization,
-        BrushKind::Scatter(s) => s.colorization,
-        BrushKind::Pattern(p) => p.colorization,
-        _ => Colorization::None,
-    };
+    let colorization = brush.kind.colorization();
     for n in &mut out {
         colorize(n, colorization, &stroke.paint);
     }

crates/brush/src/tests.rs

@@ -447,3 +447,77 @@ fn junk_pressure_brushes_draw_finite_art() {
         }
     }
 }
+
+/// A scatter brush of 10 × 4 pt rectangles whose size goes from `lo` % to `hi` % as `mode` says.
+fn sized_scatter(lo: f64, hi: f64, mode: Variation) -> Brush {
+    let s = scatter_brush(100.0);
+    let BrushKind::Scatter(sc) = s.kind else { panic!("not a scatter brush") };
+    let modes = [mode, Variation::Fixed, Variation::Fixed, Variation::Fixed];
+    Brush { kind: BrushKind::Scatter(Scatter { size: (lo, hi), modes: Some(modes), ..sc }), ..s }
+}
+
+/// Scatter Brush Options: Fixed takes the first value, Pressure goes from the first at the
+/// lightest pen pressure to the second at the heaviest; brushes saved before modes keep their look.
+#[test]
+fn scatter_values_follow_their_modes() {
+    let bp = line(0.0, 0.0, 400.0, 0.0);
+    let heights =
+        |b: &Brush, st: &StrokeLayer| -> Vec<f64> { stroke_pieces(b, &bp, st).iter().map(|n| n.geometric_bounds().unwrap().height()).collect() };
+    // Fixed: every copy at 50 %, whatever the second value.
+    assert!(heights(&sized_scatter(50.0, 300.0, Variation::Fixed), &stroke(1.0)).iter().all(|h| near(*h, 2.0, 1e-6)));
+    // Pressure: light at the start (50 %: 2 pt tall), heavy at the end (300 %: 12 pt).
+    let ramp = pressed(vec![(0.0, 0.0), (1.0, 1.0)]);
+    let h = heights(&sized_scatter(50.0, 300.0, Variation::Pressure), &ramp);
+    let (first, last) = (h[0], h[h.len() - 1]);
+    assert!(near(first, 2.0, 0.1) && last > 10.0, "{h:?}");
+    assert!(h.windows(2).all(|w| w[1] >= w[0] - 1e-9), "grows with the pressure: {h:?}");
+    // Without recorded pressure, half way between the two.
+    assert!(heights(&sized_scatter(50.0, 300.0, Variation::Pressure), &stroke(1.0)).iter().all(|h| near(*h, 7.0, 1e-6)));
+    // No modes saved: Random where the values differ, as before; Fixed and Random draw the same.
+    let old = sized_scatter(50.0, 300.0, Variation::Random);
+    let BrushKind::Scatter(sc) = &old.kind else { panic!("not a scatter brush") };
+    assert_eq!(Scatter { modes: None, ..sc.clone() }.modes(), [Variation::Random, Variation::Fixed, Variation::Fixed, Variation::Fixed]);
+    let unsaved = Brush { kind: BrushKind::Scatter(Scatter { modes: None, ..sc.clone() }), ..old.clone() };
+    assert_eq!(stroke_pieces(&old, &bp, &stroke(1.0)), stroke_pieces(&unsaved, &bp, &stroke(1.0)));
+    assert!(serde_json::to_value(&unsaved).unwrap().get("modes").is_none(), "not saved when unset");
+}
+
+/// Definitions from files and commands are kept within their ranges.
+#[test]
+fn sanitize_keeps_values_within_their_ranges() {
+    let mut v = serde_json::to_value(sized_scatter(1e308, -1e308, Variation::Random)).unwrap();
+    v["rotation"] = serde_json::json!([720.0, -1e300]);
+    v["scatter"] = serde_json::json!([5000.0, 0.0]);
+    let lib = parse_library(&serde_json::json!([
+        v,
+        {"name": "a", "type": "art", "art": rect_art(10.0, 4.0), "width": 1e308, "scale": {"mode": "betweenGuides", "start": -3.0, "end": 9.0}},
+        {"name": "p", "type": "pattern", "side": rect_art(10.0, 4.0), "scale": 0.0, "spacing": -5.0},
+        {"name": "c", "type": "calligraphic", "angle": 400.0, "roundness": -1.0, "size": 1e9, "variation": [1e9, -1.0, 2.0]},
+        {"name": "b", "type": "bristle", "size": 0.0, "length": 1000.0, "density": 0.0},
+    ]));
+    let [s, a, p, c, b] = lib.as_slice() else { panic!("{lib:?}") };
+    let BrushKind::Scatter(s) = &s.kind else { panic!() };
+    assert_eq!((s.size, s.rotation, s.scatter), ((10000.0, 1.0), (180.0, -180.0), (1000.0, 0.0)));
+    let BrushKind::Art(a) = &a.kind else { panic!() };
+    assert_eq!((a.width, a.scale), (1000.0, ArtScale::BetweenGuides { start: 0.0, end: 1.0 }));
+    let BrushKind::Pattern(p) = &p.kind else { panic!() };
+    assert_eq!((p.scale, p.spacing), (1.0, 0.0));
+    let BrushKind::Calligraphic(c) = &c.kind else { panic!() };
+    assert_eq!((c.angle, c.roundness, c.size, c.variation), (180.0, 0.0, 1296.0, [180.0, 0.0, 2.0]));
+    let BrushKind::Bristle(b) = &b.kind else { panic!() };
+    assert_eq!((b.size, b.length, b.density), (0.1, 300.0, 1.0));
+}
+
+/// Hue Shift's key colour defaults to the art's most used colour.
+#[test]
+fn art_colors_list_the_most_used_first() {
+    let red = Color::rgb(1.0, 0.0, 0.0);
+    let blue = Color::rgb(0.0, 0.0, 1.0);
+    let path =
+        |c: Color| Node::path(NodeId(0), shapes::rectangle(Rect::new(0.0, 0.0, 1.0, 1.0)), Appearance::basic(Paint::solid(c), Paint::None, 0.0));
+    let g = Node::group(NodeId(0), vec![Arc::new(path(red)), Arc::new(path(blue)), Arc::new(path(blue))]);
+    assert_eq!(art_colors([&g]), vec![blue, red]);
+    let b = defaults().iter().find(|b| b.name == "Chain").unwrap();
+    assert_eq!(b.art().len(), 3, "the side and both corner tiles");
+    assert!(calli(0.0, 100.0, 3.0).art().is_empty());
+}

crates/brush/src/warp.rs

@@ -6,11 +6,11 @@
 
 use std::sync::Arc;
 
-use vectorcraft_doc::{Node, NodeKind};
+use vectorcraft_doc::{Node, NodeKind, PressureProfile};
 use vectorcraft_geom::{Affine, BezPath, PathData, PathEl, Point, Rect, SubPath};
 
 use crate::track::{Rng, Track, seed_of, tracks};
-use crate::{ArtBrush, ArtScale, Direction, PatternBrush, PatternFit, Scatter, tolerance};
+use crate::{ArtBrush, ArtScale, Direction, PatternBrush, PatternFit, Scatter, Variation, tolerance};
 
 /// Longest mapped segment (points in document space).
 const MAX_SEG: f64 = 1.5;
@@ -188,13 +188,28 @@ pub(crate) fn art(a: &ArtBrush, bp: &BezPath, weight: f64) -> Vec<Node> {
     out
 }
 
-pub(crate) fn scatter(sc: &Scatter, bp: &BezPath, weight: f64, name: &str) -> Vec<Node> {
+/// One of a scatter brush's values for the next copy: Fixed takes the first of `(a, b)`, Random a
+/// value between them, Pressure the first at pen pressure 0 and the second at 1. Every value
+/// draws, so a copy's random values stay the same whatever the other modes.
+fn vary(rng: &mut Rng, (a, b): (f64, f64), mode: Variation, pressure: f64) -> f64 {
+    let r = rng.range(a, b);
+    match mode {
+        Variation::Fixed => a,
+        Variation::Random => r,
+        Variation::Pressure => a + (b - a) * pressure.clamp(0.0, 1.0),
+    }
+}
+
+pub(crate) fn scatter(sc: &Scatter, bp: &BezPath, weight: f64, pressure: Option<&PressureProfile>, name: &str) -> Vec<Node> {
     let Some(b) = sc.art.geometric_bounds() else { return vec![] };
     let (aw, ah) = (b.width().max(1e-3), b.height().max(1e-3));
     let mut rng = Rng::new(seed_of(bp, name));
+    let [size_mode, spacing_mode, scatter_mode, rotation_mode] = sc.modes();
     let mut out = vec![];
     for t in tracks(bp, 0.05) {
         let l = t.len();
+        // The pen pressure at arc length `at` (half way without a recorded one).
+        let pressure_at = |at: f64| pressure.map_or(PressureProfile::MID, |p| p.at(if l > 1e-9 { at / l } else { 0.0 }));
         let mut s: Option<f64> = None;
         let mut guard = 0;
         loop {
@@ -202,8 +217,10 @@ pub(crate) fn scatter(sc: &Scatter, bp: &BezPath, weight: f64, name: &str) -> Ve
             if guard > 20000 {
                 break;
             }
-            let size = rng.range(sc.size.0, sc.size.1).max(1.0) / 100.0 * weight;
-            let spacing = rng.range(sc.spacing.0, sc.spacing.1).max(1.0) / 100.0;
+            // Size and spacing place the next copy, so they take the pressure at the last one.
+            let p = pressure_at(s.unwrap_or(0.0));
+            let size = vary(&mut rng, sc.size, size_mode, p).max(1.0) / 100.0 * weight;
+            let spacing = vary(&mut rng, sc.spacing, spacing_mode, p).max(1.0) / 100.0;
             let step = aw * size * spacing;
             let pos = match s {
                 None => step / 2.0,
@@ -213,8 +230,9 @@ pub(crate) fn scatter(sc: &Scatter, bp: &BezPath, weight: f64, name: &str) -> Ve
                 break;
             }
             s = Some(pos);
-            let off = rng.range(sc.scatter.0, sc.scatter.1) / 100.0 * ah * size;
-            let rot = rng.range(sc.rotation.0, sc.rotation.1).to_radians();
+            let p = pressure_at(pos);
+            let off = vary(&mut rng, sc.scatter, scatter_mode, p) / 100.0 * ah * size;
+            let rot = vary(&mut rng, sc.rotation, rotation_mode, p).to_radians();
             let (p, tg) = t.frame(pos);
             let place = p + crate::track::normal(tg) * off;
             // Page rotation is counter-clockwise on screen (y-down), like the calligraphic angle.

crates/doc/src/graph.rs

@@ -103,14 +103,24 @@ pub struct GraphSpec {
     pub ticks: usize,
     pub axis_min: Option<f64>,
     pub axis_max: Option<f64>,
-    /// Line graphs: mark data points, connect them, fill (area-like) the lines.
+    /// Line, scatter and radar graphs: mark data points, connect them.
     pub mark_points: bool,
     pub connect_points: bool,
+    /// Line graphs: run the lines from edge to edge of the plot; off (the default for new graphs), the points sit
+    /// at the centres of their categories, like the columns of a column graph. Graphs saved before the option
+    /// existed were drawn edge to edge and keep it.
+    #[serde(default = "edge_to_edge_before_the_option")]
+    pub edge_to_edge: bool,
     /// Bounds of the art when it was last generated (detects moves/scales of the graph group).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub placed: Option<Rect>,
 }
 
+/// Edge-to-Edge Lines for a graph saved before the option existed: on, as it was drawn then.
+fn edge_to_edge_before_the_option() -> bool {
+    true
+}
+
 impl Default for GraphSpec {
     fn default() -> Self {
         Self {
@@ -128,6 +138,7 @@ impl Default for GraphSpec {
             axis_max: None,
             mark_points: true,
             connect_points: true,
+            edge_to_edge: false,
             placed: None,
         }
     }

crates/effects/src/lib.rs

@@ -144,6 +144,7 @@ const WARP: &[&str] = &["Effect", "Warp"];
 const BLUR: &[&str] = &["Effect", "Blur"];
 const SHARPEN: &[&str] = &["Effect", "Sharpen"];
 const PIXELATE: &[&str] = &["Effect", "Pixelate"];
+const VIDEO: &[&str] = &["Effect", "Video"];
 const PATHFINDER: &[&str] = &["Effect", "Pathfinder"];
 const PLUGINS: &[&str] = &["Effect", "Plug-ins"];
 const ADJUST: &[&str] = &["Effect", "Color Adjustments"];
@@ -331,6 +332,20 @@ pub fn effect_catalog() -> Vec<EffectInfo> {
             "{cellSize: pt 3..300 (5)} redraws the object as randomly placed dots of its colours on a white canvas",
             json!({"cellSize": 5.0}),
         ),
+        r(
+            "video.deinterlace",
+            "De-Interlace…",
+            VIDEO,
+            "{eliminate: \"odd\"|\"even\" (\"odd\"; which field lines are taken out), create: \"duplication\"|\"interpolation\" (\"duplication\"; a line taken out becomes a copy of the line above, or the average of the lines above and below)} the field lines are the rows of the document's raster grid (Document Raster Effects Settings › Resolution), numbered from 1 at the top of the page",
+            json!({"eliminate": "odd", "create": "duplication"}),
+        ),
+        r(
+            "video.ntscColors",
+            "NTSC Colors",
+            VIDEO,
+            "{} makes colours a television signal can't carry (luma plus chroma past 110 % of white, or luma minus chroma below −20 %) less saturated, keeping their brightness",
+            json!({}),
+        ),
     ];
     v.extend([
         g(

crates/effects/src/pixel/mod.rs

@@ -1,6 +1,6 @@
 //! Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Pixelate › Color
-//! Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask, and Stylize › Glowing
-//! Edges): filters over premultiplied RGBA8 pixels.
+//! Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask, Stylize › Glowing
+//! Edges, and Video › De-Interlace and NTSC Colors): filters over premultiplied RGBA8 pixels.
 //!
 //! - Every distance is in document units (points) and becomes pixels through the raster's
 //!   [`PixelSpace::px`], so an effect looks the same at any zoom and at any Document Raster Effects
@@ -13,6 +13,7 @@ mod blur;
 mod edges;
 mod pixelate;
 mod sharpen;
+mod video;
 
 use serde_json::Value;
 use vectorcraft_geom::{Affine, Point, Rect};
@@ -22,7 +23,7 @@ use crate::util::{num, text};
 pub use pixelate::{MEZZOTINT_TYPES, Mezzotint};
 
 /// The Photoshop-style effect ids (all raster effects, see [`crate::is_raster`]).
-pub const PIXEL_EFFECTS: [&str; 8] = [
+pub const PIXEL_EFFECTS: [&str; 10] = [
     "blur.radial",
     "blur.smart",
     "pixelate.colorHalftone",
@@ -31,6 +32,8 @@ pub const PIXEL_EFFECTS: [&str; 8] = [
     "pixelate.pointillize",
     "sharpen.unsharpMask",
     "stylize.glowingEdges",
+    "video.deinterlace",
+    "video.ntscColors",
 ];
 
 /// A Photoshop-style raster effect with its parameters read and clamped to their ranges. Lengths
@@ -59,6 +62,11 @@ pub enum PixelFx {
     /// Pixelate › Pointillize: random dots about `cell` across of the object's colours on a white
     /// canvas.
     Pointillize { cell: f64 },
+    /// Video › De-Interlace: the odd (or `even`) field lines made again from the others, by
+    /// duplication or, with `interpolate`, by averaging.
+    DeInterlace { even: bool, interpolate: bool },
+    /// Video › NTSC Colors: colours a television signal can't carry made less saturated.
+    NtscColors,
 }
 
 /// What a raster's colour channels hold, for the filters that treat them apart (Color Halftone
@@ -89,6 +97,9 @@ pub struct PixelSpace {
     pub center: Point,
     /// What the colour channels hold.
     pub channels: Channels,
+    /// The height of a line of the document's raster grid (document units: 72 / Document Raster
+    /// Effects Settings › Resolution), the fields De-Interlace works on.
+    pub line: f64,
 }
 
 /// Effect `id`'s parameters `p` (defaults merged in) as a [`PixelFx`]; `None` for other effects.
@@ -126,6 +137,11 @@ pub(crate) fn parse(id: &str, p: &Value) -> Option<PixelFx> {
         "pixelate.crystallize" => PixelFx::Crystallize { cell: num(p, "cellSize", 10.0).clamp(3.0, 300.0) },
         "pixelate.mezzotint" => PixelFx::Mezzotint { kind: Mezzotint::parse(text(p, "type", "fineDots")) },
         "pixelate.pointillize" => PixelFx::Pointillize { cell: num(p, "cellSize", 5.0).clamp(3.0, 300.0) },
+        "video.deinterlace" => PixelFx::DeInterlace {
+            even: text(p, "eliminate", "odd").eq_ignore_ascii_case("even"),
+            interpolate: text(p, "create", "duplication").eq_ignore_ascii_case("interpolation"),
+        },
+        "video.ntscColors" => PixelFx::NtscColors,
         _ => return None,
     })
 }
@@ -143,7 +159,7 @@ impl PixelFx {
             PixelFx::SmartBlur { radius, .. } => radius,
             PixelFx::UnsharpMask { .. } => 0.0,
             PixelFx::GlowingEdges { width, smoothness, .. } => width.max(smoothness * 3.0),
-            PixelFx::ColorHalftone { .. } | PixelFx::Mezzotint { .. } => 0.0,
+            PixelFx::ColorHalftone { .. } | PixelFx::Mezzotint { .. } | PixelFx::DeInterlace { .. } | PixelFx::NtscColors => 0.0,
             // A crystal's or dot's point inside the object reaches out by up to its cell.
             PixelFx::Crystallize { cell } | PixelFx::Pointillize { cell } => 1.5 * cell,
         }
@@ -163,6 +179,9 @@ impl PixelFx {
             PixelFx::Mezzotint { .. } => Some(0.0),
             // The dots' points, and the softened colour around them.
             PixelFx::Pointillize { cell } => Some(2.5 * cell),
+            // The lines above and below.
+            PixelFx::DeInterlace { .. } => Some(video::MAX_LINE),
+            PixelFx::NtscColors => Some(0.0),
         }
     }
 
@@ -180,6 +199,8 @@ impl PixelFx {
             PixelFx::Crystallize { cell } => pixelate::crystallize(px, w, h, space, cell),
             PixelFx::Mezzotint { kind } => pixelate::mezzotint(px, w, h, space, kind),
             PixelFx::Pointillize { cell } => pixelate::pointillize(px, w, h, space, cell),
+            PixelFx::DeInterlace { even, interpolate } => video::deinterlace(px, w, h, space, even, interpolate),
+            PixelFx::NtscColors => video::ntsc(px),
         }
     }
 }

crates/effects/src/pixel/tests.rs

@@ -7,7 +7,7 @@ use crate::{RasterFx, raster_effects};
 
 /// A `w` × `h` raster whose pixels are document points (origin top-left).
 fn space(w: usize, h: usize) -> PixelSpace {
-    PixelSpace { to_doc: Affine::IDENTITY, px: 1.0, center: Point::new(w as f64 / 2.0, h as f64 / 2.0), channels: Channels::Rgb }
+    PixelSpace { to_doc: Affine::IDENTITY, px: 1.0, center: Point::new(w as f64 / 2.0, h as f64 / 2.0), channels: Channels::Rgb, line: 1.0 }
 }
 
 fn image(w: usize, h: usize, f: impl Fn(usize, usize) -> [u8; 4]) -> Vec<u8> {
@@ -224,7 +224,8 @@ fn lengths_are_document_units() {
     let edge = |scale: usize| image(40 * scale, 4, move |x, _| grey(if x < 20 * scale { 100 } else { 150 }));
     let run = |scale: usize| {
         let mut d = edge(scale);
-        let s = PixelSpace { to_doc: Affine::scale(1.0 / scale as f64), px: 1.0 / scale as f64, center: Point::ZERO, channels: Channels::Rgb };
+        let s =
+            PixelSpace { to_doc: Affine::scale(1.0 / scale as f64), px: 1.0 / scale as f64, center: Point::ZERO, channels: Channels::Rgb, line: 1.0 };
         fx("sharpen.unsharpMask", json!({"amount": 100, "radius": 2})).apply(&mut d, 40 * scale, 4, &s);
         (0..40 * scale).filter(|x| at(&d, 40 * scale, *x, 2)[0] < 99).count()
     };
@@ -253,7 +254,7 @@ fn gaussian_and_plane_blurs_keep_their_mass() {
 fn pixel_timings() {
     let (w, h) = (2000, 2000);
     let src = image(w, h, |x, y| [(x % 256) as u8, (y % 256) as u8, ((x ^ y) % 256) as u8, 255]);
-    let s = PixelSpace { to_doc: Affine::IDENTITY, px: 1.0, center: Point::new(1000.0, 1000.0), channels: Channels::Rgb };
+    let s = PixelSpace { to_doc: Affine::IDENTITY, px: 1.0, center: Point::new(1000.0, 1000.0), channels: Channels::Rgb, line: 1.0 };
     let cases = [
         ("blur.radial", json!({"quality": "draft"})),
         ("blur.radial", json!({"quality": "good"})),
@@ -477,3 +478,50 @@ fn pixelate_patterns_follow_the_object_at_any_resolution() {
         assert_eq!(shifted, one, "{id}");
     }
 }
+
+/// Video › De-Interlace: lines 1, 3, 5… (or 2, 4, 6…) are made again from the others, by copying
+/// the line above or by averaging the lines above and below; the lines are the document's raster
+/// rows, whatever the raster's own resolution.
+#[test]
+fn deinterlace_remakes_one_field_from_the_other() {
+    let (w, h) = (2, 6);
+    // Line n (from 1) is grey 40 n.
+    let src = image(w, h, |_, y| grey(40 * (y as u8 + 1)));
+    let run = |p: serde_json::Value, s: &PixelSpace| {
+        let mut d = src.clone();
+        fx("video.deinterlace", p).apply(&mut d, w, h, s);
+        (0..h).map(|y| at(&d, w, 1, y)[0]).collect::<Vec<_>>()
+    };
+    let s = space(w, h);
+    // Odd lines (1, 3, 5) copy the line above; line 1 has none, so it takes line 2.
+    assert_eq!(run(json!({}), &s), [80, 80, 80, 160, 160, 240]);
+    assert_eq!(run(json!({"eliminate": "even"}), &s), [40, 40, 120, 120, 200, 200]);
+    // Interpolated: the average of the lines around (one side at the edges).
+    assert_eq!(run(json!({"eliminate": "even", "create": "interpolation"}), &s), [40, 80, 120, 160, 200, 200]);
+    // Lines two pixels tall: lines 1 and 3 (pixels 0–1 and 4–5) copy their neighbour, row by row.
+    let coarse = PixelSpace { line: 2.0, ..space(w, h) };
+    assert_eq!(run(json!({}), &coarse), [120, 160, 120, 160, 120, 160]);
+    // A damaged space changes nothing.
+    assert_eq!(run(json!({}), &PixelSpace { line: f64::NAN, ..space(w, h) }), [40, 80, 120, 160, 200, 240]);
+}
+
+/// Video › NTSC Colors: saturated yellow and cyan lose saturation (their composite signal is too
+/// strong) but keep their brightness; greys, dark colours and transparency stay as they are.
+#[test]
+fn ntsc_colors_tame_only_colours_too_strong_for_the_signal() {
+    let (w, h) = (5, 1);
+    let px = [[255, 255, 0, 255], [0, 255, 255, 255], [128, 128, 128, 255], [100, 20, 20, 255], [0, 0, 0, 0]];
+    let mut d: Vec<u8> = px.concat();
+    fx("video.ntscColors", json!({})).apply(&mut d, w, h, &space(w, h));
+    let luma = |p: [u8; 4]| 0.299 * f64::from(p[0]) + 0.587 * f64::from(p[1]) + 0.114 * f64::from(p[2]);
+    for (x, &a) in px.iter().enumerate() {
+        let b = at(&d, w, x, 0);
+        if x >= 2 {
+            assert_eq!(b, a, "{x}: unchanged");
+            continue;
+        }
+        let spread = |p: [u8; 4]| p[..3].iter().max().unwrap() - p[..3].iter().min().unwrap();
+        assert!(spread(b) < spread(a), "{x}: less saturated {b:?}");
+        assert!((luma(a) - luma(b)).abs() < 3.0, "{x}: as bright {a:?} {b:?}");
+    }
+}

crates/effects/src/pixel/video.rs

@@ -0,0 +1,74 @@
+//! Effect › Video: De-Interlace and NTSC Colors.
+
+use vectorcraft_geom::Point;
+
+use super::PixelSpace;
+
+/// The tallest field line De-Interlace reads across (document units): one pixel at the lowest
+/// document raster resolution, 1 ppi.
+pub(super) const MAX_LINE: f64 = 72.0;
+
+/// De-Interlace: the odd (or, with `even`, the even) fields of the image are made again from the
+/// others. The fields are the lines of the document's raster grid (each [`PixelSpace::line`]
+/// tall, numbered from 1 at the top of the page): a line taken out becomes a copy of the line
+/// above it (the one below at the top), or with `interpolate` the average of the two.
+pub(super) fn deinterlace(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, even: bool, interpolate: bool) {
+    let line = space.line;
+    let to_px = space.to_doc.inverse();
+    if !(line.is_finite() && line > 0.0 && to_px.is_finite() && space.to_doc.is_finite()) {
+        return;
+    }
+    let src = px.to_vec();
+    // The pixel holding document point `q`.
+    let at = |q: Point| {
+        let p = to_px * q;
+        (p.x >= 0.0 && p.y >= 0.0 && p.x < w as f64 && p.y < h as f64).then(|| src.get(p.y as usize * w + p.x as usize).copied()).flatten()
+    };
+    for (i, out) in px.iter_mut().enumerate().take(w.saturating_mul(h)) {
+        let q = space.to_doc * Point::new((i % w) as f64 + 0.5, (i / w) as f64 + 0.5);
+        let k = (q.y / line).floor();
+        // Line k + 1: odd lines have an even k.
+        if !k.is_finite() || ((k as i64).rem_euclid(2) == 1) != even {
+            continue;
+        }
+        let (above, below) = (at(Point::new(q.x, q.y - line)), at(Point::new(q.x, q.y + line)));
+        let made = match (interpolate, above, below) {
+            (true, Some(a), Some(b)) => Some([0, 1, 2, 3].map(|c| (u16::from(a[c]) + u16::from(b[c])).div_ceil(2) as u8)),
+            (_, a, b) => a.or(b),
+        };
+        if let Some(v) = made {
+            *out = v;
+        }
+    }
+}
+
+/// NTSC Colors: colours a television's composite signal can't carry are made less saturated,
+/// keeping their brightness. In YIQ, the luma plus the chroma's amplitude must stay within 110 %
+/// of white and the luma minus it above −20 %; a colour past either has its chroma cut to fit.
+pub(super) fn ntsc(px: &mut [[u8; 4]]) {
+    for p in px.iter_mut() {
+        let a = f32::from(p[3]) / 255.0;
+        if a <= 0.0 {
+            continue;
+        }
+        // Straight colour (the pixels are premultiplied).
+        let [r, g, b] = [p[0], p[1], p[2]].map(|v| (f32::from(v) / 255.0 / a).min(1.0));
+        let y = 0.299 * r + 0.587 * g + 0.114 * b;
+        let (i, q) = (0.596 * r - 0.274 * g - 0.322 * b, 0.211 * r - 0.523 * g + 0.312 * b);
+        let c = i.hypot(q);
+        let mut keep = 1.0f32;
+        if y + c > 1.1 {
+            keep = keep.min((1.1 - y) / c);
+        }
+        if y - c < -0.2 {
+            keep = keep.min((y + 0.2) / c);
+        }
+        if keep >= 1.0 || !keep.is_finite() {
+            continue;
+        }
+        let (i, q) = (i * keep.max(0.0), q * keep.max(0.0));
+        let rgb = [y + 0.956 * i + 0.621 * q, y - 0.272 * i - 0.647 * q, y - 1.106 * i + 1.703 * q];
+        let [r, g, b] = rgb.map(|v| (v.clamp(0.0, 1.0) * a * 255.0).round() as u8);
+        *p = [r, g, b, p[3]];
+    }
+}

crates/engine/src/cmd/brushsym.rs

@@ -63,7 +63,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Brush Options…",
             [],
             None,
-            "{name, params?: {…fields to change (brush.get shows them; calligraphic: angle −180..180°, roundness 0..100%, size 0..1296 pt, variation: [angle°, roundness%, size pt], modes: [fixed|random|pressure for angle, roundness, size]; pressure goes from value − variation at the lightest pen pressure to value + variation at the heaviest)}, newName?} edit a brush definition (strokes using it update) → {name}",
+            "{name, params?: {…fields to change (brush.get shows them; values outside their ranges are clamped). calligraphic: angle −180..180°, roundness 0..100%, size 0..1296 pt, variation: [angle°, roundness%, size pt], modes: [fixed|random|pressure for angle, roundness, size] (pressure goes from value − variation at the lightest pen pressure to value + variation at the heaviest). scatter: size [a, b] 1..10000%, spacing [a, b] 1..10000%, scatter [a, b] −1000..1000%, rotation [a, b] −180..180°, modes: [fixed|random|pressure for size, spacing, scatter, rotation] (fixed: a; random: between a and b; pressure: a at the lightest pen pressure to b at the heaviest), rotation_relative_to_path. art: width 1..1000%, scale: {mode: proportional|stretch|betweenGuides, start, end: 0..1 of the art length}, direction: leftToRight|rightToLeft|topToBottom|bottomToTop, flip_along, flip_across. pattern: scale 1..10000%, spacing 0..10000%, fit: stretch|addSpace|approximate, flip_along, flip_across. scatter, art and pattern: colorization: {method: none|tints|tintsAndShades|hueShift, key: colour (hueShift: the art colour that becomes the stroke colour)}}, newName?} edit a brush definition (strokes using it update) → {name}",
             has_doc,
             brush_options
         ),
@@ -383,12 +383,18 @@ fn brush_new(s: &mut Session, p: &Value) -> Result<Value> {
         }
         v[k] = serde_json::to_value(&art).unwrap_or_default();
     }
-    let b: Brush = serde_json::from_value(v).map_err(|e| bad(C, format!("invalid brush: {e}")))?;
-    lib.push(b);
+    lib.push(parse_brush(C, v)?);
     save_library(s, "New Brush", lib, None)?;
     Ok(json!({ "name": name }))
 }
 
+/// A brush definition from command params, its values kept within their ranges.
+fn parse_brush(cmd: &str, v: Value) -> Result<Brush> {
+    let mut b: Brush = serde_json::from_value(v).map_err(|e| bad(cmd, format!("invalid brush: {e}")))?;
+    b.sanitize();
+    Ok(b)
+}
+
 fn brush_delete(s: &mut Session, p: &Value) -> Result<Value> {
     let name = name_param(p, "brush.delete")?.to_string();
     let mut lib = brush::library(&s.doc()?.doc);
@@ -431,7 +437,7 @@ fn brush_options(s: &mut Session, p: &Value) -> Result<Value> {
         v["name"] = json!(name);
     }
     v["type"] = json!(lib[i].kind.type_id());
-    lib[i] = serde_json::from_value(v).map_err(|e| bad(C, format!("invalid brush: {e}")))?;
+    lib[i] = parse_brush(C, v)?;
     let out = lib[i].name.clone();
     let rename = new_name.map(|nn| (name, Some(nn)));
     save_library(s, "Brush Options", lib, rename)?;

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

@@ -652,11 +652,13 @@ fn format_filters() -> impl Iterator<Item = (&'static str, &'static [&'static st
 }
 
 /// Open-dialog filters: "All readable files" first, then one per readable format, then swatch
-/// libraries (which open in the library panel), flattener, PDF and print presets (imported).
+/// libraries (which open in the library panel), Libraries panel libraries, flattener, PDF and print
+/// presets (imported).
 pub fn open_filters() -> impl Iterator<Item = (&'static str, &'static [&'static str])> {
     std::iter::once(("All readable files", OPEN_EXTS))
         .chain(format_filters())
         .chain(std::iter::once(("Swatch libraries", super::swatchlib::LIBRARY_EXTS)))
+        .chain(std::iter::once(("Libraries", super::library::LIBRARY_EXTS)))
         .chain(std::iter::once(("Flattener presets", super::flatten::PRESET_EXTS)))
         .chain(std::iter::once(("PDF presets", super::pdfcmds::PRESET_EXTS)))
         .chain(std::iter::once(("Print presets", super::printpresets::PRESET_EXTS)))

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

@@ -157,7 +157,11 @@ fn open_exts_cover_every_readable_format() {
     }
     let filters: Vec<_> = open_filters().collect();
     assert_eq!(filters[0], ("All readable files", OPEN_EXTS));
-    assert_eq!(filters.len(), 6 + FORMATS.iter().filter(|f| f.read).count(), "and swatch libraries, flattener, PDF and print presets, plug-ins");
+    assert_eq!(
+        filters.len(),
+        7 + FORMATS.iter().filter(|f| f.read).count(),
+        "and swatch libraries, libraries, flattener, PDF and print presets, plug-ins"
+    );
     assert_eq!(filters.last(), Some(&("Plug-ins", crate::cmd::plugin::EXTS)), "File › Open installs plug-ins");
 }
 

crates/engine/src/cmd/graph.rs

@@ -41,7 +41,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Type…",
             ["Object", "Graph"],
             None,
-            "{id?, type?, columnWidth?: %, clusterWidth?: %, legend?: bool, markPoints?: bool, connectPoints?: bool, ticks?: n, axisMin?, axisMax?} change the graph type and options; no options → the current ones",
+            "{id?, type?, columnWidth?: %, clusterWidth?: %, legend?: bool, markPoints?: bool, connectPoints?: bool, edgeToEdge?: bool (line graphs: true runs the lines across the whole plot, false puts the points at the centres of their categories), ticks?: n, axisMin?, axisMax?} change the graph type and options (axisMin and axisMax together override the calculated value axis: exactly that range in `ticks` divisions, 5 when 0); no options → the current ones",
             has_selection,
             set_type
         ),
@@ -166,6 +166,37 @@ fn nice_axis(lo: f64, hi: f64, ticks: usize) -> (f64, f64, f64) {
     ((lo / step).floor() * step, (hi / step).ceil() * step, step)
 }
 
+/// The value axis: with both `axis_min` and `axis_max` set (Graph Type › Tick Values › Override Calculated Values),
+/// exactly that range split into `ticks` divisions (5 when automatic); otherwise a nice axis around the data, using
+/// whichever bound was given.
+fn value_axis(g: &GraphSpec, lo: f64, hi: f64) -> (f64, f64, f64) {
+    match (g.axis_min, g.axis_max) {
+        (Some(min), Some(max)) if max > min && (max - min).is_finite() => {
+            let n = if g.ticks == 0 { 5 } else { g.ticks.clamp(1, 100) } as f64;
+            (min, max, (max - min) / n)
+        }
+        _ => {
+            // An override too wide for f64 (or NaN) gives a non-finite axis, which would reach `clamp` with NaN bounds
+            // and panic: fall back to the data, then to 0..1.
+            let finite = |(a, b, s): (f64, f64, f64)| a.is_finite() && b.is_finite() && s.is_finite() && b > a && s > 0.0;
+            [nice_axis(g.axis_min.unwrap_or(lo), g.axis_max.unwrap_or(hi), g.ticks), nice_axis(lo, hi, g.ticks)]
+                .into_iter()
+                .find(|&a| finite(a))
+                .unwrap_or((0.0, 1.0, 0.2))
+        }
+    }
+}
+
+/// The tick values from `lo` to `hi` every `step`, both ends included: counted, not accumulated, so the last tick
+/// lands on `hi` and a step too small for the range (or not finite) can't loop forever. At most 1000 ticks.
+fn tick_values(lo: f64, hi: f64, step: f64) -> Vec<f64> {
+    let n = ((hi - lo) / step).round();
+    if !(lo.is_finite() && step.is_finite() && step > 0.0 && n.is_finite() && n >= 0.0) {
+        return vec![];
+    }
+    (0..=(n as usize).min(1000)).map(|i| lo + i as f64 * step).collect()
+}
+
 struct Gen<'a> {
     d: &'a mut Document,
     out: Vec<Arc<Node>>,
@@ -270,8 +301,7 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
         GraphKind::Radar => {
             let centre = r.center();
             let rad = (r.width().min(r.height()) / 2.0).max(1.0);
-            let hi = g.axis_max.unwrap_or_else(|| g.rows.iter().flatten().copied().fold(0.0, f64::max));
-            let (lo, hi, step) = nice_axis(g.axis_min.unwrap_or(0.0), hi, g.ticks);
+            let (lo, hi, step) = value_axis(g, 0.0, g.rows.iter().flatten().copied().fold(0.0, f64::max));
             let at = |c: usize, v: f64| {
                 let a = -std::f64::consts::FRAC_PI_2 + std::f64::consts::TAU * c as f64 / ncat as f64;
                 centre + vectorcraft_geom::Vec2::new(a.cos(), a.sin()) * (rad * ((v - lo) / (hi - lo)).clamp(0.0, 1.0))
@@ -284,21 +314,23 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                     axes.push(b.text(Point::new(p.x, p.y + LABEL_SIZE * 0.35), cat, Justify::Center));
                 }
             }
-            let mut v = lo + step;
-            while v <= hi + step * 1e-6 {
+            for v in tick_values(lo, hi, step).into_iter().skip(1) {
                 let ring: Vec<Point> = (0..ncat).map(|c| at(c, v)).collect();
                 axes.push(b.path(polyline(&ring, true), Paint::None, Paint::solid(Color::rgb(0.6, 0.6, 0.6)), 0.25));
-                v += step;
             }
             let ax = b.group("Axes", axes);
             b.out.push(ax);
             for (s, items) in series.iter_mut().enumerate() {
                 let pts: Vec<Point> = (0..ncat).map(|c| at(c, val(c, s))).collect();
-                let (fill, stroke, w) = mark(s, false, default_series_paint(s), 1.0);
-                items.push(b.path(polyline(&pts, true), fill, stroke, w));
-                for p in pts {
-                    let (fill, stroke, w) = mark(s, true, Paint::None, 0.0);
-                    items.push(b.path(marker(p, 4.0), fill, stroke, w));
+                if g.connect_points && pts.len() > 1 {
+                    let (fill, stroke, w) = mark(s, false, default_series_paint(s), 1.0);
+                    items.push(b.path(polyline(&pts, true), fill, stroke, w));
+                }
+                if g.mark_points {
+                    for p in pts {
+                        let (fill, stroke, w) = mark(s, true, Paint::None, 0.0);
+                        items.push(b.path(marker(p, 4.0), fill, stroke, w));
+                    }
                 }
             }
         }
@@ -327,7 +359,7 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                     }
                 }
             }
-            let (lo, hi, step) = nice_axis(g.axis_min.unwrap_or(lo), g.axis_max.unwrap_or(hi), g.ticks);
+            let (lo, hi, step) = value_axis(g, lo, hi);
             // Value → coordinate along the value axis (y for columns/lines, x for bars).
             let vpos = |v: f64| {
                 let t = (v - lo) / (hi - lo);
@@ -335,8 +367,7 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
             };
             let mut axes = vec![];
             // Value axis with ticks and labels.
-            let mut v = lo;
-            while v <= hi + step * 1e-6 {
+            for v in tick_values(lo, hi, step) {
                 let q = vpos(v);
                 if horizontal {
                     axes.push(b.line(Point::new(q, r.y1), Point::new(q, r.y1 + 4.0)));
@@ -345,7 +376,6 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                     axes.push(b.line(Point::new(r.x0 - 4.0, q), Point::new(r.x0, q)));
                     axes.push(b.text(Point::new(r.x0 - 6.0, q + LABEL_SIZE * 0.35), &fmt_value(v), Justify::Right));
                 }
-                v += step;
             }
             if horizontal {
                 axes.push(b.line(Point::new(r.x0, r.y1), Point::new(r.x1, r.y1)));
@@ -358,7 +388,8 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
             let span = if horizontal { r.height() } else { r.width() };
             let cat_w = span / ncat as f64;
             let cat_start = |c: usize| if horizontal { r.y0 + c as f64 * cat_w } else { r.x0 + c as f64 * cat_w };
-            let points_mode = matches!(g.kind, GraphKind::Line | GraphKind::Area);
+            // Area bands always span the plot; line graphs only with Edge-to-Edge Lines.
+            let points_mode = g.kind == GraphKind::Area || (g.kind == GraphKind::Line && g.edge_to_edge);
             let cat_mid = |c: usize| {
                 if points_mode && ncat > 1 { r.x0 + r.width() * c as f64 / (ncat - 1) as f64 } else { cat_start(c) + cat_w / 2.0 }
             };
@@ -676,11 +707,12 @@ fn set_type(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "graph.setType";
     let id = target(s, p, C)?;
     let mut spec = spec_of(s, id)?;
-    let keys = ["type", "columnWidth", "clusterWidth", "legend", "markPoints", "connectPoints", "ticks", "axisMin", "axisMax"];
+    let keys = ["type", "columnWidth", "clusterWidth", "legend", "markPoints", "connectPoints", "edgeToEdge", "ticks", "axisMin", "axisMax"];
     if !keys.iter().any(|k| p.get(*k).is_some()) {
         return Ok(json!({
             "type": spec.kind.id(), "columnWidth": spec.column_width, "clusterWidth": spec.cluster_width, "legend": spec.legend,
-            "markPoints": spec.mark_points, "connectPoints": spec.connect_points, "ticks": spec.ticks,
+            "markPoints": spec.mark_points, "connectPoints": spec.connect_points, "edgeToEdge": spec.edge_to_edge, "ticks": spec.ticks,
+            "axisMin": spec.axis_min, "axisMax": spec.axis_max,
         }));
     }
     if let Some(t) = str_param(p, "type") {
@@ -691,6 +723,7 @@ fn set_type(s: &mut Session, p: &Value) -> Result<Value> {
     spec.legend = bool_or(p, "legend", spec.legend);
     spec.mark_points = bool_or(p, "markPoints", spec.mark_points);
     spec.connect_points = bool_or(p, "connectPoints", spec.connect_points);
+    spec.edge_to_edge = bool_or(p, "edgeToEdge", spec.edge_to_edge);
     spec.ticks = p.get("ticks").and_then(Value::as_u64).map_or(spec.ticks, |t| t.min(100) as usize);
     if let Some(v) = p.get("axisMin") {
         spec.axis_min = v.as_f64();
@@ -790,6 +823,89 @@ mod tests {
         assert!(matches!(n.kind, NodeKind::Group { .. }));
     }
 
+    /// The x of every marker of series `index`, left to right.
+    fn marker_xs(s: &Session, id: NodeId, index: u32) -> Vec<f64> {
+        let n = s.doc().unwrap().doc.node(id).unwrap().clone();
+        let mut xs: Vec<f64> = series(&n, index)
+            .children()
+            .unwrap()
+            .iter()
+            .map(|c| c.geometric_bounds().unwrap())
+            .filter(|b| (b.width() - 5.0).abs() < 1e-6)
+            .map(|b| b.center().x)
+            .collect();
+        xs.sort_by(f64::total_cmp);
+        xs
+    }
+
+    #[test]
+    fn edge_to_edge_lines_off_puts_line_points_at_category_centres() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
+        // 300 pt wide, three categories: centres at 150, 250, 350 (off by default); edges at 100 and 400.
+        let id = graph(&mut s, "line");
+        assert_eq!(marker_xs(&s, id, 0), vec![150.0, 250.0, 350.0]);
+        assert_eq!(s.execute("graph.setType", &json!({})).unwrap()["edgeToEdge"], json!(false));
+        s.execute("graph.setType", &json!({"edgeToEdge": true})).unwrap();
+        assert_eq!(marker_xs(&s, id, 0), vec![100.0, 250.0, 400.0]);
+        // A graph saved before the option existed keeps its edge-to-edge lines.
+        let old: GraphSpec = serde_json::from_value(json!({"kind": "line"})).unwrap();
+        assert!(old.edge_to_edge);
+    }
+
+    #[test]
+    fn radar_graphs_follow_mark_and_connect_data_points() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
+        let id = graph(&mut s, "radar");
+        let parts = |s: &Session| series(&s.doc().unwrap().doc.node(id).unwrap().clone(), 0).children().unwrap().len();
+        // The ring, three markers and the legend swatch.
+        assert_eq!(parts(&s), 5);
+        s.execute("graph.setType", &json!({"markPoints": false})).unwrap();
+        assert_eq!(parts(&s), 2);
+        s.execute("graph.setType", &json!({"markPoints": true, "connectPoints": false})).unwrap();
+        assert_eq!(parts(&s), 4);
+    }
+
+    #[test]
+    fn an_overridden_value_axis_is_used_exactly() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
+        let r = s.execute("graph.create", &json!({"type": "column", "x": 20, "y": 20, "width": 170, "height": 74, "series": ["a"], "categories": ["x", "y"], "rows": [[4839], [10488]]})).unwrap();
+        let id = NodeId(r["id"].as_u64().unwrap());
+        let tallest = |s: &Session| -> f64 {
+            let n = s.doc().unwrap().doc.node(id).unwrap().clone();
+            let bars = series(&n, 0).children().unwrap();
+            bars.iter().map(|c| c.geometric_bounds().unwrap().height()).fold(0.0, f64::max)
+        };
+        // Calculated: a nice axis (0 to 12500 here), so the 10488 column falls short of 10488 / 12000 of the plot.
+        assert!((tallest(&s) - 74.0 * 10488.0 / 12000.0).abs() > 1.0);
+        s.execute("graph.setType", &json!({"axisMin": 0, "axisMax": 12000})).unwrap();
+        assert!((tallest(&s) - 74.0 * 10488.0 / 12000.0).abs() < 1e-6, "{}", tallest(&s));
+        let o = s.execute("graph.setType", &json!({})).unwrap();
+        assert_eq!((o["axisMin"].as_f64(), o["axisMax"].as_f64()), (Some(0.0), Some(12000.0)));
+        // One bound only keeps the calculated (nice) axis around it.
+        s.execute("graph.setType", &json!({"axisMax": null})).unwrap();
+        assert!((tallest(&s) - 74.0 * 10488.0 / 12000.0).abs() > 1.0);
+    }
+
+    #[test]
+    fn tick_values_end_on_the_maximum_and_never_run_away() {
+        // Counted, not accumulated: an offset range keeps its last tick.
+        let t = super::tick_values(1e10, 1e10 + 1.0, 0.01);
+        assert_eq!(t.len(), 101);
+        assert!((t[100] - (1e10 + 1.0)).abs() < 1e-3);
+        // A range too wide for f64, or a step too small to move, gives no ticks or a capped list.
+        assert!(super::tick_values(-1.7e308, 1.7e308, f64::INFINITY).is_empty());
+        assert!(super::tick_values(1e20, 1e20 + 16384.0, 163.84).len() <= 1001);
+        assert!(super::tick_values(0.0, 1.0, 0.0).is_empty());
+        // An override whose span overflows falls back to the calculated axis instead of hanging.
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
+        graph(&mut s, "column");
+        s.execute("graph.setType", &json!({"axisMin": -1.7e308, "axisMax": 1.7e308})).unwrap();
+    }
+
     #[test]
     fn group_selection_paint_becomes_the_series_colour_and_survives_regeneration() {
         let mut s = Session::new();

crates/engine/src/cmd/library.rs

@@ -4,7 +4,10 @@
 //! live for the session only. A graphic is kept as a native document with a PNG thumbnail: adding
 //! one copies the selection as Copy does, and placing it pastes a copy as Paste does (its images,
 //! symbols, patterns and swatches come along; a swatch name the document gives another colour is
-//! merged into the document's).
+//! merged into the document's). Items can be put in user-named groups, and a library can be
+//! exported to a `.vclibrary` file and imported from one (#926).
+
+use std::collections::{HashMap, HashSet};
 
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value, json};
@@ -16,10 +19,20 @@ use crate::Clipboard;
 
 /// The extension of a library file.
 pub const LIBRARY_EXT: &str = "vclibrary";
+/// The extensions of library files (open dialogs).
+pub const LIBRARY_EXTS: &[&str] = &[LIBRARY_EXT];
 /// Bytes a library file may have when read (graphics with large images included).
 const MAX_FILE: u64 = 512 << 20;
 /// Items of one kind a library may hold.
 const MAX_ITEMS: usize = 10_000;
+/// Groups a library may hold.
+const MAX_GROUPS: usize = 1_000;
+/// Characters of a library, group or item name kept from a file.
+const MAX_NAME: usize = 256;
+/// Base64 bytes a graphic's thumbnail may have (a 256-pixel PNG is far smaller).
+const MAX_THUMBNAIL: usize = 4 << 20;
+/// Pixels a side a thumbnail may claim (they are made at most 256).
+const MAX_THUMBNAIL_SIDE: u32 = 1024;
 
 /// A library: its name and its items, newest last.
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
@@ -34,6 +47,38 @@ pub struct Library {
     pub para_styles: Vec<TextStyleDef>,
     #[serde(default)]
     pub graphics: Vec<LibraryGraphic>,
+    /// User-named groups of its items, in the order they were made (#926); an item is in one
+    /// group at most, the others are ungrouped. Files written before groups have none.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub groups: Vec<LibraryGroup>,
+}
+
+/// A user-named group of a library's items.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct LibraryGroup {
+    pub name: String,
+    #[serde(default)]
+    pub items: Vec<ItemRef>,
+}
+
+/// A library item: its kind and its key (its name; a graphic's id).
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct ItemRef {
+    pub kind: ItemKind,
+    pub item: String,
+}
+
+/// What a library item is, as groups name it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum ItemKind {
+    Color,
+    CharStyle,
+    ParaStyle,
+    Graphic,
+    /// A kind this version doesn't know (a newer one wrote it): dropped when the file is read.
+    #[serde(other)]
+    Unknown,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -87,7 +132,7 @@ impl Libraries {
                 })
                 .and_then(|b| serde_json::from_slice::<Library>(&b).ok());
                 if let Some(mut lib) = lib {
-                    lib.cap();
+                    lib.sanitize();
                     self.libs.push((id, lib));
                 }
             }
@@ -120,12 +165,15 @@ impl Libraries {
 
     /// A new empty library called `name` → its id.
     fn create(&mut self, name: &str) -> Result<String> {
-        let base: String = name.chars().map(|c| if c.is_alphanumeric() || c == ' ' || c == '-' || c == '_' { c } else { '-' }).collect();
-        let base = base.trim();
-        let base = if base.is_empty() { "Library" } else { base };
+        self.insert(Library { name: name.to_string(), ..Default::default() })
+    }
+
+    /// `lib` as a new library, its file named after it, made the current one → its id.
+    fn insert(&mut self, lib: Library) -> Result<String> {
+        let base = file_stem_for(&lib.name);
         let taken = |id: &str| self.libs.iter().any(|(i, _)| i.eq_ignore_ascii_case(id)) || self.file_exists(id);
-        let id = std::iter::once(base.to_string()).chain((2..).map(|n| format!("{base} {n}"))).find(|id| !taken(id)).unwrap_or_default();
-        self.libs.push((id.clone(), Library { name: name.to_string(), ..Default::default() }));
+        let id = std::iter::once(base.clone()).chain((2..).map(|n| format!("{base} {n}"))).find(|id| !taken(id)).unwrap_or_default();
+        self.libs.push((id.clone(), lib));
         if let Err(e) = self.save(&id) {
             self.libs.retain(|(i, _)| i != &id);
             return Err(e);
@@ -194,15 +242,123 @@ impl Libraries {
 }
 
 impl Library {
-    /// At most [`MAX_ITEMS`] of each kind (a hand-edited file may hold more).
-    fn cap(&mut self) {
+    /// Every item as (kind, key: its name, a graphic's id, name shown): colours, then character
+    /// and paragraph styles, then graphics.
+    pub fn items(&self) -> impl Iterator<Item = (ItemKind, &str, &str)> {
+        fn styles(kind: ItemKind, list: &[TextStyleDef]) -> impl Iterator<Item = (ItemKind, &str, &str)> {
+            list.iter().map(move |t| (kind, t.name.as_str(), t.name.as_str()))
+        }
+        self.colors
+            .iter()
+            .map(|c| (ItemKind::Color, c.name.as_str(), c.name.as_str()))
+            .chain(styles(ItemKind::CharStyle, &self.char_styles))
+            .chain(styles(ItemKind::ParaStyle, &self.para_styles))
+            .chain(self.graphics.iter().map(|g| (ItemKind::Graphic, g.id.as_str(), g.name.as_str())))
+    }
+
+    /// The group of each grouped item: (kind, key) → its index in [`Library::groups`].
+    pub fn group_index(&self) -> HashMap<(ItemKind, &str), usize> {
+        self.groups.iter().enumerate().flat_map(|(i, g)| g.items.iter().map(move |r| ((r.kind, r.item.as_str()), i))).collect()
+    }
+
+    /// Group `name` (else the one of that name ignoring case): its index.
+    fn group_position(&self, name: &str) -> Option<usize> {
+        let lower = name.to_lowercase();
+        self.groups.iter().position(|g| g.name == name).or_else(|| self.groups.iter().position(|g| g.name.to_lowercase() == lower))
+    }
+
+    /// Item `item` of `kind` (a graphic by id, else by name) as a group names it.
+    fn item_ref(&self, kind: ItemKind, item: &str) -> Option<ItemRef> {
+        let found = self.items().find(|(k, key, _)| *k == kind && *key == item);
+        let found = found.or_else(|| self.items().find(|(k, _, name)| *k == kind && kind == ItemKind::Graphic && *name == item));
+        found.map(|(kind, key, _)| ItemRef { kind, item: key.to_string() })
+    }
+
+    /// Take `r` out of its group.
+    fn ungroup(&mut self, r: &ItemRef) {
+        for g in &mut self.groups {
+            g.items.retain(|x| x != r);
+        }
+    }
+
+    /// Make a library read from a file (hand-edited, imported) safe and consistent: at most
+    /// [`MAX_ITEMS`] items of each kind and [`MAX_GROUPS`] groups, names clipped to [`MAX_NAME`]
+    /// characters and unique within their kind (a repeated one gets a number), sizes finite, a
+    /// thumbnail only when it is a small PNG, and groups holding only items there are, each in one
+    /// group at most.
+    fn sanitize(&mut self) {
+        clip(&mut self.name);
         self.colors.truncate(MAX_ITEMS);
         self.char_styles.truncate(MAX_ITEMS);
         self.para_styles.truncate(MAX_ITEMS);
         self.graphics.truncate(MAX_ITEMS);
+        self.groups.truncate(MAX_GROUPS);
+        uniquify(self.colors.iter_mut().map(|c| &mut c.name), "Color", " ", false);
+        uniquify(self.char_styles.iter_mut().map(|t| &mut t.name), "Character Style", " ", false);
+        uniquify(self.para_styles.iter_mut().map(|t| &mut t.name), "Paragraph Style", " ", false);
+        uniquify(self.graphics.iter_mut().map(|g| &mut g.name), "Graphic", " ", false);
+        uniquify(self.graphics.iter_mut().map(|g| &mut g.id), "graphic", "-", false);
+        uniquify(self.groups.iter_mut().map(|g| &mut g.name), "Group", " ", true);
+        for g in &mut self.graphics {
+            for v in [&mut g.width, &mut g.height] {
+                if !(v.is_finite() && *v >= 0.0) {
+                    *v = 0.0;
+                }
+            }
+            if !thumbnail_ok(&g.thumbnail) {
+                g.thumbnail.clear();
+            }
+        }
+        let mut groups = std::mem::take(&mut self.groups);
+        let present: HashSet<(ItemKind, &str)> = self.items().map(|(k, key, _)| (k, key)).collect();
+        let mut seen = HashSet::new();
+        for g in &mut groups {
+            g.items.retain(|r| present.contains(&(r.kind, r.item.as_str())) && seen.insert(r.clone()));
+        }
+        self.groups = groups;
     }
 }
 
+/// `name` cut to [`MAX_NAME`] characters.
+fn clip(name: &mut String) {
+    if let Some((at, _)) = name.char_indices().nth(MAX_NAME) {
+        name.truncate(at);
+    }
+}
+
+/// Clip each of `names` ([`clip`]) and make it unique among them (ignoring case when `fold`): an
+/// empty one becomes `fallback`, a repeated one gets a number after `sep` (`Blue 2`).
+fn uniquify<'a>(names: impl Iterator<Item = &'a mut String>, fallback: &str, sep: &str, fold: bool) {
+    let key = |n: &str| if fold { n.to_lowercase() } else { n.to_string() };
+    let mut seen = HashSet::new();
+    for name in names {
+        clip(name);
+        if name.trim().is_empty() {
+            *name = fallback.to_string();
+        }
+        if seen.contains(&key(name)) {
+            let base = name.clone();
+            *name = (2..).map(|n| format!("{base}{sep}{n}")).find(|n| !seen.contains(&key(n))).unwrap_or_default();
+        }
+        seen.insert(key(name));
+    }
+}
+
+/// Whether `b64` is empty or a PNG of at most [`MAX_THUMBNAIL_SIDE`] pixels a side, judged by its
+/// header: the panel decodes it.
+fn thumbnail_ok(b64: &str) -> bool {
+    if b64.is_empty() {
+        return true;
+    }
+    // 32 base64 characters: 24 bytes, the signature then the IHDR chunk's length, type, width and
+    // height.
+    let Some(head) = b64.get(..32).filter(|_| b64.len() <= MAX_THUMBNAIL).and_then(vectorcraft_format::base64_decode) else { return false };
+    let side = |at: usize| {
+        head.get(at..at + 4).and_then(|b| <[u8; 4]>::try_from(b).ok()).map(u32::from_be_bytes).is_some_and(|v| (1..=MAX_THUMBNAIL_SIDE).contains(&v))
+    };
+    head.starts_with(b"\x89PNG\r\n\x1a\n") && head.get(12..16) == Some(b"IHDR".as_slice()) && side(16) && side(20)
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 fn library_paths(dir: &str) -> Vec<String> {
     let Ok(rd) = std::fs::read_dir(dir) else { return vec![] };
@@ -234,6 +390,14 @@ fn remove_file(_: &str) -> Result<()> {
     Ok(())
 }
 
+/// Library `name` as a file name without its extension: letters, digits, spaces, `-` and `_`
+/// kept, other characters as `-` ("Library" when nothing is left).
+pub fn file_stem_for(name: &str) -> String {
+    let safe: String = name.chars().map(|c| if c.is_alphanumeric() || c == ' ' || c == '-' || c == '_' { c } else { '-' }).collect();
+    let safe = safe.trim();
+    if safe.is_empty() { "Library".to_string() } else { safe.to_string() }
+}
+
 fn stem_of(path: &str) -> String {
     std::path::Path::new(path).file_stem().map_or_else(String::new, |s| s.to_string_lossy().into_owned())
 }
@@ -260,6 +424,16 @@ impl Kind {
             _ => return Err(bad(cmd, "kind must be graphic, fillColor, strokeColor, charStyle or paraStyle")),
         })
     }
+
+    /// The kind as a group names it (fill and stroke colours are one list).
+    fn item_kind(self) -> ItemKind {
+        match self {
+            Kind::Graphic => ItemKind::Graphic,
+            Kind::FillColor | Kind::StrokeColor => ItemKind::Color,
+            Kind::CharStyle => ItemKind::CharStyle,
+            Kind::ParaStyle => ItemKind::ParaStyle,
+        }
+    }
 }
 
 pub fn specs() -> Vec<CommandSpec> {
@@ -269,7 +443,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Libraries",
             [],
             None,
-            "{} → {libraries: [{id, name, graphics, colors, charStyles, paraStyles} (counts)], current: the current library's id or null, folder: the library folder, or null when libraries last for the session only (the web, headless)}",
+            "{} → {libraries: [{id, name, graphics, colors, charStyles, paraStyles, groups} (counts)], current: the current library's id or null, folder: the library folder, or null when libraries last for the session only (the web, headless)}",
             always,
             list
         ),
@@ -278,7 +452,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Library",
             [],
             None,
-            "{library?: id or name (default: the current library)} → {id, name, graphics: [{id, name, width, height, thumbnail: PNG base64}], colors: [{name, hex, color}], charStyles: [{name, attrs}], paraStyles: [{name, attrs}]}",
+            "{library?: id or name (default: the current library)} → {id, name, graphics: [{id, name, width, height, thumbnail: PNG base64}], colors: [{name, hex, color}], charStyles: [{name, attrs}], paraStyles: [{name, attrs}], groups: [{name, items: [{kind: color|charStyle|paraStyle|graphic, item: name (graphic: id)}]}] (an item is in one group at most; the others are ungrouped)}",
             always,
             get
         ),
@@ -336,7 +510,69 @@ pub fn specs() -> Vec<CommandSpec> {
             has_doc,
             use_item
         ),
-        cmd!("library.removeItem", "Delete Library Item", [], None, "{library?, kind, item: name (graphic: id or name)} → null", always, remove_item),
+        cmd!(
+            "library.removeItem",
+            "Delete Library Item",
+            [],
+            None,
+            "{library?, kind, item: name (graphic: id or name)} delete an item (out of its group too) → null",
+            always,
+            remove_item
+        ),
+        cmd!(
+            "library.createGroup",
+            "New Library Group",
+            [],
+            None,
+            "{library?, name?: \"Group\" (a name the library's groups have, ignoring case, gets a number), items?: [{kind, item}] (moved into it out of their groups)} a new group of items, after the others → {library, group: its name}",
+            always,
+            create_group
+        ),
+        cmd!(
+            "library.renameGroup",
+            "Rename Library Group",
+            [],
+            None,
+            "{library?, group: name, name} rename a group (another group's name, ignoring case, is an error) → {library, group: the new name}",
+            always,
+            rename_group
+        ),
+        cmd!(
+            "library.deleteGroup",
+            "Delete Library Group",
+            [],
+            None,
+            "{library?, group: name} delete a group: its items stay in the library, ungrouped → {library, ungrouped: how many}",
+            always,
+            delete_group
+        ),
+        cmd!(
+            "library.moveItem",
+            "Move Library Item to Group",
+            [],
+            None,
+            "{library?, kind, item: name (graphic: id or name), group?: name (null or none: out of its group)} put an item in a group (out of the one it was in) → {library, kind, item, group: name or null}",
+            always,
+            move_item
+        ),
+        cmd!(
+            query "library.export",
+            "Export Library",
+            [],
+            None,
+            "{library?: id or name (default: the current library), path?} write a library (its colours, styles, graphics with their art and thumbnails, and groups) as a .vclibrary file (JSON, as libraries are kept) → {path, name}; without path → {data: the file's text, name}",
+            always,
+            export
+        ),
+        cmd!(
+            query "library.import",
+            "Import Library",
+            [],
+            None,
+            "{path? | data?: file text | dataBase64?, name?: the library's name (default: the file's)} add the library of a .vclibrary file (as library.export writes) as a new library, made the current one; a name another library has gets a number (`Brand (2)`) → {id, name, graphics, colors, charStyles, paraStyles, groups (counts)}",
+            always,
+            import
+        ),
     ]
 }
 
@@ -362,6 +598,7 @@ fn counts(lib: &Library) -> Value {
         "colors": lib.colors.len(),
         "charStyles": lib.char_styles.len(),
         "paraStyles": lib.para_styles.len(),
+        "groups": lib.groups.len(),
     })
 }
 
@@ -391,6 +628,7 @@ fn get(s: &mut Session, p: &Value) -> Result<Value> {
         "colors": lib.colors.iter().map(|c| json!({"name": c.name, "hex": c.color.to_hex(), "color": c.color})).collect::<Vec<_>>(),
         "charStyles": lib.char_styles.iter().map(|t| json!({"name": t.name, "attrs": t.attrs})).collect::<Vec<_>>(),
         "paraStyles": lib.para_styles.iter().map(|t| json!({"name": t.name, "attrs": t.attrs})).collect::<Vec<_>>(),
+        "groups": lib.groups,
     }))
 }
 
@@ -457,7 +695,8 @@ fn add(s: &mut Session, p: &Value) -> Result<Value> {
                 }
                 let base = given.clone().unwrap_or_else(|| g.name.clone());
                 g.name = unique(&base, |n| lib.graphics.iter().any(|o| o.name == n));
-                g.id = unique("graphic", |n| lib.graphics.iter().any(|o| o.id == n)).replace(' ', "-");
+                // Ids are `graphic`, `graphic-2`…: taken ones are looked for as they are kept.
+                g.id = unique("graphic", |n| lib.graphics.iter().any(|o| o.id == n.replace(' ', "-"))).replace(' ', "-");
                 let v = json!({ "name": g.name, "id": g.id, "existing": false });
                 lib.graphics.push(g);
                 v
@@ -682,22 +921,171 @@ fn remove_item(s: &mut Session, p: &Value) -> Result<Value> {
     let (id, kind, item) = item_param(s, p, C)?;
     let item = item.to_string();
     s.libraries.change(&id, |lib| {
-        let before = (lib.graphics.len(), lib.colors.len(), lib.char_styles.len(), lib.para_styles.len());
+        let r = lib.item_ref(kind.item_kind(), &item).ok_or_else(|| bad(C, format!("the library has no item `{item}`")))?;
         match kind {
-            Kind::Graphic => {
-                let at = lib.graphics.iter().position(|g| g.id == item).or_else(|| lib.graphics.iter().position(|g| g.name == item));
-                if let Some(i) = at {
-                    lib.graphics.remove(i);
-                }
-            }
-            Kind::FillColor | Kind::StrokeColor => lib.colors.retain(|c| c.name != item),
-            Kind::CharStyle => lib.char_styles.retain(|t| t.name != item),
-            Kind::ParaStyle => lib.para_styles.retain(|t| t.name != item),
-        }
-        if before == (lib.graphics.len(), lib.colors.len(), lib.char_styles.len(), lib.para_styles.len()) {
-            return Err(bad(C, format!("the library has no item `{item}`")));
+            Kind::Graphic => lib.graphics.retain(|g| g.id != r.item),
+            Kind::FillColor | Kind::StrokeColor => lib.colors.retain(|c| c.name != r.item),
+            Kind::CharStyle => lib.char_styles.retain(|t| t.name != r.item),
+            Kind::ParaStyle => lib.para_styles.retain(|t| t.name != r.item),
         }
+        lib.ungroup(&r);
         Ok(())
     })?;
     ok()
 }
+
+/// `p`'s `name`, trimmed and clipped, else `default`.
+fn name_param(p: &Value, default: &str) -> String {
+    let mut name = str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()).unwrap_or(default).to_string();
+    clip(&mut name);
+    name
+}
+
+/// `p`'s `group`.
+fn group_param<'a>(p: &'a Value, cmd: &str) -> Result<&'a str> {
+    str_param(p, "group").ok_or_else(|| bad(cmd, "missing `group`"))
+}
+
+/// Group `name` of `lib`: its index.
+fn group_at(lib: &Library, name: &str, cmd: &str) -> Result<usize> {
+    lib.group_position(name).ok_or_else(|| bad(cmd, format!("the library has no group `{name}`")))
+}
+
+fn create_group(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "library.createGroup";
+    let id = library_id(s, p, C)?;
+    let base = name_param(p, "Group");
+    let wanted = match p.get("items") {
+        None | Some(Value::Null) => vec![],
+        Some(Value::Array(items)) if items.len() <= 4 * MAX_ITEMS => items
+            .iter()
+            .map(|v| Ok((Kind::of(v, C)?.item_kind(), str_param(v, "item").ok_or_else(|| bad(C, "each of `items` is {kind, item}"))?)))
+            .collect::<Result<Vec<_>>>()?,
+        Some(_) => return Err(bad(C, "`items` is a list of {kind, item}")),
+    };
+    let name = s.libraries.change(&id, |lib| {
+        if lib.groups.len() >= MAX_GROUPS {
+            return Err(bad(C, format!("the library holds {MAX_GROUPS} groups already")));
+        }
+        let refs = wanted
+            .iter()
+            .map(|&(kind, item)| lib.item_ref(kind, item).ok_or_else(|| bad(C, format!("the library has no item `{item}`"))))
+            .collect::<Result<Vec<_>>>()?;
+        let name = unique(&base, |n| lib.group_position(n).is_some());
+        let mut items = vec![];
+        let mut seen = HashSet::new();
+        for r in refs {
+            lib.ungroup(&r);
+            if seen.insert(r.clone()) {
+                items.push(r);
+            }
+        }
+        lib.groups.push(LibraryGroup { name: name.clone(), items });
+        Ok(name)
+    })?;
+    Ok(json!({ "library": id, "group": name }))
+}
+
+fn rename_group(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "library.renameGroup";
+    let id = library_id(s, p, C)?;
+    let group = group_param(p, C)?;
+    if str_param(p, "name").is_none_or(|n| n.trim().is_empty()) {
+        return Err(bad(C, "missing `name`"));
+    }
+    let name = name_param(p, "");
+    s.libraries.change(&id, |lib| {
+        let i = group_at(lib, group, C)?;
+        if lib.group_position(&name).is_some_and(|j| j != i) {
+            return Err(bad(C, format!("the library has a group `{name}` already")));
+        }
+        if let Some(g) = lib.groups.get_mut(i) {
+            g.name.clone_from(&name);
+        }
+        Ok(())
+    })?;
+    Ok(json!({ "library": id, "group": name }))
+}
+
+fn delete_group(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "library.deleteGroup";
+    let id = library_id(s, p, C)?;
+    let group = group_param(p, C)?;
+    let ungrouped = s.libraries.change(&id, |lib| {
+        let i = group_at(lib, group, C)?;
+        Ok(if i < lib.groups.len() { lib.groups.remove(i).items.len() } else { 0 })
+    })?;
+    Ok(json!({ "library": id, "ungrouped": ungrouped }))
+}
+
+fn move_item(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "library.moveItem";
+    let (id, kind, item) = item_param(s, p, C)?;
+    let group = str_param(p, "group");
+    let (key, to) = s.libraries.change(&id, |lib| {
+        let r = lib.item_ref(kind.item_kind(), item).ok_or_else(|| bad(C, format!("the library has no item `{item}`")))?;
+        let at = group.map(|g| group_at(lib, g, C)).transpose()?;
+        lib.ungroup(&r);
+        let key = r.item.clone();
+        let to = at.and_then(|i| lib.groups.get_mut(i)).map(|g| {
+            g.items.push(r);
+            g.name.clone()
+        });
+        Ok((key, to))
+    })?;
+    Ok(json!({ "library": id, "kind": str_param(p, "kind"), "item": key, "group": to }))
+}
+
+fn export(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "library.export";
+    let id = library_id(s, p, C)?;
+    let lib = s.libraries.get(&id).ok_or_else(|| bad(C, format!("no library `{id}`")))?;
+    let text = serde_json::to_string(lib).map_err(|e| bad(C, e.to_string()))?;
+    let name = lib.name.clone();
+    match str_param(p, "path") {
+        Some(path) => {
+            super::fileio::write_file(path, text.as_bytes())?;
+            Ok(json!({ "path": path, "name": name }))
+        }
+        None => Ok(json!({ "data": text, "name": name })),
+    }
+}
+
+fn import(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "library.import";
+    let too_big = || bad(C, format!("the file is larger than {} MB", MAX_FILE >> 20));
+    let bytes: std::borrow::Cow<[u8]> = match (str_param(p, "path"), str_param(p, "data"), str_param(p, "dataBase64")) {
+        (Some(path), ..) => {
+            if super::fileio::file_stamp(path).is_some_and(|(len, _)| len > MAX_FILE) {
+                return Err(too_big());
+            }
+            super::fileio::read_file(path)?.into()
+        }
+        (None, Some(text), _) => text.as_bytes().into(),
+        (None, None, Some(b64)) => vectorcraft_format::base64_decode(b64).ok_or_else(|| bad(C, "bad dataBase64"))?.into(),
+        _ => return Err(bad(C, "give `path`, `data` or `dataBase64`")),
+    };
+    if bytes.len() as u64 > MAX_FILE {
+        return Err(too_big());
+    }
+    let not_library = |e: String| bad(C, format!("not a library file: {e}"));
+    let v: Value = serde_json::from_slice(&bytes).map_err(|e| not_library(e.to_string()))?;
+    drop(bytes);
+    // A library names itself; another file of ours (swatches, styles) says what it is.
+    if !v.get("name").is_some_and(Value::is_string) || v.get("format").is_some_and(|f| f.as_str() != Some(LIBRARY_EXT)) {
+        return Err(not_library("it has no library name".into()));
+    }
+    let mut lib: Library = serde_json::from_value(v).map_err(|e| not_library(e.to_string()))?;
+    lib.sanitize();
+    let base = str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()).unwrap_or(lib.name.trim()).to_string();
+    let mut base = if base.is_empty() { "Library".to_string() } else { base };
+    clip(&mut base);
+    let taken = |n: &str| s.libraries.all().iter().any(|(_, l)| l.name.to_lowercase() == n.to_lowercase());
+    lib.name = std::iter::once(base.clone()).chain((2..).map(|n| format!("{base} ({n})"))).find(|n| !taken(n)).unwrap_or(base);
+    let mut r = json!({ "name": lib.name });
+    if let (Some(o), Value::Object(c)) = (r.as_object_mut(), counts(&lib)) {
+        o.extend(c);
+    }
+    r["id"] = json!(s.libraries.insert(lib)?);
+    Ok(r)
+}

crates/engine/src/cmd/object.rs

@@ -196,7 +196,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Live Shape Properties",
             [],
             None,
-            "{id?, ids?, radius?: pt, kind?: \"round\"|\"invertedRound\"|\"chamfer\", corners?: [i…], sides?: n, polygonAngle?: degrees (counterclockwise from its first vertex straight up), polygonRadius?: pt (centre to vertex), sideLength?: pt (sets the radius), makeSidesEqual?: true (a polygon scaled unevenly: drops the uneven scale and shear, keeping its centre, angle and mean radius), pieStart?, pieEnd?: degrees (an ellipse's pie, counterclockwise from 3 o'clock; 0 to 360 is the whole ellipse), invertPie?: true (swaps them: the other part of the ellipse)} (Live Corners on any path: radius and kind set its corners (anchors without handles between two straight sides): `corners` (anchor indices of the path with its corners uncut, counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a polygon's from the first vertex clockwise), else the corners with a Direct-Selected anchor, else every corner; each radius is drawn no larger than half the corner's shorter side allows; a path that isn't a live shape keeps its uncut outline so its corners stay editable, and is plain again once none is cut; sides: a polygon's, which keep the radius they shared; the polygon params apply in that order: sides, makeSidesEqual, polygonAngle, then sideLength or else polygonRadius)",
+            "{id?, ids?, radius?: pt, kind?: \"round\"|\"invertedRound\"|\"chamfer\", corners?: [i…], items?: [{id, corners?: [i…]}] (several objects, each with its own corners, in place of ids and corners: the canvas's corner widgets across a selection), sides?: n, polygonAngle?: degrees (counterclockwise from its first vertex straight up), polygonRadius?: pt (centre to vertex), sideLength?: pt (sets the radius), makeSidesEqual?: true (a polygon scaled unevenly: drops the uneven scale and shear, keeping its centre, angle and mean radius), pieStart?, pieEnd?: degrees (an ellipse's pie, counterclockwise from 3 o'clock; 0 to 360 is the whole ellipse), invertPie?: true (swaps them: the other part of the ellipse)} (Live Corners on any path: radius and kind set its corners (anchors without handles between two straight sides): `corners` (anchor indices of the path with its corners uncut, counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a polygon's from the first vertex clockwise), else the corners with a Direct-Selected anchor, else every corner; each radius is drawn no larger than half the corner's shorter side allows; a path that isn't a live shape keeps its uncut outline so its corners stay editable, and is plain again once none is cut; sides: a polygon's, which keep the radius they shared; the polygon params apply in that order: sides, makeSidesEqual, polygonAngle, then sideLength or else polygonRadius)",
             has_selection,
             set_live_shape
         ),
@@ -1083,8 +1083,32 @@ fn corners_param(p: &Value) -> Result<Option<BTreeSet<usize>>> {
 }
 
 fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
-    let ids = targets(s, p)?;
-    let corners = corners_param(p)?;
+    // `items`: objects each with its own `corners`; else `ids` (or the selection) sharing them.
+    let items = match p.get("items").filter(|v| !v.is_null()) {
+        None => None,
+        Some(Value::Array(a)) => Some(
+            a.iter()
+                .map(|it| {
+                    let id = it
+                        .get("id")
+                        .and_then(Value::as_u64)
+                        .map(NodeId)
+                        .ok_or_else(|| bad("object.setLiveShape", format!("each of `items` is {{id, corners?}} with an object id, not {it}")))?;
+                    Ok((id, corners_param(it)?))
+                })
+                .collect::<Result<Vec<_>>>()?,
+        ),
+        Some(v) => return Err(bad("object.setLiveShape", format!("`items` must be an array of {{id, corners?}}, not {v}"))),
+    };
+    let ids = match &items {
+        Some(items) => items.iter().map(|(id, _)| *id).collect(),
+        None => targets(s, p)?,
+    };
+    let shared = corners_param(p)?;
+    let corners_of = |id: NodeId| match &items {
+        Some(items) => items.iter().find(|(i, _)| *i == id).and_then(|(_, c)| c.clone()),
+        None => shared.clone(),
+    };
     let kind = p
         .get("kind")
         .filter(|v| !v.is_null())
@@ -1154,6 +1178,7 @@ fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
             let partial = sel.anchors.get_mut(id);
             // The corners to edit, the Direct-Selected ones and the anchor layout before the edit.
             let Some(c) = LiveCorners::new(path, live.as_ref()) else { continue };
+            let corners = corners_of(*id);
             let picked = match &corners {
                 Some(k) if k.last().is_some_and(|k| *k >= c.base.anchor_count()) => {
                     let n = c.base.anchor_count();

crates/engine/src/tests_brushsym.rs

@@ -297,6 +297,77 @@ fn brush_options_set_variation_modes() {
     assert_eq!(s.execute("brush.get", &json!({"name": "3 pt. Round"})).unwrap(), b, "a refused edit changes nothing");
 }
 
+/// The bounds of the brush art `id`'s strokes draw.
+fn brushed_bounds(s: &Session, id: NodeId) -> Rect {
+    let st = s.doc().unwrap();
+    let pieces = vectorcraft_brush::node_pieces(&st.doc, &node(s, id)).expect("brushed");
+    vectorcraft_brush::pieces_bounds(&pieces).expect("draws")
+}
+
+/// Scatter, Art and Pattern Brush Options: the params reach the brush and every stroke painted
+/// with it redraws; values out of range are clamped, unknown choices refused.
+#[test]
+fn scatter_art_and_pattern_brush_options_update_strokes() {
+    let mut s = session();
+    // A rectangle as an art brush (straight edges: no flattening between sizes).
+    let r = rect(&mut s, 10.0, 200.0, 40.0, 8.0);
+    let bar = s.execute("brush.new", &json!({"type": "art", "name": "Bar", "ids": [r.0]})).unwrap()["name"].as_str().unwrap().to_string();
+    let id = line(&mut s);
+    select(&mut s, &[id]);
+    let edit = |s: &mut Session, name: &str, params: Value| -> f64 {
+        s.execute("brush.apply", &json!({ "name": name })).unwrap();
+        let before = brushed_bounds(s, id).height();
+        s.execute("brush.options", &json!({ "name": name, "params": params })).unwrap();
+        brushed_bounds(s, id).height() / before
+    };
+    // Art: Width 300 % draws the art three times as wide across the path.
+    let art = json!({"width": 300, "direction": "rightToLeft", "flip_across": true});
+    assert!((edit(&mut s, &bar, art) - 3.0).abs() < 1e-6);
+    s.execute("brush.options", &json!({"name": bar, "params": {"scale": {"mode": "betweenGuides", "start": 0.2, "end": 0.6}}})).unwrap();
+    let b = s.execute("brush.get", &json!({ "name": bar })).unwrap();
+    assert_eq!(
+        (&b["direction"], &b["flip_across"], &b["scale"]),
+        (&json!("rightToLeft"), &json!(true), &json!({"mode": "betweenGuides", "start": 0.2, "end": 0.6}))
+    );
+    // Pattern: Scale 200 % doubles the tiles.
+    assert!((edit(&mut s, "Stitches", json!({"scale": 200, "spacing": 50, "fit": "addSpace", "flip_along": true})) - 2.0).abs() < 0.05);
+    let b = s.execute("brush.get", &json!({"name": "Stitches"})).unwrap();
+    assert_eq!((&b["spacing"], &b["fit"]), (&json!(50.0), &json!("addSpace")));
+    // Scatter: a fixed Size of 200 % doubles the dots; the modes and Hue Shift are kept.
+    let key = json!({"model": "rgb", "r": 0.0, "g": 0.0, "b": 0.0});
+    let scatter = json!({"size": [200, 50], "modes": ["fixed", "fixed", "fixed", "random"], "rotation_relative_to_path": true, "colorization": {"method": "hueShift", "key": key}});
+    assert!((edit(&mut s, "Dots", scatter) - 2.0).abs() < 0.05);
+    let b = s.execute("brush.get", &json!({"name": "Dots"})).unwrap();
+    assert_eq!(
+        (&b["modes"], &b["colorization"]["method"], &b["colorization"]["key"]),
+        (&json!(["fixed", "fixed", "fixed", "random"]), &json!("hueShift"), &key)
+    );
+    // Out of range: clamped. Unknown choices: refused, nothing changes.
+    let junk = json!({"size": [1e308, -1e308], "spacing": [0, 1e308], "rotation": [720, -1e9], "scatter": [-1e308, 5]});
+    s.execute("brush.options", &json!({"name": "Dots", "params": junk})).unwrap();
+    let b = s.execute("brush.get", &json!({"name": "Dots"})).unwrap();
+    assert_eq!(
+        (&b["size"], &b["spacing"], &b["rotation"], &b["scatter"]),
+        (&json!([10000.0, 1.0]), &json!([1.0, 10000.0]), &json!([180.0, -180.0]), &json!([-1000.0, 5.0]))
+    );
+    assert!(brushed_bounds(&s, id).is_finite());
+    for (name, bad) in [
+        ("Dots", json!({"modes": ["fixed", "tilt", "fixed", "fixed"]})),
+        ("Dots", json!({"modes": ["fixed"]})),
+        ("Dots", json!({"colorization": {"method": "sparkle"}})),
+        ("Arrow", json!({"direction": "diagonal"})),
+        ("Arrow", json!({"width": "wide"})),
+        ("Chain", json!({"fit": "squeeze"})),
+    ] {
+        let before = s.execute("brush.get", &json!({ "name": name })).unwrap();
+        assert!(s.execute("brush.options", &json!({ "name": name, "params": bad })).is_err(), "{bad}");
+        assert_eq!(s.execute("brush.get", &json!({ "name": name })).unwrap(), before);
+    }
+    s.execute("brush.options", &json!({"name": "Chain", "params": {"scale": 1e308, "spacing": -1e308}})).unwrap();
+    let b = s.execute("brush.get", &json!({"name": "Chain"})).unwrap();
+    assert_eq!((&b["scale"], &b["spacing"]), (&json!(10000.0), &json!(0.0)));
+}
+
 // ---------- symbols ----------
 
 fn make_symbol(s: &mut Session) -> (NodeId, String, Rect) {

crates/engine/src/tests_library.rs

@@ -161,3 +161,181 @@ fn libraries_are_kept_in_files_across_sessions() {
     assert_eq!(run(&mut v, "library.list", json!({}))["libraries"], json!([]));
     let _ = std::fs::remove_dir_all(&dir);
 }
+
+/// A library "Brand" holding a graphic, a colour and a character style, each added from the
+/// selection → (session, the graphic's id, the colour's name, the style's name).
+fn brand() -> (Session, String, String, String) {
+    let mut s = session();
+    run(&mut s, "library.create", json!({"name": "Brand"}));
+    let r = run(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 20, "height": 20}))["id"].clone();
+    run(&mut s, "paint.setFill", json!({"color": "#336699", "ids": [r]}));
+    run(&mut s, "select.set", json!({"ids": [r]}));
+    let g = run(&mut s, "library.add", json!({"kind": "graphic", "name": "Logo"}))["id"].as_str().unwrap().to_string();
+    let c = run(&mut s, "library.add", json!({"kind": "fillColor"}))["name"].as_str().unwrap().to_string();
+    let t = run(&mut s, "text.create", json!({"x": 10, "y": 80, "text": "Type", "size": 18}))["id"].clone();
+    run(&mut s, "select.set", json!({"ids": [t]}));
+    let st = run(&mut s, "library.add", json!({"kind": "charStyle"}))["name"].as_str().unwrap().to_string();
+    (s, g, c, st)
+}
+
+/// The current library's groups as `library.get` reports them: (name, [(kind, item)]).
+fn groups(s: &mut Session) -> Vec<(String, Vec<(String, String)>)> {
+    let got = run(s, "library.get", json!({}));
+    got["groups"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .map(|g| {
+            let items = g["items"].as_array().unwrap().iter().map(|r| (r["kind"].as_str().unwrap().into(), r["item"].as_str().unwrap().into()));
+            (g["name"].as_str().unwrap().to_string(), items.collect())
+        })
+        .collect()
+}
+
+fn refs(v: &[(&str, &str)]) -> Vec<(String, String)> {
+    v.iter().map(|(k, i)| (k.to_string(), i.to_string())).collect()
+}
+
+/// Graphics added one after another get ids of their own (the third used to repeat the second's).
+#[test]
+fn every_graphic_gets_an_id_of_its_own() {
+    let mut s = session();
+    run(&mut s, "library.create", json!({}));
+    let mut ids = vec![];
+    for x in [0, 30, 60, 90] {
+        let r = run(&mut s, "shape.rectangle", json!({"x": x, "y": 0, "width": 10 + x, "height": 10}))["id"].clone();
+        ids.push(run(&mut s, "library.add", json!({"kind": "graphic", "ids": [r]}))["id"].as_str().unwrap().to_string());
+    }
+    assert_eq!(ids, ["graphic", "graphic-2", "graphic-3", "graphic-4"]);
+}
+
+/// Items go into user-named groups and back out (#926); deleting a group keeps its items.
+#[test]
+fn items_are_grouped_moved_and_ungrouped() {
+    let (mut s, g, c, st) = brand();
+    assert!(groups(&mut s).is_empty(), "no groups yet");
+    // A group made with items; a graphic is named by its name or its id.
+    let r = run(&mut s, "library.createGroup", json!({"name": "Logos", "items": [{"kind": "graphic", "item": "Logo"}]}));
+    assert_eq!(r["group"], "Logos");
+    assert_eq!(groups(&mut s), [("Logos".into(), refs(&[("graphic", &g)]))]);
+    // A name taken (ignoring case) gets a number.
+    assert_eq!(run(&mut s, "library.createGroup", json!({"name": "logos"}))["group"], "logos 2");
+    run(&mut s, "library.renameGroup", json!({"group": "logos 2", "name": "Palette"}));
+    assert!(s.execute("library.renameGroup", &json!({"group": "Palette", "name": "LOGOS"})).is_err(), "another group's name");
+    assert!(s.execute("library.renameGroup", &json!({"group": "Nope", "name": "X"})).is_err());
+    // Moving an item takes it out of the group it was in; a colour is named as fill or stroke.
+    run(&mut s, "library.moveItem", json!({"kind": "strokeColor", "item": c, "group": "palette"}));
+    run(&mut s, "library.moveItem", json!({"kind": "charStyle", "item": st, "group": "Palette"}));
+    let moved = run(&mut s, "library.moveItem", json!({"kind": "graphic", "item": "Logo", "group": "Palette"}));
+    assert_eq!((moved["item"].as_str(), moved["group"].as_str()), (Some(g.as_str()), Some("Palette")));
+    assert_eq!(groups(&mut s), [("Logos".into(), vec![]), ("Palette".into(), refs(&[("color", &c), ("charStyle", &st), ("graphic", &g)]))]);
+    // Without a group, out of its group.
+    assert!(run(&mut s, "library.moveItem", json!({"kind": "fillColor", "item": c}))["group"].is_null());
+    assert!(s.execute("library.moveItem", &json!({"kind": "fillColor", "item": c, "group": "Nope"})).is_err());
+    assert!(s.execute("library.moveItem", &json!({"kind": "fillColor", "item": "#nope", "group": "Palette"})).is_err());
+    assert!(s.execute("library.createGroup", &json!({"items": [{"kind": "graphic", "item": "nope"}]})).is_err(), "no such item");
+    assert_eq!(groups(&mut s).len(), 2, "a failed command makes no group");
+    // A deleted item leaves its group.
+    run(&mut s, "library.removeItem", json!({"kind": "charStyle", "item": st}));
+    assert_eq!(groups(&mut s)[1].1, refs(&[("graphic", &g)]));
+    // A deleted group's items stay, ungrouped.
+    assert_eq!(run(&mut s, "library.deleteGroup", json!({"group": "Palette"}))["ungrouped"], 1);
+    assert_eq!(run(&mut s, "library.get", json!({}))["graphics"].as_array().unwrap().len(), 1);
+    assert_eq!(groups(&mut s), [("Logos".into(), vec![])]);
+    assert_eq!(run(&mut s, "library.list", json!({}))["libraries"][0]["groups"], 1);
+}
+
+/// A library goes out to a file with its art and groups and comes back as a new library, numbered
+/// when its name is taken; the graphic it brings places in a document (#926).
+#[test]
+fn a_library_is_exported_and_imported() {
+    let (mut s, g, c, _) = brand();
+    run(&mut s, "library.createGroup", json!({"name": "Logos", "items": [{"kind": "graphic", "item": g}, {"kind": "fillColor", "item": c}]}));
+    let out = run(&mut s, "library.export", json!({}));
+    assert_eq!(out["name"], "Brand");
+    let data = out["data"].as_str().unwrap().to_string();
+    let r = run(&mut s, "library.import", json!({"data": data}));
+    let counts = ["graphics", "colors", "charStyles", "paraStyles", "groups"].map(|k| r[k].as_u64().unwrap());
+    assert_eq!((r["name"].as_str(), counts), (Some("Brand (2)"), [1, 1, 1, 0, 1]));
+    let id = r["id"].as_str().unwrap().to_string();
+    assert_eq!(run(&mut s, "library.list", json!({}))["current"], id, "the imported library is the current one");
+    let a = run(&mut s, "library.get", json!({"library": "Brand"}));
+    let b = run(&mut s, "library.get", json!({"library": id}));
+    for k in ["graphics", "colors", "charStyles", "paraStyles", "groups"] {
+        assert_eq!(a[k], b[k], "{k}");
+    }
+    // Again: the next number; given a name, that name.
+    let b64 = vectorcraft_format::base64_encode(data.as_bytes());
+    assert_eq!(run(&mut s, "library.import", json!({"dataBase64": b64}))["name"], "Brand (3)");
+    assert_eq!(run(&mut s, "library.import", json!({"data": data, "name": "Client"}))["name"], "Client");
+    // Its graphic places in another document.
+    run(&mut s, "file.new", json!({"width": 100, "height": 100}));
+    let placed = run(&mut s, "library.use", json!({"library": id, "kind": "graphic", "item": "Logo", "center": [50, 50]}));
+    assert_eq!(placed["ids"].as_array().unwrap().len(), 1);
+    // Not a library file.
+    let swatches = json!({"format": "vcswatches", "name": "S"}).to_string();
+    for bad in [json!({"data": "{not json"}), json!({"data": "[1, 2]"}), json!({"data": swatches}), json!({"dataBase64": "%%"}), json!({})] {
+        assert!(s.execute("library.import", &bad).is_err(), "{bad}");
+    }
+}
+
+/// A file written before groups loads; one with repeated names, groups naming items that aren't
+/// there or kinds this version doesn't know, and a thumbnail claiming a huge image is made safe.
+#[test]
+fn imported_libraries_are_made_consistent() {
+    let mut s = session();
+    let old = json!({"name": "Old", "colors": [{"name": "Red", "color": {"model": "rgb", "r": 1, "g": 0, "b": 0}}]});
+    let r = run(&mut s, "library.import", json!({"data": old.to_string()}));
+    assert_eq!((r["colors"].as_u64(), r["groups"].as_u64()), (Some(1), Some(0)));
+    // A PNG header claiming 100000 × 100000 pixels.
+    let mut png = b"\x89PNG\r\n\x1a\n\0\0\0\x0dIHDR".to_vec();
+    png.extend(100_000u32.to_be_bytes());
+    png.extend(100_000u32.to_be_bytes());
+    png.extend([8, 6, 0, 0, 0]);
+    let messy = json!({
+        "name": "  ",
+        "colors": [{"name": "Red", "color": {"model": "rgb", "r": 1, "g": 0, "b": 0}}, {"name": "Red", "color": {"model": "rgb", "r": 0, "g": 1, "b": 0}}, {"name": "", "color": {"model": "rgb", "r": 0, "g": 0, "b": 1}}],
+        "graphics": [
+            {"id": "g", "name": "A", "width": 1, "height": 1, "data": "", "thumbnail": vectorcraft_format::base64_encode(&png)},
+            {"id": "g", "name": "B", "width": -5, "height": 1, "data": ""}
+        ],
+        "groups": [
+            {"name": "One", "items": [{"kind": "color", "item": "Red 2"}, {"kind": "graphic", "item": "nope"}, {"kind": "brush", "item": "Red"}]},
+            {"name": "one", "items": [{"kind": "color", "item": "Red 2"}, {"kind": "graphic", "item": "g-2"}]}
+        ]
+    });
+    let r = run(&mut s, "library.import", json!({"data": messy.to_string()}));
+    assert_eq!(r["name"], "Library", "a blank name");
+    let got = run(&mut s, "library.get", json!({}));
+    let names: Vec<&str> = got["colors"].as_array().unwrap().iter().map(|c| c["name"].as_str().unwrap()).collect();
+    assert_eq!(names, ["Red", "Red 2", "Color"]);
+    let graphics = got["graphics"].as_array().unwrap();
+    assert_eq!((graphics[0]["id"].as_str(), graphics[1]["id"].as_str()), (Some("g"), Some("g-2")));
+    assert_eq!((graphics[0]["thumbnail"].as_str(), graphics[1]["width"].as_f64()), (Some(""), Some(0.0)));
+    assert_eq!(
+        got["groups"],
+        json!([{"name": "One", "items": [{"kind": "color", "item": "Red 2"}]}, {"name": "one 2", "items": [{"kind": "graphic", "item": "g-2"}]}])
+    );
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn a_library_is_exported_to_a_file_and_imported_from_it() {
+    let dir = vectorcraft_testkit::temp_dir("library-export");
+    let path = dir.join("Brand.vclibrary").to_string_lossy().to_string();
+    let (mut s, g, ..) = brand();
+    run(&mut s, "library.createGroup", json!({"name": "Logos", "items": [{"kind": "graphic", "item": g}]}));
+    assert_eq!(run(&mut s, "library.export", json!({"library": "Brand", "path": path}))["path"], path.as_str());
+    let mut t = session();
+    let r = run(&mut t, "library.import", json!({"path": path}));
+    assert_eq!((r["name"].as_str(), r["graphics"].as_u64(), r["groups"].as_u64()), (Some("Brand"), Some(1), Some(1)));
+    assert!(t.execute("library.import", &json!({"path": dir.join("missing.vclibrary").to_string_lossy()})).is_err());
+    // Groups are kept in the library folder's files too.
+    let folder = dir.join("folder").to_string_lossy().to_string();
+    let mut u = session();
+    u.libraries.set_dir(Some(folder.clone()));
+    run(&mut u, "library.import", json!({"path": path}));
+    let mut v = session();
+    v.libraries.set_dir(Some(folder));
+    assert_eq!(groups(&mut v), [("Logos".into(), refs(&[("graphic", &g)]))]);
+}

crates/engine/src/tests_livecorners.rs

@@ -58,6 +58,25 @@ fn a_whole_rectangle_rounds_all_corners_and_given_corners_alone() {
     assert_eq!(corners(&s, id).1[3], CornerKind::Chamfer);
 }
 
+/// #938: `items` rounds several objects in one step, each its own corners (or all of them).
+#[test]
+fn items_round_several_objects_each_its_own_corners() {
+    let (mut s, a) = session();
+    let b = NodeId(s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 100, "height": 60})).unwrap()["id"].as_u64().unwrap());
+    let undo = s.doc().unwrap().history.undo.len();
+    run(&mut s, json!({"items": [{"id": a.0, "corners": [2]}, {"id": b.0}], "radius": 6}));
+    assert_eq!(corners(&s, a).0, [0.0, 0.0, 6.0, 0.0]);
+    assert_eq!(corners(&s, b).0, [6.0; 4]);
+    assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1, "one step");
+    for p in [
+        json!({"items": 3, "radius": 1}),
+        json!({"items": [{"corners": [1]}], "radius": 1}),
+        json!({"items": [{"id": a.0, "corners": [9]}], "radius": 1}),
+    ] {
+        assert!(s.execute("object.setLiveShape", &p).is_err(), "{p}");
+    }
+}
+
 #[test]
 fn bad_corners_and_kinds_are_errors() {
     let (mut s, id) = session();

crates/engine/src/tests_rasterfilters.rs

@@ -21,6 +21,10 @@ const EFFECTS: [(&str, &str); 3] = [
 const PIXELATE: [(&str, &str); 4] =
     [("pixelate.colorHalftone", "{}"), ("pixelate.crystallize", "{}"), ("pixelate.mezzotint", "{}"), ("pixelate.pointillize", "{}")];
 
+/// Effect › Video (NTSC Colors leaves the striped art's legal colours as they are: see
+/// `ntsc_colors_draws_saturated_yellow_safer`).
+const VIDEO: [(&str, &str); 1] = [("video.deinterlace", r#"{"create": "interpolation"}"#)];
+
 /// A group of a red square and a darker red stripe across it; returns the group's id.
 fn striped() -> (Session, u64) {
     let mut s = Session::new();
@@ -57,9 +61,11 @@ fn listed_applied_edited_and_undone() {
     let menus: Vec<Value> =
         EFFECTS.iter().map(|(id, _)| list["catalog"].as_array().unwrap().iter().find(|e| e["id"] == *id).unwrap()["menu"].clone()).collect();
     assert_eq!(menus, [json!(["Effect", "Blur"]), json!(["Effect", "Blur"]), json!(["Effect", "Sharpen"])]);
-    for (id, _) in PIXELATE {
-        let e = list["catalog"].as_array().unwrap().iter().find(|e| e["id"] == id).unwrap_or_else(|| panic!("{id} listed"));
-        assert_eq!((&e["raster"], &e["menu"]), (&json!(true), &json!(["Effect", "Pixelate"])), "{id}");
+    for (group, menu) in [(PIXELATE.as_slice(), "Pixelate"), (VIDEO.as_slice(), "Video"), ([("video.ntscColors", "{}")].as_slice(), "Video")] {
+        for (id, _) in group {
+            let e = list["catalog"].as_array().unwrap().iter().find(|e| e["id"] == *id).unwrap_or_else(|| panic!("{id} listed"));
+            assert_eq!((&e["raster"], &e["menu"]), (&json!(true), &json!(["Effect", menu])), "{id}");
+        }
     }
     // Junk parameters are stored as given and read clamped; the canvas still draws.
     for (id, _) in EFFECTS {
@@ -80,7 +86,7 @@ fn listed_applied_edited_and_undone() {
 
 #[test]
 fn each_effect_changes_the_canvas_and_draws_the_same_twice() {
-    for (id, params) in EFFECTS.into_iter().chain(PIXELATE) {
+    for (id, params) in EFFECTS.into_iter().chain(PIXELATE).chain(VIDEO) {
         let (mut s, g) = striped();
         let plain = render(&s);
         let params: Value = serde_json::from_str(params).unwrap();
@@ -109,7 +115,7 @@ fn spin_blur_reaches_past_the_corners() {
 
 #[test]
 fn pdf_and_svg_write_the_effected_object_as_an_image() {
-    for (id, params) in EFFECTS.into_iter().chain(PIXELATE) {
+    for (id, params) in EFFECTS.into_iter().chain(PIXELATE).chain(VIDEO) {
         let (mut s, g) = striped();
         let params: Value = serde_json::from_str(params).unwrap();
         s.execute("effect.apply", &json!({"effect": id, "ids": [g], "params": params})).unwrap();
@@ -140,3 +146,22 @@ fn expand_appearance_makes_an_image() {
     s.execute("effect.expandAppearance", &json!({"ids": [g]})).unwrap();
     assert!(matches!(s.doc().unwrap().doc.node(NodeId(g)).unwrap().kind, NodeKind::Image(_)));
 }
+
+/// Video › NTSC Colors on the canvas: a saturated yellow, too strong for a television signal, draws
+/// less saturated; the effect is listed and applies without options.
+#[test]
+fn ntsc_colors_draws_saturated_yellow_safer() {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
+    let id = s.execute("shape.rectangle", &json!({"x": 50, "y": 50, "width": 100, "height": 100})).unwrap()["id"].as_u64().unwrap();
+    s.execute("paint.setFill", &json!({"color": "#ffff00", "ids": [id]})).unwrap();
+    s.execute("paint.setStroke", &json!({"none": true, "ids": [id]})).unwrap();
+    let before = render(&s);
+    s.execute("effect.apply", &json!({"effect": "video.ntscColors", "ids": [id]})).unwrap();
+    let after = render(&s);
+    let px = |r: &Rendered| r.pixel(100, 100);
+    let (a, b) = (px(&before), px(&after));
+    assert_eq!(&a[..3], &[255, 255, 0]);
+    assert!(b[2] > 20 && b[0] < 255 && b[3] == 255, "less saturated: {b:?}");
+    assert_eq!(after.pixels, render(&s).pixels, "deterministic");
+}

crates/engine/tests/command_sweep.rs

@@ -227,6 +227,20 @@ fn structured_junk() {
             "brush.options",
             json!({"name": "3 pt. Round", "params": {"modes": ["pressure", "pressure", "pressure"], "variation": [1e308, 1e308, 1e308], "size": 1e308, "angle": -1e308}}),
         ),
+        (
+            "brush.options",
+            json!({"name": "Confetti", "params": {"size": [1e308, -1e308], "spacing": [0, 1e308], "scatter": [-1e308, 1e308], "rotation": [1e308, -1e308], "modes": ["pressure", "random", "fixed", "pressure"]}}),
+        ),
+        ("brush.options", json!({"name": "Dots", "params": {"modes": ["fixed", "tilt", "fixed", "fixed"], "size": "x"}})),
+        ("brush.options", json!({"name": "Dots", "params": {"modes": ["fixed"], "colorization": {"method": "sparkle"}}})),
+        (
+            "brush.options",
+            json!({"name": "Dots", "params": {"colorization": {"method": "hueShift", "key": {"model": "rgb", "r": 1e308, "g": -1e308, "b": 0}}}}),
+        ),
+        ("brush.options", json!({"name": "Arrow", "params": {"width": 1e308, "scale": {"mode": "betweenGuides", "start": 1e308, "end": -1e308}}})),
+        ("brush.options", json!({"name": "Arrow", "params": {"width": -5, "direction": "diagonal", "flip_along": "yes"}})),
+        ("brush.options", json!({"name": "Chain", "params": {"scale": 1e308, "spacing": -1e308, "fit": "approximate", "flip_across": true}})),
+        ("brush.options", json!({"name": "Chain", "params": {"scale": 0, "spacing": 1e308, "fit": "nope", "side": null}})),
         ("path.curvature", json!({"points": [{"x": 0, "y": 0}]})),
         ("path.curvatureEdit", json!({"id": 2, "op": "move", "anchor": 1000, "x": 0, "y": 0})),
         ("path.curvatureEdit", json!({"id": 2, "op": "move", "anchor": 0, "x": 1e308, "y": -1e308})),
@@ -282,6 +296,8 @@ fn structured_junk() {
         ("effect.apply", json!({"effect": "pixelate.crystallize", "params": {"cellSize": -1e308}})),
         ("effect.apply", json!({"effect": "pixelate.mezzotint", "params": {"type": 5}})),
         ("effect.apply", json!({"effect": "pixelate.pointillize", "params": {"cellSize": "NaN"}})),
+        ("effect.apply", json!({"effect": "video.deinterlace", "params": {"eliminate": 7, "create": ["x"]}})),
+        ("effect.apply", json!({"effect": "video.ntscColors", "params": {"junk": 1e308}})),
         ("effect.apply", json!({"effect": "no.such.effect"})),
         ("effect.remove", json!({"index": 99})),
         ("effect.setParams", json!({"index": 0, "params": null})),

crates/engine/tests/import_fuzz.rs

@@ -804,6 +804,53 @@ fn styles(what: &str, data: &str) -> Result<(), TestCaseError> {
     })
 }
 
+/// Libraries panel library file `data` imported, then each kind's first item used on the rich
+/// document and moved into its first group, the group deleted and the library exported (#926).
+fn libraries(what: &str, data: &str) -> Result<(), TestCaseError> {
+    survive_library(what, "library.import", data, |s, r| {
+        let lib = r["id"].clone();
+        let Ok(got) = no_panic(s.execute("library.get", &json!({"library": lib}))) else { return };
+        let _ = no_panic(s.execute("select.all", &json!({})));
+        for (list, kind, key) in
+            [("graphics", "graphic", "id"), ("colors", "fillColor", "name"), ("charStyles", "charStyle", "name"), ("paraStyles", "paraStyle", "name")]
+        {
+            if let Some(item) = got[list].get(0) {
+                let _ = no_panic(s.execute("library.use", &json!({"library": lib, "kind": kind, "item": item[key]})));
+                let to = json!({"library": lib, "kind": kind, "item": item[key], "group": got["groups"][0]["name"]});
+                let _ = no_panic(s.execute("library.moveItem", &to));
+            }
+        }
+        if let Some(g) = got["groups"].get(0) {
+            let _ = no_panic(s.execute("library.deleteGroup", &json!({"library": lib, "group": g["name"]})));
+        }
+        let _ = no_panic(s.execute("library.export", &json!({"library": lib})));
+    })
+}
+
+/// A Libraries panel library of the rich document's first object (a graphic), a colour, its
+/// type's character and paragraph styles and a group, exported, made once.
+fn saved_library() -> String {
+    static TEXT: std::sync::OnceLock<String> = std::sync::OnceLock::new();
+    TEXT.get_or_init(|| {
+        let mut s = rich_session();
+        s.execute("library.create", &json!({"name": "Fuzz"})).unwrap();
+        let first = s.doc().unwrap().doc.layers[0].children().unwrap()[0].id.0;
+        let g = s.execute("library.add", &json!({"kind": "graphic", "ids": [first]})).unwrap()["id"].clone();
+        s.execute("library.add", &json!({"kind": "fillColor", "color": "#336699"})).unwrap();
+        s.execute("select.all", &json!({})).unwrap();
+        for kind in ["charStyle", "paraStyle"] {
+            s.execute("library.add", &json!({"kind": kind})).unwrap();
+        }
+        s.execute(
+            "library.createGroup",
+            &json!({"name": "Logos", "items": [{"kind": "graphic", "item": g}, {"kind": "fillColor", "item": "#336699"}]}),
+        )
+        .unwrap();
+        s.execute("library.export", &json!({})).unwrap()["data"].as_str().unwrap().to_string()
+    })
+    .clone()
+}
+
 fn flattener_presets(what: &str, data: &str) -> Result<(), TestCaseError> {
     survive_library(what, "flattener.presets.import", data, |s, r| {
         let _ = no_panic(s.execute("select.all", &json!({})));
@@ -865,11 +912,12 @@ proptest! {
     #![proptest_config(config())]
 
     #[test]
-    fn library_garbage_never_panics(s in ".{0,300}", head in prop::sample::select(vec!["", "GIMP Palette\n","{\"format\": \"vcswatches\", ", "{\"format\": \"vcstyles\", ", "{\"format\": \"vcflattener\", "])) {
+    fn library_garbage_never_panics(s in ".{0,300}", head in prop::sample::select(vec!["", "GIMP Palette\n","{\"format\": \"vcswatches\", ", "{\"format\": \"vcstyles\", ", "{\"format\": \"vcflattener\", ", "{\"name\": \"L\", "])) {
         let data = format!("{head}{s}");
         swatches("swatch library garbage", &data)?;
         styles("style library garbage", &data)?;
         flattener_presets("flattener preset garbage", &data)?;
+        libraries("library garbage", &data)?;
     }
 
     #[test]
@@ -890,6 +938,14 @@ proptest! {
         flattener_presets("mutated flattener presets", &mutate_text(&text, cut, &edits))?;
     }
 
+    #[test]
+    fn mutated_libraries_never_panic(keep in 0.0f64..1.2, edits in prop::collection::vec(arb_edit(), 0..10)) {
+        // Cut anywhere in the file (whole most of the time), the edits anywhere in it.
+        let text = saved_library();
+        let cut = (text.chars().count() as f64 * keep) as usize;
+        libraries("mutated library", &mutate_text(&text, cut, &edits))?;
+    }
+
     #[test]
     fn swatch_exchange_garbage_never_panics(blocks in prop::collection::vec(arb_ase_block(), 0..12), tail in prop::collection::vec(any::<u8>(), 0..16)) {
         let mut bytes = b"ASEF\0\x01\0\0".to_vec();

crates/pdf/src/import.rs

@@ -503,6 +503,46 @@ fn matching_face(
     best.map(|(_, f)| f)
 }
 
+/// The characters a glyph no mapping names is looked for among (#811): those single-byte fonts
+/// encode (ASCII, Latin-1, Latin Extended-A, general punctuation, the euro and trade mark signs,
+/// the fi and fl ligatures).
+const IDENTIFIABLE: [std::ops::RangeInclusive<u32>; 6] =
+    [0x21..=0x7E, 0xA1..=0x17F, 0x2010..=0x2044, 0x20AC..=0x20AC, 0x2122..=0x2122, 0xFB01..=0xFB02];
+
+/// The character whose glyph in installed `face` draws `embedded` (a glyph outline in thousandths
+/// of an em, y up): the first of [`IDENTIFIABLE`] with the same outline, point for point. A subset
+/// font embedded without a character map still carries the font's own outlines, so a glyph whose
+/// subset code names nothing is found this way. `None` when no glyph matches (another version of
+/// the font, or a glyph that is no character), and for empty glyphs, which every space draws.
+pub(crate) fn identify_glyph(face: &vectorcraft_text::FontFace, embedded: &BezPath) -> Option<char> {
+    if embedded.elements().is_empty() {
+        return None;
+    }
+    let k = 1000.0 / face.units_per_em();
+    // Installed outlines are y-down in font units.
+    let to_pdf = Affine::new([k, 0.0, 0.0, -k, 0.0, 0.0]);
+    let db = vectorcraft_text::FontDb::global();
+    IDENTIFIABLE.iter().cloned().flatten().filter_map(char::from_u32).find(|c| {
+        let gid = face.glyph_for(*c);
+        gid != 0 && same_shape(embedded, &(to_pdf * db.outline(face, gid).as_ref().clone()))
+    })
+}
+
+/// Do outlines `a` and `b` draw the same segments, every point within 2/1000 em (closing
+/// commands aside)?
+fn same_shape(a: &BezPath, b: &BezPath) -> bool {
+    let drawn = |p: &BezPath| p.elements().iter().filter(|e| !matches!(e, PathEl::ClosePath)).copied().collect::<Vec<_>>();
+    let (a, b) = (drawn(a), drawn(b));
+    let near = |p: kurbo::Point, q: kurbo::Point| (p - q).hypot() <= 2.0;
+    a.len() == b.len()
+        && a.iter().zip(&b).all(|(x, y)| match (x, y) {
+            (PathEl::MoveTo(p), PathEl::MoveTo(q)) | (PathEl::LineTo(p), PathEl::LineTo(q)) => near(*p, *q),
+            (PathEl::QuadTo(p1, p2), PathEl::QuadTo(q1, q2)) => near(*p1, *q1) && near(*p2, *q2),
+            (PathEl::CurveTo(p1, p2, p3), PathEl::CurveTo(q1, q2, q3)) => near(*p1, *q1) && near(*p2, *q2) && near(*p3, *q3),
+            _ => false,
+        })
+}
+
 /// The character of glyph `text` when its outline can be compared with an installed font's: a
 /// single character, and not CJK punctuation set vertically (its vertical form differs).
 fn comparable(text: &str, vertical: bool) -> Option<char> {
@@ -666,6 +706,9 @@ struct Builder<'p> {
     /// Font (cache key) → the installed face that draws its glyphs, decided from its first glyph
     /// that can be compared ([`matching_face`]); `None`: its glyphs differ, so it stays outlines.
     matched: HashMap<u128, Option<Arc<vectorcraft_text::FontFace>>>,
+    /// (Font, glyph) → the character its outline matches in the installed face, for glyphs no
+    /// mapping names ([`Builder::identified_char`]).
+    identified: HashMap<(u128, u32), Option<char>>,
     /// Per font: the installed version its type names, when it isn't the one its family and style
     /// resolve to (see `CharStyle::font_version`).
     versions: HashMap<u128, Option<String>>,
@@ -817,6 +860,7 @@ impl<'p> Builder<'p> {
             cid_text: HashMap::new(),
             font_chars: HashMap::new(),
             matched: HashMap::new(),
+            identified: HashMap::new(),
             versions: HashMap::new(),
             mask: None,
             masked: vec![],
@@ -1286,6 +1330,17 @@ impl<'p> Builder<'p> {
 
     /// The family and style of font `key` (drawing glyph `o`): the installed face of its PostScript
     /// name, else the available family its name reads as; whether it is available.
+    /// The character of glyph `glyph` of font `key` that no mapping names, found by its outline in
+    /// the installed face of the font's name ([`identify_glyph`]); cached per glyph.
+    fn identified_char(&mut self, key: u128, glyph: u32, o: &hayro_interpret::font::OutlineGlyph) -> Option<char> {
+        if let Some(c) = self.identified.get(&(key, glyph)) {
+            return *c;
+        }
+        let c = self.font_name(key, o).face.and_then(|f| identify_glyph(&f, &o.outline()));
+        self.identified.insert((key, glyph), c);
+        c
+    }
+
     fn font_name(&mut self, key: u128, o: &hayro_interpret::font::OutlineGlyph) -> FontInfo {
         if let Some(n) = self.font_names.get(&key) {
             return n.clone();
@@ -1345,7 +1400,9 @@ impl<'p> Builder<'p> {
                             .font_chars
                             .entry(key)
                             .or_insert_with(|| o.font_data().and_then(|d| font_chars(d.data.as_ref().as_ref())).map(Arc::new));
-                        (chars.as_ref().and_then(|m| m.get(&glyph)).map(|c| BfString::Char(*c)), false)
+                        let named = chars.as_ref().and_then(|m| m.get(&glyph)).copied();
+                        // Still unnamed: the installed font may draw the same outline (#811).
+                        (named.or_else(|| self.identified_char(key, glyph, o)).map(BfString::Char), false)
                     }
                 }
             }

crates/pdf/src/tests_realtext.rs

@@ -248,17 +248,33 @@ fn digits_unnamed(text: &str) -> Vec<u8> {
     out
 }
 
-/// #708: a glyph whose ToUnicode value is U+FFFD isn't type showing "�". This subset font has no
-/// character map of its own, so the digits keep their outlines, drawn as the file draws them, and
-/// a warning names the font.
+/// #708, #811: a glyph whose ToUnicode value is U+FFFD isn't type showing "�". This subset font
+/// has no character map of its own, but the font is installed: each digit is found by its outline
+/// there, so the whole text stays one type object, with no outlines left behind.
 #[test]
-fn glyphs_mapped_to_the_replacement_character_keep_their_outlines() {
+fn unnamed_glyphs_of_an_installed_font_are_found_by_their_outline() {
     let bytes = digits_unnamed("Tel 02-12345");
     let report = import_with_report(&bytes, &ImportOptions { text_as: TextAs::Text, ..Default::default() }).unwrap();
-    let all = texts(&report.document).concat();
-    assert!(!all.contains('\u{FFFD}') && all.contains("Tel"), "no replacement characters: {all:?}");
-    assert!(ink(&report.document).width() > 50.0, "the digits are outlines");
-    assert!(report.warnings.iter().any(|w| w.contains("U+FFFD")), "{:?}", report.warnings);
+    assert_eq!(texts(&report.document), ["Tel 02-12345"]);
+    let mut paths = 0;
+    report.document.walk(|n| paths += usize::from(matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. })));
+    assert_eq!(paths, 0, "no outlines left: {:?}", report.warnings);
+    assert!(!report.warnings.iter().any(|w| w.contains("U+FFFD")), "{:?}", report.warnings);
+}
+
+/// #811: an outline is named only by a glyph that draws it exactly; one moved off its place, or an
+/// empty glyph (which every space draws), stays unnamed and keeps its outlines.
+#[test]
+fn glyphs_are_named_only_by_an_exact_outline() {
+    let db = FontDb::global();
+    let face = db.face("Source Sans 3", "Regular").unwrap();
+    let k = 1000.0 / face.units_per_em();
+    let pdf_space = |c: char| Affine::new([k, 0.0, 0.0, -k, 0.0, 0.0]) * db.outline(&face, face.glyph_for(c)).as_ref().clone();
+    for c in ['R', 'a', '7', '&', 'é'] {
+        assert_eq!(crate::import::identify_glyph(&face, &pdf_space(c)), Some(c));
+    }
+    assert_eq!(crate::import::identify_glyph(&face, &(Affine::translate((100.0, 0.0)) * pdf_space('R'))), None);
+    assert_eq!(crate::import::identify_glyph(&face, &BezPath::new()), None);
 }
 
 /// #708: where the embedded font program has a character map, a glyph's character comes from it.

crates/render/src/fx.rs

@@ -601,7 +601,9 @@ impl Renderer {
             Ink::Display if f.doc.color_mode == vectorcraft_doc::ColorMode::Cmyk => effects::pixel::Channels::Cmyk,
             Ink::Display => effects::pixel::Channels::Rgb,
         };
-        let space = effects::PixelSpace { to_doc, px, center: content.reach.center(), channels };
+        // De-Interlace's field lines: the rows of the document's raster grid (1 to 2400 ppi).
+        let ppi = Some(f.doc.raster_effects_ppi).filter(|v| v.is_finite()).unwrap_or(72.0).clamp(1.0, 2400.0);
+        let space = effects::PixelSpace { to_doc, px, center: content.reach.center(), channels, line: 72.0 / ppi };
         let (wz, hz) = (wu as usize, hu as usize);
         for fx in chain {
             match fx {

crates/tools/src/corners.rs

@@ -1,8 +1,8 @@
-//! Live Corners: the widgets inside the corners of a selected path. The Selection tool shows them
-//! on a live rectangle or polygon, Direct Selection on any path (a star, a pen path) at each corner
-//! anchor: one without handles between two straight sides. Dragging one rounds (or sharpens) the
-//! corners whose widgets show together: every corner when the whole path is selected, those with a
-//! selected anchor when Direct Selection picked some. Alt-clicking a widget cycles their corner
+//! Live Corners: the widgets inside the corners of the selected paths. The Selection tool shows
+//! them on live rectangles and polygons, Direct Selection on any path (a star, a pen path) at each
+//! corner anchor: one without handles between two straight sides. Dragging one rounds (or
+//! sharpens) the corners whose widgets show together, on every selected path (#938): every corner
+//! of a path selected whole, those with a selected anchor when Direct Selection picked some. Alt-clicking a widget cycles their corner
 //! kind (round, inverted round, chamfer); double-clicking one opens the Corners dialog. The
 //! Selection and Direct Selection tools share this, and the canvas draws the widgets from the same
 //! geometry.
@@ -38,10 +38,10 @@ struct Widget {
     at: Point,
 }
 
-/// The corner widgets of a selection that is exactly one editable path with corners.
+/// The corner widgets of one selected path.
 #[derive(Clone, Debug, PartialEq)]
-pub struct CornerWidgets {
-    pub id: NodeId,
+struct PathWidgets {
+    id: NodeId,
     /// Maps the corners' space into the document (a live rectangle's own; else none).
     xf: Affine,
     /// The widgets that show (and which a drag edits), in anchor order.
@@ -50,11 +50,10 @@ pub struct CornerWidgets {
     all: bool,
 }
 
-impl CornerWidgets {
-    /// The widgets at `zoom` (screen px per document point), if the selection has them: on any
-    /// path with Direct Selection (`any_path`), on live rectangles and polygons with Selection.
-    pub fn of(doc: &Document, selection: &Selection, zoom: f64, any_path: bool) -> Option<Self> {
-        let [id] = selection.objects[..] else { return None };
+impl PathWidgets {
+    /// The widgets of path `id` at `zoom` (screen px per document point), if it has any: any path
+    /// with Direct Selection (`any_path`), live rectangles and polygons with Selection.
+    fn of(doc: &Document, selection: &Selection, id: NodeId, zoom: f64, any_path: bool) -> Option<Self> {
         if !doc.is_editable(id) {
             return None;
         }
@@ -86,13 +85,36 @@ impl CornerWidgets {
         (!widgets.is_empty()).then_some(Self { id, xf: lc.xf, widgets, all })
     }
 
+    /// The corners whose widgets show: anchor indices of the path's uncut outline.
+    fn corners(&self) -> Vec<usize> {
+        self.widgets.iter().map(|w| w.corner.index).collect()
+    }
+}
+
+/// The corner widgets of the selected paths that have some.
+#[derive(Clone, Debug, PartialEq)]
+pub struct CornerWidgets {
+    paths: Vec<PathWidgets>,
+}
+
+impl CornerWidgets {
+    /// The widgets at `zoom` (screen px per document point), if the selection has them: on any
+    /// path with Direct Selection (`any_path`), on live rectangles and polygons with Selection.
+    pub fn of(doc: &Document, selection: &Selection, zoom: f64, any_path: bool) -> Option<Self> {
+        let paths: Vec<_> = selection.objects.iter().filter_map(|id| PathWidgets::of(doc, selection, *id, zoom, any_path)).collect();
+        (!paths.is_empty()).then_some(Self { paths })
+    }
+
     /// Selection & Anchor Display → Hide Corner Widget for angles greater than: the widgets of
     /// corners wider than `max` degrees (in the document) hide; none if all do.
     pub fn within_angle(mut self, max: f64) -> Option<Self> {
-        let n = self.widgets.len();
-        self.widgets.retain(|w| w.angle <= max + 1e-9);
-        self.all &= self.widgets.len() == n;
-        (!self.widgets.is_empty()).then_some(self)
+        for p in &mut self.paths {
+            let n = p.widgets.len();
+            p.widgets.retain(|w| w.angle <= max + 1e-9);
+            p.all &= p.widgets.len() == n;
+        }
+        self.paths.retain(|p| !p.widgets.is_empty());
+        (!self.paths.is_empty()).then_some(self)
     }
 
     /// The widgets on show: [`Self::of`] with View → Show Corner Widget `on`, less those wider
@@ -111,30 +133,61 @@ impl CornerWidgets {
 
     /// The centres of the widgets that show.
     pub fn visible(&self) -> impl Iterator<Item = Point> + '_ {
-        self.widgets.iter().map(|w| w.at)
+        self.visible_on().map(|(_, at)| at)
     }
 
-    /// The corners whose widgets show: anchor indices of the path's uncut outline.
+    /// The centres of the widgets that show, each with the object it belongs to.
+    pub fn visible_on(&self) -> impl Iterator<Item = (NodeId, Point)> + '_ {
+        self.paths.iter().flat_map(|p| p.widgets.iter().map(move |w| (p.id, w.at)))
+    }
+
+    /// The corners whose widgets show, path after path: anchor indices of each path's uncut
+    /// outline.
     pub fn corners(&self) -> Vec<usize> {
-        self.widgets.iter().map(|w| w.corner.index).collect()
+        self.paths.iter().flat_map(PathWidgets::corners).collect()
     }
 
-    /// The widget nearest to `p` within `tol` (document units).
-    fn hit(&self, p: Point, tol: f64) -> Option<usize> {
-        let d = |k: &usize| self.widgets.get(*k).map_or(f64::INFINITY, |w| w.at.distance(p));
-        (0..self.widgets.len()).filter(|k| d(k) <= tol).min_by(|a, b| d(a).total_cmp(&d(b)))
+    /// The widget nearest to `p` within `tol` (document units): its path's and its own index.
+    fn hit(&self, p: Point, tol: f64) -> Option<(usize, usize)> {
+        let d = |&(i, k): &(usize, usize)| self.widget(i, k).map_or(f64::INFINITY, |w| w.at.distance(p));
+        self.paths
+            .iter()
+            .enumerate()
+            .flat_map(|(i, path)| (0..path.widgets.len()).map(move |k| (i, k)))
+            .filter(|ik| d(ik) <= tol)
+            .min_by(|a, b| d(a).total_cmp(&d(b)))
     }
 
-    /// `object.setLiveShape` params setting `key` on the shown corners (every corner unless some
-    /// are hidden, which `corners` then leaves out).
+    fn widget(&self, path: usize, k: usize) -> Option<&Widget> {
+        self.paths.get(path).and_then(|p| p.widgets.get(k))
+    }
+
+    /// `object.setLiveShape` params setting `key` on the shown corners (every corner of a path
+    /// unless some are hidden, which `corners` then leaves out): one path by its `id`, several as
+    /// `items`.
     fn command(&self, key: &str, value: Value) -> Value {
-        let mut p = Map::new();
-        p.insert("id".into(), json!(self.id.0));
-        p.insert(key.into(), value);
-        if !self.all {
-            p.insert("corners".into(), json!(self.corners()));
+        let corners = |p: &PathWidgets| (!p.all).then(|| p.corners());
+        let mut out = Map::new();
+        match self.paths.as_slice() {
+            [p] => {
+                out.insert("id".into(), json!(p.id.0));
+                if let Some(c) = corners(p) {
+                    out.insert("corners".into(), json!(c));
+                }
+            }
+            paths => {
+                let items: Vec<Value> = paths
+                    .iter()
+                    .map(|p| match corners(p) {
+                        Some(c) => json!({ "id": p.id.0, "corners": c }),
+                        None => json!({ "id": p.id.0 }),
+                    })
+                    .collect();
+                out.insert("items".into(), Value::Array(items));
+            }
         }
-        Value::Object(p)
+        out.insert(key.into(), value);
+        Value::Object(out)
     }
 }
 
@@ -151,11 +204,22 @@ pub fn over_widget(cx: &ToolContext, p: Point, any_path: bool) -> bool {
     CornerWidgets::for_tool(cx, any_path).and_then(|w| w.hit(p, cx.tol(5.0))).is_some()
 }
 
-/// A double-click on a corner widget opens the Corners dialog for the shown corners.
+/// A double-click on a corner widget opens the Corners dialog for the shown corners of its path.
 pub fn double_click(cx: &ToolContext, p: Point, any_path: bool) -> Option<Action> {
     let w = CornerWidgets::for_tool(cx, any_path)?;
-    w.hit(p, cx.tol(5.0))?;
-    Some(Action::Dialog(DIALOG.into(), json!({ "id": w.id.0, "corners": w.corners() })))
+    let (i, _) = w.hit(p, cx.tol(5.0))?;
+    let path = w.paths.get(i)?;
+    Some(Action::Dialog(DIALOG.into(), json!({ "id": path.id.0, "corners": path.corners() })))
+}
+
+/// A path's uncut outline with its corners' radii and kinds, and the corners' space (to outline
+/// the corners at their largest).
+#[derive(Clone, Debug)]
+struct Outline {
+    base: PathData,
+    radii: Vec<f64>,
+    kinds: Vec<CornerKind>,
+    xf: Affine,
 }
 
 /// Dragging a corner widget: the radius follows the pointer along the corner's bisector. An
@@ -163,13 +227,10 @@ pub fn double_click(cx: &ToolContext, p: Point, any_path: bool) -> Option<Action
 #[derive(Clone, Debug)]
 pub struct CornerDrag {
     widgets: CornerWidgets,
-    /// The dragged widget (index into the shown ones).
-    widget: usize,
-    /// The path's uncut outline with its corners' radii and kinds (to outline the corners at
-    /// their largest).
-    base: PathData,
-    radii: Vec<f64>,
-    kinds: Vec<CornerKind>,
+    /// The dragged widget: its path's and its own index among the shown ones.
+    widget: (usize, usize),
+    /// Each shown path's outline, in the order of [`CornerWidgets`]' paths.
+    outlines: Vec<Outline>,
     start: Point,
     began: bool,
     alt: bool,
@@ -185,20 +246,29 @@ impl CornerDrag {
     pub fn hit(cx: &ToolContext, ev: &PointerEvent, any_path: bool) -> Option<Self> {
         let (widgets, p) = (CornerWidgets::for_tool(cx, any_path)?, ev.pos);
         let widget = widgets.hit(p, cx.tol(5.0))?;
-        let radius = widgets.widgets.get(widget)?.radius;
-        let lc = cx.doc.node(widgets.id).and_then(LiveCorners::of)?;
-        let n = lc.base.anchor_count();
-        let (radii, kinds) = ((0..n).map(|k| lc.radius(k)).collect(), (0..n).map(|k| lc.kind(k)).collect());
-        let base = lc.base.into_owned();
-        Some(Self { widgets, widget, base, radii, kinds, start: p, began: false, alt: ev.mods.alt, radius, at_limit: false, at: p })
+        let radius = widgets.widget(widget.0, widget.1)?.radius;
+        let outlines = widgets
+            .paths
+            .iter()
+            .map(|w| {
+                let lc = cx.doc.node(w.id).and_then(LiveCorners::of)?;
+                let n = lc.base.anchor_count();
+                let (radii, kinds) = ((0..n).map(|k| lc.radius(k)).collect(), (0..n).map(|k| lc.kind(k)).collect());
+                Some(Outline { base: lc.base.into_owned(), radii, kinds, xf: w.xf })
+            })
+            .collect::<Option<Vec<_>>>()?;
+        Some(Self { widgets, widget, outlines, start: p, began: false, alt: ev.mods.alt, radius, at_limit: false, at: p })
     }
 
     /// The start radius (as drawn: no larger than fits) plus the pointer's travel along the
     /// corner's bisector (in the corners' own units), from square to fully round; and whether the
     /// travel reached fully round.
     fn radius_at(&self, p: Point) -> (f64, bool) {
-        let Some(w) = self.widgets.widgets.get(self.widget) else { return (self.radius, self.at_limit) };
-        let inv = self.widgets.xf.inverse();
+        let (path, k) = self.widget;
+        let (Some(w), Some(xf)) = (self.widgets.widget(path, k), self.widgets.paths.get(path).map(|p| p.xf)) else {
+            return (self.radius, self.at_limit);
+        };
+        let inv = xf.inverse();
         let max = w.corner.max_radius();
         let r = w.corner.fitted(w.radius) + w.corner.radius_change(inv * p - inv * self.start);
         (r.min(max).max(0.0), max > 0.0 && r >= max)
@@ -206,25 +276,27 @@ impl CornerDrag {
 
     /// The cuts of the edited corners that are at their largest radius, in document coordinates.
     fn corners_at_limit(&self) -> BezPath {
-        let shown = &self.widgets.widgets;
-        let mut radii = self.radii.clone();
-        for w in shown {
-            if let Some(r) = radii.get_mut(w.corner.index) {
-                *r = self.radius;
-            }
-        }
-        let full = |k: &usize| shown.iter().any(|w| w.corner.index == *k && self.radius >= w.corner.max_radius() - 1e-9);
-        let (path, sources) = cut_corners(&self.base, &radii, &self.kinds);
         let mut out = BezPath::new();
-        for (sp, from) in path.transformed(self.widgets.xf).subpaths.iter().zip(&sources) {
-            // A corner's cut is the segment between its two anchors (the last one, for a closed
-            // subpath's first corner).
-            for i in 0..sp.segment_count() {
-                let (a, b) = (from.get(i), from.get(i + 1).or(from.first()));
-                if a == b && a.is_some_and(full) {
-                    let c = sp.segment(i);
-                    out.move_to(c.p0);
-                    out.curve_to(c.p1, c.p2, c.p3);
+        for (shown, o) in self.widgets.paths.iter().zip(&self.outlines) {
+            let shown = &shown.widgets;
+            let mut radii = o.radii.clone();
+            for w in shown {
+                if let Some(r) = radii.get_mut(w.corner.index) {
+                    *r = self.radius;
+                }
+            }
+            let full = |k: &usize| shown.iter().any(|w| w.corner.index == *k && self.radius >= w.corner.max_radius() - 1e-9);
+            let (path, sources) = cut_corners(&o.base, &radii, &o.kinds);
+            for (sp, from) in path.transformed(o.xf).subpaths.iter().zip(&sources) {
+                // A corner's cut is the segment between its two anchors (the last one, for a
+                // closed subpath's first corner).
+                for i in 0..sp.segment_count() {
+                    let (a, b) = (from.get(i), from.get(i + 1).or(from.first()));
+                    if a == b && a.is_some_and(full) {
+                        let c = sp.segment(i);
+                        out.move_to(c.p0);
+                        out.curve_to(c.p1, c.p2, c.p3);
+                    }
                 }
             }
         }
@@ -249,7 +321,7 @@ impl CornerDrag {
     pub fn finish(self) -> Vec<Action> {
         if self.began {
             vec![Action::Commit]
-        } else if let Some(w) = self.widgets.widgets.get(self.widget).filter(|_| self.alt) {
+        } else if let Some(w) = self.widgets.widget(self.widget.0, self.widget.1).filter(|_| self.alt) {
             vec![Action::Exec("object.setLiveShape".into(), self.widgets.command("kind", json!(w.kind.next())))]
         } else {
             vec![]
@@ -359,6 +431,37 @@ mod tests {
         }
     }
 
+    /// #938: with two rectangles selected, both show their widgets, and a drag on either rounds
+    /// the corners of both in one step; with Direct Selection, each its shown corners.
+    #[test]
+    fn widgets_of_several_selected_paths_drag_together() {
+        let (mut d, a) = live_rect(0.0, Affine::translate((100.0, 100.0)));
+        let live = LiveShape::Rectangle { w: 100.0, h: 100.0, radii: [0.0; 4], kinds: Default::default(), xf: Affine::translate((300.0, 100.0)) };
+        let b = d.alloc_id();
+        let mut n = Node::path(b, live.to_path(), Appearance::default_art());
+        if let NodeKind::Path { live: slot, .. } = &mut n.kind {
+            *slot = Some(live);
+        }
+        let l = d.layers[0].id;
+        d.insert(Some(l), 1, n).unwrap();
+        let mut s = selected(a);
+        s.add(b);
+        assert_eq!(pts(&CornerWidgets::of(&d, &s, 1.0, false).unwrap()).len(), 8);
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let mut t = crate::create("selection");
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 390.0, 191.0));
+        let preview = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 375.0, 176.0));
+        assert!((radius(&preview[1]) - 15.0).abs() < 1e-9);
+        let Action::Preview(_, v) = &preview[1] else { panic!() };
+        assert_eq!(v["items"], json!([{"id": a.0}, {"id": b.0}]));
+        // Direct Selection with one anchor of the first: its corner, and the whole second.
+        s.anchors.insert(a, [(0, 2)].into());
+        let w = CornerWidgets::of(&d, &s, 1.0, true).unwrap();
+        assert_eq!(w.corners(), [2, 0, 1, 2, 3]);
+        assert_eq!(w.command("radius", json!(5.0)), json!({"items": [{"id": a.0, "corners": [2]}, {"id": b.0}], "radius": 5.0}));
+    }
+
     /// #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.

crates/tools/src/direct.rs

@@ -574,6 +574,14 @@ impl Tool for DirectSelectionTool {
                         }
                     }
                 });
+                // Objects without anchors to pick (type, images, symbols…) are selected whole when
+                // the marquee touches them, as with the Selection tool (#927).
+                for id in vectorcraft_doc::hit::marquee(cx.doc, r, cx.isolation, true) {
+                    let whole = cx.doc.node(id).is_some_and(|n| !matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. }));
+                    if whole && !sel.iter().any(|(s, _)| *s == id) {
+                        sel.push((id, vec![]));
+                    }
+                }
                 sel.retain(|(id, _)| cx.doc.is_editable(*id));
                 let items: Vec<Value> = sel.iter().map(|(id, v)| json!({"id": id.0, "anchors": anchors_json(v)})).collect();
                 vec![Action::Exec("select.anchorsMany".into(), json!({"items": items, "mode": if toggle { "toggle" } else { "set" }}))]
@@ -838,6 +846,28 @@ mod tests {
         let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 250.0, 150.0));
         assert_eq!(a, vec![Action::Exec("select.anchorsMany".into(), json!({"items": [{"id": id.0, "anchors": [[0, 1]]}], "mode": "set"}))]);
     }
+    /// #927: a marquee across type selects the type object whole, beside the anchors it holds.
+    #[test]
+    fn marquee_selects_type_it_touches() {
+        // The rectangle at (100, 100)–(200, 200) and area type at (300, 300).
+        let (d, text) = doc_with_area_type();
+        let rect = d.layers[0].children().and_then(|c| c.first()).map(|n| n.id).unwrap();
+        let s = Selection::default();
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let mut t = DirectSelectionTool::new(false);
+        // From empty canvas across the type to inside the rectangle (its bottom-right corner).
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 450.0, 450.0));
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0));
+        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 150.0, 150.0));
+        let items = json!([{"id": rect.0, "anchors": [[0, 2]]}, {"id": text.0, "anchors": []}]);
+        assert_eq!(a, vec![Action::Exec("select.anchorsMany".into(), json!({"items": items, "mode": "set"}))]);
+        // Away from the type, only anchors.
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 150.0, 50.0));
+        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 250.0, 150.0));
+        assert_eq!(a, vec![Action::Exec("select.anchorsMany".into(), json!({"items": [{"id": rect.0, "anchors": [[0, 1]]}], "mode": "set"}))]);
+    }
+
     /// Shift-drag a marquee: the anchors inside toggle (#483), with Group Selection too.
     #[test]
     fn shift_marquee_toggles_anchors() {

crates/ui-egui/src/canvas.rs

@@ -1701,8 +1701,8 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
             app.session.prefs.hide_corner_widget_above,
         )
     {
-        let color = c32(st.doc.layer_color(w.id));
-        for sp in w.visible().map(|q| xf.to_screen(q)) {
+        for (id, q) in w.visible_on() {
+            let (sp, color) = (xf.to_screen(q), c32(st.doc.layer_color(id)));
             p.circle_filled(sp, 3.0, Color32::WHITE);
             p.circle_stroke(sp, 3.0, Stroke::new(1.0, color));
             p.circle_filled(sp, 1.0, color);

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

@@ -0,0 +1,413 @@
+//! Scatter, Art and Pattern Brush Options: the [`super::brush_options`] of the brushes made of
+//! art. Each has the brush's own values, Colorization (Method, and Key Color for Hue Shift, picked
+//! from the art's colours) and a live preview of a stroke.
+//!
+//! Fields (besides `__brush`, `__type` and `name`): `__def` (the brush definition, for the preview),
+//! `__colors` (the art's colours, most used first), `colorization` (`none` | `tints` |
+//! `tintsAndShades` | `hueShift`), `keyColor` (a colour).
+//! Scatter: per value (`size`, `spacing`, `scatter` %, `rotation` °) `…Min`, `…Max` and `…Mode`
+//! (`fixed` | `random` | `pressure`), `rotationRelativeTo` (`page` | `path`).
+//! Art: `width` (%), `scaleMode` (`proportional` | `stretch` | `betweenGuides`), `guideStart` and
+//! `guideEnd` (% of the art's length), `direction` (`leftToRight` …), `flipAlong`, `flipAcross`.
+//! Pattern: `scale`, `spacing` (%), `fit` (`stretch` | `addSpace` | `approximate`), `flipAlong`,
+//! `flipAcross`, `__tiles` (slot → preview key, for the tiles the brush has).
+
+use std::hash::{Hash, Hasher};
+
+use egui::{Color32, Sense, Stroke, pos2, vec2};
+use serde_json::{Map, Value, json};
+use vectorcraft_brush::{ArtBrush, ArtScale, Brush, BrushKind, Colorization, Direction, PatternBrush, PatternFit, Scatter, Variation};
+use vectorcraft_color::{Color, Paint};
+use vectorcraft_doc::{Document, Node};
+
+use super::brush_options::{clamped, mode_key, stroke_preview};
+use crate::state::Dialog;
+use crate::theme::Tokens;
+use crate::widgets;
+
+/// Scatter values: (field, suffix), in [`Scatter::RANGES`] order.
+const SCATTER: [(&str, &str); 4] = [("size", "%"), ("spacing", "%"), ("scatter", "%"), ("rotation", "°")];
+
+/// Art brush directions, in the order of their arrows (→ ← ↓ ↑).
+const DIRECTIONS: [Direction; 4] = [Direction::LeftToRight, Direction::RightToLeft, Direction::TopToBottom, Direction::BottomToTop];
+
+/// Pattern brush tiles: (field of the definition, slot), in the dialog's order.
+const TILES: [(&str, &str); 5] =
+    [("outer_corner", "outerCorner"), ("side", "side"), ("inner_corner", "innerCorner"), ("start", "start"), ("end", "end")];
+
+/// The most key colours offered.
+const MAX_COLORS: usize = 16;
+
+/// Width of the label column.
+const LABEL_W: f32 = 132.0;
+
+/// Width of the stroke preview.
+const PREVIEW_W: f32 = 420.0;
+
+pub(super) fn heading(ty: &str) -> &'static str {
+    match ty {
+        "scatter" => tl!("Scatter Brush Options"),
+        "art" => tl!("Art Brush Options"),
+        _ => tl!("Pattern Brush Options"),
+    }
+}
+
+fn min_key(key: &str) -> String {
+    format!("{key}Min")
+}
+
+fn max_key(key: &str) -> String {
+    format!("{key}Max")
+}
+
+/// A definition id of a serde enum (`leftToRight`, `addSpace` …).
+fn id_of<T: serde::Serialize>(v: &T) -> String {
+    serde_json::to_value(v).ok().and_then(|v| v.as_str().map(str::to_string)).unwrap_or_default()
+}
+
+/// The value of the serde enum `T` that field `key` names, else `T`'s default.
+fn parse_field<T: serde::de::DeserializeOwned + Default>(d: &Dialog, key: &str) -> T {
+    serde_json::from_value(json!(d.str(key))).unwrap_or_default()
+}
+
+// ---------- fields ----------
+
+/// The fields of brush `b` (a scatter, art or pattern brush) whose definition is `def`.
+pub(super) fn fields(b: &Brush, def: Value, f: &mut Map<String, Value>) {
+    match &b.kind {
+        BrushKind::Scatter(s) => {
+            for ((key, _), ((lo, hi), mode)) in SCATTER.iter().zip(s.values().into_iter().zip(s.modes())) {
+                f.insert(min_key(key), json!(lo));
+                f.insert(max_key(key), json!(hi));
+                f.insert(mode_key(key), json!(mode.id()));
+            }
+            f.insert("rotationRelativeTo".into(), json!(if s.rotation_relative_to_path { "path" } else { "page" }));
+        }
+        BrushKind::Art(a) => {
+            let (mode, start, end) = match a.scale {
+                ArtScale::Proportional => ("proportional", 0.0, 1.0),
+                ArtScale::Stretch => ("stretch", 0.0, 1.0),
+                ArtScale::BetweenGuides { start, end } => ("betweenGuides", start, end),
+            };
+            f.insert("width".into(), json!(a.width));
+            f.insert("scaleMode".into(), json!(mode));
+            f.insert("guideStart".into(), json!(start * 100.0));
+            f.insert("guideEnd".into(), json!(end * 100.0));
+            f.insert("direction".into(), json!(id_of(&a.direction)));
+            f.insert("flipAlong".into(), json!(a.flip_along));
+            f.insert("flipAcross".into(), json!(a.flip_across));
+        }
+        BrushKind::Pattern(p) => {
+            f.insert("scale".into(), json!(p.scale));
+            f.insert("spacing".into(), json!(p.spacing));
+            f.insert("fit".into(), json!(id_of(&p.fit)));
+            f.insert("flipAlong".into(), json!(p.flip_along));
+            f.insert("flipAcross".into(), json!(p.flip_across));
+            // A preview key per tile the brush has: its art's hash, so a changed tile redraws.
+            let tiles: Map<String, Value> = TILES
+                .iter()
+                .filter_map(|(field, slot)| {
+                    let art = def.get(*field).filter(|v| !v.is_null())?;
+                    let mut h = std::collections::hash_map::DefaultHasher::new();
+                    art.to_string().hash(&mut h);
+                    Some(((*slot).to_string(), json!(format!("brush-tile:{:x}", h.finish()))))
+                })
+                .collect();
+            f.insert("__tiles".into(), Value::Object(tiles));
+        }
+        BrushKind::Calligraphic(_) | BrushKind::Bristle(_) => {}
+    }
+    let colors = vectorcraft_brush::art_colors(b.art());
+    let colorization = b.kind.colorization();
+    let key = match colorization {
+        Colorization::HueShift { key } => key,
+        _ => colors.first().copied().unwrap_or(Color::BLACK),
+    };
+    f.insert("colorization".into(), json!(colorization.id()));
+    f.insert("keyColor".into(), serde_json::to_value(key).unwrap_or_default());
+    f.insert("__colors".into(), serde_json::to_value(colors.into_iter().take(MAX_COLORS).collect::<Vec<_>>()).unwrap_or_default());
+    f.insert("__def".into(), def);
+}
+
+fn key_color(d: &Dialog) -> Color {
+    d.fields.get("keyColor").and_then(|v| serde_json::from_value(v.clone()).ok()).unwrap_or(Color::BLACK)
+}
+
+fn colorization(d: &Dialog) -> Colorization {
+    Colorization::parse(&d.str("colorization"), key_color(d)).unwrap_or_default()
+}
+
+/// How scatter value `key` varies.
+fn scatter_mode(d: &Dialog, key: &str) -> Variation {
+    Variation::parse(&d.str(&mode_key(key))).unwrap_or_default()
+}
+
+/// `brush.options` params from the fields.
+pub(super) fn params(d: &Dialog) -> Value {
+    let mut p = match d.str("__type").as_str() {
+        "scatter" => {
+            let mut p = json!({ "rotation_relative_to_path": d.str("rotationRelativeTo") == "path" });
+            for ((key, _), range) in SCATTER.iter().zip(Scatter::RANGES) {
+                p[*key] = json!([clamped(d, &min_key(key), range), clamped(d, &max_key(key), range)]);
+            }
+            p["modes"] = json!(SCATTER.map(|(key, _)| scatter_mode(d, key).id()));
+            p
+        }
+        "art" => {
+            let scale = match d.str("scaleMode").as_str() {
+                "proportional" => ArtScale::Proportional,
+                "betweenGuides" => ArtScale::BetweenGuides {
+                    start: clamped(d, "guideStart", (0.0, 100.0)) / 100.0,
+                    end: clamped(d, "guideEnd", (0.0, 100.0)) / 100.0,
+                },
+                _ => ArtScale::Stretch,
+            };
+            json!({
+                "width": clamped(d, "width", ArtBrush::WIDTH_RANGE),
+                "scale": serde_json::to_value(scale).unwrap_or_default(),
+                "direction": id_of(&parse_field::<Direction>(d, "direction")),
+                "flip_along": d.bool("flipAlong"),
+                "flip_across": d.bool("flipAcross"),
+            })
+        }
+        _ => json!({
+            "scale": clamped(d, "scale", PatternBrush::SCALE_RANGE),
+            "spacing": clamped(d, "spacing", PatternBrush::SPACING_RANGE),
+            "fit": id_of(&parse_field::<PatternFit>(d, "fit")),
+            "flip_along": d.bool("flipAlong"),
+            "flip_across": d.bool("flipAcross"),
+        }),
+    };
+    p["colorization"] = serde_json::to_value(colorization(d)).unwrap_or_default();
+    p
+}
+
+// ---------- body ----------
+
+pub(super) fn body(ui: &mut egui::Ui, d: &mut Dialog) {
+    match d.str("__type").as_str() {
+        "scatter" => scatter_body(ui, d),
+        "art" => art_body(ui, d),
+        _ => pattern_body(ui, d),
+    }
+    ui.add_space(6.0);
+    colorization_body(ui, d);
+    ui.add_space(10.0);
+    // The brush as OK would make it, on a sample stroke.
+    let mut def = d.fields.get("__def").cloned().unwrap_or_default();
+    if let (Some(o), Value::Object(p)) = (def.as_object_mut(), params(d)) {
+        o.extend(p);
+    }
+    let ty = d.str("__type");
+    stroke_preview(ui, &ty, def, vec2(PREVIEW_W, 64.0));
+}
+
+/// A whole-number field (`suffix`: % or °) bound to `d.fields[key]`, kept within `range`.
+fn number(ui: &mut egui::Ui, d: &mut Dialog, key: &str, range: (f64, f64), suffix: &str, enabled: bool) {
+    ui.add_enabled_ui(enabled, |ui| {
+        if let Some(v) = widgets::range_field(ui, ("brush-art-value", key), clamped(d, key, range), range.0..=range.1, suffix, 0, 72.0) {
+            d.fields.insert(key.into(), json!(v));
+        }
+    });
+}
+
+/// A row of radio buttons bound to the string field `key`: (value, label).
+fn radios(ui: &mut egui::Ui, d: &mut Dialog, key: &str, options: &[(&str, &str)]) {
+    let cur = d.str(key);
+    for (value, label) in options {
+        if widgets::radio(ui, label, cur == *value, true) {
+            d.fields.insert(key.into(), json!(value));
+        }
+    }
+}
+
+fn flips(ui: &mut egui::Ui, d: &mut Dialog) {
+    widgets::label_row(ui, tl!("Flip:"), LABEL_W, |ui| {
+        super::form::check(ui, d, "flipAlong", tl!("Flip Along"));
+        ui.add_space(12.0);
+        super::form::check(ui, d, "flipAcross", tl!("Flip Across"));
+    });
+}
+
+fn scatter_body(ui: &mut egui::Ui, d: &mut Dialog) {
+    let labels = [tl!("Size:"), tl!("Spacing:"), tl!("Scatter:"), tl!("Rotation:")];
+    let modes = Variation::ALL.map(Variation::label);
+    egui::Grid::new("brush-options-scatter").num_columns(4).spacing([8.0, 8.0]).show(ui, |ui| {
+        for (((key, suffix), range), text) in SCATTER.into_iter().zip(Scatter::RANGES).zip(labels) {
+            super::swatch_options::label(ui, text);
+            let mode = scatter_mode(d, key);
+            for (field, enabled) in [(min_key(key), true), (max_key(key), mode != Variation::Fixed)] {
+                ui.add_enabled_ui(enabled, |ui| {
+                    if let Some(v) =
+                        widgets::range_field(ui, ("brush-scatter", field.as_str()), clamped(d, &field, range), range.0..=range.1, suffix, 0, 72.0)
+                    {
+                        d.fields.insert(field.clone(), json!(v));
+                    }
+                });
+            }
+            if let Some(m) = widgets::dropdown(ui, ("brush-scatter-mode", key), mode.label(), &modes, 104.0).and_then(|i| Variation::ALL.get(i)) {
+                d.fields.insert(mode_key(key), json!(m.id()));
+            }
+            ui.end_row();
+        }
+    });
+    ui.add_space(4.0);
+    let relative = [("page", tl!("Page")), ("path", tl!("Path"))];
+    super::form::choice(ui, d, "rotationRelativeTo", tl!("Rotation relative to:"), (LABEL_W, 104.0), &relative);
+}
+
+fn art_body(ui: &mut egui::Ui, d: &mut Dialog) {
+    widgets::label_row(ui, tl!("Width:"), LABEL_W, |ui| number(ui, d, "width", ArtBrush::WIDTH_RANGE, "%", true));
+    ui.add_space(4.0);
+    widgets::section_header(ui, tl!("Brush Scale Options"));
+    let scales = [
+        ("proportional", tl!("Scale Proportionately")),
+        ("stretch", tl!("Stretch to Fit Stroke Length")),
+        ("betweenGuides", tl!("Stretch Between Guides")),
+    ];
+    radios(ui, d, "scaleMode", &scales);
+    let guides = d.str("scaleMode") == "betweenGuides";
+    ui.horizontal(|ui| {
+        ui.add_space(18.0);
+        widgets::label_row(ui, tl!("Start:"), 40.0, |ui| number(ui, d, "guideStart", (0.0, 100.0), "%", guides));
+        ui.add_space(8.0);
+        widgets::label_row(ui, tl!("End:"), 34.0, |ui| number(ui, d, "guideEnd", (0.0, 100.0), "%", guides));
+    });
+    ui.add_space(6.0);
+    widgets::label_row(ui, tl!("Direction:"), LABEL_W, |ui| {
+        let tips = [tl!("Left to Right"), tl!("Right to Left"), tl!("Top to Bottom"), tl!("Bottom to Top")];
+        let cur = parse_field::<Direction>(d, "direction");
+        for (dir, tip) in DIRECTIONS.into_iter().zip(tips) {
+            if arrow_button(ui, dir, dir == cur, tip) {
+                d.fields.insert("direction".into(), json!(id_of(&dir)));
+            }
+        }
+    });
+    flips(ui, d);
+}
+
+/// A toggle button showing an arrow pointing the way `dir` runs. Whether it was clicked.
+fn arrow_button(ui: &mut egui::Ui, dir: Direction, selected: bool, tip: &str) -> bool {
+    let t = Tokens::get(ui.ctx());
+    let (r, resp) = ui.allocate_exact_size(vec2(26.0, 24.0), Sense::click());
+    let p = ui.painter();
+    if selected {
+        p.rect_filled(r, 3.0, t.row_selected);
+    } else if resp.hovered() {
+        p.rect_filled(r, 3.0, t.hover);
+    }
+    p.rect_stroke(r, 3.0, Stroke::new(1.0, if selected { t.accent } else { t.input_border }), egui::StrokeKind::Inside);
+    let u = match dir {
+        Direction::LeftToRight => vec2(1.0, 0.0),
+        Direction::RightToLeft => vec2(-1.0, 0.0),
+        Direction::TopToBottom => vec2(0.0, 1.0),
+        Direction::BottomToTop => vec2(0.0, -1.0),
+    };
+    let (c, n) = (r.center(), vec2(-u.y, u.x));
+    let (tail, tip_at) = (c - u * 7.0, c + u * 7.0);
+    let stroke = Stroke::new(1.5, if selected { t.text_strong } else { t.text });
+    p.line_segment([tail, tip_at], stroke);
+    p.line_segment([tip_at, tip_at - u * 4.0 + n * 4.0], stroke);
+    p.line_segment([tip_at, tip_at - u * 4.0 - n * 4.0], stroke);
+    resp.on_hover_text(tip).clicked()
+}
+
+fn pattern_body(ui: &mut egui::Ui, d: &mut Dialog) {
+    widgets::label_row(ui, tl!("Scale:"), LABEL_W, |ui| number(ui, d, "scale", PatternBrush::SCALE_RANGE, "%", true));
+    widgets::label_row(ui, tl!("Spacing:"), LABEL_W, |ui| number(ui, d, "spacing", PatternBrush::SPACING_RANGE, "%", true));
+    ui.add_space(6.0);
+    tiles(ui, d);
+    ui.add_space(6.0);
+    flips(ui, d);
+    widgets::section_header(ui, tl!("Fit"));
+    let fits = [("stretch", tl!("Stretch to fit")), ("addSpace", tl!("Add space to fit")), ("approximate", tl!("Approximate path"))];
+    radios(ui, d, "fit", &fits);
+}
+
+/// The pattern's five tiles, each with its art (or None when the brush has no such tile).
+fn tiles(ui: &mut egui::Ui, d: &Dialog) {
+    let t = Tokens::get(ui.ctx());
+    let names = [tl!("Outer Corner Tile"), tl!("Side Tile"), tl!("Inner Corner Tile"), tl!("Start Tile"), tl!("End Tile")];
+    let keys = d.fields.get("__tiles");
+    ui.horizontal(|ui| {
+        ui.spacing_mut().item_spacing.x = 6.0;
+        for ((field, slot), name) in TILES.into_iter().zip(names) {
+            ui.vertical(|ui| {
+                let (r, resp) = ui.allocate_exact_size(vec2(76.0, 44.0), Sense::hover());
+                ui.painter().rect_filled(r, 0.0, Color32::WHITE);
+                let key = keys.and_then(|k| k.get(slot)).and_then(Value::as_str);
+                let tex = key.and_then(|key| {
+                    widgets::doc_preview(ui, key, r.size(), |w, h| {
+                        let art: Node = serde_json::from_value(d.fields.get("__def")?.get(field)?.clone()).ok()?;
+                        tile_doc(&art, w, h)
+                    })
+                });
+                match tex {
+                    Some(tex) => {
+                        ui.painter().image(tex.id(), r, egui::Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
+                    }
+                    None => {
+                        ui.painter().text(
+                            r.center(),
+                            egui::Align2::CENTER_CENTER,
+                            tl!("None"),
+                            egui::FontId::proportional(11.5),
+                            Color32::from_gray(140),
+                        );
+                    }
+                }
+                ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, t.input_border), egui::StrokeKind::Inside);
+                resp.on_hover_text(name);
+                ui.add_sized(vec2(76.0, 14.0), egui::Label::new(egui::RichText::new(name).size(10.5).color(t.text_dim)).truncate());
+            });
+        }
+    });
+}
+
+/// A document of `w` × `h` showing `art` scaled to fit, centred.
+fn tile_doc(art: &Node, w: f64, h: f64) -> Option<Document> {
+    let b = art.visual_bounds().or_else(|| art.geometric_bounds())?;
+    let k = ((w - 8.0) / b.width().max(1e-6)).min((h - 8.0) / b.height().max(1e-6));
+    if !k.is_finite() || k <= 0.0 {
+        return None;
+    }
+    let mut doc = Document::new(w, h);
+    let mut n = doc.reid(art);
+    let xf = vectorcraft_geom::Affine::translate((w / 2.0, h / 2.0))
+        * vectorcraft_geom::Affine::scale(k)
+        * vectorcraft_geom::Affine::translate(-b.center().to_vec2());
+    n.transform(xf, true);
+    let l = doc.layers.first()?.id;
+    doc.insert(Some(l), 0, n).ok()?;
+    Some(doc)
+}
+
+fn colorization_body(ui: &mut egui::Ui, d: &mut Dialog) {
+    widgets::section_header(ui, tl!("Colorization"));
+    let methods = [tl!("None"), tl!("Tints"), tl!("Tints and Shades"), tl!("Hue Shift")];
+    let cur = d.str("colorization");
+    let at = Colorization::IDS.iter().position(|id| *id == cur).unwrap_or(0);
+    widgets::label_row(ui, tl!("Method:"), LABEL_W, |ui| {
+        if let Some(id) = widgets::dropdown_names(ui, "brush-colorization", methods.get(at).copied().unwrap_or_default(), &methods, 150.0)
+            .and_then(|i| Colorization::IDS.get(i))
+        {
+            d.fields.insert("colorization".into(), json!(id));
+        }
+    });
+    // Hue Shift's key colour: the art colour that becomes the stroke colour.
+    let colors: Vec<Color> = d.fields.get("__colors").and_then(|v| serde_json::from_value(v.clone()).ok()).unwrap_or_default();
+    let hue_shift = cur == "hueShift";
+    let key = key_color(d);
+    widgets::label_row(ui, tl!("Key Color:"), LABEL_W, |ui| {
+        ui.add_enabled_ui(hue_shift, |ui| {
+            ui.spacing_mut().item_spacing.x = 3.0;
+            for c in colors {
+                let (r, resp) = ui.allocate_exact_size(vec2(18.0, 18.0), Sense::click());
+                widgets::swatch_tile(ui, r, &Paint::solid(c), hue_shift && c == key, resp.hovered());
+                if resp.on_hover_text(c.to_hex()).clicked() {
+                    d.fields.insert("keyColor".into(), serde_json::to_value(c).unwrap_or_default());
+                }
+            }
+        });
+    });
+}

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

@@ -1,10 +1,12 @@
 //! Brush Options (double-click a brush in the Brushes panel, or the panel menu's Brush Options…).
 //! Calligraphic Brush Options: Name, then Angle, Roundness and Size, each Fixed, Random or
 //! Pressure with its Variation, over live previews of the nib and of a stroke (light, heavy, light
-//! pressure). Bristle Brush Options: Name, Shape and the bristle sliders. OK runs `brush.options`
-//! (strokes painted with the brush update); a name another brush has keeps the dialog open.
+//! pressure). Bristle Brush Options: Name, Shape and the bristle sliders. Scatter, Art and Pattern
+//! Brush Options: see [`super::brush_art_options`]. OK runs `brush.options` (strokes painted with
+//! the brush update); a name another brush has keeps the dialog open.
 //!
-//! Fields: `__brush` (the brush's name), `__type` (`calligraphic` | `bristle`), `name`.
+//! Fields: `__brush` (the brush's name), `__type` (`calligraphic` | `bristle` | `scatter` | `art` |
+//! `pattern`), `name`.
 //! Calligraphic: `angle` (−180..180°), `roundness` (0..100 %), `size` (0..1296 pt), and per value
 //! `angleMode`, `roundnessMode`, `sizeMode` (`fixed` | `random` | `pressure`) and
 //! `angleVariation`, `roundnessVariation`, `sizeVariation`. Bristle: `shape` (`roundPoint`…),
@@ -12,10 +14,10 @@
 
 use egui::{Color32, Sense, Stroke, pos2, vec2};
 use serde_json::{Map, Value, json};
-use vectorcraft_brush::{Brush, BrushKind, Calligraphic, Variation};
+use vectorcraft_brush::{Bristle, Brush, BrushKind, Calligraphic, Variation};
 
 use super::swatch_options::{grid, label};
-use super::{DialogSpec, form};
+use super::{DialogSpec, brush_art_options, form};
 use crate::state::Dialog;
 use crate::theme::Tokens;
 use crate::{VectorcraftApp, widgets};
@@ -25,19 +27,16 @@ pub const KIND: &str = "brushOptions";
 
 pub(super) const SPEC: DialogSpec = DialogSpec { heading, body, confirm, min_width: 440.0, ..DialogSpec::FORM };
 
-/// The brush types that have an options dialog.
-pub const TYPES: [&str; 2] = ["calligraphic", "bristle"];
-
 /// Calligraphic values: (field, label, suffix, decimals), in [`Calligraphic::RANGES`] order.
 const CALLI: [(&str, &str, &str, usize); 3] = [("angle", "Angle:", "°", 0), ("roundness", "Roundness:", "%", 0), ("size", "Size:", " pt", 1)];
 
-/// Bristle sliders: (field, label, min, max), in percent.
-const BRISTLE: [(&str, &str, f64, f64); 5] = [
-    ("length", "Bristle Length:", 25.0, 300.0),
-    ("density", "Bristle Density:", 1.0, 100.0),
-    ("thickness", "Bristle Thickness:", 1.0, 100.0),
-    ("opacity", "Paint Opacity:", 1.0, 100.0),
-    ("stiffness", "Stiffness:", 1.0, 100.0),
+/// Bristle sliders: (field, label, range), in percent.
+const BRISTLE: [(&str, &str, (f64, f64)); 5] = [
+    ("length", "Bristle Length:", Bristle::LENGTH_RANGE),
+    ("density", "Bristle Density:", Bristle::PERCENT_RANGE),
+    ("thickness", "Bristle Thickness:", Bristle::PERCENT_RANGE),
+    ("opacity", "Paint Opacity:", Bristle::PERCENT_RANGE),
+    ("stiffness", "Stiffness:", Bristle::PERCENT_RANGE),
 ];
 
 /// Bristle tip shapes: (value, label).
@@ -64,11 +63,12 @@ const STROKE_W: f32 = 400.0;
 fn heading(d: &Dialog) -> String {
     match d.str("__type").as_str() {
         "bristle" => tl!("Bristle Brush Options").into(),
-        _ => tl!("Calligraphic Brush Options").into(),
+        "calligraphic" => tl!("Calligraphic Brush Options").into(),
+        ty => brush_art_options::heading(ty).into(),
     }
 }
 
-fn mode_key(key: &str) -> String {
+pub(super) fn mode_key(key: &str) -> String {
     format!("{key}Mode")
 }
 
@@ -83,7 +83,7 @@ pub fn open(app: &mut VectorcraftApp, name: Option<&str>) -> Result<Value, Strin
         None => target(app).ok_or("no brush selected")?,
     };
     let def = app.run("brush.get", json!({ "name": name }))?;
-    let b: Brush = serde_json::from_value(def).map_err(|e| e.to_string())?;
+    let b: Brush = serde_json::from_value(def.clone()).map_err(|e| e.to_string())?;
     let mut f = Map::new();
     f.insert("__brush".into(), json!(b.name));
     f.insert("name".into(), json!(b.name));
@@ -104,16 +104,17 @@ pub fn open(app: &mut VectorcraftApp, name: Option<&str>) -> Result<Value, Strin
                 f.insert(key.into(), v.get(key).cloned().unwrap_or(Value::Null));
             }
         }
-        _ => return Err("this kind of brush has no options dialog yet".into()),
+        // The definition goes along, for the preview (and the art it carries).
+        BrushKind::Scatter(_) | BrushKind::Art(_) | BrushKind::Pattern(_) => brush_art_options::fields(&b, def, &mut f),
     }
     app.ui.dialog = Some(Dialog { kind: KIND.into(), fields: f });
     Ok(Value::Null)
 }
 
-/// Can Brush Options open without a name (its brush has a type with a dialog)?
+/// Can Brush Options open without a name (the selected path's brush, else the current one, exists)?
 pub fn available(app: &VectorcraftApp) -> bool {
     let Some(st) = app.session.active() else { return false };
-    target(app).and_then(|n| vectorcraft_brush::find(&st.doc, &n)).is_some_and(|b| TYPES.contains(&b.kind.type_id()))
+    target(app).is_some_and(|n| vectorcraft_brush::find(&st.doc, &n).is_some())
 }
 
 /// The brush Brush Options opens on without a name: the selected path's brush, else the current one.
@@ -124,7 +125,7 @@ fn target(app: &VectorcraftApp) -> Option<String> {
 }
 
 /// The value of field `key` within `range`.
-fn clamped(d: &Dialog, key: &str, (lo, hi): (f64, f64)) -> f64 {
+pub(super) fn clamped(d: &Dialog, key: &str, (lo, hi): (f64, f64)) -> f64 {
     d.f64(key, lo).clamp(lo, hi)
 }
 
@@ -141,13 +142,14 @@ fn calligraphic(d: &Dialog) -> Calligraphic {
 fn params(d: &Dialog) -> Value {
     match d.str("__type").as_str() {
         "bristle" => {
-            let mut p = json!({ "shape": d.str("shape"), "size": clamped(d, "size", (0.1, 1296.0)) });
-            for (key, _, lo, hi) in BRISTLE {
-                p[key] = json!(clamped(d, key, (lo, hi)));
+            let mut p = json!({ "shape": d.str("shape"), "size": clamped(d, "size", Bristle::SIZE_RANGE) });
+            for (key, _, range) in BRISTLE {
+                p[key] = json!(clamped(d, key, range));
             }
             p
         }
-        _ => serde_json::to_value(calligraphic(d)).unwrap_or_default(),
+        "calligraphic" => serde_json::to_value(calligraphic(d)).unwrap_or_default(),
+        _ => brush_art_options::params(d),
     }
 }
 
@@ -160,7 +162,8 @@ fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
     ui.add_space(10.0);
     match d.str("__type").as_str() {
         "bristle" => bristle_body(app, ui, d),
-        _ => calligraphic_body(ui, d),
+        "calligraphic" => calligraphic_body(ui, d),
+        _ => brush_art_options::body(ui, d),
     }
     false
 }
@@ -203,7 +206,7 @@ fn bristle_body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) {
         form::length(ui, d, "size", app.session.general_unit(), 80.0);
     });
     let rail = Tokens::get(ui.ctx()).input_border;
-    for (key, text, lo, hi) in BRISTLE {
+    for (key, text, (lo, hi)) in BRISTLE {
         widgets::label_row(ui, tl!(text), LABEL_W, |ui| form::slider_field(ui, d, key, lo..=hi, "%", &|_| rail));
     }
     ui.add_space(8.0);
@@ -212,7 +215,7 @@ fn bristle_body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) {
 }
 
 /// A stroke painted with the brush the fields describe (type `ty`, definition fields `def`).
-fn stroke_preview(ui: &mut egui::Ui, ty: &str, mut def: Value, size: egui::Vec2) {
+pub(super) fn stroke_preview(ui: &mut egui::Ui, ty: &str, mut def: Value, size: egui::Vec2) {
     def["name"] = json!("preview");
     def["type"] = json!(ty);
     let (r, _) = ui.allocate_exact_size(size, Sense::hover());
@@ -325,7 +328,7 @@ mod tests {
     }
 
     #[test]
-    fn bristle_options_and_brushes_without_a_dialog() {
+    fn bristle_options_and_an_unknown_brush() {
         let mut app = app();
         app.run("ui.brushOptions", json!({"name": "Bristle Round"})).unwrap();
         let text = shown(&mut app);
@@ -336,9 +339,158 @@ mod tests {
         super::super::confirm(&mut app).unwrap();
         let def = app.run("brush.get", json!({"name": "Bristle Round"})).unwrap();
         assert_eq!((def["shape"].clone(), def["density"].clone(), def["length"].clone()), (json!("flatFan"), json!(1.0), json!(120.0)));
-        // Art, scatter and pattern brushes have no dialog yet: an error, nothing opens.
-        assert!(app.run("ui.brushOptions", json!({"name": "Arrow"})).is_err());
-        assert!(app.ui.dialog.is_none());
+        // No such brush: an error, nothing opens.
+        app.ui.dialog = None;
         assert!(app.run("ui.brushOptions", json!({"name": "Nope"})).is_err());
+        assert!(app.ui.dialog.is_none());
+    }
+
+    /// A path painted with brush `name`, and the height of the art its stroke draws.
+    fn brushed(app: &mut VectorcraftApp, name: &str) -> (vectorcraft_doc::NodeId, f64) {
+        let id = app.run("shape.line", json!({"x1": 20, "y1": 100, "x2": 280, "y2": 100})).unwrap()["id"].as_u64().unwrap();
+        let id = vectorcraft_doc::NodeId(id);
+        app.run("brush.apply", json!({ "name": name, "ids": [id.0] })).unwrap();
+        (id, drawn_height(app, id))
+    }
+
+    fn drawn_height(app: &VectorcraftApp, id: vectorcraft_doc::NodeId) -> f64 {
+        let st = app.session.active().unwrap();
+        let pieces = vectorcraft_brush::node_pieces(&st.doc, st.doc.node(id).unwrap()).unwrap();
+        vectorcraft_brush::pieces_bounds(&pieces).unwrap().height()
+    }
+
+    #[test]
+    fn scatter_options_show_each_value_with_its_mode_and_ok_applies_them() {
+        let mut app = app();
+        let (id, before) = brushed(&mut app, "Confetti");
+        app.run("ui.brushOptions", json!({"name": "Confetti"})).unwrap();
+        let text = shown(&mut app);
+        for label in [
+            "Scatter Brush Options",
+            "Name:",
+            "Size:",
+            "Spacing:",
+            "Scatter:",
+            "Rotation:",
+            "Random",
+            "Rotation relative to:",
+            "Page",
+            "Colorization",
+            "Method:",
+            "Tints",
+            "Key Color:",
+        ] {
+            assert!(text.contains(label), "{label} in {text}");
+        }
+        let d = app.ui.dialog.as_ref().unwrap();
+        assert_eq!((d.f64("sizeMin", 0.0), d.f64("sizeMax", 0.0), d.str("sizeMode")), (60.0, 140.0, "random".into()));
+        assert_eq!((d.str("rotationRelativeTo"), d.str("colorization")), ("page".into(), "tints".into()));
+        // Values are kept within their ranges (rotation here); Fixed takes the first value.
+        set(
+            &mut app,
+            json!({"sizeMode": "fixed", "sizeMin": 5000, "spacingMode": "pressure", "rotationMin": -400, "rotationRelativeTo": "path", "colorization": "hueShift"}),
+        );
+        assert!(shown(&mut app).contains("Hue Shift"));
+        super::super::confirm(&mut app).unwrap();
+        assert!(app.ui.dialog.is_none());
+        let def = app.run("brush.get", json!({"name": "Confetti"})).unwrap();
+        assert_eq!(
+            (&def["size"], &def["rotation"][0], &def["modes"]),
+            (&json!([5000.0, 140.0]), &json!(-180.0), &json!(["fixed", "pressure", "random", "random"]))
+        );
+        assert_eq!((&def["rotation_relative_to_path"], &def["colorization"]["method"]), (&json!(true), &json!("hueShift")));
+        assert!(def["colorization"]["key"].is_object(), "the art's colour as the key: {def}");
+        assert!(drawn_height(&app, id) > before, "the stroke redraws with the bigger confetti");
+        // Opened again, it shows what was set.
+        app.run("ui.brushOptions", json!({"name": "Confetti"})).unwrap();
+        let d = app.ui.dialog.as_ref().unwrap();
+        assert_eq!((d.str("sizeMode"), d.str("spacingMode"), d.str("colorization")), ("fixed".into(), "pressure".into(), "hueShift".into()));
+    }
+
+    #[test]
+    fn art_options_set_width_scale_direction_flips_and_colorization() {
+        let mut app = app();
+        let (id, before) = brushed(&mut app, "Arrow");
+        app.run("ui.brushOptions", json!({"name": "Arrow"})).unwrap();
+        let text = shown(&mut app);
+        for label in [
+            "Art Brush Options",
+            "Width:",
+            "Brush Scale Options",
+            "Scale Proportionately",
+            "Stretch to Fit Stroke Length",
+            "Stretch Between Guides",
+            "Start:",
+            "End:",
+            "Direction:",
+            "Flip Along",
+            "Flip Across",
+            "Colorization",
+        ] {
+            assert!(text.contains(label), "{label} in {text}");
+        }
+        let d = app.ui.dialog.as_ref().unwrap();
+        assert_eq!(
+            (d.f64("width", 0.0), d.str("scaleMode"), d.f64("guideEnd", 0.0), d.str("direction")),
+            (100.0, "betweenGuides".into(), 78.0, "leftToRight".into())
+        );
+        set(
+            &mut app,
+            json!({"width": 250, "guideStart": 10, "guideEnd": 140, "direction": "bottomToTop", "flipAcross": true, "colorization": "none"}),
+        );
+        super::super::confirm(&mut app).unwrap();
+        let def = app.run("brush.get", json!({"name": "Arrow"})).unwrap();
+        assert_eq!(
+            (&def["width"], &def["scale"], &def["direction"]),
+            (&json!(250.0), &json!({"mode": "betweenGuides", "start": 0.1, "end": 1.0}), &json!("bottomToTop"))
+        );
+        assert_eq!((&def["flip_across"], &def["flip_along"], &def["colorization"]), (&json!(true), &json!(false), &json!({"method": "none"})));
+        assert!(drawn_height(&app, id) != before, "the stroke redraws");
+        // Stretch to Fit drops the guides.
+        app.run("ui.brushOptions", json!({"name": "Arrow"})).unwrap();
+        set(&mut app, json!({"scaleMode": "stretch"}));
+        super::super::confirm(&mut app).unwrap();
+        assert_eq!(app.run("brush.get", json!({"name": "Arrow"})).unwrap()["scale"], json!({"mode": "stretch"}));
+    }
+
+    #[test]
+    fn pattern_options_show_the_tiles_and_set_scale_spacing_fit() {
+        let mut app = app();
+        app.run("ui.brushOptions", json!({"name": "Chain"})).unwrap();
+        let text = shown(&mut app);
+        for label in [
+            "Pattern Brush Options",
+            "Scale:",
+            "Spacing:",
+            "Outer Corner Tile",
+            "Side Tile",
+            "Inner Corner Tile",
+            "Start Tile",
+            "End Tile",
+            "None",
+            "Fit",
+            "Stretch to fit",
+            "Add space to fit",
+            "Approximate path",
+            "Flip Along",
+        ] {
+            assert!(text.contains(label), "{label} in {text}");
+        }
+        let d = app.ui.dialog.as_ref().unwrap();
+        let mut tiles: Vec<&String> = d.fields["__tiles"].as_object().unwrap().keys().collect();
+        tiles.sort();
+        assert_eq!(tiles, ["innerCorner", "outerCorner", "side"], "Chain has side and corner tiles, no start or end");
+        // Diamonds (straight-edged tiles, so sizes compare exactly).
+        let (id, before) = brushed(&mut app, "Diamonds");
+        app.run("ui.brushOptions", json!({"name": "Diamonds"})).unwrap();
+        assert_eq!((app.ui.dialog.as_ref().unwrap().f64("spacing", 0.0), app.ui.dialog.as_ref().unwrap().str("fit")), (25.0, "addSpace".into()));
+        set(&mut app, json!({"scale": 200, "spacing": 30, "fit": "approximate", "flipAlong": true}));
+        super::super::confirm(&mut app).unwrap();
+        let def = app.run("brush.get", json!({"name": "Diamonds"})).unwrap();
+        assert_eq!(
+            (&def["scale"], &def["spacing"], &def["fit"], &def["flip_along"]),
+            (&json!(200.0), &json!(30.0), &json!("approximate"), &json!(true))
+        );
+        assert!((drawn_height(&app, id) / before - 2.0).abs() < 1e-6, "tiles twice the size");
     }
 }

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

@@ -1,5 +1,5 @@
 //! The generic parameter dialog (`ui.paramDialog`): edits a command's parameters (`__command`,
-//! headed `__label`) and runs it on OK.
+//! headed `__label`) and runs it on OK, with the fixed ones in `__params` (not shown) added.
 
 use serde_json::Value;
 
@@ -60,7 +60,10 @@ const VERTICAL_ALIGN: form::Choices = &[("Top", "top"), ("Center", "center"), ("
 /// Closes before running, so a dialog the command opens stays open.
 fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
     let cmd = d.str("__command");
-    let params = form::params(d);
+    let mut params = form::params(d);
+    if let (Some(o), Some(Value::Object(fixed))) = (params.as_object_mut(), d.fields.get("__params")) {
+        o.extend(fixed.clone());
+    }
     app.ui.dialog = None;
     // A tool's click-to-size shape (Flare) goes on the active perspective plane while the grid shows.
     let at = |x: &str, y: &str| Some(vectorcraft_geom::Point::new(params.get(x)?.as_f64()?, params.get(y)?.as_f64()?));

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

@@ -160,6 +160,8 @@ fn choices(effect: &str, key: &str) -> Option<form::Choices> {
         ("blur.radial", "quality") => Some(&[("Draft", "draft"), ("Good", "good"), ("Best", "best")]),
         ("blur.smart", "quality") => Some(&[("Low", "low"), ("Medium", "medium"), ("High", "high")]),
         ("pixelate.mezzotint", "type") => Some(&vectorcraft_effects::pixel::MEZZOTINT_TYPES),
+        ("video.deinterlace", "eliminate") => Some(&[("Odd Fields", "odd"), ("Even Fields", "even")]),
+        ("video.deinterlace", "create") => Some(&[("Duplication", "duplication"), ("Interpolation", "interpolation")]),
         ("path.offsetPath", "joins") => Some(&[("Miter", "miter"), ("Round", "round"), ("Bevel", "bevel")]),
         ("distort.roughen" | "distort.zigZag", "points") => Some(&[("Smooth", "smooth"), ("Corner", "corner")]),
         _ => None,

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

@@ -357,6 +357,7 @@ pub(super) fn humanize(k: &str) -> String {
         "Channel4" => "Channel 4:".into(),
         "Include Cmy Blacks" => "Include Blacks with CMY:".into(),
         "Align To Path" => "Align to Path:".into(),
+        "Create" => "Create New Fields by:".into(),
         _ => format!("{s}:"),
     }
 }

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

@@ -10,6 +10,7 @@ mod about;
 mod all_tools;
 pub mod artboard_options;
 pub mod blend_options;
+mod brush_art_options;
 pub mod brush_options;
 pub mod color_balance;
 pub mod color_guide_options;

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

@@ -657,3 +657,6 @@
 	Crystallize…	Krystalizace…
 	Mezzotint…	Mezzotinta…
 	Pointillize…	Pointilismus…
+	Video	Video
+	De-Interlace…	Odstranit prokládání…
+	NTSC Colors	Barvy NTSC

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

@@ -1588,6 +1588,37 @@
 	New Bristle Brush	Nuevo pincel de cerdas
 	Calligraphic Brush Options	Opciones de pincel caligráfico
 	Bristle Brush Options	Opciones de pincel de cerdas
+	Scatter Brush Options	Opciones de pincel de dispersión
+	Art Brush Options	Opciones de pincel de arte
+	Pattern Brush Options	Opciones de pincel de motivo
+	Scatter:	Dispersión:
+	Rotation:	Rotación:
+	Rotation relative to:	Rotación relativa a:
+	Brush Scale Options	Opciones de escala del pincel
+	Scale Proportionately	Escalar proporcionalmente
+	Stretch to Fit Stroke Length	Estirar para ajustar a la longitud del trazo
+	Stretch Between Guides	Estirar entre guías
+	Start:	Inicio:
+	End:	Final:
+	Left to Right	De izquierda a derecha
+	Right to Left	De derecha a izquierda
+	Top to Bottom	De arriba abajo
+	Bottom to Top	De abajo arriba
+	Flip:	Voltear:
+	Outer Corner Tile	Mosaico de esquina exterior
+	Side Tile	Mosaico lateral
+	Inner Corner Tile	Mosaico de esquina interior
+	Start Tile	Mosaico inicial
+	End Tile	Mosaico final
+	Fit	Ajuste
+	Stretch to fit	Estirar para ajustar
+	Add space to fit	Agregar espacio para ajustar
+	Approximate path	Aproximar trazado
+	Colorization	Coloración
+	Tints	Matices
+	Tints and Shades	Matices y sombras
+	Hue Shift	Cambio de tono
+	Key Color:	Color clave:
 	Roundness:	Redondez:
 	Fixed	Fijo
 	Pressure	Presión
@@ -2760,6 +2791,23 @@
 	Add to Library	Añadir a la biblioteca
 	Delete Library	Eliminar biblioteca
 	Delete Library Item	Eliminar elemento de la biblioteca
+	No results	Sin resultados
+	No items in this library match “{query}”.	Ningún elemento de esta biblioteca coincide con “{query}”.
+	Right-click an item to move it into this group.	Haz clic con el botón derecho en un elemento para moverlo a este grupo.
+	New Group	Nuevo grupo
+	New Group…	Nuevo grupo…
+	Move to Group	Mover al grupo
+	No Group	Sin grupo
+	Rename Group…	Cambiar nombre del grupo…
+	Delete Group	Eliminar grupo
+	Import Library…	Importar biblioteca…
+	Export Library…	Exportar biblioteca…
+	Import Library	Importar biblioteca
+	Export Library	Exportar biblioteca
+	New Library Group	Nuevo grupo de biblioteca
+	Rename Library Group	Cambiar nombre del grupo de biblioteca
+	Delete Library Group	Eliminar grupo de biblioteca
+	Move Library Item to Group	Mover elemento de la biblioteca al grupo
 	Library	Biblioteca
 	Rename Library	Cambiar nombre de la biblioteca
 	Show Library	Mostrar biblioteca
@@ -3485,7 +3533,6 @@ axis	Both	Ambos
 @msg	no bounds	sin límites
 @msg	no brush named `{name}`	no hay ningún pincel llamado `{name}`
 @msg	no brush selected	no hay ningún pincel seleccionado
-@msg	this kind of brush has no options dialog yet	este tipo de pincel aún no tiene un cuadro de opciones
 @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
@@ -3871,3 +3918,14 @@ axis	Both	Ambos
 @msg	the PSD file is cut short	el archivo PSD está incompleto
 @msg	the PSD file's header is damaged	el encabezado del archivo PSD está dañado
 @msg	the PSD file's image data can't be read: {e}	no se pueden leer los datos de imagen del archivo PSD: {e}
+	Video	Video
+	De-Interlace…	Desentrelazar…
+	De-Interlace	Desentrelazar
+	NTSC Colors	Colores NTSC
+	Eliminate	Eliminar
+	Create New Fields by	Crear campos nuevos por
+	Odd Fields	Campos impares
+	Even Fields	Campos pares
+	Duplication	Duplicación
+	Interpolation	Interpolación
+@msg	Imported library {name}	Biblioteca {name} importada

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

@@ -1585,6 +1585,37 @@
 	New Bristle Brush	Nouvelle forme Soies
 	Calligraphic Brush Options	Options de forme calligraphique
 	Bristle Brush Options	Options de forme Soies
+	Scatter Brush Options	Options de forme de diffusion
+	Art Brush Options	Options de forme artistique
+	Pattern Brush Options	Options de forme de motif
+	Scatter:	Dispersion :
+	Rotation:	Rotation :
+	Rotation relative to:	Rotation par rapport à :
+	Brush Scale Options	Options de mise à l'échelle de la forme
+	Scale Proportionately	Mettre à l'échelle proportionnellement
+	Stretch to Fit Stroke Length	Étirer selon la longueur du contour
+	Stretch Between Guides	Étirer entre les repères
+	Start:	Début :
+	End:	Fin :
+	Left to Right	De gauche à droite
+	Right to Left	De droite à gauche
+	Top to Bottom	De haut en bas
+	Bottom to Top	De bas en haut
+	Flip:	Retourner :
+	Outer Corner Tile	Carreau d'angle extérieur
+	Side Tile	Carreau latéral
+	Inner Corner Tile	Carreau d'angle intérieur
+	Start Tile	Carreau de début
+	End Tile	Carreau de fin
+	Fit	Ajustement
+	Stretch to fit	Étirer pour ajuster
+	Add space to fit	Ajouter de l'espace pour ajuster
+	Approximate path	Tracé approximatif
+	Colorization	Colorisation
+	Tints	Teintes
+	Tints and Shades	Teintes et ombres
+	Hue Shift	Décalage de teinte
+	Key Color:	Couleur clé :
 	Roundness:	Arrondi :
 	Fixed	Fixe
 	Pressure	Pression
@@ -2757,6 +2788,23 @@
 	Add to Library	Ajouter à la bibliothèque
 	Delete Library	Supprimer la bibliothèque
 	Delete Library Item	Supprimer l’élément de la bibliothèque
+	No results	Aucun résultat
+	No items in this library match “{query}”.	Aucun élément de cette bibliothèque ne correspond à « {query} ».
+	Right-click an item to move it into this group.	Cliquez avec le bouton droit sur un élément pour le placer dans ce groupe.
+	New Group	Nouveau groupe
+	New Group…	Nouveau groupe…
+	Move to Group	Déplacer vers le groupe
+	No Group	Aucun groupe
+	Rename Group…	Renommer le groupe…
+	Delete Group	Supprimer le groupe
+	Import Library…	Importer une bibliothèque…
+	Export Library…	Exporter la bibliothèque…
+	Import Library	Importer une bibliothèque
+	Export Library	Exporter la bibliothèque
+	New Library Group	Nouveau groupe de bibliothèque
+	Rename Library Group	Renommer le groupe de bibliothèque
+	Delete Library Group	Supprimer le groupe de bibliothèque
+	Move Library Item to Group	Déplacer l’élément de la bibliothèque vers un groupe
 	Library	Bibliothèque
 	Rename Library	Renommer la bibliothèque
 	Show Library	Afficher la bibliothèque
@@ -3482,7 +3530,6 @@ axis	Both	Les deux
 @msg	no bounds	aucune limite
 @msg	no brush named `{name}`	aucune forme nommée `{name}`
 @msg	no brush selected	aucune forme sélectionnée
-@msg	this kind of brush has no options dialog yet	ce type de forme n’a pas encore de boîte de dialogue d’options
 @msg	no catalog	aucun catalogue
 @msg	no changes since the last save	aucune modification depuis le dernier enregistrement
 @msg	no clock to keep a heartbeat by	aucune horloge pour entretenir le signal d’activité
@@ -3882,3 +3929,14 @@ axis	Both	Les deux
 @msg	the PSD file is cut short	le fichier PSD est tronqué
 @msg	the PSD file's header is damaged	l'en-tête du fichier PSD est endommagé
 @msg	the PSD file's image data can't be read: {e}	les données d'image du fichier PSD ne peuvent pas être lues : {e}
+	Video	Vidéo
+	De-Interlace…	Désentrelacement…
+	De-Interlace	Désentrelacement
+	NTSC Colors	Couleurs NTSC
+	Eliminate	Supprimer
+	Create New Fields by	Créer des trames par
+	Odd Fields	Trames impaires
+	Even Fields	Trames paires
+	Duplication	Duplication
+	Interpolation	Interpolation
+@msg	Imported library {name}	Bibliothèque {name} importée

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

@@ -1588,6 +1588,37 @@
 	New Bristle Brush	Nuovo pennello a setole
 	Calligraphic Brush Options	Opzioni pennello calligrafico
 	Bristle Brush Options	Opzioni pennello a setole
+	Scatter Brush Options	Opzioni pennello a dispersione
+	Art Brush Options	Opzioni pennello artistico
+	Pattern Brush Options	Opzioni pennello motivo
+	Scatter:	Dispersione:
+	Rotation:	Rotazione:
+	Rotation relative to:	Rotazione relativa a:
+	Brush Scale Options	Opzioni di scala del pennello
+	Scale Proportionately	Ridimensiona proporzionalmente
+	Stretch to Fit Stroke Length	Allunga per adattare alla lunghezza del tratto
+	Stretch Between Guides	Allunga tra le guide
+	Start:	Inizio:
+	End:	Fine:
+	Left to Right	Da sinistra a destra
+	Right to Left	Da destra a sinistra
+	Top to Bottom	Dall'alto in basso
+	Bottom to Top	Dal basso in alto
+	Flip:	Capovolgi:
+	Outer Corner Tile	Tassello angolo esterno
+	Side Tile	Tassello laterale
+	Inner Corner Tile	Tassello angolo interno
+	Start Tile	Tassello iniziale
+	End Tile	Tassello finale
+	Fit	Adattamento
+	Stretch to fit	Allunga per adattare
+	Add space to fit	Aggiungi spazio per adattare
+	Approximate path	Approssima tracciato
+	Colorization	Colorazione
+	Tints	Tinte
+	Tints and Shades	Tinte e ombre
+	Hue Shift	Variazione tonalità
+	Key Color:	Colore chiave:
 	Roundness:	Rotondità:
 	Fixed	Fisso
 	Pressure	Pressione
@@ -2760,6 +2791,23 @@
 	Add to Library	Aggiungi alla libreria
 	Delete Library	Elimina libreria
 	Delete Library Item	Elimina elemento della libreria
+	No results	Nessun risultato
+	No items in this library match “{query}”.	Nessun elemento di questa libreria corrisponde a “{query}”.
+	Right-click an item to move it into this group.	Fai clic con il pulsante destro su un elemento per spostarlo in questo gruppo.
+	New Group	Nuovo gruppo
+	New Group…	Nuovo gruppo…
+	Move to Group	Sposta nel gruppo
+	No Group	Nessun gruppo
+	Rename Group…	Rinomina gruppo…
+	Delete Group	Elimina gruppo
+	Import Library…	Importa libreria…
+	Export Library…	Esporta libreria…
+	Import Library	Importa libreria
+	Export Library	Esporta libreria
+	New Library Group	Nuovo gruppo di libreria
+	Rename Library Group	Rinomina gruppo di libreria
+	Delete Library Group	Elimina gruppo di libreria
+	Move Library Item to Group	Sposta elemento della libreria nel gruppo
 	Library	Libreria
 	Rename Library	Rinomina libreria
 	Show Library	Mostra libreria
@@ -3485,7 +3533,6 @@ axis	Both	Entrambi
 @msg	no bounds	nessun limite
 @msg	no brush named `{name}`	nessun pennello denominato `{name}`
 @msg	no brush selected	nessun pennello selezionato
-@msg	this kind of brush has no options dialog yet	questo tipo di pennello non ha ancora una finestra di opzioni
 @msg	no catalog	nessun catalogo
 @msg	no changes since the last save	nessuna modifica dall'ultimo salvataggio
 @msg	no clock to keep a heartbeat by	nessun orologio con cui mantenere il segnale di attività
@@ -3871,3 +3918,14 @@ axis	Both	Entrambi
 @msg	the PSD file is cut short	il file PSD è troncato
 @msg	the PSD file's header is damaged	l'intestazione del file PSD è danneggiata
 @msg	the PSD file's image data can't be read: {e}	i dati immagine del file PSD non possono essere letti: {e}
+	Video	Video
+	De-Interlace…	Deinterlaccia…
+	De-Interlace	Deinterlaccia
+	NTSC Colors	Colori NTSC
+	Eliminate	Elimina
+	Create New Fields by	Crea nuovi campi per
+	Odd Fields	Campi dispari
+	Even Fields	Campi pari
+	Duplication	Duplicazione
+	Interpolation	Interpolazione
+@msg	Imported library {name}	Libreria {name} importata

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

@@ -1681,6 +1681,37 @@
 	New Bristle Brush	新規剛毛ブラシ
 	Calligraphic Brush Options	絵筆ブラシオプション
 	Bristle Brush Options	剛毛ブラシオプション
+	Scatter Brush Options	散布ブラシオプション
+	Art Brush Options	アートブラシオプション
+	Pattern Brush Options	パターンブラシオプション
+	Scatter:	散布:
+	Rotation:	回転:
+	Rotation relative to:	回転の基準:
+	Brush Scale Options	ブラシ伸縮オプション
+	Scale Proportionately	縦横比を保持して拡大・縮小
+	Stretch to Fit Stroke Length	ストロークの長さに合わせて伸縮
+	Stretch Between Guides	ガイド間で伸縮
+	Start:	始点:
+	End:	終点:
+	Left to Right	左から右
+	Right to Left	右から左
+	Top to Bottom	上から下
+	Bottom to Top	下から上
+	Flip:	反転:
+	Outer Corner Tile	外角タイル
+	Side Tile	サイドタイル
+	Inner Corner Tile	内角タイル
+	Start Tile	始点タイル
+	End Tile	終点タイル
+	Fit	調整
+	Stretch to fit	伸縮して合わせる
+	Add space to fit	間隔を空けて合わせる
+	Approximate path	パスに近似
+	Colorization	着色
+	Tints	淡彩
+	Tints and Shades	淡彩と陰影
+	Hue Shift	色相シフト
+	Key Color:	キーカラー:
 	Roundness:	真円率:
 	Fixed	固定
 	Pressure	筆圧
@@ -2496,6 +2527,23 @@
 	Add to Library	ライブラリに追加
 	Delete Library	ライブラリを削除
 	Delete Library Item	ライブラリ項目を削除
+	No results	結果はありません
+	No items in this library match “{query}”.	このライブラリには「{query}」に一致する項目がありません。
+	Right-click an item to move it into this group.	項目を右クリックすると、このグループに移動できます。
+	New Group	新規グループ
+	New Group…	新規グループ…
+	Move to Group	グループに移動
+	No Group	グループなし
+	Rename Group…	グループ名を変更…
+	Delete Group	グループを削除
+	Import Library…	ライブラリを読み込み…
+	Export Library…	ライブラリを書き出し…
+	Import Library	ライブラリを読み込み
+	Export Library	ライブラリを書き出し
+	New Library Group	新規ライブラリグループ
+	Rename Library Group	ライブラリグループ名を変更
+	Delete Library Group	ライブラリグループを削除
+	Move Library Item to Group	ライブラリ項目をグループに移動
 	Library	ライブラリ
 	Rename Library	ライブラリ名を変更
 	Show Library	ライブラリを表示
@@ -3300,7 +3348,6 @@ theme	Appearance	外観
 @msg	Expand: no brush strokes selected	拡張: ブラシストロークが選択されていません
 @msg	no brush named `{name}`	`{name}` という名前のブラシが見つかりません
 @msg	no brush selected	ブラシが選択されていません
-@msg	this kind of brush has no options dialog yet	この種類のブラシにはまだオプションダイアログがありません
 @msg	no symbol instances selected	シンボルインスタンスが選択されていません
 @msg	select a symbol instance	シンボルインスタンスを選択してください
 @msg	the art has no bounds	アートに境界がありません
@@ -3863,3 +3910,14 @@ theme	Appearance	外観
 @msg	the PSD file is cut short	PSD ファイルが途中で切れています
 @msg	the PSD file's header is damaged	PSD ファイルのヘッダーが破損しています
 @msg	the PSD file's image data can't be read: {e}	PSD ファイルの画像データを読み込めません：{e}
+	Video	ビデオ
+	De-Interlace…	インターレース解除…
+	De-Interlace	インターレース解除
+	NTSC Colors	NTSC カラー
+	Eliminate	削除
+	Create New Fields by	新規フィールドの作成
+	Odd Fields	奇数フィールド
+	Even Fields	偶数フィールド
+	Duplication	複製
+	Interpolation	補間
+@msg	Imported library {name}	ライブラリ {name} を読み込みました

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

@@ -2718,3 +2718,6 @@
 	Crystallize…	Cristalizar…
 	Mezzotint…	Meia-Tinta…
 	Pointillize…	Pontilhar…
+	Video	Vídeo
+	De-Interlace…	Desentrelaçar…
+	NTSC Colors	Cores NTSC

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

@@ -1584,6 +1584,37 @@
 	New Bristle Brush	Новая щетинная кисть
 	Calligraphic Brush Options	Параметры каллиграфической кисти
 	Bristle Brush Options	Параметры щетинной кисти
+	Scatter Brush Options	Параметры кисти-распыления
+	Art Brush Options	Параметры художественной кисти
+	Pattern Brush Options	Параметры узорной кисти
+	Scatter:	Рассеивание:
+	Rotation:	Поворот:
+	Rotation relative to:	Поворот относительно:
+	Brush Scale Options	Параметры масштабирования кисти
+	Scale Proportionately	Масштабировать пропорционально
+	Stretch to Fit Stroke Length	Растянуть по длине обводки
+	Stretch Between Guides	Растянуть между направляющими
+	Start:	Начало:
+	End:	Конец:
+	Left to Right	Слева направо
+	Right to Left	Справа налево
+	Top to Bottom	Сверху вниз
+	Bottom to Top	Снизу вверх
+	Flip:	Отразить:
+	Outer Corner Tile	Фрагмент внешнего угла
+	Side Tile	Боковой фрагмент
+	Inner Corner Tile	Фрагмент внутреннего угла
+	Start Tile	Начальный фрагмент
+	End Tile	Конечный фрагмент
+	Fit	Подгонка
+	Stretch to fit	Растянуть для подгонки
+	Add space to fit	Добавить интервалы для подгонки
+	Approximate path	Приблизить к контуру
+	Colorization	Перекрашивание
+	Tints	Оттенки
+	Tints and Shades	Оттенки и тени
+	Hue Shift	Сдвиг тона
+	Key Color:	Ключевой цвет:
 	Roundness:	Округлость:
 	Fixed	Фиксированный
 	Pressure	Нажим
@@ -2756,6 +2787,23 @@
 	Add to Library	Добавить в библиотеку
 	Delete Library	Удалить библиотеку
 	Delete Library Item	Удалить элемент библиотеки
+	No results	Ничего не найдено
+	No items in this library match “{query}”.	В этой библиотеке нет элементов, соответствующих «{query}».
+	Right-click an item to move it into this group.	Щёлкните элемент правой кнопкой мыши, чтобы переместить его в эту группу.
+	New Group	Новая группа
+	New Group…	Новая группа…
+	Move to Group	Переместить в группу
+	No Group	Без группы
+	Rename Group…	Переименовать группу…
+	Delete Group	Удалить группу
+	Import Library…	Импортировать библиотеку…
+	Export Library…	Экспортировать библиотеку…
+	Import Library	Импортировать библиотеку
+	Export Library	Экспортировать библиотеку
+	New Library Group	Новая группа библиотеки
+	Rename Library Group	Переименовать группу библиотеки
+	Delete Library Group	Удалить группу библиотеки
+	Move Library Item to Group	Переместить элемент библиотеки в группу
 	Library	Библиотека
 	Rename Library	Переименовать библиотеку
 	Show Library	Показать библиотеку
@@ -3481,7 +3529,6 @@ axis	Both	Оба
 @msg	no bounds	нет границ
 @msg	no brush named `{name}`	нет кисти с именем `{name}`
 @msg	no brush selected	кисть не выбрана
-@msg	this kind of brush has no options dialog yet	у кисти этого типа пока нет окна параметров
 @msg	no catalog	нет каталога
 @msg	no changes since the last save	нет изменений с момента последнего сохранения
 @msg	no clock to keep a heartbeat by	нет часов для поддержания сигнала
@@ -3869,3 +3916,14 @@ axis	Both	Оба
 @msg	the PSD file is cut short	файл PSD обрезан
 @msg	the PSD file's header is damaged	заголовок файла PSD повреждён
 @msg	the PSD file's image data can't be read: {e}	не удаётся прочитать данные изображения файла PSD: {e}
+	Video	Видео
+	De-Interlace…	Устранение чересстрочности…
+	De-Interlace	Устранение чересстрочности
+	NTSC Colors	Цвета NTSC
+	Eliminate	Удалить
+	Create New Fields by	Создать новые поля
+	Odd Fields	Нечётные поля
+	Even Fields	Чётные поля
+	Duplication	Дублированием
+	Interpolation	Интерполяцией
+@msg	Imported library {name}	Импортирована библиотека {name}

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

@@ -1580,6 +1580,37 @@
 	New Bristle Brush	Новий щетинний пензель
 	Calligraphic Brush Options	Параметри каліграфічного пензля
 	Bristle Brush Options	Параметри щетинного пензля
+	Scatter Brush Options	Параметри пензля-розпорошення
+	Art Brush Options	Параметри художнього пензля
+	Pattern Brush Options	Параметри візерункового пензля
+	Scatter:	Розсіювання:
+	Rotation:	Поворот:
+	Rotation relative to:	Поворот відносно:
+	Brush Scale Options	Параметри масштабування пензля
+	Scale Proportionately	Масштабувати пропорційно
+	Stretch to Fit Stroke Length	Розтягнути за довжиною обведення
+	Stretch Between Guides	Розтягнути між напрямними
+	Start:	Початок:
+	End:	Кінець:
+	Left to Right	Зліва направо
+	Right to Left	Справа наліво
+	Top to Bottom	Згори вниз
+	Bottom to Top	Знизу вгору
+	Flip:	Відобразити:
+	Outer Corner Tile	Фрагмент зовнішнього кута
+	Side Tile	Бічний фрагмент
+	Inner Corner Tile	Фрагмент внутрішнього кута
+	Start Tile	Початковий фрагмент
+	End Tile	Кінцевий фрагмент
+	Fit	Припасування
+	Stretch to fit	Розтягнути для припасування
+	Add space to fit	Додати інтервали для припасування
+	Approximate path	Наблизити до контуру
+	Colorization	Перефарбування
+	Tints	Відтінки
+	Tints and Shades	Відтінки й тіні
+	Hue Shift	Зсув тону
+	Key Color:	Ключовий колір:
 	Roundness:	Округлість:
 	Fixed	Фіксований
 	Pressure	Натиск
@@ -2752,6 +2783,23 @@
 	Add to Library	Додати до бібліотеки
 	Delete Library	Видалити бібліотеку
 	Delete Library Item	Видалити елемент бібліотеки
+	No results	Нічого не знайдено
+	No items in this library match “{query}”.	У цій бібліотеці немає елементів, що відповідають «{query}».
+	Right-click an item to move it into this group.	Клацніть елемент правою кнопкою миші, щоб перемістити його в цю групу.
+	New Group	Нова група
+	New Group…	Нова група…
+	Move to Group	Перемістити в групу
+	No Group	Без групи
+	Rename Group…	Перейменувати групу…
+	Delete Group	Видалити групу
+	Import Library…	Імпортувати бібліотеку…
+	Export Library…	Експортувати бібліотеку…
+	Import Library	Імпортувати бібліотеку
+	Export Library	Експортувати бібліотеку
+	New Library Group	Нова група бібліотеки
+	Rename Library Group	Перейменувати групу бібліотеки
+	Delete Library Group	Видалити групу бібліотеки
+	Move Library Item to Group	Перемістити елемент бібліотеки в групу
 	Library	Бібліотека
 	Rename Library	Перейменувати бібліотеку
 	Show Library	Показати бібліотеку
@@ -3468,7 +3516,6 @@ axis	Both	Обидві
 @msg	no bounds	немає кордонів
 @msg	no brush named `{name}`	немає пензля з ім’ям `{name}`
 @msg	no brush selected	пензель не вибрано
-@msg	this kind of brush has no options dialog yet	пензель цього типу ще не має вікна параметрів
 @msg	no catalog	немає каталогу
 @msg	no changes since the last save	немає змін з моменту останнього збереження
 @msg	no clock to keep a heartbeat by	немає годинника для підтримки сигналу
@@ -3854,3 +3901,14 @@ axis	Both	Обидві
 @msg	the PSD file is cut short	файл PSD обрізаний
 @msg	the PSD file's header is damaged	заголовок файлу PSD пошкоджено
 @msg	the PSD file's image data can't be read: {e}	не вдається прочитати дані зображення файлу PSD: {e}
+	Video	Відео
+	De-Interlace…	Усунення черезрядковості…
+	De-Interlace	Усунення черезрядковості
+	NTSC Colors	Кольори NTSC
+	Eliminate	Вилучити
+	Create New Fields by	Створити нові поля
+	Odd Fields	Непарні поля
+	Even Fields	Парні поля
+	Duplication	Дублюванням
+	Interpolation	Інтерполяцією
+@msg	Imported library {name}	Імпортовано бібліотеку {name}

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

@@ -1519,6 +1519,34 @@
 	New Bristle Brush	新建鬃毛画笔
 	Calligraphic Brush Options	书法画笔选项
 	Bristle Brush Options	鬃毛画笔选项
+	Scatter Brush Options	散布画笔选项
+	Art Brush Options	艺术画笔选项
+	Pattern Brush Options	图案画笔选项
+	Scatter:	散布：
+	Rotation:	旋转：
+	Rotation relative to:	旋转相对于：
+	Brush Scale Options	画笔缩放选项
+	Scale Proportionately	等比缩放
+	Stretch to Fit Stroke Length	伸展以适合描边长度
+	Stretch Between Guides	在参考线之间伸展
+	Start:	起点：
+	End:	终点：
+	Left to Right	从左到右
+	Right to Left	从右到左
+	Top to Bottom	从上到下
+	Bottom to Top	从下到上
+	Flip:	翻转：
+	Outer Corner Tile	外角拼贴
+	Side Tile	边线拼贴
+	Inner Corner Tile	内角拼贴
+	Start Tile	起点拼贴
+	End Tile	终点拼贴
+	Fit	适合
+	Stretch to fit	伸展以适合
+	Add space to fit	添加间距以适合
+	Approximate path	近似路径
+	Colorization	着色
+	Key Color:	主色：
 	Roundness:	圆度：
 	Fixed	固定
 	Pressure	压力
@@ -2652,6 +2680,23 @@
 	Add to Library	添加到库
 	Delete Library	删除库
 	Delete Library Item	删除库项目
+	No results	无结果
+	No items in this library match “{query}”.	此库中没有与“{query}”匹配的项目。
+	Right-click an item to move it into this group.	右键单击项目可将其移到此组。
+	New Group	新建组
+	New Group…	新建组…
+	Move to Group	移到组
+	No Group	无组
+	Rename Group…	重命名组…
+	Delete Group	删除组
+	Import Library…	导入库…
+	Export Library…	导出库…
+	Import Library	导入库
+	Export Library	导出库
+	New Library Group	新建库组
+	Rename Library Group	重命名库组
+	Delete Library Group	删除库组
+	Move Library Item to Group	将库项目移到组
 	Library	库
 	Rename Library	重命名库
 	Show Library	显示库
@@ -3504,3 +3549,13 @@ axis	Both	两者
 	Draft	草稿
 	Good	良好
 	Best	最佳
+	Video	视频
+	De-Interlace…	逐行…
+	De-Interlace	逐行
+	NTSC Colors	NTSC 颜色
+	Eliminate	消除
+	Create New Fields by	创建新场方式
+	Odd Fields	奇数场
+	Even Fields	偶数场
+	Duplication	复制
+	Interpolation	插值

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

@@ -1563,6 +1563,37 @@
 	New Bristle Brush	新增鬃毛筆刷
 	Calligraphic Brush Options	書法筆刷選項
 	Bristle Brush Options	鬃毛筆刷選項
+	Scatter Brush Options	散佈筆刷選項
+	Art Brush Options	藝術筆刷選項
+	Pattern Brush Options	圖樣筆刷選項
+	Scatter:	散佈：
+	Rotation:	旋轉：
+	Rotation relative to:	旋轉相對於：
+	Brush Scale Options	筆刷縮放選項
+	Scale Proportionately	等比例縮放
+	Stretch to Fit Stroke Length	延伸以符合筆畫長度
+	Stretch Between Guides	在參考線之間延伸
+	Start:	起點：
+	End:	終點：
+	Left to Right	由左至右
+	Right to Left	由右至左
+	Top to Bottom	由上而下
+	Bottom to Top	由下而上
+	Flip:	翻轉：
+	Outer Corner Tile	外角拼貼
+	Side Tile	邊線拼貼
+	Inner Corner Tile	內角拼貼
+	Start Tile	起點拼貼
+	End Tile	終點拼貼
+	Fit	符合
+	Stretch to fit	延伸以符合
+	Add space to fit	增加間距以符合
+	Approximate path	近似路徑
+	Colorization	上色
+	Tints	淺色
+	Tints and Shades	淺色與暗色
+	Hue Shift	色相偏移
+	Key Color:	主要顏色：
 	Roundness:	圓度：
 	Fixed	固定
 	Pressure	壓力
@@ -2738,6 +2769,23 @@
 	Add to Library	加入資料庫
 	Delete Library	刪除資料庫
 	Delete Library Item	刪除資料庫項目
+	No results	沒有結果
+	No items in this library match “{query}”.	此資料庫中沒有符合「{query}」的項目。
+	Right-click an item to move it into this group.	在項目上按一下右鍵，即可將其移至此群組。
+	New Group	新增群組
+	New Group…	新增群組…
+	Move to Group	移至群組
+	No Group	無群組
+	Rename Group…	重新命名群組…
+	Delete Group	刪除群組
+	Import Library…	匯入資料庫…
+	Export Library…	匯出資料庫…
+	Import Library	匯入資料庫
+	Export Library	匯出資料庫
+	New Library Group	新增資料庫群組
+	Rename Library Group	重新命名資料庫群組
+	Delete Library Group	刪除資料庫群組
+	Move Library Item to Group	將資料庫項目移至群組
 	Library	資料庫
 	Rename Library	重新命名資料庫
 	Show Library	顯示資料庫
@@ -3282,3 +3330,13 @@ axis	Both	兩者
 	Draft	草稿
 	Good	良好
 	Best	最佳
+	Video	視訊
+	De-Interlace…	反交錯…
+	De-Interlace	反交錯
+	NTSC Colors	NTSC 色彩
+	Eliminate	消除
+	Create New Fields by	建立新圖場以
+	Odd Fields	奇數圖場
+	Even Fields	偶數圖場
+	Duplication	複製
+	Interpolation	內插

crates/ui-egui/src/io.rs

@@ -15,8 +15,8 @@ use crate::{FilePick, Services, VectorcraftApp, dialogs};
 const TEMPLATE_EXTS: &[&str] = &["vctemplate", "ait", "vectorcraft", "drawcraft"];
 
 /// Open bytes of any readable format as a new document (templates open untitled); swatch and
-/// graphic style library files open in the library panel and flattener, PDF, print and perspective
-/// grid presets files are imported. → `document.open`'s result for a document opened now (its
+/// graphic style library files open in the library panel, Libraries panel files are added to it,
+/// and flattener, PDF, print and perspective grid presets files are imported. → `document.open`'s result for a document opened now (its
 /// `warnings` say what didn't come in as it was), else null.
 pub fn open_bytes(app: &mut VectorcraftApp, name: &str, bytes: &[u8], path: Option<String>) -> Result<Value, String> {
     let ext = fileio::extension(name);
@@ -39,6 +39,9 @@ pub fn open_bytes(app: &mut VectorcraftApp, name: &str, bytes: &[u8], path: Opti
         app.status(format!("Imported {what}: {}", names.join(", ")));
         return Ok(Value::Null);
     }
+    if vectorcraft_engine::cmd::library::LIBRARY_EXTS.contains(&ext.as_str()) {
+        return crate::panels::libraries::import(app, json!({"data": String::from_utf8_lossy(bytes)})).map(|_| Value::Null);
+    }
     let swatches = vectorcraft_engine::cmd::swatchlib::LIBRARY_EXTS.contains(&ext.as_str());
     if swatches || ext == vectorcraft_doc::style_libs::STYLES_EXT {
         let p = match path {

crates/ui-egui/src/menus.rs

@@ -346,7 +346,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "ui.brushOptions",
         "Brush Options…",
         "",
-        "{name?} (default: the selected path's brush, else the current brush) open its Brush Options, what double-clicking a brush in the Brushes panel opens: Calligraphic (dialog `brushOptions`, fields name, angle −180..180, roundness 0..100, size 0..1296 pt, angleMode/roundnessMode/sizeMode: fixed|random|pressure, angleVariation/roundnessVariation/sizeVariation) or Bristle (fields name, shape, size, length, density, thickness, opacity, stiffness); OK runs brush.options. Other brush types: error",
+        "{name?} (default: the selected path's brush, else the current brush) open its Brush Options, what double-clicking a brush in the Brushes panel opens (dialog `brushOptions`): Calligraphic (fields name, angle −180..180, roundness 0..100, size 0..1296 pt, angleMode/roundnessMode/sizeMode: fixed|random|pressure, angleVariation/roundnessVariation/sizeVariation), Bristle (fields name, shape, size, length, density, thickness, opacity, stiffness), Scatter (fields sizeMin/sizeMax/sizeMode, spacingMin/spacingMax/spacingMode, scatterMin/scatterMax/scatterMode, rotationMin/rotationMax/rotationMode with modes fixed|random|pressure, rotationRelativeTo: page|path), Art (fields width %, scaleMode: proportional|stretch|betweenGuides, guideStart/guideEnd % of the art length, direction: leftToRight|rightToLeft|topToBottom|bottomToTop, flipAlong, flipAcross) or Pattern (fields scale %, spacing %, fit: stretch|addSpace|approximate, flipAlong, flipAcross); Scatter, Art and Pattern also colorization: none|tints|tintsAndShades|hueShift and keyColor; OK runs brush.options",
     ),
     (
         "ui.graphicStyleOptions",
@@ -3305,8 +3305,8 @@ fn font_items(english_names: bool) -> Vec<Item> {
 
 /// The raster effects' submenus of the Effect menu (the Photoshop-style effects, below the
 /// vector effects): (submenu, the catalogue's menu path of its effects).
-const RASTER_MENUS: [(&str, &[&str]); 3] =
-    [("Blur", &["Effect", "Blur"]), ("Pixelate", &["Effect", "Pixelate"]), ("Sharpen", &["Effect", "Sharpen"])];
+const RASTER_MENUS: [(&str, &[&str]); 4] =
+    [("Blur", &["Effect", "Blur"]), ("Pixelate", &["Effect", "Pixelate"]), ("Sharpen", &["Effect", "Sharpen"]), ("Video", &["Effect", "Video"])];
 
 /// The Effect menu, built from the effects catalogue (vector effects), plus raster effects.
 fn effect_menu() -> Vec<Item> {

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

@@ -89,7 +89,6 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
             if group.is_empty() {
                 continue;
             }
-            let has_options = brush_options::TYPES.contains(&ty);
             let row = |ui: &mut Ui, name: &str, size: egui::Vec2, label: bool| -> egui::Response {
                 let (r, resp) = ui.allocate_exact_size(size, Sense::click_and_drag());
                 // Dragged onto a path, the brush is applied to it.
@@ -121,7 +120,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
             };
             // A click applies the brush; the second click of a double-click opens its options.
             let mut pick = |resp: egui::Response, name: &String| {
-                if resp.double_clicked() && has_options {
+                if resp.double_clicked() {
                     options = Some(name.clone());
                 } else if resp.clicked() {
                     clicked = Some(name.clone());

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

@@ -4,16 +4,20 @@
 //! graphic, fill or stroke colour or text styles. A colour click paints the selection through the
 //! active Fill/Stroke proxy, a style click applies it to the selected type, and a graphic is
 //! dragged onto the canvas (or double-clicked) to place a copy. Libraries are kept on this machine.
+//!
+//! The search field filters the items by name; items can be moved into user-named groups, shown as
+//! collapsible sections after the ungrouped items; and the panel menu exports the library to a
+//! `.vclibrary` file and imports one as a new library (#926).
 
 use std::collections::HashMap;
 
 use egui::{Rect, Sense, Stroke, StrokeKind, Ui, vec2};
 use serde_json::{Value, json};
 use vectorcraft_color::Paint;
-use vectorcraft_engine::cmd::library::Library;
+use vectorcraft_engine::cmd::library::{ItemKind, LIBRARY_EXT, LIBRARY_EXTS, Library, LibraryGraphic};
 
 use crate::theme::Tokens;
-use crate::widgets::{self, PanelDrag, menu_item};
+use crate::widgets::{self, PanelDrag, menu_item, menu_item_name};
 use crate::{VectorcraftApp, icons};
 
 /// The size of a graphic's tile.
@@ -21,20 +25,28 @@ const TILE: f32 = 56.0;
 /// The size of a colour chip.
 const CHIP: f32 = 22.0;
 
-/// The current library: its id and a copy of it (the panel acts on it after reading).
+/// The current library: its id and a copy of it (the panel menu acts on it after reading).
 fn current(app: &VectorcraftApp) -> Option<(String, Library)> {
     let libs = &app.session.libraries;
     let id = libs.current()?;
     Some((id.to_string(), libs.get(id)?.clone()))
 }
 
-/// Run `cmd`, reporting a failure in the status bar.
-fn run(app: &mut VectorcraftApp, cmd: &str, p: Value) {
-    if let Err(e) = app.run(cmd, p) {
+/// Report a failure in the status bar (a file dialog closed or still open says nothing).
+fn report<T>(app: &mut VectorcraftApp, r: Result<T, String>) {
+    if let Err(e) = r
+        && e != "cancelled"
+    {
         app.status(e);
     }
 }
 
+/// Run `cmd`, reporting a failure in the status bar.
+fn run(app: &mut VectorcraftApp, cmd: &str, p: Value) {
+    let r = app.run(cmd, p);
+    report(app, r);
+}
+
 /// The name dialog for a new library, or for renaming the current one.
 fn ask_name(app: &mut VectorcraftApp, rename: Option<&str>) {
     let (cmd, label, name) = match rename {
@@ -44,9 +56,46 @@ fn ask_name(app: &mut VectorcraftApp, rename: Option<&str>) {
     app.ui.dialog = Some(crate::state::Dialog::new("command", json!({ "__command": cmd, "__label": label, "name": name })));
 }
 
+/// The name dialog for a new group of `library` (`items`: `[{kind, item}]` moved into it), or for
+/// renaming group `rename`.
+fn ask_group_name(app: &mut VectorcraftApp, library: &str, rename: Option<&str>, items: Value) {
+    let (cmd, label, name, fixed) = match rename {
+        Some(g) => ("library.renameGroup", "Rename Library Group", g, json!({ "library": library, "group": g })),
+        None => ("library.createGroup", "New Library Group", "Group", json!({ "library": library, "items": items })),
+    };
+    let d = json!({ "__command": cmd, "__label": label, "name": name, "__params": fixed });
+    app.ui.dialog = Some(crate::state::Dialog::new("command", d));
+}
+
+/// What a click in the panel asks for, done once the list is drawn.
+enum Act {
+    Run(&'static str, Value),
+    /// The New Group dialog; the items (`[{kind, item}]`) go into the new group.
+    NewGroup(Value),
+    RenameGroup(String),
+}
+
+/// What the item list draws from.
+struct Items<'a> {
+    library: &'a str,
+    lib: &'a Library,
+    /// The group of each grouped item ([`Library::group_index`]).
+    groups: HashMap<(ItemKind, &'a str), usize>,
+    fill_active: bool,
+}
+
+impl Items<'_> {
+    fn group_of(&self, kind: ItemKind, key: &str) -> Option<usize> {
+        self.groups.get(&(kind, key)).copied()
+    }
+}
+
 pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
-    let Some((lib_id, lib)) = current(app) else {
+    let fill_active = app.session.fill_active;
+    let has_doc = app.session.active().is_some();
+    let libs = &app.session.libraries;
+    let Some((lib_id, lib)) = libs.current().and_then(|id| Some((id.to_string(), libs.get(id)?))) else {
         ui.add_space(16.0);
         ui.vertical_centered(|ui| {
             icons::icon(ui, "library", 40.0, t.text_dim);
@@ -60,18 +109,27 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
         });
         return;
     };
+    let mut act: Option<Act> = None;
     // The library picker.
-    let libs: Vec<(String, String)> = app.session.libraries.all().iter().map(|(i, l)| (i.clone(), l.name.clone())).collect();
-    let names: Vec<&str> = libs.iter().map(|(_, n)| n.as_str()).collect();
-    if let Some(i) = widgets::dropdown_names(ui, "lib-picker", &lib.name, &names, ui.available_width())
-        && let Some((id, _)) = libs.get(i)
-    {
-        run(app, "library.setCurrent", json!({ "library": id }));
+    let names: Vec<&str> = libs.all().iter().map(|(_, l)| l.name.as_str()).collect();
+    if let Some((id, _)) = widgets::dropdown_names(ui, "lib-picker", &lib.name, &names, ui.available_width()).and_then(|i| libs.all().get(i)) {
+        act = Some(Act::Run("library.setCurrent", json!({ "library": id })));
+    }
+    ui.add_space(4.0);
+    let empty = lib.items().next().is_none() && lib.groups.is_empty();
+    let query = if empty { String::new() } else { widgets::search_field(ui, egui::Id::new("library-search"), tl!("Search")) };
+    let query = query.trim().to_lowercase();
+    let searching = !query.is_empty();
+    let shown = |name: &str| !searching || name.to_lowercase().contains(&query);
+    let items = Items { library: &lib_id, lib, groups: lib.group_index(), fill_active };
+    // The items shown in each section: the ungrouped ones first, then each group's.
+    let mut counts = vec![0usize; lib.groups.len() + 1];
+    for (kind, key, _) in lib.items().filter(|(_, _, name)| shown(name)) {
+        if let Some(n) = counts.get_mut(items.group_of(kind, key).map_or(0, |i| i + 1)) {
+            *n += 1;
+        }
     }
     ui.add_space(4.0);
-    let empty = lib.colors.is_empty() && lib.char_styles.is_empty() && lib.para_styles.is_empty() && lib.graphics.is_empty();
-    let mut act: Option<(&'static str, Value)> = None;
-    let fill_active = app.session.fill_active;
     let list_rect = widgets::list_box(ui, |ui| {
         ui.set_min_height(140.0);
         ui.set_width(ui.available_width());
@@ -84,101 +142,53 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
             );
             return ui.min_rect();
         }
+        if searching && counts.iter().all(|n| *n == 0) {
+            let body = crate::i18n::fmt(tl!("No items in this library match “{query}”."), &[("query", &query)]);
+            super::empty_state(ui, "search", tl!("No results"), &body);
+            return ui.min_rect();
+        }
         egui::Frame::NONE.inner_margin(egui::Margin::same(6)).show(ui, |ui| {
-            if !lib.colors.is_empty() {
-                heading(ui, tl!("Colors"));
-                ui.horizontal_wrapped(|ui| {
-                    ui.spacing_mut().item_spacing = vec2(4.0, 4.0);
-                    for c in &lib.colors {
-                        let (r, resp) = ui.allocate_exact_size(vec2(CHIP, CHIP), Sense::click_and_drag());
-                        let paint = Paint::solid(c.color);
-                        widgets::swatch_tile(ui, r, &paint, false, false);
-                        ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, t.border), StrokeKind::Inside);
-                        widgets::drag_source(ui, &resp, || PanelDrag::Paint {
-                            paint: paint.clone(),
-                            params: json!({ "color": c.color }),
-                            rows: None,
-                        });
-                        let resp = resp.on_hover_text(&c.name);
-                        if resp.clicked() {
-                            act = Some((
-                                "library.use",
-                                json!({ "kind": "fillColor", "item": c.name, "to": if fill_active { "fill" } else { "stroke" } }),
-                            ));
-                        }
-                        resp.context_menu(|ui| {
-                            if menu_item(ui, "Delete", true, false) {
-                                act = Some(("library.removeItem", json!({ "kind": "fillColor", "item": c.name })));
-                                ui.close();
-                            }
-                        });
-                    }
-                });
-                ui.add_space(6.0);
-            }
-            for (para, list, title) in [(false, &lib.char_styles, tl!("Character Styles")), (true, &lib.para_styles, tl!("Paragraph Styles"))] {
-                if list.is_empty() {
+            items.show(ui, &mut act, |kind, key, name| items.group_of(kind, key).is_none() && shown(name));
+            for (i, g) in lib.groups.iter().enumerate() {
+                let n = counts.get(i + 1).copied().unwrap_or_default();
+                if searching && n == 0 {
                     continue;
                 }
-                heading(ui, title);
-                let kind = if para { "paraStyle" } else { "charStyle" };
-                for st in list {
-                    let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), Sense::click());
-                    if resp.hovered() {
-                        ui.painter().rect_filled(r, 0.0, t.hover);
-                    }
-                    icons::paint(
-                        ui,
-                        if para { "pilcrow" } else { "type" },
-                        Rect::from_center_size(r.left_center() + vec2(10.0, 0.0), vec2(14.0, 14.0)),
-                        t.icon,
-                    );
-                    ui.painter().text(
-                        r.left_center() + vec2(24.0, 0.0),
-                        egui::Align2::LEFT_CENTER,
-                        &st.name,
-                        egui::FontId::proportional(12.5),
-                        t.text,
-                    );
-                    let resp = resp.on_hover_text(tl!("Click to apply to the selected type"));
-                    if resp.clicked() {
-                        act = Some(("library.use", json!({ "kind": kind, "item": st.name })));
-                    }
-                    resp.context_menu(|ui| {
-                        if menu_item(ui, "Delete", true, false) {
-                            act = Some(("library.removeItem", json!({ "kind": kind, "item": st.name })));
-                            ui.close();
-                        }
-                    });
+                // Open unless closed; open while searching, to show what matched.
+                let key = format!("library-group-closed:{lib_id}:{}", g.name);
+                let closed: bool = super::pstate(ui.ctx(), &key);
+                let open = searching || !closed;
+                let header = widgets::section_toggle_name(ui, &g.name, open);
+                ui.painter().text(
+                    header.rect.right_center() - vec2(6.0, 0.0),
+                    egui::Align2::RIGHT_CENTER,
+                    n.to_string(),
+                    egui::FontId::proportional(11.5),
+                    t.text_dim,
+                );
+                if header.clicked() && !searching {
+                    super::set_pstate(ui.ctx(), &key, !closed);
                 }
-                ui.add_space(6.0);
-            }
-            if !lib.graphics.is_empty() {
-                heading(ui, tl!("Graphics"));
-                ui.horizontal_wrapped(|ui| {
-                    ui.spacing_mut().item_spacing = vec2(4.0, 4.0);
-                    for g in &lib.graphics {
-                        let (r, resp) = ui.allocate_exact_size(vec2(TILE, TILE), Sense::click_and_drag());
-                        tile(ui, r, &lib_id, g);
-                        ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, if resp.hovered() { t.accent } else { t.border }), StrokeKind::Inside);
-                        // Dragged onto the canvas, a copy is placed where it is dropped.
-                        widgets::drag_source(ui, &resp, || PanelDrag::LibraryGraphic { library: lib_id.clone(), item: g.id.clone() });
-                        let resp = resp.on_hover_text(&g.name);
-                        if resp.double_clicked() {
-                            act = Some(("library.use", json!({ "kind": "graphic", "item": g.id })));
-                        }
-                        resp.context_menu(|ui| {
-                            if menu_item(ui, "Place", true, false) {
-                                act = Some(("library.use", json!({ "kind": "graphic", "item": g.id })));
-                                ui.close();
-                            }
-                            if menu_item(ui, "Delete", true, false) {
-                                act = Some(("library.removeItem", json!({ "kind": "graphic", "item": g.id })));
-                                ui.close();
-                            }
-                        });
+                header.context_menu(|ui| {
+                    if menu_item(ui, "Rename Group…", true, false) {
+                        act = Some(Act::RenameGroup(g.name.clone()));
+                        ui.close();
+                    }
+                    if menu_item(ui, "Delete Group", true, false) {
+                        act = Some(Act::Run("library.deleteGroup", json!({ "group": g.name })));
+                        ui.close();
                     }
                 });
+                if !open {
+                    continue;
+                }
+                ui.add_space(2.0);
+                if n == 0 {
+                    ui.label(egui::RichText::new(tl!("Right-click an item to move it into this group.")).size(11.5).color(t.text_dim));
+                    ui.add_space(6.0);
+                } else {
+                    items.show(ui, &mut act, |kind, key, name| items.group_of(kind, key) == Some(i) && shown(name));
+                }
             }
         });
         ui.min_rect()
@@ -186,7 +196,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
     // Art dragged off the canvas, or a swatch, dropped on the list is added to the library.
     let zone = ui.interact(list_rect, ui.id().with("libraries-drop"), Sense::hover());
     if let Some(ids) = widgets::art_drop(ui, &zone) {
-        act = Some(("library.add", json!({ "kind": "graphic", "ids": ids })));
+        act = Some(Act::Run("library.add", json!({ "kind": "graphic", "ids": ids })));
     }
     if let Some(drag) = zone.dnd_hover_payload::<PanelDrag>()
         && let PanelDrag::Paint { paint: Paint::Solid { color, .. }, .. } = &*drag
@@ -194,21 +204,13 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
         ui.painter().rect_stroke(zone.rect, 0.0, Stroke::new(1.5, t.accent), StrokeKind::Inside);
         let color = *color;
         if zone.dnd_release_payload::<PanelDrag>().is_some() {
-            act = Some(("library.add", json!({ "kind": "fillColor", "color": color })));
+            act = Some(Act::Run("library.add", json!({ "kind": "fillColor", "color": color })));
         }
     }
-    if let Some((cmd, mut p)) = act {
-        p["library"] = json!(lib_id);
-        if cmd == "library.use" && p["kind"] == "graphic" {
-            // Placed at the centre of the view.
-            if let Some(v) = app.view() {
-                p["center"] = json!([v.center.x, v.center.y]);
-            }
-        }
-        run(app, cmd, p);
-    }
-    let has_doc = app.session.active().is_some();
     widgets::bottom_bar(ui, |ui| {
+        if widgets::icon_button(ui, "group", tl!("New Group"), false, 24.0).clicked() {
+            act = Some(Act::NewGroup(json!([])));
+        }
         let add = widgets::icon_button_enabled(ui, "plus", tl!("Add Content"), false, has_doc, 24.0);
         egui::Popup::menu(&add).show(|ui| {
             for (label, kind) in [
@@ -219,12 +221,154 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
                 ("Paragraph Style", "paraStyle"),
             ] {
                 if menu_item(ui, label, true, false) {
-                    run(app, "library.add", json!({ "library": lib_id, "kind": kind }));
+                    act = Some(Act::Run("library.add", json!({ "kind": kind })));
                     ui.close();
                 }
             }
         });
     });
+    match act {
+        Some(Act::Run(cmd, mut p)) => {
+            if cmd != "library.setCurrent" {
+                p["library"] = json!(lib_id);
+            }
+            if cmd == "library.use" && p["kind"] == "graphic" {
+                // Placed at the centre of the view.
+                if let Some(v) = app.view() {
+                    p["center"] = json!([v.center.x, v.center.y]);
+                }
+            }
+            run(app, cmd, p);
+        }
+        Some(Act::NewGroup(items)) => ask_group_name(app, &lib_id, None, items),
+        Some(Act::RenameGroup(g)) => ask_group_name(app, &lib_id, Some(&g), Value::Null),
+        None => {}
+    }
+}
+
+impl Items<'_> {
+    /// The colours, character and paragraph styles and graphics `keep` keeps (given the kind, key
+    /// and name of each), each kind under its heading.
+    fn show(&self, ui: &mut Ui, act: &mut Option<Act>, keep: impl Fn(ItemKind, &str, &str) -> bool) {
+        let t = Tokens::get(ui.ctx());
+        let lib = self.lib;
+        let colors: Vec<_> = lib.colors.iter().filter(|c| keep(ItemKind::Color, &c.name, &c.name)).collect();
+        if !colors.is_empty() {
+            heading(ui, tl!("Colors"));
+            ui.horizontal_wrapped(|ui| {
+                ui.spacing_mut().item_spacing = vec2(4.0, 4.0);
+                for c in colors {
+                    let (r, resp) = ui.allocate_exact_size(vec2(CHIP, CHIP), Sense::click_and_drag());
+                    let paint = Paint::solid(c.color);
+                    widgets::swatch_tile(ui, r, &paint, false, false);
+                    ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, t.border), StrokeKind::Inside);
+                    widgets::drag_source(ui, &resp, || PanelDrag::Paint { paint: paint.clone(), params: json!({ "color": c.color }), rows: None });
+                    let resp = resp.on_hover_text(&c.name);
+                    if resp.clicked() {
+                        let to = if self.fill_active { "fill" } else { "stroke" };
+                        *act = Some(Act::Run("library.use", json!({ "kind": "fillColor", "item": c.name, "to": to })));
+                    }
+                    resp.context_menu(|ui| self.item_menu(ui, act, ItemKind::Color, &c.name));
+                }
+            });
+            ui.add_space(6.0);
+        }
+        for (kind, list, title) in
+            [(ItemKind::CharStyle, &lib.char_styles, tl!("Character Styles")), (ItemKind::ParaStyle, &lib.para_styles, tl!("Paragraph Styles"))]
+        {
+            let list: Vec<_> = list.iter().filter(|s| keep(kind, &s.name, &s.name)).collect();
+            if list.is_empty() {
+                continue;
+            }
+            heading(ui, title);
+            for st in list {
+                let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), Sense::click());
+                if resp.hovered() {
+                    ui.painter().rect_filled(r, 0.0, t.hover);
+                }
+                let icon = if kind == ItemKind::ParaStyle { "pilcrow" } else { "type" };
+                icons::paint(ui, icon, Rect::from_center_size(r.left_center() + vec2(10.0, 0.0), vec2(14.0, 14.0)), t.icon);
+                ui.painter().text(r.left_center() + vec2(24.0, 0.0), egui::Align2::LEFT_CENTER, &st.name, egui::FontId::proportional(12.5), t.text);
+                let resp = resp.on_hover_text(tl!("Click to apply to the selected type"));
+                if resp.clicked() {
+                    *act = Some(Act::Run("library.use", json!({ "kind": kind_param(kind), "item": st.name })));
+                }
+                resp.context_menu(|ui| self.item_menu(ui, act, kind, &st.name));
+            }
+            ui.add_space(6.0);
+        }
+        let graphics: Vec<_> = lib.graphics.iter().filter(|g| keep(ItemKind::Graphic, &g.id, &g.name)).collect();
+        if !graphics.is_empty() {
+            heading(ui, tl!("Graphics"));
+            ui.horizontal_wrapped(|ui| {
+                ui.spacing_mut().item_spacing = vec2(4.0, 4.0);
+                for g in graphics {
+                    let (r, resp) = ui.allocate_exact_size(vec2(TILE, TILE), Sense::click_and_drag());
+                    tile(ui, r, self.library, g);
+                    ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, if resp.hovered() { t.accent } else { t.border }), StrokeKind::Inside);
+                    // Dragged onto the canvas, a copy is placed where it is dropped.
+                    widgets::drag_source(ui, &resp, || PanelDrag::LibraryGraphic { library: self.library.to_string(), item: g.id.clone() });
+                    let resp = resp.on_hover_text(&g.name);
+                    let place = || Act::Run("library.use", json!({ "kind": "graphic", "item": g.id }));
+                    if resp.double_clicked() {
+                        *act = Some(place());
+                    }
+                    resp.context_menu(|ui| {
+                        if menu_item(ui, "Place", true, false) {
+                            *act = Some(place());
+                            ui.close();
+                        }
+                        self.item_menu(ui, act, ItemKind::Graphic, &g.id);
+                    });
+                }
+            });
+            ui.add_space(6.0);
+        }
+    }
+
+    /// An item's context menu entries: Move to Group (No Group, the library's groups, New
+    /// Group…) and Delete.
+    fn item_menu(&self, ui: &mut Ui, act: &mut Option<Act>, kind: ItemKind, key: &str) {
+        let at = self.group_of(kind, key);
+        let item = json!({ "kind": kind_param(kind), "item": key });
+        ui.menu_button(format!("   {}", tl!("Move to Group")), |ui| {
+            if menu_item(ui, "No Group", true, at.is_none()) {
+                if at.is_some() {
+                    *act = Some(Act::Run("library.moveItem", item.clone()));
+                }
+                ui.close();
+            }
+            for (i, g) in self.lib.groups.iter().enumerate() {
+                if menu_item_name(ui, &g.name, true, at == Some(i)) {
+                    if at != Some(i) {
+                        let mut p = item.clone();
+                        p["group"] = json!(g.name);
+                        *act = Some(Act::Run("library.moveItem", p));
+                    }
+                    ui.close();
+                }
+            }
+            ui.separator();
+            if menu_item(ui, "New Group…", true, false) {
+                *act = Some(Act::NewGroup(json!([item])));
+                ui.close();
+            }
+        });
+        if menu_item(ui, "Delete", true, false) {
+            *act = Some(Act::Run("library.removeItem", item));
+            ui.close();
+        }
+    }
+}
+
+/// `kind` as the `library.*` commands' `kind` param (a colour as a fill colour).
+fn kind_param(kind: ItemKind) -> &'static str {
+    match kind {
+        ItemKind::Graphic => "graphic",
+        ItemKind::CharStyle => "charStyle",
+        ItemKind::ParaStyle => "paraStyle",
+        ItemKind::Color | ItemKind::Unknown => "fillColor",
+    }
 }
 
 /// A section heading in the list.
@@ -235,7 +379,7 @@ fn heading(ui: &mut Ui, text: &str) {
 }
 
 /// Graphic `g`'s thumbnail on white in `r`.
-fn tile(ui: &Ui, r: Rect, library: &str, g: &vectorcraft_engine::cmd::library::LibraryGraphic) {
+fn tile(ui: &Ui, r: Rect, library: &str, g: &LibraryGraphic) {
     ui.painter().rect_filled(r, 0.0, egui::Color32::WHITE);
     if let Some(tex) = thumbnail(ui.ctx(), library, g) {
         let size = tex.size_vec2();
@@ -246,7 +390,7 @@ fn tile(ui: &Ui, r: Rect, library: &str, g: &vectorcraft_engine::cmd::library::L
 }
 
 /// The texture of graphic `g`'s PNG thumbnail, decoded once.
-fn thumbnail(ctx: &egui::Context, library: &str, g: &vectorcraft_engine::cmd::library::LibraryGraphic) -> Option<egui::TextureHandle> {
+fn thumbnail(ctx: &egui::Context, library: &str, g: &LibraryGraphic) -> Option<egui::TextureHandle> {
     thread_local! {
         static CACHE: crate::graphics::TexCache<HashMap<(String, String, usize), Option<egui::TextureHandle>>> = crate::graphics::TexCache::default();
     }
@@ -278,7 +422,37 @@ pub(crate) fn chip(app: &VectorcraftApp, ui: &Ui, r: Rect, library: &str, item:
     }
 }
 
-/// The panel's ≡ menu: Create New Library, Rename Library…, Delete Library.
+/// Import a library file (`library.import`'s params), saying so in the status bar.
+pub(crate) fn import(app: &mut VectorcraftApp, p: Value) -> Result<Value, String> {
+    let r = app.run("library.import", p)?;
+    let name = r["name"].as_str().unwrap_or_default().to_string();
+    app.status(format!("Imported library {name}"));
+    Ok(r)
+}
+
+/// Import Library…: a picked `.vclibrary` file becomes a new library (on the web the picked file
+/// arrives later through [`crate::io::open_bytes`]).
+fn import_picked(app: &mut VectorcraftApp) {
+    if let Some(f) = app.services.open_async.as_mut() {
+        f();
+        return;
+    }
+    let pick = crate::FilePick { filters: vec![("Libraries", LIBRARY_EXTS)], ..Default::default() };
+    if let Some(path) = crate::picks::open(app, &pick) {
+        let r = import(app, json!({ "path": path }));
+        report(app, r);
+    }
+}
+
+/// Export Library…: library `id` written to a picked file named after it (the web downloads it).
+fn export_picked(app: &mut VectorcraftApp, id: &str, name: &str) {
+    let file = format!("{}.{LIBRARY_EXT}", vectorcraft_engine::cmd::library::file_stem_for(name));
+    let r = crate::io::save_command_output_named(app, "library.export", &file, json!({ "library": id }));
+    report(app, r);
+}
+
+/// The panel's ≡ menu: Create New Library, Rename Library…, Delete Library, New Group…, Import
+/// Library…, Export Library….
 pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
     let cur = current(app);
     if menu_item(ui, "Create New Library…", true, false) {
@@ -304,6 +478,24 @@ pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
         );
         ui.close();
     }
+    ui.separator();
+    if menu_item(ui, "New Group…", cur.is_some(), false)
+        && let Some((id, _)) = &cur
+    {
+        ask_group_name(app, id, None, json!([]));
+        ui.close();
+    }
+    ui.separator();
+    if menu_item(ui, "Import Library…", true, false) {
+        crate::picks::button(app, import_picked);
+        ui.close();
+    }
+    if menu_item(ui, "Export Library…", cur.is_some(), false)
+        && let Some((id, lib)) = cur
+    {
+        crate::picks::button(app, move |app| export_picked(app, &id, &lib.name));
+        ui.close();
+    }
 }
 
 #[cfg(test)]
@@ -315,6 +507,7 @@ mod tests {
 
     fn frame(app: &mut VectorcraftApp) {
         let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx);
         let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
             show(app, ui);
             menu(app, ui);
@@ -345,4 +538,94 @@ mod tests {
         let ctx = egui::Context::default();
         assert!(thumbnail(&ctx, "Brand", &lib.graphics[0]).is_some());
     }
+
+    /// The panel's text: every label it shows in one frame (`query` typed in the search field).
+    fn texts(app: &mut VectorcraftApp, query: &str) -> Vec<String> {
+        let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx);
+        ctx.data_mut(|d| d.insert_temp(egui::Id::new("library-search"), query.to_string()));
+        let mut shapes = vec![];
+        let mut out = ctx.run_ui(egui::RawInput::default(), |ui| show(app, ui));
+        out.textures_delta.clear();
+        shapes.append(&mut out.shapes);
+        let mut texts = vec![];
+        for s in shapes {
+            if let egui::epaint::Shape::Text(t) = s.shape {
+                texts.push(t.galley.text().to_string());
+            }
+        }
+        texts
+    }
+
+    /// The search field filters items by name, ignoring case; groups show after the ungrouped
+    /// items, and a search nothing matches says so (#926).
+    #[test]
+    fn the_panel_searches_and_shows_groups() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
+        app.run("library.create", json!({"name": "Brand"})).unwrap();
+        for (name, color) in [("Ocean Blue", "#0044aa"), ("Sun Yellow", "#ffcc00")] {
+            app.run("library.add", json!({"kind": "fillColor", "color": color, "name": name})).unwrap();
+        }
+        let t = app.run("text.create", json!({"x": 10, "y": 80, "text": "Type"})).unwrap()["id"].clone();
+        app.run("select.set", json!({"ids": [t]})).unwrap();
+        app.run("library.add", json!({"kind": "charStyle", "name": "Headline"})).unwrap();
+        app.run("library.createGroup", json!({"name": "Warm", "items": [{"kind": "fillColor", "item": "Sun Yellow"}]})).unwrap();
+        let all = texts(&mut app, "");
+        let at = |s: &str| all.iter().position(|t| t == s);
+        assert!(at("Headline").is_some() && at("Warm").is_some(), "{all:?}");
+        assert!(at("Headline") < at("Warm"), "groups come after the ungrouped items: {all:?}");
+        // "BLUE" finds the blue swatch only: the style and the group without a match are hidden.
+        let found = texts(&mut app, "BLUE");
+        assert!(!found.iter().any(|t| t == "Headline" || t == "Warm"), "{found:?}");
+        let found = texts(&mut app, "yellow");
+        assert!(found.iter().any(|t| t == "Warm") && !found.iter().any(|t| t == "Headline"), "{found:?}");
+        let none = texts(&mut app, "zzz");
+        assert!(none.iter().any(|t| t == "No results"), "{none:?}");
+    }
+
+    /// New Group… and Rename Group… ask for a name and act on the library and group they came
+    /// from; the dialog shows only the name.
+    #[test]
+    fn group_dialogs_run_with_their_library_and_group() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
+        let lib = app.run("library.create", json!({"name": "Brand"})).unwrap()["id"].as_str().unwrap().to_string();
+        app.run("library.add", json!({"kind": "fillColor", "color": "#0044aa", "name": "Blue"})).unwrap();
+        ask_group_name(&mut app, &lib, None, json!([{"kind": "fillColor", "item": "Blue"}]));
+        app.ui.dialog.as_mut().unwrap().fields.insert("name".into(), json!("Cool"));
+        crate::dialogs::confirm(&mut app).unwrap();
+        ask_group_name(&mut app, &lib, Some("Cool"), Value::Null);
+        app.ui.dialog.as_mut().unwrap().fields.insert("name".into(), json!("Cold"));
+        crate::dialogs::confirm(&mut app).unwrap();
+        let got = app.run("library.get", json!({})).unwrap();
+        assert_eq!(got["groups"], json!([{"name": "Cold", "items": [{"kind": "color", "item": "Blue"}]}]));
+    }
+
+    /// Export Library… writes the library's file and Import Library… adds it back as a new library.
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn libraries_are_exported_and_imported_from_the_panel_menu() {
+        let dir = vectorcraft_testkit::temp_dir("libraries-panel");
+        let path = dir.join("Brand.vclibrary").to_string_lossy().to_string();
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
+        app.run("library.create", json!({"name": "Brand"})).unwrap();
+        app.run("library.add", json!({"kind": "fillColor", "color": "#0044aa", "name": "Blue"})).unwrap();
+        let picked = path.clone();
+        app.services.pick_save = Some(Box::new(move |pick: &crate::FilePick| {
+            assert_eq!(pick.name, "Brand.vclibrary", "the library's name suggested");
+            Some(picked.clone())
+        }));
+        app.services.write = Some(Box::new(|p: &str, bytes: &[u8]| std::fs::write(p, bytes).map_err(|e| e.to_string())));
+        export_picked(&mut app, "Brand", "Brand");
+        assert!(std::path::Path::new(&path).exists());
+        let picked = path.clone();
+        app.services.pick_open = Some(Box::new(move |_: &crate::FilePick| Some(picked.clone())));
+        import_picked(&mut app);
+        let list = app.run("library.list", json!({})).unwrap();
+        let names: Vec<&str> = list["libraries"].as_array().unwrap().iter().map(|l| l["name"].as_str().unwrap()).collect();
+        assert_eq!(names, ["Brand", "Brand (2)"]);
+        assert_eq!(app.ui.status, "Imported library Brand (2)");
+    }
 }

crates/ui-egui/src/tests_labels.rs

@@ -64,6 +64,20 @@ fn effect_menu_lists_the_pixelate_filters_between_blur_and_sharpen() {
     assert!(at("Blur") < at("Pixelate") && at("Pixelate") < at("Sharpen"));
 }
 
+/// Effect › Video, after Sharpen: De-Interlace opens its dialog, NTSC Colors (no options) applies.
+#[test]
+fn effect_menu_lists_the_video_filters_last() {
+    let app = app();
+    let entries = menus::menu_entries(&app);
+    let video: Vec<_> = entries.iter().filter(|e| e.path == ["Effect", "Video"]).collect();
+    let items: Vec<(&str, Option<&str>)> = video.iter().map(|e| (e.label.as_str(), e.command.as_deref())).collect();
+    assert_eq!(items, [("De-Interlace…", Some("effect.dialog")), ("NTSC Colors", Some("effect.apply"))]);
+    let raster: Vec<&str> =
+        entries.iter().filter_map(|e| e.path.get(1).filter(|_| e.path.len() == 2 && e.path[0] == "Effect")).map(String::as_str).collect();
+    let at = |name: &str| raster.iter().position(|s| *s == name).unwrap();
+    assert!(at("Sharpen") < at("Video"));
+}
+
 #[test]
 fn library_submenus_are_disabled_placeholders() {
     let app = app();

crates/ui-egui/src/widgets.rs

@@ -124,6 +124,12 @@ pub fn section_header(ui: &mut Ui, text: &str) {
 /// A collapsible section's header across the panel: a chevron (down while `open`) and `text`;
 /// a click anywhere on it toggles the section. Whether it was clicked.
 pub fn section_toggle(ui: &mut Ui, text: &str, open: bool) -> bool {
+    section_toggle_name(ui, tl!(text), open).clicked()
+}
+
+/// [`section_toggle`] for a name that is user data (a library group), shown as it is → its
+/// response (clicked: toggle; it takes a context menu).
+pub fn section_toggle_name(ui: &mut Ui, text: &str, open: bool) -> Response {
     let t = Tokens::get(ui.ctx());
     let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 24.0), Sense::click());
     if resp.hovered() {
@@ -131,9 +137,9 @@ pub fn section_toggle(ui: &mut Ui, text: &str, open: bool) -> bool {
     }
     let chevron = Rect::from_center_size(pos2(rect.left() + 8.0, rect.center().y), vec2(12.0, 12.0));
     icons::paint(ui, if open { "chevron-down" } else { "chevron-right" }, chevron, if resp.hovered() { t.text_strong } else { t.icon });
-    ui.painter().text(pos2(rect.left() + 18.0, rect.center().y), egui::Align2::LEFT_CENTER, tl!(text), theme::semibold(12.5), t.text);
-    resp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::CollapsingHeader, true, open, tl!(text)));
-    resp.on_hover_cursor(egui::CursorIcon::PointingHand).clicked()
+    ui.painter().text(pos2(rect.left() + 18.0, rect.center().y), egui::Align2::LEFT_CENTER, text, theme::semibold(12.5), t.text);
+    resp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::CollapsingHeader, true, open, text));
+    resp.on_hover_cursor(egui::CursorIcon::PointingHand)
 }
 
 /// Full-width 1 px divider with vertical margins.

docs/mcp.md

@@ -953,9 +953,26 @@ gives another colour merges into the document's), a colour paints the selection'
 to the document (numbered when its name is taken by other attributes) and applied to the selected text, each as one
 undo step. `library.removeItem {library?, kind, item}` removes one.
 
+Items can be put in user-named groups, which the panel shows as collapsible sections after the ungrouped items (its
+search field filters every item by name; `library.get` lists them all to filter). `library.createGroup {library?,
+name?, items?: [{kind, item}]}` makes one (a name another group has, ignoring case, gets a number) with those items
+moved into it; `library.renameGroup {library?, group, name}` renames one; `library.deleteGroup {library?, group}`
+deletes one, its items staying in the library ungrouped; and `library.moveItem {library?, kind, item, group?}` moves
+an item into a group (without `group`, out of its group). An item is in one group at most; `library.get` lists the
+groups as `groups: [{name, items: [{kind: "color"|"charStyle"|"paraStyle"|"graphic", item}]}]` (a graphic by its id).
+
+`library.export {library?, path?}` writes a library (its colours, styles, graphics with their art and thumbnails, and
+its groups) as a `.vclibrary` file, the JSON the library folder keeps (without `path`: `{data}`, the file's text).
+`library.import {path? | data? | dataBase64?, name?}` adds the library of such a file as a new library and makes it
+the current one; a name another library has gets a number (`Brand (2)`). Imported files are checked: at most 10,000
+items of each kind and 1,000 groups, names clipped and made unique, thumbnails kept only when they are small PNGs, and
+groups naming items that aren't there dropped. Files written before groups load as they are.
+
 ```json
 {"name":"run_command","arguments":{"command":"library.add","params":{"kind":"graphic","name":"Logo"}}}
 {"name":"run_command","arguments":{"command":"library.use","params":{"kind":"graphic","item":"Logo","center":[300,200]}}}
+{"name":"run_command","arguments":{"command":"library.createGroup","params":{"name":"Logos","items":[{"kind":"graphic","item":"Logo"}]}}}
+{"name":"run_command","arguments":{"command":"library.export","params":{"path":"/tmp/Brand.vclibrary"}}}
 ```
 
 ## Strokes on type
@@ -1380,7 +1397,7 @@ size. The journal entry of a scaling command records the `strokes` and `corners`
 
 ## Live Corners
 
-`object.setLiveShape {id?, ids?, radius?, kind?, corners?}` sets the corners of any path (one undo step): a live
+`object.setLiveShape {id?, ids?, radius?, kind?, corners?, items?}` sets the corners of any path (one undo step): a live
 rectangle's or polygon's, a star's, a pen path's. A corner is an anchor without handles between two straight sides
 (not an open path's ends, not a smooth anchor, not one the sides run straight on through). `radius` (pt) and `kind`
 (`round`, `invertedRound` or `chamfer`) go to the `corners` given, else to the corners holding a Direct-Selected
@@ -1396,9 +1413,10 @@ draws no larger than takes the cut halfway along the corner's shorter side (half
 same limit for its four corners), the corners stay circular through uneven scales (the radius scales by the mean scale,
 or keeps its size with Scale Corners off), 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. Dragging a corner widget
-rounds the corners whose widgets show (every corner, or the Direct-Selected ones), outlining in red those that reach
-their limit; the Selection tool shows the widgets of live rectangles and polygons, the Direct Selection tool those of
-any path. Alt-clicking one cycles their kind and double-clicking one opens Corners (`ui.corners {id?, corners?}`,
+rounds the corners whose widgets show (every corner, or the Direct-Selected ones) on every selected path at once,
+outlining in red those that reach their limit; the Selection tool shows the widgets of live rectangles and polygons,
+the Direct Selection tool those of any path. Several objects each with their own corners are one call:
+`items: [{id, corners?}]` in place of `ids` and `corners`. 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