Part of gap 2: Effect › Texture (Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass, Texturizer)

Six raster effects on the pixel-filter pipeline
(vectorcraft_effects::pixel::texture), under a new Effect › Texture
submenu between Sharpen and Video in the Raster Effects section:

- Craquelure (crackSpacing pt 2..100, default 15; crackDepth 0..10, 6;
  crackBrightness 0..10, 9): the object on relief plaster that cracks into
  plates about Crack Spacing apart (a Voronoi network over jittered points)
  and along the quarter, half and three-quarter contours of its softened
  tones. Depth sets how dark and wide the cracks are and how high the
  plates' bevels and the tones stand (lit from the top left); Brightness
  how brightly the surface is lit.
- Grain (intensity 0..100, 40; contrast 0..100, 50 = unchanged; grainType
  Regular, Soft, Sprinkles, Clumped, Contrasty, Enlarged, Stippled,
  Horizontal, Vertical, Speckle; default Regular): coloured 1-point grains,
  smooth ones, clumps, 2-point grains, streaks along rows or columns, dark
  specks; Sprinkles and Stippled use the background colour, white.
- Mosaic Tiles (tileSize pt 2..100, 12; groutWidth 1..15, 3; lightenGrout
  0..10, 9): irregular tiles bevelled at their edges, with sunken grout half
  a point wide per step, lightened as Lighten Grout says.
- Patchwork (squareSize pt 0..10, 4; relief 0..25, 8): squares filled with
  the colour around their centres, raised to heights that follow the
  highlights and shadows, a little more or less at random.
- Stained Glass (cellSize pt 2..50, 10; borderThickness 1..20, 4;
  lightIntensity 0..10, 3): single-coloured panes leaded in the foreground
  colour (black, half a point per step), lit from behind at the object's
  centre and fading out towards its corners (PixelSpace gains `extent`).
- Texturizer (texture Brick, Burlap, Canvas, Sandstone, default Canvas;
  scaling % 50..200, 100; relief 0..50, 4; lightDirection Bottom, Bottom
  Left, Left, Top Left, Top, Top Right, Right, Bottom Right, default Top;
  invert): the object on a surface in relief. The four surfaces are height
  fields generated in code (bricks in stretcher bond, plain weaves coarse
  and fine, octaves of smooth noise); no image files. Load Texture is left
  out.

Every pattern lies in document space around the object's centre, so the
result is the same at any zoom or raster resolution, moves with the object
and is identical on every redraw (hash noise of cell indices); slopes are
taken in document units. Work per pixel is bounded (a 5 x 5 cell search,
four or five height samples, box blurs); parameters are clamped to their
ranges and finite-checked. The Pixelate helpers (Place, the cell search,
the softened colours) are shared, Mezzotint uses the shared smooth noise,
and the effect dialogs' dropdowns translate their labels in an "effect"
context where the plain word means something else (Soft, Horizontal and
Vertical are type settings in Japanese and Chinese).

Catalogue rows with parameter docs, outsets and reaches, menu entries,
dropdowns (Grain Type, Texture, Light Direction), translations, tests
(parameters and clamping, cracks and contours, ten distinct grains, tiles
and grout, squares in relief, leaded panes and the centre light, the
textures lit and inverted, the same at twice the resolution and when
moved, canvas, multithreaded, PDF and SVG, the command sweep with junk
parameters, the dialogs and the menu) and ROADMAP.

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

Cargo.lock

@@ -4499,6 +4499,7 @@ dependencies = [
  "vectorcraft-effects",
  "vectorcraft-geom",
  "vectorcraft-metafile",
+ "vectorcraft-pdf",
  "vectorcraft-render",
  "vectorcraft-testkit",
  "vectorcraft-text",

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,10 +35,10 @@ 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 (~16 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, 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 |
+| **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 |
 | **Bundled content:** brush, symbol, style and swatch libraries | ~30% | Ours are original and generated in code, and far fewer than Illustrator ships; brush and symbol libraries are still missing |
 | **Performance** | unverified | Multithreaded, off-thread rendering and caches are in place. The last budget run (2026-10-01, loaded machine) measured 290 ms for a 50k-path fit against a 16 ms budget. Re-run `vectorcraft-cli perf` on an idle machine |
 | **Robustness** | good, new | ~2,840 tests, property tests, no panics in shipped code (lints, the `guard` safety net, import fuzzing), Data Recovery. Missing: a corpus of real-world files, Windows/Linux/browser QA |
@@ -53,13 +53,15 @@ 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 39 filters (Artistic, Brush Strokes, Distort,
+   Sketch, Stylize) 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, Texture › Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass and Texturizer (its
+   Brick, Burlap, Canvas and Sandstone surfaces made in code; Load Texture is missing) and Video › De-Interlace and
+   NTSC Colors; each new filter is now one function, a catalogue row, menu and translations. Parallelizes
+   well across agents. 20–33 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 +70,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 +142,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. Blank cells (an empty CSV cell or `null`) are values left out, not zeros: columns, bars and stacked segments skip them, lines and scatter lines break around them and the value axis ignores them, while area, pie and radar draw them as 0; a number in straight quotes is a label, and the data window writes it back quoted. 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 +164,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.
@@ -171,7 +175,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 - **Files (M4):**
   - `.vectorcraft` (lossless JSON, compressed, atomic saves, save down to v1), Save As with a format chooser, Save a Copy, Revert, templates, Data Recovery after a crash (browser tabs hold their copies with Web Locks too, so a background tab's copies are never taken for a crash's, and a tab repairs copies another removed when it resumes: #367), background save and export. The desktop app writes its warnings and errors (graphics adapter, a lost graphics device, panics the guard recovered from) to standard error and to `logs/vectorcraft.log` next to the preferences, the two previous runs kept and each file capped at 16 MiB, so a launch without a terminal still leaves something to attach to a bug report (#465).
   - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units (SVG type under a transform or `viewBox` scale opens at the size it draws at, the scale moved into its size, leading, baseline shift and strokes, a stretch, skew or rotation kept as its transform: #396; a top-level group with a clip path, such as a clipped Inkscape layer, opens as a layer with a clipping mask, its name kept: #420; hidden objects written hidden on Save and `convert`, and `data-*` attributes kept as the objects' own data: #522; top-level groups open as layers named from `data-name`, else the id, also when one more group (a transform on all the art, a `<switch>`) wraps them, hidden ones hidden, and a file whose art sits loose under a root `<svg>` with an id (or `data-name`), as one-layer exports write it, opens with its one layer named from it; nested groups stay groups, except the sublayers VectorCraft writes, marked `data-vc-layer`, and Inkscape sublayers, which open as sublayers in their layer's colour: #372); PDF and PDF-compatible `.ai` in and out (layers, with hidden ones kept hidden with their art and nested ones as sublayers, on pages of up to 64 million operators, art whose layer can't be told going to a hidden, non-printing layer rather than showing or printing: #419; strokes kept live, a fill and a stroke of one outline as one object; a type object's stroke written as each glyph's outline stroked back on the type, so it stays one editable object; lines wrapped in a frame (each wrapped line ending in a space, one left edge, leading and font) back as one area type object, left aligned or justified with its paragraph spacing, where laying it out breaks the lines where the file does; glyphs set apart by gaps wider than a space (a barcode's digit groups) keeping their places; layers stacked as the pages mark them even when one first paints on a later page, art ending a layer's marked content or a clip closing in a later layer kept in its own layer, and layers with no art kept empty: #508; art reaching past a plain PDF's page clipped to its crop box, as PDF viewers show it, each such object in a clip group of its own (a PDF-compatible `.ai` opens whole: #675); masks, editable text with type set along a curve coming back as type on a path, each artboard's art on its own page only, an `.ai`'s white page under its layers left out rather than coming in as art, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3). CMYK images keep their ink amounts from PDF import (and from placed CMYK TIFFs) to PDF export: a CMYK JPEG passes through unchanged, others stay CMYK (DeviceCMYK, or ICC-based CMYK in PDF/X-3/X-4) unless the Output settings convert them; the canvas shows them through the working CMYK profile (#320). A masked CMYK image (`/SMask`, `/Mask` or a colour key) keeps its inks too, its alpha coming in as a greyscale opacity mask.
-  - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs a PostScript Level 3 interpreter written from the PostScript Language Reference: resource categories and `resourceforall`, local and global VM (`currentglobal`/`setglobal`/`gcheck`), `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters and strings, `load` by any key, `//name` immediate names, `token`, `execform`, user paths, `cshow`, `rootfont`, `cachestatus`, colour rendering and halftone queries, file `status` and data read with `flushfile`, and `pdfmark` marks dropped (Discord feedback, #466, #469, #474). Masked images (`ImageType 3` in its three interleavings) and reusable streams are read, and an image's several data sources are read in turn, as the reference defines (procedures that read one file get their own rows: such images came in banded, #498). `restore` puts dictionaries back as they were at the `save`, so programs that count their saves in a dictionary read to their end (part of #505). Tiling patterns come in as pattern swatches, uncoloured ones too; Type 3 fonts' glyphs as their outlines, spaced by `ashow`/`widthshow`/`xshow`/`kshow`; mesh and function-based shadings (types 1, 4–7) as gradient meshes; sampled functions (type 0) and Flate/LZW predictors are read. It is tested with programs written from the specification in the ways common generators use these features; Inkscape/cairo EPS files open as vectors. When a file's PostScript still can't be read, it opens as its TIFF preview, its Windows metafile preview (as vectors) or its EPSI preview, and the warning (in the status bar, `document.open`/`app.open`/MCP `open_file` replies and `vectorcraft-cli info`) names the error, the operator that raised it and the procedures it ran in. Legacy PostScript `.ai` files (Illustrator 3–8, written with the prolog that defines their operators) keep their groups and nested groups (`u` … `U`), between and inside clipping groups; EPS and EMF/WMF import nest clips (and groups) at most 128 deep, so a hostile file can't exhaust the stack. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole). PDF export writes type as real, searchable text in embedded subset fonts by default, as Illustrator's PDF presets do (Convert Text to Outlines is an option; printer's marks stay shapes), so text-heavy PDFs stay small (#733). DXF export writes each fill as its outlines followed by its hatch, so laser and cutter software, which skips hatches, gets filled art and type too (#546).
+  - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export; PSD and PSB files open and place, linked or embedded, as their merged image in every colour mode and depth (#918). EPS import runs a PostScript Level 3 interpreter written from the PostScript Language Reference: resource categories and `resourceforall`, local and global VM (`currentglobal`/`setglobal`/`gcheck`), `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters and strings, `load` by any key, `//name` immediate names, `token`, `execform`, user paths, `cshow`, `rootfont`, `cachestatus`, colour rendering and halftone queries, file `status` and data read with `flushfile`, and `pdfmark` marks dropped (Discord feedback, #466, #469, #474). Masked images (`ImageType 3` in its three interleavings) and reusable streams are read, and an image's several data sources are read in turn, as the reference defines (procedures that read one file get their own rows: such images came in banded, #498). `restore` puts dictionaries back as they were at the `save`, so programs that count their saves in a dictionary read to their end (part of #505). Tiling patterns come in as pattern swatches, uncoloured ones too; Type 3 fonts' glyphs as their outlines, spaced by `ashow`/`widthshow`/`xshow`/`kshow`; mesh and function-based shadings (types 1, 4–7) as gradient meshes; sampled functions (type 0) and Flate/LZW predictors are read. It is tested with programs written from the specification in the ways common generators use these features; Inkscape/cairo EPS files open as vectors. When a file's PostScript still can't be read, it opens as its TIFF preview, its Windows metafile preview (as vectors) or its EPSI preview, and the warning (in the status bar, `document.open`/`app.open`/MCP `open_file` replies and `vectorcraft-cli info`) names the error, the operator that raised it and the procedures it ran in. Legacy PostScript `.ai` files (Illustrator 3–8, written with the prolog that defines their operators) keep their groups and nested groups (`u` … `U`), between and inside clipping groups; EPS and EMF/WMF import nest clips (and groups) at most 128 deep, so a hostile file can't exhaust the stack. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole). PDF export writes type as real, searchable text in embedded subset fonts by default, as Illustrator's PDF presets do (Convert Text to Outlines is an option; printer's marks stay shapes), so text-heavy PDFs stay small (#733). DXF export writes each fill as its outlines followed by its hatch, so laser and cutter software, which skips hatches, gets filled art and type too (#546).
   - Affinity documents in (AF.1–AF.4): `.af` (Affinity 3) and `.afdesign`/`.afphoto`/`.afpub` (Affinity 1 and 2, container versions 8–12) open and place as editable art: layers and sublayers, groups (pass-through or isolated), artboards (with their names and backgrounds) and Publisher pages side by side, curves with live corners, parametric shapes (rectangles with corner radii, ellipses, polygons, stars, pies, triangles, trapezoids), compound shapes, solid/linear/elliptical gradient fills and strokes (weight, dashes, alignment, scale-with-object), clipping by nesting, vector and pixel masks, artistic and frame text with fonts, sizes, tracking, leading and alignment, placed images (their original JPEG/PNG) and pixel layers (8/16-bit RGB, CMYK), opacity, visibility, locking and blend modes, at the document's resolution in points. Effects, adjustments, brushes and pressure profiles, transparency gradients, master pages, symbol instances (imported as their cached picture), special shapes (cloud, heart, cog…, imported as ellipses) and Affinity-only blend modes are named in the import warning. A file whose native data can't be read opens as its embedded preview with the reason, and that preview can't be placed. Save never writes back over the Affinity file and there is no Affinity export. AF.4 adds Affinity 3 artboard recognition and actual-outline clipping, source-backed JPEG/PNG raster tiles, Unicode text-run recovery, stored fallback/exact installed fonts, OpenType feature flags and compound-geometry limits. 51 public CC0/MIT/Apache-2.0 files (33 current `.af`), pinned and sha256-verified (`cargo xtask corpus --affinity`), test native retention and every-board native/SVG/PDF/PSD output for current files; selected files compare their saved thumbnails. No Affinity reopen or independent paired PSD oracle was available; [source audit and complex-font gaps](docs/affinity-validation.md); [scope, provenance and limits](crates/affinity/README.md).
   - Placed documents: File › Place of a `.vectorcraft` file links to it by default (`file.place`'s `link`): one locked object showing an artboard of the document (or its art's bounds), read the way placing it without Link reads it, its symbols, patterns and images kept apart from the document's; without Link (or from bytes, not a file) it is an editable copy as before. It stays vectors in every output (SVG, PDF, EPS, EMF, DXF), and so do placed documents inside it, read from their own files up to 8 levels deep (documents that place each other stop there). On screen they draw from bitmaps cached per file and zoom step, shared by every copy and made in the background (a placeholder until ready), so a sheet of them redraws in about a millisecond; exports and prints draw them exactly. Like linked images, a save keeps only a preview of each (JPEG when opaque) unless Include Linked Files; output, and zooming past the preview, read the file again, falling back to the preview with a warning when it is gone or changed. Saves for older versions write them as plain art. Links check, update, relink, Update Links on open, Link Info (the artboard's size), Placement Options, Break Link (also Embed, Object › Expand: the editable copy placing without Link gives, its resources joining the document), Edit Original (the document in a new tab) and the Links panel cover them; saving a document updates the open documents that place it. The native format (v4) keeps data of 8 KB or more after the JSON instead of base64 in it.
   - Place and the Links panel, Package (placed `.vectorcraft` documents packaged with their own linked files and fonts, relinked to the copies: #777), File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours; files copied in a file manager paste as art (SVG, PDF, EMF/WMF, bitmaps) on every desktop platform, and Linux/Wayland reads the compositor's clipboard (#398); on Linux the Paste menu checks the clipboard off the UI thread, so an X11 owner that never answers can't freeze the window (#510); screenshots and other copied pictures paste as embedded images at the view centre everywhere, the web included (#457).
@@ -220,10 +224,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 | 32% | ~39 Photoshop-style filters (Artistic, Brush Strokes, Distort, Sketch, Stylize), Smart Blur's Edge Only / Overlay Edge modes, Texturizer's Load Texture 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), Texture (Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass, Texturizer) and Video (De-Interlace, NTSC Colors) are done | 20–33 |
 | 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 |
@@ -232,12 +236,12 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Layers, artboards, document setup | 5 | 82% | Layers panel: a confirmation before deleting layers that hold art, Collect for Export, row context menus, the Layer Options dialog for several rows with mixed values, Paste Remembers Layers for sublayers, drag-scrolling a long panel while dragging rows; artboard preset polish (Move Artwork for artboard X/Y edits, Rearrange All Artboards, Document Setup, New Document and the rest of the Layers panel are done) | 4–7 |
 | View & navigation | 3 | 70% | New View/Edit Views, multiple windows/arrange, Snap to Pixel/Glyph (print tiling is done) | 9–14 |
 | Guides, grids, smart guides, snapping, rulers | 3 | 85% | global/video rulers, Spacing Guides' distance readouts and spacing for resized or drawn art, Smart Guides' angle and distance readouts while drawing, Alt swapping a ruler guide's orientation, ruler guides selected together with art (marquee, Shift-click), ruler guides as Layers rows with their own lock and hide (#451: Lock Guides locks them all; Make Guides paths are Layers rows already) (dragging existing guides is done, #414; new guides snapping to side midpoints and artboards, and artboard guides, #451; the drawing tools snapping, with Construction Guides, #506; Spacing Guides for moves, #394; moves snapping to the grid, #740; ruler guides pulling drawn points with Smart Guides on, and "center" and "anchor" labels while hovering with the Selection tool, #812) | 2–4 |
-| File formats | 6 | 85% | Affinity export, and the rest of Affinity import (effects, adjustments, brushes, master pages, live symbol instances), DWG (no open spec: DXF instead), PSD placement as layers, EPS checked against more real files users send (Inkscape files open as vectors; other generators' constructs are tested with programs written from the PostScript Language Reference only; CID-keyed CJK type and `CCITTFaxDecode` images not read), legacy `.ai` files saved without the prolog that defines their operators (their own operator set isn't read yet), the rest of Illustrator's editing data (appearances and live effects, symbols, pattern fills, brushes, placed files: #637), the remaining fidelity polish; EPS, DXF, EMF/WMF, TIFF, BMP, Targa, PSD export, SVGZ, PDF security, PDF/X, PDF layers, presets and Affinity import are done | 6–10 (existing scope; Affinity export unestimated) |
+| File formats | 6 | 85% | Affinity export, and the rest of Affinity import (effects, adjustments, brushes, master pages, live symbol instances), DWG (no open spec: DXF instead), PSD placement as layers (Photoshop Import Options; the merged image is done), EPS checked against more real files users send (Inkscape files open as vectors; other generators' constructs are tested with programs written from the PostScript Language Reference only; CID-keyed CJK type and `CCITTFaxDecode` images not read), legacy `.ai` files saved without the prolog that defines their operators (their own operator set isn't read yet), the rest of Illustrator's editing data (appearances and live effects, symbols, pattern fills, brushes, placed files: #637), the remaining fidelity polish; EPS, DXF, EMF/WMF, TIFF, BMP, Targa, PSD export, SVGZ, PDF security, PDF/X, PDF layers, presets and Affinity import are done | 6–10 (existing scope; Affinity export unestimated) |
 | Export for Screens, Asset Export, slices, Save for Web | 3 | 85% | polish only (all four are done) | 2–4 |
 | Print, colour management, separations, flattener | 3 | 80% | print preview fidelity (flattener presets in PDF and print, overprint in PDF and composite print, Print dialog, presets, PostScript, marks, separations, Print Tiling, print overprint/flattener/bitmap options and printer profile are done) | 1–2 |
 | Automation | 3 | 60% | Variables (data merge), scripting surface, batch | 8–12 |
 | UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 78% | 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 |

apps/vectorcraft/src/main.rs

@@ -621,13 +621,14 @@ mod tests {
             .collect()
     }
 
-    /// Finder offers the app for every file File › Open reads (#295, #354), takes over no other
-    /// app's files, and hands them to the app rather than to AppKit's document machinery.
+    /// Finder offers the app for every file File › Open reads (#295, #354) but Photoshop documents
+    /// (`UNASSOCIATED_EXTS`), takes over no other app's files, and hands them to the app rather than
+    /// to AppKit's document machinery.
     #[test]
     fn the_macos_bundle_opens_every_readable_format() {
         let plist = include_str!("../../../packaging/macos/Info.plist.in");
         let declared = plist_extensions(plist);
-        for e in fileio::OPEN_EXTS {
+        for e in fileio::OPEN_EXTS.iter().filter(|e| !fileio::UNASSOCIATED_EXTS.contains(e)) {
             assert!(declared.contains(e), "Info.plist.in doesn't declare .{e}");
         }
         for e in &declared {

contributors/people.toml

@@ -26,6 +26,9 @@ sync_github_name = false
 real_name = "Riccardo Balloch"
 sync_github_name = false
 
+[people.crqch]
+sync_github_name = true
+
 [people.mo0kid]
 sync_github_name = true
 

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

@@ -1,8 +1,15 @@
 //! Graphs (Illustrator's graph tools): a group whose art is generated from a [`GraphSpec`].
 
+use std::collections::HashSet;
+
 use serde::{Deserialize, Serialize};
 use vectorcraft_geom::Rect;
 
+/// Most categories (rows) and series (columns) a graph's data grid holds: the grid is built in full for drawing and
+/// for the data window, so a file can't make it allocate without bound.
+pub const MAX_GRAPH_CATEGORIES: usize = 10_000;
+pub const MAX_GRAPH_SERIES: usize = 256;
+
 /// The nine graph types, in the Graph tool group's order.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -93,6 +100,10 @@ pub struct GraphSpec {
     pub series: Vec<String>,
     pub categories: Vec<String>,
     pub rows: Vec<Vec<f64>>,
+    /// Blank cells as `[category, series]`: their `rows` entry is a 0 placeholder, so a file still reads (as zeros)
+    /// in a version that doesn't know blanks. Cells past the end of a short row are blank too.
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub blanks: Vec<[usize; 2]>,
     /// Column/bar width as a % of the available category width (90).
     pub column_width: f64,
     /// Cluster width as a % (80).
@@ -103,14 +114,46 @@ 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 GraphSpec {
+    /// The data with blank cells as `None`, every row as long as the longest (at most [`MAX_GRAPH_CATEGORIES`] rows
+    /// of [`MAX_GRAPH_SERIES`] cells).
+    pub fn cells(&self) -> Vec<Vec<Option<f64>>> {
+        let width = self.rows.iter().map(Vec::len).max().unwrap_or(0).min(MAX_GRAPH_SERIES);
+        let blank: HashSet<[usize; 2]> = self.blanks.iter().copied().collect();
+        self.rows
+            .iter()
+            .take(MAX_GRAPH_CATEGORIES)
+            .enumerate()
+            .map(|(c, r)| (0..width).map(|s| r.get(s).copied().filter(|_| !blank.contains(&[c, s]))).collect())
+            .collect()
+    }
+
+    /// Store `cells`, a blank (`None`) as a 0 placeholder listed in `blanks`.
+    pub fn set_cells(&mut self, cells: Vec<Vec<Option<f64>>>) {
+        self.blanks =
+            cells.iter().enumerate().flat_map(|(c, r)| r.iter().enumerate().filter(|(_, v)| v.is_none()).map(move |(s, _)| [c, s])).collect();
+        self.rows = cells.into_iter().map(|r| r.into_iter().map(|v| v.unwrap_or(0.0)).collect()).collect();
+    }
+}
+
 impl Default for GraphSpec {
     fn default() -> Self {
         Self {
@@ -120,6 +163,7 @@ impl Default for GraphSpec {
             series: vec![],
             categories: vec![],
             rows: vec![vec![1.0]],
+            blanks: vec![],
             column_width: 90.0,
             cluster_width: 80.0,
             legend: true,
@@ -128,6 +172,7 @@ impl Default for GraphSpec {
             axis_max: None,
             mark_points: true,
             connect_points: true,
+            edge_to_edge: false,
             placed: None,
         }
     }

crates/doc/src/lib.rs

@@ -65,7 +65,7 @@ pub use appearance::{
 };
 pub use assets::ExportAsset;
 pub use corners::LiveCorners;
-pub use graph::{GraphKind, GraphSpec, SeriesPaint};
+pub use graph::{GraphKind, GraphSpec, MAX_GRAPH_CATEGORIES, MAX_GRAPH_SERIES, SeriesPaint};
 pub use hit::{Hit, HitKind};
 pub use links::{LinkInfo, PlacementOptions};
 pub use live::{BlendOrientation, BlendSpacing, BlendSpec, EnvelopeKind, GradientMesh, MeshPoint};

crates/effects/src/lib.rs

@@ -130,6 +130,10 @@ fn lengths_of(id: &str) -> Lengths {
         "stylize.glowingEdges" => always(&["edgeWidth", "smoothness"]),
         "pixelate.colorHalftone" => always(&["maxRadius"]),
         "pixelate.crystallize" | "pixelate.pointillize" => always(&["cellSize"]),
+        "texture.craquelure" => always(&["crackSpacing"]),
+        "texture.mosaicTiles" => always(&["tileSize"]),
+        "texture.patchwork" => always(&["squareSize"]),
+        "texture.stainedGlass" => always(&["cellSize"]),
         _ => Lengths::default(),
     }
 }
@@ -144,6 +148,8 @@ const WARP: &[&str] = &["Effect", "Warp"];
 const BLUR: &[&str] = &["Effect", "Blur"];
 const SHARPEN: &[&str] = &["Effect", "Sharpen"];
 const PIXELATE: &[&str] = &["Effect", "Pixelate"];
+const TEXTURE: &[&str] = &["Effect", "Texture"];
+const VIDEO: &[&str] = &["Effect", "Video"];
 const PATHFINDER: &[&str] = &["Effect", "Pathfinder"];
 const PLUGINS: &[&str] = &["Effect", "Plug-ins"];
 const ADJUST: &[&str] = &["Effect", "Color Adjustments"];
@@ -331,6 +337,62 @@ 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(
+            "texture.craquelure",
+            "Craquelure…",
+            TEXTURE,
+            "{crackSpacing: pt 2..100 (15; how far apart the cracks are), crackDepth: 0..10 (6; how deep and wide the cracks are, and how high the plates and the tones stand), crackBrightness: 0..10 (9; how brightly the plaster is lit)} paints the object on relief plaster cracked into plates and along the contours of its tones",
+            json!({"crackSpacing": 15.0, "crackDepth": 6.0, "crackBrightness": 9.0}),
+        ),
+        r(
+            "texture.grain",
+            "Grain…",
+            TEXTURE,
+            "{intensity: 0..100 (40), contrast: 0..100 (50; the image's contrast, 50 leaves it as it is), grainType: \"regular\"|\"soft\"|\"sprinkles\"|\"clumped\"|\"contrasty\"|\"enlarged\"|\"stippled\"|\"horizontal\"|\"vertical\"|\"speckle\" (\"regular\")} adds grain in 1 pt grains (2 pt Enlarged, clumps Clumped, streaks Horizontal and Vertical); Sprinkles and Stippled use the background colour, white",
+            json!({"intensity": 40.0, "contrast": 50.0, "grainType": "regular"}),
+        ),
+        r(
+            "texture.mosaicTiles",
+            "Mosaic Tiles…",
+            TEXTURE,
+            "{tileSize: pt 2..100 (12), groutWidth: 1..15 (3; the grout is half a point wide per step), lightenGrout: 0..10 (9; how light the grout is)} lays the object in irregular tiles bevelled at their edges, with sunken grout between them",
+            json!({"tileSize": 12.0, "groutWidth": 3.0, "lightenGrout": 9.0}),
+        ),
+        r(
+            "texture.patchwork",
+            "Patchwork…",
+            TEXTURE,
+            "{squareSize: pt 0..10 (4; 0 draws 1 pt squares), relief: 0..25 (8)} redraws the object in squares of the colour around their centres, raised to heights that follow its highlights and shadows, a little more or less at random, lit from the top left",
+            json!({"squareSize": 4.0, "relief": 8.0}),
+        ),
+        r(
+            "texture.stainedGlass",
+            "Stained Glass…",
+            TEXTURE,
+            "{cellSize: pt 2..50 (10), borderThickness: 1..20 (4; the lead between the panes, half a point wide per step, in the foreground colour: black), lightIntensity: 0..10 (3; a light behind the object's centre, fading out towards its corners)} redraws the object as single-coloured panes around random points about cellSize apart",
+            json!({"cellSize": 10.0, "borderThickness": 4.0, "lightIntensity": 3.0}),
+        ),
+        r(
+            "texture.texturizer",
+            "Texturizer…",
+            TEXTURE,
+            "{texture: \"brick\"|\"burlap\"|\"canvas\"|\"sandstone\" (\"canvas\"; surfaces made in code), scaling: % 50..200 (100), relief: 0..50 (4), lightDirection: \"bottom\"|\"bottomLeft\"|\"left\"|\"topLeft\"|\"top\"|\"topRight\"|\"right\"|\"bottomRight\" (\"top\"), invert: bool (false; turns the surface's heights over)} paints the object on a surface in relief",
+            json!({"texture": "canvas", "scaling": 100.0, "relief": 4.0, "lightDirection": "top", "invert": false}),
+        ),
+        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,7 @@
 //! 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, Texture › Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass and Texturizer, 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,16 +14,19 @@ mod blur;
 mod edges;
 mod pixelate;
 mod sharpen;
+mod texture;
+mod video;
 
 use serde_json::Value;
 use vectorcraft_geom::{Affine, Point, Rect};
 
-use crate::util::{num, text};
+use crate::util::{flag, num, text};
 
 pub use pixelate::{MEZZOTINT_TYPES, Mezzotint};
+pub use texture::{GRAIN_TYPES, Grain, LIGHT_DIRECTIONS, Light, TEXTURES, Texture};
 
 /// The Photoshop-style effect ids (all raster effects, see [`crate::is_raster`]).
-pub const PIXEL_EFFECTS: [&str; 8] = [
+pub const PIXEL_EFFECTS: [&str; 16] = [
     "blur.radial",
     "blur.smart",
     "pixelate.colorHalftone",
@@ -31,6 +35,14 @@ pub const PIXEL_EFFECTS: [&str; 8] = [
     "pixelate.pointillize",
     "sharpen.unsharpMask",
     "stylize.glowingEdges",
+    "texture.craquelure",
+    "texture.grain",
+    "texture.mosaicTiles",
+    "texture.patchwork",
+    "texture.stainedGlass",
+    "texture.texturizer",
+    "video.deinterlace",
+    "video.ntscColors",
 ];
 
 /// A Photoshop-style raster effect with its parameters read and clamped to their ranges. Lengths
@@ -59,6 +71,29 @@ pub enum PixelFx {
     /// Pixelate › Pointillize: random dots about `cell` across of the object's colours on a white
     /// canvas.
     Pointillize { cell: f64 },
+    /// Texture › Craquelure: cracked relief plaster, plates about `spacing` apart, cracks as deep
+    /// as `depth` (0..10), lit as brightly as `brightness` (0..10).
+    Craquelure { spacing: f64, depth: f64, brightness: f64 },
+    /// Texture › Grain: noise of `kind` as strong as `intensity` (0..100), the image's contrast
+    /// set by `contrast` (0..100, 50 leaves it).
+    Grain { intensity: f64, contrast: f64, kind: Grain },
+    /// Texture › Mosaic Tiles: irregular tiles about `tile` across with sunken grout `grout` / 2
+    /// wide (1..15), lightened by `lighten` (0..10).
+    MosaicTiles { tile: f64, grout: f64, lighten: f64 },
+    /// Texture › Patchwork: squares `square` across of the colour around their centres, raised by
+    /// up to `relief` (0..25).
+    Patchwork { square: f64, relief: f64 },
+    /// Texture › Stained Glass: panes about `cell` across leaded `border` / 2 wide (1..20) in
+    /// black, lit at the centre by `light` (0..10).
+    StainedGlass { cell: f64, border: f64, light: f64 },
+    /// Texture › Texturizer: a `texture` surface scaled by `scaling` (0.5..2), in relief as strong
+    /// as `relief` (0..50), lit from `light`, its heights turned over when `invert`.
+    Texturizer { texture: Texture, scaling: f64, relief: f64, light: Light, invert: bool },
+    /// 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 +124,12 @@ 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,
+    /// How far the corners of the object's bounds lie from its centre (document units): Stained
+    /// Glass's light fades out over it.
+    pub extent: f64,
 }
 
 /// Effect `id`'s parameters `p` (defaults merged in) as a [`PixelFx`]; `None` for other effects.
@@ -126,6 +167,41 @@ 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) },
+        "texture.craquelure" => PixelFx::Craquelure {
+            spacing: num(p, "crackSpacing", 15.0).clamp(2.0, 100.0),
+            depth: num(p, "crackDepth", 6.0).clamp(0.0, 10.0),
+            brightness: num(p, "crackBrightness", 9.0).clamp(0.0, 10.0),
+        },
+        "texture.grain" => PixelFx::Grain {
+            intensity: num(p, "intensity", 40.0).clamp(0.0, 100.0),
+            contrast: num(p, "contrast", 50.0).clamp(0.0, 100.0),
+            kind: Grain::parse(text(p, "grainType", "regular")),
+        },
+        "texture.mosaicTiles" => PixelFx::MosaicTiles {
+            tile: num(p, "tileSize", 12.0).clamp(2.0, 100.0),
+            grout: num(p, "groutWidth", 3.0).clamp(1.0, 15.0),
+            lighten: num(p, "lightenGrout", 9.0).clamp(0.0, 10.0),
+        },
+        "texture.patchwork" => {
+            PixelFx::Patchwork { square: num(p, "squareSize", 4.0).clamp(0.0, 10.0), relief: num(p, "relief", 8.0).clamp(0.0, 25.0) }
+        }
+        "texture.stainedGlass" => PixelFx::StainedGlass {
+            cell: num(p, "cellSize", 10.0).clamp(2.0, 50.0),
+            border: num(p, "borderThickness", 4.0).clamp(1.0, 20.0),
+            light: num(p, "lightIntensity", 3.0).clamp(0.0, 10.0),
+        },
+        "texture.texturizer" => PixelFx::Texturizer {
+            texture: Texture::parse(text(p, "texture", "canvas")),
+            scaling: num(p, "scaling", 100.0).clamp(50.0, 200.0) / 100.0,
+            relief: num(p, "relief", 4.0).clamp(0.0, 50.0),
+            light: Light::parse(text(p, "lightDirection", "top")),
+            invert: flag(p, "invert", false),
+        },
+        "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,9 +219,18 @@ 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,
-            // 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,
+            PixelFx::ColorHalftone { .. }
+            | PixelFx::Mezzotint { .. }
+            | PixelFx::Craquelure { .. }
+            | PixelFx::Grain { .. }
+            | PixelFx::MosaicTiles { .. }
+            | PixelFx::Texturizer { .. }
+            | PixelFx::DeInterlace { .. }
+            | PixelFx::NtscColors => 0.0,
+            // A crystal's, dot's or pane's point inside the object reaches out by up to its cell.
+            PixelFx::Crystallize { cell } | PixelFx::Pointillize { cell } | PixelFx::StainedGlass { cell, .. } => 1.5 * cell,
+            // A square whose centre is on the object is drawn whole.
+            PixelFx::Patchwork { square, .. } => square.max(1.0),
         }
     }
 
@@ -163,6 +248,15 @@ impl PixelFx {
             PixelFx::Mezzotint { .. } => Some(0.0),
             // The dots' points, and the softened colour around them.
             PixelFx::Pointillize { cell } => Some(2.5 * cell),
+            // The softened tones around the pixel.
+            PixelFx::Craquelure { spacing, .. } => Some(3.0 * texture::CONTOUR_SOFTNESS * spacing),
+            PixelFx::Grain { .. } | PixelFx::MosaicTiles { .. } | PixelFx::Texturizer { .. } => Some(0.0),
+            // The square's or pane's point, and the softened colour around it.
+            PixelFx::Patchwork { square, .. } => Some(2.0 * square.max(1.0)),
+            PixelFx::StainedGlass { cell, .. } => Some(2.5 * cell),
+            // The lines above and below.
+            PixelFx::DeInterlace { .. } => Some(video::MAX_LINE),
+            PixelFx::NtscColors => Some(0.0),
         }
     }
 
@@ -180,10 +274,26 @@ 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::Craquelure { spacing, depth, brightness } => texture::craquelure(px, w, h, space, spacing, depth, brightness),
+            PixelFx::Grain { intensity, contrast, kind } => texture::grain(px, w, h, space, intensity, contrast, kind),
+            PixelFx::MosaicTiles { tile, grout, lighten } => texture::mosaic_tiles(px, w, h, space, tile, grout, lighten),
+            PixelFx::Patchwork { square, relief } => texture::patchwork(px, w, h, space, square, relief),
+            PixelFx::StainedGlass { cell, border, light } => texture::stained_glass(px, w, h, space, cell, border, light),
+            PixelFx::Texturizer { texture, scaling, relief, light, invert } => {
+                texture::texturizer(px, w, h, space, texture, scaling, relief, light, invert)
+            }
+            PixelFx::DeInterlace { even, interpolate } => video::deinterlace(px, w, h, space, even, interpolate),
+            PixelFx::NtscColors => video::ntsc(px),
         }
     }
 }
 
+/// The entry of `all` whose value in `table` (the same order) is `value`, any case; `default`
+/// otherwise.
+fn pick<T: Copy>(table: &[(&str, &str)], all: &[T], value: &str, default: T) -> T {
+    table.iter().zip(all).find(|((_, v), _)| v.eq_ignore_ascii_case(value)).map_or(default, |(_, t)| *t)
+}
+
 /// `data` as `w` × `h` RGBA pixels, `None` when it isn't that size (or is empty).
 fn pixels(data: &mut [u8], w: usize, h: usize) -> Option<&mut [[u8; 4]]> {
     let (px, rest) = data.as_chunks_mut::<4>();

crates/effects/src/pixel/pixelate.rs

@@ -8,7 +8,7 @@ use std::sync::OnceLock;
 
 use vectorcraft_geom::{Affine, Point};
 
-use super::{Channels, PixelSpace, gaussian, to16};
+use super::{Channels, PixelSpace, Px16, gaussian, pick, to16};
 use crate::util::noise;
 
 /// Mezzotint's patterns, in its Type menu's order: (label, parameter value).
@@ -62,7 +62,7 @@ impl Mezzotint {
 
     /// The pattern of Type `value` (a [`MEZZOTINT_TYPES`] value, any case); Fine Dots otherwise.
     pub fn parse(value: &str) -> Self {
-        MEZZOTINT_TYPES.iter().zip(MEZZOTINT_KINDS).find(|((_, v), _)| v.eq_ignore_ascii_case(value)).map_or(Self::FINE_DOTS, |(_, kind)| kind)
+        pick(&MEZZOTINT_TYPES, &MEZZOTINT_KINDS, value, Self::FINE_DOTS)
     }
 }
 
@@ -70,48 +70,48 @@ impl Mezzotint {
 const SEED: u64 = 0x5049_5845_4C41_5445;
 
 /// A random number in [0, 1) for cell (`i`, `j`) of pattern `salt`; `k` picks one of several.
-fn rand(salt: u64, i: i64, j: i64, k: u64) -> f64 {
+pub(super) fn rand(salt: u64, i: i64, j: i64, k: u64) -> f64 {
     0.5 * (noise(SEED ^ salt, i as u64, j as u64, k) + 1.0)
 }
 
 /// The cell holding coordinate `v` (in cells); `None` far beyond any raster (or not finite).
-fn cell(v: f64) -> Option<i64> {
+pub(super) fn cell(v: f64) -> Option<i64> {
     let f = v.floor();
     (f.abs() < 1e15).then_some(f as i64)
 }
 
 /// Where a raster's pixels lie relative to the object's centre, in document units.
-struct Place {
+pub(super) struct Place {
     /// Pixel coordinates → document coordinates relative to the centre.
-    to_rel: Affine,
+    pub(super) to_rel: Affine,
     /// The other way.
-    to_px: Affine,
+    pub(super) to_px: Affine,
     /// A pixel's size in document units.
-    px: f64,
+    pub(super) px: f64,
     w: usize,
     h: usize,
 }
 
 impl Place {
-    fn new(space: &PixelSpace, w: usize, h: usize) -> Option<Self> {
+    pub(super) fn new(space: &PixelSpace, w: usize, h: usize) -> Option<Self> {
         let to_rel = Affine::translate(-space.center.to_vec2()) * space.to_doc;
         let to_px = to_rel.inverse();
         (to_rel.is_finite() && to_px.is_finite() && space.px.is_finite() && space.px > 0.0).then_some(Self { to_rel, to_px, px: space.px, w, h })
     }
 
     /// The centre of pixel (`x`, `y`).
-    fn at(&self, x: usize, y: usize) -> Point {
+    pub(super) fn at(&self, x: usize, y: usize) -> Point {
         self.to_rel * Point::new(x as f64 + 0.5, y as f64 + 0.5)
     }
 
     /// The index of the pixel holding point `p`; `None` outside the raster.
-    fn index(&self, p: Point) -> Option<usize> {
+    pub(super) fn index(&self, p: Point) -> Option<usize> {
         let q = self.to_px * p;
         (q.x >= 0.0 && q.y >= 0.0 && q.x < self.w as f64 && q.y < self.h as f64).then(|| q.y as usize * self.w + q.x as usize)
     }
 
     /// Run `f(x, y, pixel)` on every pixel.
-    fn each(&self, px: &mut [[u8; 4]], mut f: impl FnMut(usize, usize, &mut [u8; 4])) {
+    pub(super) fn each(&self, px: &mut [[u8; 4]], mut f: impl FnMut(usize, usize, &mut [u8; 4])) {
         for (y, row) in px.chunks_exact_mut(self.w.max(1)).enumerate().take(self.h) {
             for (x, p) in row.iter_mut().enumerate() {
                 f(x, y, p);
@@ -122,7 +122,7 @@ impl Place {
 
 /// The cells around a pixel's cell, in the order they can hold its nearest random point: the
 /// cell itself, its 8 neighbours, then the ring around them.
-const AROUND: [(i64, i64); 25] = [
+pub(super) const AROUND: [(i64, i64); 25] = [
     (0, 0),
     (-1, 0),
     (1, 0),
@@ -152,18 +152,18 @@ const AROUND: [(i64, i64); 25] = [
 
 /// What the cells [`AROUND`] one cell hold, made when first asked for and kept while consecutive
 /// pixels stay in that cell.
-struct Around<T> {
+pub(super) struct Around<T> {
     cell: Option<(i64, i64)>,
     items: [Option<T>; 25],
 }
 
 impl<T: Copy> Around<T> {
-    fn new() -> Self {
+    pub(super) fn new() -> Self {
         Self { cell: None, items: [None; 25] }
     }
 
     /// Item `k` of [`AROUND`] cell (`i`, `j`): `make(cell i', j')`.
-    fn get(&mut self, (i, j): (i64, i64), k: usize, make: impl FnOnce(i64, i64) -> T) -> Option<T> {
+    pub(super) fn get(&mut self, (i, j): (i64, i64), k: usize, make: impl FnOnce(i64, i64) -> T) -> Option<T> {
         if self.cell != Some((i, j)) {
             self.cell = Some((i, j));
             self.items = [None; 25];
@@ -175,10 +175,26 @@ impl<T: Copy> Around<T> {
 }
 
 /// The random point of cell (`i`, `j`) of pattern `salt`, in cells.
-fn point_in(salt: u64, i: i64, j: i64) -> Point {
+pub(super) fn point_in(salt: u64, i: i64, j: i64) -> Point {
     Point::new(i as f64 + rand(salt, i, j, 0), j as f64 + rand(salt, i, j, 1))
 }
 
+/// How far cell `c` lies from coordinate `t` (in cells) along one axis.
+pub(super) fn gap(c: i64, t: f64) -> f64 {
+    (c as f64 - t).max(t - c as f64 - 1.0).max(0.0)
+}
+
+/// Smooth random values in [0, 1) of pattern `salt` at whole coordinates, blended between them.
+pub(super) fn value_noise(salt: u64, x: f64, y: f64) -> f64 {
+    let (Some(i), Some(j)) = (cell(x), cell(y)) else { return 0.5 };
+    let smooth = |t: f64| t * t * (3.0 - 2.0 * t);
+    let (fx, fy) = (smooth(x - i as f64), smooth(y - j as f64));
+    let at = |di: i64, dj: i64| rand(salt, i.wrapping_add(di), j.wrapping_add(dj), 0);
+    let top = at(0, 0) + (at(1, 0) - at(0, 0)) * fx;
+    let bottom = at(0, 1) + (at(1, 1) - at(0, 1)) * fx;
+    top + (bottom - top) * fy
+}
+
 /// Crystallize: every pixel takes the colour at the nearest of one random point per `cell` ×
 /// `cell` square (a Voronoi diagram over a jittered grid): polygon crystals of solid colour.
 pub(super) fn crystallize(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, cell_size: f64) {
@@ -188,8 +204,6 @@ pub(super) fn crystallize(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelS
     }
     let src = px.to_vec();
     let mut around = Around::new();
-    // How far cell `c` lies from coordinate `t` (in cells) along one axis.
-    let gap = |c: i64, t: f64| (c as f64 - t).max(t - c as f64 - 1.0).max(0.0);
     place.each(px, |x, y, out| {
         let q = place.at(x, y);
         let (u, v) = (q.x / cell_size, q.y / cell_size);
@@ -215,6 +229,34 @@ pub(super) fn crystallize(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelS
     });
 }
 
+/// The object's colours softened by a Gaussian of `sigma` pixels, with its coverage as it is: what
+/// the cell filters (Pointillize, Patchwork, Stained Glass) fill their cells with.
+pub(super) struct Soft {
+    colour: Vec<Px16>,
+    alpha: Vec<u8>,
+}
+
+impl Soft {
+    pub(super) fn new(px: &[[u8; 4]], w: usize, sigma: f64) -> Self {
+        let mut colour = to16(px);
+        gaussian(&mut colour, w, sigma);
+        Self { colour, alpha: px.iter().map(|p| p[3]).collect() }
+    }
+
+    /// The colour around pixel `k` (premultiplied, 0..1), as opaque as the object is at `k`; clear
+    /// outside the raster.
+    pub(super) fn at(&self, k: Option<usize>) -> [f32; 4] {
+        let a = k.and_then(|k| self.alpha.get(k)).map_or(0.0, |a| f32::from(*a) / 255.0);
+        match k.and_then(|k| self.colour.get(k)) {
+            Some(p) if p[3] > 0 => {
+                let s = a / f32::from(p[3]);
+                [f32::from(p[0]) * s, f32::from(p[1]) * s, f32::from(p[2]) * s, a]
+            }
+            _ => [0.0; 4],
+        }
+    }
+}
+
 /// One of Pointillize's dots: where (in cells), its radius (document units), its stacking order
 /// and its colour (premultiplied, 0..1).
 #[derive(Clone, Copy)]
@@ -237,20 +279,10 @@ pub(super) fn pointillize(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelS
     }
     // Each dot takes the colour around its centre, not of a single pixel there, and is as opaque
     // as the object at its centre (whole dots on the object, none beside it).
-    let alpha: Vec<u8> = px.iter().map(|p| p[3]).collect();
-    let mut soft = to16(px);
-    gaussian(&mut soft, w, cell_size / place.px / 4.0);
+    let soft = Soft::new(px, w, cell_size / place.px / 4.0);
     let dot = |i: i64, j: i64| {
         let at = point_in(2, i, j);
-        let k = place.index(Point::new(at.x * cell_size, at.y * cell_size));
-        let a = k.and_then(|k| alpha.get(k)).map_or(0.0, |a| f32::from(*a) / 255.0);
-        let colour = match k.and_then(|k| soft.get(k)) {
-            Some(p) if p[3] > 0 => {
-                let s = a / f32::from(p[3]);
-                [f32::from(p[0]) * s, f32::from(p[1]) * s, f32::from(p[2]) * s, a]
-            }
-            _ => [0.0; 4],
-        };
+        let colour = soft.at(place.index(Point::new(at.x * cell_size, at.y * cell_size)));
         Dot { at, radius: (DOT_RADIUS.0 + DOT_RADIUS.1 * rand(2, i, j, 2)) * cell_size, z: rand(2, i, j, 3), colour }
     };
     let mut around = Around::new();
@@ -499,19 +531,6 @@ pub(super) fn mezzotint(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpa
 /// Mezzotint's threshold in [0, 1) at point `q` (document units around the centre) of pattern
 /// `salt`.
 fn threshold(kind: Mezzotint, salt: u64, q: Point) -> f64 {
-    let smooth = |t: f64| t * t * (3.0 - 2.0 * t);
-    // Random values at whole coordinates, blended smoothly between them along x (and y).
-    let blend = |x: f64, y: f64, along_y: bool| {
-        let (Some(i), Some(j)) = (cell(x), cell(y)) else { return 0.5 };
-        let (fx, fy) = (smooth(x - i as f64), smooth(y - j as f64));
-        let at = |di: i64, dj: i64| rand(salt, i.wrapping_add(di), j.wrapping_add(dj), 0);
-        let top = at(0, 0) + (at(1, 0) - at(0, 0)) * fx;
-        if !along_y {
-            return top;
-        }
-        let bottom = at(0, 1) + (at(1, 1) - at(0, 1)) * fx;
-        top + (bottom - top) * fy
-    };
     let grain = |size: f64| match (cell(q.x / size), cell(q.y / size)) {
         (Some(i), Some(j)) => rand(salt, i, j, 1),
         _ => 0.5,
@@ -520,12 +539,10 @@ fn threshold(kind: Mezzotint, salt: u64, q: Point) -> f64 {
         Mezzotint::Dots { size, smooth: false, .. } => grain(f64::from(size)),
         Mezzotint::Dots { size, grainy, .. } => {
             let s = f64::from(size);
-            let blob = blend(q.x / s, q.y / s, true);
+            let blob = value_noise(salt, q.x / s, q.y / s);
             if grainy { 0.5 * (blob + grain(1.0)) } else { blob }
         }
-        Mezzotint::Lines { length, width } => {
-            let row = (q.y / f64::from(width)).floor();
-            blend(q.x / f64::from(length), row, false)
-        }
+        // Blended along x only: whole rows.
+        Mezzotint::Lines { length, width } => value_noise(salt, q.x / f64::from(length), (q.y / f64::from(width)).floor()),
     }
 }

crates/effects/src/pixel/tests.rs

@@ -5,9 +5,17 @@ use vectorcraft_geom::{Affine, Point, Rect};
 use super::*;
 use crate::{RasterFx, raster_effects};
 
-/// A `w` × `h` raster whose pixels are document points (origin top-left).
+/// A `w` × `h` raster whose pixels are document points (origin top-left), of an object that fills it.
 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 }
+    let (w, h) = (w as f64, h as f64);
+    PixelSpace {
+        to_doc: Affine::IDENTITY,
+        px: 1.0,
+        center: Point::new(w / 2.0, h / 2.0),
+        channels: Channels::Rgb,
+        line: 1.0,
+        extent: 0.5 * w.hypot(h),
+    }
 }
 
 fn image(w: usize, h: usize, f: impl Fn(usize, usize) -> [u8; 4]) -> Vec<u8> {
@@ -224,7 +232,14 @@ 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,
+            extent: 0.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 +268,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, extent: 0.0 };
     let cases = [
         ("blur.radial", json!({"quality": "draft"})),
         ("blur.radial", json!({"quality": "good"})),
@@ -267,6 +282,14 @@ fn pixel_timings() {
         ("pixelate.mezzotint", json!({"type": "grainyDots"})),
         ("pixelate.pointillize", json!({"cellSize": 3})),
         ("pixelate.pointillize", json!({"cellSize": 300})),
+        ("texture.craquelure", json!({"crackSpacing": 2})),
+        ("texture.craquelure", json!({"crackSpacing": 100})),
+        ("texture.grain", json!({"grainType": "clumped"})),
+        ("texture.mosaicTiles", json!({"tileSize": 2})),
+        ("texture.patchwork", json!({"squareSize": 0})),
+        ("texture.stainedGlass", json!({"cellSize": 2})),
+        ("texture.texturizer", json!({"texture": "sandstone", "scaling": 50})),
+        ("texture.texturizer", json!({"texture": "burlap"})),
     ];
     for (id, p) in cases {
         let mut d = src.clone();
@@ -477,3 +500,329 @@ 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:?}");
+    }
+}
+
+#[test]
+fn texture_params_take_defaults_and_stay_in_range() {
+    assert_eq!(fx("texture.craquelure", json!({})), PixelFx::Craquelure { spacing: 15.0, depth: 6.0, brightness: 9.0 });
+    assert_eq!(
+        fx("texture.craquelure", json!({"crackSpacing": 1e9, "crackDepth": -1, "crackBrightness": "x"})),
+        PixelFx::Craquelure { spacing: 100.0, depth: 0.0, brightness: 9.0 }
+    );
+    assert_eq!(fx("texture.grain", json!({})), PixelFx::Grain { intensity: 40.0, contrast: 50.0, kind: Grain::Regular });
+    assert_eq!(
+        fx("texture.grain", json!({"intensity": 1e300, "contrast": -5, "grainType": "SPECKLE"})),
+        PixelFx::Grain { intensity: 100.0, contrast: 0.0, kind: Grain::Speckle }
+    );
+    assert_eq!(fx("texture.mosaicTiles", json!({})), PixelFx::MosaicTiles { tile: 12.0, grout: 3.0, lighten: 9.0 });
+    assert_eq!(
+        fx("texture.mosaicTiles", json!({"tileSize": 0, "groutWidth": 99, "lightenGrout": 11})),
+        PixelFx::MosaicTiles { tile: 2.0, grout: 15.0, lighten: 10.0 }
+    );
+    assert_eq!(fx("texture.patchwork", json!({})), PixelFx::Patchwork { square: 4.0, relief: 8.0 });
+    assert_eq!(fx("texture.patchwork", json!({"squareSize": -1, "relief": 26})), PixelFx::Patchwork { square: 0.0, relief: 25.0 });
+    assert_eq!(fx("texture.stainedGlass", json!({})), PixelFx::StainedGlass { cell: 10.0, border: 4.0, light: 3.0 });
+    assert_eq!(
+        fx("texture.stainedGlass", json!({"cellSize": 1, "borderThickness": 21, "lightIntensity": "1e999"})),
+        PixelFx::StainedGlass { cell: 2.0, border: 20.0, light: 3.0 }
+    );
+    let canvas = PixelFx::Texturizer { texture: Texture::Canvas, scaling: 1.0, relief: 4.0, light: Light::Top, invert: false };
+    assert_eq!(fx("texture.texturizer", json!({})), canvas);
+    assert_eq!(
+        fx("texture.texturizer", json!({"texture": "Brick", "scaling": 10, "relief": 60, "lightDirection": "bottomRight", "invert": true})),
+        PixelFx::Texturizer { texture: Texture::Brick, scaling: 0.5, relief: 50.0, light: Light::BottomRight, invert: true }
+    );
+    assert_eq!(
+        fx("texture.texturizer", json!({"texture": 3, "lightDirection": "up", "scaling": 1e9})),
+        PixelFx::Texturizer { texture: Texture::Canvas, scaling: 2.0, relief: 4.0, light: Light::Top, invert: false }
+    );
+    assert_eq!(fx("texture.grain", json!({"grainType": ["x"]})), fx("texture.grain", json!({})));
+    // Every menu value is documented in the catalogue and parses to a choice of its own.
+    for (id, key, table) in [
+        ("texture.grain", "grainType", GRAIN_TYPES.as_slice()),
+        ("texture.texturizer", "texture", TEXTURES.as_slice()),
+        ("texture.texturizer", "lightDirection", LIGHT_DIRECTIONS.as_slice()),
+    ] {
+        let doc = crate::effect_info(id).unwrap().params;
+        let parsed: Vec<PixelFx> = table.iter().map(|(_, v)| fx(id, json!({ key: v }))).collect();
+        for (i, (_, v)) in table.iter().enumerate() {
+            assert!(doc.contains(&format!("\"{v}\"")), "{id} {v}");
+            assert!(parsed.iter().skip(i + 1).all(|p| *p != parsed[i]), "{id} {v}");
+        }
+    }
+    // Panes and squares reach beyond the object; the surfaces stay on it.
+    let b = Rect::new(0.0, 0.0, 100.0, 50.0);
+    assert_eq!(fx("texture.stainedGlass", json!({"cellSize": 20})).outset(b), 30.0);
+    assert_eq!(fx("texture.patchwork", json!({"squareSize": 0})).outset(b), 1.0);
+    for id in ["texture.craquelure", "texture.grain", "texture.mosaicTiles", "texture.texturizer"] {
+        assert_eq!(fx(id, json!({})).outset(b), 0.0, "{id}");
+    }
+    assert_eq!(fx("texture.grain", json!({})).reach(), Some(0.0));
+    assert_eq!(fx("texture.craquelure", json!({"crackSpacing": 12})).reach(), Some(6.0));
+}
+
+/// The pixels of `d` (`w` wide) in the square `lo..hi` on both axes.
+fn square(d: &[u8], w: usize, lo: usize, hi: usize) -> Vec<[u8; 4]> {
+    (lo..hi).flat_map(|y| (lo..hi).map(move |x| (x, y))).map(|(x, y)| at(d, w, x, y)).collect()
+}
+
+/// A `w`-square raster of one colour.
+fn flat(w: usize, c: [u8; 4]) -> Vec<u8> {
+    image(w, w, |_, _| c)
+}
+
+#[test]
+fn craquelure_cracks_plates_and_contours() {
+    let w = 96;
+    let tan = [180, 150, 110, 255];
+    let mut d = flat(w, tan);
+    fx("texture.craquelure", json!({"crackBrightness": 10})).apply(&mut d, w, w, &space(w, w));
+    let px = square(&d, w, 16, 80);
+    let dark = px.iter().filter(|p| p[0] < 120).count() as f64 / px.len() as f64;
+    assert!((0.03..0.4).contains(&dark), "a network of dark cracks: {dark}");
+    assert!(px.iter().all(|p| p[3] == 255 && p[0] >= p[1] && p[1] >= p[2]), "the colour stays, darkened or lit");
+    assert!(px.iter().any(|p| p[0] > 182), "plate edges catch the light");
+    // Without depth there are no cracks and no relief; brightness lights the surface.
+    let mut flat_lit = flat(w, tan);
+    fx("texture.craquelure", json!({"crackDepth": 0, "crackBrightness": 10})).apply(&mut flat_lit, w, w, &space(w, w));
+    assert_eq!(flat_lit, flat(w, tan));
+    let mut dim = flat(w, tan);
+    fx("texture.craquelure", json!({"crackDepth": 0, "crackBrightness": 0})).apply(&mut dim, w, w, &space(w, w));
+    assert_eq!(at(&dim, w, 40, 40), [90, 75, 55, 255]);
+    // A dark half and a light half: a crack follows the contour between them, straight down (a
+    // dark line between lighter pixels in nearly every row), where one tone has none.
+    let craquelure = fx("texture.craquelure", json!({"crackSpacing": 100, "crackBrightness": 10}));
+    let rows_cracked = |src: Vec<u8>| {
+        let mut d = src;
+        craquelure.apply(&mut d, w, w, &space(w, w));
+        let v = |x: usize, y: usize| i32::from(at(&d, w, x, y)[0]);
+        (20..76).filter(|y| (26..35).any(|x| v(x, *y) + 8 < v(x - 2, *y) && v(x, *y) + 8 < v(x + 2, *y))).count()
+    };
+    let (contour, plain) = (rows_cracked(image(w, w, |x, _| grey(if x < 30 { 60 } else { 200 }))), rows_cracked(flat(w, grey(200))));
+    assert!(contour >= 48 && contour >= plain + 25, "{contour} rows cracked along the contour, {plain} without one");
+}
+
+#[test]
+fn grain_types_each_add_their_own_noise() {
+    let w = 48;
+    let mid = grey(128);
+    let mut seen: Vec<Vec<u8>> = Vec::new();
+    for (_, kind) in GRAIN_TYPES {
+        let mut d = flat(w, mid);
+        fx("texture.grain", json!({ "grainType": kind })).apply(&mut d, w, w, &space(w, w));
+        assert_ne!(d, flat(w, mid), "{kind} adds grain");
+        assert!(d.as_chunks::<4>().0.iter().all(|p| p[3] == 255), "{kind}: coverage stays");
+        assert!(!seen.contains(&d), "{kind}: a grain of its own");
+        seen.push(d);
+    }
+    // Regular grain is 1-point grains of every colour around the image's own.
+    let mut d = flat(w, mid);
+    fx("texture.grain", json!({})).apply(&mut d, w, w, &space(w, w));
+    let px = d.as_chunks::<4>().0;
+    let mean = px.iter().map(|p| f64::from(p[0])).sum::<f64>() / px.len() as f64;
+    assert!((mean - 128.0).abs() < 8.0, "{mean}");
+    assert!(px.iter().any(|p| p[0] != p[1]), "coloured grains");
+    // Horizontal grain runs in streaks along the rows.
+    let mut d = flat(w, mid);
+    fx("texture.grain", json!({"grainType": "horizontal", "intensity": 100})).apply(&mut d, w, w, &space(w, w));
+    let along = (0..w - 1).map(|x| u32::from(at(&d, w, x, 10)[0].abs_diff(at(&d, w, x + 1, 10)[0]))).sum::<u32>();
+    let across = (0..w - 1).map(|y| u32::from(at(&d, w, 10, y)[0].abs_diff(at(&d, w, 10, y + 1)[0]))).sum::<u32>();
+    assert!(along * 3 < across, "{along} along, {across} across");
+    // No intensity at neutral contrast leaves the image; contrast spreads its tones.
+    let ramp = image(w, w, |x, _| grey((x * 5) as u8));
+    let mut d = ramp.clone();
+    fx("texture.grain", json!({"intensity": 0})).apply(&mut d, w, w, &space(w, w));
+    assert_eq!(d, ramp);
+    fx("texture.grain", json!({"intensity": 0, "contrast": 100})).apply(&mut d, w, w, &space(w, w));
+    assert!(at(&d, w, 2, 0)[0] < at(&ramp, w, 2, 0)[0] && at(&d, w, 45, 0)[0] > at(&ramp, w, 45, 0)[0]);
+    // Sprinkles are the background colour, white.
+    let mut d = flat(w, [0, 0, 160, 255]);
+    fx("texture.grain", json!({"grainType": "sprinkles", "intensity": 100})).apply(&mut d, w, w, &space(w, w));
+    assert!(d.as_chunks::<4>().0.iter().any(|p| p[0] > 200 && p[2] > 240));
+}
+
+#[test]
+fn mosaic_tiles_lay_tiles_in_light_grout() {
+    let w = 96;
+    let blue = [40, 60, 160, 255];
+    let mut d = flat(w, blue);
+    fx("texture.mosaicTiles", json!({})).apply(&mut d, w, w, &space(w, w));
+    let px = square(&d, w, 8, 88);
+    let grout = px.iter().filter(|p| p[0] > 170).count() as f64 / px.len() as f64;
+    assert!((0.08..0.5).contains(&grout), "light grout between the tiles: {grout}");
+    assert!(px.iter().filter(|p| **p == blue).count() > px.len() / 10, "tile faces keep the colour");
+    // Dark grout without lightening.
+    let mut d = flat(w, blue);
+    fx("texture.mosaicTiles", json!({"lightenGrout": 0})).apply(&mut d, w, w, &space(w, w));
+    let px = square(&d, w, 8, 88);
+    let grout = px.iter().filter(|p| p[2] < 100).count() as f64 / px.len() as f64;
+    assert!((0.08..0.5).contains(&grout) && px.iter().all(|p| p[0] < 170), "dark grout: {grout}");
+    // Transparency around the object stays.
+    let mut d = image(w, w, |x, _| if x < 48 { blue } else { [0; 4] });
+    fx("texture.mosaicTiles", json!({})).apply(&mut d, w, w, &space(w, w));
+    assert!((0..w).all(|y| (48..w).all(|x| at(&d, w, x, y) == [0; 4])));
+}
+
+#[test]
+fn patchwork_fills_squares_with_one_colour_in_relief() {
+    let w = 64;
+    let src = image(w, w, |x, y| [(x * 4) as u8, (y * 4) as u8, 90, 255]);
+    let mut d = src.clone();
+    fx("texture.patchwork", json!({"squareSize": 8, "relief": 0})).apply(&mut d, w, w, &space(w, w));
+    // Squares of 8 points (the object's centre is a corner), each one colour.
+    for (i, j) in [(1, 1), (2, 5), (6, 3)] {
+        let first = at(&d, w, 8 * i, 8 * j);
+        assert!((0..8).all(|y| (0..8).all(|x| at(&d, w, 8 * i + x, 8 * j + y) == first)), "square {i} {j}");
+    }
+    assert_ne!(at(&d, w, 8, 8), at(&d, w, 16, 8));
+    // In relief, the squares' sides catch the light from the top left and fall into shade.
+    let mut lit = src.clone();
+    fx("texture.patchwork", json!({"squareSize": 8, "relief": 25})).apply(&mut lit, w, w, &space(w, w));
+    let (face, top, bottom) = (at(&lit, w, 28, 28)[1], at(&lit, w, 28, 24)[1], at(&lit, w, 28, 31)[1]);
+    assert!(top > face && bottom < face, "{top} {face} {bottom}");
+    // Squares around the object's edge are drawn whole.
+    let mut d = image(w, w, |x, _| if x < 30 { [200, 0, 0, 255] } else { [0; 4] });
+    fx("texture.patchwork", json!({"squareSize": 8, "relief": 0})).apply(&mut d, w, w, &space(w, w));
+    assert!((0..w).all(|y| at(&d, w, 31, y)[3] == 255 && at(&d, w, 33, y)[3] == 0));
+}
+
+#[test]
+fn stained_glass_leads_panes_and_lights_the_centre() {
+    let w = 96;
+    let src = image(w, w, |x, y| [(40 + x) as u8, (40 + y) as u8, 120, 255]);
+    let mut d = src.clone();
+    fx("texture.stainedGlass", json!({"lightIntensity": 0})).apply(&mut d, w, w, &space(w, w));
+    let px = square(&d, w, 16, 80);
+    let lead = px.iter().filter(|p| p[0] == 0 && p[1] == 0 && p[2] == 0).count() as f64 / px.len() as f64;
+    assert!((0.1..0.6).contains(&lead), "black lead: {lead}");
+    let same = (16..80).flat_map(|y| (16..79).map(move |x| (x, y))).filter(|(x, y)| at(&d, w, *x, *y) == at(&d, w, x + 1, *y)).count();
+    assert!(same * 5 > 2 * 64 * 63, "single-coloured panes: {same}");
+    assert!(px.iter().all(|p| p[3] == 255));
+    // The light shines through the middle, not the corners.
+    let mut lit = src.clone();
+    fx("texture.stainedGlass", json!({"lightIntensity": 10})).apply(&mut lit, w, w, &space(w, w));
+    let brighter = |x: usize, y: usize| i32::from(at(&lit, w, x, y)[2]) - i32::from(at(&d, w, x, y)[2]);
+    let centre = (44..52).flat_map(|y| (44..52).map(move |x| (x, y))).map(|(x, y)| brighter(x, y)).max().unwrap();
+    let corner = (0..6).flat_map(|y| (0..6).map(move |x| (x, y))).map(|(x, y)| brighter(x, y)).max().unwrap();
+    assert!(centre > 40 && corner * 3 < centre, "{centre} at the centre, {corner} in the corner");
+    // Panes beyond the object stay clear; lead outlines it.
+    let mut d = image(w, w, |x, y| if (24..72).contains(&x) && (24..72).contains(&y) { [200, 40, 40, 255] } else { [0; 4] });
+    fx("texture.stainedGlass", json!({})).apply(&mut d, w, w, &space(w, w));
+    assert!((0..6).all(|y| (0..w).all(|x| at(&d, w, x, y) == [0; 4])));
+    assert!(d.as_chunks::<4>().0.iter().all(|p| p[0] <= p[3] && p[1] <= p[3] && p[2] <= p[3]));
+}
+
+#[test]
+fn texturizer_lights_each_surface_from_its_side() {
+    let w = 64;
+    let mid = grey(150);
+    let run = |p: serde_json::Value| {
+        let mut d = flat(w, mid);
+        fx("texture.texturizer", p).apply(&mut d, w, w, &space(w, w));
+        d
+    };
+    let mut seen: Vec<Vec<u8>> = Vec::new();
+    for (_, texture) in TEXTURES {
+        let d = run(json!({ "texture": texture, "relief": 20 }));
+        assert_ne!(d, flat(w, mid), "{texture}");
+        assert!(!seen.contains(&d), "{texture}: a surface of its own");
+        // Inverted, the lit slopes are the shaded ones, and the other way round.
+        let inv = run(json!({ "texture": texture, "relief": 20, "invert": true }));
+        let shift = |d: &[u8]| d.as_chunks::<4>().0.iter().map(|p| i32::from(p[0]) - 150).collect::<Vec<_>>();
+        let (a, b) = (shift(&d), shift(&inv));
+        let opposite = a.iter().zip(&b).filter(|(a, b)| a.abs() > 4 && b.abs() > 4 && a.signum() != b.signum()).count();
+        let lit_or_shaded = a.iter().filter(|a| a.abs() > 4).count();
+        assert!(lit_or_shaded > 100 && opposite * 10 > lit_or_shaded * 8, "{texture}: {opposite} of {lit_or_shaded}");
+        // From the other side as well.
+        assert_ne!(run(json!({ "texture": texture, "relief": 20, "lightDirection": "bottom" })), d, "{texture}");
+        // No relief, no change.
+        assert_eq!(run(json!({ "texture": texture, "relief": 0 })), flat(w, mid), "{texture}");
+        seen.push(d);
+    }
+    // Scaling enlarges the surface: 200 % at 2 points a pixel draws as 100 % at 1.
+    let mut big = flat(w, mid);
+    let coarse = PixelSpace { to_doc: Affine::scale(2.0), px: 2.0, center: Point::new(64.0, 64.0), ..space(w, w) };
+    fx("texture.texturizer", json!({"texture": "brick", "scaling": 200, "relief": 20})).apply(&mut big, w, w, &coarse);
+    assert_eq!(big, run(json!({"texture": "brick", "relief": 20})));
+}
+
+/// The Texture filters' patterns lie in document space around the object's centre: the same at
+/// twice the resolution, and moving with the object.
+#[test]
+fn texture_patterns_follow_the_object_at_any_resolution() {
+    let (w, h) = (48, 48);
+    let art = |x: f64, y: f64| -> [u8; 4] {
+        if (8.0..40.0).contains(&x) && (8.0..40.0).contains(&y) { [(x * 5.0) as u8, (y * 5.0) as u8, 120, 255] } else { [0; 4] }
+    };
+    for (id, p) in [
+        ("texture.craquelure", json!({"crackSpacing": 8})),
+        ("texture.grain", json!({"grainType": "enlarged"})),
+        ("texture.mosaicTiles", json!({"tileSize": 8, "groutWidth": 2})),
+        ("texture.patchwork", json!({"squareSize": 6})),
+        ("texture.stainedGlass", json!({"cellSize": 8, "borderThickness": 2})),
+        ("texture.texturizer", json!({"texture": "sandstone", "relief": 10})),
+    ] {
+        let f = fx(id, p);
+        let mut one = image(w, h, |x, y| art(x as f64 + 0.5, y as f64 + 0.5));
+        f.apply(&mut one, w, h, &space(w, h));
+        let mut two = image(2 * w, 2 * h, |x, y| art((x as f64 + 0.5) / 2.0, (y as f64 + 0.5) / 2.0));
+        let fine = PixelSpace { to_doc: Affine::scale(0.5), px: 0.5, ..space(w, h) };
+        f.apply(&mut two, 2 * w, 2 * h, &fine);
+        let down = image(w, h, |x, y| {
+            let q = [(0, 0), (1, 0), (0, 1), (1, 1)].map(|(dx, dy)| at(&two, 2 * w, 2 * x + dx, 2 * y + dy));
+            std::array::from_fn(|c| (q.iter().map(|p| u32::from(p[c])).sum::<u32>() / 4) as u8)
+        });
+        let diff = one.iter().zip(&down).map(|(a, b)| f64::from(a.abs_diff(*b))).sum::<f64>() / one.len() as f64;
+        assert!(diff < 12.0, "{id}: {diff}");
+        let moved = PixelSpace { to_doc: Affine::translate((7.0, 3.0)), center: Point::new(31.0, 27.0), ..space(w, h) };
+        let mut shifted = image(w, h, |x, y| art(x as f64 + 0.5, y as f64 + 0.5));
+        f.apply(&mut shifted, w, h, &moved);
+        assert_eq!(shifted, one, "{id}");
+    }
+}

crates/effects/src/pixel/texture.rs

@@ -0,0 +1,576 @@
+//! Texture › Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass and Texturizer.
+//!
+//! Like the Pixelate filters' patterns, theirs (cracks, grain, tiles, squares, panes and the
+//! Texturizer's surfaces, all generated here, no image files) lie in document space around the
+//! object's centre: the same at any zoom or resolution, moving with the object, and the same on
+//! every redraw (hash noise of the pattern's cell indices). Surfaces in relief are height fields
+//! whose slopes, taken in document units, are lit from one side.
+
+use std::f64::consts::{FRAC_1_SQRT_2, PI};
+
+use vectorcraft_geom::{Point, Vec2};
+
+use super::pixelate::{AROUND, Around, Place, Soft, cell, gap, point_in, rand, value_noise};
+use super::{PixelSpace, blur_plane, pick};
+
+/// Grain's types, in its Grain Type menu's order: (label, parameter value).
+pub const GRAIN_TYPES: [(&str, &str); 10] = [
+    ("Regular", "regular"),
+    ("Soft", "soft"),
+    ("Sprinkles", "sprinkles"),
+    ("Clumped", "clumped"),
+    ("Contrasty", "contrasty"),
+    ("Enlarged", "enlarged"),
+    ("Stippled", "stippled"),
+    ("Horizontal", "horizontal"),
+    ("Vertical", "vertical"),
+    ("Speckle", "speckle"),
+];
+
+/// A Grain type ([`GRAIN_TYPES`]).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Grain {
+    Regular,
+    Soft,
+    Sprinkles,
+    Clumped,
+    Contrasty,
+    Enlarged,
+    Stippled,
+    Horizontal,
+    Vertical,
+    Speckle,
+}
+
+impl Grain {
+    const ALL: [Grain; 10] = [
+        Grain::Regular,
+        Grain::Soft,
+        Grain::Sprinkles,
+        Grain::Clumped,
+        Grain::Contrasty,
+        Grain::Enlarged,
+        Grain::Stippled,
+        Grain::Horizontal,
+        Grain::Vertical,
+        Grain::Speckle,
+    ];
+
+    /// The type of Grain Type `value` (a [`GRAIN_TYPES`] value, any case); Regular otherwise.
+    pub fn parse(value: &str) -> Self {
+        pick(&GRAIN_TYPES, &Self::ALL, value, Grain::Regular)
+    }
+}
+
+/// Texturizer's textures, in its Texture menu's order: (label, parameter value).
+pub const TEXTURES: [(&str, &str); 4] = [("Brick", "brick"), ("Burlap", "burlap"), ("Canvas", "canvas"), ("Sandstone", "sandstone")];
+
+/// A Texturizer surface ([`TEXTURES`]), made in code.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Texture {
+    Brick,
+    Burlap,
+    Canvas,
+    Sandstone,
+}
+
+impl Texture {
+    const ALL: [Texture; 4] = [Texture::Brick, Texture::Burlap, Texture::Canvas, Texture::Sandstone];
+
+    /// The texture of `value` (a [`TEXTURES`] value, any case); Canvas otherwise.
+    pub fn parse(value: &str) -> Self {
+        pick(&TEXTURES, &Self::ALL, value, Texture::Canvas)
+    }
+
+    /// The surface's height at `p` (points at 100 %), in points: slopes of about 1 at most.
+    fn height(self, p: Point) -> f64 {
+        match self {
+            Texture::Brick => brick(p),
+            Texture::Burlap => weave(p, 7.0, true),
+            Texture::Canvas => weave(p, 4.0, false),
+            Texture::Sandstone => sandstone(p),
+        }
+    }
+}
+
+/// Texturizer's light directions, in its Light menu's order: (label, parameter value).
+pub const LIGHT_DIRECTIONS: [(&str, &str); 8] = [
+    ("Bottom", "bottom"),
+    ("Bottom Left", "bottomLeft"),
+    ("Left", "left"),
+    ("Top Left", "topLeft"),
+    ("Top", "top"),
+    ("Top Right", "topRight"),
+    ("Right", "right"),
+    ("Bottom Right", "bottomRight"),
+];
+
+/// Where a surface is lit from ([`LIGHT_DIRECTIONS`]), on the page.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Light {
+    Bottom,
+    BottomLeft,
+    Left,
+    TopLeft,
+    Top,
+    TopRight,
+    Right,
+    BottomRight,
+}
+
+impl Light {
+    const ALL: [Light; 8] =
+        [Light::Bottom, Light::BottomLeft, Light::Left, Light::TopLeft, Light::Top, Light::TopRight, Light::Right, Light::BottomRight];
+
+    /// The direction of `value` (a [`LIGHT_DIRECTIONS`] value, any case); Top otherwise.
+    pub fn parse(value: &str) -> Self {
+        pick(&LIGHT_DIRECTIONS, &Self::ALL, value, Light::Top)
+    }
+
+    /// The unit vector towards the light (document axes, y down).
+    fn toward(self) -> Vec2 {
+        let d = FRAC_1_SQRT_2;
+        match self {
+            Light::Bottom => Vec2::new(0.0, 1.0),
+            Light::BottomLeft => Vec2::new(-d, d),
+            Light::Left => Vec2::new(-1.0, 0.0),
+            Light::TopLeft => Vec2::new(-d, -d),
+            Light::Top => Vec2::new(0.0, -1.0),
+            Light::TopRight => Vec2::new(d, -d),
+            Light::Right => Vec2::new(1.0, 0.0),
+            Light::BottomRight => Vec2::new(d, d),
+        }
+    }
+}
+
+/// Seeds of the Texture filters' patterns (Pixelate's use smaller salts).
+const SALT_CRACKS: u64 = 64;
+const SALT_GRAIN: u64 = 72;
+const SALT_TILES: u64 = 88;
+const SALT_PATCH: u64 = 96;
+const SALT_GLASS: u64 = 104;
+const SALT_SURFACE: u64 = 112;
+
+/// How soft Craquelure's tones are, as a share of the crack spacing: their contours become cracks.
+pub(super) const CONTOUR_SOFTNESS: f64 = 1.0 / 6.0;
+
+/// A pixel's straight colour (0..1).
+fn straight(p: [u8; 4]) -> [f32; 3] {
+    let a = f32::from(p[3]);
+    [p[0], p[1], p[2]].map(|v| if a > 0.0 { (f32::from(v) / a).min(1.0) } else { 0.0 })
+}
+
+/// The pixel of straight colour `c` at coverage `alpha` (0..1), premultiplied.
+fn premultiply(c: [f32; 3], alpha: f32) -> [u8; 4] {
+    let a = (alpha.clamp(0.0, 1.0) * 255.0).round();
+    let [r, g, b] = c.map(|v| (v.clamp(0.0, 1.0) * a).round().min(a) as u8);
+    [r, g, b, a as u8]
+}
+
+/// Colour `c` lit by `s`: darkened towards black below 0, lightened towards white above.
+fn lit(c: [f32; 3], s: f64) -> [f32; 3] {
+    let s = if s.is_finite() { s.clamp(-1.0, 1.0) as f32 } else { 0.0 };
+    c.map(|v| if s < 0.0 { v * (1.0 + s) } else { v + (1.0 - v) * s })
+}
+
+/// How a surface whose height rises along `slope` (height per length) faces a light from
+/// `toward`: 0 flat, positive facing it, negative turned away.
+fn facing(slope: Vec2, toward: Vec2) -> f64 {
+    -slope.dot(toward)
+}
+
+/// The share of a pixel `px` wide that lies within `d` of a line (negative `d`: beyond it).
+fn cover(d: f64, px: f64) -> f64 {
+    (d / px + 0.5).clamp(0.0, 1.0)
+}
+
+/// The luma of colour `c` (Rec. 601 weights).
+fn luma(c: [f32; 3]) -> f32 {
+    0.299 * c[0] + 0.587 * c[1] + 0.114 * c[2]
+}
+
+/// The two random points nearest to (`u`, `v`) (in cells), `point(i, j)` being cell (`i`, `j`)'s,
+/// found among the cells [`AROUND`] the one holding it.
+fn nearest_two(u: f64, v: f64, around: &mut Around<Point>, point: impl Fn(i64, i64) -> Point) -> Option<(Point, Point)> {
+    let (i, j) = (cell(u)?, cell(v)?);
+    let mut best: [(f64, Option<Point>); 2] = [(f64::INFINITY, None); 2];
+    for (k, (di, dj)) in AROUND.iter().enumerate() {
+        // A cell farther than the second point so far can't hold a nearer one.
+        if gap(i.wrapping_add(*di), u).hypot(gap(j.wrapping_add(*dj), v)) >= best[1].0 {
+            continue;
+        }
+        let Some(p) = around.get((i, j), k, &point) else { continue };
+        let d = (p.x - u).hypot(p.y - v);
+        if d < best[0].0 {
+            best = [(d, Some(p)), best[0]];
+        } else if d < best[1].0 {
+            best[1] = (d, Some(p));
+        }
+    }
+    Some((best[0].1?, best[1].1?))
+}
+
+/// How far (`u`, `v`) lies from the border between the cells of `near` and `next` (its nearest
+/// points, [`nearest_two`]), and the way away from it (unit), in cells.
+fn edge(u: f64, v: f64, near: Point, next: Point) -> (f64, Vec2) {
+    let q = Point::new(u, v);
+    let apart = near - next;
+    let len = apart.hypot();
+    if !(len.is_finite() && len > 1e-12) {
+        return (0.0, Vec2::ZERO);
+    }
+    (((q - next).hypot2() - (q - near).hypot2()) / (2.0 * len), apart / len)
+}
+
+/// The slope of a rise of 1 over `width` from a border at distance `d` (smooth at both ends).
+fn bevel(d: f64, width: f64) -> f64 {
+    if !(width.is_finite() && width > 0.0) {
+        return 0.0;
+    }
+    let t = (d / width).clamp(0.0, 1.0);
+    6.0 * t * (1.0 - t)
+}
+
+/// The object's straight luminance (0..1) softened by a Gaussian of `sigma` pixels, weighted by
+/// coverage so the transparency around it doesn't darken its edges.
+struct Tones {
+    v: Vec<f32>,
+    w: usize,
+    h: usize,
+}
+
+impl Tones {
+    fn new(px: &[[u8; 4]], w: usize, h: usize, sigma: f64) -> Self {
+        let mut l: Vec<f32> = px.iter().map(|p| luma([p[0], p[1], p[2]].map(f32::from)) / 255.0).collect();
+        let mut a: Vec<f32> = px.iter().map(|p| f32::from(p[3]) / 255.0).collect();
+        blur_plane(&mut l, w, h, sigma);
+        blur_plane(&mut a, w, h, sigma);
+        let v = l.iter().zip(&a).map(|(l, a)| if *a > 1e-4 { (l / a).clamp(0.0, 1.0) } else { 0.0 }).collect();
+        Self { v, w, h }
+    }
+
+    fn get(&self, x: usize, y: usize) -> f64 {
+        let (x, y) = (x.min(self.w.saturating_sub(1)), y.min(self.h.saturating_sub(1)));
+        self.v.get(y * self.w + x).map_or(0.0, |v| f64::from(*v))
+    }
+
+    /// The tone at pixel (`x`, `y`) and its slope per document unit along the document's axes.
+    fn slope(&self, x: usize, y: usize, place: &Place) -> (f64, Vec2) {
+        let gx = 0.5 * (self.get(x + 1, y) - self.get(x.saturating_sub(1), y));
+        let gy = 0.5 * (self.get(x, y + 1) - self.get(x, y.saturating_sub(1)));
+        // Per pixel → per document unit: through the transpose of the document → pixel map.
+        let [a, b, c, d, _, _] = place.to_px.as_coeffs();
+        (self.get(x, y), Vec2::new(gx * a + gy * b, gx * c + gy * d))
+    }
+}
+
+/// Craquelure: the object painted on relief plaster that cracks into plates about `spacing` apart
+/// and along the contours of its tones. `depth` (0..10) sets how deep and wide the cracks are and
+/// how high the plates and the tones stand; `brightness` (0..10) how brightly the surface is lit.
+pub(super) fn craquelure(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, spacing: f64, depth: f64, brightness: f64) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    if !(spacing.is_finite() && spacing > 0.0) {
+        return;
+    }
+    let depth = (depth / 10.0).clamp(0.0, 1.0);
+    let light = (0.5 + 0.05 * brightness.clamp(0.0, 10.0)) as f32;
+    let soft = CONTOUR_SOFTNESS * spacing;
+    let tones = Tones::new(px, w, h, soft / place.px);
+    let half = (0.15 + 0.6 * depth).min(0.15 * spacing);
+    let rise = (3.0 * half).max(0.12 * spacing);
+    let toward = Light::TopLeft.toward();
+    let mut around = Around::new();
+    place.each(px, |x, y, p| {
+        if p[3] == 0 {
+            return;
+        }
+        let q = place.at(x, y);
+        let (u, v) = (q.x / spacing, q.y / spacing);
+        // The cracks between the plates; each plate's edge bevels down into them.
+        let (mut crack, mut slope) = (0.0, Vec2::ZERO);
+        if let Some((near, next)) = nearest_two(u, v, &mut around, |i, j| point_in(SALT_CRACKS, i, j)) {
+            let (e, away) = edge(u, v, near, next);
+            crack = cover(half - e * spacing, place.px);
+            slope = away * (0.6 * bevel(e * spacing - half, rise));
+        }
+        // The cracks along the tones' contours (quarter, half and three-quarter tone).
+        let (tone, grad) = tones.slope(x, y, &place);
+        let steep = grad.hypot();
+        if steep > 1e-4 {
+            let level = (tone * 4.0).round().clamp(1.0, 3.0) / 4.0;
+            crack = crack.max(cover(0.8 * half - (tone - level).abs() / steep, place.px));
+        }
+        slope += grad * (0.8 * soft);
+        let c = lit(straight(*p), 0.5 * depth * facing(slope, toward));
+        let dark = (1.0 - 0.85 * crack * depth) as f32;
+        *p = premultiply(c.map(|v| v * light * dark), f32::from(p[3]) / 255.0);
+    });
+}
+
+/// A random value in [-1, 1) for the `size`-point cell holding `q`; `k` picks one of several.
+fn cell_noise(salt: u64, q: Point, size: f64, k: u64) -> f64 {
+    match (cell(q.x / size), cell(q.y / size)) {
+        (Some(i), Some(j)) => 2.0 * rand(salt, i, j, k) - 1.0,
+        _ => 0.0,
+    }
+}
+
+/// [`value_noise`] in [-1, 1) over cells `size` points wide.
+fn smooth_noise(salt: u64, q: Point, size: f64) -> f64 {
+    2.0 * value_noise(salt, q.x / size, q.y / size) - 1.0
+}
+
+/// Grain: noise of `kind` over the object in 1-point grains (2 for Enlarged, clumps for Clumped),
+/// as strong as `intensity` (0..100); `contrast` (0..100, 50 leaves it) sets the image's
+/// contrast. Sprinkles and Stippled use the background colour, white.
+pub(super) fn grain(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, intensity: f64, contrast: f64, kind: Grain) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    let a = (intensity / 100.0).clamp(0.0, 1.0);
+    let k = (0.5 + contrast / 100.0).clamp(0.5, 1.5) as f32;
+    let s = SALT_GRAIN;
+    place.each(px, |x, y, p| {
+        if p[3] == 0 {
+            return;
+        }
+        let q = place.at(x, y);
+        let mut c = straight(*p).map(|v| (v - 0.5) * k + 0.5);
+        let chance = 0.5 * (cell_noise(s, q, 1.0, 3) + 1.0);
+        match kind {
+            Grain::Regular => add(&mut c, |ch| cell_noise(s, q, 1.0, ch), 0.5 * a),
+            Grain::Soft => add(&mut c, |ch| smooth_noise(s + ch, q, 1.0), 0.4 * a),
+            Grain::Clumped => add(&mut c, |ch| 0.65 * smooth_noise(s + ch, q, 3.0) + 0.35 * cell_noise(s, q, 1.0, ch), 0.6 * a),
+            Grain::Enlarged => add(&mut c, |ch| 0.5 * (smooth_noise(s + ch, q, 2.0) + cell_noise(s, q, 2.0, ch)), 0.5 * a),
+            Grain::Contrasty => {
+                c = c.map(|v| (v - 0.5) * 1.4 + 0.5);
+                add(&mut c, |_| cell_noise(s, q, 1.0, 4), 0.6 * a);
+            }
+            Grain::Horizontal | Grain::Vertical => {
+                // Streaks one point thick: a value per row (column) drifting along it.
+                let (along, across) = if kind == Grain::Horizontal { (q.x, q.y) } else { (q.y, q.x) };
+                let line = cell(across).unwrap_or(0);
+                let n = 0.6 * (2.0 * rand(s, 0, line, 6) - 1.0) + 0.4 * (2.0 * value_noise(s + 7, along / 12.0, line as f64) - 1.0);
+                add(&mut c, |_| n, 0.5 * a);
+            }
+            Grain::Sprinkles => {
+                if chance < 0.35 * a {
+                    c = c.map(|v| v + (1.0 - v) * 0.9);
+                }
+            }
+            Grain::Speckle => {
+                if chance < 0.25 * a {
+                    c = c.map(|v| v * 0.25);
+                } else {
+                    add(&mut c, |_| cell_noise(s, q, 1.0, 5), 0.1 * a);
+                }
+            }
+            Grain::Stippled => {
+                // Dots of the colour where it is dark, the background between them.
+                let dots = f64::from(1.0 - luma(c).clamp(0.0, 1.0)) * (0.35 + 0.65 * a);
+                c = if chance < dots { c.map(|v| v * 0.6) } else { [1.0; 3] };
+            }
+        }
+        *p = premultiply(c, f32::from(p[3]) / 255.0);
+    });
+}
+
+/// Add noise `n(channel)` (-1..1) times `amount` to colour `c`.
+fn add(c: &mut [f32; 3], n: impl Fn(u64) -> f64, amount: f64) {
+    for (ch, v) in c.iter_mut().enumerate() {
+        *v += (amount * n(ch as u64)) as f32;
+    }
+}
+
+/// A random point of cell (`i`, `j`) of pattern `salt` within `jitter` (0..1, a share of the
+/// cell) of its centre, in cells.
+fn jittered(salt: u64, i: i64, j: i64, jitter: f64) -> Point {
+    Point::new(i as f64 + 0.5 + jitter * (rand(salt, i, j, 0) - 0.5), j as f64 + 0.5 + jitter * (rand(salt, i, j, 1) - 0.5))
+}
+
+/// Mosaic Tiles: the object laid in irregular tiles about `tile` across, bevelled at their edges,
+/// with sunken grout between them half a point wide per step of `grout` (1..15), as light as
+/// `lighten` (0..10) says.
+pub(super) fn mosaic_tiles(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, tile: f64, grout: f64, lighten: f64) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    if !(tile.is_finite() && tile > 0.0 && grout.is_finite()) {
+        return;
+    }
+    let half = (0.25 * grout).clamp(0.0, 0.225 * tile);
+    let rise = (1.2 * half).max(0.08 * tile);
+    let lighten = (0.08 * lighten.clamp(0.0, 10.0)) as f32;
+    let toward = Light::TopLeft.toward();
+    let mut around = Around::new();
+    place.each(px, |x, y, p| {
+        if p[3] == 0 {
+            return;
+        }
+        let q = place.at(x, y);
+        let (u, v) = (q.x / tile, q.y / tile);
+        let Some((near, next)) = nearest_two(u, v, &mut around, |i, j| jittered(SALT_TILES, i, j, 0.5)) else { return };
+        let (e, away) = edge(u, v, near, next);
+        let e = e * tile;
+        let c = straight(*p);
+        let face = lit(c, 0.35 * facing(away * bevel(e - half, rise), toward));
+        // Sunk in shade, then lightened.
+        let sunk = c.map(|v| 0.5 * v + (1.0 - 0.5 * v) * lighten);
+        let g = cover(half - e, place.px) as f32;
+        let mut out = face;
+        for (o, s) in out.iter_mut().zip(sunk) {
+            *o = *o * (1.0 - g) + s * g;
+        }
+        *p = premultiply(out, f32::from(p[3]) / 255.0);
+    });
+}
+
+/// Patchwork: the object in squares `square` points across, each filled with the colour around
+/// its centre and raised to a height of its own (brighter squares stand higher, each a little
+/// more or less at random), its bevelled sides lit from the top left as strongly as `relief`
+/// (0..25) says.
+pub(super) fn patchwork(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, square: f64, relief: f64) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    let side = square.max(1.0);
+    if !side.is_finite() {
+        return;
+    }
+    let soft = Soft::new(px, w, side / 3.0 / place.px);
+    let relief = (relief / 25.0).clamp(0.0, 1.0);
+    let rise = 0.25 * side;
+    let toward = Light::TopLeft.toward();
+    place.each(px, |x, y, p| {
+        let q = place.at(x, y);
+        let (Some(i), Some(j)) = (cell(q.x / side), cell(q.y / side)) else { return };
+        let (x0, y0) = (i as f64 * side, j as f64 * side);
+        let [r, g, b, alpha] = soft.at(place.index(Point::new(x0 + 0.5 * side, y0 + 0.5 * side)));
+        if alpha <= 0.0 {
+            *p = [0; 4];
+            return;
+        }
+        let c = [r, g, b].map(|v| v / alpha);
+        let height = relief * (0.35 + 0.65 * (0.5 * rand(SALT_PATCH, i, j, 0) + 0.5 * f64::from(luma(c))));
+        // The bevels rise inwards from each side.
+        let (fx, fy) = (q.x - x0, q.y - y0);
+        let ramp = |d: f64| cover(rise - d, place.px);
+        let slope = Vec2::new(ramp(fx) - ramp(side - fx), ramp(fy) - ramp(side - fy)) * (1.5 * height);
+        *p = premultiply(lit(c, 0.9 * facing(slope, toward)), alpha);
+    });
+}
+
+/// Stained Glass: the object as panes of single colours around random points about `cell_size`
+/// apart, leaded in the foreground colour (black) half a point wide per step of `border` (1..20),
+/// lit from behind at its centre as strongly as `light` (0..10) says, fading out towards its
+/// corners.
+pub(super) fn stained_glass(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, cell_size: f64, border: f64, light: f64) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    if !(cell_size.is_finite() && cell_size > 0.0 && border.is_finite()) {
+        return;
+    }
+    let soft = Soft::new(px, w, cell_size / place.px / 4.0);
+    let half = (0.25 * border).clamp(0.0, 0.25 * cell_size);
+    let light = (light / 10.0).clamp(0.0, 1.0);
+    let extent = space.extent;
+    let mut around = Around::new();
+    place.each(px, |x, y, p| {
+        let q = place.at(x, y);
+        let (u, v) = (q.x / cell_size, q.y / cell_size);
+        let Some((near, next)) = nearest_two(u, v, &mut around, |i, j| point_in(SALT_GLASS, i, j)) else { return };
+        let pane = |at: Point| soft.at(place.index(Point::new(at.x * cell_size, at.y * cell_size)));
+        let (glass, other) = (pane(near), pane(next));
+        let (e, _) = edge(u, v, near, next);
+        let lead = cover(half - e * cell_size, place.px) as f32;
+        let glow = if extent.is_finite() && extent > 0.0 { light * (1.0 - (q.to_vec2().hypot() / extent).powi(2)).max(0.0) } else { 0.0 };
+        let [r, g, b, a] = glass;
+        let c = if a > 0.0 { lit([r, g, b].map(|v| v / a), 0.6 * glow) } else { [0.0; 3] };
+        // The lead holds the panes on both sides of it, as opaque as the more opaque one.
+        let alpha = a * (1.0 - lead) + a.max(other[3]) * lead;
+        let rgb = c.map(|v| v * a * (1.0 - lead));
+        *p = if alpha > 0.0 { premultiply(rgb.map(|v| v / alpha), alpha) } else { [0; 4] };
+    });
+}
+
+/// Brick in stretcher bond (bricks 20 × 8 points, 1.5-point mortar): each brick raised with
+/// 1-point bevels and a little higher or lower than the next, rough faced, the mortar sandy.
+fn brick(p: Point) -> f64 {
+    const LENGTH: f64 = 20.0;
+    const COURSE: f64 = 8.0;
+    const MORTAR: f64 = 1.5;
+    let Some(row) = cell(p.y / COURSE) else { return 0.0 };
+    let x = p.x + if row.rem_euclid(2) == 1 { 0.5 * LENGTH } else { 0.0 };
+    let Some(col) = cell(x / LENGTH) else { return 0.0 };
+    let (fx, fy) = (x - col as f64 * LENGTH, p.y - row as f64 * COURSE);
+    let edge = fx.min(LENGTH - fx).min(fy).min(COURSE - fy) - 0.5 * MORTAR;
+    if edge <= 0.0 {
+        return 0.2 * value_noise(SALT_SURFACE, p.x / 0.6, p.y / 0.6);
+    }
+    edge.min(1.0) + 0.4 * rand(SALT_SURFACE, col, row, 2) + 0.3 * value_noise(SALT_SURFACE + 1, p.x / 1.5, p.y / 1.5)
+}
+
+/// A plain weave of threads `period` points apart, each passing over one thread and under the
+/// next; `coarse` threads (burlap) wander and are hairy, fine ones (canvas) are even.
+fn weave(p: Point, period: f64, coarse: bool) -> f64 {
+    let (wander, hair) = if coarse { (0.35, 0.35) } else { (0.08, 0.12) };
+    let drift = |salt: u64, t: f64| wander * (2.0 * value_noise(salt, t / (4.0 * period), 0.5) - 1.0);
+    let x = p.x / period + drift(SALT_SURFACE + 3, p.y);
+    let y = p.y / period + drift(SALT_SURFACE + 4, p.x);
+    let (Some(i), Some(j)) = (cell(x), cell(y)) else { return 0.0 };
+    let (fx, fy) = (x - i as f64, y - j as f64);
+    // Each thread is round across and rises and falls along its length, over one crossing thread
+    // and under the next; the higher of the two threads shows.
+    let profile = |t: f64| (PI * t).sin().max(0.0).sqrt();
+    let over = if i.wrapping_add(j).rem_euclid(2) == 0 { 0.5 } else { -0.5 };
+    let down = profile(fx) * (0.5 + over * (PI * fy).sin());
+    let across = profile(fy) * (0.5 - over * (PI * fx).sin());
+    let thread = down.max(across);
+    let fibres = hair * value_noise(SALT_SURFACE + 5, p.x / (0.25 * period), p.y / (0.25 * period));
+    (thread + fibres) * period / PI
+}
+
+/// Sandstone: four octaves of smooth noise (8 down to 1 point) over a fine sandy grain.
+fn sandstone(p: Point) -> f64 {
+    let (mut h, mut size, mut amp) = (0.0, 8.0, 1.6);
+    for octave in 0..4 {
+        h += amp * value_noise(SALT_SURFACE + 8 + octave, p.x / size, p.y / size);
+        size *= 0.5;
+        amp *= 0.5;
+    }
+    h + 0.06 * cell_noise(SALT_SURFACE + 12, p, 0.5, 0)
+}
+
+/// Texturizer: the object on a `texture` surface scaled by `scaling` (0.5..2), in relief as
+/// strong as `relief` (0..50) and lit from `light`; `invert` turns the surface's heights over.
+#[allow(clippy::too_many_arguments)] // the effect's five options
+pub(super) fn texturizer(
+    px: &mut [[u8; 4]],
+    w: usize,
+    h: usize,
+    space: &PixelSpace,
+    texture: Texture,
+    scaling: f64,
+    relief: f64,
+    light: Light,
+    invert: bool,
+) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    if !(scaling.is_finite() && scaling > 0.0) {
+        return;
+    }
+    // Slopes over a quarter point of the texture, or half a pixel where pixels are larger.
+    let step = (0.25f64).max(0.5 * place.px / scaling);
+    let strength = 0.1 * relief.clamp(0.0, 50.0) * if invert { -1.0 } else { 1.0 };
+    let toward = light.toward();
+    place.each(px, |x, y, p| {
+        if p[3] == 0 {
+            return;
+        }
+        let q = place.at(x, y);
+        let t = Point::new(q.x / scaling, q.y / scaling);
+        if !(t.x.is_finite() && t.y.is_finite()) {
+            return;
+        }
+        let at = |dx: f64, dy: f64| texture.height(Point::new(t.x + dx, t.y + dy));
+        let (left, right, up, down) = (at(-step, 0.0), at(step, 0.0), at(0.0, -step), at(0.0, step));
+        let slope = Vec2::new(right - left, down - up) / (2.0 * step);
+        // Ridges catch some light from any side and hollows stay in shade, so the surface shows
+        // whichever way it runs.
+        let ridge = (at(0.0, 0.0) - 0.25 * (left + right + up + down)) / step;
+        *p = premultiply(lit(straight(*p), strength * (facing(slope, toward) + ridge)), f32::from(p[3]) / 255.0);
+    });
+}

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

@@ -8,7 +8,7 @@ use vectorcraft_geom::Affine;
 
 use super::super::*;
 use super::pdfimport::LoadOptions;
-use super::{Format, SAVE_FORMATS, absolute_path, file_stamp, format, format_for_name, read_file};
+use super::{Format, SAVE_FORMATS, absolute_path, file_stamp, format, format_for_name, psdread, read_file};
 use crate::EngineError;
 
 /// A file read into a document, with its format and non-fatal import notes.
@@ -76,6 +76,9 @@ pub fn detect(name: &str, bytes: &[u8]) -> Option<&'static Format> {
     if let Some(kind) = vectorcraft_metafile::sniff(bytes) {
         return format(kind.id());
     }
+    if psdread::is_psd(bytes) {
+        return format(if psdread::is_psb(bytes) { "psb" } else { "psd" });
+    }
     if let Some(f) = image::guess_format(bytes).ok().and_then(image_format) {
         return Some(f);
     }
@@ -355,37 +358,50 @@ const MAX_RASTER_ALLOC: u64 = if cfg!(target_arch = "wasm32") { 512 << 20 } else
 
 /// Decode an image's header (and, for formats stored as PNG, its pixels). CMYK TIFFs are kept as
 /// they are, with their ink amounts ([`ImageBlob::cmyk`]); CMYK TIFFs with an alpha channel, which
-/// the decoder can't read, become RGBA in the active colour settings' CMYK.
+/// the decoder can't read, become RGBA in the active colour settings' CMYK, as do CMYK Photoshop
+/// documents, whose merged image is read ([`psdread`]).
 pub fn raster_image(bytes: &[u8]) -> Result<RasterImage> {
+    let ppi = super::ppi::resolution(bytes);
+    if psdread::is_psd(bytes) {
+        let cms = vectorcraft_color::cms::active();
+        return as_png(psdread::decode(bytes, MAX_RASTER_ALLOC, |c| cms.cmyk_to_srgb(c, false)).map_err(err)?, ppi);
+    }
     let mut reader = image::ImageReader::new(Cursor::new(bytes)).with_guessed_format().map_err(err)?;
     let mut limits = image::Limits::default();
     limits.max_alloc = Some(MAX_RASTER_ALLOC);
     reader.limits(limits);
     let kind = reader.format().ok_or_else(|| err("not an image VectorCraft reads (see document.formats)"))?;
     let f = image_format(kind).ok_or_else(|| err(format!("{kind:?} images can't be opened (see document.formats)")))?;
-    let ppi = super::ppi::resolution(bytes);
     let cmyk = || ImageBlob::new(f.mime, bytes.to_vec()).cmyk().is_some();
-    let (bytes, mime, (width, height)) = if matches!(f.id, "png" | "jpg" | "gif" | "webp") || (f.id == "tiff" && cmyk()) {
-        (bytes.to_vec(), f.mime, reader.into_dimensions().map_err(err)?)
-    } else {
-        let cmyka = || {
-            let cms = vectorcraft_color::cms::active();
-            vectorcraft_doc::cmyk::cmyka_tiff_rgba(bytes, |c| cms.cmyk_to_srgb(c, false))
-        };
-        let img = match (f.id == "tiff").then(cmyka).flatten() {
-            Some(img) => img,
-            None => reader.decode().map_err(err)?.to_rgba8(),
-        };
-        let size = img.dimensions();
-        let mut png = Vec::new();
-        img.write_to(&mut Cursor::new(&mut png), image::ImageFormat::Png).map_err(err)?;
-        // The stored PNG keeps the file's resolution.
-        let png = match ppi {
-            Some(r) => super::ppi::with_png_resolution(&png, r),
-            None => png,
-        };
-        (png, "image/png", size)
+    if matches!(f.id, "png" | "jpg" | "gif" | "webp") || (f.id == "tiff" && cmyk()) {
+        let (width, height) = reader.into_dimensions().map_err(err)?;
+        return stored(bytes.to_vec(), f.mime, (width, height), ppi);
+    }
+    let cmyka = || {
+        let cms = vectorcraft_color::cms::active();
+        vectorcraft_doc::cmyk::cmyka_tiff_rgba(bytes, |c| cms.cmyk_to_srgb(c, false))
     };
+    let img = match (f.id == "tiff").then(cmyka).flatten() {
+        Some(img) => img,
+        None => reader.decode().map_err(err)?.to_rgba8(),
+    };
+    as_png(img, ppi)
+}
+
+/// `img` stored as a PNG that keeps the file's resolution.
+fn as_png(img: image::RgbaImage, ppi: Option<(f64, f64)>) -> Result<RasterImage> {
+    let size = img.dimensions();
+    let mut png = Vec::new();
+    img.write_to(&mut Cursor::new(&mut png), image::ImageFormat::Png).map_err(err)?;
+    let png = match ppi {
+        Some(r) => super::ppi::with_png_resolution(&png, r),
+        None => png,
+    };
+    stored(png, "image/png", size, ppi)
+}
+
+/// An image's encoded `bytes`, `width` × `height` pixels, ready to embed.
+fn stored(bytes: Vec<u8>, mime: &'static str, (width, height): (u32, u32), ppi: Option<(f64, f64)>) -> Result<RasterImage> {
     if width == 0 || height == 0 {
         return Err(err("the image is empty"));
     }

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

@@ -34,6 +34,7 @@ pub mod pdf;
 mod pdfimport;
 pub mod pngtext;
 pub mod ppi;
+pub mod psdread;
 mod save;
 mod screens;
 mod svg;
@@ -558,10 +559,12 @@ pub const FORMATS: &[Format] = &[
     Format { id: "emf", label: "EMF", extensions: &["emf"], mime: "image/emf", read: true, write: true, raster: false, options: metafile::OPTIONS },
     Format { id: "wmf", label: "WMF", extensions: &["wmf"], mime: "image/wmf", read: true, write: true, raster: false, options: metafile::OPTIONS },
     Format { id: "tga", label: "Targa", extensions: &["tga"], mime: "image/x-tga", read: false, write: true, raster: true, options: TGA_OPTIONS },
-    Format { id: "psd", label: "PSD", extensions: &["psd"], mime: "image/x-psd", read: false, write: true, raster: true, options: PSD_OPTIONS },
+    Format { id: "psd", label: "PSD", extensions: &["psd"], mime: "image/x-psd", read: true, write: true, raster: true, options: PSD_OPTIONS },
     // Affinity Photo's `.afphoto` opens by its content but isn't listed: Finder shouldn't offer a
     // vector app for a raster editor's documents.
     reader("affinity", "Affinity", &["af", "afdesign", "afpub"], "application/vnd.affinity", false),
+    // Photoshop's large document format: read like a PSD (its merged image), never written.
+    reader("psb", "PSB", &["psb"], "image/x-psb", true),
 ];
 
 /// Every extension `document.open` reads (the "All readable files" filter of open dialogs).
@@ -581,6 +584,8 @@ pub const OPEN_EXTS: &[&str] = &[
     "tif",
     "tiff",
     "bmp",
+    "psd",
+    "psb",
     "vctemplate",
     "dxf",
     "emf",
@@ -591,6 +596,11 @@ pub const OPEN_EXTS: &[&str] = &[
     "afpub",
 ];
 
+/// Extensions in [`OPEN_EXTS`] the desktop packaging doesn't associate with VectorCraft: Photoshop
+/// documents belong to raster editors, so Finder and file managers don't offer a vector app for
+/// them (File › Open and Place still read them).
+pub const UNASSOCIATED_EXTS: &[&str] = &["psd", "psb"];
+
 /// The extension that picks each writable format when exporting (the format's first; PNG-8 shares
 /// `.png` with PNG, so `.png` comes once), in [`FORMATS`] order.
 pub fn export_extensions() -> Vec<&'static str> {
@@ -623,6 +633,8 @@ pub const PLACE_EXTS: &[&str] = &[
     "tif",
     "tiff",
     "bmp",
+    "psd",
+    "psb",
     "vctemplate",
     "dxf",
     "emf",
@@ -640,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)))
@@ -979,6 +993,8 @@ mod tests_tiffbmp;
 mod tests_pdfx;
 #[cfg(test)]
 mod tests_psd;
+#[cfg(test)]
+mod tests_psdread;
 
 #[cfg(test)]
 mod tests_epsimport;

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

@@ -1,6 +1,7 @@
 //! Image resolution metadata (pixels per inch): PNG `pHYs`, JPEG JFIF density or EXIF, TIFF and
-//! WebP EXIF resolution tags, BMP pixels per metre. Place sizes an image by it (72 ppi when the file
-//! has none); images converted to PNG on import keep it as a `pHYs` chunk.
+//! WebP EXIF resolution tags, BMP pixels per metre, a Photoshop document's ResolutionInfo. Place
+//! sizes an image by it (72 ppi when the file has none); images converted to PNG on import keep it
+//! as a `pHYs` chunk.
 
 const INCH_M: f64 = 0.0254;
 const INCH_CM: f64 = 2.54;
@@ -18,6 +19,8 @@ pub fn resolution(bytes: &[u8]) -> Option<(f64, f64)> {
         webp(bytes)
     } else if bytes.starts_with(b"BM") {
         bmp(bytes)
+    } else if super::psdread::is_psd(bytes) {
+        super::psdread::resolution(bytes)
     } else {
         None
     };

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

@@ -0,0 +1,370 @@
+//! Reading Photoshop documents (PSD, and PSB, the large document format) for File › Open and
+//! File › Place (#918): the merged image, the flattened picture every PSD carries after its layers,
+//! as a linked PSD shows. Written from Adobe's public "Photoshop File Formats Specification"
+//! (<https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/>). Layers aren't read.
+//!
+//! Every mode Photoshop saves a merged image in is read: Bitmap, Grayscale, Duotone (as its
+//! grayscale data), Indexed, RGB, CMYK and Lab, at 1, 8, 16 and 32 bits per channel, stored raw,
+//! PackBits-compressed or zipped. The merged image of a document with transparency is stored on
+//! white with its alpha in the first extra channel: it comes back with straight colours. The file
+//! is untrusted: every read is checked and the image's size is capped before anything is
+//! allocated.
+
+use std::io::Read;
+
+use vectorcraft_color::cms::{Lab, lab::lab_to_srgb};
+
+/// Photoshop's colour modes (the header's numbers), as far as the merged image is concerned.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Mode {
+    Bitmap,
+    Gray,
+    Indexed,
+    Rgb,
+    Cmyk,
+    Lab,
+}
+
+impl Mode {
+    /// The channels holding colour (an alpha channel may follow them).
+    fn colors(self) -> usize {
+        match self {
+            Mode::Bitmap | Mode::Gray | Mode::Indexed => 1,
+            Mode::Rgb | Mode::Lab => 3,
+            Mode::Cmyk => 4,
+        }
+    }
+}
+
+/// Is `bytes` a Photoshop document (PSD or PSB)?
+pub fn is_psd(bytes: &[u8]) -> bool {
+    bytes.starts_with(b"8BPS") && matches!(bytes.get(4..6), Some([0, 1] | [0, 2]))
+}
+
+/// Is `bytes` a PSB, Photoshop's large document format?
+pub fn is_psb(bytes: &[u8]) -> bool {
+    is_psd(bytes) && bytes.get(4..6) == Some(&[0, 2])
+}
+
+const TRUNCATED: &str = "the PSD file is cut short";
+const DAMAGED: &str = "the PSD file's header is damaged";
+
+/// Big-endian reads through `b`, each checked against its end.
+struct Reader<'a> {
+    b: &'a [u8],
+    at: usize,
+}
+
+impl<'a> Reader<'a> {
+    fn new(b: &'a [u8]) -> Self {
+        Self { b, at: 0 }
+    }
+    fn take(&mut self, n: usize) -> Result<&'a [u8], String> {
+        let s = self.at.checked_add(n).and_then(|end| self.b.get(self.at..end)).ok_or(TRUNCATED)?;
+        self.at += n;
+        Ok(s)
+    }
+    fn array<const N: usize>(&mut self) -> Result<[u8; N], String> {
+        self.take(N)?.try_into().map_err(|_| TRUNCATED.to_string())
+    }
+    fn u8(&mut self) -> Result<u8, String> {
+        self.array::<1>().map(|[v]| v)
+    }
+    fn u16(&mut self) -> Result<u16, String> {
+        self.array().map(u16::from_be_bytes)
+    }
+    fn u32(&mut self) -> Result<u32, String> {
+        self.array().map(u32::from_be_bytes)
+    }
+    /// A section length: 4 bytes in a PSD, 8 in a PSB.
+    fn length(&mut self, psb: bool) -> Result<usize, String> {
+        let n = if psb { self.array().map(u64::from_be_bytes)? } else { u64::from(self.u32()?) };
+        usize::try_from(n).map_err(|_| TRUNCATED.to_string())
+    }
+    /// A section: its length, then that many bytes.
+    fn section(&mut self, psb: bool) -> Result<&'a [u8], String> {
+        let n = self.length(psb)?;
+        self.take(n)
+    }
+    fn rest(&self) -> &'a [u8] {
+        self.b.get(self.at..).unwrap_or_default()
+    }
+}
+
+/// The fixed-size header and the sections before the image data.
+struct Header<'a> {
+    psb: bool,
+    channels: usize,
+    width: u32,
+    height: u32,
+    depth: u16,
+    mode: Mode,
+    /// Colour mode data: an indexed image's palette (256 reds, then greens, then blues).
+    palette: &'a [u8],
+    /// The image resources.
+    resources: &'a [u8],
+    /// The layer and mask information.
+    layers: &'a [u8],
+}
+
+fn header<'a>(r: &mut Reader<'a>) -> Result<Header<'a>, String> {
+    if !is_psd(r.b) {
+        return Err("not a PSD file".into());
+    }
+    r.take(4)?;
+    let psb = r.u16()? == 2;
+    r.take(6)?;
+    let channels = usize::from(r.u16()?);
+    let height = r.u32()?;
+    let width = r.u32()?;
+    let depth = r.u16()?;
+    let mode = match r.u16()? {
+        0 => Mode::Bitmap,
+        // Duotone documents keep their grayscale data in the merged image.
+        1 | 8 => Mode::Gray,
+        2 => Mode::Indexed,
+        3 => Mode::Rgb,
+        4 => Mode::Cmyk,
+        9 => Mode::Lab,
+        7 => return Err("Multichannel PSD files can't be read: save it in RGB, CMYK or Grayscale mode".into()),
+        m => return Err(format!("the PSD file has an unknown colour mode ({m})")),
+    };
+    let max_side = if psb { 300_000 } else { 30_000 };
+    if !(1..=56).contains(&channels) || channels < mode.colors() || !(1..=max_side).contains(&width) || !(1..=max_side).contains(&height) {
+        return Err(DAMAGED.into());
+    }
+    let depth_ok = match mode {
+        Mode::Bitmap => depth == 1,
+        Mode::Indexed => depth == 8,
+        Mode::Cmyk | Mode::Lab => matches!(depth, 8 | 16),
+        Mode::Gray | Mode::Rgb => matches!(depth, 8 | 16 | 32),
+    };
+    if !depth_ok {
+        return Err(format!("{depth}-bit PSD files in this colour mode can't be read"));
+    }
+    let palette = r.section(false)?;
+    let resources = r.section(false)?;
+    let layers = r.section(psb)?;
+    Ok(Header { psb, channels, width, height, depth, mode, palette, resources, layers })
+}
+
+/// The resolution a Photoshop document declares (pixels per inch, across and down), from its
+/// ResolutionInfo resource (1005).
+pub fn resolution(bytes: &[u8]) -> Option<(f64, f64)> {
+    let mut r = Reader::new(bytes);
+    let h = header(&mut r).ok()?;
+    let mut r = Reader::new(h.resources);
+    while !r.rest().is_empty() {
+        r.take(4).ok()?;
+        let id = r.u16().ok()?;
+        // A Pascal string padded to an even size, length byte included.
+        let name = usize::from(r.u8().ok()?);
+        r.take(name + (name + 1) % 2).ok()?;
+        let size = usize::try_from(r.u32().ok()?).ok()?;
+        let data = r.take(size).ok()?;
+        r.take(size % 2).ok()?;
+        if id == 0x03ed {
+            let mut d = Reader::new(data);
+            // Fixed 16.16 values, each with its unit (1: per inch, 2: per centimetre) and the
+            // unit the size is shown in.
+            let mut axis = || -> Option<f64> {
+                let v = f64::from(d.u32().ok()?) / 65536.0;
+                let unit = d.u16().ok()?;
+                d.u16().ok()?;
+                Some(if unit == 2 { v * 2.54 } else { v })
+            };
+            return Some((axis()?, axis()?));
+        }
+    }
+    None
+}
+
+/// Does the merged image keep its transparency in the first extra channel? Yes when the layer
+/// count is negative: in the layer info, or for 16- and 32-bit documents (whose layer info is
+/// empty) in their `Lr16` / `Lr32` block.
+fn merged_alpha(layers: &[u8], psb: bool) -> bool {
+    let count_negative = |info: &[u8]| info.get(..2).is_some_and(|c| i16::from_be_bytes([c[0], c[1]]) < 0);
+    let mut r = Reader::new(layers);
+    let Ok(info) = r.section(psb) else { return false };
+    if !info.is_empty() {
+        return count_negative(info);
+    }
+    // The global layer mask info, then tagged blocks: signature, key, length (8 bytes for the
+    // layer blocks of a PSB), data padded to 4 bytes.
+    if r.section(false).is_err() {
+        return false;
+    }
+    while r.rest().len() >= 12 {
+        let (Ok(_), Ok(key)) = (r.take(4), r.array::<4>()) else { return false };
+        let layer_block = matches!(&key, b"Lr16" | b"Lr32" | b"Layr");
+        let long = layer_block || matches!(&key, b"LMsk" | b"Mt16" | b"Mt32" | b"Mtrn" | b"Alph" | b"FMsk" | b"lnk2" | b"FEid" | b"FXid" | b"PxSD");
+        let Ok(data) = r.section(psb && long) else {
+            return false;
+        };
+        if layer_block {
+            return count_negative(data);
+        }
+        if r.take((4 - data.len() % 4) % 4).is_err() {
+            return false;
+        }
+    }
+    false
+}
+
+/// The most bytes one channel row may take (a PSB at 32 bits).
+fn row_bytes(width: usize, depth: u16) -> usize {
+    if depth == 1 { width.div_ceil(8) } else { width * usize::from(depth / 8) }
+}
+
+/// Undo PackBits: `src` into `dst` (a row; a short or overlong run leaves the rest as it is).
+fn unpack_bits(mut src: &[u8], dst: &mut [u8]) {
+    let mut at = 0;
+    while let Some((&n, rest)) = src.split_first() {
+        src = rest;
+        let n = n as i8;
+        if n >= 0 {
+            let len = usize::from(n.unsigned_abs()) + 1;
+            let (run, rest) = src.split_at(len.min(src.len()));
+            src = rest;
+            for &b in run {
+                if let Some(d) = dst.get_mut(at) {
+                    *d = b;
+                }
+                at += 1;
+            }
+        } else if n != -128 {
+            let Some((&b, rest)) = src.split_first() else { break };
+            src = rest;
+            let len = usize::from(n.unsigned_abs()) + 1;
+            for d in dst.iter_mut().skip(at).take(len) {
+                *d = b;
+            }
+            at += len;
+        }
+        if at >= dst.len() {
+            break;
+        }
+    }
+}
+
+/// The first `channels` channels of the image data (after its compression method), each as
+/// `height` rows of `row` bytes, one after the other.
+fn channel_data(data: &[u8], h: &Header<'_>, channels: usize, row: usize) -> Result<Vec<u8>, String> {
+    let (rows, all) = (h.height as usize, h.channels);
+    let mut r = Reader::new(data);
+    let method = r.u16()?;
+    let wanted = channels * rows * row;
+    match method {
+        0 => r.take(wanted).map(<[u8]>::to_vec),
+        1 => {
+            // Every row's byte count (4 bytes each in a PSB), channel by channel: those of the
+            // channels read, then the others'.
+            let size = if h.psb { 4 } else { 2 };
+            let counts = r.take(channels * rows * size)?;
+            r.take((all - channels) * rows * size)?;
+            let counts = counts.chunks_exact(size).map(|c| c.iter().fold(0usize, |n, &b| n << 8 | usize::from(b)));
+            let mut out = vec![0; wanted];
+            for (dst, n) in out.chunks_exact_mut(row).zip(counts) {
+                unpack_bits(r.take(n)?, dst);
+            }
+            Ok(out)
+        }
+        2 | 3 => {
+            let mut out = Vec::new();
+            flate2::read::ZlibDecoder::new(r.rest())
+                .take(wanted as u64)
+                .read_to_end(&mut out)
+                .map_err(|e| format!("the PSD file's image data can't be read: {e}"))?;
+            if out.len() < wanted {
+                return Err(TRUNCATED.into());
+            }
+            if method == 3 {
+                // Each row stores the difference from the sample before it.
+                match h.depth {
+                    8 => out.chunks_exact_mut(row).for_each(|r| (1..r.len()).for_each(|i| r[i] = r[i].wrapping_add(r[i - 1]))),
+                    16 => out.chunks_exact_mut(row).for_each(|r| {
+                        let mut prev = 0u16;
+                        for s in r.as_chunks_mut::<2>().0 {
+                            prev = prev.wrapping_add(u16::from_be_bytes(*s));
+                            *s = prev.to_be_bytes();
+                        }
+                    }),
+                    _ => return Err("zipped 32-bit PSD image data with prediction can't be read".into()),
+                }
+            }
+            Ok(out)
+        }
+        m => Err(format!("the PSD file's image data uses an unknown compression ({m})")),
+    }
+}
+
+/// sRGB's transfer curve, for 32-bit documents, whose values are linear.
+fn srgb_encode(v: f32) -> f32 {
+    if v <= 0.003_130_8 { v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 }
+}
+
+/// Sample `x` of a channel row, 0..1.
+fn sample(row: &[u8], x: usize, depth: u16, linear: bool) -> f32 {
+    match depth {
+        1 => {
+            // Bitmap: a set bit is black.
+            let bit = row.get(x / 8).map_or(0, |b| (b >> (7 - x % 8)) & 1);
+            if bit == 1 { 0.0 } else { 1.0 }
+        }
+        16 => row.get(x * 2..x * 2 + 2).map_or(0.0, |s| f32::from(u16::from_be_bytes([s[0], s[1]])) / 65535.0),
+        32 => {
+            let v = row.get(x * 4..x * 4 + 4).map_or(0.0, |s| f32::from_be_bytes([s[0], s[1], s[2], s[3]]));
+            let v = if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 };
+            if linear { srgb_encode(v) } else { v }
+        }
+        _ => row.get(x).map_or(0.0, |&b| f32::from(b) / 255.0),
+    }
+}
+
+fn byte(v: f32) -> u8 {
+    (v.clamp(0.0, 1.0) * 255.0).round() as u8
+}
+
+/// A Photoshop document's merged image as straight RGBA. CMYK converts through `cmyk` (ink
+/// amounts 0..1 → sRGB). Fails, without allocating, when the image would need more than
+/// `max_alloc` bytes.
+pub fn decode(bytes: &[u8], max_alloc: u64, cmyk: impl Fn([f32; 4]) -> [f32; 3]) -> Result<image::RgbaImage, String> {
+    let mut r = Reader::new(bytes);
+    let h = header(&mut r)?;
+    let colors = h.mode.colors();
+    let alpha = h.channels > colors && merged_alpha(h.layers, h.psb);
+    let channels = colors + usize::from(alpha);
+    let (w, rows) = (h.width as usize, h.height as usize);
+    let row = row_bytes(w, h.depth);
+    // The channels read and the RGBA image made of them.
+    let need = (channels as u64 * row as u64).saturating_add(4 * w as u64).saturating_mul(rows as u64);
+    if need > max_alloc {
+        return Err(format!("the PSD image is too large to read ({} × {} pixels)", h.width, h.height));
+    }
+    let data = channel_data(r.rest(), &h, channels, row)?;
+    let mut out = image::RgbaImage::new(h.width, h.height);
+    let linear = h.depth == 32;
+    for (y, line) in out.rows_mut().enumerate() {
+        let planes: Vec<&[u8]> = (0..channels).map(|c| data.get((c * rows + y) * row..(c * rows + y + 1) * row).unwrap_or_default()).collect();
+        for (x, px) in line.enumerate() {
+            let v = |c: usize| planes.get(c).map_or(0.0, |p| sample(p, x, h.depth, linear && c < colors));
+            let rgb = match h.mode {
+                Mode::Bitmap | Mode::Gray => [v(0); 3],
+                Mode::Indexed => {
+                    let i = usize::from(byte(v(0)));
+                    [0, 256, 512].map(|at| h.palette.get(at + i).map_or(0.0, |&c| f32::from(c) / 255.0))
+                }
+                Mode::Rgb => [v(0), v(1), v(2)],
+                // Inks are stored as 1 − amount.
+                Mode::Cmyk => cmyk([0, 1, 2, 3].map(|c| 1.0 - v(c))),
+                Mode::Lab => lab_to_srgb(Lab { l: v(0) * 100.0, a: v(1) * 255.0 - 128.0, b: v(2) * 255.0 - 128.0 }),
+            };
+            let a = if alpha { v(colors) } else { 1.0 };
+            // The merged image is stored on white: take the white back out.
+            let straight = |c: f32| if a <= 0.0 { 0.0 } else { (c - (1.0 - a)) / a };
+            let rgb = if alpha { rgb.map(straight) } else { rgb };
+            px.0 = [byte(rgb[0]), byte(rgb[1]), byte(rgb[2]), byte(a)];
+        }
+    }
+    Ok(out)
+}

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/fileio/tests_psd.rs

@@ -77,7 +77,7 @@ fn psd_is_listed_with_its_options_and_writes_one_file_per_artboard() {
     let psd = r["formats"].as_array().unwrap().iter().find(|f| f["id"] == "psd").unwrap().clone();
     assert_eq!(
         (psd["label"].as_str(), psd["write"].as_bool(), psd["read"].as_bool(), psd["raster"].as_bool()),
-        (Some("PSD"), Some(true), Some(false), Some(true))
+        (Some("PSD"), Some(true), Some(true), Some(true))
     );
     for k in ["colorModel", "layers", "maxEditability", "hiddenLayers", "embedIcc", "ppi", "antiAlias", "background"] {
         assert!(psd["options"].get(k).is_some(), "psd takes {k}");

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

@@ -0,0 +1,244 @@
+//! Reading Photoshop documents (#918): the merged image of every colour mode, depth and
+//! compression, PSB files, transparency, the resolution, and damaged files refused without a panic.
+
+use serde_json::{Value, json};
+
+use super::psdread::{decode, is_psd, resolution};
+use super::*;
+
+/// A Photoshop document built from its parts: `version` 1 (PSD) or 2 (PSB), the header's fields,
+/// then the colour mode data, resources, layer and mask section and image data as given.
+#[allow(clippy::too_many_arguments)]
+fn psd(
+    version: u16,
+    channels: u16,
+    (w, h): (u32, u32),
+    depth: u16,
+    mode: u16,
+    palette: &[u8],
+    resources: &[u8],
+    layers: &[u8],
+    image: &[u8],
+) -> Vec<u8> {
+    let mut f = b"8BPS".to_vec();
+    f.extend(version.to_be_bytes());
+    f.extend([0; 6]);
+    f.extend(channels.to_be_bytes());
+    f.extend(h.to_be_bytes());
+    f.extend(w.to_be_bytes());
+    f.extend(depth.to_be_bytes());
+    f.extend(mode.to_be_bytes());
+    for part in [palette, resources] {
+        f.extend((part.len() as u32).to_be_bytes());
+        f.extend(part);
+    }
+    if version == 2 {
+        f.extend((layers.len() as u64).to_be_bytes());
+    } else {
+        f.extend((layers.len() as u32).to_be_bytes());
+    }
+    f.extend(layers);
+    f.extend(image);
+    f
+}
+
+/// Raw image data: the compression method (0), then the planes.
+fn raw(planes: &[&[u8]]) -> Vec<u8> {
+    let mut d = vec![0, 0];
+    planes.iter().for_each(|p| d.extend(*p));
+    d
+}
+
+/// A layer and mask section whose layer info holds just the layer `count` (negative: the merged
+/// image's first extra channel is its transparency).
+fn layer_count(count: i16, psb: bool) -> Vec<u8> {
+    let mut s = if psb { 2u64.to_be_bytes().to_vec() } else { 2u32.to_be_bytes().to_vec() };
+    s.extend(count.to_be_bytes());
+    s
+}
+
+/// Straight sRGB through a naive CMYK conversion (tests don't depend on colour settings).
+fn naive(c: [f32; 4]) -> [f32; 3] {
+    [0, 1, 2].map(|i| (1.0 - c[i]) * (1.0 - c[3]))
+}
+
+fn pixels(f: &[u8]) -> Vec<[u8; 4]> {
+    decode(f, 1 << 30, naive).unwrap().pixels().map(|p| p.0).collect()
+}
+
+#[test]
+fn every_colour_mode_and_depth_reads() {
+    // Grayscale, 16 bits.
+    let g = psd(1, 1, (2, 1), 16, 1, &[], &[], &[], &raw(&[&[0, 0, 0xff, 0xff]]));
+    assert!(is_psd(&g));
+    assert_eq!(pixels(&g), [[0, 0, 0, 255], [255, 255, 255, 255]]);
+    // Bitmap: a set bit is black.
+    let b = psd(1, 1, (9, 1), 1, 0, &[], &[], &[], &raw(&[&[0b1000_0000, 0b1000_0000]]));
+    let px = pixels(&b);
+    assert_eq!((px[0], px[1], px[8]), ([0, 0, 0, 255], [255, 255, 255, 255], [0, 0, 0, 255]));
+    // Indexed: 256 reds, greens, blues.
+    let mut palette = vec![0; 768];
+    (palette[1], palette[257], palette[513]) = (10, 20, 30);
+    let i = psd(1, 1, (1, 1), 8, 2, &palette, &[], &[], &raw(&[&[1]]));
+    assert_eq!(pixels(&i), [[10, 20, 30, 255]]);
+    // RGB, 32 bits: linear values, shown through sRGB's curve.
+    let half = 0.5f32.to_be_bytes();
+    let r = psd(1, 3, (1, 1), 32, 3, &[], &[], &[], &raw(&[&half, &half, &1.0f32.to_be_bytes()]));
+    assert_eq!(pixels(&r), [[188, 188, 255, 255]]);
+    // CMYK, inks stored as 255 − amount: 100 % K is black, no ink white.
+    let c = psd(1, 4, (2, 1), 8, 4, &[], &[], &[], &raw(&[&[255, 255], &[255, 255], &[255, 255], &[0, 255]]));
+    assert_eq!(pixels(&c), [[0, 0, 0, 255], [255, 255, 255, 255]]);
+    // Lab: L 100, a 0, b 0 is white.
+    let l = psd(1, 3, (1, 1), 8, 9, &[], &[], &[], &raw(&[&[255], &[128], &[128]]));
+    assert!(pixels(&l)[0].iter().all(|&v| v >= 253), "{:?}", pixels(&l));
+    // Duotone keeps its grayscale data in the merged image.
+    assert_eq!(pixels(&psd(1, 1, (1, 1), 8, 8, &[0; 40], &[], &[], &raw(&[&[64]]))), [[64, 64, 64, 255]]);
+}
+
+#[test]
+fn transparency_comes_back_straight_and_extra_channels_without_it_stay_out() {
+    // Half-transparent red, stored on white: (255, 127, 127) with alpha 128.
+    let planes: [&[u8]; 4] = [&[255], &[127], &[127], &[128]];
+    let with = psd(1, 4, (1, 1), 8, 3, &[], &[], &layer_count(-1, false), &raw(&planes));
+    let [r, g, b, a] = pixels(&with)[0];
+    assert!(r == 255 && g <= 1 && b <= 1 && a == 128, "{:?}", [r, g, b, a]);
+    // A flat document's extra channel is a saved selection, not transparency.
+    let flat = psd(1, 4, (1, 1), 8, 3, &[], &[], &[], &raw(&planes));
+    assert_eq!(pixels(&flat), [[255, 127, 127, 255]]);
+    // A 16-bit document says so in its Lr16 block (its layer info is empty).
+    let mut layers = 0u32.to_be_bytes().to_vec();
+    layers.extend(0u32.to_be_bytes());
+    layers.extend(b"8BIMLr16");
+    layers.extend(4u32.to_be_bytes());
+    layers.extend((-1i16).to_be_bytes());
+    layers.extend([0, 0]);
+    let wide: [&[u8]; 4] = [&[0xff, 0xff], &[0x7f, 0x7f], &[0x7f, 0x7f], &[0x80, 0x80]];
+    let deep = psd(1, 4, (1, 1), 16, 3, &[], &[], &layers, &raw(&wide));
+    let [r, g, _, a] = pixels(&deep)[0];
+    assert!(r == 255 && g <= 1 && a == 128, "{:?}", pixels(&deep));
+}
+
+#[test]
+fn packbits_zip_and_psb_files_read() {
+    // PackBits in a PSB: 4-byte row counts, transparency from a negative layer count.
+    let mut rle = vec![0, 1];
+    for _ in 0..4 {
+        rle.extend(2u32.to_be_bytes());
+    }
+    for v in [200u8, 100, 50, 255] {
+        rle.extend([0xfe, v]); // a run of three
+    }
+    let big = psd(2, 4, (3, 1), 8, 3, &[], &[], &layer_count(-1, true), &rle);
+    assert_eq!(pixels(&big), [[200, 100, 50, 255]; 3]);
+    let mut s = Session::new();
+    let r = s.execute("document.open", &json!({"name": "big.psb", "dataBase64": vectorcraft_format::base64_encode(&big)})).unwrap();
+    assert_eq!(r["format"], "psb");
+    // Zipped with prediction, 16 bits: each sample is the difference from the one before.
+    let deltas: Vec<u8> = [0x1000u16, 0x1000, 0x1000].iter().flat_map(|d| d.to_be_bytes()).collect();
+    let mut z = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
+    std::io::Write::write_all(&mut z, &deltas).unwrap();
+    let mut zip = vec![0, 3];
+    zip.extend(z.finish().unwrap());
+    let px = pixels(&psd(1, 1, (3, 1), 16, 1, &[], &[], &[], &zip));
+    assert_eq!(px.iter().map(|p| p[0]).collect::<Vec<_>>(), [16, 32, 48]);
+}
+
+#[test]
+fn the_resolution_resource_sizes_the_placed_image() {
+    // ResolutionInfo (1005): 300 ppi across, 118.11 per cm (300 ppi) down.
+    let mut res = b"8BIM".to_vec();
+    res.extend(0x03edu16.to_be_bytes());
+    res.extend([0, 0]); // an empty name, padded
+    res.extend(16u32.to_be_bytes());
+    res.extend((300u32 << 16).to_be_bytes());
+    res.extend([0, 1, 0, 1]);
+    res.extend(((118.11f64 * 65536.0) as u32).to_be_bytes());
+    res.extend([0, 2, 0, 1]);
+    let f = psd(1, 3, (300, 150), 8, 3, &[], &res, &[], &raw(&[&[9; 45_000], &[9; 45_000], &[9; 45_000]]));
+    let (x, y) = resolution(&f).unwrap();
+    assert!((x - 300.0).abs() < 1e-9 && (y - 300.0).abs() < 0.01, "{x} {y}");
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
+    let r = s.execute("file.place", &json!({"name": "photo.psd", "dataBase64": vectorcraft_format::base64_encode(&f)})).unwrap();
+    assert!(
+        (r["width"].as_f64().unwrap() - 72.0).abs() < 0.01 && (r["height"].as_f64().unwrap() - 36.0).abs() < 0.01,
+        "an inch by half an inch: {r}"
+    );
+}
+
+/// A 60 × 40 pt document: a red square on a transparent page, and a half-transparent blue one.
+fn art() -> Session {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 60, "height": 40})).unwrap();
+    s.execute("paint.setStroke", &json!({"none": true})).unwrap();
+    s.execute("paint.setFill", &json!({"color": "#ff0000"})).unwrap();
+    s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 30, "height": 40})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    s.execute("paint.setFill", &json!({"color": "#0000ff"})).unwrap();
+    s.execute("shape.rectangle", &json!({"x": 40, "y": 0, "width": 20, "height": 40})).unwrap();
+    s.execute("transparency.set", &json!({"opacity": 50})).unwrap();
+    s
+}
+
+fn exported(s: &mut Session, p: Value) -> Vec<u8> {
+    let r = s.execute("document.export", &p).unwrap();
+    vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap()
+}
+
+#[test]
+fn psd_exports_open_and_place_again() {
+    let mut s = art();
+    let png = image::load_from_memory(&exported(&mut s, json!({"format": "png"}))).unwrap().to_rgba8();
+    for (options, what) in [(json!({}), "layered RGB"), (json!({"layers": false}), "flat RGB"), (json!({"colorModel": "gray"}), "grey")] {
+        let f = exported(&mut s, merge(json!({"format": "psd"}), options));
+        let back = decode(&f, 1 << 30, naive).unwrap();
+        assert_eq!(back.dimensions(), png.dimensions(), "{what}");
+        let (red, clear, blue) = (back.get_pixel(10, 20).0, back.get_pixel(35, 20).0, back.get_pixel(50, 20).0);
+        if what == "layered RGB" {
+            assert_eq!((red, clear[3]), ([255, 0, 0, 255], 0), "{what}");
+            assert!(blue[2] >= 250 && blue[0] <= 3 && (blue[3] as i32 - png.get_pixel(50, 20).0[3] as i32).abs() <= 1, "{what}: {blue:?}");
+        } else if what == "flat RGB" {
+            assert_eq!((red, clear), ([255, 0, 0, 255], [255, 255, 255, 255]), "{what}: flat files are on white");
+        } else {
+            assert!(red[0] == red[1] && red[3] == 255, "{what}: {red:?}");
+        }
+        // Open and Place take it by its content, whatever its name.
+        let r = s.execute("document.open", &json!({"name": "back.bin", "dataBase64": vectorcraft_format::base64_encode(&f)})).unwrap();
+        assert_eq!(r["format"], "psd", "{what}");
+        let d = &s.doc().unwrap().doc;
+        assert!((d.artboards[0].rect.width() - 60.0).abs() < 1e-6, "{what}");
+    }
+    let r = s.execute("document.formats", &json!({})).unwrap();
+    assert!(r["readable"].as_array().unwrap().iter().any(|v| v == "psd"));
+    assert!(PLACE_EXTS.contains(&"psd") && PLACE_EXTS.contains(&"psb") && OPEN_EXTS.contains(&"psb"));
+}
+
+#[test]
+fn damaged_and_unsupported_files_are_refused_without_a_panic() {
+    let good = psd(2, 4, (3, 2), 8, 3, &[], &[], &layer_count(-1, true), &raw(&[&[1; 6], &[2; 6], &[3; 6], &[4; 6]]));
+    assert!(decode(&good, 1 << 30, naive).is_ok());
+    for n in 0..good.len() {
+        assert!(decode(&good[..n], 1 << 30, naive).is_err(), "cut at {n}");
+        let _ = resolution(&good[..n]);
+    }
+    // Every byte changed in turn: an error or an image, never a panic.
+    for i in 0..good.len() {
+        for v in [0, 1, 0x7f, 0x80, 0xff] {
+            let mut f = good.clone();
+            f[i] = v;
+            let _ = decode(&f, 1 << 30, naive);
+            let _ = resolution(&f);
+        }
+    }
+    // An image too large for the memory allowed is refused before anything is allocated.
+    let huge = psd(2, 3, (300_000, 300_000), 16, 3, &[], &[], &[], &[0, 0]);
+    assert!(decode(&huge, 1 << 30, naive).unwrap_err().contains("too large"));
+    // Multichannel, and depths a mode doesn't have.
+    assert!(decode(&psd(1, 2, (1, 1), 8, 7, &[], &[], &[], &raw(&[&[0], &[0]])), 1 << 30, naive).unwrap_err().contains("Multichannel"));
+    assert!(decode(&psd(1, 4, (1, 1), 32, 4, &[], &[], &[], &[0, 0]), 1 << 30, naive).is_err());
+    // A placed file with a damaged image reports it.
+    let mut s = Session::new();
+    s.execute("file.new", &json!({})).unwrap();
+    let cut = &good[..good.len() - 3];
+    assert!(s.execute("file.place", &json!({"name": "cut.psd", "dataBase64": vectorcraft_format::base64_encode(cut)})).is_err());
+}

crates/engine/src/cmd/graph.rs

@@ -23,7 +23,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Create Graph",
             [],
             None,
-            "{type: column|stackedColumn|bar|stackedBar|line|area|scatter|pie|radar, x, y, width, height, series?: [..], categories?: [..], rows?: [[..]], csv?} → {id}",
+            "{type: column|stackedColumn|bar|stackedBar|line|area|scatter|pie|radar, x, y, width, height, series?: [..], categories?: [..], rows?: [[number|null]], csv?} → {id}; an empty CSV cell or a null is a blank value, a number in straight quotes is a label",
             has_doc,
             create
         ),
@@ -32,7 +32,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Data…",
             ["Object", "Graph"],
             None,
-            "{id?, series?, categories?, rows?, csv?: first row = series labels (first cell empty), then one row per category: label, values…} replace the graph's data; no data → the current {csv, series, categories, rows}",
+            "{id?, series?, categories?, rows?, csv?: first row = series labels (first cell empty), then one row per category: label, values…; an empty cell or a null is a blank value, a quoted number a label} replace the graph's data; no data → the current {csv, series, categories, rows}",
             has_selection,
             set_data
         ),
@@ -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
         ),
@@ -50,46 +50,83 @@ pub fn specs() -> Vec<CommandSpec> {
 
 // ---------- data ----------
 
-fn parse_csv(csv: &str) -> (Vec<String>, Vec<String>, Vec<Vec<f64>>) {
-    let rows: Vec<Vec<String>> = csv
+/// One CSV cell: its text, and whether it was in straight quotes (a quoted number is a label, not a value).
+struct Cell {
+    text: String,
+    quoted: bool,
+}
+
+impl Cell {
+    fn number(&self) -> Option<f64> {
+        if self.quoted { None } else { self.text.parse::<f64>().ok().filter(|v| v.is_finite()) }
+    }
+}
+
+fn parse_csv(csv: &str) -> (Vec<String>, Vec<String>, Vec<Vec<Option<f64>>>) {
+    let rows: Vec<Vec<Cell>> = csv
         .lines()
         .map(|l| l.trim_end_matches('\r'))
         .filter(|l| !l.trim().is_empty())
         .map(|l| {
             let sep = if l.contains('\t') { '\t' } else { ',' };
-            l.split(sep).map(|c| c.trim().trim_matches('"').to_string()).collect()
+            l.split(sep)
+                .map(|c| {
+                    let c = c.trim();
+                    let quoted = c.len() >= 2 && c.starts_with('"') && c.ends_with('"');
+                    Cell { text: c.trim_matches('"').to_string(), quoted }
+                })
+                .collect()
         })
         .collect();
     let Some(first) = rows.first() else { return (vec![], vec![], vec![]) };
-    // A header row has a non-numeric cell after the first one (or an empty first cell).
-    let header = first.first().is_some_and(|c| c.is_empty()) || first.iter().skip(1).any(|c| c.parse::<f64>().is_err());
-    let series = if header { first.iter().skip(1).cloned().collect() } else { vec![] };
+    // A label is quoted or doesn't read as a number; an empty unquoted cell is a blank value.
+    let label = |c: &Cell| c.quoted || (c.number().is_none() && !c.text.is_empty());
+    // A header row has an empty first cell or a label after it, or is a label followed only by empty cells (`Year,,`).
+    // All-empty series names mean no legend.
+    let empty = |c: &Cell| c.text.is_empty() && !c.quoted;
+    let header = first.first().is_some_and(empty)
+        || first.iter().skip(1).any(label)
+        || (first.len() > 1 && first.first().is_some_and(label) && first.iter().skip(1).all(empty));
+    let mut series: Vec<String> = if header { first.iter().skip(1).map(|c| c.text.clone()).collect() } else { vec![] };
+    if series.iter().all(String::is_empty) {
+        series.clear();
+    }
+    let data = rows.get(usize::from(header)..).unwrap_or_default();
+    // The first column holds the category labels if any row starts with one; then it does for every row, so a
+    // row with an empty label doesn't shift its values one place left.
+    let labelled = data.iter().any(|r| r.first().is_some_and(label));
     let mut categories = vec![];
     let mut values = vec![];
-    for r in rows.iter().skip(header as usize) {
-        let labelled = r.first().is_some_and(|c| c.parse::<f64>().is_err());
-        categories.push(if labelled { r[0].clone() } else { String::new() });
-        values.push(r.iter().skip(labelled as usize).map(|c| c.parse::<f64>().unwrap_or(0.0)).collect());
-    }
-    if categories.iter().all(String::is_empty) {
-        categories.clear();
+    for r in data {
+        if labelled {
+            categories.push(r.first().map(|c| c.text.clone()).unwrap_or_default());
+        }
+        values.push(r.iter().skip(labelled as usize).map(Cell::number).collect());
     }
     (series, categories, values)
 }
 
 fn to_csv(g: &GraphSpec) -> String {
-    let mut out = String::new();
-    if !g.series.is_empty() {
-        out.push(',');
-        out.push_str(&g.series.join(","));
-        out.push('\n');
-    }
-    for (i, r) in g.rows.iter().enumerate() {
-        if let Some(c) = g.categories.get(i) {
-            out.push_str(c);
+    // Always a header row (empty first cell), so a first data row starting with a blank isn't read as one.
+    let cells = g.cells();
+    let width = cells.iter().map(Vec::len).max().unwrap_or(0).max(g.series.len());
+    let mut out = String::from(",");
+    out.push_str(&(0..width).map(|s| g.series.get(s).cloned().unwrap_or_default()).collect::<Vec<_>>().join(","));
+    out.push('\n');
+    let labelled = !g.categories.is_empty();
+    for (i, r) in cells.iter().enumerate() {
+        if labelled {
+            // An empty label, one that reads as a number or one with spaces around it goes in quotes, so it reads back
+            // as the same label.
+            let c = g.categories.get(i).map(String::as_str).unwrap_or_default();
+            if c.trim().is_empty() || c.trim().parse::<f64>().is_ok() || c != c.trim() {
+                out.push_str(&format!("\"{c}\""));
+            } else {
+                out.push_str(c);
+            }
             out.push(',');
         }
-        out.push_str(&r.iter().map(|v| fmt_value(*v)).collect::<Vec<_>>().join(","));
+        out.push_str(&r.iter().map(|v| v.map(fmt_value).unwrap_or_default()).collect::<Vec<_>>().join(","));
         out.push('\n');
     }
     out
@@ -101,7 +138,7 @@ fn apply_data(g: &mut GraphSpec, p: &Value) -> bool {
         let (s, c, r) = parse_csv(csv);
         g.series = s;
         g.categories = c;
-        g.rows = r;
+        g.set_cells(r);
         changed = true;
     }
     let strings =
@@ -115,10 +152,24 @@ fn apply_data(g: &mut GraphSpec, p: &Value) -> bool {
         changed = true;
     }
     if let Some(rows) = p.get("rows").and_then(Value::as_array) {
-        g.rows = rows.iter().map(|r| r.as_array().map(|a| a.iter().map(|v| v.as_f64().unwrap_or(0.0)).collect()).unwrap_or_default()).collect();
+        // `null` (or anything that isn't a finite number) is a blank cell.
+        g.set_cells(
+            rows.iter().map(|r| r.as_array().map(|a| a.iter().map(|v| v.as_f64().filter(|v| v.is_finite())).collect()).unwrap_or_default()).collect(),
+        );
         changed = true;
     }
-    g.rows.retain(|r| !r.is_empty());
+    // Drop rows with neither a value nor a label; a label-only row stays, its values blank.
+    let mut cells = g.cells();
+    let keep: Vec<bool> = (0..cells.len())
+        .map(|c| cells.get(c).is_some_and(|r| r.iter().any(Option::is_some)) || g.categories.get(c).is_some_and(|l| !l.is_empty()))
+        .collect();
+    if keep.contains(&false) || cells.len() < g.rows.len() {
+        let mut k = keep.iter();
+        cells.retain(|_| k.next().copied().unwrap_or(false));
+        let mut k = keep.iter();
+        g.categories.retain(|_| k.next().copied().unwrap_or(true));
+        g.set_cells(cells);
+    }
     changed
 }
 
@@ -166,6 +217,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>>,
@@ -203,6 +285,11 @@ impl Gen<'_> {
     }
 }
 
+/// The stretches of two or more points between blank cells, which a line connects.
+fn runs(pts: &[Option<Point>]) -> Vec<Vec<Point>> {
+    pts.split(Option::is_none).map(|r| r.iter().flatten().copied().collect::<Vec<_>>()).filter(|r| r.len() > 1).collect()
+}
+
 fn polyline(pts: &[Point], closed: bool) -> PathData {
     let mut bp = BezPath::new();
     for (i, p) in pts.iter().enumerate() {
@@ -231,7 +318,11 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
     let ncat = g.rows.len().max(1);
     let series_label = |i: usize| g.series.get(i).cloned().unwrap_or_default();
     let mut series: Vec<Vec<Arc<Node>>> = vec![vec![]; nser];
-    let val = |c: usize, s: usize| g.rows.get(c).and_then(|r| r.get(s)).copied().unwrap_or(0.0);
+    // A blank cell (no value) is `None`: columns, bars and stacked segments leave it out, lines and scatter points
+    // break around it and the value axis ignores it. Area, pie and radar draw it as 0, which is what it adds to them.
+    let cells = g.cells();
+    let cell = |c: usize, s: usize| cells.get(c).and_then(|r| r.get(s)).copied().flatten();
+    let val = |c: usize, s: usize| cell(c, s).unwrap_or(0.0);
     let stacked = matches!(g.kind, GraphKind::StackedColumn | GraphKind::StackedBar | GraphKind::Area);
     let horizontal = matches!(g.kind, GraphKind::Bar | GraphKind::StackedBar);
 
@@ -270,8 +361,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 +374,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));
+                    }
                 }
             }
         }
@@ -315,19 +407,21 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                     lo = lo.min(neg);
                 } else if scatter {
                     for s in (0..nser).step_by(2) {
-                        hi = hi.max(val(c, s));
-                        lo = lo.min(val(c, s));
-                        xlo = xlo.min(val(c, s + 1));
-                        xhi = xhi.max(val(c, s + 1));
+                        if let (Some(y), Some(x)) = (cell(c, s), cell(c, s + 1)) {
+                            hi = hi.max(y);
+                            lo = lo.min(y);
+                            xlo = xlo.min(x);
+                            xhi = xhi.max(x);
+                        }
                     }
                 } else {
-                    for s in 0..nser {
-                        hi = hi.max(val(c, s));
-                        lo = lo.min(val(c, s));
+                    for v in (0..nser).filter_map(|s| cell(c, s)) {
+                        hi = hi.max(v);
+                        lo = lo.min(v);
                     }
                 }
             }
-            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 +429,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 +438,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 +450,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 }
             };
@@ -384,14 +477,20 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                     x += xs;
                 }
                 for (si, s) in (0..nser).step_by(2).enumerate() {
-                    let pts: Vec<Point> =
-                        (0..ncat).map(|c| Point::new(r.x0 + (val(c, s + 1) - xl) / (xh - xl) * r.width(), vpos(val(c, s)))).collect();
-                    if g.connect_points && pts.len() > 1 {
-                        let (fill, stroke, w) = mark(si, false, default_series_paint(si), 1.0);
-                        series[si].push(b.path(polyline(&pts, false), fill, stroke, w));
+                    let pts: Vec<Option<Point>> = (0..ncat)
+                        .map(|c| match (cell(c, s), cell(c, s + 1)) {
+                            (Some(y), Some(x)) => Some(Point::new(r.x0 + (x - xl) / (xh - xl) * r.width(), vpos(y))),
+                            _ => None,
+                        })
+                        .collect();
+                    if g.connect_points {
+                        for run in runs(&pts) {
+                            let (fill, stroke, w) = mark(si, false, default_series_paint(si), 1.0);
+                            series[si].push(b.path(polyline(&run, false), fill, stroke, w));
+                        }
                     }
                     if g.mark_points {
-                        for p in &pts {
+                        for p in pts.iter().flatten() {
                             let (fill, stroke, w) = mark(si, true, Paint::None, 0.0);
                             series[si].push(b.path(marker(*p, 5.0), fill, stroke, w));
                         }
@@ -408,8 +507,9 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                     for c in 0..ncat {
                         let c0 = cat_start(c) + (cat_w - cluster) / 2.0;
                         for (s, items) in series.iter_mut().enumerate() {
+                            let Some(v) = cell(c, s) else { continue };
                             let a = c0 + slot * s as f64 + (slot - bar) / 2.0;
-                            let (v0, v1) = (vpos(0.0f64.clamp(lo, hi)), vpos(val(c, s)));
+                            let (v0, v1) = (vpos(0.0f64.clamp(lo, hi)), vpos(v));
                             let rect = if horizontal {
                                 Rect::new(v0.min(v1), a, v0.max(v1), a + bar)
                             } else {
@@ -427,7 +527,7 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                         let a = cat_start(c) + (cat_w - bar) / 2.0;
                         let (mut pos, mut neg) = (0.0, 0.0);
                         for (s, items) in series.iter_mut().enumerate() {
-                            let v = val(c, s);
+                            let Some(v) = cell(c, s) else { continue };
                             let base = if v >= 0.0 { &mut pos } else { &mut neg };
                             let (v0, v1) = (vpos(*base), vpos(*base + v));
                             *base += v;
@@ -443,13 +543,15 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                 }
                 GraphKind::Line => {
                     for (s, items) in series.iter_mut().enumerate() {
-                        let pts: Vec<Point> = (0..ncat).map(|c| Point::new(cat_mid(c), vpos(val(c, s)))).collect();
-                        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, false), fill, stroke, w));
+                        let pts: Vec<Option<Point>> = (0..ncat).map(|c| cell(c, s).map(|v| Point::new(cat_mid(c), vpos(v)))).collect();
+                        if g.connect_points {
+                            for run in runs(&pts) {
+                                let (fill, stroke, w) = mark(s, false, default_series_paint(s), 1.0);
+                                items.push(b.path(polyline(&run, false), fill, stroke, w));
+                            }
                         }
                         if g.mark_points {
-                            for p in &pts {
+                            for p in pts.iter().flatten() {
                                 let (fill, stroke, w) = mark(s, true, Paint::None, 0.0);
                                 items.push(b.path(marker(*p, 5.0), fill, stroke, w));
                             }
@@ -666,7 +768,8 @@ fn set_data(s: &mut Session, p: &Value) -> Result<Value> {
     let id = target(s, p, "graph.setData")?;
     let mut spec = spec_of(s, id)?;
     if !apply_data(&mut spec, p) {
-        return Ok(json!({ "csv": to_csv(&spec), "series": spec.series, "categories": spec.categories, "rows": spec.rows }));
+        // Blank cells come back as null, so the rows can be edited and sent back as they are.
+        return Ok(json!({ "csv": to_csv(&spec), "series": spec.series, "categories": spec.categories, "rows": spec.cells() }));
     }
     s.edit("Graph Data", |d, _| regenerate(d, id, spec))?;
     Ok(json!({ "id": id.0 }))
@@ -676,11 +779,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 +795,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 +895,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();
@@ -1017,10 +1205,115 @@ mod tests {
         let (s, c, r) = super::parse_csv("\t2024\t2025\nQ1\t1\t2\nQ2\t3\t4\n");
         assert_eq!(s, vec!["2024", "2025"]);
         assert_eq!(c, vec!["Q1", "Q2"]);
-        assert_eq!(r, vec![vec![1.0, 2.0], vec![3.0, 4.0]]);
+        assert_eq!(r, vec![vec![Some(1.0), Some(2.0)], vec![Some(3.0), Some(4.0)]]);
         let (s, c, r) = super::parse_csv("1,2\n3,4");
         assert!(s.is_empty() && c.is_empty());
         assert_eq!(r.len(), 2);
         assert_eq!(super::nice_axis(0.0, 7.0, 0), (0.0, 8.0, 2.0));
     }
+
+    #[test]
+    fn empty_cells_are_blank_and_quoted_numbers_are_labels() {
+        // Quoted years label the rows; empty and non-numeric cells are blank values, not zeros.
+        let (s, c, r) = super::parse_csv(",a,b\n\"2023\",1,\n\"2024\",,x\n\"2025\",3,4");
+        assert_eq!(s, vec!["a", "b"]);
+        assert_eq!(c, vec!["2023", "2024", "2025"]);
+        assert_eq!(r, vec![vec![Some(1.0), None], vec![None, None], vec![Some(3.0), Some(4.0)]]);
+        // Back to CSV: blanks stay empty and numeric labels keep their quotes, so it reads back the same.
+        let mut g = GraphSpec { series: s, categories: c, ..GraphSpec::default() };
+        g.set_cells(r);
+        assert_eq!(g.blanks, vec![[0, 1], [1, 0], [1, 1]]);
+        let csv = super::to_csv(&g);
+        assert!(csv.contains("\"2024\",,"), "{csv}");
+        let (s2, c2, r2) = super::parse_csv(&csv);
+        assert_eq!((s2, c2, r2), (g.series.clone(), g.categories.clone(), g.cells()));
+    }
+
+    #[test]
+    fn a_row_with_an_empty_label_keeps_its_values_in_place() {
+        // The label column is the first column of every row once any row has a label.
+        let (_, c, r) = super::parse_csv(",a,b\nQ1,1,2\n,3,4");
+        assert_eq!(c, vec!["Q1", ""]);
+        assert_eq!(r, vec![vec![Some(1.0), Some(2.0)], vec![Some(3.0), Some(4.0)]]);
+        // And a data window round trip keeps it (the empty label is written as "").
+        let mut g = GraphSpec { series: vec!["a".into(), "b".into()], categories: c, ..GraphSpec::default() };
+        g.set_cells(r);
+        assert_eq!(super::parse_csv(&super::to_csv(&g)).2, g.cells());
+        // Without series or labels, a first row starting with a blank is still data after a round trip.
+        let mut g = GraphSpec::default();
+        g.set_cells(vec![vec![None, Some(2.0)], vec![Some(3.0), Some(4.0)]]);
+        let (s, c, r) = super::parse_csv(&super::to_csv(&g));
+        assert!(s.is_empty() && c.is_empty());
+        assert_eq!(r, g.cells());
+        // A label with spaces around a number stays a label, spaces and all.
+        let mut g = GraphSpec { categories: vec!["2024 ".into()], ..GraphSpec::default() };
+        g.set_cells(vec![vec![Some(1.0)]]);
+        assert_eq!(super::parse_csv(&super::to_csv(&g)).1, vec!["2024 "]);
+    }
+
+    #[test]
+    fn blanks_read_back_as_null_and_year_header_rows_still_read_as_headers() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
+        let r =
+            s.execute("graph.create", &json!({"type": "line", "x": 0, "y": 0, "width": 300, "height": 200, "rows": [[1, null], [2, 3]]})).unwrap();
+        let id = NodeId(r["id"].as_u64().unwrap());
+        assert_eq!(s.execute("graph.setData", &json!({"id": id.0})).unwrap()["rows"], json!([[1.0, null], [2.0, 3.0]]));
+        // A label followed by empty cells is a header with no series names, as before blanks existed.
+        let (s, c, r) = super::parse_csv("Year,,\n2023,1,2");
+        assert!(s.is_empty());
+        assert_eq!(c, Vec::<String>::new());
+        assert_eq!(r, vec![vec![Some(2023.0), Some(1.0), Some(2.0)]]);
+    }
+
+    #[test]
+    fn a_huge_ragged_grid_is_capped() {
+        let g = GraphSpec { rows: vec![vec![0.0; vectorcraft_doc::MAX_GRAPH_SERIES + 10]; 3], ..GraphSpec::default() };
+        assert!(g.cells().iter().all(|r| r.len() == vectorcraft_doc::MAX_GRAPH_SERIES));
+    }
+
+    #[test]
+    fn a_label_only_row_stays_with_blank_values() {
+        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": 0, "y": 0, "width": 300, "height": 200, "csv": ",a\nQ1,1\nQ2\nQ3,3"})).unwrap();
+        let id = NodeId(r["id"].as_u64().unwrap());
+        let spec = s.doc().unwrap().doc.node(id).unwrap().graph.clone().unwrap();
+        assert_eq!(spec.categories, vec!["Q1", "Q2", "Q3"]);
+        assert_eq!(spec.cells(), vec![vec![Some(1.0)], vec![None], vec![Some(3.0)]]);
+    }
+
+    #[test]
+    fn blank_cells_leave_out_their_columns_and_break_lines() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
+        let rows = json!([[3, 1], [null, 2], [5, null], [4, 4]]);
+        let r = s
+            .execute("graph.create", &json!({"type": "column", "x": 100, "y": 100, "width": 400, "height": 200, "series": ["a", "b"], "rows": rows}))
+            .unwrap();
+        let id = NodeId(r["id"].as_u64().unwrap());
+        let count = |s: &Session, index: u32| series(&s.doc().unwrap().doc.node(id).unwrap().clone(), index).children().unwrap().len();
+        // Three columns each (one blank), plus the legend swatch.
+        assert_eq!((count(&s, 0), count(&s, 1)), (4, 4));
+        s.execute("graph.setType", &json!({"type": "stackedColumn"})).unwrap();
+        assert_eq!((count(&s, 0), count(&s, 1)), (4, 4));
+        // Line: series a is 3, blank, 5, 4. The lone first point has nothing to connect to, so one line (5 to 4), three
+        // markers and the legend swatch.
+        s.execute("graph.setType", &json!({"type": "line"})).unwrap();
+        assert_eq!(count(&s, 0), 1 + 3 + 1);
+        // Series b is 1, 2, blank, 4: one line (1 to 2), three markers and the swatch.
+        assert_eq!(count(&s, 1), 1 + 3 + 1);
+        // A data window round trip keeps the blanks.
+        let csv = s.execute("graph.setData", &json!({})).unwrap()["csv"].as_str().unwrap().to_string();
+        assert_eq!(csv.lines().nth(2), Some(",2"), "{csv}");
+        let spec = s.doc().unwrap().doc.node(id).unwrap().graph.clone().unwrap();
+        assert_eq!(spec.cells()[1], vec![None, Some(2.0)]);
+        // In the file a blank is a 0 placeholder plus its place in `blanks`, so a version without blanks reads
+        // numbers (as zeros); a graph without blanks writes no `blanks` at all.
+        let v = serde_json::to_value(&spec).unwrap();
+        assert_eq!(v["rows"][1], json!([0.0, 2.0]));
+        assert_eq!(v["blanks"], json!([[1, 0], [2, 1]]));
+        assert!(serde_json::to_value(GraphSpec::default()).unwrap().get("blanks").is_none());
+    }
 }

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_links.rs

@@ -127,6 +127,36 @@ fn a_placed_link_records_the_file_and_the_document_saves_only_a_preview() {
     assert_eq!(saved["images"][&im.key]["proxy"], Value::Null, "an embedded image shows it too");
 }
 
+/// A flat `w`×`h` Photoshop document of one colour (raw RGB, no layers).
+fn psd(w: u32, h: u32, rgb: [u8; 3]) -> Vec<u8> {
+    let mut f = b"8BPS\0\x01\0\0\0\0\0\0\0\x03".to_vec();
+    f.extend(h.to_be_bytes());
+    f.extend(w.to_be_bytes());
+    f.extend([0, 8, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    for v in rgb {
+        f.extend(std::iter::repeat_n(v, (w * h) as usize));
+    }
+    f
+}
+
+/// #918: a Photoshop document placed linked shows its merged image, and updates when it changes.
+#[test]
+fn a_linked_photoshop_document_places_and_updates() {
+    let dir = Folder::new("psd");
+    let pic = dir.file("art/photo.psd");
+    write(&pic, &psd(600, 300, RED));
+    let mut s = session();
+    let id = place(&mut s, &pic);
+    let link = image(&s, id).link.unwrap();
+    assert_eq!(link.path, pic);
+    assert!(near(centre_colour(&s.doc().unwrap().doc), RED));
+    write(&pic, &psd(400, 400, BLUE));
+    assert_eq!(s.execute("links.update", &json!({})).unwrap(), json!({"updated": [id.0], "missing": []}));
+    let im = image(&s, id);
+    assert_eq!((im.width, im.height), (400, 400));
+    assert!(near(centre_colour(&s.doc().unwrap().doc), BLUE));
+}
+
 #[test]
 fn the_relative_path_finds_the_file_after_the_folder_moves() {
     let a = Folder::new("move-a");

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

@@ -1,5 +1,6 @@
 //! The Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Pixelate ›
-//! Color Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask): applied and
+//! Color Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask, Texture ›
+//! Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass and Texturizer, Video): applied and
 //! edited as commands, listed in the catalogue, drawn on the canvas, and written to PDF and SVG
 //! as images of the effected object.
 
@@ -21,6 +22,20 @@ const EFFECTS: [(&str, &str); 3] = [
 const PIXELATE: [(&str, &str); 4] =
     [("pixelate.colorHalftone", "{}"), ("pixelate.crystallize", "{}"), ("pixelate.mezzotint", "{}"), ("pixelate.pointillize", "{}")];
 
+/// Effect › Texture, at their defaults.
+const TEXTURE: [(&str, &str); 6] = [
+    ("texture.craquelure", "{}"),
+    ("texture.grain", "{}"),
+    ("texture.mosaicTiles", "{}"),
+    ("texture.patchwork", "{}"),
+    ("texture.stainedGlass", "{}"),
+    ("texture.texturizer", "{}"),
+];
+
+/// 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 +72,16 @@ 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"),
+        (TEXTURE.as_slice(), "Texture"),
+        (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 +102,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(TEXTURE).chain(VIDEO) {
         let (mut s, g) = striped();
         let plain = render(&s);
         let params: Value = serde_json::from_str(params).unwrap();
@@ -109,7 +131,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(TEXTURE).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 +162,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,17 @@ 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": "texture.craquelure", "params": {"crackSpacing": -1e308, "crackDepth": "NaN", "crackBrightness": 1e308}})),
+        ("effect.apply", json!({"effect": "texture.grain", "params": {"intensity": 1e308, "contrast": [1], "grainType": 7}})),
+        ("effect.apply", json!({"effect": "texture.mosaicTiles", "params": {"tileSize": "1e999", "groutWidth": -1, "lightenGrout": null}})),
+        ("effect.apply", json!({"effect": "texture.patchwork", "params": {"squareSize": 1e308, "relief": -1e308}})),
+        ("effect.apply", json!({"effect": "texture.stainedGlass", "params": {"cellSize": 0, "borderThickness": 1e308, "lightIntensity": "x"}})),
+        (
+            "effect.apply",
+            json!({"effect": "texture.texturizer", "params": {"texture": {}, "scaling": -1e308, "relief": 1e308, "lightDirection": 3, "invert": "yes"}}),
+        ),
+        ("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

@@ -1,5 +1,5 @@
 //! Untrusted files never crash the app: garbage, truncated, mutated and hostile SVG, PDF and DXF input,
-//! mutated raster images placed with File → Place, and swatch (`.vcswatches`, `.gpl`, `.ase`), graphic style (`.vcstyles`) and flattener preset
+//! mutated raster images (Photoshop documents among them) placed with File → Place, and swatch (`.vcswatches`, `.gpl`, `.ase`), graphic style (`.vcstyles`) and flattener preset
 //! (`.vcflattener`) libraries, and native files (compressed, damaged, saved for older versions),
 //! must load as an error or as a document that then renders and exports, without a panic; nor may
 //! bitmaps, PDF and text pasted from other apps, nor EMF and WMF pictures (damaged files, records
@@ -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();
@@ -945,6 +1001,19 @@ fn raster_samples() -> Vec<(&'static str, Vec<u8>)> {
         out.push((name, b));
     }
     out[0].1 = vectorcraft_engine::cmd::fileio::ppi::with_png_resolution(&out[0].1, (300.0, 150.0));
+    // A layered PSD with transparency (as VectorCraft exports it), and a PackBits PSB by hand.
+    let mut s = rich_session();
+    let r = s.execute("document.export", &json!({"format": "psd", "ppi": 2})).unwrap();
+    out.push(("a.psd", vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap()));
+    let mut psb = b"8BPS\0\x02\0\0\0\0\0\0\0\x04\0\0\0\x02\0\0\0\x03\0\x08\0\x03".to_vec();
+    psb.extend([0; 8]);
+    psb.extend(10u64.to_be_bytes());
+    psb.extend(2u64.to_be_bytes());
+    psb.extend((-1i16).to_be_bytes());
+    psb.extend([0, 1]);
+    psb.extend((0..8).flat_map(|_| 2u32.to_be_bytes()));
+    psb.extend((0..8u8).flat_map(|v| [0xfe, v * 30]));
+    out.push(("a.psb", psb));
     out
 }
 
@@ -954,7 +1023,7 @@ proptest! {
     /// Mutated image headers (resolution metadata, chunk and segment lengths) never crash reading
     /// their resolution or placing them.
     #[test]
-    fn mutated_images_place_without_panics(which in 0usize..4, cut in 0usize..400, edits in prop::collection::vec((0usize..120, any::<u8>()), 0..12)) {
+    fn mutated_images_place_without_panics(which in 0usize..6, cut in 0usize..4000, edits in prop::collection::vec((0usize..120, any::<u8>()), 0..12)) {
         let (name, mut bytes) = raster_samples().swap_remove(which);
         for (at, b) in edits {
             if let Some(x) = bytes.get_mut(at) {

crates/eps/Cargo.toml

@@ -17,6 +17,8 @@ vectorcraft-brush = { workspace = true }
 vectorcraft-text = { workspace = true }
 # Windows metafile previews, opened when a file's PostScript can't be read.
 vectorcraft-metafile = { workspace = true }
+# Non-native art in Illustrator editing data (a placed PDF's content, kept as a PDF).
+vectorcraft-pdf = { workspace = true }
 # The TIFF writer (previews) and PackBits, shared with raster export.
 vectorcraft-render = { workspace = true }
 kurbo = { workspace = true }

crates/eps/src/import/ai/read.rs

@@ -37,6 +37,7 @@ use vectorcraft_geom::{FillRule, PathData};
 use super::lex::{Lexer, Tok};
 use super::obj::{self, Obj, V};
 use super::paint::{self, GradientDef, Instance, Named};
+use crate::ps;
 
 /// Deepest nesting of layers, groups and dictionaries.
 const MAX_DEPTH: usize = 256;
@@ -248,6 +249,8 @@ struct Reader<'a> {
     hidden_ids: HashSet<NodeId>,
     /// CMYK samples converted, by value.
     cmyk_cache: HashMap<[u8; 4], [u8; 3]>,
+    /// A `/ForeignObject`'s `/Data`: its PDF as ASCII85 in comment lines, until the object closes.
+    foreign_data: Option<Vec<u8>>,
     /// The page ended: what follows isn't art.
     done: bool,
     /// The dictionary closed last was opened on a `%_` line.
@@ -316,8 +319,11 @@ const SKIPPED: &[(&str, &str)] = &[
     ("Alternate_Content", "End_Versioned_Content"),
 ];
 
-/// The note for a `/ForeignObject`, art the editor shows but doesn't edit.
-pub const NON_NATIVE_ART: &str = "non-native art (a placed PDF's content) is left out: VectorCraft doesn't draw it from the editing data yet";
+/// The note for a `/ForeignObject` (non-native art, the content of a placed PDF, which the editor
+/// shows but doesn't edit) whose PDF can't be read.
+pub const NON_NATIVE_ART_UNREAD: &str = "non-native art (a placed PDF's content) that VectorCraft can't read is left out";
+/// The name of the group a `/ForeignObject`'s art comes in as.
+pub const NON_NATIVE_ART: &str = "Non-native art";
 
 /// A section comment's marker without its `AI<version>_` prefix and value (`AI14_BeginSymbol` →
 /// `BeginSymbol`); DSC comments (`%%BeginProlog`) keep their `%`.
@@ -350,6 +356,7 @@ impl<'a> Reader<'a> {
             pending_stroke: None,
             spots: Vec::new(),
             raster: None,
+            foreign_data: None,
             after_object: false,
             nodes: 0,
             unsupported: BTreeSet::new(),
@@ -659,8 +666,10 @@ impl<'a> Reader<'a> {
                     // of it may start with `%_` and read as hidden tokens: a `(` there would open
                     // a string that swallows the rest of the layer.
                     let key = o.entries.last().and_then(|(k, _)| k.as_deref());
-                    if (o.ty == "Binary" && key == Some("ASCII85Decode")) || (o.ty == "ForeignObject" && key == Some("Data")) {
+                    if o.ty == "Binary" && key == Some("ASCII85Decode") {
                         self.lex.skip_past(b"~>");
+                    } else if o.ty == "ForeignObject" && key == Some("Data") {
+                        self.foreign_data = Some(self.lex.skip_past(b"~>").to_vec());
                     }
                 }
                 return Ok(());
@@ -839,9 +848,7 @@ impl<'a> Reader<'a> {
             "Document" => self.document(&o),
             "AI11Text" => self.text_slot(&o)?,
             "SymbolInstance" => self.unreadable("symbols"),
-            // Art Illustrator shows but doesn't edit (a placed PDF's content): its PDF is kept in
-            // the dictionary, which nothing draws from yet, so the file opens without it.
-            "ForeignObject" => self.warn(NON_NATIVE_ART),
+            "ForeignObject" => self.foreign_art(&o)?,
             _ => {}
         }
         Ok(())
@@ -858,6 +865,94 @@ impl<'a> Reader<'a> {
         self.add(n, hidden)
     }
 
+    /// Non-native art (`/ForeignObject`): the content of a placed PDF, which Illustrator shows but
+    /// doesn't edit. Its `/Data` is that PDF (ASCII85 in comment lines, kept by the `,` handler),
+    /// `/Bounds` the art's box in a space measured from `/Origin` with y down, and `/RTransform`
+    /// maps that space onto the art (both read off files: the box lands on the clipping paths
+    /// around it). The PDF importer reads the PDF, and its art is fitted to the box, as one
+    /// group. Without data, or with a PDF that can't be read, nothing is drawn.
+    fn foreign_art(&mut self, o: &Obj) -> Result<(), String> {
+        let Some(text) = self.foreign_data.take() else { return Ok(()) };
+        // One `%` starts each line; the rest, `_` included, is data.
+        let mut encoded = String::with_capacity(text.len());
+        for line in text.split(|b| matches!(b, b'\r' | b'\n')) {
+            encoded.push_str(&String::from_utf8_lossy(line.strip_prefix(b"%").unwrap_or(line)));
+        }
+        let Some(pdf) = ps::ascii85_decode(&encoded) else {
+            self.warn(NON_NATIVE_ART_UNREAD);
+            return Ok(());
+        };
+        let (rt, origin, bounds) = (o.get("RTransform").map(Self::nums), o.get("Origin").map(Self::nums), o.get("Bounds").map(Self::nums));
+        let (Some([a, b, c, d, tx, ty]), Some([ox, oy]), Some([x0, y0, x1, y1])) = (rt.as_deref(), origin.as_deref(), bounds.as_deref()) else {
+            self.warn(NON_NATIVE_ART_UNREAD);
+            return Ok(());
+        };
+        let place = Affine::new([*a, *b, *c, *d, *tx, *ty]) * Affine::new([1.0, 0.0, 0.0, -1.0, *ox, *oy]);
+        let art_box = place.transform_rect_bbox(Rect::new(*x0, *y0, *x1, *y1));
+        if !sane(art_box) || art_box.width() <= 0.0 || art_box.height() <= 0.0 {
+            self.warn(NON_NATIVE_ART_UNREAD);
+            return Ok(());
+        }
+        let target = self.ensure_space().transform_rect_bbox(art_box);
+        let opts = vectorcraft_pdf::ImportOptions { layers: false, ..Default::default() };
+        let read = match vectorcraft_pdf::import_with_report(&pdf, &opts) {
+            Ok(r) => r,
+            Err(e) => {
+                self.warn(&format!("{NON_NATIVE_ART_UNREAD} ({e})"));
+                return Ok(());
+            }
+        };
+        let mut art: Vec<Node> = read.document.layers.iter().filter_map(|l| l.children()).flatten().map(|n| n.as_ref().clone()).collect();
+        let Some(bbox) = art.iter().fold(None, |acc, n| vectorcraft_geom::union_opt(acc, n.geometric_bounds())) else { return Ok(()) };
+        if bbox.width() <= 0.0 || bbox.height() <= 0.0 {
+            return Ok(());
+        }
+        // The art's own box onto the object's box (its measure of the same art), upside down:
+        // the object's space has y down, and the PDF's content is kept in its own y-up
+        // coordinates, so the PDF's bottom is the top of the box.
+        let fit = Affine::translate((target.x0, target.y1))
+            * Affine::scale_non_uniform(target.width() / bbox.width(), -target.height() / bbox.height())
+            * Affine::translate((-bbox.x0, -bbox.y0));
+        for n in &mut art {
+            n.transform(fit, true);
+            // The PDF's swatches stay with it: its colours keep their values, unlinked.
+            self.reid(n);
+        }
+        for (key, blob) in read.document.images {
+            self.doc.images.entry(key).or_insert(blob);
+        }
+        let gs = self.gs.clone();
+        let mut group = self.new_node(NodeKind::Group { children: art.into_iter().map(Arc::new).collect(), clip: false }, &gs);
+        group.name = Some(NON_NATIVE_ART.into());
+        self.add(group, self.obj_hidden)
+    }
+
+    /// Give `n` and its descendants ids of this document, and unlink their swatches.
+    fn reid(&mut self, n: &mut Node) {
+        n.id = self.doc.alloc_id();
+        for it in &mut n.appearance.items {
+            let p = match it {
+                AppearanceItem::Fill(f) => &mut f.paint,
+                AppearanceItem::Stroke(s) => &mut s.paint,
+            };
+            if let Paint::Gradient(g) = p {
+                g.swatch = None;
+            }
+            p.map_links(&mut |_, link, _| {
+                *link = None;
+                true
+            });
+        }
+        if let Some(m) = &mut n.mask {
+            self.reid(Arc::make_mut(&mut m.art));
+        }
+        if let Some(children) = n.children_mut() {
+            for c in children {
+                self.reid(Arc::make_mut(c));
+            }
+        }
+    }
+
     /// Note something the data has that isn't read: an error on a layer that shows, left out of a
     /// layer that doesn't.
     fn unreadable(&mut self, what: &str) {

crates/eps/src/import/ai/tests.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use kurbo::{Point, Rect};
 use vectorcraft_color::gradient::GradientKind;
 use vectorcraft_color::{BlendMode, Color, Paint};
-use vectorcraft_doc::{ColorMode, Document, Knockout, LayerColor, LineCap, LineJoin, Node, NodeKind};
+use vectorcraft_doc::{AppearanceItem, ColorMode, Document, Knockout, LayerColor, LineCap, LineJoin, Node, NodeKind};
 
 use super::*;
 
@@ -332,13 +332,102 @@ fn sections_it_skips() {
 /// Non-native art (a placed PDF's content) keeps its PDF as ASCII85 in comment lines after
 /// `/Data ,`. ASCII85 has `_`, so a line may start with `%_`, which otherwise reads as hidden
 /// tokens, and a `(` in it would swallow the rest of the layer (a letterhead saved by Illustrator
-/// 28 wouldn't open: "it ends inside a layer"). The art is left out with a note.
+/// 28 wouldn't open: "it ends inside a layer"). Data that isn't a PDF is left out with a note.
 #[test]
-fn non_native_art_is_skipped_with_its_ascii85_data() {
-    let foreign = "/ForeignObject :\n1 /Version ,\n2 0 0 2 10 20  /RTransform ,\n/Data ,\n%,u@!!/MSk8%41#ocdN=10d&\n%_O%*mGn(RduU.]4`[u[.f\n%_;(]<[%\n%1H@<P2`V<S,pbuU7L]\\~>\n;\n0 0 Xd\n6 () XW\n0 Ae\n";
+fn non_native_art_that_is_not_a_pdf_is_left_out_with_a_note() {
+    let foreign = "/ForeignObject :\n1 /Version ,\n2 0 0 2 10 20  /RTransform ,\n10 20  /Origin ,\n1 2 5 8  /Bounds ,\n/Data ,\n%,u@!!/MSk8%41#ocdN=10d&\n%_O%*mGn(RduU.]4`[u[.f\n%_;(]<[%\n%1H@<P2`V<S,pbuU7L]\\~>\n;\n0 0 Xd\n6 () XW\n0 Ae\n";
     let s = read_ok(&layer(&format!("{foreign}{}", rect_path(0.0, 0.0, 1.0, 1.0) + "f\n")));
     assert_eq!(art(&s.doc).len(), 1);
-    assert!(s.warnings.iter().any(|w| w == read::NON_NATIVE_ART), "{:?}", s.warnings);
+    assert!(s.warnings.iter().any(|w| w.starts_with(read::NON_NATIVE_ART_UNREAD)), "{:?}", s.warnings);
+}
+
+/// A PDF with one page of `size` points holding `content`.
+fn tiny_pdf(size: f64, content: &str) -> Vec<u8> {
+    let objects = [
+        "<< /Type /Catalog /Pages 2 0 R >>".to_string(),
+        "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string(),
+        format!("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {size} {size}] /Contents 4 0 R >>"),
+        format!("<< /Length {} >>\nstream\n{content}\nendstream", content.len() + 1),
+    ];
+    let mut pdf = b"%PDF-1.4\n".to_vec();
+    let mut offsets = vec![];
+    for (i, o) in objects.iter().enumerate() {
+        offsets.push(pdf.len());
+        pdf.extend_from_slice(format!("{} 0 obj\n{o}\nendobj\n", i + 1).as_bytes());
+    }
+    let xref = pdf.len();
+    pdf.extend_from_slice(format!("xref\n0 {}\n0000000000 65535 f \n", objects.len() + 1).as_bytes());
+    for o in offsets {
+        pdf.extend_from_slice(format!("{o:010} 00000 n \n").as_bytes());
+    }
+    pdf.extend_from_slice(format!("trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n", objects.len() + 1).as_bytes());
+    pdf
+}
+
+/// `bytes` as ASCII85 in comment lines of 60 characters, ending with `~>`.
+fn ascii85_comment_lines(bytes: &[u8]) -> String {
+    let mut text = String::new();
+    for chunk in bytes.chunks(4) {
+        let mut word = [0u8; 4];
+        word[..chunk.len()].copy_from_slice(chunk);
+        let mut v = u32::from_be_bytes(word);
+        let mut digits = [0u8; 5];
+        for d in digits.iter_mut().rev() {
+            *d = (v % 85) as u8 + b'!';
+            v /= 85;
+        }
+        text.extend(digits.iter().take(chunk.len() + 1).map(|d| char::from(*d)));
+    }
+    let mut lines = String::new();
+    for line in text.as_bytes().chunks(60) {
+        lines.push('%');
+        lines.push_str(std::str::from_utf8(line).unwrap());
+        lines.push('\n');
+    }
+    lines.push_str("%~>\n");
+    lines
+}
+
+/// The PDF of non-native art is drawn by the PDF importer, its art fitted to the object's box:
+/// `/Bounds` in a space measured from `/Origin` with y down, then `/RTransform`. Two squares at
+/// 1..5 × 2..8 of a 10-point page, blue below red: bounds (1, 2)–(5, 8) → from the origin
+/// (10, 20), y down, (11, 18)–(15, 12) → twice that plus (100, 50): x 122..130, y 74..86 in art
+/// space, which is y 14..26 in the document (crop marks 100 high). The space has y down, so the
+/// PDF's bottom (blue) is the top of the box.
+#[test]
+fn non_native_art_is_drawn_from_its_pdf_fitted_to_its_bounds() {
+    let pdf = tiny_pdf(10.0, "0 0 1 rg 1 2 4 3 re f 1 0 0 rg 1 5 4 3 re f");
+    let foreign = format!(
+        "q\n/ForeignObject :\n1 /Version ,\n2 0 0 2 100 50  /RTransform ,\n10 20  /Origin ,\n1 2 5 8  /Bounds ,\n/Data ,\n{};\n0 0 Xd\n6 () XW\n0 Ae\n{}h\nW\nn\nQ\n",
+        ascii85_comment_lines(&pdf),
+        rect_path(120.0, 70.0, 130.0, 90.0)
+    );
+    let s = read_ok(&layer(&foreign));
+    assert!(s.warnings.is_empty(), "{:?}", s.warnings);
+    let objects = art(&s.doc);
+    assert_eq!(objects.len(), 1, "{objects:?}");
+    // A clipping group: the clip path first, then the non-native art's group.
+    let NodeKind::Group { children, clip: true } = &objects[0].kind else { panic!("{:?}", objects[0].kind) };
+    assert_eq!(children.len(), 2);
+    let group = &children[1];
+    assert_eq!(group.name.as_deref(), Some(read::NON_NATIVE_ART));
+    let bounds = group.geometric_bounds().unwrap();
+    for (got, want) in [(bounds.x0, 122.0), (bounds.y0, 14.0), (bounds.x1, 130.0), (bounds.y1, 26.0)] {
+        assert!((got - want).abs() < 1e-6, "{bounds:?}");
+    }
+    let paths = group.children().unwrap();
+    assert_eq!(paths.len(), 2);
+    let fill =
+        |n: &Node| n.appearance.items.iter().find_map(|it| if let AppearanceItem::Fill(f) = it { Some(f.paint.clone()) } else { None }).unwrap();
+    let (blue, red) = (fill(&paths[0]), fill(&paths[1]));
+    assert!(matches!(&blue, Paint::Solid { color, swatch: None, .. } if color.to_rgba8(1.0) == [0, 0, 255, 255]), "{blue:?}");
+    assert!(matches!(&red, Paint::Solid { color, swatch: None, .. } if color.to_rgba8(1.0) == [255, 0, 0, 255]), "{red:?}");
+    let (b, r) = (paths[0].geometric_bounds().unwrap(), paths[1].geometric_bounds().unwrap());
+    assert!((b.y0 - 14.0).abs() < 1e-6 && (b.y1 - 20.0).abs() < 1e-6, "blue {b:?}");
+    assert!((r.y0 - 20.0).abs() < 1e-6 && (r.y1 - 26.0).abs() < 1e-6, "red {r:?}");
+    // Its ids are this document's.
+    assert_ne!(group.id, paths[0].id);
+    assert_ne!(paths[0].id, paths[1].id);
 }
 
 #[test]

crates/eps/src/import/graphics.rs

@@ -34,6 +34,9 @@ const MAX_PATH: usize = 1 << 20;
 const MAX_DRAWN: usize = 1 << 24;
 /// Samples taken of a shading function that isn't a plain interpolation.
 const SHADING_SAMPLES: usize = 32;
+/// Most bounds of a stitched linear function that become a gradient's stops: past it, the
+/// function is sampled like any other (each stop evaluates the whole function).
+const MAX_STITCH_STOPS: usize = 1024;
 
 pub(super) const FAR_AWAY: &str = "objects far outside the page were left out";
 pub(super) const TOO_MUCH: &str = "the file draws more than VectorCraft reads: the rest was left out";
@@ -1007,8 +1010,10 @@ impl Interp<'_> {
         let domain = nums(get("Domain"));
         let (d0, d1) = (domain.first().copied().unwrap_or(0.0), domain.get(1).copied().unwrap_or(1.0));
         let f = get("Function").ok_or(PsError::Ps("undefined", "Function".into()))?;
-        // Where the colour changes: the ends, and the bounds of stitched linear functions.
-        let ts: Vec<f64> = match linear_points(&f) {
+        // Where the colour changes: the ends, and the bounds of stitched linear functions (unless
+        // there are too many).
+        let mut visits = 0;
+        let ts: Vec<f64> = match linear_points(&f, 0, &mut visits).filter(|p| p.len() <= MAX_STITCH_STOPS) {
             Some(mut pts) => {
                 pts.retain(|t| (d0.min(d1)..=d0.max(d1)).contains(t));
                 pts.iter().map(|t| if d1 != d0 { (t - d0) / (d1 - d0) } else { 0.0 }).chain([0.0, 1.0]).collect()
@@ -1085,16 +1090,21 @@ impl Interp<'_> {
                 Ok(c0.iter().zip(&c1).map(|(a, b)| a + x * (b - a)).collect())
             }
             Some(3.0) => {
-                let fs = get("Functions").and_then(|o| o.items().map(|i| i.to_vec())).unwrap_or_default();
+                // Read the pieces through the borrow and clone only the one we recurse into: a
+                // `Functions` array of millions (shared, or reached again through a cycle) must
+                // not be copied on every call and at every live recursion level.
+                let functions = get("Functions");
+                let fs = functions.as_ref().and_then(Obj::items);
+                let n = fs.map_or(0, Shared::len);
                 let bounds = nums(get("Bounds"));
                 let encode = nums(get("Encode"));
                 let (lo, hi) = (domain.first().copied().unwrap_or(0.0), domain.get(1).copied().unwrap_or(1.0));
-                let k = bounds.iter().take_while(|b| t >= **b).count().min(fs.len().saturating_sub(1));
+                let k = bounds.iter().take_while(|b| t >= **b).count().min(n.saturating_sub(1));
                 let a = if k == 0 { lo } else { bounds.get(k - 1).copied().unwrap_or(lo) };
                 let b = bounds.get(k).copied().unwrap_or(hi);
                 let (e0, e1) = (encode.get(2 * k).copied().unwrap_or(0.0), encode.get(2 * k + 1).copied().unwrap_or(1.0));
                 let u = if b != a { e0 + (t - a) / (b - a) * (e1 - e0) } else { e0 };
-                let g = fs.get(k).cloned().ok_or(PsError::Ps("rangecheck", "Functions".into()))?;
+                let g = fs.and_then(|fs| fs.get(k)).ok_or(PsError::Ps("rangecheck", "Functions".into()))?;
                 self.eval(&g, &[u], depth + 1)
             }
             _ => {
@@ -1621,16 +1631,34 @@ fn is_mesh(sh: &DictRef) -> bool {
 }
 
 /// Where a stitched function of linear interpolations changes slope (its bounds), when it is
-/// one; `None` for functions that must be sampled.
-fn linear_points(f: &Obj) -> Option<Vec<f64>> {
+/// one; `None` for functions that must be sampled. `depth` bounds the nesting the same way
+/// [`Interp::eval`] does (`> 8`) and `visits` (shared by the whole recursion, incremented on
+/// every call) bounds the total nodes looked at. Both are needed: the depth limit alone stops a
+/// function that refers to itself in a cycle, but not one that fans out through shared children
+/// (1025 references to a child a few levels deep is 1025^levels nodes without the visit cap). A
+/// well-formed stitch of linear pieces is one level, at most `MAX_STITCH_STOPS + 1` pieces, so it
+/// costs at most `MAX_STITCH_STOPS + 2` visits and is never cut off.
+fn linear_points(f: &Obj, depth: u32, visits: &mut usize) -> Option<Vec<f64>> {
+    *visits += 1;
+    if depth > 8 || *visits > 2 * (MAX_STITCH_STOPS + 1) {
+        return None;
+    }
     let Obj::Dict(d) = f else { return None };
     let d = d.borrow();
     let num = |k: &str| d.get(&Key::name(k)).and_then(Obj::as_num);
     match num("FunctionType")? {
         2.0 if num("N").unwrap_or(1.0) == 1.0 => Some(vec![]),
         3.0 => {
-            let fs = d.get(&Key::name("Functions"))?.items()?.to_vec();
-            if !fs.iter().all(|g| linear_points(g).is_some_and(|p| p.is_empty())) {
+            let items = d.get(&Key::name("Functions"))?.items()?;
+            // More pieces than the stop cap allows: sample the function instead (tested before
+            // `to_vec`, so a huge `Functions` array is not copied only to be rejected). Each stop
+            // runs [`Interp::eval`], which reads one piece, so a short `Bounds` with a huge
+            // `Functions` would still be O(stops * Functions) to find each piece without this.
+            if items.len() > MAX_STITCH_STOPS + 1 {
+                return None;
+            }
+            let fs = items.to_vec();
+            if !fs.iter().all(|g| linear_points(g, depth + 1, visits).is_some_and(|p| p.is_empty())) {
                 return None;
             }
             d.get(&Key::name("Bounds"))?.items().map(|i| i.borrow().iter().filter_map(Obj::as_num).collect())

crates/eps/src/import/tests_generators.rs

@@ -897,6 +897,99 @@ fn hostile_patterns_glyphs_and_shadings_end() {
     assert_eq!(objects(&r.document).len(), 1);
 }
 
+/// The stops of the gradient `body` draws, after asserting it came in cleanly as one gradient.
+fn stitch_stops(body: &str) -> Vec<f32> {
+    let r = read(body);
+    assert!(r.warnings.is_empty(), "{:?}", r.warnings);
+    let o = objects(&r.document);
+    let [node] = o.as_slice() else { panic!("{o:?}") };
+    let Some(Paint::Gradient(g)) = fill(node) else { panic!("{node:?}") };
+    g.gradient.stops.iter().map(|s| s.offset).collect()
+}
+
+/// A gradient stitched from linear pieces keeps their bounds as its stops up to the cap, and is
+/// sampled past it. The cap is on the pieces; a well-formed stitch has one more piece than bounds.
+#[test]
+fn gradients_stitched_from_linear_pieces_keep_or_sample_their_stops() {
+    // `bounds` interior bounds at i / (bounds + 1), with one linear piece more than that.
+    let stitched = |bounds: usize| {
+        let pieces = bounds + 1;
+        format!(
+            "/F << /FunctionType 2 /Domain [0 1] /C0 [0] /C1 [1] /N 1 >> def \
+             << /ShadingType 2 /ColorSpace /DeviceGray /Coords [0 0 100 0] /Function << /FunctionType 3 /Domain [0 1] \
+             /Functions [ {pieces} {{ F }} repeat ] /Bounds [ 1 1 {bounds} {{ {pieces} div }} for ] >> >> shfill"
+        )
+    };
+    // A few pieces: the bounds are kept exactly as stops (three bounds -> five stops with the ends).
+    assert_eq!(stitch_stops(&stitched(3)), vec![0.0, 0.25, 0.5, 0.75, 1.0]);
+    // At the cap (1024 bounds, 1025 pieces) the 1024 bounds and the two ends are all kept.
+    assert_eq!(stitch_stops(&stitched(1024)).len(), 1026);
+    // One past it (1025 bounds, 1026 pieces) the function is sampled instead.
+    assert_eq!(stitch_stops(&stitched(1025)).len(), 33);
+}
+
+/// A malformed stitching function with a single piece but thousands of bounds is sampled, not
+/// turned into thousands of stops. This is the one case the stop-count `.filter` catches on its
+/// own: the one piece is under the Functions-length guard, so only the bound count is out of range.
+#[test]
+fn a_stitching_function_with_one_piece_but_many_bounds_is_sampled() {
+    let stops = stitch_stops(
+        "/F << /FunctionType 2 /Domain [0 1] /C0 [0] /C1 [1] /N 1 >> def \
+         << /ShadingType 2 /ColorSpace /DeviceGray /Coords [0 0 100 0] /Function << /FunctionType 3 /Domain [0 1] \
+         /Functions [ F ] /Bounds [ 1 1 2000 { 2001 div } for ] >> >> shfill",
+    );
+    // Base keeps all 2000 bounds (2002 stops); the fix samples.
+    assert_eq!(stops.len(), 33);
+}
+
+/// A short `Bounds` with a `Functions` array one past the cap is sampled: without the length
+/// guard each of the ~1000 stops would read through the whole array to find its piece.
+#[test]
+fn a_gradient_with_a_functions_array_past_the_cap_is_sampled() {
+    let stops = stitch_stops(
+        "/F << /FunctionType 2 /Domain [0 1] /C0 [0] /C1 [1] /N 1 >> def \
+         << /ShadingType 2 /ColorSpace /DeviceGray /Coords [0 0 100 0] /Function << /FunctionType 3 /Domain [0 1] \
+         /Functions [ 1026 { F } repeat ] /Bounds [ 1 1 1000 { 1001 div } for ] >> >> shfill",
+    );
+    // Base keeps the 1000 bounds (1002 stops); the fix samples.
+    assert_eq!(stops.len(), 33);
+}
+
+/// A stitching function (type 3) whose `Functions` array holds the function itself must not
+/// recurse without end: `linear_points` (depth- and visit-bounded) and `eval` (depth-bounded)
+/// both stop, so the shading raises an error instead of overflowing the stack (an abort
+/// `vectorcraft_engine::guard` can't catch, and on wasm there is no net at all).
+#[test]
+fn a_stitching_function_that_refers_to_itself_is_rejected_not_crashed() {
+    let r = read(
+        "0 0 10 10 rectfill \
+         /F 5 dict def F /FunctionType 3 put F /Domain [0 1] put F /Bounds [] put F /Encode [0 1] put F /Functions [ F ] put \
+         << /ShadingType 2 /ColorSpace /DeviceGray /Coords [0 0 100 0] /Function F >> shfill",
+    );
+    // Not an abort: the reader stops at the error, keeps the rectangle drawn before it, and leaves
+    // the rest of the program unread (see `import`: what follows the error is left out).
+    assert_eq!(objects(&r.document).len(), 1);
+    assert!(r.warnings.iter().any(|w| w.contains("read up to an error") && w.contains("Function")), "{:?}", r.warnings);
+}
+
+/// A stitching function need not point at itself to blow up: a `Functions` array of 1025
+/// references to a child that holds 1025 references to a child ... is a tree of 1025^levels nodes
+/// though it is tiny in memory (the children are shared). The shared visit counter stops
+/// `linear_points` after about 2 * (MAX_STITCH_STOPS + 1) nodes, so it is sampled at once instead
+/// of being walked; on the unmodified reader this explores ~1025^3 nodes.
+#[test]
+fn a_deeply_shared_stitching_function_is_sampled_not_walked() {
+    // leaf (linear) <- mid2[1025 leaf] <- mid1[1025 mid2] <- top[1025 mid1] (1000 bounds).
+    let stops = stitch_stops(
+        "/leaf << /FunctionType 2 /Domain [0 1] /C0 [0] /C1 [1] /N 1 >> def \
+         /mid2 << /FunctionType 3 /Domain [0 1] /Bounds [] /Functions [ 1025 { leaf } repeat ] >> def \
+         /mid1 << /FunctionType 3 /Domain [0 1] /Bounds [] /Functions [ 1025 { mid2 } repeat ] >> def \
+         /top  << /FunctionType 3 /Domain [0 1] /Bounds [ 1 1 1000 { 1001 div } for ] /Functions [ 1025 { mid1 } repeat ] >> def \
+         << /ShadingType 2 /ColorSpace /DeviceGray /Coords [0 0 100 0] /Function top >> shfill",
+    );
+    assert_eq!(stops.len(), 33);
+}
+
 /// Executable strings and keys other than names (#474): `cvx` makes a string executable, and
 /// running it runs its text (PLRM 3rd ed. §3.3.1, `cvx`, `exec`); `load` takes any key (§8.2).
 /// A program closes its shading dictionaries with an executable string (`>>` at Level 2 and up,

crates/mcp/src/tools.rs

@@ -419,7 +419,7 @@ pub fn tool_definitions() -> Vec<Value> {
         tool(
             "create_graph",
             "Create graph",
-            "Create a graph (graph tools) in the plot rectangle. Data as `csv` (first row: empty cell then series names; then one row per category: label, values…) or `series`/`categories`/`rows`. Edit later with run_command graph.setData / graph.setType.",
+            "Create a graph (graph tools) in the plot rectangle. Data as `csv` (first row: empty cell then series names; then one row per category: label, values…) or `series`/`categories`/`rows`. An empty CSV cell or a null in `rows` is a blank value (no column; lines break around it); a number in straight quotes is a label. Edit later with run_command graph.setData / graph.setType.",
             obj(
                 json!({
                     "type": {"type": "string", "enum": ["column", "stackedColumn", "bar", "stackedBar", "line", "area", "scatter", "pie", "radar"]},
@@ -430,7 +430,7 @@ pub fn tool_definitions() -> Vec<Value> {
                     "csv": {"type": "string"},
                     "series": {"type": "array", "items": {"type": "string"}},
                     "categories": {"type": "array", "items": {"type": "string"}},
-                    "rows": {"type": "array", "items": {"type": "array", "items": {"type": "number"}}},
+                    "rows": {"type": "array", "items": {"type": "array", "items": {"type": ["number", "null"]}}},
                 }),
                 &["x", "y", "width", "height"],
             ),

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,10 @@ 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 (center, extent) = (content.reach.center(), 0.5 * content.reach.width().hypot(content.reach.height()));
+        let space = effects::PixelSpace { to_doc, px, center, channels, line: 72.0 / ppi, extent };
         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

@@ -367,13 +367,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
             painter.add(Shape::closed_line(xf.quad(doc.setup.bleed_rect(ab.rect)), Stroke::new(1.0, t.bleed)));
         }
         if (artboard_tool || doc.artboards.len() > 1) && tool_labelled != u64::try_from(i).ok() {
-            painter.text(
-                r.left_top() - vec2(0.0, 4.0),
-                egui::Align2::LEFT_BOTTOM,
-                format!("{:02} - {}", i + 1, ab.name),
-                egui::FontId::proportional(11.0),
-                t.text_dim,
-            );
+            artboard_label(&painter, r, &format!("{:02} - {}", i + 1, ab.name), t.text_dim);
         }
     }
     if app.ui.view.guides {
@@ -1701,8 +1695,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);
@@ -1749,6 +1743,22 @@ fn ime_output(app: &mut VectorcraftApp, ctx: &egui::Context, xf: &Xf) {
     });
 }
 
+/// The width an artboard needs on screen for its name to show (px): narrower, the name is left
+/// out rather than spilling over its neighbours.
+const MIN_LABELLED_ARTBOARD: f32 = 24.0;
+
+/// Artboard `name` above the top-left corner of its on-screen rect `r`, no wider than the
+/// artboard: a longer name ends in "…", and an artboard too narrow shows none (#949).
+fn artboard_label(painter: &egui::Painter, r: egui::Rect, name: &str, color: Color32) {
+    if r.width() < MIN_LABELLED_ARTBOARD {
+        return;
+    }
+    let mut job = egui::text::LayoutJob::simple_singleline(name.to_owned(), egui::FontId::proportional(11.0), color);
+    job.wrap = egui::text::TextWrapping { max_width: r.width(), max_rows: 1, break_anywhere: true, overflow_character: Some('…') };
+    let galley = painter.layout_job(job);
+    painter.galley(r.left_top() - vec2(0.0, 4.0 + galley.size().y), galley, color);
+}
+
 /// Is overlay label `text` the Artboard tool's "01 - <artboard name>"? It holds a name, so it is
 /// shown as it is; the tools' other labels ("anchor", "path", Puppet Warp's warning) are ours.
 fn names_an_artboard(text: &str) -> bool {
@@ -2219,6 +2229,31 @@ mod tests {
         assert!(!names_an_artboard("anchor") && !names_an_artboard("1 - x") && !names_an_artboard("Off the mesh - move closer"));
     }
 
+    /// #949: an artboard's name stays within the artboard's width on screen, ending in "…" when
+    /// longer, and an artboard too narrow shows none.
+    #[test]
+    fn artboard_labels_fit_their_artboard() {
+        let ctx = egui::Context::default();
+        let drawn = |width: f32| {
+            let r = egui::Rect::from_min_size(pos2(50.0, 50.0), vec2(width, 40.0));
+            let mut out = ctx.run_ui(egui::RawInput::default(), |ui| artboard_label(ui.painter(), r, "01 - A long artboard name", Color32::WHITE));
+            out.textures_delta.clear();
+            out.shapes
+                .into_iter()
+                .filter_map(|c| match c.shape {
+                    egui::Shape::Text(t) => Some((t.galley.text().to_string(), t.galley.size().x)),
+                    _ => None,
+                })
+                .collect::<Vec<_>>()
+        };
+        let full = drawn(400.0);
+        assert_eq!(full.first().map(|(s, _)| s.as_str()), Some("01 - A long artboard name"));
+        // Laid out no wider than the artboard (the galley keeps the whole text; it draws "…").
+        let (_, w) = drawn(30.0).first().cloned().unwrap();
+        assert!(full[0].1 > 30.0 && w <= 30.0 + 0.5, "{full:?} {w}");
+        assert!(drawn(10.0).is_empty());
+    }
+
     fn middle(pos: Pos2, pressed: bool) -> egui::Event {
         egui::Event::PointerButton { pos, button: egui::PointerButton::Middle, pressed, modifiers: Default::default() }
     }

crates/ui-egui/src/credits.rs

@@ -7,6 +7,8 @@ use std::cmp::Ordering;
 
 use egui::RichText;
 
+use crate::VectorcraftApp;
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Contributor {
     pub login: &'static str,
@@ -214,7 +216,7 @@ impl Default for View {
 }
 
 /// About ▸ Contributors: a name toggle, a sort, and the list as a grab bag or a table.
-pub fn contributors_ui(ui: &mut egui::Ui) {
+pub fn contributors_ui(app: &mut VectorcraftApp, ui: &mut egui::Ui) {
     let id = egui::Id::new("credits_view");
     let mut v = ui.data_mut(|d| d.get_temp::<View>(id)).unwrap_or_default();
     ui.horizontal_wrapped(|ui| {
@@ -254,14 +256,14 @@ pub fn contributors_ui(ui: &mut egui::Ui) {
         if list.is_empty() {
             ui.label(tl!("No contributor data was built into this copy."));
         } else if v.table {
-            table(ui, &list, &mut v);
+            table(app, ui, &list, &mut v);
         } else {
             ui.horizontal_wrapped(|ui| {
                 for (i, c) in list.iter().enumerate() {
                     if i > 0 {
                         ui.label(RichText::new("·").weak());
                     }
-                    ui.hyperlink_to(c.name(v.names), format!("https://github.com/{}", c.login)).on_hover_text(c.summary());
+                    link(app, ui, c, v.names);
                 }
             });
         }
@@ -269,7 +271,16 @@ pub fn contributors_ui(ui: &mut egui::Ui) {
     ui.data_mut(|d| d.insert_temp(id, v));
 }
 
-fn table(ui: &mut egui::Ui, list: &[&Contributor], v: &mut View) {
+fn link(app: &mut VectorcraftApp, ui: &mut egui::Ui, c: &Contributor, names: NameMode) -> egui::Response {
+    let url = format!("https://github.com/{}", c.login);
+    let r = ui.add(egui::Link::new(c.name(names))).on_hover_text(c.summary());
+    if r.clicked() {
+        app.open_url(&url);
+    }
+    r
+}
+
+fn table(app: &mut VectorcraftApp, ui: &mut egui::Ui, list: &[&Contributor], v: &mut View) {
     egui::Grid::new("credits_table").striped(true).num_columns(SortKey::ALL.len()).show(ui, |ui| {
         for k in SortKey::ALL {
             let arrow = if v.key == k { if v.ascending { " ▲" } else { " ▼" } } else { "" };
@@ -284,7 +295,7 @@ fn table(ui: &mut egui::Ui, list: &[&Contributor], v: &mut View) {
         }
         ui.end_row();
         for c in list {
-            ui.hyperlink_to(c.name(v.names), format!("https://github.com/{}", c.login)).on_hover_text(c.summary());
+            link(app, ui, c, v.names);
             ui.label(group(c.prs));
             ui.label(group(c.commits));
             ui.label(group(c.lines_added));

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

@@ -33,7 +33,7 @@ pub(super) fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
             match tab {
                 1 => {
                     ui.set_width(660.0);
-                    crate::credits::contributors_ui(ui);
+                    crate::credits::contributors_ui(app, ui);
                 }
                 2 => {
                     ui.set_width(660.0);

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,11 @@ 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),
+        ("texture.grain", "grainType") => Some(&vectorcraft_effects::pixel::GRAIN_TYPES),
+        ("texture.texturizer", "texture") => Some(&vectorcraft_effects::pixel::TEXTURES),
+        ("texture.texturizer", "lightDirection") => Some(&vectorcraft_effects::pixel::LIGHT_DIRECTIONS),
+        ("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

@@ -232,10 +232,13 @@ pub(super) fn param_fields(
                 continue;
             }
             if let Some(options) = choices(&k) {
+                // In the "effect" context: some languages read the plain Soft, Horizontal and
+                // Vertical (Grain's types) as type settings.
+                let shown = |label: &'static str| crate::i18n::tr_ctx(crate::i18n::current(), "effect", label);
                 let cur = v.as_str().unwrap_or_default();
-                let label = options.iter().find(|(_, value)| *value == cur).map_or(cur, |(l, _)| *l);
-                let labels: Vec<&str> = options.iter().map(|(l, _)| *l).collect();
-                if let Some((_, value)) = crate::widgets::dropdown(ui, ("fx-choice", &k), label, &labels, 140.0).and_then(|i| options.get(i)) {
+                let label = options.iter().find(|(_, value)| *value == cur).map_or(cur, |(l, _)| shown(l));
+                let labels: Vec<&str> = options.iter().map(|(l, _)| shown(l)).collect();
+                if let Some((_, value)) = crate::widgets::dropdown_names(ui, ("fx-choice", &k), label, &labels, 140.0).and_then(|i| options.get(i)) {
                     d.fields.insert(k, json!(value));
                     changed = true;
                 }
@@ -357,6 +360,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/missing_links.rs

@@ -2,7 +2,8 @@
 //! (`links.relink`), and with Apply to All the other missing files are looked for by name in its
 //! folder; Ignore keeps the images showing their saved preview, and with Apply to All ignores the
 //! rest. Afterwards, with Preferences › Update Links: Ask When Modified, the modified links are
-//! offered for update (`links.update`).
+//! offered for update (`links.update`). Files changed while the app was in the background are
+//! checked when its window comes back to the front ([`after_focus`]).
 //!
 //! Fields: `missing` (`[{name, path, ids}]`, the one asked about first), `modified` (the ids of
 //! images whose file was modified), `applyToAll`, `path` (the replacement file; picked when empty)
@@ -74,6 +75,39 @@ fn ask_update(app: &mut VectorcraftApp, ids: Vec<Value>) {
     super::confirm::ask(app, tl!("Update Modified Links"), &detail, "links.update", json!({ "ids": ids }));
 }
 
+/// A linked file as last seen: its path, and its size and modification time when it exists.
+pub(crate) type FileStamp = (String, Option<(u64, Option<std::time::SystemTime>)>);
+
+/// The window came back to the front (#925): linked files of the active document changed
+/// meanwhile are read again with Update Links: Automatically, offered for update with Ask When
+/// Modified (once per change of a file), and left to the Links panel with Manually. Nothing is
+/// asked while a dialog is open.
+pub fn after_focus(app: &mut VectorcraftApp) {
+    if cfg!(target_arch = "wasm32") || app.session.prefs.update_links == "manually" || app.ui.dialog.is_some() || app.session.active().is_none() {
+        return;
+    }
+    let Ok(r) = app.session.execute("links.check", &json!({})) else { return };
+    let rows: Vec<Value> = r["links"].as_array().into_iter().flatten().filter(|l| l["status"] == "modified").cloned().collect();
+    if rows.is_empty() {
+        return;
+    }
+    if app.session.prefs.update_links == "automatically" {
+        // A failure shows in the status bar, as the Links panel's Update Link does.
+        let _ = app.run("links.update", json!({ "ids": ids(&rows) }));
+        return;
+    }
+    // The file each link reads (one found elsewhere after a move), its size and when it was last
+    // changed (two changes can share a time on file systems that keep it coarsely).
+    let stamp = |l: &Value| -> FileStamp {
+        let path = l["found"].as_str().or(l["path"].as_str()).unwrap_or_default().to_string();
+        let meta = std::fs::metadata(&path).ok();
+        let at = meta.as_ref().map(|m| (m.len(), m.modified().ok()));
+        (path, at)
+    };
+    let new: Vec<Value> = rows.into_iter().filter(|l| app.links_asked.insert(stamp(l))).collect();
+    ask_update(app, ids(&new));
+}
+
 fn body(_: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
     let t = Tokens::get(ui.ctx());
     let missing = d.fields.get("missing").and_then(Value::as_array).map_or(&[][..], Vec::as_slice);
@@ -262,4 +296,58 @@ mod tests {
         assert!(app.ui.dialog.is_none());
         let _ = std::fs::remove_dir_all(dir);
     }
+
+    /// #925: a linked file changed while the app was in the background follows Update Links when
+    /// the window comes back to the front.
+    #[test]
+    fn a_link_changed_in_the_background_follows_update_links_on_focus() {
+        let dir = std::env::temp_dir().join(format!("vectorcraft-focus-links-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.services.read = Some(Box::new(|p: &str| std::fs::read(p).map_err(|e| e.to_string())));
+        app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+        let pic = dir.join("a.png");
+        // Each version a different size, so no two share a length and modification time.
+        let mut version = 0;
+        let mut change = || {
+            version += 1;
+            let mut out = vec![];
+            image::RgbaImage::from_pixel(100 + version, 50, image::Rgba([40 * version as u8, 0, 0, 255]))
+                .write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png)
+                .unwrap();
+            std::fs::write(&pic, out).unwrap();
+        };
+        change();
+        app.run("file.place", json!({"path": pic.to_string_lossy()})).unwrap();
+        let modified = |app: &mut VectorcraftApp| app.run("links.check", json!({})).unwrap()["modified"].as_u64().unwrap();
+        // The window coming to the front asks for the check.
+        let mut raw = egui::RawInput { events: vec![egui::Event::WindowFocused(true)], ..Default::default() };
+        app.raw_input_hook(&mut raw);
+        assert!(app.links_check);
+        // Ask When Modified (the default): asked once per change.
+        change();
+        after_focus(&mut app);
+        let d = app.ui.dialog.take().expect("asks");
+        assert_eq!(d.str("__command"), "links.update");
+        after_focus(&mut app);
+        assert!(app.ui.dialog.is_none(), "not twice for the same change");
+        change();
+        after_focus(&mut app);
+        assert!(app.ui.dialog.is_some(), "a new change asks again");
+        super::super::confirm(&mut app).unwrap();
+        assert_eq!(modified(&mut app), 0);
+        // Automatically: read again without asking.
+        app.run("prefs.set", json!({"key": "updateLinks", "value": "automatically"})).unwrap();
+        change();
+        after_focus(&mut app);
+        assert!(app.ui.dialog.is_none());
+        assert_eq!(modified(&mut app), 0);
+        // Manually: left to the Links panel.
+        app.run("prefs.set", json!({"key": "updateLinks", "value": "manually"})).unwrap();
+        change();
+        after_focus(&mut app);
+        assert!(app.ui.dialog.is_none());
+        assert_eq!(modified(&mut app), 1);
+        let _ = std::fs::remove_dir_all(dir);
+    }
 }

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/dialogs/tests.rs

@@ -176,6 +176,12 @@ fn raster_filter_dialogs_preview_and_apply() {
         ("pixelate.crystallize", "cellSize", "20"),
         ("pixelate.mezzotint", "type", "longLines"),
         ("pixelate.pointillize", "cellSize", "12"),
+        ("texture.craquelure", "crackDepth", "9"),
+        ("texture.grain", "grainType", "stippled"),
+        ("texture.mosaicTiles", "tileSize", "20"),
+        ("texture.patchwork", "relief", "20"),
+        ("texture.stainedGlass", "borderThickness", "2"),
+        ("texture.texturizer", "lightDirection", "bottomLeft"),
     ] {
         let mut app = app();
         let id = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap()["id"].as_u64().unwrap();
@@ -203,6 +209,10 @@ fn raster_filter_dialogs_preview_and_apply() {
     assert_eq!(super::form::humanize("maxRadius"), "Max. Radius:");
     assert_eq!(super::form::humanize("channel3"), "Channel 3:");
     assert_eq!(super::form::humanize("cellSize"), "Cell Size:");
+    assert_eq!(super::form::humanize("lightDirection"), "Light Direction:");
+    let doc = vectorcraft_effects::effect_info("texture.texturizer").unwrap().params;
+    let ranks: Vec<usize> = ["texture", "scaling", "relief", "lightDirection", "invert"].iter().map(|k| super::effect::doc_rank(doc, k)).collect();
+    assert!(ranks.windows(2).all(|w| w[0] < w[1]) && ranks[4] < usize::MAX, "{ranks:?}");
 }
 
 #[test]

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

@@ -657,3 +657,16 @@
 	Crystallize…	Krystalizace…
 	Mezzotint…	Mezzotinta…
 	Pointillize…	Pointilismus…
+	Video	Video
+	De-Interlace…	Odstranit prokládání…
+	NTSC Colors	Barvy NTSC
+	RGB:	RGB:
+	CMYK:	CMYK:
+	CMYK	CMYK
+	Texture	Textura
+	Craquelure…	Krakelování…
+	Grain…	Zrno…
+	Mosaic Tiles…	Mozaikové dlaždice…
+	Patchwork…	Patchwork…
+	Stained Glass…	Vitráž…
+	Texturizer…	Texturovač…

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
@@ -3861,3 +3908,66 @@ axis	Both	Ambos
 @msg	automation path rejected: cannot resolve {path}: {e}	ruta de automatización rechazada: no se puede resolver {path}: {e}
 @msg	automation path rejected: parent traversal below a folder that doesn't exist: {path}	ruta de automatización rechazada: sube (..) desde una carpeta que no existe: {path}
 @msg	automation path rejected: reserved device names are not allowed: {path}	ruta de automatización rechazada: no se permiten nombres de dispositivo reservados: {path}
+@msg	Multichannel PSD files can't be read: save it in RGB, CMYK or Grayscale mode	Los archivos PSD en modo Multicanal no se pueden leer: guárdalo en modo RGB, CMYK o Escala de grises
+@msg	not a PSD file	no es un documento PSD
+@msg	the PSD file has an unknown colour mode ({m})	el archivo PSD tiene un modo de color desconocido ({m})
+@msg	the PSD file's image data uses an unknown compression ({m})	los datos de imagen del archivo PSD usan una compresión desconocida ({m})
+@msg	the PSD image is too large to read ({_1} × {_2} pixels)	la imagen PSD es demasiado grande para leerla ({_1} × {_2} píxeles)
+@msg	zipped 32-bit PSD image data with prediction can't be read	no se pueden leer datos de imagen PSD de 32 bits comprimidos en ZIP con predicción
+@msg	{depth}-bit PSD files in this colour mode can't be read	los archivos PSD de {depth} bits en este modo de color no se pueden leer
+@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
+	RGB:	RGB:
+	CMYK:	CMYK:
+	Texture	Textura
+	Craquelure…	Craquelado…
+	Grain…	Granulado…
+	Mosaic Tiles…	Azulejos de mosaico…
+	Patchwork…	Retazos…
+	Stained Glass…	Vidriera…
+	Texturizer…	Texturizador…
+	Craquelure	Craquelado
+	Grain	Granulado
+	Mosaic Tiles	Azulejos de mosaico
+	Patchwork	Retazos
+	Stained Glass	Vidriera
+	Texturizer	Texturizador
+	Crack Spacing	Espaciado de grietas
+	Crack Depth	Profundidad de grietas
+	Crack Brightness	Brillo de grietas
+	Intensity	Intensidad
+	Grain Type	Tipo de granulado
+	Tile Size	Tamaño de azulejo
+	Grout Width	Anchura de la junta
+	Lighten Grout	Aclarar junta
+	Square Size	Tamaño de cuadrado
+	Relief	Relieve
+	Border Thickness	Grosor del borde
+	Light Intensity	Intensidad de luz
+	Light Direction	Dirección de la luz
+	Sprinkles	Espolvoreado
+	Clumped	Agrupado
+	Contrasty	Contrastado
+	Enlarged	Ampliado
+	Stippled	Punteado
+	Speckle	Moteado
+	Brick	Ladrillo
+	Burlap	Arpillera
+	Canvas	Lienzo
+	Sandstone	Arenisca
+	Bottom Left	Abajo a la izquierda
+	Top Left	Arriba a la izquierda
+	Top Right	Arriba a la derecha
+	Bottom Right	Abajo a la derecha

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é
@@ -3872,3 +3919,67 @@ axis	Both	Les deux
 @msg	automation path rejected: cannot resolve {path}: {e}	chemin d’automatisation refusé : impossible de résoudre {path} : {e}
 @msg	automation path rejected: parent traversal below a folder that doesn't exist: {path}	chemin d’automatisation refusé : remonte (..) depuis un dossier qui n’existe pas : {path}
 @msg	automation path rejected: reserved device names are not allowed: {path}	chemin d’automatisation refusé : les noms de périphériques réservés ne sont pas autorisés : {path}
+@msg	Multichannel PSD files can't be read: save it in RGB, CMYK or Grayscale mode	Les fichiers PSD en mode Multicouche ne peuvent pas être lus : enregistrez-le en mode RVB, CMJN ou Niveaux de gris
+@msg	not a PSD file	ce n'est pas un document PSD
+@msg	the PSD file has an unknown colour mode ({m})	le fichier PSD a un mode colorimétrique inconnu ({m})
+@msg	the PSD file's image data uses an unknown compression ({m})	les données d'image du fichier PSD utilisent une compression inconnue ({m})
+@msg	the PSD image is too large to read ({_1} × {_2} pixels)	l'image PSD est trop grande pour être lue ({_1} × {_2} pixels)
+@msg	zipped 32-bit PSD image data with prediction can't be read	les données d'image PSD 32 bits compressées en ZIP avec prédiction ne peuvent pas être lues
+@msg	{depth}-bit PSD files in this colour mode can't be read	les fichiers PSD {depth} bits dans ce mode colorimétrique ne peuvent pas être lus
+@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
+	RGB:	RGB:
+	CMYK:	CMYK:
+	Texture	Texture
+	Craquelure…	Craquelure…
+	Grain…	Grain…
+	Mosaic Tiles…	Carreaux de mosaïque…
+	Patchwork…	Patchwork…
+	Stained Glass…	Vitrail…
+	Texturizer…	Placage de texture…
+	Craquelure	Craquelure
+	Grain	Grain
+	Mosaic Tiles	Carreaux de mosaïque
+	Patchwork	Patchwork
+	Stained Glass	Vitrail
+	Texturizer	Placage de texture
+	Crack Spacing	Espacement des craquelures
+	Crack Depth	Profondeur des craquelures
+	Crack Brightness	Luminosité des craquelures
+	Intensity	Intensité
+	Grain Type	Type de grain
+	Tile Size	Taille des carreaux
+	Grout Width	Largeur des joints
+	Lighten Grout	Éclaircir les joints
+	Square Size	Taille des carrés
+	Relief	Relief
+	Border Thickness	Épaisseur de la bordure
+	Light Intensity	Intensité de la lumière
+	Light Direction	Direction de la lumière
+	Sprinkles	Saupoudré
+	Clumped	Agglutiné
+	Contrasty	Contrasté
+	Enlarged	Agrandi
+	Stippled	Pointillé
+	Speckle	Moucheté
+	Brick	Brique
+	Burlap	Toile de jute
+	Canvas	Toile
+	Sandstone	Grès
+	Bottom Left	En bas à gauche
+	Top Left	En haut à gauche
+	Top Right	En haut à droite
+	Bottom Right	En bas à droite
+effect	Soft	Doux

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à
@@ -3861,3 +3908,68 @@ axis	Both	Entrambi
 @msg	automation path rejected: cannot resolve {path}: {e}	percorso di automazione rifiutato: impossibile risolvere {path}: {e}
 @msg	automation path rejected: parent traversal below a folder that doesn't exist: {path}	percorso di automazione rifiutato: risale (..) da una cartella che non esiste: {path}
 @msg	automation path rejected: reserved device names are not allowed: {path}	percorso di automazione rifiutato: i nomi di dispositivo riservati non sono consentiti: {path}
+@msg	Multichannel PSD files can't be read: save it in RGB, CMYK or Grayscale mode	I file PSD in modalità Multicanale non possono essere letti: salvalo in modalità RGB, CMYK o Scala di grigio
+@msg	not a PSD file	non è un documento PSD
+@msg	the PSD file has an unknown colour mode ({m})	il file PSD ha un metodo colore sconosciuto ({m})
+@msg	the PSD file's image data uses an unknown compression ({m})	i dati immagine del file PSD usano una compressione sconosciuta ({m})
+@msg	the PSD image is too large to read ({_1} × {_2} pixels)	l'immagine PSD è troppo grande per essere letta ({_1} × {_2} pixel)
+@msg	zipped 32-bit PSD image data with prediction can't be read	i dati immagine PSD a 32 bit compressi ZIP con previsione non possono essere letti
+@msg	{depth}-bit PSD files in this colour mode can't be read	i file PSD a {depth} bit in questo metodo colore non possono essere letti
+@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
+	RGB:	RGB:
+	CMYK:	CMYK:
+	Texture	Texture
+	Craquelure…	Craquelé…
+	Grain…	Granulosità…
+	Mosaic Tiles…	Tessere di mosaico…
+	Patchwork…	Patchwork…
+	Stained Glass…	Vetro colorato…
+	Texturizer…	Applica texture…
+	Craquelure	Craquelé
+	Grain	Granulosità
+	Mosaic Tiles	Tessere di mosaico
+	Patchwork	Patchwork
+	Stained Glass	Vetro colorato
+	Texturizer	Applica texture
+	Crack Spacing	Spaziatura crepe
+	Crack Depth	Profondità crepe
+	Crack Brightness	Luminosità crepe
+	Intensity	Intensità
+	Grain Type	Tipo di granulosità
+	Tile Size	Dimensione tessere
+	Grout Width	Larghezza stuccatura
+	Lighten Grout	Schiarisci stuccatura
+	Square Size	Dimensione quadrati
+	Relief	Rilievo
+	Border Thickness	Spessore bordo
+	Light Intensity	Intensità luce
+	Light Direction	Direzione luce
+	Sprinkles	Spruzzato
+	Clumped	Raggruppato
+	Contrasty	Contrastato
+	Enlarged	Ingrandito
+	Stippled	Punteggiato
+	Speckle	Maculato
+	Brick	Mattone
+	Burlap	Tela di iuta
+	Canvas	Tela
+	Sandstone	Arenaria
+	Bottom Left	In basso a sinistra
+	Top Left	In alto a sinistra
+	Top Right	In alto a destra
+	Bottom Right	In basso a destra
+effect	Soft	Morbido
+effect	Regular	Normale

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	アートに境界がありません
@@ -3853,3 +3900,69 @@ theme	Appearance	外観
 @msg	automation path rejected: cannot resolve {path}: {e}	自動化のパスを拒否しました: {path} を解決できません: {e}
 @msg	automation path rejected: parent traversal below a folder that doesn't exist: {path}	自動化のパスを拒否しました: 存在しないフォルダーから上の階層 (..) へ移動しています: {path}
 @msg	automation path rejected: reserved device names are not allowed: {path}	自動化のパスを拒否しました: 予約済みのデバイス名は使用できません: {path}
+@msg	Multichannel PSD files can't be read: save it in RGB, CMYK or Grayscale mode	マルチチャンネルの PSD ファイルは読み込めません：RGB、CMYK またはグレースケールモードで保存してください
+@msg	not a PSD file	PSD ドキュメントではありません
+@msg	the PSD file has an unknown colour mode ({m})	PSD ファイルのカラーモードが不明です（{m}）
+@msg	the PSD file's image data uses an unknown compression ({m})	PSD ファイルの画像データの圧縮方式が不明です（{m}）
+@msg	the PSD image is too large to read ({_1} × {_2} pixels)	PSD 画像が大きすぎて読み込めません（{_1} × {_2} ピクセル）
+@msg	zipped 32-bit PSD image data with prediction can't be read	予測付き ZIP 圧縮の 32 bit PSD 画像データは読み込めません
+@msg	{depth}-bit PSD files in this colour mode can't be read	このカラーモードの {depth} bit PSD ファイルは読み込めません
+@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} を読み込みました
+	RGB:	RGB:
+	CMYK:	CMYK:
+	Texture	テクスチャ
+	Craquelure…	クラッキング…
+	Grain…	粒状…
+	Mosaic Tiles…	モザイクタイル…
+	Patchwork…	パッチワーク…
+	Stained Glass…	ステンドグラス…
+	Texturizer…	テクスチャライザー…
+	Craquelure	クラッキング
+	Grain	粒状
+	Mosaic Tiles	モザイクタイル
+	Patchwork	パッチワーク
+	Stained Glass	ステンドグラス
+	Texturizer	テクスチャライザー
+	Crack Spacing	溝の間隔
+	Crack Depth	溝の深さ
+	Crack Brightness	溝の明るさ
+	Intensity	強さ
+	Grain Type	粒子の種類
+	Tile Size	タイルのサイズ
+	Grout Width	目地の幅
+	Lighten Grout	目地を明るく
+	Square Size	正方形のサイズ
+	Relief	レリーフ
+	Border Thickness	境界線の太さ
+	Light Intensity	光の強さ
+	Light Direction	光源の方向
+	Sprinkles	散布
+	Clumped	集合
+	Contrasty	高コントラスト
+	Enlarged	拡大
+	Stippled	スティップル
+	Speckle	斑点
+	Brick	レンガ
+	Burlap	麻布
+	Canvas	カンバス
+	Sandstone	砂岩
+	Bottom Left	左下
+	Top Left	左上
+	Top Right	右上
+	Bottom Right	右下
+effect	Soft	ソフト
+effect	Horizontal	水平
+effect	Vertical	垂直

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

@@ -254,6 +254,13 @@ pub fn lang_from_tag(tag: &str) -> Option<Lang> {
     cands.iter().find_map(|c| Lang::from_code(c))
 }
 
+/// True when `tag` names the generic `C` / `POSIX` locale (or a variant like `C.UTF-8`), which on
+/// macOS means "no particular language" rather than English: the system language list decides.
+fn is_c_locale(tag: &str) -> bool {
+    let base = tag.split(['.', '@']).next().unwrap_or("").to_ascii_lowercase();
+    matches!(base.as_str(), "c" | "posix")
+}
+
 /// Work out the system language on a background thread, so the first frame doesn't wait for the
 /// locale probe (which runs `reg.exe` on Windows and `defaults` on macOS). Call it at startup; a
 /// frame that needs the language before the probe finishes waits for it. A no-op on wasm.
@@ -295,6 +302,11 @@ fn detect_system_lang() -> Lang {
     // variables. `LANGUAGE` is a colon-separated priority list.
     for var in ["VECTORCRAFT_LOCALE", "LC_ALL", "LC_MESSAGES", "LANG", "LANGUAGE"] {
         let Some(v) = std::env::var(var).ok().filter(|v| !v.is_empty()) else { continue };
+        // `C` / `POSIX` (and variants like `C.UTF-8`, `POSIX.UTF-8`) mean "no particular locale":
+        // don't force English, fall through to the OS preferred-languages list below.
+        if v.split(':').all(is_c_locale) {
+            continue;
+        }
         if let Some(l) = v.split(':').find_map(lang_from_tag) {
             return l;
         }

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

@@ -2718,3 +2718,15 @@
 	Crystallize…	Cristalizar…
 	Mezzotint…	Meia-Tinta…
 	Pointillize…	Pontilhar…
+	Video	Vídeo
+	De-Interlace…	Desentrelaçar…
+	NTSC Colors	Cores NTSC
+	RGB:	RGB:
+	CMYK:	CMYK:
+	Texture	Textura
+	Craquelure…	Craquelê…
+	Grain…	Granulação…
+	Mosaic Tiles…	Ladrilhos de mosaico…
+	Patchwork…	Colcha de retalhos…
+	Stained Glass…	Vitral…
+	Texturizer…	Texturizador…

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	нет часов для поддержания сигнала
@@ -3859,3 +3906,66 @@ axis	Both	Оба
 @msg	automation path rejected: cannot resolve {path}: {e}	путь автоматизации отклонён: не удаётся определить {path}: {e}
 @msg	automation path rejected: parent traversal below a folder that doesn't exist: {path}	путь автоматизации отклонён: переход вверх (..) из несуществующей папки: {path}
 @msg	automation path rejected: reserved device names are not allowed: {path}	путь автоматизации отклонён: зарезервированные имена устройств недопустимы: {path}
+@msg	Multichannel PSD files can't be read: save it in RGB, CMYK or Grayscale mode	Файлы PSD в режиме «Многоканальный» не читаются: сохраните его в режиме RGB, CMYK или «Градации серого»
+@msg	not a PSD file	это не документ PSD
+@msg	the PSD file has an unknown colour mode ({m})	у файла PSD неизвестный цветовой режим ({m})
+@msg	the PSD file's image data uses an unknown compression ({m})	данные изображения файла PSD используют неизвестное сжатие ({m})
+@msg	the PSD image is too large to read ({_1} × {_2} pixels)	изображение PSD слишком велико для чтения ({_1} × {_2} пикс.)
+@msg	zipped 32-bit PSD image data with prediction can't be read	32-битные данные изображения PSD со сжатием ZIP с предсказанием не читаются
+@msg	{depth}-bit PSD files in this colour mode can't be read	{depth}-битные файлы PSD в этом цветовом режиме не читаются
+@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}
+	RGB:	RGB:
+	CMYK:	CMYK:
+	Texture	Текстура
+	Craquelure…	Кракелюры…
+	Grain…	Зерно…
+	Mosaic Tiles…	Мозаичные фрагменты…
+	Patchwork…	Цветная плитка…
+	Stained Glass…	Витраж…
+	Texturizer…	Текстуризатор…
+	Craquelure	Кракелюры
+	Grain	Зерно
+	Mosaic Tiles	Мозаичные фрагменты
+	Patchwork	Цветная плитка
+	Stained Glass	Витраж
+	Texturizer	Текстуризатор
+	Crack Spacing	Интервал трещин
+	Crack Depth	Глубина трещин
+	Crack Brightness	Яркость трещин
+	Intensity	Интенсивность
+	Grain Type	Тип зерна
+	Tile Size	Размер фрагментов
+	Grout Width	Ширина швов
+	Lighten Grout	Осветление швов
+	Square Size	Размер квадратов
+	Relief	Рельеф
+	Border Thickness	Толщина границ
+	Light Intensity	Интенсивность света
+	Light Direction	Направление света
+	Sprinkles	Брызги
+	Clumped	Комки
+	Contrasty	Контрастное
+	Enlarged	Укрупнённое
+	Stippled	Пунктир
+	Speckle	Крапинки
+	Brick	Кирпич
+	Burlap	Мешковина
+	Canvas	Холст
+	Sandstone	Песчаник
+	Bottom Left	Снизу слева
+	Top Left	Сверху слева
+	Top Right	Сверху справа
+	Bottom Right	Снизу справа

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	немає годинника для підтримки сигналу
@@ -3844,3 +3891,66 @@ axis	Both	Обидві
 @msg	automation path rejected: cannot resolve {path}: {e}	шлях автоматизації відхилено: не вдається визначити {path}: {e}
 @msg	automation path rejected: parent traversal below a folder that doesn't exist: {path}	шлях автоматизації відхилено: перехід угору (..) з папки, якої не існує: {path}
 @msg	automation path rejected: reserved device names are not allowed: {path}	шлях автоматизації відхилено: зарезервовані імена пристроїв не дозволені: {path}
+@msg	Multichannel PSD files can't be read: save it in RGB, CMYK or Grayscale mode	Файли PSD у режимі «Багатоканальний» не читаються: збережіть його в режимі RGB, CMYK або «Відтінки сірого»
+@msg	not a PSD file	це не документ PSD
+@msg	the PSD file has an unknown colour mode ({m})	файл PSD має невідомий колірний режим ({m})
+@msg	the PSD file's image data uses an unknown compression ({m})	дані зображення файлу PSD використовують невідоме стиснення ({m})
+@msg	the PSD image is too large to read ({_1} × {_2} pixels)	зображення PSD завелике для читання ({_1} × {_2} пікс.)
+@msg	zipped 32-bit PSD image data with prediction can't be read	32-бітні дані зображення PSD зі стисненням ZIP із передбаченням не читаються
+@msg	{depth}-bit PSD files in this colour mode can't be read	{depth}-бітні файли PSD у цьому колірному режимі не читаються
+@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}
+	RGB:	RGB:
+	CMYK:	CMYK:
+	Texture	Текстура
+	Craquelure…	Кракелюри…
+	Grain…	Зерно…
+	Mosaic Tiles…	Мозаїчні фрагменти…
+	Patchwork…	Клаптикова плитка…
+	Stained Glass…	Вітраж…
+	Texturizer…	Текстуризатор…
+	Craquelure	Кракелюри
+	Grain	Зерно
+	Mosaic Tiles	Мозаїчні фрагменти
+	Patchwork	Клаптикова плитка
+	Stained Glass	Вітраж
+	Texturizer	Текстуризатор
+	Crack Spacing	Інтервал тріщин
+	Crack Depth	Глибина тріщин
+	Crack Brightness	Яскравість тріщин
+	Intensity	Інтенсивність
+	Grain Type	Тип зерна
+	Tile Size	Розмір фрагментів
+	Grout Width	Ширина швів
+	Lighten Grout	Освітлення швів
+	Square Size	Розмір квадратів
+	Relief	Рельєф
+	Border Thickness	Товщина меж
+	Light Intensity	Інтенсивність світла
+	Light Direction	Напрямок світла
+	Sprinkles	Бризки
+	Clumped	Грудки
+	Contrasty	Контрастне
+	Enlarged	Збільшене
+	Stippled	Пунктир
+	Speckle	Цятки
+	Brick	Цегла
+	Burlap	Мішковина
+	Canvas	Полотно
+	Sandstone	Пісковик
+	Bottom Left	Знизу ліворуч
+	Top Left	Вгорі ліворуч
+	Top Right	Вгорі праворуч
+	Bottom Right	Знизу праворуч

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,56 @@ axis	Both	两者
 	Draft	草稿
 	Good	良好
 	Best	最佳
+	Video	视频
+	De-Interlace…	逐行…
+	De-Interlace	逐行
+	NTSC Colors	NTSC 颜色
+	Eliminate	消除
+	Create New Fields by	创建新场方式
+	Odd Fields	奇数场
+	Even Fields	偶数场
+	Duplication	复制
+	Interpolation	插值
+	Texture	纹理
+	Craquelure…	龟裂缝…
+	Grain…	颗粒…
+	Mosaic Tiles…	马赛克拼贴…
+	Patchwork…	拼缀图…
+	Stained Glass…	染色玻璃…
+	Texturizer…	纹理化…
+	Craquelure	龟裂缝
+	Grain	颗粒
+	Mosaic Tiles	马赛克拼贴
+	Patchwork	拼缀图
+	Stained Glass	染色玻璃
+	Texturizer	纹理化
+	Crack Spacing	裂缝间距
+	Crack Depth	裂缝深度
+	Crack Brightness	裂缝亮度
+	Intensity	强度
+	Grain Type	颗粒类型
+	Tile Size	拼贴大小
+	Grout Width	缝隙宽度
+	Lighten Grout	加亮缝隙
+	Square Size	方形大小
+	Relief	凸现
+	Border Thickness	边框粗细
+	Light Intensity	光照强度
+	Light Direction	光照方向
+	Sprinkles	喷洒
+	Clumped	结块
+	Contrasty	强反差
+	Enlarged	扩大
+	Stippled	点刻
+	Speckle	斑点
+	Brick	砖形
+	Burlap	粗麻布
+	Canvas	画布
+	Sandstone	砂岩
+	Bottom Left	左下
+	Top Left	左上
+	Top Right	右上
+	Bottom Right	右下
+effect	Soft	柔和
+effect	Horizontal	水平
+effect	Vertical	垂直

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,56 @@ axis	Both	兩者
 	Draft	草稿
 	Good	良好
 	Best	最佳
+	Video	視訊
+	De-Interlace…	反交錯…
+	De-Interlace	反交錯
+	NTSC Colors	NTSC 色彩
+	Eliminate	消除
+	Create New Fields by	建立新圖場以
+	Odd Fields	奇數圖場
+	Even Fields	偶數圖場
+	Duplication	複製
+	Interpolation	內插
+	RGB:	RGB：
+	CMYK:	CMYK：
+	Texture	紋理
+	Craquelure…	龜裂紋…
+	Grain…	顆粒…
+	Mosaic Tiles…	馬賽克拼貼…
+	Patchwork…	拼綴圖…
+	Stained Glass…	彩色玻璃…
+	Texturizer…	紋理化…
+	Craquelure	龜裂紋
+	Grain	顆粒
+	Mosaic Tiles	馬賽克拼貼
+	Patchwork	拼綴圖
+	Stained Glass	彩色玻璃
+	Texturizer	紋理化
+	Crack Spacing	裂紋間距
+	Crack Depth	裂紋深度
+	Crack Brightness	裂紋亮度
+	Intensity	強度
+	Grain Type	顆粒類型
+	Tile Size	拼貼大小
+	Grout Width	縫隙寬度
+	Lighten Grout	加亮縫隙
+	Square Size	方塊大小
+	Relief	浮雕
+	Border Thickness	邊框粗細
+	Light Intensity	光源強度
+	Light Direction	光源方向
+	Sprinkles	噴灑
+	Clumped	結塊
+	Contrasty	高反差
+	Enlarged	放大
+	Stippled	點刻
+	Speckle	斑點
+	Brick	磚塊
+	Burlap	粗麻布
+	Canvas	畫布
+	Sandstone	砂岩
+	Bottom Left	左下
+	Top Left	左上
+	Top Right	右上
+	Bottom Right	右下
+effect	Soft	柔和

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

@@ -371,6 +371,12 @@ pub struct VectorcraftApp {
     /// The look for fonts installed or removed while the app was in the background, running
     /// ([`Self::refresh_installed_fonts`]): whether they were.
     font_check: Option<std::sync::mpsc::Receiver<bool>>,
+    /// The window came back to the front: check the active document's linked files next frame
+    /// ([`dialogs::missing_links::after_focus`]).
+    pub(crate) links_check: bool,
+    /// The changed linked files already offered for update (path, size and modification time), so
+    /// coming back to the window doesn't ask about the same change twice.
+    pub(crate) links_asked: std::collections::HashSet<dialogs::missing_links::FileStamp>,
     /// Keyboard pastes of something other than text (see [`shortcuts::PasteChord`]).
     pub(crate) paste_chord: shortcuts::PasteChord,
     /// Saves and exports running in the background (Preferences → File Handling).
@@ -468,6 +474,8 @@ impl VectorcraftApp {
             clipboard_probe: None,
             picks: picks::Picks::default(),
             font_check: None,
+            links_check: false,
+            links_asked: Default::default(),
             paste_chord: Default::default(),
             background: Default::default(),
             recovery: Default::default(),
@@ -881,6 +889,9 @@ impl VectorcraftApp {
             self.system_paste = wanted && self.system_clipboard_pasteable();
         }
         self.poll_font_check(ctx);
+        if std::mem::take(&mut self.links_check) {
+            dialogs::missing_links::after_focus(self);
+        }
         picks::poll(self, ctx);
         background::poll(self);
         if !self.background.jobs.is_empty() {
@@ -1014,7 +1025,10 @@ impl VectorcraftApp {
             match e {
                 egui::Event::ModifiersChanged(m) => self.host_modifiers = *m,
                 egui::Event::WindowFocused(false) => self.host_modifiers = egui::Modifiers::NONE,
-                egui::Event::WindowFocused(true) => self.refresh_installed_fonts(),
+                egui::Event::WindowFocused(true) => {
+                    self.refresh_installed_fonts();
+                    self.links_check = true;
+                }
                 _ => {}
             }
         }

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,13 @@ 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]); 5] = [
+    ("Blur", &["Effect", "Blur"]),
+    ("Pixelate", &["Effect", "Pixelate"]),
+    ("Sharpen", &["Effect", "Sharpen"]),
+    ("Texture", &["Effect", "Texture"]),
+    ("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/gradient.rs

@@ -95,6 +95,43 @@ fn dragged_stops(origin: &[GradientStop], i: usize, offset: f32, copy: bool, ove
 
 // ---------- shared edits ----------
 
+/// The Type row: Linear, Radial and Freeform for the paint behind the active proxy (one of them
+/// lit when it is a gradient). The Gradient panel's and the Properties panel's.
+pub(crate) fn type_row(app: &mut VectorcraftApp, ui: &mut Ui) {
+    let kind = current(app).map(|g| g.gradient.kind);
+    ui.horizontal(|ui| {
+        widgets::dim_label(ui, tl!("Type:"));
+        for (k, icon, tip) in [
+            (GradientKind::Linear, "dc-grad-linear", tl!("Linear Gradient")),
+            (GradientKind::Radial, "dc-grad-radial", tl!("Radial Gradient")),
+            (GradientKind::Freeform, "dc-grad-freeform", tl!("Freeform Gradient")),
+        ] {
+            if widgets::icon_button(ui, icon, tip, kind == Some(k), 24.0).clicked() {
+                edit(app, json!({"kind": k.label().to_lowercase()}), Live::Released);
+            }
+        }
+    });
+}
+
+/// Set how the Gradient tool adds the points of the freeform gradient behind the active proxy.
+fn set_draw_mode(app: &mut VectorcraftApp, mode: FreeformMode) {
+    edit(app, json!({ "mode": mode.label().to_lowercase() }), Live::Released);
+}
+
+/// The Properties panel's Draw row for a freeform gradient: Points and Lines as radio buttons.
+pub(crate) fn draw_radios(app: &mut VectorcraftApp, ui: &mut Ui) {
+    let Some(g) = current(app).filter(|g| g.gradient.kind == GradientKind::Freeform) else { return };
+    let mode = shown_points(&g).mode;
+    ui.horizontal(|ui| {
+        widgets::dim_label(ui, tl!("Draw:"));
+        for (m, label) in [(FreeformMode::Points, tl!("Points")), (FreeformMode::Lines, tl!("Lines"))] {
+            if widgets::radio(ui, label, mode == m, true) && mode != m {
+                set_draw_mode(app, m);
+            }
+        }
+    });
+}
+
 /// The gradient behind the active proxy.
 fn current(app: &VectorcraftApp) -> Option<GradientPaint> {
     match active_paint(app) {
@@ -184,18 +221,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
         }
         ui.add_space(4.0);
         ui.vertical(|ui| {
-            ui.horizontal(|ui| {
-                widgets::dim_label(ui, tl!("Type:"));
-                for (k, icon, tip) in [
-                    (GradientKind::Linear, "dc-grad-linear", tl!("Linear Gradient")),
-                    (GradientKind::Radial, "dc-grad-radial", tl!("Radial Gradient")),
-                    (GradientKind::Freeform, "dc-grad-freeform", tl!("Freeform Gradient")),
-                ] {
-                    if widgets::icon_button(ui, icon, tip, is_grad && kind == k, 24.0).clicked() {
-                        edit(app, json!({"kind": k.label().to_lowercase()}), Live::Released);
-                    }
-                }
-            });
+            type_row(app, ui);
             if widgets::flat_button(ui, tl!("Edit Gradient"), 96.0).clicked() {
                 app.select_tool("gradient");
             }
@@ -297,7 +323,7 @@ fn freeform_section(app: &mut VectorcraftApp, ui: &mut Ui, g: &GradientPaint) {
             (FreeformMode::Lines, "spline", tl!("Lines: clicks add points joined by a line")),
         ] {
             if widgets::icon_button(ui, icon, tip, mode == m, 24.0).clicked() && mode != m {
-                edit(app, json!({ "mode": m.label().to_lowercase() }), Live::Released);
+                set_draw_mode(app, m);
             }
         }
     });

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/panels/mod.rs

@@ -424,7 +424,7 @@ pub(crate) fn label_or_name(s: &str, built_in: bool) -> &str {
 /// command feeds); returns the one clicked, for the caller to apply.
 pub(crate) fn recent_colors_row(app: &VectorcraftApp, ui: &mut Ui) -> Option<Color> {
     let t = Tokens::get(ui.ctx());
-    crate::widgets::subheader(ui, "Recent Colors");
+    crate::widgets::subheader(ui, tl!("Recent Colors"));
     let (r, _) = ui.allocate_exact_size(vec2(ui.available_width(), 22.0), Sense::hover());
     ui.painter().rect_stroke(r, 0.0, egui::Stroke::new(1.0, t.input_border), egui::StrokeKind::Inside);
     let mut chosen = None;

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

@@ -40,6 +40,13 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
     }
     transform_section(app, ui);
     divider(ui);
+    // The Gradient tool: the gradient's type and, for a freeform one, how clicks add points (#921).
+    if app.session.tool_id() == "gradient" {
+        section_header(ui, tl!("Gradient"));
+        super::gradient::type_row(app, ui);
+        super::gradient::draw_radios(app, ui);
+        divider(ui);
+    }
     let is_image = n_sel == 1 && matches!(first.as_ref().map(|n| &n.kind), Some(NodeKind::Image(_)));
     if is_image {
         image_section(app, ui);
@@ -563,6 +570,31 @@ mod tests {
         frame(app, ctx, vec![b(false)]);
     }
 
+    /// #921: with the Gradient tool, a Gradient section: the type, and for a freeform gradient
+    /// Draw as Points or Lines radio buttons.
+    #[test]
+    fn the_gradient_tool_shows_the_gradient_type_and_draw() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 200, "height": 100})).unwrap();
+        let id = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 40})).unwrap()["id"].as_u64().unwrap();
+        app.run("paint.setFill", json!({"gradient": {}})).unwrap();
+        let ctx = egui::Context::default();
+        let has = |texts: &[(String, Rect)], s: &str| texts.iter().any(|(t, _)| t == s);
+        let texts = frame(&mut app, &ctx, vec![]);
+        assert!(!has(&texts, "Gradient"), "only with the Gradient tool");
+        app.select_tool("gradient");
+        let texts = frame(&mut app, &ctx, vec![]);
+        assert!(has(&texts, "Gradient") && has(&texts, "Type:") && !has(&texts, "Draw:"), "{texts:?}");
+        app.run("paint.editGradient", json!({"kind": "freeform"})).unwrap();
+        frame(&mut app, &ctx, vec![]);
+        let texts = frame(&mut app, &ctx, vec![]);
+        assert!(has(&texts, "Draw:") && has(&texts, "Points") && has(&texts, "Lines"), "{texts:?}");
+        click(&mut app, &ctx, &texts, "Lines");
+        let fill = app.session.doc().unwrap().doc.node(vectorcraft_doc::NodeId(id)).unwrap().appearance.fill_paint();
+        let vectorcraft_color::Paint::Gradient(g) = fill else { panic!("{fill:?}") };
+        assert_eq!(super::super::gradient::shown_points(&g).mode, vectorcraft_color::FreeformMode::Lines);
+    }
+
     /// #696: the number fields are all as wide: the Transform fields, the rotation, the corner
     /// radius, Opacity and the stroke weight.
     #[test]

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

@@ -50,7 +50,7 @@ fn plates_section(app: &mut VectorcraftApp, ui: &mut Ui) {
                     run(app, "view.separationsPreview", json!({"plates": plates.iter().map(|p| p.name.clone()).collect::<Vec<_>>()}));
                 }
             });
-            ui.label(egui::RichText::new("CMYK").size(12.0).color(if on { t.text } else { t.text_dim }));
+            ui.label(egui::RichText::new(tl!("CMYK")).size(12.0).color(if on { t.text } else { t.text_dim }));
         });
         for p in &plates {
             ui.horizontal(|ui| {
@@ -86,13 +86,13 @@ fn settings_section(app: &mut VectorcraftApp, ui: &mut Ui) {
     let st = cms::active_settings();
     widgets::section_header(ui, tl!("Color Settings"));
     ui.horizontal(|ui| {
-        ui.label("RGB:");
+        ui.label(tl!("RGB:"));
         if let Some(n) = profile_dropdown(ui, "cms-rgb", &st.rgb, ProfileKind::Rgb, None) {
             run(app, "edit.colorSettings", json!({"rgb": n}));
         }
     });
     ui.horizontal(|ui| {
-        ui.label("CMYK:");
+        ui.label(tl!("CMYK:"));
         if let Some(n) = profile_dropdown(ui, "cms-cmyk", &st.cmyk, ProfileKind::Cmyk, None) {
             run(app, "edit.colorSettings", json!({"cmyk": n}));
         }

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

@@ -141,22 +141,20 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
         }
         ui.end_row();
         ui.label(egui::RichText::new(tl!("Leader:")).color(t.text));
-        let mut leader = stops.get(sel).map(|s| s.leader.clone()).unwrap_or_default();
-        if ui.add_enabled(stops.get(sel).is_some(), egui::TextEdit::singleline(&mut leader).desired_width(90.0)).lost_focus()
-            && let Some(s) = stops.get_mut(sel)
-            && s.leader != leader
-        {
+        // The fields keep what is typed until Enter or a click away commits it (#924).
+        let leader = stops.get(sel).map(|s| s.leader.clone()).unwrap_or_default();
+        let typed = ui.add_enabled_ui(stops.get(sel).is_some(), |ui| widgets::exact_text_field(ui, "tabs-leader", &leader, 90.0)).inner;
+        if let (Some(leader), Some(s)) = (typed, stops.get_mut(sel)) {
+            // Up to eight characters repeat in the leader.
             s.leader = leader.chars().take(8).collect();
             apply(app, &stops);
         }
         ui.end_row();
         ui.label(egui::RichText::new(tl!("Align On:")).color(t.text));
         let decimal = stops.get(sel).is_some_and(|s| s.align == TabAlign::Decimal);
-        let mut on = stops.get(sel).map(|s| s.align_on.to_string()).unwrap_or_else(|| ".".into());
-        if ui.add_enabled(decimal, egui::TextEdit::singleline(&mut on).desired_width(30.0)).lost_focus()
-            && let (Some(s), Some(c)) = (stops.get_mut(sel), on.chars().next())
-            && s.align_on != c
-        {
+        let on = stops.get(sel).map(|s| s.align_on.to_string()).unwrap_or_else(|| ".".into());
+        let typed = ui.add_enabled_ui(decimal, |ui| widgets::exact_text_field(ui, "tabs-align-on", &on, 30.0)).inner;
+        if let (Some(c), Some(s)) = (typed.and_then(|t| t.chars().next()), stops.get_mut(sel)) {
             s.align_on = c;
             apply(app, &stops);
         }
@@ -305,6 +303,62 @@ mod tests {
         assert_eq!(back[1]["align"], json!("decimal"));
     }
 
+    /// #924: Leader and Align On keep what is typed, frame after frame, until Enter applies it
+    /// (spaces kept, eight characters at most).
+    #[test]
+    fn leader_and_align_on_keep_what_is_typed_until_enter() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.session.execute("file.new", &json!({})).unwrap();
+        app.session.execute("text.create", &json!({"x": 10, "y": 20, "text": "a	b", "area": {"width": 300, "height": 100}})).unwrap();
+        app.session.execute("text.tabs.set", &json!({"stops": [{"position": 50, "align": "decimal"}]})).unwrap();
+        let ctx = egui::Context::default();
+        let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(320.0, 400.0));
+        // One frame with `events` → the texts painted and where.
+        let frame = |app: &mut VectorcraftApp, events: Vec<egui::Event>| {
+            let mut out = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), events, ..Default::default() }, |ui| show(app, ui));
+            out.textures_delta.clear();
+            out.shapes
+                .iter()
+                .filter_map(|c| match &c.shape {
+                    egui::Shape::Text(t) => Some((t.galley.text().to_string(), t.visual_bounding_rect())),
+                    _ => None,
+                })
+                .collect::<Vec<_>>()
+        };
+        let key = |key| egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };
+        let click = |at| {
+            [true, false].map(|pressed| egui::Event::PointerButton {
+                pos: at,
+                button: egui::PointerButton::Primary,
+                pressed,
+                modifiers: Default::default(),
+            })
+        };
+        let stop = |app: &VectorcraftApp| current(app).unwrap().1[0].clone();
+        for (label, typed, want) in [("Leader:", [". ", "_", "123456789"], ". _12345"), ("Align On:", [",", "", ""], ",")] {
+            let texts = frame(&mut app, vec![]);
+            let r = texts.iter().find(|(t, _)| t == label).unwrap_or_else(|| panic!("{label} in {texts:?}")).1;
+            let at = egui::pos2(r.right() + 30.0, r.center().y);
+            let [down, up] = click(at);
+            frame(&mut app, vec![egui::Event::PointerMoved(at), down]);
+            frame(&mut app, vec![up]);
+            // Select what is there, then type in pieces over several frames.
+            frame(
+                &mut app,
+                vec![egui::Event::Key { key: egui::Key::A, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::COMMAND }],
+            );
+            for piece in typed.iter().filter(|p| !p.is_empty()) {
+                frame(&mut app, vec![egui::Event::Text(piece.to_string())]);
+                frame(&mut app, vec![]);
+            }
+            frame(&mut app, vec![key(egui::Key::Enter)]);
+            frame(&mut app, vec![]);
+            let s = stop(&app);
+            let got = if label == "Leader:" { s.leader } else { s.align_on.to_string() };
+            assert_eq!(got, want, "{label}");
+        }
+    }
+
     /// Position Panel Above Text floats the panel over the text, its ruler's 0 on the frame's left
     /// edge and a stop's mark over the column it sets, at any zoom (#729).
     #[test]

crates/ui-egui/src/tests_labels.rs

@@ -64,6 +64,35 @@ 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"));
+}
+
+/// Effect › Texture, between Sharpen and Video: each filter opens its dialog.
+#[test]
+fn effect_menu_lists_the_texture_filters_between_sharpen_and_video() {
+    let app = app();
+    let entries = menus::menu_entries(&app);
+    let texture: Vec<_> = entries.iter().filter(|e| e.path == ["Effect", "Texture"]).collect();
+    let labels: Vec<&str> = texture.iter().map(|e| e.label.as_str()).collect();
+    assert_eq!(labels, ["Craquelure…", "Grain…", "Mosaic Tiles…", "Patchwork…", "Stained Glass…", "Texturizer…"]);
+    assert!(texture.iter().all(|e| e.command.as_deref() == Some("effect.dialog")));
+    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("Texture") && at("Texture") < 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.
@@ -364,6 +370,14 @@ pub fn text_field(ui: &mut Ui, id: impl std::hash::Hash + std::fmt::Debug, value
     (resp.lost_focus() && buf.trim() != shown).then(|| buf.trim().to_string())
 }
 
+/// A one-line [`text_field`] that keeps the text exactly as typed, spaces included (a tab
+/// leader such as ". "). Returns it when a change is committed (Enter or focus loss).
+pub fn exact_text_field(ui: &mut Ui, id: impl std::hash::Hash + std::fmt::Debug, value: &str, width: f32) -> Option<String> {
+    let id = ui.id().with(id);
+    let (buf, resp, _) = recessed_text(ui, id, value, width, 1);
+    (resp.lost_focus() && buf != value).then_some(buf)
+}
+
 /// A form row: `label` in a column `label_width` wide, then what `add` draws.
 pub fn label_row(ui: &mut Ui, label: &str, label_width: f32, add: impl FnOnce(&mut Ui)) {
     ui.horizontal(|ui| {
@@ -584,10 +598,10 @@ pub fn fill_stroke_proxy(ui: &mut Ui, fill: &Paint, stroke: &Paint, mixed: (bool
         None
     };
     ProxyClicks {
-        fill: fill_resp.on_hover_text("Fill (X), double-click for the Color Picker").clicked(),
-        stroke: stroke_resp.on_hover_text("Stroke (X), double-click for the Color Picker").clicked(),
-        swap: swap.on_hover_text("Swap Fill and Stroke (Shift+X)").clicked(),
-        default: def.on_hover_text("Default Fill and Stroke (D)").clicked(),
+        fill: fill_resp.on_hover_text(tl!("Fill (X), double-click for the Color Picker")).clicked(),
+        stroke: stroke_resp.on_hover_text(tl!("Stroke (X), double-click for the Color Picker")).clicked(),
+        swap: swap.on_hover_text(tl!("Swap Fill and Stroke (Shift+X)")).clicked(),
+        default: def.on_hover_text(tl!("Default Fill and Stroke (D)")).clicked(),
         pick,
     }
 }
@@ -1654,7 +1668,7 @@ pub fn harmony_wheel(ui: &mut Ui, id: &str, size: f32, colors: &[Color], base: O
     ui.add_space(6.0);
     ui.horizontal(|ui| {
         ui.add_space(((ui.available_width() - size - 76.0) / 2.0).max(0.0));
-        ui.add_sized([70.0, 22.0], egui::Label::new(egui::RichText::new("Brightness").color(t.text_dim)));
+        ui.add_sized([70.0, 22.0], egui::Label::new(egui::RichText::new(tl!("Brightness")).color(t.text_dim)));
         if let (Some(b), Some([h, s, _])) = (base, base_hsb)
             && let (Some(nv), _) = color_slider(ui, (id, "brightness"), v, size, &|x| crate::panels::c32(&Color::from_hsb(h, s, x)))
         {

docs/control-protocol.md

@@ -404,7 +404,9 @@ Missing linked files: `app.open` of a document whose linked images' files can't
 folder; `ui.dialog.set {field: "discard", value: true}` then confirm ignores it (the images keep their preview), with
 `applyToAll` the rest too. The next missing file is asked about after each answer; `ui.dialog.cancel` stops asking.
 Then, with the preference `updateLinks: "askWhenModified"`, modified linked files are offered for update in a
-`confirm` dialog whose `ui.dialog.confirm` runs `links.update`.
+`confirm` dialog whose `ui.dialog.confirm` runs `links.update`. The same happens when the app's window comes back to
+the front and a linked file of the active document changed meanwhile (asked once per change of a file); with
+`"automatically"` the files are read again at once, with `"manually"` the Links panel shows them as modified.
 
 Missing fonts: once the missing linked file questions are answered, or at once when there are none, `app.open` of a
 document whose type uses fonts that aren't available (`text.missingFonts`) opens the `missingFonts` dialog, one document

docs/mcp.md

@@ -275,14 +275,14 @@ objects' fills or strokes differ (`fillMixed` / `strokeMixed`, drawn as a "?" pr
 | `invoke_menu` | `{command, params?}` | Invokes a menu item by command id. Includes UI commands such as `view.*` and `window.*` in remote mode. |
 | `open_panel` | `{panel}` | Remote only. `panel` is a panel id (`layers`, `swatches`, `colorGuide`, …, as `window.panel` takes) or its display label (`"Color Guide"`), in any case. |
 | `screenshot` | `{path?, scale?, artboard?, window?}` | Returns MCP image content (`image/png`, base64) plus a text block. Renders the artboard; `window:true` captures the app window (remote only). With `path` the backend (the headless session or the app) writes the PNG there too. |
-| `open_file` | `{path}` | Opens any readable file as a new active document: `.vectorcraft`/`.drawcraft`, `.vctemplate`, `.svg`/`.svgz`, `.pdf`/`.ai`, `.ait`, `.eps`, `.dxf`, `.emf`, `.wmf`, PNG, JPEG, GIF, WebP, TIFF, BMP (an image opens as a document of its pixel size). Templates (`.vctemplate`, `.ait`) open as a new untitled document. PDF, `.ai` and SVG files saved with Preserve Editing reopen as the document they carry. The reply is `document.open`'s: its `warnings` say what didn't come in as it was (an EPS whose PostScript can't be read opens as its preview, and the warning names the PostScript error, the operator and the procedure). `run_command document.formats` lists the formats. |
+| `open_file` | `{path}` | Opens any readable file as a new active document: `.vectorcraft`/`.drawcraft`, `.vctemplate`, `.svg`/`.svgz`, `.pdf`/`.ai`, `.ait`, `.eps`, `.dxf`, `.emf`, `.wmf`, PNG, JPEG, GIF, WebP, TIFF, BMP, PSD/PSB (an image opens as a document of its pixel size; a Photoshop file as its merged image). Templates (`.vctemplate`, `.ait`) open as a new untitled document. PDF, `.ai` and SVG files saved with Preserve Editing reopen as the document they carry. The reply is `document.open`'s: its `warnings` say what didn't come in as it was (an EPS whose PostScript can't be read opens as its preview, and the warning names the PostScript error, the operator and the procedure). `run_command document.formats` lists the formats. |
 | `save_file` | `{path?}` | Runs `document.save`: the document's own file in its own format (native `.vectorcraft` unless it was opened from or saved as SVG, PDF or a restorable `.ai`; then `warnings` say what that format loses). A path's extension picks the format (`.vectorcraft`, `.vctemplate`, `.pdf`, `.svg`, `.svgz`, `.ai`: a PDF carrying the native document, which reopens editable). |
 | `export` | `{path?, format?, scale?, artboard?, range?, selection?, outlineText?, options?}` | `svg`, `svgz`, `pdf`, `eps`, `dxf`, `emf`, `wmf`, `png`, `jpg`, `webp`, `gif`, `png8` (an indexed `.png`), `tiff`, `bmp`, `tga`, `psd` (layered), `txt` (the document's text), `vectorcraft` or `template` (a native template). The tool's `format` enum and `document.formats` list them, generated from the engine's format table. When `format` is omitted, it comes from the path's extension. PDF writes one page per artboard: all of them, or `artboard` (0-based) / `range` (`"1-3, 5"`, 1-based); the other formats write one artboard. `options` carries more format options (e.g. `{"quality": 80}` for JPEG). `selection: true` exports the selected objects cropped to their bounds (the reply adds their `bounds`, and reports `format` and the encoder's `warnings` as a whole-document export does); `outlineText: true` writes SVG text as paths. Template layers are left out, live effects are kept, and exporting `vectorcraft` never changes the document's path. Without `path` the bytes come back as `dataBase64`. Both backends run the same `document.export` call. |
 | `add_text` | `{text, x?, y?, width?, height?, path?, mode?, pathEffect?, size?, font?, color?}` | Point type at (x, y); area type with `width`/`height`; or `path` + `mode` (`area`/`onPath`) to flow text in or along a path, with `pathEffect` (`rainbow`, `skew`, `3dRibbon`, `stairStep`, `gravity`). |
 | `apply_effect` | `{effect?, params?, ids?}` | Appends a live effect. Without `effect`, returns the effect catalogue with parameters and defaults. |
 | `pathfinder` | `{operation, ids?}` | `unite`, `minusFront`, `intersect`, `exclude`, `divide`, `trim`, `merge`, `crop`, `outline`, `minusBack`. For a live version, apply the `pathfinder.*` effect to a group (`effect.apply` groups several loose selected objects first). |
 | `transform` | `{ids?, dx?, dy?, rotate?, scale?, scaleX?, scaleY?, reflect?, shear?, origin?, copy?}` | Runs move, rotate, scale, reflect, shear in that order. With `copy`, the first step duplicates. |
-| `create_graph` | `{type?, x, y, width, height, csv? \| series?, categories?, rows?}` | The nine Illustrator graph types: column, stacked column, bar, stacked bar, line, area, scatter, pie and radar. Edit later with `graph.setData` / `graph.setType` via `run_command`. |
+| `create_graph` | `{type?, x, y, width, height, csv? \| series?, categories?, rows?}` | The nine Illustrator graph types: column, stacked column, bar, stacked bar, line, area, scatter, pie and radar. An empty CSV cell or a `null` in `rows` is a blank value; a number in straight quotes is a label. Edit later with `graph.setData` / `graph.setType` via `run_command`. |
 | `text_wrap` | `{ids?, offset?, invert?, release?}` | Area type below the objects (same layer) flows around them. |
 | `undo` / `redo` | `{}` | |
 
@@ -521,9 +521,10 @@ CMYK too.
 PostScript files (`.eps`, and `.ai` files saved in older formats or without PDF compatibility) open through the EPS
 reader (see EPS and PostScript import). An `.ai` saved without PDF compatibility (its PDF part is only a placeholder
 page) opens from its editing data alone: its type is made from the file's text document where it can be (point type,
-area type and type on a path), and what can't be is left out with a warning; so is non-native art (the content of a
-placed PDF, which Illustrator shows but doesn't edit and keeps as a PDF inside the editing data); without editing data
-it says it can't be opened.
+area type and type on a path), and what can't be is left out with a warning. Non-native art (the content of a placed
+PDF, which Illustrator shows but doesn't edit and keeps as a PDF inside the editing data) is drawn by the PDF importer,
+as a group named "Non-native art" fitted to the object's box; one whose PDF can't be read is left out with a warning.
+Without editing data it says it can't be opened.
 
 What a PDF holds comes in as editable art: soft masks become opacity masks (an alpha mask as a white copy of its art;
 the backdrop colour gives Clip, an inverting transfer function Invert), transparency groups keep isolation and knockout,
@@ -953,9 +954,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 +1398,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 +1414,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
@@ -1690,7 +1709,7 @@ passed straight back to `file.new`. Print presets and sizes without `units` star
 
 `file.place` puts another file's art into the active document as one undo step without touching the clipboard:
 a raster image at 100% of its physical size (the resolution its file declares, else 72 ppi; linked to its `path`
-unless `link: false`), an SVG as one group, a PDF/.ai page as one clipped group, with the images, symbols, patterns
+unless `link: false`; a Photoshop document as its merged image), an SVG as one group, a PDF/.ai page as one clipped group, with the images, symbols, patterns
 and swatches it uses. A VectorCraft document read from `path` is a placed document: one locked object showing its
 artboard `page` (or, with `crop: "bounding"`, its art's bounds), linked to the file and read again when it changes
 (see Linked images), and vectors in every output; with `link: false` (or from `dataBase64`) it is an editable copy
@@ -1809,7 +1828,8 @@ the preview instead of the pixels, plus the path relative to the saved file. `do
 the linked files again, looking for each at its path, then at its relative path and by name in the document's folder
 (so a folder moved with its links still opens): the result lists `missingLinks` (their images show the preview),
 `modifiedLinks` (left as they were; read again only with the preference `updateLinks: "automatically"`, then they are
-in `updatedLinks`), each as `{name, path, ids}`. `links.check` reports every link's `status` (`ok`, `modified`,
+in `updatedLinks`), each as `{name, path, ids}`. The desktop app also checks the active document's links when its window
+comes back to the front, following the same preference. `links.check` reports every link's `status` (`ok`, `modified`,
 `missing`), `links.update {ids?}` reads modified files again and `links.relink {ids?, path | folder}` points images at
 another file (or each at the file of its name in a folder); images keep their bounds, one undo step each. Without a
 file system (the web), linked images show their previews.
@@ -2288,7 +2308,13 @@ show) is the flat render. `maxEditability: true` turns layers and sublayers into
 named as the Layers panel names it (text objects by their text); layers with a clipping mask, an opacity mask, an
 appearance of their own or knockout stay one pixel layer. Hidden layers and objects are left out unless
 `hiddenLayers: true` writes them as hidden layers. `layers: false` writes one flat image, on white where nothing is
-drawn. Files are at most 30000 pixels a side; PSD files don't open in VectorCraft.
+drawn. Files are at most 30000 pixels a side.
+
+Photoshop documents (`.psd`, and `.psb`, the large document format) open and place as their merged image, the
+flattened picture every Photoshop file carries (layers aren't read): Bitmap, Grayscale, Duotone, Indexed, RGB, CMYK
+(converted with the colour settings' CMYK) and Lab, at 1, 8, 16 and 32 bits per channel, sized by their resolution.
+A document with transparency keeps it. `file.place {path}` links the file like any image (`links.update` reads it
+again when it changes); Multichannel files are refused.
 
 ```json
 {"name":"export","arguments":{"path":"/tmp/poster.psd","options":{"ppi":300,"maxEditability":true}}}

xtask/src/layers.rs

@@ -75,6 +75,8 @@ pub const INTRA_LAYER_ORDER: &[&[&str]] = &[
     &["text", "effects"],
     &["render", "eps"],
     &["metafile", "eps"],
+    // Non-native art in Illustrator editing data is a PDF, drawn by the PDF importer.
+    &["pdf", "eps"],
     &["plugins", "effects"],
 ];