Part of gap 2: Effect › Pixelate (Color Halftone, Crystallize, Mezzotint, Pointillize)

Four Photoshop-style raster effects on the pixel-filter pipeline (vectorcraft_effects::pixel::pixelate), under a new Effect › Pixelate submenu between Blur and Sharpen in the Raster Effects section: - Color Halftone (maxRadius 4..127, default 8; channel1..channel4 screen angles -360..360, defaults 108/162/90/45): each colour channel is screened at its angle in square cells sized so a dot of Max. Radius fills one; each cell's dot covers the share of the cell that is the channel's coverage-weighted mean there (white stays white, black black). RGB documents screen R, G, B (channels 1 to 3); CMYK documents screen C, M, Y, K inks (channels 1 to 4), also when they are drawn ink plane by ink plane (the K plane uses channel 4). - Crystallize (cellSize 3..300, default 10): every pixel takes the colour at the nearest of one jittered point per cell (exact Voronoi over a 5 x 5 neighbourhood, pruned by distance). - Mezzotint (type: Fine/Medium/Grainy/Coarse Dots, Short/Medium/Long Lines, Short/Medium/Long Strokes; default Fine Dots; a dropdown in the dialog): each channel is turned fully on or off against its own random threshold pattern, so the object becomes pure colours. - Pointillize (cellSize 3..300, default 5): one dot of random size per cell at a jittered point, coloured by the softened object there and as opaque as the object at its centre, stacked in random order over a white canvas where the object is. Lengths are in points (Scale Strokes & Effects scales them) and 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 the pattern's cell indices, no state). Work per pixel is bounded whatever the parameters, which are clamped to their ranges and finite-checked; the halftone's cell grid is capped by the raster's size and a screen finer than 3 pixels leaves the image as it is (its average). PixelSpace gains `channels` so the renderer tells the filters what the channels hold. Catalogue rows with parameter docs, outsets and reaches for cropping, menu entries, dialog labels (Max. Radius, Channel 1-4, Cell Size), the Mezzotint Type dropdown, translations, and tests: parameters and clamping, tone and coverage, CMYK inks, polygon crystals, pure-colour mezzotints with ten distinct patterns, dots on a white canvas, the same result at twice the resolution and when moved, the canvas, PDF and SVG through the engine, the command sweep with junk parameters, the dialogs and the menu. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Merge pull request #923 from callmeBalloch/fix/artboard-artwork-movement
2026-10-10 15:42:24 +07:00 · 2026-10-10 15:29:47 +07:00 · 2026-10-10 15:06:59 +07:00 · 2026-10-10 09:49:24 +02:00 · 2026-10-10 14:37:23 +07:00 · 2026-10-10 14:33:41 +07:00
36 changed files with 1748 additions and 82 deletions
@@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob

 This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands.

-_Last updated: 2026-10-10 (after placed documents (File › Place of a `.vectorcraft` file, linked), M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG windoLine truncated
+_Last updated: 2026-10-10 (after placed documents (File › Place of a `.vectorcraft` file, linked), M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381), SVG type opening at the size it draws at (#396), the Wayland clipboard with copied-file paste (#398), ruler guides that can be selected, moved and deleted (#414), two batches of Preferences options that were stored but unused (#394), skeleton reads with `document.find` for large documents over MCP (#416) and anchors dragged with Direct Selection snapping to points, segments and smart guides, clipped SVG layers opening as clipping layers (#420), PDF/`.ai` layers read on pages of tens of millions of operators (#419), Document Color Mode putting RGB greys on the black plate on request and converting pattern tiles (#421) and movable dialogs with Offset Path's Joins dropdown (#423) and numeric fields scrubbed by dragging their label (#400), stroke weight presets in the stroke unit (#426), the Appearance panel's Opacity popup (#430), type on a path brackets, flip and Type on a Path Options that keep the type in place (#429), Layers rows dragged with a ghost and dropped on the trash or New Layer (#435), tool flyouts opening on a right or corner press (#436), tool flyouts torn off into floating toolbars (#437), the Shape Builder's erase mode deleting edges too (#439), installed fonts registered outside the font folders and fonts installed while the app runs listed in the font menus (#443), alike circular corners on rectangles that aren't square (#442), tool cursors as OS cursors so the pointer no longer trails over the canvas (#444), artboards copied and pasted with their art (#446), guides dragged out of the rulers snapping to the art's side midpoints and the artboards, artboard guides (#451), the toolbar's double arrow and Window › Toolbars › Double Column switching between one and two columns in any window height (#455), the Smart Guides display options and Snapping Tolerance (#394), Font Size and Leading combo boxes with preset lists in the Character and Properties panels and the Control bar (#458), screenshots pasted from the clipboard on macOS, Windows and the web (#457), the Properties panel's Fill and Stroke matching the Control bar's, Illustrator's Window menu panel keys (Shift+F7 for Align…) and Alt-wheel zoom whatever the wheel preference (Discord feedback), the point/area type widget (Discord feedback), groups in legacy Illustrator .ai files (Discord feedback), a rotating desktop log file (#465), image controls in the Control bar and Properties panel: Image Trace with its presets, Mask, Crop Image, Embed/Unembed, and an Image Trace object's preset, Expand and Release (Discord feedback), the Pen working as the Anchor Point tool with Alt held over a selected path's handles and anchors, and anchor buttons that convert, connect and cut paths at the selected anchors (Discord feedback), Japanese hanging punctuation (burasagari, #463), Escape leaving Presentation Mode with no screen mode saved across restarts, documents dropped on the desktop app opening as tabs of their own and a note that an `.ai` file's art off its artboards isn't in the part read (#472), Add/Delete Anchor Point tool icons drawn from the Pen tool's (#479), EPS import running more of PostScript Level 3 (patterns, Type 3 fonts, mesh shadings, masked images, VM and resource probes), and a preview that stands in saying why (Discord feedback, #466, #469, #474), chords with modifiers recorded in Edit › Keyboard Shortcuts (#487), Type Object Selection by Path Only (#394), Anti-aliased Artwork (#394), Show Pixel Grid (#394), pen and touch taps pressed and lifted within one frame clicking where they tapped and the Linux/Wayland pen-tablet workaround (#491), bounding-box resizes landing on the other objects' anchors and centres with labels, and the Rotate, Scale, Shear and Reflect tools snapping their drags (#482), Shift-drag marquees that toggle the objects or anchors they reach and a Lasso whose Alt subtraction keeps the rest of the selection (#483), the mouse wheel stepping the focused numeric field, the dialogs' and preferences' drag values made such fields (#485), Show The Home Screen When No Documents Are Open (#394), Numbers Without Units Are Points (#394), Auto-Collapse Iconic Panels (#394), the Contextual Task Bar moved by its handle and its More Options menu pinning and resetting its position, a designed macOS DMG windoLine truncated

 ## Where we are

@@ -35,7 +35,7 @@ since 2026-10-01.
 |---|---|---|
 | **Breadth:** menus, tools and panels exist | ~90% | 13 menu items still stubbed; every tool implemented except Touch Type; 51 panel modules |
 | **Depth:** each feature behaves like Illustrator | ~69–75% | Strong: paint, appearance and colour (M3), Pathfinder and booleans, selection, drawing, files (M4). Weak: advanced type (~45%; inline symbols in text are beyond parity and don't raise it), brushes and symbols (in progress), raster effects (~20%) |
-| **Large missing subsystems** | 0–20% | 3D & Materials (0%), Photoshop-style raster effects and the Effect Gallery (~4 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 (~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 |
 | **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 |
@@ -53,12 +53,13 @@ Ordered by how much each gap blocks someone from switching. Sizes are one-agent
 1. **Interaction fidelity:** go tool by tool and panel by panel against `plan/illustrator/05-tools.md`,
   `06-panels.md` and `09-shortcuts.md`, covering modifier keys, cursors, the Properties panel per context and
   isolation mode. The Shaper’s rough-square recognition and shape orientation steps are corrected; Shaper Groups now retain editable originals for region merges/punches and separate fill/stroke edits; their construction-mode widget and gesture refinements remain. 60–90 h.
-2. **Photoshop-style raster effects and the Effect Gallery:** about 51 filters (Artistic, Brush Strokes, Distort,
-   Pixelate, 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 47 filters (Artistic, Brush Strokes, Distort,
+   Sketch, Stylize, Texture, Video) 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), Sharpen › Unsharp Mask and Stylize › Glowing Edges; each new filter is now one function, a catalogue row, menu and
-   translations. Parallelizes well across agents. 26–40 h.
+   (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.
 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.
@@ -93,6 +94,7 @@ When a task lands, update this section, the parity table and "Shipped so far" in
 grade by behaviour against `plan/illustrator/`, not by whether a menu item exists.

 ## Shipped so far
+
 - **Architecture:** 19+ crates with enforced layering (`cargo xtask layers`). Every action is a command (~400 engine + ~50 UI). Undo is unlimited via structural sharing. `command.batch` runs several commands as one transaction.
 - **Automation:**
  - Actions panel (record/playback, persisted), generic parameter dialogs for every "…" command.
@@ -136,7 +138,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.
+  - **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.
  - **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.
@@ -192,8 +194,8 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 | M8 | Transform & distort (Puppet Warp, Liquify tools, Envelopes, Blends, Perspective Grid) | ✅ done (M8.1–M8.20 on 2026-10-06, fidelity pass): Liquify Tool Options with one shared brush, pen pressure, hold-to-apply, a safe scope and incremental strokes; tool options that last; Puppet Warp rotation, multi-select, Control bar and a rest-shape session that follows Undo; Width tool on compound paths; Envelope dialogs with preview, Reset with Warp/Mesh, full Envelope Options, type/images/symbols/appearance/gradients/patterns distorted on canvas and in every export, warps that keep their frame, Edit Contents, mesh handles and Control bar; Blend Options, anchor-targeted Blend tool, editable spine, keys picked on the canvas, faithful interpolation and knockout; Perspective Grid with Define Grid, presets, lock/snap/rulers, widgets, the 1–4 plane switch, movable planes, Perspective Selection scale/copy/perpendicular/Transform Again, and type and symbols truly projected with Edit Text. Left: Anti-Alias and Preserve Shape output, warp-envelope point editing, brush interpolation in blends, Free Transform/Scale/Reflect along a rotated box | 2–4 |
 | M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder and Color Adjustments; SVG Filters, Document Raster Effects Settings, 3D pending | 86–135 |
 | M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG `<pattern>`/PDF export) and live Repeat (radial/grid/mirror) done; brushes/symbols in progress | 23–37 |
-| M11 | Artboards & views (artboard panel/tool, Trim View, middle-button pan, print tiling and the status bar's artboard navigator done; multiple windows, presentation polish) | 🟡 | 15–25 |
-| M12 | Advanced color & art (CMYK/ICC, separations, Gradient Mesh, Live Paint, Image Trace, Graphs) | 🟡 Gradient Mesh, Live Paint, Image Trace (13 presets, 18 ms/1k² image; the Flat Logo mode places edges to a fraction of a pixel, restores sharp corners, snaps lines and circles, and refuses gradients), Recolor Artwork, colour management (ICC, soft proofing, separations preview), Graphs (all 9 tools, Graph Data/Type, regenerate in place) done; graph Design/Column/Marker designs pending | 6–10 |
+| M11 | Artboards & views (artboard panel/tool with Move Artwork for X/Y fields and Artboard Options, Trim View, middle-button pan, print tiling and the status bar's artboard navigator done; multiple windows, presentation polish) | 🟡 | 15–25 |
+| M12 | Advanced color & art (CMYK/ICC, separations, Gradient Mesh, Live Paint, Image Trace, Graphs) | 🟡 Gradient Mesh, Live Paint, Image Trace (13 presets, 18 ms/1k² image; the Flat Logo mode places edges to a fraction of a pixel, restores sharp corners, snaps lines and circles, and refuses gradients), Recolor Artwork, colour management (ICC, soft proofing, separations preview), Graphs (all 9 tools, Graph Data/Type, group-selected series colours persist through regenerate/save/open) done; graph Design/Column/Marker designs pending | 6–10 |
 | M13 | Automation (Actions ✅ record/playback, persisted; variables, scripting, batch) | 🟡 | 18–27 |
 | M14 | 1.0 polish (preferences, shortcut editor, workspaces, accessibility, packaging for all OSes) | 🟡 Preferences, shortcut editor (chords with Shift and a punctuation key fire as typed), workspaces, a custom title bar on Windows/Linux with a Home button, content-sized dialogs, menus that scroll when longer than the window and macOS native menu dismissal done (M14.8); an experimental, unsupported Windows 7 x64 portable OpenGL build (not verified by maintainers); accessibility and broader Windows/Linux packaging/QA pending | 18–28 |
 | — | Interaction fidelity pass (every tool's modifiers, Properties panel per context, isolation, nuance) | ⬜ | 60–90 |
@@ -221,13 +223,13 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | 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 |
 | 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 | 25% | ~51 Photoshop-style filters (Artistic, Brush Strokes, Distort, Pixelate, 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 and Glowing Edges are done | 26–40 |
+| 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 |
 | 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 |
 | Symbols, blends, envelopes, Repeat, perspective | 5 | 88% | symbol libraries (original), dynamic symbols, envelope Anti-Alias/Preserve Shape output and warp point editing, brush interpolation in blends (M8 fidelity pass done) | 5–8 |
-| Image Trace, graphs, image tools | 3 | 72% | graph Design/Column/Marker, Create Object Mosaic, per-feature stroke/fill choice and varying widths in Image Trace's Create Strokes (Vector Halftone and the Image Trace View modes, Palette and Create Strokes are done) | 6–10 |
-| Layers, artboards, document setup | 5 | 82% | Layers panel: a confirmation before deleting layers that hold art, Collect for Export, row context menus, the Layer Options dialog for several rows with mixed values, Paste Remembers Layers for sublayers, drag-scrolling a long panel while dragging rows; artboard preset polish (Rearrange All Artboards, Document Setup, New Document and the rest of the Layers panel are done) | 4–7 |
+| Image Trace, graphs, image tools | 3 | 72% | graph Design/Column/Marker artwork (series colours set with Group Selection are done), Create Object Mosaic, per-feature stroke/fill choice and varying widths in Image Trace's Create Strokes (Vector Halftone and the Image Trace View modes, Palette and Create Strokes are done) | 6–10 |
+| Layers, artboards, document setup | 5 | 82% | Layers panel: a confirmation before deleting layers that hold art, Collect for Export, row context menus, the Layer Options dialog for several rows with mixed values, Paste Remembers Layers for sublayers, drag-scrolling a long panel while dragging rows; artboard 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) |
@@ -64,12 +64,29 @@ impl GraphKind {
    }
 }

+/// The fill and stroke captured from one series' generated marks. An absent paint keeps whatever
+/// the generator draws for that part (greyscale for a series fill, the part's own stroke otherwise).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct SeriesPaint {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub fill: Option<vectorcraft_color::Paint>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stroke: Option<vectorcraft_color::Paint>,
+    /// Stroke weight in points, kept with [`Self::stroke`].
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stroke_width: Option<f64>,
+}
+
 /// Graph data and options. `rows` are categories (one per row of the Graph Data window), each
 /// holding one value per series; `series` are the legend labels (the first row of the window).
 /// Scatter graphs read each series as (y, x) column pairs, like Illustrator.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct GraphSpec {
+    /// Paint taken from the series' marks (Group Selection). One entry per series index; missing
+    /// entries keep the generator's own fill and stroke.
+    pub series_paints: Vec<SeriesPaint>,
    pub kind: GraphKind,
    /// The plot rectangle (the area the graph tool dragged), document points.
    pub rect: Rect,
@@ -97,6 +114,7 @@ pub struct GraphSpec {
 impl Default for GraphSpec {
    fn default() -> Self {
        Self {
+            series_paints: vec![],
            kind: GraphKind::Column,
            rect: Rect::new(0.0, 0.0, 200.0, 150.0),
            series: vec![],
@@ -65,7 +65,7 @@ pub use appearance::{
 };
 pub use assets::ExportAsset;
 pub use corners::LiveCorners;
-pub use graph::{GraphKind, GraphSpec};
+pub use graph::{GraphKind, GraphSpec, SeriesPaint};
 pub use hit::{Hit, HitKind};
 pub use links::{LinkInfo, PlacementOptions};
 pub use live::{BlendOrientation, BlendSpacing, BlendSpec, EnvelopeKind, GradientMesh, MeshPoint};
@@ -528,6 +528,10 @@ pub struct Node {
    /// Graph object: the group's children are generated from this spec (Object → Graph).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub graph: Option<Box<crate::graph::GraphSpec>>,
+    /// Index of the graph series this generated group belongs to. Axes, the legend and other
+    /// children leave it unset, so a series named "Legend" or "Axes" is not mistaken for them.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub series_index: Option<u32>,
    /// Editable Shaper composition; the original art is retained in its source child.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shaper: Option<Box<crate::shaper::ShaperSpec>>,
@@ -595,6 +599,7 @@ impl Node {
            trace: None,
            wrap: None,
            graph: None,
+            series_index: None,
            shaper: None,
            kind,
            graphic_style: None,
@@ -6,7 +6,8 @@
 //! - **Geometry effects** (Distort & Transform, Path, Convert to Shape, Round Corners, Scribble,
 //!   Warp) rewrite a path: [`apply_geometry`] evaluates them in stack order.
 //! - **Raster effects** (Drop Shadow, Inner/Outer Glow, Feather, Gaussian Blur, and the
-//!   Photoshop-style filters of [`pixel`]: Radial Blur, Smart Blur, Unsharp Mask and Glowing Edges) are described by
+//!   Photoshop-style filters of [`pixel`]: Radial Blur, Smart Blur, Color Halftone, Crystallize, Mezzotint, Pointillize,
+//!   Unsharp Mask and Glowing Edges) are described by
 //!   [`raster_effects`] and painted by the renderer; [`outset`] says how far they reach beyond
 //!   the geometry.
 //! - **Stroke geometry** ([`stroke`]): arrowheads, dash patterns and width profiles, shared by the
@@ -27,7 +28,8 @@
 //!   renderer and the exporters.
 //!
 //! Everything is deterministic: "random" effects (Roughen, Tweak, Scribble) use a seeded hash
-//! noise (`seed` parameter, default 0).
+//! noise (`seed` parameter, default 0); the random Pixelate filters hash their pattern's cells,
+//! anchored at the object's centre.
 #![forbid(unsafe_code)]

 mod adjust;
@@ -126,6 +128,8 @@ fn lengths_of(id: &str) -> Lengths {
        "stylize.dropShadow" => always(&["x", "y", "blur"]),
        "stylize.innerGlow" | "stylize.outerGlow" => always(&["blur"]),
        "stylize.glowingEdges" => always(&["edgeWidth", "smoothness"]),
+        "pixelate.colorHalftone" => always(&["maxRadius"]),
+        "pixelate.crystallize" | "pixelate.pointillize" => always(&["cellSize"]),
        _ => Lengths::default(),
    }
 }
@@ -139,6 +143,7 @@ const STYLIZE: &[&str] = &["Effect", "Stylize"];
 const WARP: &[&str] = &["Effect", "Warp"];
 const BLUR: &[&str] = &["Effect", "Blur"];
 const SHARPEN: &[&str] = &["Effect", "Sharpen"];
+const PIXELATE: &[&str] = &["Effect", "Pixelate"];
 const PATHFINDER: &[&str] = &["Effect", "Pathfinder"];
 const PLUGINS: &[&str] = &["Effect", "Plug-ins"];
 const ADJUST: &[&str] = &["Effect", "Color Adjustments"];
@@ -298,6 +303,34 @@ pub fn effect_catalog() -> Vec<EffectInfo> {
            "{edgeWidth: pt 1..14 (2), edgeBrightness: 0..20 (6), smoothness: pt 1..15 (5)} finds alpha-weighted Sobel edges and draws bright coloured outlines on black",
            json!({"edgeWidth": 2.0, "edgeBrightness": 6.0, "smoothness": 5.0}),
        ),
+        r(
+            "pixelate.colorHalftone",
+            "Color Halftone…",
+            PIXELATE,
+            "{maxRadius: pt 4..127 (8; the radius of a dot at full strength, which fills its square cell), channel1: screen angle deg -360..360 (108), channel2: deg (162), channel3: deg (90), channel4: deg (45)} screens each colour channel (red, green, blue: channels 1 to 3; in CMYK documents cyan, magenta, yellow, black: 1 to 4) at its angle into dots whose area follows the channel's mean over their cell",
+            json!({"maxRadius": 8.0, "channel1": 108.0, "channel2": 162.0, "channel3": 90.0, "channel4": 45.0}),
+        ),
+        r(
+            "pixelate.crystallize",
+            "Crystallize…",
+            PIXELATE,
+            "{cellSize: pt 3..300 (10)} redraws the object as polygon crystals of solid colour around random points about cellSize apart",
+            json!({"cellSize": 10.0}),
+        ),
+        r(
+            "pixelate.mezzotint",
+            "Mezzotint…",
+            PIXELATE,
+            "{type: \"fineDots\"|\"mediumDots\"|\"grainyDots\"|\"coarseDots\"|\"shortLines\"|\"mediumLines\"|\"longLines\"|\"shortStrokes\"|\"mediumStrokes\"|\"longStrokes\" (\"fineDots\")} turns each colour channel fully on or off against a random pattern of dots, lines or strokes: fully saturated colours",
+            json!({"type": "fineDots"}),
+        ),
+        r(
+            "pixelate.pointillize",
+            "Pointillize…",
+            PIXELATE,
+            "{cellSize: pt 3..300 (5)} redraws the object as randomly placed dots of its colours on a white canvas",
+            json!({"cellSize": 5.0}),
+        ),
    ];
    v.extend([
        g(
@@ -1,5 +1,6 @@
-//! Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Sharpen › Unsharp
-//! Mask, and Stylize › Glowing Edges): filters over premultiplied RGBA8 pixels.
+//! 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.
 //!
 //! - 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
@@ -10,6 +11,7 @@

 mod blur;
 mod edges;
+mod pixelate;
 mod sharpen;

 use serde_json::Value;
@@ -17,8 +19,19 @@ use vectorcraft_geom::{Affine, Point, Rect};

 use crate::util::{num, text};

+pub use pixelate::{MEZZOTINT_TYPES, Mezzotint};
+
 /// The Photoshop-style effect ids (all raster effects, see [`crate::is_raster`]).
-pub const PIXEL_EFFECTS: [&str; 4] = ["blur.radial", "blur.smart", "sharpen.unsharpMask", "stylize.glowingEdges"];
+pub const PIXEL_EFFECTS: [&str; 8] = [
+    "blur.radial",
+    "blur.smart",
+    "pixelate.colorHalftone",
+    "pixelate.crystallize",
+    "pixelate.mezzotint",
+    "pixelate.pointillize",
+    "sharpen.unsharpMask",
+    "stylize.glowingEdges",
+];

 /// A Photoshop-style raster effect with its parameters read and clamped to their ranges. Lengths
 /// are in document units.
@@ -36,6 +49,31 @@ pub enum PixelFx {
    UnsharpMask { amount: f64, radius: f64, threshold: f64 },
    /// Stylize › Glowing Edges: bright coloured Sobel outlines on black.
    GlowingEdges { width: f64, brightness: f64, smoothness: f64 },
+    /// Pixelate › Color Halftone: each colour channel screened at its angle (`angles`° of channels
+    /// 1 to 4) into dots of up to `max_radius`, whose area follows the channel's strength.
+    ColorHalftone { max_radius: f64, angles: [f64; 4] },
+    /// Pixelate › Crystallize: polygons of solid colour around random points about `cell` apart.
+    Crystallize { cell: f64 },
+    /// Pixelate › Mezzotint: every colour channel fully on or off against a random pattern.
+    Mezzotint { kind: Mezzotint },
+    /// Pixelate › Pointillize: random dots about `cell` across of the object's colours on a white
+    /// canvas.
+    Pointillize { cell: f64 },
+}
+
+/// What a raster's colour channels hold, for the filters that treat them apart (Color Halftone
+/// screens each channel, Mezzotint thresholds each).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum Channels {
+    /// Red, green and blue light.
+    #[default]
+    Rgb,
+    /// Screen colours of a CMYK document: treated as its cyan, magenta, yellow and black inks.
+    Cmyk,
+    /// The complemented C, M and Y inks (a CMYK document drawn ink plane by ink plane).
+    CmyPlane,
+    /// The complemented K ink, as a grey.
+    KPlane,
 }

 /// Where a raster's pixels lie in the document.
@@ -46,8 +84,11 @@ pub struct PixelSpace {
    pub to_doc: Affine,
    /// The size of a pixel in document units.
    pub px: f64,
-    /// The object's centre (document coordinates): where Radial Blur blurs around.
+    /// The object's centre (document coordinates): where Radial Blur blurs around, and where the
+    /// Pixelate filters' patterns are anchored (so they move with the object).
    pub center: Point,
+    /// What the colour channels hold.
+    pub channels: Channels,
 }

 /// Effect `id`'s parameters `p` (defaults merged in) as a [`PixelFx`]; `None` for other effects.
@@ -77,6 +118,14 @@ pub(crate) fn parse(id: &str, p: &Value) -> Option<PixelFx> {
            brightness: num(p, "edgeBrightness", 6.0).clamp(0.0, 20.0),
            smoothness: num(p, "smoothness", 5.0).clamp(1.0, 15.0),
        },
+        "pixelate.colorHalftone" => PixelFx::ColorHalftone {
+            max_radius: num(p, "maxRadius", 8.0).clamp(4.0, 127.0),
+            angles: [("channel1", 108.0), ("channel2", 162.0), ("channel3", 90.0), ("channel4", 45.0)]
+                .map(|(k, d)| num(p, k, d).clamp(-360.0, 360.0)),
+        },
+        "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) },
        _ => return None,
    })
 }
@@ -94,6 +143,9 @@ 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,
        }
    }

@@ -105,6 +157,12 @@ impl PixelFx {
            PixelFx::SmartBlur { radius, .. } => Some(radius),
            PixelFx::UnsharpMask { radius, .. } => Some(3.0 * radius),
            PixelFx::GlowingEdges { width, smoothness, .. } => Some(width.max(smoothness * 3.0)),
+            // The cells around the pixel's, and the cells around theirs.
+            PixelFx::ColorHalftone { max_radius, .. } => Some(3.0 * std::f64::consts::SQRT_2 * max_radius),
+            PixelFx::Crystallize { cell } => Some(1.5 * cell),
+            PixelFx::Mezzotint { .. } => Some(0.0),
+            // The dots' points, and the softened colour around them.
+            PixelFx::Pointillize { cell } => Some(2.5 * cell),
        }
    }

@@ -118,6 +176,10 @@ impl PixelFx {
            PixelFx::SmartBlur { radius, threshold, samples } => blur::smart(px, w, h, to_px(radius), threshold, samples),
            PixelFx::UnsharpMask { amount, radius, threshold } => sharpen::unsharp(px, w, h, amount, to_px(radius), threshold),
            PixelFx::GlowingEdges { width, brightness, smoothness } => edges::glow(px, w, h, to_px(width), brightness, to_px(smoothness)),
+            PixelFx::ColorHalftone { max_radius, angles } => pixelate::color_halftone(px, w, h, space, max_radius, angles),
+            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),
        }
    }
 }
@@ -0,0 +1,531 @@
+//! Pixelate › Color Halftone, Crystallize, Mezzotint and Pointillize.
+//!
+//! Their patterns (screens, crystals, grains and dots) lie in document space around the object's
+//! centre, so they keep their size at any zoom or resolution and move with the object. The random
+//! ones hash the pattern's cell indices: every redraw gives the same result.
+
+use std::sync::OnceLock;
+
+use vectorcraft_geom::{Affine, Point};
+
+use super::{Channels, PixelSpace, gaussian, to16};
+use crate::util::noise;
+
+/// Mezzotint's patterns, in its Type menu's order: (label, parameter value).
+pub const MEZZOTINT_TYPES: [(&str, &str); 10] = [
+    ("Fine Dots", "fineDots"),
+    ("Medium Dots", "mediumDots"),
+    ("Grainy Dots", "grainyDots"),
+    ("Coarse Dots", "coarseDots"),
+    ("Short Lines", "shortLines"),
+    ("Medium Lines", "mediumLines"),
+    ("Long Lines", "longLines"),
+    ("Short Strokes", "shortStrokes"),
+    ("Medium Strokes", "mediumStrokes"),
+    ("Long Strokes", "longStrokes"),
+];
+
+/// A Mezzotint pattern ([`MEZZOTINT_TYPES`]): random dots, or horizontal lines or strokes.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Mezzotint {
+    /// Dots `size` points across (smooth blobs when `smooth`), plus fine grain when `grainy`.
+    Dots { size: u8, smooth: bool, grainy: bool },
+    /// Horizontal streaks about `length` points long and `width` points thick.
+    Lines { length: u8, width: u8 },
+}
+
+/// The patterns of [`MEZZOTINT_TYPES`], in the same order.
+const MEZZOTINT_KINDS: [Mezzotint; 10] = {
+    const fn dots(size: u8, smooth: bool, grainy: bool) -> Mezzotint {
+        Mezzotint::Dots { size, smooth, grainy }
+    }
+    const fn lines(length: u8, width: u8) -> Mezzotint {
+        Mezzotint::Lines { length, width }
+    }
+    [
+        dots(1, false, false),
+        dots(2, true, false),
+        dots(3, true, true),
+        dots(4, true, false),
+        lines(4, 1),
+        lines(8, 1),
+        lines(16, 1),
+        lines(6, 2),
+        lines(12, 2),
+        lines(24, 2),
+    ]
+};
+
+impl Mezzotint {
+    /// Fine Dots, the first type.
+    pub const FINE_DOTS: Mezzotint = Mezzotint::Dots { size: 1, smooth: false, grainy: false };
+
+    /// 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)
+    }
+}
+
+/// Seeds of the filters' noise ("PIXELATE" and a filter number).
+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 {
+    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> {
+    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 {
+    /// Pixel coordinates → document coordinates relative to the centre.
+    to_rel: Affine,
+    /// The other way.
+    to_px: Affine,
+    /// A pixel's size in document units.
+    px: f64,
+    w: usize,
+    h: usize,
+}
+
+impl Place {
+    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 {
+        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> {
+        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])) {
+        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);
+            }
+        }
+    }
+}
+
+/// 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] = [
+    (0, 0),
+    (-1, 0),
+    (1, 0),
+    (0, -1),
+    (0, 1),
+    (-1, -1),
+    (1, -1),
+    (-1, 1),
+    (1, 1),
+    (-2, -2),
+    (-1, -2),
+    (0, -2),
+    (1, -2),
+    (2, -2),
+    (-2, -1),
+    (2, -1),
+    (-2, 0),
+    (2, 0),
+    (-2, 1),
+    (2, 1),
+    (-2, 2),
+    (-1, 2),
+    (0, 2),
+    (1, 2),
+    (2, 2),
+];
+
+/// What the cells [`AROUND`] one cell hold, made when first asked for and kept while consecutive
+/// pixels stay in that cell.
+struct Around<T> {
+    cell: Option<(i64, i64)>,
+    items: [Option<T>; 25],
+}
+
+impl<T: Copy> Around<T> {
+    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> {
+        if self.cell != Some((i, j)) {
+            self.cell = Some((i, j));
+            self.items = [None; 25];
+        }
+        let (di, dj) = AROUND.get(k)?;
+        let slot = self.items.get_mut(k)?;
+        Some(*slot.get_or_insert_with(|| make(i.wrapping_add(*di), j.wrapping_add(*dj))))
+    }
+}
+
+/// The random point of cell (`i`, `j`) of pattern `salt`, in cells.
+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))
+}
+
+/// 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) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    if !(cell_size.is_finite() && cell_size > 0.0) {
+        return;
+    }
+    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);
+        let (Some(i), Some(j)) = (cell(u), cell(v)) else { return };
+        let mut best = (f64::INFINITY, None);
+        for (k, (di, dj)) in AROUND.iter().enumerate() {
+            // A cell farther than the best point so far can't hold a nearer one.
+            let (ci, cj) = (i.wrapping_add(*di), j.wrapping_add(*dj));
+            if gap(ci, u).hypot(gap(cj, v)) >= best.0 {
+                continue;
+            }
+            if let Some(p) = around.get((i, j), k, |a, b| point_in(1, a, b)) {
+                let d = (p.x - u).hypot(p.y - v);
+                if d < best.0 {
+                    best = (d, Some(p));
+                }
+            }
+        }
+        if let Some(p) = best.1 {
+            let at = Point::new(p.x * cell_size, p.y * cell_size);
+            *out = place.index(at).and_then(|i| src.get(i)).copied().unwrap_or([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)]
+struct Dot {
+    at: Point,
+    radius: f64,
+    z: f64,
+    colour: [f32; 4],
+}
+
+/// The smallest dot radius and the spread above it, in cells.
+const DOT_RADIUS: (f64, f64) = (0.45, 0.25);
+
+/// Pointillize: a dot at one random point per `cell` × `cell` square, of random size around the
+/// cell's, coloured by the (softened) object there, over a white canvas where the object is.
+pub(super) fn pointillize(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, cell_size: f64) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    if !(cell_size.is_finite() && cell_size > 0.0) {
+        return;
+    }
+    // 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 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],
+        };
+        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();
+    place.each(px, |x, y, out| {
+        let q = place.at(x, y);
+        let (u, v) = (q.x / cell_size, q.y / cell_size);
+        let (Some(i), Some(j)) = (cell(u), cell(v)) else { return };
+        // The dots covering the pixel (only the 3 × 3 cells around it reach it), bottom first.
+        let mut hits: [(f64, f32, [f32; 4]); 9] = [(0.0, 0.0, [0.0; 4]); 9];
+        let mut n = 0;
+        for k in 0..9 {
+            let Some(d) = around.get((i, j), k, dot) else { continue };
+            let dist = (d.at.x - u).hypot(d.at.y - v) * cell_size;
+            let cover = ((d.radius - dist) / place.px + 0.5).clamp(0.0, 1.0) as f32;
+            if cover > 0.0
+                && d.colour[3] > 0.0
+                && let Some(slot) = hits.get_mut(n)
+            {
+                *slot = (d.z, cover, d.colour);
+                n += 1;
+            }
+        }
+        let hits = hits.get_mut(..n).unwrap_or_default();
+        hits.sort_by(|a, b| a.0.total_cmp(&b.0));
+        let alpha = f32::from(out[3]) / 255.0;
+        let mut acc = [alpha; 4];
+        for (_, cover, c) in hits.iter() {
+            let keep = 1.0 - c[3] * cover;
+            for (a, v) in acc.iter_mut().zip(c) {
+                *a = v * cover + *a * keep;
+            }
+        }
+        let a = (acc[3].clamp(0.0, 1.0) * 255.0).round();
+        let v = |c: f32| (c.clamp(0.0, 1.0) * 255.0).round().min(a) as u8;
+        *out = [v(acc[0]), v(acc[1]), v(acc[2]), a as u8];
+    });
+}
+
+/// A pixel's colour as the channels the Pixelate filters treat apart (straight, 0..1; see
+/// [`Channels`]), and how many of the four there are.
+fn split(p: [u8; 4], channels: Channels) -> ([f32; 4], usize) {
+    let a = f32::from(p[3]);
+    let [r, g, b] = [p[0], p[1], p[2]].map(|v| if a > 0.0 { (f32::from(v) / a).min(1.0) } else { 0.0 });
+    match channels {
+        Channels::Rgb => ([r, g, b, 0.0], 3),
+        Channels::Cmyk => {
+            // A light black generation, as separations print: black ink takes over in the
+            // shadows, coloured inks build the midtones.
+            let k = (1.0 - r.max(g).max(b)).powi(2);
+            let ink = |v: f32| if k < 1.0 { ((1.0 - v - k) / (1.0 - k)).clamp(0.0, 1.0) } else { 0.0 };
+            ([ink(r), ink(g), ink(b), k], 4)
+        }
+        Channels::CmyPlane => ([1.0 - r, 1.0 - g, 1.0 - b, 0.0], 3),
+        Channels::KPlane => ([1.0 - r, 0.0, 0.0, 0.0], 1),
+    }
+}
+
+/// The pixel of channel values `v` ([`split`]'s) at coverage `alpha` (premultiplied).
+fn join(v: [f32; 4], channels: Channels, alpha: u8) -> [u8; 4] {
+    let [a, b, c, d] = v.map(|x| x.clamp(0.0, 1.0));
+    let rgb = match channels {
+        Channels::Rgb => [a, b, c],
+        Channels::Cmyk => [(1.0 - a) * (1.0 - d), (1.0 - b) * (1.0 - d), (1.0 - c) * (1.0 - d)],
+        Channels::CmyPlane => [1.0 - a, 1.0 - b, 1.0 - c],
+        Channels::KPlane => [1.0 - a; 3],
+    };
+    let al = f32::from(alpha);
+    let [r, g, b] = rgb.map(|x| (x * al).round().clamp(0.0, al) as u8);
+    [r, g, b, alpha]
+}
+
+/// Which of Color Halftone's four screen angles channel `i` of `channels` uses: the K plane's
+/// only channel is the fourth (black) one.
+fn angle_of(channels: Channels, i: usize) -> usize {
+    if channels == Channels::KPlane { 3 } else { i }
+}
+
+/// The share of a `1` × `1` square that a circle of radius `rho` around its centre covers.
+fn circle_in_square(rho: f64) -> f64 {
+    let half = 0.5;
+    if rho <= half {
+        std::f64::consts::PI * rho * rho
+    } else if rho < std::f64::consts::FRAC_1_SQRT_2 {
+        // The circle less the four caps beyond the square's sides.
+        let cap = rho * rho * (half / rho).acos() - half * (rho * rho - half * half).sqrt();
+        std::f64::consts::PI * rho * rho - 4.0 * cap
+    } else {
+        1.0
+    }
+}
+
+/// The radius (in cells) of the dot that covers share `v` of its cell.
+fn dot_radius(v: f64) -> f64 {
+    const STEPS: usize = 256;
+    static TABLE: OnceLock<[f64; STEPS + 1]> = OnceLock::new();
+    let table = TABLE.get_or_init(|| {
+        std::array::from_fn(|k| {
+            let target = k as f64 / STEPS as f64;
+            let (mut lo, mut hi) = (0.0, std::f64::consts::FRAC_1_SQRT_2);
+            for _ in 0..48 {
+                let mid = 0.5 * (lo + hi);
+                if circle_in_square(mid) < target {
+                    lo = mid;
+                } else {
+                    hi = mid;
+                }
+            }
+            hi
+        })
+    });
+    let x = if v.is_finite() { v.clamp(0.0, 1.0) * STEPS as f64 } else { 0.0 };
+    let k = (x.floor() as usize).min(STEPS - 1);
+    let (a, b) = (table.get(k).copied().unwrap_or(0.0), table.get(k + 1).copied().unwrap_or(0.0));
+    a + (b - a) * (x - k as f64)
+}
+
+/// One channel's halftone screen: square cells at an angle, each with the dot of its mean value.
+struct Screen {
+    /// Document coordinates relative to the centre → cells.
+    to_cells: Affine,
+    /// The first cell's indices and the grid's size in cells.
+    origin: (i64, i64),
+    size: (usize, usize),
+    /// Per cell: the channel's sum (× coverage) and the coverage's (then the dot's radius in
+    /// document units, in `sums[k][0]`).
+    sums: Vec<[f32; 2]>,
+}
+
+impl Screen {
+    /// The screen at `angle`° with cells `side` wide over the raster `place` covers; `None` when
+    /// it would have more than `limit` cells.
+    fn new(place: &Place, angle: f64, side: f64, limit: usize) -> Option<Self> {
+        let to_cells = Affine::scale(1.0 / side) * Affine::rotate(angle.to_radians());
+        let corners = [(0.0, 0.0), (place.w as f64, 0.0), (0.0, place.h as f64), (place.w as f64, place.h as f64)];
+        let pts = corners.map(|(x, y)| to_cells * (place.to_rel * Point::new(x, y)));
+        let (lo, hi) = pts.iter().fold(((f64::INFINITY, f64::INFINITY), (f64::NEG_INFINITY, f64::NEG_INFINITY)), |(lo, hi), p| {
+            ((lo.0.min(p.x), lo.1.min(p.y)), (hi.0.max(p.x), hi.1.max(p.y)))
+        });
+        let (i0, j0, i1, j1) = (cell(lo.0)?.checked_sub(1)?, cell(lo.1)?.checked_sub(1)?, cell(hi.0)?.checked_add(1)?, cell(hi.1)?.checked_add(1)?);
+        let gw = usize::try_from(i1.checked_sub(i0)?.checked_add(1)?).ok()?;
+        let gh = usize::try_from(j1.checked_sub(j0)?.checked_add(1)?).ok()?;
+        (gw.checked_mul(gh)? <= limit).then(|| Self { to_cells, origin: (i0, j0), size: (gw, gh), sums: vec![[0.0; 2]; gw * gh] })
+    }
+
+    /// The index of cell (`i`, `j`) in the grid.
+    fn slot(&self, i: i64, j: i64) -> Option<usize> {
+        let x = usize::try_from(i.checked_sub(self.origin.0)?).ok().filter(|x| *x < self.size.0)?;
+        let y = usize::try_from(j.checked_sub(self.origin.1)?).ok().filter(|y| *y < self.size.1)?;
+        Some(y * self.size.0 + x)
+    }
+}
+
+/// Color Halftone: each channel screened at its angle in square cells sized so that a dot of
+/// `max_radius` fills one; each cell's dot covers the share of it that is the channel's mean
+/// there (white stays white, black black). Coverage stays as it is.
+pub(super) fn color_halftone(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, max_radius: f64, angles: [f64; 4]) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    let side = max_radius * std::f64::consts::SQRT_2;
+    // Cells under 3 pixels can't show their dots: on average a screen is the image itself.
+    if !(side.is_finite() && side / place.px >= 3.0) {
+        return;
+    }
+    let channels = space.channels;
+    let n = split([0; 4], channels).1;
+    let limit = w.saturating_mul(h).saturating_add(4096);
+    let mut screens = Vec::with_capacity(n);
+    for i in 0..n {
+        let angle = angles.get(angle_of(channels, i)).copied().unwrap_or(0.0);
+        let Some(s) = Screen::new(&place, angle, side, limit) else { return };
+        screens.push(s);
+    }
+    // Each cell's mean of each channel, weighted by coverage.
+    place.each(px, |x, y, p| {
+        if p[3] == 0 {
+            return;
+        }
+        let (v, _) = split(*p, channels);
+        let a = f32::from(p[3]) / 255.0;
+        let q = place.at(x, y);
+        for (s, v) in screens.iter_mut().zip(v) {
+            let c = s.to_cells * q;
+            if let (Some(i), Some(j)) = (cell(c.x), cell(c.y))
+                && let Some(sum) = s.slot(i, j).and_then(|k| s.sums.get_mut(k))
+            {
+                sum[0] += v * a;
+                sum[1] += a;
+            }
+        }
+    });
+    for s in &mut screens {
+        for sum in &mut s.sums {
+            let mean = if sum[1] > 1e-6 { f64::from(sum[0] / sum[1]) } else { 0.0 };
+            // Full strength fills the cell, corners too; none leaves no speck.
+            let radius = match mean {
+                m if m >= 254.5 / 255.0 => f64::INFINITY,
+                m if m <= 0.5 / 255.0 => 0.0,
+                m => dot_radius(m) * side,
+            };
+            sum[0] = radius as f32;
+        }
+    }
+    place.each(px, |x, y, p| {
+        if p[3] == 0 {
+            return;
+        }
+        let q = place.at(x, y);
+        let mut v = [0.0f32; 4];
+        for (s, out) in screens.iter().zip(v.iter_mut()) {
+            let c = s.to_cells * q;
+            let (Some(i), Some(j)) = (cell(c.x), cell(c.y)) else { continue };
+            // A dot reaches past its cell into the neighbours on the pixel's side only.
+            let (si, sj) = (if c.x - (i as f64) < 0.5 { -1 } else { 1 }, if c.y - (j as f64) < 0.5 { -1 } else { 1 });
+            for (di, dj) in [(0, 0), (si, 0), (0, sj), (si, sj)] {
+                let (ci, cj) = (i.wrapping_add(di), j.wrapping_add(dj));
+                let radius = s.slot(ci, cj).and_then(|k| s.sums.get(k)).map_or(0.0, |sum| f64::from(sum[0]));
+                if radius <= 0.0 {
+                    continue;
+                }
+                let dist = (c.x - (ci as f64 + 0.5)).hypot(c.y - (cj as f64 + 0.5)) * side;
+                *out = out.max(((radius - dist) / place.px + 0.5).clamp(0.0, 1.0) as f32);
+            }
+        }
+        *p = join(v, channels, p[3]);
+    });
+}
+
+/// Mezzotint: every channel turned fully on or off where it is above or below a random threshold
+/// pattern (each channel its own), so the image becomes dots or streaks of pure colours.
+pub(super) fn mezzotint(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, kind: Mezzotint) {
+    let Some(place) = Place::new(space, w, h) else { return };
+    let channels = space.channels;
+    place.each(px, |x, y, p| {
+        if p[3] == 0 {
+            return;
+        }
+        let q = place.at(x, y);
+        let (mut v, n) = split(*p, channels);
+        for (c, value) in v.iter_mut().enumerate().take(n) {
+            let t = threshold(kind, 16 + c as u64, q);
+            *value = if f64::from(*value) > t { 1.0 } else { 0.0 };
+        }
+        *p = join(v, channels, p[3]);
+    });
+}
+
+/// 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,
+    };
+    match kind {
+        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);
+            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)
+        }
+    }
+}
@@ -7,7 +7,7 @@ use crate::{RasterFx, raster_effects};

 /// A `w` × `h` raster whose pixels are document points (origin top-left).
 fn space(w: usize, h: usize) -> PixelSpace {
-    PixelSpace { to_doc: Affine::IDENTITY, px: 1.0, center: Point::new(w as f64 / 2.0, h as f64 / 2.0) }
+    PixelSpace { to_doc: Affine::IDENTITY, px: 1.0, center: Point::new(w as f64 / 2.0, h as f64 / 2.0), channels: Channels::Rgb }
 }

 fn image(w: usize, h: usize, f: impl Fn(usize, usize) -> [u8; 4]) -> Vec<u8> {
@@ -224,7 +224,7 @@ 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 };
+        let s = PixelSpace { to_doc: Affine::scale(1.0 / scale as f64), px: 1.0 / scale as f64, center: Point::ZERO, channels: Channels::Rgb };
        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 +253,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) };
+    let s = PixelSpace { to_doc: Affine::IDENTITY, px: 1.0, center: Point::new(1000.0, 1000.0), channels: Channels::Rgb };
    let cases = [
        ("blur.radial", json!({"quality": "draft"})),
        ("blur.radial", json!({"quality": "good"})),
@@ -261,6 +261,12 @@ fn pixel_timings() {
        ("blur.smart", json!({"quality": "low"})),
        ("blur.smart", json!({"quality": "high", "radius": 30})),
        ("sharpen.unsharpMask", json!({"radius": 20})),
+        ("pixelate.colorHalftone", json!({"maxRadius": 4})),
+        ("pixelate.crystallize", json!({"cellSize": 3})),
+        ("pixelate.crystallize", json!({"cellSize": 300})),
+        ("pixelate.mezzotint", json!({"type": "grainyDots"})),
+        ("pixelate.pointillize", json!({"cellSize": 3})),
+        ("pixelate.pointillize", json!({"cellSize": 300})),
    ];
    for (id, p) in cases {
        let mut d = src.clone();
@@ -269,3 +275,205 @@ fn pixel_timings() {
        println!("{id} {p}: {:?}", t.elapsed());
    }
 }
+
+#[test]
+fn pixelate_params_take_defaults_and_stay_in_range() {
+    assert_eq!(fx("pixelate.colorHalftone", json!({})), PixelFx::ColorHalftone { max_radius: 8.0, angles: [108.0, 162.0, 90.0, 45.0] });
+    assert_eq!(
+        fx("pixelate.colorHalftone", json!({"maxRadius": 1e9, "channel1": -1e9, "channel2": 30, "channel4": "x"})),
+        PixelFx::ColorHalftone { max_radius: 127.0, angles: [-360.0, 30.0, 90.0, 45.0] }
+    );
+    assert_eq!(fx("pixelate.colorHalftone", json!({"maxRadius": 0})), PixelFx::ColorHalftone { max_radius: 4.0, angles: [108.0, 162.0, 90.0, 45.0] });
+    assert_eq!(fx("pixelate.crystallize", json!({})), PixelFx::Crystallize { cell: 10.0 });
+    assert_eq!(fx("pixelate.crystallize", json!({"cellSize": -4})), PixelFx::Crystallize { cell: 3.0 });
+    assert_eq!(fx("pixelate.pointillize", json!({})), PixelFx::Pointillize { cell: 5.0 });
+    assert_eq!(fx("pixelate.pointillize", json!({"cellSize": 1e300})), PixelFx::Pointillize { cell: 300.0 });
+    assert_eq!(fx("pixelate.mezzotint", json!({})), PixelFx::Mezzotint { kind: Mezzotint::FINE_DOTS });
+    assert_eq!(fx("pixelate.mezzotint", json!({"type": "LONGSTROKES"})), PixelFx::Mezzotint { kind: Mezzotint::Lines { length: 24, width: 2 } });
+    for junk in [json!({"type": 7}), json!({"type": "nonsense"})] {
+        assert_eq!(fx("pixelate.mezzotint", junk), PixelFx::Mezzotint { kind: Mezzotint::FINE_DOTS });
+    }
+    // Every Type is a pattern of its own, documented in the catalogue.
+    let doc = crate::effect_info("pixelate.mezzotint").unwrap().params;
+    let kinds: Vec<Mezzotint> = MEZZOTINT_TYPES.iter().map(|(_, v)| Mezzotint::parse(v)).collect();
+    for (i, (_, v)) in MEZZOTINT_TYPES.iter().enumerate() {
+        assert!(doc.contains(&format!("\"{v}\"")), "{v}");
+        assert!(kinds.iter().skip(i + 1).all(|k| *k != kinds[i]), "{v}");
+    }
+    // Dots and crystals reach beyond the object; screens and grain stay on it.
+    let b = Rect::new(0.0, 0.0, 100.0, 50.0);
+    assert_eq!(fx("pixelate.crystallize", json!({"cellSize": 20})).outset(b), 30.0);
+    assert_eq!(fx("pixelate.pointillize", json!({"cellSize": 20})).outset(b), 30.0);
+    assert_eq!(fx("pixelate.colorHalftone", json!({})).outset(b), 0.0);
+    assert_eq!(fx("pixelate.mezzotint", json!({})).reach(), Some(0.0));
+}
+
+/// Fraction of `d`'s pixels for which `f` holds.
+fn share(d: &[u8], f: impl Fn(&[u8; 4]) -> bool) -> f64 {
+    let px = d.as_chunks::<4>().0;
+    px.iter().filter(|p| f(p)).count() as f64 / px.len() as f64
+}
+
+#[test]
+fn color_halftone_screens_midtones_into_dots_and_keeps_white_and_black() {
+    let (w, h) = (64, 64);
+    let halftone = fx("pixelate.colorHalftone", json!({}));
+    for v in [0, 255] {
+        let mut d = image(w, h, |_, _| grey(v));
+        halftone.apply(&mut d, w, h, &space(w, h));
+        assert_eq!(d, image(w, h, |_, _| grey(v)), "{v} stays");
+    }
+    // Mid grey: each channel's dots cover about half its screen, so the tone stays.
+    let mut d = image(w, h, |_, _| grey(128));
+    halftone.apply(&mut d, w, h, &space(w, h));
+    let px = d.as_chunks::<4>().0;
+    for c in 0..3 {
+        let mean = px.iter().map(|p| f64::from(p[c])).sum::<f64>() / px.len() as f64;
+        assert!((mean - 128.0).abs() < 16.0, "channel {c}: {mean}");
+    }
+    assert!(share(&d, |p| p[0] == 255) > 0.25 && share(&d, |p| p[0] == 0) > 0.25, "dots, not grey");
+    assert!(share(&d, |p| p[0] != p[1]) > 0.1, "the channels' screens lie at different angles");
+    assert!(px.iter().all(|p| p[3] == 255), "coverage stays");
+    // Transparency stays transparent.
+    let mut half = image(w, h, |x, _| if x < 32 { grey(160) } else { [0; 4] });
+    halftone.apply(&mut half, w, h, &space(w, h));
+    assert!((0..h).all(|y| (32..w).all(|x| at(&half, w, x, y) == [0; 4])));
+    // Dots are bigger where the image is brighter.
+    let mut ramp = image(w, h, |x, _| grey((x * 4) as u8));
+    halftone.apply(&mut ramp, w, h, &space(w, h));
+    let lit = |x0: usize| (0..h).flat_map(|y| (x0..x0 + 16).map(move |x| (x, y))).filter(|(x, y)| at(&ramp, w, *x, *y)[0] > 127).count();
+    assert!(lit(8) < lit(40), "{} < {}", lit(8), lit(40));
+}
+
+#[test]
+fn color_halftone_screens_inks_in_cmyk_documents() {
+    let (w, h) = (64, 64);
+    let halftone = fx("pixelate.colorHalftone", json!({}));
+    let cmyk = PixelSpace { channels: Channels::Cmyk, ..space(w, h) };
+    // A neutral grey prints with all four inks: dots of each on white paper, black where they
+    // all overlap.
+    let mut d = image(w, h, |_, _| grey(128));
+    halftone.apply(&mut d, w, h, &cmyk);
+    assert!(share(&d, |p| *p == grey(255)) > 0.02 && share(&d, |p| *p == grey(0)) > 0.02);
+    for (ink, colour) in [("cyan", [0, 255, 255, 255]), ("magenta", [255, 0, 255, 255]), ("yellow", [255, 255, 0, 255])] {
+        assert!(share(&d, |p| *p == colour) > 0.0, "{ink} dots alone");
+    }
+    // White paper stays bare; pure cyan ink fills its cells.
+    let mut white = image(w, h, |_, _| grey(255));
+    halftone.apply(&mut white, w, h, &cmyk);
+    assert_eq!(white, image(w, h, |_, _| grey(255)));
+    let mut cyan = image(w, h, |_, _| [0, 255, 255, 255]);
+    halftone.apply(&mut cyan, w, h, &cmyk);
+    assert_eq!(cyan, image(w, h, |_, _| [0, 255, 255, 255]));
+    // Ink planes: the complemented K plane screens one grey channel at the black angle (45°,
+    // the same in every quarter turn).
+    let mut k = image(w, h, |_, _| grey(128));
+    halftone.apply(&mut k, w, h, &PixelSpace { channels: Channels::KPlane, ..space(w, h) });
+    assert!(k.as_chunks::<4>().0.iter().all(|p| p[0] == p[1] && p[1] == p[2]), "one grey channel");
+    assert!(share(&k, |p| p[0] == 255) > 0.25 && share(&k, |p| p[0] == 0) > 0.25);
+    let mut turned = image(w, h, |_, _| grey(128));
+    fx("pixelate.colorHalftone", json!({"channel4": 135})).apply(&mut turned, w, h, &PixelSpace { channels: Channels::KPlane, ..space(w, h) });
+    let mut other = image(w, h, |_, _| grey(128));
+    fx("pixelate.colorHalftone", json!({"channel4": 30})).apply(&mut other, w, h, &PixelSpace { channels: Channels::KPlane, ..space(w, h) });
+    assert_eq!(turned, k, "channel 4 sets the K plane's angle");
+    assert_ne!(other, k);
+}
+
+#[test]
+fn crystallize_redraws_in_solid_polygons() {
+    let (w, h) = (48, 48);
+    let crystals = fx("pixelate.crystallize", json!({"cellSize": 6}));
+    // One colour stays that colour (away from the raster's edges, where crystals around points
+    // beyond it take the transparency there).
+    let mut d = image(w, h, |_, _| [200, 100, 50, 255]);
+    crystals.apply(&mut d, w, h, &space(w, h));
+    assert!((9..39).all(|y| (9..39).all(|x| at(&d, w, x, y) == [200, 100, 50, 255])));
+    // Two halves: every pixel takes one of the colours, and the border between them zigzags.
+    let (red, blue) = ([200, 0, 0, 255], [0, 0, 200, 255]);
+    let src = image(w, h, |x, _| if x < 24 { red } else { blue });
+    let mut d = src.clone();
+    crystals.apply(&mut d, w, h, &space(w, h));
+    assert!((9..39).all(|y| (9..39).all(|x| [red, blue].contains(&at(&d, w, x, y)))));
+    let crossed = (9..39).flat_map(|y| (9..39).map(move |x| (x, y))).filter(|(x, y)| at(&d, w, *x, *y) != at(&src, w, *x, *y)).count();
+    assert!(crossed > 10, "{crossed}");
+    let border: std::collections::BTreeSet<usize> = (9..39).map(|y| (9..39).find(|x| at(&d, w, *x, y) == blue).unwrap()).collect();
+    assert!(border.len() > 2, "{border:?}");
+}
+
+#[test]
+fn mezzotint_turns_channels_fully_on_or_off() {
+    let (w, h) = (64, 64);
+    let grey_square = image(w, h, |x, y| if (8..56).contains(&x) && (8..56).contains(&y) { grey(128) } else { [0; 4] });
+    let mut seen = Vec::new();
+    for (_, kind) in MEZZOTINT_TYPES {
+        let f = fx("pixelate.mezzotint", json!({ "type": kind }));
+        for v in [0, 255] {
+            let mut d = image(w, h, |_, _| grey(v));
+            f.apply(&mut d, w, h, &space(w, h));
+            assert_eq!(d, image(w, h, |_, _| grey(v)), "{kind}: {v} stays");
+        }
+        let mut d = grey_square.clone();
+        f.apply(&mut d, w, h, &space(w, h));
+        let px = d.as_chunks::<4>().0;
+        assert!(px.iter().all(|p| p[..3].iter().all(|c| *c == 0 || *c == p[3])), "{kind}: pure colours");
+        let on = px.iter().filter(|p| p[3] > 0 && p[0] > 0).count() as f64 / (48.0 * 48.0);
+        assert!((0.25..0.75).contains(&on), "{kind}: {on}");
+        assert!(px.iter().any(|p| p[3] > 0 && p[0] != p[1]), "{kind}: each channel its own pattern");
+        assert!(d.iter().zip(&grey_square).skip(3).step_by(4).all(|(a, b)| a == b), "{kind}: coverage stays");
+        assert!(!seen.contains(&d), "{kind}: a pattern of its own");
+        seen.push(d);
+    }
+}
+
+#[test]
+fn pointillize_paints_dots_on_a_white_canvas() {
+    let (w, h) = (80, 80);
+    let red = [200, 0, 0, 255];
+    let src = image(w, h, |x, y| if (20..60).contains(&x) && (20..60).contains(&y) { red } else { [0; 4] });
+    let mut d = src.clone();
+    fx("pixelate.pointillize", json!({})).apply(&mut d, w, h, &space(w, h));
+    let inside: Vec<[u8; 4]> = (26..54).flat_map(|y| (26..54).map(move |x| (x, y))).map(|(x, y)| at(&d, w, x, y)).collect();
+    let canvas = inside.iter().filter(|p| **p == grey(255)).count();
+    let dots = inside.iter().filter(|p| **p == red).count();
+    assert!(canvas > inside.len() / 20 && dots > inside.len() / 3, "{canvas} canvas, {dots} dots of {}", inside.len());
+    assert!(inside.iter().all(|p| p[3] == 255 && p[1] == p[2] && p[0] >= p[1]), "red over white only");
+    // Dots at the edges reach a little past the object; far from it stays transparent.
+    assert!((0..h).any(|y| (14..20).any(|x| at(&d, w, x, y)[3] > 0)));
+    assert!((0..h).all(|y| (0..10).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]));
+}
+
+/// The patterns lie in document space around the object's centre: the same at twice the
+/// resolution, and moving with the object.
+#[test]
+fn pixelate_patterns_follow_the_object_at_any_resolution() {
+    let (w, h) = (40, 40);
+    let art = |x: f64, y: f64| -> [u8; 4] {
+        if (8.0..32.0).contains(&x) && (8.0..32.0).contains(&y) { [(x * 6.0) as u8, (y * 6.0) as u8, 120, 255] } else { [0; 4] }
+    };
+    for (id, p) in [
+        ("pixelate.colorHalftone", json!({"maxRadius": 4})),
+        ("pixelate.crystallize", json!({"cellSize": 4})),
+        ("pixelate.mezzotint", json!({"type": "coarseDots"})),
+        ("pixelate.pointillize", json!({"cellSize": 4})),
+    ] {
+        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));
+        // Twice the pixels for the same art, averaged back down.
+        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 < 24.0, "{id}: {diff}");
+        // The object and its raster 7 × 3 points further: the same pixels.
+        let moved = PixelSpace { to_doc: Affine::translate((7.0, 3.0)), center: Point::new(27.0, 23.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}");
+    }
+}
@@ -318,7 +318,22 @@ fn require_targets(s: &Session, p: &Value, cmd: &str) -> Result<Vec<NodeId>> {

 /// One undo step (`label`) running `f` on each of `ids` with the item a fill (`fill`) or stroke
 /// edit aimed at `item` changes there (`None`: the topmost one; text then edits its characters).
+/// Nothing targeted is not an edit.
 pub(crate) fn edit_items(
+    s: &mut Session,
+    ids: &[NodeId],
+    item: ItemTarget,
+    cmd: &str,
+    label: &str,
+    fill: bool,
+    f: impl FnMut(&mut Node, Option<usize>) -> Result<()>,
+) -> Result<()> {
+    edit_items_then(s, ids, item, cmd, label, fill, f, |_, _| Ok(()))
+}
+
+/// [`edit_items`], then `after` on the ids `f` changed, inside the same undo step.
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn edit_items_then(
    s: &mut Session,
    ids: &[NodeId],
    item: ItemTarget,
@@ -326,17 +341,20 @@ pub(crate) fn edit_items(
    label: &str,
    fill: bool,
    mut f: impl FnMut(&mut Node, Option<usize>) -> Result<()>,
+    mut after: impl FnMut(&mut vectorcraft_doc::Document, &[NodeId]) -> Result<()>,
 ) -> Result<()> {
    if ids.is_empty() {
        return Ok(());
    }
    s.edit(label, |d, _| {
+        let mut changed = Vec::new();
        for id in ids {
            let Some(n) = d.node_mut(*id) else { continue };
            let index = item.resolve(&n.appearance, fill, cmd)?;
            f(n, index)?;
+            changed.push(*id);
        }
-        Ok(())
+        after(d, &changed)
    })
 }

@@ -5,6 +5,7 @@
 //! the spec. Editing the data or the type regenerates them in place, keeping any move/scale the
 //! user applied to the graph since it was generated.

+use std::collections::HashMap;
 use std::sync::Arc;

 use serde_json::{Value, json};
@@ -131,11 +132,26 @@ fn fmt_value(v: f64) -> String {

 // ---------- generation ----------

-/// Series colours: black, then greys (Illustrator's graphs start in greyscale too).
-fn series_paint(i: usize) -> Paint {
+/// Series colours: black, then greys (graphs start in greyscale).
+fn default_series_color(i: usize) -> Color {
    const LEVELS: [f32; 8] = [0.0, 0.55, 0.8, 0.3, 0.68, 0.15, 0.9, 0.42];
    let l = LEVELS[i % LEVELS.len()];
-    Paint::solid(Color::rgb(l, l, l))
+    Color::rgb(l, l, l)
+}
+
+fn default_series_paint(i: usize) -> Paint {
+    Paint::solid(default_series_color(i))
+}
+
+/// Fill and stroke for one generated mark of series `i`. A stored fill is used only where the
+/// generator paints with the series colour (`series_fill`). A stored stroke replaces that part's
+/// own stroke, so a column's stroke stays a stroke and a line's markers do not repaint its line.
+fn series_marks(g: &GraphSpec, i: usize, series_fill: bool, stroke: Paint, width: f64) -> (Paint, Paint, f64) {
+    let slot = g.series_paints.get(i);
+    let fill = if series_fill { slot.and_then(|p| p.fill.clone()).unwrap_or_else(|| default_series_paint(i)) } else { Paint::None };
+    let stroke = slot.and_then(|p| p.stroke.clone()).unwrap_or(stroke);
+    let width = if slot.is_some_and(|p| p.stroke.is_some()) { slot.and_then(|p| p.stroke_width).unwrap_or(width) } else { width };
+    (fill, stroke, width)
 }

 const LABEL_SIZE: f64 = 9.0;
@@ -177,6 +193,14 @@ impl Gen<'_> {
        g.name = Some(name.into());
        Arc::new(g)
    }
+    /// A series group. Empty series are omitted by the caller; the index is stored on the group
+    /// so later paint edits find the series without counting siblings.
+    fn series(&mut self, name: &str, index: usize, children: Vec<Arc<Node>>) -> Arc<Node> {
+        let mut g = Node::group(self.d.alloc_id(), children);
+        g.name = Some(name.into());
+        g.series_index = u32::try_from(index).ok();
+        Arc::new(g)
+    }
 }

 fn polyline(pts: &[Point], closed: bool) -> PathData {
@@ -200,6 +224,7 @@ fn marker(p: Point, s: f64) -> PathData {

 /// Build the graph's children.
 fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
+    let mark = |i: usize, series_fill: bool, stroke: Paint, width: f64| series_marks(g, i, series_fill, stroke, width);
    let mut b = Gen { d, out: vec![] };
    let r = g.rect;
    let nser = g.rows.iter().map(Vec::len).max().unwrap_or(0).max(1);
@@ -231,7 +256,8 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                    bp.line_to(centre + vectorcraft_geom::Vec2::new(a0.cos(), a0.sin()) * rad);
                    arc.to_cubic_beziers(0.1, |p1, p2, p| bp.curve_to(p1, p2, p));
                    bp.close_path();
-                    let n = b.path(PathData::from_bezpath(&bp), series_paint(s), Paint::solid(Color::WHITE), 0.5);
+                    let (fill, stroke, w) = mark(s, true, Paint::solid(Color::WHITE), 0.5);
+                    let n = b.path(PathData::from_bezpath(&bp), fill, stroke, w);
                    items.push(n);
                    a0 += sweep;
                }
@@ -268,9 +294,11 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
            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();
-                items.push(b.path(polyline(&pts, true), Paint::None, series_paint(s), 1.0));
+                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 {
-                    items.push(b.path(marker(p, 4.0), series_paint(s), Paint::None, 0.0));
+                    let (fill, stroke, w) = mark(s, true, Paint::None, 0.0);
+                    items.push(b.path(marker(p, 4.0), fill, stroke, w));
                }
            }
        }
@@ -359,11 +387,13 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                    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 {
-                        series[si].push(b.path(polyline(&pts, false), Paint::None, series_paint(si), 1.0));
+                        let (fill, stroke, w) = mark(si, false, default_series_paint(si), 1.0);
+                        series[si].push(b.path(polyline(&pts, false), fill, stroke, w));
                    }
                    if g.mark_points {
                        for p in &pts {
-                            series[si].push(b.path(marker(*p, 5.0), series_paint(si), Paint::None, 0.0));
+                            let (fill, stroke, w) = mark(si, true, Paint::None, 0.0);
+                            series[si].push(b.path(marker(*p, 5.0), fill, stroke, w));
                        }
                    }
                }
@@ -385,7 +415,8 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                            } else {
                                Rect::new(a, v0.min(v1), a + bar, v0.max(v1))
                            };
-                            items.push(b.path(shapes::rectangle(rect), series_paint(s), Paint::None, 0.0));
+                            let (fill, stroke, w) = mark(s, true, Paint::None, 0.0);
+                            items.push(b.path(shapes::rectangle(rect), fill, stroke, w));
                        }
                    }
                }
@@ -405,7 +436,8 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                            } else {
                                Rect::new(a, v0.min(v1), a + bar, v0.max(v1))
                            };
-                            items.push(b.path(shapes::rectangle(rect), series_paint(s), Paint::solid(Color::WHITE), 0.25));
+                            let (fill, stroke, w) = mark(s, true, Paint::solid(Color::WHITE), 0.25);
+                            items.push(b.path(shapes::rectangle(rect), fill, stroke, w));
                        }
                    }
                }
@@ -413,11 +445,13 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                    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 {
-                            items.push(b.path(polyline(&pts, false), Paint::None, series_paint(s), 1.0));
+                            let (fill, stroke, w) = mark(s, false, default_series_paint(s), 1.0);
+                            items.push(b.path(polyline(&pts, false), fill, stroke, w));
                        }
                        if g.mark_points {
                            for p in &pts {
-                                items.push(b.path(marker(*p, 5.0), series_paint(s), Paint::None, 0.0));
+                                let (fill, stroke, w) = mark(s, true, Paint::None, 0.0);
+                                items.push(b.path(marker(*p, 5.0), fill, stroke, w));
                            }
                        }
                    }
@@ -429,7 +463,8 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                        let above: Vec<f64> = (0..ncat).map(|c| below[c] + val(c, s)).collect();
                        let mut pts: Vec<Point> = (0..ncat).map(|c| Point::new(cat_mid(c), vpos(above[c]))).collect();
                        pts.extend((0..ncat).rev().map(|c| Point::new(cat_mid(c), vpos(below[c]))));
-                        items.push(b.path(polyline(&pts, true), series_paint(s), Paint::solid(Color::WHITE), 0.25));
+                        let (fill, stroke, w) = mark(s, true, Paint::solid(Color::WHITE), 0.25);
+                        items.push(b.path(polyline(&pts, true), fill, stroke, w));
                        below = above;
                    }
                }
@@ -448,16 +483,18 @@ fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
                continue;
            }
            let y = r.y0 + s as f64 * (LABEL_SIZE * 1.8);
-            items.push(b.path(shapes::rectangle(Rect::new(x, y, x + 8.0, y + 8.0)), series_paint(s), Paint::None, 0.0));
+            let (fill, stroke, w) = mark(s, true, Paint::None, 0.0);
+            items.push(b.path(shapes::rectangle(Rect::new(x, y, x + 8.0, y + 8.0)), fill, stroke, w));
            labels.push(b.text(Point::new(x + 12.0, y + 7.5), &label, Justify::Left));
        }
    }
    for (s, items) in series.into_iter().enumerate() {
-        if !items.is_empty() {
-            let name = g.series.get(s).cloned().filter(|n| !n.is_empty()).unwrap_or_else(|| format!("Series {}", s + 1));
-            let grp = b.group(&name, items);
-            b.out.push(grp);
+        if items.is_empty() {
+            continue;
        }
+        let name = g.series.get(s).cloned().filter(|n| !n.is_empty()).unwrap_or_else(|| format!("Series {}", s + 1));
+        let grp = b.series(&name, s, items);
+        b.out.push(grp);
    }
    if !labels.is_empty() {
        let grp = b.group("Legend", labels);
@@ -540,6 +577,91 @@ fn spec_of(s: &Session, id: NodeId) -> Result<GraphSpec> {
    s.doc()?.doc.node(id).and_then(|n| n.graph.as_deref().cloned()).ok_or(EngineError::NoNode(id))
 }

+/// Where a node inside a graph's generated series art belongs: the graph, the series group and
+/// the series index stored on that group.
+#[derive(Clone, Copy)]
+struct SeriesRef {
+    graph: NodeId,
+    group: NodeId,
+    index: usize,
+}
+
+/// Every node in a graph's series groups (the groups too), found in one pass over the document.
+/// Axes, the legend and groups whose index is past the graph's series (the index comes from the
+/// file) are left out.
+fn series_members(doc: &Document) -> HashMap<NodeId, SeriesRef> {
+    let mut out = HashMap::new();
+    doc.walk(|n| {
+        let Some(spec) = n.graph.as_deref() else { return };
+        let count = spec.rows.iter().map(Vec::len).max().unwrap_or(0).max(1);
+        for group in n.children().into_iter().flatten() {
+            let Some(index) = group.series_index.and_then(|i| usize::try_from(i).ok()).filter(|i| *i < count) else { continue };
+            let r = SeriesRef { graph: n.id, group: group.id, index };
+            group.walk(&mut |m| {
+                out.insert(m.id, r);
+            });
+        }
+    });
+    out
+}
+
+/// Group Selection on a graph series targets its constituent marks and legend swatch, not a
+/// group-level appearance which the generated art does not inherit. Other ids pass through.
+pub(crate) fn paint_targets(doc: &Document, ids: &[NodeId]) -> Vec<NodeId> {
+    let members = series_members(doc);
+    if members.is_empty() {
+        return ids.to_vec();
+    }
+    let mut out = Vec::new();
+    for id in ids {
+        match members.get(id).filter(|r| r.group == *id).and_then(|_| doc.node(*id)) {
+            Some(group) => group.walk(&mut |m| {
+                if matches!(m.kind, NodeKind::Path { .. }) {
+                    out.push(m.id);
+                }
+            }),
+            None => out.push(*id),
+        }
+    }
+    out.sort_unstable();
+    out.dedup();
+    out
+}
+
+/// Copy the paint just applied to generated series art into that series' fill or stroke. Called
+/// inside the same document edit, so the visible paint and future regeneration undo together.
+/// Gradients, patterns and swatch links are kept as [`Paint`], not reduced to a solid colour.
+pub(crate) fn capture_series_paints(doc: &mut Document, ids: &[NodeId], fill: bool) {
+    let members = series_members(doc);
+    if members.is_empty() {
+        return;
+    }
+    let captures: Vec<_> = ids
+        .iter()
+        .filter_map(|id| {
+            let r = members.get(id)?;
+            let node = doc.node(*id)?;
+            let paint = node.appearance.paint_at(None, fill)?.clone();
+            let width = (!fill).then(|| node.appearance.stroke_width());
+            Some((r.graph, r.index, paint, width))
+        })
+        .collect();
+    for (graph, index, paint, width) in captures {
+        let Some(spec) = doc.node_mut(graph).and_then(|n| n.graph.as_deref_mut()) else { continue };
+        // `index` is below the graph's series count (`series_members`).
+        if spec.series_paints.len() <= index {
+            spec.series_paints.resize(index + 1, vectorcraft_doc::SeriesPaint::default());
+        }
+        let Some(slot) = spec.series_paints.get_mut(index) else { continue };
+        if fill {
+            slot.fill = Some(paint);
+        } else {
+            slot.stroke = Some(paint);
+            slot.stroke_width = width;
+        }
+    }
+}
+
 fn set_data(s: &mut Session, p: &Value) -> Result<Value> {
    let id = target(s, p, "graph.setData")?;
    let mut spec = spec_of(s, id)?;
@@ -592,7 +714,8 @@ fn set_type(s: &mut Session, p: &Value) -> Result<Value> {
 #[cfg(test)]
 mod tests {
    use serde_json::json;
-    use vectorcraft_doc::NodeKind;
+    use vectorcraft_color::Paint;
+    use vectorcraft_doc::{GraphKind, GraphSpec, NodeKind};

    use crate::{NodeId, Session};

@@ -609,6 +732,11 @@ mod tests {
        n.children().unwrap().iter().find(|c| c.name.as_deref() == Some(name)).unwrap_or_else(|| panic!("no {name}"))
    }

+    /// The generated group stored for series `index`, not a sibling that happens to share its name.
+    fn series(n: &vectorcraft_doc::Node, index: u32) -> &vectorcraft_doc::Node {
+        n.children().unwrap().iter().find(|c| c.series_index == Some(index)).unwrap_or_else(|| panic!("no series {index}"))
+    }
+
    #[test]
    fn every_graph_type_generates_series_groups() {
        let mut s = Session::new();
@@ -662,6 +790,228 @@ mod tests {
        assert!(matches!(n.kind, NodeKind::Group { .. }));
    }

+    #[test]
+    fn group_selection_paint_becomes_the_series_colour_and_survives_regeneration() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({})).unwrap();
+        for ty in GraphKind::ALL {
+            let id = graph(&mut s, ty.id());
+            let series_id = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
+            s.execute("paint.setFill", &json!({"ids": [series_id.0], "color": "#ff0000"})).unwrap();
+            let spec = s.doc().unwrap().doc.node(id).unwrap().graph.as_deref().unwrap().clone();
+            let restored: GraphSpec = serde_json::from_value(serde_json::to_value(&spec).unwrap()).unwrap();
+            assert_eq!(spec, restored);
+            let red = Paint::solid(vectorcraft_color::Color::rgb(1.0, 0.0, 0.0));
+            assert_eq!(spec.series_paints.first().and_then(|p| p.fill.clone()), Some(red.clone()), "{ty:?}");
+            let selected_group = group(s.doc().unwrap().doc.node(id).unwrap(), "2024");
+            assert!(selected_group.children().unwrap().iter().all(|n| n.appearance.fill_paint() == red), "{ty:?}");
+            s.execute("graph.setData", &json!({"rows": [[2, 3], [4, 5]]})).unwrap();
+            s.execute("graph.setType", &json!({"type": "line"})).unwrap();
+            let spec = s.doc().unwrap().doc.node(id).unwrap().graph.as_deref().unwrap();
+            assert_eq!(spec.series_paints.first().and_then(|p| p.fill.clone()), Some(red.clone()), "{ty:?}");
+            let series = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap();
+            assert!(series.iter().any(|n| n.appearance.fill_paint() == red), "{ty:?}");
+        }
+    }
+
+    #[test]
+    fn painting_a_series_is_one_undoable_edit() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({})).unwrap();
+        let id = graph(&mut s, "column");
+        let series_id = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
+        s.execute("paint.setFill", &json!({"ids": [series_id.0], "color": "#e8573f"})).unwrap();
+        assert_eq!(
+            s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().series_paints[0].fill.as_ref().and_then(Paint::color).unwrap().to_hex(),
+            "#e8573f"
+        );
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert!(s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().series_paints.is_empty());
+        assert_eq!(
+            group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap()[0].appearance.fill_paint().color(),
+            Some(super::default_series_color(0))
+        );
+        s.execute("edit.redo", &json!({})).unwrap();
+        assert_eq!(
+            s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().series_paints[0].fill.as_ref().and_then(Paint::color).unwrap().to_hex(),
+            "#e8573f"
+        );
+    }
+
+    #[test]
+    fn painting_one_bar_sets_the_colour_used_by_the_whole_series_on_rebuild() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({})).unwrap();
+        let id = graph(&mut s, "column");
+        let bar = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap()[0].id;
+        s.execute("paint.setFill", &json!({"ids": [bar.0], "color": "#12ab34"})).unwrap();
+        s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
+        let node = s.doc().unwrap().doc.node(id).unwrap();
+        let green = vectorcraft_color::Color::rgb(18.0 / 255.0, 171.0 / 255.0, 52.0 / 255.0);
+        assert_eq!(node.graph.as_ref().unwrap().series_paints[0].fill.as_ref().and_then(Paint::color), Some(green));
+        assert!(group(node, "2024").children().unwrap().iter().all(|n| n.appearance.fill_paint().color() == Some(green)));
+    }
+
+    /// A series index read from a file past the graph's series is not a series: painting its art
+    /// paints the art alone and stores nothing (no allocation sized by the file).
+    #[test]
+    fn a_series_index_past_the_graphs_series_is_ignored() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({})).unwrap();
+        let id = graph(&mut s, "column");
+        let series_id = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
+        s.edit("Junk", |d, _| {
+            d.node_mut(series_id).unwrap().series_index = Some(u32::MAX);
+            Ok(())
+        })
+        .unwrap();
+        let bar = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap()[0].id;
+        s.execute("paint.setFill", &json!({"ids": [bar.0, series_id.0], "color": "#12ab34"})).unwrap();
+        let node = s.doc().unwrap().doc.node(id).unwrap();
+        assert!(node.graph.as_ref().unwrap().series_paints.is_empty());
+        assert_eq!(group(node, "2024").children().unwrap()[0].appearance.fill_paint().color().map(|c| c.to_hex()), Some("#12ab34".into()));
+    }
+
+    #[test]
+    fn painting_a_line_series_stroke_sets_its_persistent_colour() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({})).unwrap();
+        let id = graph(&mut s, "line");
+        let series_id = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
+        s.execute("paint.setStroke", &json!({"ids": [series_id.0], "color": "#3751c8"})).unwrap();
+        let blue = vectorcraft_color::Color::rgb(55.0 / 255.0, 81.0 / 255.0, 200.0 / 255.0);
+        assert_eq!(
+            s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().series_paints[0].stroke.as_ref().and_then(Paint::color),
+            Some(blue)
+        );
+        assert!(s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().series_paints[0].fill.is_none());
+        s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
+        assert!(
+            group(s.doc().unwrap().doc.node(id).unwrap(), "2024")
+                .children()
+                .unwrap()
+                .iter()
+                .any(|n| n.appearance.stroke_paint().color() == Some(blue))
+        );
+    }
+
+    #[test]
+    fn series_colours_survive_native_save_open_and_export() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({})).unwrap();
+        let id = graph(&mut s, "column");
+        let first = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
+        let second = group(s.doc().unwrap().doc.node(id).unwrap(), "2025").id;
+        s.execute("paint.setFill", &json!({"ids": [first.0], "color": "#f00"})).unwrap();
+        s.execute("paint.setFill", &json!({"ids": [second.0], "color": "#008080"})).unwrap();
+        let dir = vectorcraft_testkit::temp_dir("graph-palette");
+        let path = dir.join("palette.vectorcraft");
+        s.execute("document.save", &json!({"path": path})).unwrap();
+        s.execute("document.open", &json!({"path": path})).unwrap();
+        let paints = &s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().series_paints;
+        assert_eq!(paints.iter().map(|p| p.fill.as_ref().and_then(Paint::color).unwrap().to_hex()).collect::<Vec<_>>(), vec!["#ff0000", "#008080"]);
+        s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
+        s.execute("graph.setData", &json!({"id": id.0, "rows": [[3, 4, 5]]})).unwrap();
+        let n = s.doc().unwrap().doc.node(id).unwrap();
+        let swatch = group(n, "2025").children().unwrap().last().unwrap();
+        assert_eq!(swatch.appearance.fill_paint().color().unwrap().to_hex(), "#008080");
+        let third = group(n, "Series 3").children().unwrap().first().unwrap();
+        assert_eq!(third.appearance.fill_paint().color().unwrap().to_hex(), "#cccccc");
+        let svg = s.execute("document.serialize", &json!({"format": "svg"})).unwrap();
+        let svg = svg["text"].as_str().unwrap();
+        assert!(svg.contains("#ff0000") && svg.contains("#008080"));
+        let png = dir.join("palette.png");
+        s.execute("document.export", &json!({"format": "png", "path": png})).unwrap();
+        let pixels = image::open(&png).unwrap().to_rgba8();
+        assert!(pixels.pixels().any(|p| p.0 == [255, 0, 0, 255]));
+        assert!(pixels.pixels().any(|p| p.0 == [0, 128, 128, 255]));
+        let old: GraphSpec = serde_json::from_value(json!({"rows": [[1.0]]})).unwrap();
+        assert!(old.series_paints.is_empty(), "older files keep the greyscale default");
+    }
+
+    #[test]
+    fn a_column_stroke_stays_a_stroke_and_a_marker_fill_does_not_recolour_its_line() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({})).unwrap();
+        let id = graph(&mut s, "column");
+        let series_id = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
+        s.execute("paint.setStroke", &json!({"ids": [series_id.0], "color": "#0000ff"})).unwrap();
+        s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
+        let spec = s.doc().unwrap().doc.node(id).unwrap().graph.as_deref().unwrap().clone();
+        let blue = Paint::solid(vectorcraft_color::Color::rgb(0.0, 0.0, 1.0));
+        assert_eq!(spec.series_paints[0].stroke, Some(blue.clone()));
+        assert!(spec.series_paints[0].fill.is_none());
+        let bar = &group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap()[0];
+        assert_eq!(bar.appearance.fill_paint().color(), Some(super::default_series_color(0)));
+        assert_eq!(bar.appearance.stroke_paint(), blue);
+
+        let id = graph(&mut s, "line");
+        let marker = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap()[1].id;
+        s.execute("paint.setFill", &json!({"ids": [marker.0], "color": "#ff0000"})).unwrap();
+        s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
+        let spec = s.doc().unwrap().doc.node(id).unwrap().graph.as_deref().unwrap().clone();
+        assert!(spec.series_paints[0].stroke.is_none());
+        let series = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap();
+        assert_eq!(series[0].appearance.stroke_paint().color(), Some(super::default_series_color(0)));
+        assert_eq!(series[1].appearance.fill_paint().color(), Some(vectorcraft_color::Color::rgb(1.0, 0.0, 0.0)));
+    }
+
+    #[test]
+    fn a_gradient_fill_survives_regeneration() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({})).unwrap();
+        let id = graph(&mut s, "column");
+        let series_id = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
+        s.execute(
+            "paint.setFill",
+            &json!({"ids": [series_id.0], "gradient": {"kind": "linear", "stops": [{"offset": 0, "color": "#ff0000"}, {"offset": 1, "color": "#0000ff"}]}}),
+        )
+        .unwrap();
+        s.execute("graph.setData", &json!({"rows": [[2, 3], [4, 5]]})).unwrap();
+        let spec = s.doc().unwrap().doc.node(id).unwrap().graph.as_deref().unwrap().clone();
+        assert!(matches!(spec.series_paints[0].fill, Some(Paint::Gradient(_))));
+        let bar = &group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap()[0];
+        assert!(matches!(bar.appearance.fill_paint(), Paint::Gradient(_)));
+    }
+
+    #[test]
+    fn a_series_named_legend_keeps_its_own_index_and_an_empty_series_is_omitted() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({})).unwrap();
+        let csv = ",Legend,Axes\nQ1,3,2\nQ2,5,4";
+        let id = NodeId(s.execute("graph.create", &json!({"type": "column", "x": 0, "y": 0, "csv": csv})).unwrap()["id"].as_u64().unwrap());
+        let legend_id = {
+            let n = s.doc().unwrap().doc.node(id).unwrap();
+            let legend = series(n, 0);
+            assert_eq!(legend.name.as_deref(), Some("Legend"));
+            assert!(n.children().unwrap().iter().any(|c| c.name.as_deref() == Some("Legend") && c.series_index.is_none()));
+            assert!(n.children().unwrap().iter().any(|c| c.name.as_deref() == Some("Axes") && c.series_index.is_none()));
+            legend.id
+        };
+        s.execute("paint.setFill", &json!({"ids": [legend_id.0], "color": "#ff0000"})).unwrap();
+        s.execute("graph.setData", &json!({"csv": csv})).unwrap();
+        let n = s.doc().unwrap().doc.node(id).unwrap();
+        assert_eq!(n.graph.as_ref().unwrap().series_paints[0].fill.as_ref().and_then(Paint::color).unwrap().to_hex(), "#ff0000");
+        assert!(n.graph.as_ref().unwrap().series_paints.get(1).is_none_or(|p| p.fill.is_none()));
+        assert_eq!(series(n, 0).children().unwrap()[0].appearance.fill_paint().color().unwrap().to_hex(), "#ff0000");
+        assert_eq!(series(n, 1).name.as_deref(), Some("Axes"));
+        assert_ne!(series(n, 1).children().unwrap()[0].appearance.fill_paint().color().unwrap().to_hex(), "#ff0000");
+
+        let id = graph(&mut s, "pie");
+        s.execute("graph.setType", &json!({"id": id.0, "legend": false})).unwrap();
+        s.execute("graph.setData", &json!({"id": id.0, "csv": ",Keep,Drop\nQ1,4,0\nQ2,2,0"})).unwrap();
+        let n = s.doc().unwrap().doc.node(id).unwrap();
+        assert!(n.children().unwrap().iter().any(|c| c.name.as_deref() == Some("Keep")));
+        assert!(n.children().unwrap().iter().all(|c| c.name.as_deref() != Some("Drop")));
+        let keep = group(n, "Keep").id;
+        s.execute("paint.setFill", &json!({"ids": [keep.0], "color": "#00ff00"})).unwrap();
+        s.execute("graph.setData", &json!({"id": id.0, "rows": [[8, 0], [1, 0]]})).unwrap();
+        let n = s.doc().unwrap().doc.node(id).unwrap();
+        assert_eq!(group(n, "Keep").series_index, Some(0));
+        assert_eq!(n.graph.as_ref().unwrap().series_paints[0].fill.as_ref().and_then(Paint::color).unwrap().to_hex(), "#00ff00");
+        assert!(n.children().unwrap().iter().all(|c| c.name.as_deref() != Some("Drop")));
+    }
+
    #[test]
    fn csv_parsing() {
        let (s, c, r) = super::parse_csv("\t2024\t2025\nQ1\t1\t2\nQ2\t3\t4\n");
@@ -135,7 +135,7 @@ pub fn specs() -> Vec<CommandSpec> {
            "Artboard Options…",
            ["Window", "Artboards"],
            None,
-            "{index, name?, x?, y?, width?, height?, scaleArt?: bool (Scale Artwork with Artboard: resized, the artboard takes the art fully inside it (locked and hidden art only with lockedAndHidden?: bool, default prefs moveLockedWithArtboard) and its guides from its old rectangle onto the new one, each side by its own ratio; strokes/corners/patterns as object.scale)} → null, or with scaleArt {scaled: the art scaled}",
+            "{index, name?, x?, y?, width?, height?, moveArt?: bool (default false; a position-only change moves the contained art with its artboard), scaleArt?: bool (Scale Artwork with Artboard: resized, the artboard takes the art fully inside it (locked and hidden art only with lockedAndHidden?: bool, default prefs moveLockedWithArtboard) and its guides from its old rectangle onto the new one, each side by its own ratio; strokes/corners/patterns as object.scale)} → null, or with scaleArt {scaled: the art scaled}",
            has_doc,
            artboard_set
        ),
@@ -771,8 +771,13 @@ fn artboard_set(s: &mut Session, p: &Value) -> Result<Value> {
    // Artboard gathers it) and its guides from the old rectangle onto the new one.
    let scale_art = bool_or(p, "scaleArt", false);
    let fit = if scale_art && resized { rect_map(was, now) } else { None };
-    let art = if fit.is_some() {
-        // Locked and hidden art too? Noted in the journal, so a replay scales the same objects
+    // Position fields honor Move Artwork independently of Scale Artwork. A resize still
+    // leaves the art alone unless scaling was requested. Fit-to-art callers keep the default.
+    let delta = now.origin() - was.origin();
+    let moving = !resized && bool_or(p, "moveArt", false) && delta != vectorcraft_geom::Vec2::ZERO;
+    let transform = fit.or_else(|| moving.then(|| Affine::translate(delta)));
+    let art = if transform.is_some() {
+        // Locked and hidden art too? Noted in the journal, so a replay transforms the same objects
        // whatever the preference is then.
        let all = bool_or(p, "lockedAndHidden", s.prefs.move_locked_with_artboard);
        s.note_journal("lockedAndHidden", json!(all));
@@ -792,7 +797,7 @@ fn artboard_set(s: &mut Session, p: &Value) -> Result<Value> {
            a.name = n.to_string();
        }
        let id = a.id;
-        if let Some(xf) = fit {
+        if let Some(xf) = transform {
            d.map_artboard_guides(id, xf);
            for id in &art {
                if let Some(n) = d.node_mut(*id) {
@@ -801,14 +806,14 @@ fn artboard_set(s: &mut Session, p: &Value) -> Result<Value> {
            }
        } else if !resized {
            // Moved (not resized), it takes its guides along.
-            d.move_artboard_guides(id, now.origin() - was.origin());
+            d.move_artboard_guides(id, delta);
        }
        Ok(())
    })?;
    if !scale_art {
        return ok();
    }
-    Ok(json!({ "scaled": art.iter().map(|i| i.0).collect::<Vec<_>>() }))
+    Ok(json!({ "scaled": if fit.is_some() { art.iter().map(|i| i.0).collect::<Vec<_>>() } else { vec![] } }))
 }

 /// The map taking artboard rectangle `from` onto `to`, each side scaled by its own ratio. None
@@ -4,7 +4,7 @@ use serde_json::{Value, json};
 use vectorcraft_color::{BlendMode, Color, GradientPaint, Paint};
 use vectorcraft_doc::{Appearance, CharStyle, Document, Node, NodeId, NodeKind};

-use super::appearance::{ItemTarget, appearance_targets, edit_items, item_target};
+use super::appearance::{ItemTarget, appearance_targets, edit_items, edit_items_then, item_target};
 use super::gradient::{item_paint_bounds, place_paint, place_run_paint, run_paint_mut, run_stroke_weight, unplaced};
 use super::*;
 use crate::{DocState, EngineError};
@@ -385,30 +385,44 @@ fn apply_paint(s: &mut Session, p: &Value, paint: Paint, fill: bool) -> Result<V
        s.fill_active = fill;
    }
    let item = item_target(s, p, cmd)?.of_kind(s, fill);
-    let ids = item.targets(s, p)?;
-    edit_items(s, &ids, item, cmd, if fill { "Fill Color" } else { "Stroke Color" }, fill, |n, index| {
-        if index.is_none()
-            && let NodeKind::Text(t) = &mut n.kind
-        {
-            let (xf, lb) = (t.xf, t.local_bounds());
-            for r in &mut t.runs {
-                if !fill && !paint.is_none() {
-                    run_stroke_weight(&mut r.style);
+    let selected = item.targets(s, p)?;
+    let ids = super::graph::paint_targets(&s.doc()?.doc, &selected);
+    let label = if fill { "Fill Color" } else { "Stroke Color" };
+    edit_items_then(
+        s,
+        &ids,
+        item,
+        cmd,
+        label,
+        fill,
+        |n, index| {
+            if index.is_none()
+                && let NodeKind::Text(t) = &mut n.kind
+            {
+                let (xf, lb) = (t.xf, t.local_bounds());
+                for r in &mut t.runs {
+                    if !fill && !paint.is_none() {
+                        run_stroke_weight(&mut r.style);
+                    }
+                    let (cur, b) = run_paint_mut(r, !fill, lb);
+                    *cur = place_run_paint(&paint, p, xf, b);
                }
-                let (cur, b) = run_paint_mut(r, !fill, lb);
-                *cur = place_run_paint(&paint, p, xf, b);
+                return Ok(());
            }
-            return Ok(());
-        }
-        // A missing top fill or stroke is created first: a new stroke's weight sizes the box its
-        // gradient fits.
-        if n.appearance.paint_at(index, fill).is_none() {
-            n.appearance.set_paint_at(index, fill, Paint::None);
-        }
-        let placed = place_paint(&paint, p, item_paint_bounds(n, index, fill));
-        n.appearance.set_paint_at(index, fill, placed);
-        Ok(())
-    })?;
+            // A missing top fill or stroke is created first: a new stroke's weight sizes the box its
+            // gradient fits.
+            if n.appearance.paint_at(index, fill).is_none() {
+                n.appearance.set_paint_at(index, fill, Paint::None);
+            }
+            let placed = place_paint(&paint, p, item_paint_bounds(n, index, fill));
+            n.appearance.set_paint_at(index, fill, placed);
+            Ok(())
+        },
+        |d, changed| {
+            super::graph::capture_series_paints(d, changed, fill);
+            Ok(())
+        },
+    )?;
    s.remember_paint(&paint);
    ok()
 }
@@ -1,6 +1,7 @@
-//! The Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Sharpen ›
-//! Unsharp Mask): 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.
+//! The Photoshop-style raster effects (Effect › Blur › Radial Blur and Smart Blur, Pixelate ›
+//! Color Halftone, Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask): 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.

 use serde_json::{Value, json};
 use vectorcraft_doc::NodeKind;
@@ -16,6 +17,10 @@ const EFFECTS: [(&str, &str); 3] = [
    ("sharpen.unsharpMask", r#"{"amount": 300, "radius": 3}"#),
 ];

+/// Effect › Pixelate, at their defaults.
+const PIXELATE: [(&str, &str); 4] =
+    [("pixelate.colorHalftone", "{}"), ("pixelate.crystallize", "{}"), ("pixelate.mezzotint", "{}"), ("pixelate.pointillize", "{}")];
+
 /// 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();
@@ -52,6 +57,10 @@ 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}");
+    }
    // Junk parameters are stored as given and read clamped; the canvas still draws.
    for (id, _) in EFFECTS {
        s.execute("effect.apply", &json!({"effect": id, "ids": [g], "params": {"amount": 1e308, "radius": -1e308, "threshold": "x", "quality": 7}}))
@@ -71,7 +80,7 @@ fn listed_applied_edited_and_undone() {

 #[test]
 fn each_effect_changes_the_canvas_and_draws_the_same_twice() {
-    for (id, params) in EFFECTS {
+    for (id, params) in EFFECTS.into_iter().chain(PIXELATE) {
        let (mut s, g) = striped();
        let plain = render(&s);
        let params: Value = serde_json::from_str(params).unwrap();
@@ -100,7 +109,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 {
+    for (id, params) in EFFECTS.into_iter().chain(PIXELATE) {
        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();
@@ -371,6 +371,52 @@ fn artboard_set_props_scales_art_only_when_asked_and_resized() {
    assert!(s.execute("artboard.setProps", &json!({"index": 9, "width": 10, "scaleArt": true})).is_err());
 }

+/// Move Artwork is independent of scaling and takes only fully contained art and board guides.
+#[test]
+fn coordinate_moves_honor_move_art_and_keep_resize_behavior() {
+    let mut s = session();
+    let inside = rect(&mut s, 100.0, 100.0, 200.0, 100.0);
+    s.execute("stroke.set", &json!({"weight": 4})).unwrap();
+    let partly = rect(&mut s, 700.0, 500.0, 200.0, 200.0);
+    s.execute("guide.add", &json!({"vertical": true, "pos": 400, "artboard": 0})).unwrap();
+    s.execute("guide.add", &json!({"vertical": true, "pos": 400})).unwrap();
+    let before = s.doc().unwrap().doc.clone();
+    for scale in [false, true] {
+        let out = s.execute("artboard.setProps", &json!({"index": 0, "x": 30, "y": -10, "moveArt": true, "scaleArt": scale})).unwrap();
+        assert_eq!(bounds(&s, inside), Rect::new(130.0, 90.0, 330.0, 190.0));
+        assert_eq!(bounds(&s, partly), Rect::new(700.0, 500.0, 900.0, 700.0));
+        assert_eq!(stroke_width(&s, inside), 4.0);
+        assert_eq!(guide_positions(&s), vec![430.0, 400.0]);
+        assert_eq!(out, if scale { json!({"scaled": []}) } else { Value::Null });
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(*s.doc().unwrap().doc, *before);
+    }
+    for p in [json!({"index": 0, "x": 30, "moveArt": false}), json!({"index": 0, "x": 30, "width": 400, "moveArt": true})] {
+        s.execute("artboard.setProps", &p).unwrap();
+        assert_eq!(bounds(&s, inside), Rect::new(100.0, 100.0, 300.0, 200.0));
+        s.execute("edit.undo", &json!({})).unwrap();
+    }
+}
+
+#[test]
+fn coordinate_moves_journal_the_locked_art_preference() {
+    let mut s = session();
+    let locked = rect(&mut s, 100.0, 100.0, 200.0, 100.0);
+    s.execute("object.lock", &json!({})).unwrap();
+    s.execute("artboard.setProps", &json!({"index": 0, "x": 30, "moveArt": true})).unwrap();
+    assert_eq!(bounds(&s, locked), Rect::new(100.0, 100.0, 300.0, 200.0));
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.prefs.move_locked_with_artboard = true;
+    s.execute("artboard.setProps", &json!({"index": 0, "x": 30, "moveArt": true})).unwrap();
+    assert_eq!(bounds(&s, locked), Rect::new(130.0, 100.0, 330.0, 200.0));
+    let (id, p) = s.journal.last().unwrap().clone();
+    assert_eq!(p["lockedAndHidden"], true);
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.prefs.move_locked_with_artboard = false;
+    s.execute(&id, &p).unwrap();
+    assert_eq!(bounds(&s, locked), Rect::new(130.0, 100.0, 330.0, 200.0));
+}
+
 /// Locked and hidden art scales only with Move Locked and Hidden Artwork with Artboard, as it
 /// moves only with it.
 #[test]
@@ -145,3 +145,42 @@ fn several_spreads_preserve_each_board_and_leave_room_between_spreads() {
    assert_eq!(loaded.doc.artboards[0].rect, Rect::new(0.0, 0.0, 100.0, 60.0));
    assert_eq!(loaded.doc.artboards[1].rect, Rect::new(136.0, 0.0, 236.0, 60.0));
 }
+
+/// Coordinate fields use setProps rather than the drag tool's artboard.move command.
+#[test]
+fn coordinate_edits_move_imported_clipping_groups_and_undo_together() {
+    use serde_json::json;
+    use vectorcraft_engine::Session;
+    use vectorcraft_geom::Vec2;
+
+    for current in [false, true] {
+        let child = shape(20, "Oversized", false, false, [-10.0, -10.0, 110.0, 70.0], IDENTITY, vec![]);
+        let mut first = shape(10, "First", true, false, [0.0, 0.0, 100.0, 60.0], IDENTITY, vec![child]);
+        if current {
+            let F::Def(_, _, fields) = &mut first else { panic!() };
+            fields.retain(|(t, _)| *t != tag(b"ABEn"));
+            fields.push(field(b"phrp", F::Def(18, vec![tag(b"aprp")], vec![])));
+        }
+        let second = shape(30, "Second", true, false, [0.0, 0.0, 40.0, 60.0], [1.0, 0.0, 200.0, 0.0, 1.0, 0.0], vec![]);
+        let loaded = vectorcraft_engine::cmd::fileio::load("synthetic.af", &document(vec![vec![first, second]], 72.0, Method::Zstd)).unwrap();
+        let mut s = Session::new();
+        s.add_document(loaded.doc, None);
+        let before = s.doc().unwrap().doc.clone();
+        let first_bounds = find(&before.layers, "First").unwrap().geometric_bounds().unwrap();
+        let second_node = find(&before.layers, "Second").unwrap().clone();
+        let child_bounds = find(&before.layers, "First").unwrap().children().unwrap()[1].geometric_bounds().unwrap();
+        let delta = Vec2::new(13.0, -7.0);
+        s.execute("artboard.setProps", &json!({"index": 0, "x": 13, "y": -7, "moveArt": true})).unwrap();
+        let after = s.doc().unwrap().doc.clone();
+        assert_eq!(after.artboards[0].rect, before.artboards[0].rect + delta);
+        let first = find(&after.layers, "First").unwrap();
+        assert_eq!(first.geometric_bounds().unwrap(), first_bounds + delta);
+        assert_eq!(first.children().unwrap()[1].geometric_bounds().unwrap(), child_bounds + delta);
+        assert_eq!(find(&after.layers, "Second").unwrap(), &second_node);
+        assert_eq!(after.artboards[1], before.artboards[1]);
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(*s.doc().unwrap().doc, *before);
+        s.execute("edit.redo", &json!({})).unwrap();
+        assert_eq!(*s.doc().unwrap().doc, *after);
+    }
+}
@@ -278,6 +278,10 @@ fn structured_junk() {
        ("effect.apply", json!({"effect": "blur.radial", "params": {"amount": 1e308, "method": 5, "quality": "best"}})),
        ("effect.apply", json!({"effect": "blur.smart", "params": {"radius": 1e308, "threshold": -1e308, "quality": null}})),
        ("effect.apply", json!({"effect": "sharpen.unsharpMask", "params": {"amount": -1, "radius": "1e999", "threshold": 1e308}})),
+        ("effect.apply", json!({"effect": "pixelate.colorHalftone", "params": {"maxRadius": 1e308, "channel1": "1e999", "channel4": null}})),
+        ("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": "no.such.effect"})),
        ("effect.remove", json!({"index": 99})),
        ("effect.setParams", json!({"index": 0, "params": null})),
@@ -595,7 +595,13 @@ impl Renderer {
        off.flush();
        let mut pm = vello_cpu::Pixmap::new(wu, hu);
        off.render(&mut pm, &mut self.resources);
-        let space = effects::PixelSpace { to_doc, px, center: content.reach.center() };
+        let channels = match f.ink {
+            Ink::Cmy => effects::pixel::Channels::CmyPlane,
+            Ink::K => effects::pixel::Channels::KPlane,
+            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 };
        let (wz, hz) = (wu as usize, hu as usize);
        for fx in chain {
            match fx {
@@ -35,5 +35,6 @@ fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
            p[k] = json!(d.f64(k, 0.0));
        }
    }
+    p["moveArt"] = json!(crate::panels::artboards::move_art(app));
    run_and_close(app, "artboard.setProps", p)
 }
@@ -159,6 +159,7 @@ fn choices(effect: &str, key: &str) -> Option<form::Choices> {
        ("blur.radial", "method") => Some(&[("Spin", "spin"), ("Zoom", "zoom")]),
        ("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),
        ("path.offsetPath", "joins") => Some(&[("Miter", "miter"), ("Round", "round"), ("Bevel", "bevel")]),
        ("distort.roughen" | "distort.zigZag", "points") => Some(&[("Smooth", "smooth"), ("Corner", "corner")]),
        _ => None,
@@ -350,6 +350,11 @@ pub(super) fn humanize(k: &str) -> String {
        "Sy" => "Vertical %".into(),
        "Radius1" => "Radius 1".into(),
        "Radius2" => "Radius 2".into(),
+        "Max Radius" => "Max. Radius:".into(),
+        "Channel1" => "Channel 1:".into(),
+        "Channel2" => "Channel 2:".into(),
+        "Channel3" => "Channel 3:".into(),
+        "Channel4" => "Channel 4:".into(),
        "Include Cmy Blacks" => "Include Blacks with CMY:".into(),
        "Align To Path" => "Align to Path:".into(),
        _ => format!("{s}:"),
@@ -168,7 +168,15 @@ fn effect_preview_is_kept_as_one_undo_step() {

 #[test]
 fn raster_filter_dialogs_preview_and_apply() {
-    for (effect, key, value) in [("blur.radial", "method", "zoom"), ("blur.smart", "quality", "high"), ("sharpen.unsharpMask", "amount", "120")] {
+    for (effect, key, value) in [
+        ("blur.radial", "method", "zoom"),
+        ("blur.smart", "quality", "high"),
+        ("sharpen.unsharpMask", "amount", "120"),
+        ("pixelate.colorHalftone", "channel1", "30"),
+        ("pixelate.crystallize", "cellSize", "20"),
+        ("pixelate.mezzotint", "type", "longLines"),
+        ("pixelate.pointillize", "cellSize", "12"),
+    ] {
        let mut app = app();
        let id = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap()["id"].as_u64().unwrap();
        app.run("select.all", json!({})).unwrap();
@@ -188,6 +196,13 @@ fn raster_filter_dialogs_preview_and_apply() {
    let ranks: Vec<usize> = ["radius", "threshold", "quality"].iter().map(|k| super::effect::doc_rank(doc, k)).collect();
    assert!(ranks.windows(2).all(|w| w[0] < w[1]), "{ranks:?}");
    assert_eq!(super::effect::doc_rank(doc, "nope"), usize::MAX);
+    let doc = vectorcraft_effects::effect_info("pixelate.colorHalftone").unwrap().params;
+    let ranks: Vec<usize> = ["maxRadius", "channel1", "channel2", "channel3", "channel4"].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:?}");
+    // Labels as the dialogs show them.
+    assert_eq!(super::form::humanize("maxRadius"), "Max. Radius:");
+    assert_eq!(super::form::humanize("channel3"), "Channel 3:");
+    assert_eq!(super::form::humanize("cellSize"), "Cell Size:");
 }

 #[test]
@@ -446,3 +461,26 @@ fn the_transform_effect_dialog_has_its_controls_previews_them_and_shows_them_aga
    let text = crate::tests_labels::painted_text(&mut app, |app, ui| show(app, ui.ctx()));
    assert!(text.lines().any(|l| l == "Reference Point"), "{text}");
 }
+
+#[test]
+fn artboard_options_position_moves_art_only_with_the_tool_option_on() {
+    for move_art in [false, true] {
+        let mut app = app();
+        let id = app.run("shape.rectangle", json!({"x": 10, "y": 20, "width": 30, "height": 40})).unwrap()["id"].as_u64().unwrap();
+        app.select_tool("artboard");
+        app.session.set_tool_option("moveArt", &json!(move_art));
+        crate::dialogs::artboard_options::open(&mut app).unwrap();
+        app.ui.dialog.as_mut().unwrap().fields.insert("x".into(), json!(50));
+        // Draw the dialog once and confirm through its registry, as the OK button does.
+        frame(&mut app, Default::default());
+        let before = app.session.doc().unwrap().doc.clone();
+        super::confirm(&mut app).unwrap();
+        assert_eq!(app.session.doc().unwrap().doc.artboards[0].rect.x0, 50.0);
+        assert_eq!(
+            app.session.doc().unwrap().doc.node(vectorcraft_doc::NodeId(id)).unwrap().geometric_bounds().unwrap().x0,
+            if move_art { 60.0 } else { 10.0 }
+        );
+        app.run("edit.undo", json!({})).unwrap();
+        assert_eq!(*app.session.doc().unwrap().doc, *before);
+    }
+}
@@ -652,3 +652,8 @@
 	Smart Blur…	Chytré rozostření…
 	Sharpen	Zostření
 	Unsharp Mask…	Maska rozostření…
+	Pixelate	Pixelizace
+	Color Halftone…	Barevný polotón…
+	Crystallize…	Krystalizace…
+	Mezzotint…	Mezzotinta…
+	Pointillize…	Pointilismus…
@@ -21,6 +21,31 @@
 	Smart Blur…	Desenfoque inteligente…
 	Sharpen	Enfocar
 	Unsharp Mask…	Máscara de enfoque…
+	Pixelate	Pixelizar
+	Color Halftone…	Semitono de color…
+	Crystallize…	Cristalizar…
+	Mezzotint…	Grabado a media tinta…
+	Pointillize…	Puntillismo…
+	Color Halftone	Semitono de color
+	Crystallize	Cristalizar
+	Mezzotint	Grabado a media tinta
+	Pointillize	Puntillismo
+	Max. Radius	Radio máx.
+	Channel 1	Canal 1
+	Channel 2	Canal 2
+	Channel 3	Canal 3
+	Channel 4	Canal 4
+	Cell Size	Tamaño de celda
+	Fine Dots	Puntos finos
+	Medium Dots	Puntos medios
+	Grainy Dots	Puntos granulados
+	Coarse Dots	Puntos gruesos
+	Short Lines	Líneas cortas
+	Medium Lines	Líneas medias
+	Long Lines	Líneas largas
+	Short Strokes	Trazos cortos
+	Medium Strokes	Trazos medios
+	Long Strokes	Trazos largos
 	Radial Blur	Desenfoque radial
 	Smart Blur	Desenfoque inteligente
 	Unsharp Mask	Máscara de enfoque
@@ -22,6 +22,31 @@
 	Smart Blur…	Flou intelligent…
 	Sharpen	Netteté
 	Unsharp Mask…	Masque de netteté…
+	Pixelate	Pixellisation
+	Color Halftone…	Demi-teintes couleur…
+	Crystallize…	Cristalliser…
+	Mezzotint…	Manière noire…
+	Pointillize…	Pointillisme…
+	Color Halftone	Demi-teintes couleur
+	Crystallize	Cristalliser
+	Mezzotint	Manière noire
+	Pointillize	Pointillisme
+	Max. Radius	Rayon max.
+	Channel 1	Couche 1
+	Channel 2	Couche 2
+	Channel 3	Couche 3
+	Channel 4	Couche 4
+	Cell Size	Taille de cellule
+	Fine Dots	Points fins
+	Medium Dots	Points moyens
+	Grainy Dots	Points granuleux
+	Coarse Dots	Gros points
+	Short Lines	Lignes courtes
+	Medium Lines	Lignes moyennes
+	Long Lines	Lignes longues
+	Short Strokes	Traits courts
+	Medium Strokes	Traits moyens
+	Long Strokes	Traits longs
 	Radial Blur	Flou radial
 	Smart Blur	Flou intelligent
 	Unsharp Mask	Masque de netteté
@@ -21,6 +21,31 @@
 	Smart Blur…	Sfocatura intelligente…
 	Sharpen	Nitidezza
 	Unsharp Mask…	Maschera di contrasto…
+	Pixelate	Effetto pixel
+	Color Halftone…	Mezzetinte colore…
+	Crystallize…	Cristallizza…
+	Mezzotint…	Mezzatinta…
+	Pointillize…	Puntinismo…
+	Color Halftone	Mezzetinte colore
+	Crystallize	Cristallizza
+	Mezzotint	Mezzatinta
+	Pointillize	Puntinismo
+	Max. Radius	Raggio max.
+	Channel 1	Canale 1
+	Channel 2	Canale 2
+	Channel 3	Canale 3
+	Channel 4	Canale 4
+	Cell Size	Dimensione cella
+	Fine Dots	Punti fini
+	Medium Dots	Punti medi
+	Grainy Dots	Punti granulosi
+	Coarse Dots	Punti grossi
+	Short Lines	Linee corte
+	Medium Lines	Linee medie
+	Long Lines	Linee lunghe
+	Short Strokes	Tratti corti
+	Medium Strokes	Tratti medi
+	Long Strokes	Tratti lunghi
 	Radial Blur	Sfocatura radiale
 	Smart Blur	Sfocatura intelligente
 	Unsharp Mask	Maschera di contrasto
@@ -3217,6 +3217,31 @@ theme	Appearance	外観
 	Smart Blur…	ぼかし (詳細)…
 	Sharpen	シャープ
 	Unsharp Mask…	アンシャープマスク…
+	Pixelate	ピクセレート
+	Color Halftone…	カラーハーフトーン…
+	Crystallize…	結晶化…
+	Mezzotint…	メゾティント…
+	Pointillize…	点描…
+	Color Halftone	カラーハーフトーン
+	Crystallize	結晶化
+	Mezzotint	メゾティント
+	Pointillize	点描
+	Max. Radius	最大半径
+	Channel 1	チャンネル 1
+	Channel 2	チャンネル 2
+	Channel 3	チャンネル 3
+	Channel 4	チャンネル 4
+	Cell Size	セルの大きさ
+	Fine Dots	細かい点
+	Medium Dots	中程度の点
+	Grainy Dots	粒状の点
+	Coarse Dots	粗い点
+	Short Lines	短い線
+	Medium Lines	中程度の線
+	Long Lines	長い線
+	Short Strokes	短いストローク
+	Medium Strokes	中程度のストローク
+	Long Strokes	長いストローク
 	Radial Blur	ぼかし (放射状)
 	Smart Blur	ぼかし (詳細)
 	Unsharp Mask	アンシャープマスク
@@ -2713,3 +2713,8 @@
 	Smart Blur…	Desfoque Inteligente…
 	Sharpen	Nitidez
 	Unsharp Mask…	Máscara de Nitidez…
+	Pixelate	Pixelizar
+	Color Halftone…	Meio-Tom Colorido…
+	Crystallize…	Cristalizar…
+	Mezzotint…	Meia-Tinta…
+	Pointillize…	Pontilhar…
@@ -19,6 +19,31 @@
 	Smart Blur…	Умное размытие…
 	Sharpen	Резкость
 	Unsharp Mask…	Нерезкая маска…
+	Pixelate	Пикселизация
+	Color Halftone…	Цветные полутона…
+	Crystallize…	Кристаллизация…
+	Mezzotint…	Меццо-тинто…
+	Pointillize…	Пуантилизм…
+	Color Halftone	Цветные полутона
+	Crystallize	Кристаллизация
+	Mezzotint	Меццо-тинто
+	Pointillize	Пуантилизм
+	Max. Radius	Макс. радиус
+	Channel 1	Канал 1
+	Channel 2	Канал 2
+	Channel 3	Канал 3
+	Channel 4	Канал 4
+	Cell Size	Размер ячейки
+	Fine Dots	Мелкие точки
+	Medium Dots	Средние точки
+	Grainy Dots	Зернистые точки
+	Coarse Dots	Крупные точки
+	Short Lines	Короткие линии
+	Medium Lines	Средние линии
+	Long Lines	Длинные линии
+	Short Strokes	Короткие штрихи
+	Medium Strokes	Средние штрихи
+	Long Strokes	Длинные штрихи
 	Radial Blur	Радиальное размытие
 	Smart Blur	Умное размытие
 	Unsharp Mask	Нерезкая маска
@@ -20,6 +20,31 @@
 	Smart Blur…	Розумне розмиття…
 	Sharpen	Різкість
 	Unsharp Mask…	Нерізка маска…
+	Pixelate	Пікселізація
+	Color Halftone…	Кольорові півтони…
+	Crystallize…	Кристалізація…
+	Mezzotint…	Меццо-тинто…
+	Pointillize…	Пуантилізм…
+	Color Halftone	Кольорові півтони
+	Crystallize	Кристалізація
+	Mezzotint	Меццо-тинто
+	Pointillize	Пуантилізм
+	Max. Radius	Макс. радіус
+	Channel 1	Канал 1
+	Channel 2	Канал 2
+	Channel 3	Канал 3
+	Channel 4	Канал 4
+	Cell Size	Розмір комірки
+	Fine Dots	Дрібні точки
+	Medium Dots	Середні точки
+	Grainy Dots	Зернисті точки
+	Coarse Dots	Великі точки
+	Short Lines	Короткі лінії
+	Medium Lines	Середні лінії
+	Long Lines	Довгі лінії
+	Short Strokes	Короткі штрихи
+	Medium Strokes	Середні штрихи
+	Long Strokes	Довгі штрихи
 	Radial Blur	Радіальне розмиття
 	Smart Blur	Розумне розмиття
 	Unsharp Mask	Нерізка маска
@@ -3468,6 +3468,31 @@ axis	Both	两者
 	Smart Blur…	智能模糊…
 	Sharpen	锐化
 	Unsharp Mask…	反锐化遮罩…
+	Pixelate	像素化
+	Color Halftone…	彩色半调…
+	Crystallize…	晶格化…
+	Mezzotint…	铜版雕刻…
+	Pointillize…	点彩…
+	Color Halftone	彩色半调
+	Crystallize	晶格化
+	Mezzotint	铜版雕刻
+	Pointillize	点彩
+	Max. Radius	最大半径
+	Channel 1	色版 1
+	Channel 2	色版 2
+	Channel 3	色版 3
+	Channel 4	色版 4
+	Cell Size	单元格大小
+	Fine Dots	细点
+	Medium Dots	中等点
+	Grainy Dots	颗粒点
+	Coarse Dots	粗点
+	Short Lines	短线
+	Medium Lines	中等线
+	Long Lines	长线
+	Short Strokes	短笔画
+	Medium Strokes	中等笔画
+	Long Strokes	长笔画
 	Radial Blur	径向模糊
 	Smart Blur	智能模糊
 	Unsharp Mask	反锐化遮罩
@@ -3246,6 +3246,31 @@ axis	Both	兩者
 	Smart Blur…	智慧型模糊…
 	Sharpen	銳利化
 	Unsharp Mask…	反銳利化遮罩…
+	Pixelate	像素化
+	Color Halftone…	彩色半色調…
+	Crystallize…	結晶化…
+	Mezzotint…	網線銅版…
+	Pointillize…	點描…
+	Color Halftone	彩色半色調
+	Crystallize	結晶化
+	Mezzotint	網線銅版
+	Pointillize	點描
+	Max. Radius	最大半徑
+	Channel 1	色版 1
+	Channel 2	色版 2
+	Channel 3	色版 3
+	Channel 4	色版 4
+	Cell Size	單元大小
+	Fine Dots	細點
+	Medium Dots	中等點
+	Grainy Dots	顆粒點
+	Coarse Dots	粗點
+	Short Lines	短線
+	Medium Lines	中等線
+	Long Lines	長線
+	Short Strokes	短筆畫
+	Medium Strokes	中等筆畫
+	Long Strokes	長筆畫
 	Radial Blur	放射狀模糊
 	Smart Blur	智慧型模糊
 	Unsharp Mask	反銳利化遮罩
@@ -3305,7 +3305,8 @@ fn font_items(english_names: bool) -> Vec<Item> {

 /// The raster effects' submenus of the Effect menu (the Photoshop-style effects, below the
 /// vector effects): (submenu, the catalogue's menu path of its effects).
-const RASTER_MENUS: [(&str, &[&str]); 2] = [("Blur", &["Effect", "Blur"]), ("Sharpen", &["Effect", "Sharpen"])];
+const RASTER_MENUS: [(&str, &[&str]); 3] =
+    [("Blur", &["Effect", "Blur"]), ("Pixelate", &["Effect", "Pixelate"]), ("Sharpen", &["Effect", "Sharpen"])];

 /// The Effect menu, built from the effects catalogue (vector effects), plus raster effects.
 fn effect_menu() -> Vec<Item> {
@@ -30,6 +30,11 @@ pub(crate) fn scale_art(app: &VectorcraftApp) -> bool {
    app.session.tool_id() == "artboard" && app.session.tool_options()["scaleArt"].as_bool().unwrap_or(false)
 }

+/// Whether position edits take their art along, matching the Artboard tool's move option.
+pub(crate) fn move_art(app: &VectorcraftApp) -> bool {
+    app.session.tool_id() == "artboard" && app.session.tool_options()["moveArt"].as_bool().unwrap_or(true)
+}
+
 /// The active artboard (of `n`).
 pub(crate) fn selected(app: &VectorcraftApp, n: usize) -> usize {
    app.view().map_or(0, |v| v.artboard).min(n.saturating_sub(1))
@@ -195,6 +195,7 @@ fn artboard_sections(app: &mut VectorcraftApp, ui: &mut Ui) {
    let n = app.session.active().map_or(0, |d| d.doc.artboards.len());
    let i = super::artboards::selected(app, n);
    let scale_art = super::artboards::scale_art(app);
+    let move_art = super::artboards::move_art(app);
    if let Some(ab) = app.session.active().and_then(|d| d.doc.artboards.get(i)).cloned() {
        // Its name as it is (names are never translated).
        ui.label(egui::RichText::new(&ab.name).size(13.0).color(Tokens::get(ui.ctx()).text));
@@ -207,7 +208,7 @@ fn artboard_sections(app: &mut VectorcraftApp, ui: &mut Ui) {
                for (label, key, v) in [(l1, k1, v1), (l2, k2, v2)] {
                    dim_label(ui, label);
                    if let Some(v) = widgets::num_field(ui, ("ab", key, row), Some(v), units, fw) {
-                        app.run("artboard.setProps", json!({"index": i, key: v, "scaleArt": scale_art})).ok();
+                        app.run("artboard.setProps", json!({"index": i, key: v, "scaleArt": scale_art, "moveArt": move_art})).ok();
                    }
                }
                ui.end_row();
@@ -536,8 +537,12 @@ mod tests {

    /// One frame of the panel with `events` → the texts painted, with their rects.
    fn frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<Event>) -> Vec<(String, Rect)> {
+        panel_frame(app, ctx, events, show)
+    }
+
+    fn panel_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<Event>, draw: fn(&mut VectorcraftApp, &mut Ui)) -> Vec<(String, Rect)> {
        let raw = egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(300.0, 700.0))), events, ..Default::default() };
-        let mut out = ctx.run_ui(raw, |ui| show(app, ui));
+        let mut out = ctx.run_ui(raw, |ui| draw(app, ui));
        out.textures_delta.clear();
        out.shapes
            .iter()
@@ -586,6 +591,41 @@ mod tests {
        assert!(widths.iter().all(|w| (w - widths[0]).abs() < 1.0), "X, rotation, corner radius, opacity: {widths:?}");
    }

+    /// Both panels forward the Move Artwork toggle when their actual X field is edited.
+    #[test]
+    fn artboard_coordinate_fields_move_art_in_properties_and_transform() {
+        for draw in [show as fn(&mut VectorcraftApp, &mut Ui), super::super::transform::show] {
+            for move_art in [false, true] {
+                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": 20, "width": 30, "height": 40})).unwrap()["id"].as_u64().unwrap();
+                app.select_tool("artboard");
+                app.session.set_tool_option("moveArt", &json!(move_art));
+                let ctx = egui::Context::default();
+                panel_frame(&mut app, &ctx, vec![], draw);
+                let texts = panel_frame(&mut app, &ctx, vec![], draw);
+                let label = texts.iter().find(|(t, _)| t == "X:").unwrap().1;
+                let at = egui::pos2(label.right() + 40.0, label.center().y);
+                let press = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
+                panel_frame(&mut app, &ctx, vec![Event::PointerMoved(at), press(true)], draw);
+                panel_frame(&mut app, &ctx, vec![press(false)], draw);
+                panel_frame(
+                    &mut app,
+                    &ctx,
+                    vec![Event::Key { key: egui::Key::ArrowUp, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }],
+                    draw,
+                );
+                let d = &app.session.doc().unwrap().doc;
+                assert_eq!(d.artboards[0].rect.x0, 1.0, "the focused X field steps its position");
+                assert_eq!(d.node(vectorcraft_doc::NodeId(id)).unwrap().geometric_bounds().unwrap().x0, if move_art { 11.0 } else { 10.0 });
+                app.run("edit.undo", json!({})).unwrap();
+                let d = &app.session.doc().unwrap().doc;
+                assert_eq!(d.artboards[0].rect.x0, 0.0);
+                assert_eq!(d.node(vectorcraft_doc::NodeId(id)).unwrap().geometric_bounds().unwrap().x0, 10.0);
+            }
+        }
+    }
+
    /// #530: Edit Artboards shows the active artboard, with New Artboard, Delete Artboard and Exit.
    /// #775: type's Paragraph section has Hyphenate, and its checkbox turns it on.
    #[test]
@@ -58,7 +58,8 @@ fn artboard_fields(app: &mut VectorcraftApp, ui: &mut Ui, index: usize, r: Rect)
    let set = |app: &mut VectorcraftApp, x, y, w, h| {
        let n = artboard_rect(r, refi, x, y, w, h, link);
        let scale_art = crate::panels::artboards::scale_art(app);
-        let p = json!({"index": index, "x": n.x0, "y": n.y0, "width": n.width(), "height": n.height(), "scaleArt": scale_art});
+        let move_art = crate::panels::artboards::move_art(app);
+        let p = json!({"index": index, "x": n.x0, "y": n.y0, "width": n.width(), "height": n.height(), "scaleArt": scale_art, "moveArt": move_art});
        if let Err(e) = app.run("artboard.setProps", p) {
            app.status(e);
        }
@@ -50,6 +50,20 @@ fn effect_menu_has_a_vector_effects_section() {
    assert!(effect.iter().any(|i| matches!(i, Item::Header("Vector Effects"))));
 }

+#[test]
+fn effect_menu_lists_the_pixelate_filters_between_blur_and_sharpen() {
+    let app = app();
+    let entries = menus::menu_entries(&app);
+    let pixelate: Vec<_> = entries.iter().filter(|e| e.path == ["Effect", "Pixelate"]).collect();
+    let labels: Vec<&str> = pixelate.iter().map(|e| e.label.as_str()).collect();
+    assert_eq!(labels, ["Color Halftone…", "Crystallize…", "Mezzotint…", "Pointillize…"]);
+    assert!(pixelate.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("Blur") < at("Pixelate") && at("Pixelate") < at("Sharpen"));
+}
+
 #[test]
 fn library_submenus_are_disabled_placeholders() {
    let app = app();
Author	SHA1	Message	Date
bflatasticandClaude Opus 5.5	9bad0a24ca	Part of gap 2: Effect › Pixelate (Color Halftone, Crystallize, Mezzotint, Pointillize) Four Photoshop-style raster effects on the pixel-filter pipeline (vectorcraft_effects::pixel::pixelate), under a new Effect › Pixelate submenu between Blur and Sharpen in the Raster Effects section: - Color Halftone (maxRadius 4..127, default 8; channel1..channel4 screen angles -360..360, defaults 108/162/90/45): each colour channel is screened at its angle in square cells sized so a dot of Max. Radius fills one; each cell's dot covers the share of the cell that is the channel's coverage-weighted mean there (white stays white, black black). RGB documents screen R, G, B (channels 1 to 3); CMYK documents screen C, M, Y, K inks (channels 1 to 4), also when they are drawn ink plane by ink plane (the K plane uses channel 4). - Crystallize (cellSize 3..300, default 10): every pixel takes the colour at the nearest of one jittered point per cell (exact Voronoi over a 5 x 5 neighbourhood, pruned by distance). - Mezzotint (type: Fine/Medium/Grainy/Coarse Dots, Short/Medium/Long Lines, Short/Medium/Long Strokes; default Fine Dots; a dropdown in the dialog): each channel is turned fully on or off against its own random threshold pattern, so the object becomes pure colours. - Pointillize (cellSize 3..300, default 5): one dot of random size per cell at a jittered point, coloured by the softened object there and as opaque as the object at its centre, stacked in random order over a white canvas where the object is. Lengths are in points (Scale Strokes & Effects scales them) and 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 the pattern's cell indices, no state). Work per pixel is bounded whatever the parameters, which are clamped to their ranges and finite-checked; the halftone's cell grid is capped by the raster's size and a screen finer than 3 pixels leaves the image as it is (its average). PixelSpace gains `channels` so the renderer tells the filters what the channels hold. Catalogue rows with parameter docs, outsets and reaches for cropping, menu entries, dialog labels (Max. Radius, Channel 1-4, Cell Size), the Mezzotint Type dropdown, translations, and tests: parameters and clamping, tone and coverage, CMYK inks, polygon crystals, pure-colour mezzotints with ten distinct patterns, dots on a white canvas, the same result at twice the resolution and when moved, the canvas, PDF and SVG through the engine, the command sweep with junk parameters, the dialogs and the menu. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 15:42:24 +07:00
BFlat	2d6014583a	Merge pull request #923 from callmeBalloch/fix/artboard-artwork-movement Fix artwork movement when editing artboard X/Y coordinates	2026-10-10 15:29:47 +07:00
bflatasticandClaude Opus 5.5	f3f5e38bb6	ROADMAP: the #922 note joins the Last updated list Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 15:06:59 +07:00
Rick	934b65b42a	M11: honor Move Artwork in artboard coordinate edits	2026-10-10 09:49:24 +02:00
BFlat	e1599a16aa	Merge pull request #799 from vbasky/feat/graph-series-palette Colour graph series through Group Selection	2026-10-10 14:37:23 +07:00
bflatasticandClaude Opus 5.5	f21f8a89ce	Graph series: find series art in one pass and ignore indices past the series Painting looked up each selected object's graph by walking up through parent_of, a search of the whole document per level, so a fill or stroke change on a large selection grew with the square of the document. The series art of every graph is now mapped in one pass, and documents with no graph skip the lookup. A series index comes from the file: one past the graph's series grew the graph's series paints to that length. Such a group is no longer taken for a series. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 14:33:41 +07:00
Vikram Bhaskaran	5c9ffc69e8	Colour graph series through Group Selection Group Selection's fill and stroke on a graph series are kept on the graph, separately per series, and reapplied when its data, type or size changes, and through save, open and undo.	2026-10-10 14:33:40 +07:00
BFlat	dd61dfa146	Merge pull request #920 from storytold/feat/885-transform-effect-dialog Part of #885: the Transform effect's dialog takes Transform Each's controls	2026-10-10 14:32:55 +07:00