Fix #787 : raster exports keep translucent edges over opaque art opaque

The renderer composited in 8-bit integers, so where a partly transparent anti-aliased edge crossed opaque art (or a background colour) the result came out at alpha 254 on some pixels, and PNG, TIFF and WebP files were written with an alpha channel. Raster exports (and Save for Web) now composite in floating point (vello_cpu's f32 pipeline, enabled as a feature), offscreen groups, masks and patterns included; the canvas keeps the faster 8-bit path. Co-Authored-By: Claude Opus 5.5 <[email protected]>
Fix #798 : the Curvature tool edits any selected path
2026-10-16 20:26:55 -04:00 · 2026-10-10 11:12:13 +07:00 · 2026-10-10 11:12:10 +07:00 · 2026-10-10 10:52:27 +07:00 · 2026-10-10 10:46:53 +07:00 · 2026-10-10 10:46:45 +07:00
27 changed files with 1126 additions and 66 deletions
@@ -54,7 +54,7 @@ wasmi = { version = "2.0.0", default-features = false, features = ["std", "valid
 wat = "1.228"

 # rendering / formats
-vello_cpu = "0.2"
+vello_cpu = { version = "0.2", features = ["f32_pipeline"] }
 image = { version = "0.25", default-features = false, features = ["png", "jpeg", "webp", "gif", "tiff", "bmp"] }
 usvg = "0.48"
 krilla = "0.8"
@@ -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

@@ -42,7 +42,7 @@ since 2026-10-01.
 | **Bundled content:** brush, symbol, style and swatch libraries | ~30% | Ours are original and generated in code, and far fewer than Illustrator ships; brush and symbol libraries are still missing |
 | **Performance** | unverified | Multithreaded, off-thread rendering and caches are in place. The last budget run (2026-10-01, loaded machine) measured 290 ms for a 50k-path fit against a 16 ms budget. Re-run `vectorcraft-cli perf` on an idle machine |
 | **Robustness** | good, new | ~2,840 tests, property tests, no panics in shipped code (lints, the `guard` safety net, import fuzzing), Data Recovery. Missing: a corpus of real-world files, Windows/Linux/browser QA |
-| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); on macOS the menus are in the system menu bar, laid out as a Mac app's, with the in-window menus as a fallback (`--in-window-menus`; verified on Windows and by cross-compilation, not yet by hand on a Mac); hybrid-graphics laptops render on the power-saving GPU by default on Windows and macOS (#306), and Windows renders through DX12 before Vulkan (#545: Vulkan flickered black on an Intel GPU, DX12 and OpenGL didn't; verified by unit tests and the reporter's runs with `WGPU_BACKEND`), and Linux on the GPU the desktop runs on, since a Wayland compositor may refuse frames from the other one; a window that fails on its GPU while starting up starts again on the next one instead of crashing (#502; the dual-GPU Wayland case is verified by unit tests and cross-compilation, not on such hardware); web drops land in the document they were dropped on (#359); desktop drops carry no pointer position (winit 0.30), so a dropped document opens as a tab of its own and a picture or text is placed in the middle of the view, while the web places anything dropped on the canvas and opens what is dropped off it, as Illustrator does (#472); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); on Linux/Wayland the clipboard reads the compositor's own (data-control) and copied image files paste, but files can't be dropped on the window under Wayland until eframe moves to winit 0.31 (#398; the Wayland side is verified by compilation only); on Linux the Paste menu checks the system clipboard on a background thread, so a clipboard owner that never answers no longer freezes the window, while Windows and macOS keep their quick in-line check (#510; the X11 hang verified by the contributor, here by headless tests); on KDE Plasma 6.3+ under Wayland, pens and pen displays reach the app only under XWayland (`WAYLAND_DISPLAY=`) or with KWin's `KWIN_WAYLAND_EMULATE_TABLET=1`, since winit 0.30 has no Wayland tablet input (#491, not verified on hardware); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) |
+| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); on macOS the menus are in the system menu bar, laid out as a Mac app's, with the in-window menus as a fallback (`--in-window-menus`; verified on Windows and by cross-compilation, not yet by hand on a Mac); hybrid-graphics laptops render on the power-saving GPU by default on Windows and macOS (#306), and Windows starts on Direct3D 12, falling back to OpenGL, and loads no Vulkan driver unless `WGPU_BACKEND` asks for it (#545: Vulkan flickered black on an Intel GPU, DX12 and OpenGL didn't; #806: a faulty Vulkan driver crashed the app before its window appeared; verified by unit tests and the reporter's runs with `WGPU_BACKEND`), and Linux on the GPU the desktop runs on, since a Wayland compositor may refuse frames from the other one; a window that fails on its GPU while starting up starts again on the next one instead of crashing (#502; the dual-GPU Wayland case is verified by unit tests and cross-compilation, not on such hardware); web drops land in the document they were dropped on (#359); desktop drops carry no pointer position (winit 0.30), so a dropped document opens as a tab of its own and a picture or text is placed in the middle of the view, while the web places anything dropped on the canvas and opens what is dropped off it, as Illustrator does (#472); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); on Linux/Wayland the clipboard reads the compositor's own (data-control) and copied image files paste, but files can't be dropped on the window under Wayland until eframe moves to winit 0.31 (#398; the Wayland side is verified by compilation only); on Linux the Paste menu checks the system clipboard on a background thread, so a clipboard owner that never answers no longer freezes the window, while Windows and macOS keep their quick in-line check (#510; the X11 hang verified by the contributor, here by headless tests); on KDE Plasma 6.3+ under Wayland, pens and pen displays reach the app only under XWayland (`WAYLAND_DISPLAY=`) or with KWin's `KWIN_WAYLAND_EMULATE_TABLET=1`, since winit 0.30 has no Wayland tablet input (#491, not verified on hardware); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) |
 | **Agent automation** | beyond Illustrator | Every command, gesture and dialog is drivable over MCP, the CLI and the control channel |
 | **Scrubby numeric fields** | beyond Illustrator | As in Photoshop, dragging a numeric field's label (`W:`, `Opacity:`, the Character panel's icons) left or right steps its value live; one undo step per drag, Escape cancels (#400) |

@@ -128,7 +128,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
    Agent selection commands validate every object id before changing the selection and report the resulting count and ids (#784).
    Clear deletes individual selected compound-path members without deleting their siblings, and explicit object ids work without a selection; Cut still removes the same objects it copies (#786).
  - **Saved selections:** Select ▸ Save Selection… asks for a name and keeps the selection in the document (saved with the file, undoable, up to 25); each one is listed at the bottom of the Select menu and a click selects its objects again; Edit Selection… lists them to rename or delete, applied together on OK. A file's saved selections are capped and checked against its objects when it opens. Not yet: Update Selection and the Layers panel's saved-selection menu.
-  - **Drawing:** Pen, Curvature, anchor tools, Pencil, Paintbrush, Blob Brush, Smooth, Path Eraser, Join. Direction handles dragged with Direct Selection or the Anchor Point tool snap to smart guides, and Shift keeps them at 45° steps from their anchor. The Pen continues any open path from the end clicked, and while drawing, a click on an end of another open path joins the two into one (#776). Every point a drawing tool places snaps to Smart Guides through one snapper (#506): the Pen's and Curvature tool's anchors, the Pencil's ends, the shape tools' start and dragged corner or radius (Rectangle, Rounded Rectangle, Ellipse, Polygon, Star, Line Segment, Arc, Spiral, the grids), the Type tool's click and frame, a new artboard's corners.
+  - **Drawing:** Pen, Curvature, anchor tools, Pencil, Paintbrush, Blob Brush, Smooth, Path Eraser, Join. Direction handles dragged with Direct Selection or the Anchor Point tool snap to smart guides, and Shift keeps them at 45° steps from their anchor. The Pen continues any open path from the end clicked, and while drawing, a click on an end of another open path joins the two into one (#776). The Curvature tool edits any selected path, whatever drew it, keeping its shape except where edited (#798): a click on a point makes it current and a drag moves it, re-curving only its two segments; Alt-click or double-click toggles it smooth or corner and Delete removes it; a click on a segment adds a point without changing the shape; with an end of an open path current, clicks go on from it and its other end closes it (`path.curvatureEdit`). Every point a drawing tool places snaps to Smart Guides through one snapper (#506): the Pen's and Curvature tool's anchors, the Pencil's ends, the shape tools' start and dragged corner or radius (Rectangle, Rounded Rectangle, Ellipse, Polygon, Star, Line Segment, Arc, Spiral, the grids), the Type tool's click and frame, a new artboard's corners.
  - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers). An ellipse's Pie Start and End Angle and Invert Pie (Transform and Properties panels' Ellipse Properties, `object.setLiveShape {pieStart, pieEnd, invertPie}`) cut it as a pie (#812; the on-canvas pie widget is still to come).
  - **Cutting:** Eraser, Scissors, Knife, Mirror & Cut, Line Cut and Rectangle Cut (real geometry, compound paths keep their holes).
  - **Transform:** Rotate, Reflect, Scale, Shear (click or Alt-click snaps the reference point to anchors and centres; Alt-click opens the tool's dialog, and a drag with Alt down at the release, from the press or pressed mid-drag, transforms a copy), Reshape, Free Transform (free and perspective distort and shear, switched by the keys held during a handle drag).
@@ -227,7 +227,7 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | 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 |
 | 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) | 2–4 |
+| 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) |
 | Export for Screens, Asset Export, slices, Save for Web | 3 | 85% | polish only (all four are done) | 2–4 |
 | Print, colour management, separations, flattener | 3 | 80% | print preview fidelity (flattener presets in PDF and print, overprint in PDF and composite print, Print dialog, presets, PostScript, marks, separations, Print Tiling, print overprint/flattener/bitmap options and printer profile are done) | 1–2 |
@@ -52,6 +52,13 @@ impl RasterFx {
    pub fn is_below(&self) -> bool {
        matches!(self, RasterFx::DropShadow { .. } | RasterFx::OuterGlow { .. })
    }
+    /// The blend mode it paints with (shadows and glows).
+    pub fn mode(&self) -> Option<BlendMode> {
+        match self {
+            RasterFx::DropShadow { mode, .. } | RasterFx::OuterGlow { mode, .. } | RasterFx::InnerGlow { mode, .. } => Some(*mode),
+            _ => None,
+        }
+    }
    /// How far this effect reaches beyond `bounds`, what it paints around (Radial Blur reaches
    /// further around larger objects).
    pub fn outset(&self, bounds: Rect) -> f64 {
@@ -36,6 +36,15 @@ pub fn specs() -> Vec<CommandSpec> {
            has_doc,
            curvature
        ),
+        cmd!(
+            "path.curvatureEdit",
+            "Curvature",
+            [],
+            None,
+            "{id, subpath?, op: \"move\"|\"insert\"|\"extend\"|\"close\", anchor?, segment?, t?, end?: \"start\"|\"end\", from?: \"keep\"|\"smooth\"|\"corner\", x?, y?} edit a path as the Curvature tool does, its shape kept elsewhere; the anchor edited becomes the direct-selected one → {anchor}. move: anchor to x, y, re-curving only its two segments; insert: a smooth anchor at t on segment, the shape unchanged (with x, y: then moved there); extend: an open subpath goes on from its end (default) or start to a new end at x, y; close: an open subpath closes from that end. The old end bends into the new segment as from says: keep its curve (default), smooth through its neighbours, or a corner",
+            has_doc,
+            curvature_edit
+        ),
        cmd!(
            "path.removeAnchor",
            "Delete Anchor Point",
@@ -593,6 +602,76 @@ fn curvature(s: &mut Session, p: &Value) -> Result<Value> {
    add_look(s, "Curvature", path_kind(PathData::single(sp)), look, None)
 }

+/// An edit `path.curvatureEdit` makes.
+enum CurvatureOp {
+    Move(usize, Point),
+    Insert(usize, f64, Option<Point>),
+    Extend(Point),
+    Close,
+}
+
+fn curvature_edit(s: &mut Session, p: &Value) -> Result<Value> {
+    use vectorcraft_tools::draw2::{EndCurve, curvature_close, curvature_extend, curvature_insert, curvature_move};
+    const C: &str = "path.curvatureEdit";
+    let id = id_param(p, "id").ok_or_else(|| bad(C, "missing id"))?;
+    let si = p.get("subpath").and_then(Value::as_u64).unwrap_or(0) as usize;
+    let at = match (p.get("x").and_then(Value::as_f64), p.get("y").and_then(Value::as_f64)) {
+        (Some(x), Some(y)) if x.is_finite() && y.is_finite() => Some(Point::new(x, y)),
+        (None, None) => None,
+        _ => return Err(bad(C, "x and y must be finite numbers")),
+    };
+    let to = || at.ok_or_else(|| bad(C, "missing x, y"));
+    let start = match str_param(p, "end") {
+        None | Some("end") => false,
+        Some("start") => true,
+        Some(e) => return Err(bad(C, format!("unknown end {e:?}"))),
+    };
+    let how = match str_param(p, "from") {
+        None => EndCurve::Keep,
+        Some(f) => EndCurve::parse(f).ok_or_else(|| bad(C, format!("unknown from {f:?}")))?,
+    };
+    let op = match str_param(p, "op") {
+        Some("move") => CurvatureOp::Move(usize_req(p, "anchor", C)?, to()?),
+        Some("insert") => CurvatureOp::Insert(usize_req(p, "segment", C)?, f64_or(p, "t", 0.5), at),
+        Some("extend") => CurvatureOp::Extend(to()?),
+        Some("close") => CurvatureOp::Close,
+        Some(o) => return Err(bad(C, format!("unknown op {o:?}"))),
+        None => return Err(bad(C, "missing op")),
+    };
+    let anchor = s.edit("Curvature", |d, sel| {
+        let path = path_mut(d, id)?;
+        let sp = path.subpaths.get_mut(si).ok_or_else(|| EngineError::Other("no such subpath".into()))?;
+        if matches!(op, CurvatureOp::Extend(_) | CurvatureOp::Close) && sp.closed {
+            return Err(EngineError::Other("path is already closed".into()));
+        }
+        let ai = match op {
+            CurvatureOp::Move(ai, q) => curvature_move(sp, ai, q).then_some(ai).ok_or_else(|| EngineError::Other("no such anchor".into()))?,
+            CurvatureOp::Insert(seg, t, q) => {
+                let ai = curvature_insert(sp, seg, t).ok_or_else(|| EngineError::Other("no such segment".into()))?;
+                if let Some(q) = q {
+                    curvature_move(sp, ai, q);
+                }
+                ai
+            }
+            CurvatureOp::Extend(q) => {
+                curvature_extend(sp, start, q, how);
+                if start { 0 } else { sp.anchors.len() - 1 }
+            }
+            CurvatureOp::Close => {
+                if sp.anchors.len() < 3 {
+                    return Err(EngineError::Other("closing needs three anchors".into()));
+                }
+                curvature_close(sp, start, how);
+                if start { sp.anchors.len() - 1 } else { 0 }
+            }
+        };
+        sel.set([id]);
+        sel.anchors.insert(id, [(si, ai)].into());
+        Ok(ai)
+    })?;
+    Ok(json!({ "anchor": anchor }))
+}
+
 // ---------- anchor tools ----------

 fn remove_anchor(s: &mut Session, p: &Value) -> Result<Value> {
@@ -15,7 +15,7 @@
 use std::sync::Arc;

 use serde_json::{Map, Value, json};
-use vectorcraft_color::Paint;
+use vectorcraft_color::{BlendMode, Paint};
 use vectorcraft_doc::rastersettings::MAX_ADD_AROUND;
 use vectorcraft_doc::{
    Appearance, AppearanceItem, ColorMode, Document, Effect, ImageBlob, ImageObject, Node, NodeId, NodeKind, RasterColorModel, StrokeLayer,
@@ -217,18 +217,55 @@ pub(crate) fn raster_fx(n: &Node) -> Vec<RasterFx> {
 /// Remove the raster effects of `n` (its own and its fills' and strokes') and, with `members`, of
 /// everything inside it.
 pub(crate) fn strip_raster(n: &mut Node, members: bool) {
-    let keep = |e: &Effect| !effects::is_raster(&e.id);
+    retain_effects(n, members, &|e| !effects::is_raster(&e.id));
+}
+
+/// Keep the effects of `n` (its own and its fills' and strokes') that `keep` accepts and, with
+/// `members`, of everything inside it.
+fn retain_effects(n: &mut Node, members: bool, keep: &dyn Fn(&Effect) -> bool) {
    n.appearance.effects.retain(keep);
    for it in &mut n.appearance.items {
        it.effects_mut().retain(keep);
    }
    if members {
        for c in n.children_mut().into_iter().flatten() {
-            strip_raster(Arc::make_mut(c), true);
+            retain_effects(Arc::make_mut(c), true, keep);
        }
    }
 }

+/// The blend mode raster effect `e` paints with (`None`: not a raster effect, or one without).
+fn effect_mode(e: &Effect) -> Option<BlendMode> {
+    effects::raster_effects(std::slice::from_ref(e)).first().and_then(RasterFx::mode)
+}
+
+/// The images of the shadows and outer glows of `n`, one per blend mode they use (in the order
+/// the modes first come), each composited with its mode: rendered alone, over nothing, they can't
+/// blend with the art below the object, so the image does.
+fn below_images(d: &mut Document, n: &Node) -> Option<Vec<Node>> {
+    let mut modes: Vec<BlendMode> = vec![];
+    for mode in raster_fx(n).iter().filter_map(RasterFx::mode) {
+        if !modes.contains(&mode) {
+            modes.push(mode);
+        }
+    }
+    if modes.len() < 2 {
+        let mut image = raster_image(d, n, true, false)?;
+        image.blend = modes.first().copied().unwrap_or_default();
+        return Some(vec![image]);
+    }
+    modes
+        .into_iter()
+        .map(|mode| {
+            let mut only = n.clone();
+            retain_effects(&mut only, false, &|e| effect_mode(e).is_none_or(|m| m == mode));
+            let mut image = raster_image(d, &only, true, false)?;
+            image.blend = mode;
+            Some(image)
+        })
+        .collect()
+}
+
 /// The raster effects of `n` (its own, its fills' and strokes') as an embedded image of `d`
 /// rendered at the document's raster effects resolution, without `n`'s transparency (that stays
 /// on the object). With `below` (they all paint below it: shadows and outer glows) the image holds
@@ -405,15 +442,18 @@ fn walk(out: &mut Document, n: &Node, which: Which) -> Option<Node> {
        return Some(walk(out, &g, which).unwrap_or(g));
    }
    // An image that can't be made leaves the object as it is (the writer reports its effects).
-    let image = raster_image(out, n, below, false)?;
    let mut v = n.clone();
    strip_raster(&mut v, false);
    let mut m = if below {
+        let images = below_images(out, n)?;
        let mut m = walk(out, &v, which).unwrap_or(v);
-        put_below(out, &mut m, image);
+        // Each goes in first: the last one put is the lowest.
+        for image in images.into_iter().rev() {
+            put_below(out, &mut m, image);
+        }
        m
    } else {
-        replace_with_image(v, image)
+        replace_with_image(v, raster_image(out, n, false, false)?)
    };
    walk_mask(out, &mut m, which);
    Some(m)
@@ -582,7 +582,8 @@ pub fn render(doc: &Document, s: &WebSettings) -> std::result::Result<WebRender,
    let doc = doc.without_edit_modes();
    let (region, scale) = region(&doc, s)?;
    let page = (doc.setup.background == vectorcraft_doc::Background::White).then_some([255; 4]);
-    let opts = vectorcraft_render::RenderOptions { background: page, skip_templates: true, anti_alias: s.anti_alias, ..Default::default() };
+    let opts =
+        vectorcraft_render::RenderOptions { background: page, skip_templates: true, anti_alias: s.anti_alias, precise: true, ..Default::default() };
    let img = vectorcraft_render::Renderer::new().render_region_with(&doc, region, scale, &opts);
    Ok(WebRender { rgba: img.to_straight(), width: img.width, height: img.height, region, scale })
 }
@@ -197,6 +197,68 @@ fn curvature_click_first_point_closes() {
    assert_eq!(p.anchor_count(), 3);
 }

+/// The Curvature tool edits a path another tool drew (#798), one undo step per edit, keeping its
+/// shape except where edited.
+#[test]
+fn curvature_edits_any_selected_path() {
+    let mut s = session();
+    let v = view();
+    let anchors = json!([
+        {"x": 100, "y": 300},
+        {"x": 200, "y": 200, "in": [160, 210], "out": [260, 185]},
+        {"x": 350, "y": 280, "in": [320, 230], "out": [380, 330]},
+        {"x": 450, "y": 350, "in": [420, 360], "out": [480, 300]},
+        {"x": 550, "y": 260, "in": [520, 290]}
+    ]);
+    let id = NodeId(s.execute("path.create", &json!({ "anchors": anchors })).unwrap()["id"].as_u64().unwrap());
+    s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
+    s.select_tool("curvature", v).unwrap();
+    let before = path(&s, id).subpaths[0].clone();
+    // Drag a point: only its two segments change.
+    assert_eq!(gesture(&mut s, &[(350.0, 280.0), (360.0, 320.0), (370.0, 340.0)], Mods::default()), 1);
+    let sp = path(&s, id).subpaths[0].clone();
+    assert_eq!(sp.anchors[2].p, Point::new(370.0, 340.0));
+    assert_eq!((sp.segment(0), sp.segment(3)), (before.segment(0), before.segment(3)));
+    assert_eq!(s.doc().unwrap().selection.anchors.get(&id).map(|a| a.len()), Some(1), "the point is current");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(path(&s, id).subpaths[0], before);
+    // Alt-click toggles it, Delete removes the current point: one step each.
+    let (alt, steps) = (Mods { alt: true, ..Default::default() }, undo_steps(&s));
+    assert_eq!(gesture(&mut s, &[(200.0, 200.0)], alt), 1);
+    assert!(!path(&s, id).subpaths[0].anchors[1].has_out());
+    s.tool_key(ToolKey::Delete, Mods::default(), v).unwrap();
+    assert_eq!(path(&s, id).anchor_count(), 4);
+    assert_eq!(undo_steps(&s), steps + 2);
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(path(&s, id).subpaths[0], before);
+    // A press on a segment adds a point, the drag moving it: one step.
+    s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
+    let on = kurbo::ParamCurve::eval(&before.segment(3), 0.5);
+    assert_eq!(gesture(&mut s, &[(on.x, on.y), (on.x, on.y + 20.0), (on.x, on.y + 30.0)], Mods::default()), 1);
+    let sp = path(&s, id).subpaths[0].clone();
+    assert_eq!(sp.anchors.len(), 6);
+    assert_eq!(sp.anchors[4].p, Point::new(on.x, on.y + 30.0));
+    assert_eq!((sp.segment(0), sp.segment(1), sp.segment(2)), (before.segment(0), before.segment(1), before.segment(2)));
+    s.execute("edit.undo", &json!({})).unwrap();
+    // A click on an end, then two more: the path goes on, its old segments unchanged.
+    let steps = undo_steps(&s);
+    for (x, y) in [(550.0, 260.0), (650.0, 300.0), (720.0, 220.0)] {
+        gesture(&mut s, &[(x, y)], Mods::default());
+    }
+    assert_eq!(undo_steps(&s), steps + 2, "selecting the end is no step");
+    let sp = path(&s, id).subpaths[0].clone();
+    assert_eq!(sp.anchors.len(), 7);
+    assert!((0..4).all(|i| sp.segment(i) == before.segment(i)));
+    assert_eq!(sp.anchors[6].p, Point::new(720.0, 220.0));
+    // The other end closes it; Esc and a click away start a new path.
+    gesture(&mut s, &[(100.0, 300.0)], Mods::default());
+    assert!(path(&s, id).is_closed());
+    s.tool_key(ToolKey::Escape, Mods::default(), v).unwrap();
+    gesture(&mut s, &[(700.0, 550.0)], Mods::default());
+    assert_eq!(paths(&s).len(), 2);
+}
+
 #[test]
 fn add_and_delete_anchor_tools() {
    let mut s = session();
@@ -150,3 +150,35 @@ fn live_objects_and_single_fills_and_strokes_keep_their_raster_effects() {
        assert_eq!(pieces, 2, "item {item}: one piece per fill and stroke");
    }
 }
+
+#[test]
+fn shadows_and_glows_keep_their_blend_modes() {
+    // #827: a red Screen glow over grey can't darken it, as Normal would.
+    let glow = Effect {
+        id: "stylize.outerGlow".into(),
+        params: json!({"mode": "screen", "color": "#ff0000", "opacity": 100.0, "blur": 20.0}),
+        visible: true,
+    };
+    let mut d = Document::new(200.0, 200.0);
+    let back = rect(&mut d, Rect::new(0.0, 0.0, 200.0, 200.0), Color::rgb(0.5, 0.5, 0.5));
+    add(&mut d, back);
+    let dot = rect(&mut d, Rect::new(70.0, 70.0, 130.0, 130.0), Color::rgb(0.12, 0.12, 0.12));
+    add(&mut d, with(dot, glow.clone()));
+    assert_written("screen glow", &d);
+    let r = crate::cmd::rasterfx::export_pdf_with_report(&d, &Default::default()).unwrap();
+    let back = render(&vectorcraft_pdf::import(&r.bytes).unwrap());
+    for x in [133, 138, 145] {
+        let i = (100 * back.width as usize + x) * 4;
+        let (red, green, blue) = (back.pixels[i], back.pixels[i + 1], back.pixels[i + 2]);
+        assert!(red > green && green >= 124 && blue >= 124, "x {x}: {:?}", (red, green, blue));
+    }
+
+    // A Multiply shadow and the Screen glow: an image each, composited with its mode.
+    let mut d = Document::new(200.0, 200.0);
+    let dot = rect(&mut d, Rect::new(70.0, 70.0, 130.0, 130.0), Color::rgb(0.12, 0.12, 0.12));
+    add(&mut d, with(with(dot, shadow()), glow));
+    let flat = crate::flatten_raster_effects(&d).unwrap();
+    let modes: Vec<_> =
+        flat.layers[0].children().unwrap()[0].children().unwrap().iter().filter(|c| matches!(c.kind, NodeKind::Image(_))).map(|c| c.blend).collect();
+    assert_eq!(modes, [vectorcraft_color::BlendMode::Multiply, vectorcraft_color::BlendMode::Screen]);
+}
@@ -215,6 +215,11 @@ fn structured_junk() {
        ("path.freehand", json!({"points": [[0, 0], [0, 0], [0, 0], [0, 0]]})),
        ("path.freehand", json!({"points": [[1e308, 1e308], [-1e308, 0]], "fidelity": 0})),
        ("path.curvature", json!({"points": [{"x": 0, "y": 0}]})),
+        ("path.curvatureEdit", json!({"id": 2, "op": "move", "anchor": 1000, "x": 0, "y": 0})),
+        ("path.curvatureEdit", json!({"id": 2, "op": "move", "anchor": 0, "x": 1e308, "y": -1e308})),
+        ("path.curvatureEdit", json!({"id": 2, "subpath": 7, "op": "extend", "x": 1e308, "y": -1e308, "from": "smooth"})),
+        ("path.curvatureEdit", json!({"id": 2, "op": "insert", "segment": 99, "t": -5, "x": 1})),
+        ("path.curvatureEdit", json!({"id": 2, "op": "close", "end": "start", "from": "corner"})),
        ("path.knife", json!({"points": [[0, 0], [1e9, 1e9]]})),
        ("path.eraseRegion", json!({"points": [[100, 80]], "size": 0})),
        ("path.eraseRegion", json!({"points": [[100, 80], [101, 80]], "size": 1e9})),
@@ -87,7 +87,7 @@ impl RasterExportOptions {
    }

    /// What the renderer draws for `format`: template layers and guides left out, over the background
-    /// (white for a JPEG or a flat PSD without one).
+    /// (white for a JPEG or a flat PSD without one), composited in floating point.
    pub fn render_options(&self, format: RasterFormat) -> RenderOptions {
        let flat = format == RasterFormat::Jpeg || (format == RasterFormat::Psd && !self.psd.layers);
        let background = self.background.or(flat.then_some([255; 3]));
@@ -95,6 +95,8 @@ impl RasterExportOptions {
            background: background.map(|[r, g, b]| [r, g, b, 255]),
            skip_templates: true,
            anti_alias: self.anti_alias,
+            // Opaque art stays exactly opaque where translucent edges cross it (#787).
+            precise: true,
            ..Default::default()
        }
    }
@@ -110,6 +110,44 @@ fn backgrounds_are_opaque_or_transparent() {
    assert_eq!(webp.get_pixel(0, 0).0, [0, 0, 0, 255]);
 }

+/// #787: translucent art over opaque art (or a background) stays exactly opaque, its anti-aliased
+/// edges too, so the file is written as RGB.
+#[test]
+fn translucent_edges_over_opaque_art_stay_opaque() {
+    let mut d = Document::new(100.0, 100.0);
+    let l = d.layers[0].id;
+    let under = Node::path(
+        d.alloc_id(),
+        shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 100.0)),
+        Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 0.0),
+    );
+    let mut over =
+        Node::path(d.alloc_id(), shapes::ellipse(Rect::new(10.0, 10.0, 90.0, 90.0)), Appearance::basic(Paint::solid(Color::WHITE), Paint::None, 0.0));
+    over.opacity = 0.5;
+    let only_over = {
+        let mut d = d.clone();
+        d.insert(Some(l), 0, over.clone()).unwrap();
+        d
+    };
+    d.insert(Some(l), 0, under).unwrap();
+    d.insert(Some(l), 1, over).unwrap();
+    // Over a black background at 72 ppi, and over an opaque rectangle at a scale that puts the
+    // edges on fractions of a pixel.
+    for (doc, o) in [
+        (&only_over, RasterExportOptions { background: Some([0, 0, 0]), ..Default::default() }),
+        (&d, RasterExportOptions { ppi: 72.0 * 0.3515625, ..Default::default() }),
+    ] {
+        let png = Renderer::new().export_region(doc, doc.artboards[0].rect, RasterFormat::Png, &o).unwrap();
+        let img = image::load_from_memory(&png).unwrap().to_rgba8();
+        let below: Vec<_> = img.pixels().filter(|p| p[3] < 255).collect();
+        assert!(below.is_empty(), "ppi {}: {} pixels below alpha 255, e.g. {:?}", o.ppi, below.len(), below.first());
+        assert_eq!(png[25], 2, "IHDR colour type: RGB");
+    }
+    // The inside is half white over black.
+    let img = export(&only_over, RasterFormat::Png, &RasterExportOptions { background: Some([0, 0, 0]), ..Default::default() });
+    assert!(img.get_pixel(50, 50).0[..3].iter().all(|c| (127..=128).contains(c)), "{:?}", img.get_pixel(50, 50));
+}
+
 #[test]
 fn interlaced_export_decodes_to_the_same_pixels() {
    let d = circle_doc();
@@ -137,7 +137,7 @@ impl Renderer {
    fn flatten(&mut self, ctx: &mut RenderContext, r: Region) -> Arc<Pixmap> {
        ctx.flush();
        let mut all = Pixmap::new(ctx.width(), ctx.height());
-        ctx.render(&mut all, &mut self.resources);
+        ctx.render_with(&mut all, &mut self.resources, self.raster);
        ctx.reset();
        let crop = if (r.x, r.y, r.w, r.h) == (0, 0, all.width(), all.height()) {
            None
@@ -171,7 +171,7 @@ impl Renderer {
        (self.nested, self.backdrop, self.clip_paths) = outer;
        ctx.flush();
        let mut pm = Pixmap::new(r.w, r.h);
-        ctx.render(&mut pm, &mut self.resources);
+        ctx.render_with(&mut pm, &mut self.resources, self.raster);
        pm
    }

@@ -110,6 +110,10 @@ pub struct RenderOptions {
    /// Screen view in isolation mode: the isolated group or layer. Everything around it draws
    /// dimmed ([`ISOLATION_DIM`]).
    pub isolated: Option<NodeId>,
+    /// Composite in floating point (exports): translucent art over opaque art comes out exactly
+    /// opaque, where 8-bit compositing leaves alpha 254 on some anti-aliased edges (#787). Off,
+    /// the faster 8-bit pipeline (the canvas).
+    pub precise: bool,
 }

 /// The opacity of the art around an isolated group or layer.
@@ -181,6 +185,7 @@ impl Default for RenderOptions {
            trace_views: false,
            smooth_images: true,
            isolated: None,
+            precise: false,
        }
    }
 }
@@ -362,6 +367,9 @@ pub struct Renderer {
    /// Inline graphics being drawn inside inline graphics (a symbol whose art holds text showing
    /// it): drawing stops at [`MAX_INLINE_DEPTH`].
    inline_depth: u32,
+    /// How the frame being drawn is rasterized ([`RenderOptions::precise`]): its offscreen groups,
+    /// masks and patterns too.
+    raster: vello_cpu::RasterizerSettings,
    /// [`RenderOptions::isolated`]'s layers and groups, from the top layer down to it, for the
    /// frame (`stamp`) and document they were found in.
    isolation: Option<(u64, usize, NodeId, Vec<NodeId>)>,
@@ -453,6 +461,7 @@ impl Renderer {
            adjusted: Default::default(),
            dim_images: None,
            inline_depth: 0,
+            raster: vello_cpu::RasterizerSettings::default(),
            isolation: None,
            isolation_settled: false,
        }
@@ -532,6 +541,8 @@ impl Renderer {
        };
        // `reset` keeps the threshold of the previous render: set it every time.
        ctx.set_aliasing_threshold(opts.anti_alias.threshold());
+        let render_mode = if opts.precise { vello_cpu::RenderMode::OptimizeQuality } else { vello_cpu::RenderMode::OptimizeSpeed };
+        self.raster = vello_cpu::RasterizerSettings { render_mode, ..Default::default() };
        if let Some(bg) = opts.background {
            ctx.set_transform(Affine::IDENTITY);
            ctx.set_paint(f.ink.fixed(bg));
@@ -560,7 +571,7 @@ impl Renderer {
        }
        ctx.flush();
        let mut pm = Pixmap::new(w, h);
-        ctx.render(&mut pm, &mut self.resources);
+        ctx.render_with(&mut pm, &mut self.resources, self.raster);
        if threads == 0 {
            self.ctx_st = Some(ctx);
        } else {
@@ -795,7 +806,7 @@ impl Renderer {
        (self.knockout, self.nested, self.backdrop, self.clip_paths) = outer;
        mctx.flush();
        let mut pm = Pixmap::new(w, h);
-        mctx.render(&mut pm, &mut self.resources);
+        mctx.render_with(&mut pm, &mut self.resources, self.raster);
        pm.data().iter().map(|p| mask_value(p.r, p.g, p.b, p.a, m.clip, m.invert)).collect()
    }

@@ -88,7 +88,7 @@ fn rasterize(r: &mut Renderer, doc: &Document, def: &PatternDef, region: Rect, w
    }
    ctx.flush();
    let mut pm = Pixmap::new(w, h);
-    ctx.render(&mut pm, &mut r.resources);
+    ctx.render_with(&mut pm, &mut r.resources, r.raster);
    pm
 }

@@ -15,7 +15,7 @@ use vectorcraft_geom::{Anchor, AnchorKind, BezPath, Point, SubPath};
 use crate::{Action, Tool, ToolContext};

 pub use anchor::AnchorTool;
-pub use curvature::CurvatureTool;
+pub use curvature::{CurvatureTool, EndCurve, curvature_close, curvature_extend, curvature_insert, curvature_move};
 pub use family::FamilyTool;
 pub use gesture::GestureTool;

@@ -94,6 +94,15 @@ fn candidate_paths(cx: &ToolContext) -> Vec<NodeId> {
    v
 }

+/// The selected paths the Pen and the Curvature tool edit (not guides, nor locked or hidden ones).
+pub(crate) fn editable_paths<'a>(cx: &'a ToolContext) -> impl Iterator<Item = NodeId> + 'a {
+    cx.selection
+        .objects
+        .iter()
+        .copied()
+        .filter(|&id| cx.doc.is_editable(id) && cx.doc.node(id).is_some_and(|n| matches!(n.kind, NodeKind::Path { guide: false, .. })))
+}
+
 /// Nearest anchor within `tol`: (path, subpath, anchor).
 pub(crate) fn hit_anchor(cx: &ToolContext, p: Point, tol: f64) -> Option<(NodeId, usize, usize)> {
    anchor_in(cx, candidate_paths(cx), p, tol)
@@ -5,28 +5,293 @@
 //! first point to close; Backspace/Delete removes the last touched point; Esc/Enter ends the path.
 //! A rubber band shows the curve to the cursor (Enable Rubber Band for Curvature Tool). Each point
 //! placed or dragged snaps to Smart Guides ([`DrawSnap`]), as the Pen's anchors do.
+//!
+//! It edits any selected path too, whatever drew it, keeping its shape except where edited
+//! (#798). A click on one of its points makes that the current point (direct-selected); a drag
+//! moves it, re-curving only the two segments at it ([`curvature_move`]); Alt-click or
+//! double-click toggles it between smooth and corner and Backspace/Delete removes it. A click on
+//! a segment adds a smooth point there without changing the shape ([`curvature_insert`]), and a
+//! drag moves the new point at once. While the current point is an end of an open path, clicks go
+//! on from it ([`curvature_extend`]): the old segments keep their shape, the new ones curve
+//! through the new points, and a click on the path's other end closes it. Each edit is one
+//! `path.curvatureEdit`, `path.convertAnchor` or `path.removeAnchor` (one undo step).

 use serde_json::{Value, json};
 use vectorcraft_doc::{NodeId, Selection};
-use vectorcraft_geom::Point;
+use vectorcraft_geom::{Anchor, AnchorKind, BezPath, Point, SubPath, Vec2};

-use super::{FEEDBACK, catmull_rom};
+use super::{FEEDBACK, anchor_in, catmull_rom, editable_paths, remove_anchor, segment_in};
 use crate::guides::{DrawSnap, Leave, Targets};
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};

+/// The command that edits a selected path.
+const EDIT: &str = "path.curvatureEdit";
+
 #[derive(Default)]
 pub struct CurvatureTool {
    pts: Vec<(Point, bool)>,
    closed: bool,
    id: Option<NodeId>,
-    /// Point being dragged: (index, began).
-    drag: Option<(usize, Point, bool)>,
-    /// Last touched point (Backspace removes it).
+    /// The point being dragged, the pointer at the press, and whether the drag began.
+    drag: Option<(Grab, Point, bool)>,
+    /// Last touched point of the path being drawn (Backspace removes it).
    current: Option<usize>,
    hover: Option<Point>,
+    /// The end the last click on a selected path placed.
+    placed: Option<Placed>,
    snap: DrawSnap,
 }

+/// What a press grabbed for a drag.
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Grab {
+    /// A point of the path being drawn.
+    Drawn(usize),
+    /// An anchor of a selected path: (path, subpath, anchor).
+    Anchor(NodeId, usize, usize),
+    /// The anchor the press added on a segment of a selected path: (path, subpath, segment, t).
+    Inserted(NodeId, usize, usize, f64),
+}
+
+/// The end a click on a selected path placed, while it still is that end (its subpath has as many
+/// anchors as then): going on from it, it curves through its neighbours, or stays a corner when it
+/// was Alt-clicked. Any other end keeps its curve.
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct Placed {
+    id: NodeId,
+    si: usize,
+    start: bool,
+    anchors: usize,
+    corner: bool,
+}
+
+/// The current point of a selected path while it is an end of an open subpath: where clicks go on
+/// from (its start with `start`), and the other end, which a click closes the subpath on.
+#[derive(Clone, Copy)]
+struct End {
+    id: NodeId,
+    si: usize,
+    start: bool,
+    anchors: usize,
+    p: Point,
+    other: Point,
+}
+
+impl End {
+    /// `end` for `path.curvatureEdit`.
+    fn name(&self) -> &'static str {
+        if self.start { "start" } else { "end" }
+    }
+}
+
+/// How the end a path goes on from bends into the new segment ([`curvature_extend`],
+/// [`curvature_close`]).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum EndCurve {
+    /// The segment it ends keeps its shape: the new handle goes on along its handle, or along the
+    /// curve where it has none, and with both it is smooth.
+    #[default]
+    Keep,
+    /// Smooth through its neighbours, as [`catmull_rom`] curves a point (a point the Curvature tool
+    /// placed: its segment re-curves).
+    Smooth,
+    /// A corner, without handles.
+    Corner,
+}
+
+impl EndCurve {
+    pub fn parse(s: &str) -> Option<Self> {
+        Some(match s {
+            "keep" => Self::Keep,
+            "smooth" => Self::Smooth,
+            "corner" => Self::Corner,
+            _ => return None,
+        })
+    }
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Keep => "keep",
+            Self::Smooth => "smooth",
+            Self::Corner => "corner",
+        }
+    }
+}
+
+/// The anchors before and after anchor `i` of `sp` (round the start of a closed one).
+fn neighbours(sp: &SubPath, i: usize) -> [Option<usize>; 2] {
+    let n = sp.anchors.len();
+    let wrap = sp.closed && n > 1;
+    let prev = if i > 0 { Some(i - 1) } else { wrap.then(|| n - 1) };
+    let next = if i + 1 < n { Some(i + 1) } else { wrap.then_some(0) };
+    [prev, next]
+}
+
+/// Move anchor `i` of `sp` to `q` as the Curvature tool drags a point: only the two segments at it
+/// change. A smooth anchor turns along the line through its neighbours; the neighbours' handles on
+/// those segments, and a corner's own handles, keep their directions, their lengths scaling with
+/// their segment's chord, so the segments beyond don't move and a corner without handles keeps
+/// none. False when there is no anchor `i`.
+pub fn curvature_move(sp: &mut SubPath, i: usize, q: Point) -> bool {
+    let Some(&a) = sp.anchors.get(i) else { return false };
+    let mut own = [a.h_in - a.p, a.h_out - a.p];
+    let mut ends = [None; 2];
+    for (side, j) in neighbours(sp, i).into_iter().enumerate() {
+        let Some(b) = j.and_then(|j| sp.anchors.get_mut(j)) else { continue };
+        let old = a.p.distance(b.p);
+        let s = if old > 1e-9 { q.distance(b.p) / old } else { 1.0 };
+        let h = if side == 0 { &mut b.h_out } else { &mut b.h_in };
+        *h = b.p + (*h - b.p) * s;
+        own[side] *= s;
+        ends[side] = Some(b.p);
+    }
+    let mut m = Anchor { p: q, h_in: q + own[0], h_out: q + own[1], kind: a.kind };
+    if let (AnchorKind::Smooth, [Some(prev), Some(next)]) = (a.kind, ends) {
+        let d = next - prev;
+        let l = d.hypot();
+        if l > 1e-9 {
+            // A handle it lacks comes out a third of the way to that side's neighbour.
+            let len = |h: Vec2, to: Point| if h.hypot() > 1e-9 { h.hypot() } else { q.distance(to) / 3.0 };
+            m.h_in = q - d * (len(own[0], prev) / l);
+            m.h_out = q + d * (len(own[1], next) / l);
+        }
+    }
+    if let Some(x) = sp.anchors.get_mut(i) {
+        *x = m;
+    }
+    true
+}
+
+/// Add a smooth anchor at `t` on segment `seg` of `sp` without changing its shape (on a straight
+/// segment its handles lie along it, so a drag curves it): the new anchor's index. None when there
+/// is no such segment.
+pub fn curvature_insert(sp: &mut SubPath, seg: usize, t: f64) -> Option<usize> {
+    if seg >= sp.segment_count() {
+        return None;
+    }
+    let line = sp.segment_is_line(seg);
+    let i = sp.insert_anchor(seg, if t.is_finite() { t.clamp(0.0, 1.0) } else { 0.5 });
+    if line {
+        sp.smooth_anchor(i);
+    }
+    Some(i)
+}
+
+/// Go on from an end of the open subpath `sp` (its start with `start`) to a new end at `p`, which
+/// has no handles; the old end bends into the new segment as `how` says.
+pub fn curvature_extend(sp: &mut SubPath, start: bool, p: Point, how: EndCurve) {
+    if start {
+        sp.reverse();
+    }
+    bend_last(sp, p, how);
+    sp.anchors.push(Anchor::corner(p));
+    if start {
+        sp.reverse();
+    }
+}
+
+/// Close the open subpath `sp` from its end (its start with `start`): that end bends into the
+/// closing segment as `how` says, and the other keeps its curve.
+pub fn curvature_close(sp: &mut SubPath, start: bool, how: EndCurve) {
+    if start {
+        sp.reverse();
+    }
+    if let (Some(first), Some(last)) = (sp.anchors.first().map(|a| a.p), sp.anchors.last().map(|a| a.p)) {
+        bend_last(sp, first, how);
+        sp.reverse();
+        bend_last(sp, last, EndCurve::Keep);
+        sp.reverse();
+        sp.closed = true;
+    }
+    if start {
+        sp.reverse();
+    }
+}
+
+/// Bend the last anchor of `sp` into a new segment on to `to`, as `how` says.
+fn bend_last(sp: &mut SubPath, to: Point, how: EndCurve) {
+    let prev = sp.anchors.len().checked_sub(2).and_then(|j| sp.anchors.get(j)).copied();
+    let Some(e) = sp.anchors.last_mut() else { return };
+    match how {
+        EndCurve::Corner => e.retract(),
+        EndCurve::Smooth => {
+            let t = prev.map_or(Vec2::ZERO, |b| (to - b.p) / 6.0);
+            if t.hypot() > 1e-9 {
+                *e = Anchor { p: e.p, h_in: e.p - t, h_out: e.p + t, kind: AnchorKind::Smooth };
+            } else {
+                e.retract();
+            }
+        }
+        EndCurve::Keep => {
+            // The way the curve comes in: from its handle, or else the segment's tangent there.
+            let back = if e.has_in() { Some(e.h_in) } else { prev.map(|b| if b.h_out.distance(e.p) > 1e-9 { b.h_out } else { b.p }) };
+            let d = back.map_or(Vec2::ZERO, |b| e.p - b);
+            let l = d.hypot();
+            e.h_out = if l > 1e-9 { e.p + d * (e.p.distance(to) / 3.0 / l) } else { e.p };
+            if e.has_in() && e.has_out() {
+                e.kind = AnchorKind::Smooth;
+            }
+        }
+    }
+}
+
+/// Subpath `si` of `id`, a selected path the tool edits.
+fn subpath<'a>(cx: &ToolContext<'a>, id: NodeId, si: usize) -> Option<&'a SubPath> {
+    if !editable_paths(cx).any(|e| e == id) {
+        return None;
+    }
+    cx.doc.node(id)?.path_data()?.subpaths.get(si)
+}
+
+/// The current point of a selected path: its one direct-selected anchor (path, subpath, anchor).
+fn current_point(cx: &ToolContext) -> Option<(NodeId, usize, usize)> {
+    let mut sets = cx.selection.anchors.iter().filter(|(_, set)| !set.is_empty());
+    let (&id, set) = sets.next()?;
+    if set.len() != 1 || sets.next().is_some() {
+        return None;
+    }
+    let &(si, ai) = set.first()?;
+    subpath(cx, id, si).filter(|sp| ai < sp.anchors.len()).map(|_| (id, si, ai))
+}
+
+/// The current point while it is an end of an open subpath.
+fn current_end(cx: &ToolContext) -> Option<End> {
+    let (id, si, ai) = current_point(cx)?;
+    let sp = subpath(cx, id, si)?;
+    let n = sp.anchors.len();
+    let (first, last) = (sp.anchors.first()?.p, sp.anchors.last()?.p);
+    if sp.closed || (ai > 0 && ai + 1 < n) {
+        return None;
+    }
+    // A one-anchor subpath goes on from its end.
+    let start = ai == 0 && n > 1;
+    let (p, other) = if start { (first, last) } else { (last, first) };
+    Some(End { id, si, start, anchors: n, p, other })
+}
+
+/// Make anchor `(id, si, ai)` the current point.
+fn select_point((id, si, ai): (NodeId, usize, usize)) -> Action {
+    Action::Exec("select.anchors".into(), json!({"id": id.0, "anchors": [[si, ai]], "mode": "set"}))
+}
+
+/// Toggle anchor `(id, si, ai)` of a selected path between smooth and corner.
+fn toggle(cx: &ToolContext, (id, si, ai): (NodeId, usize, usize)) -> Option<Action> {
+    let a = subpath(cx, id, si)?.anchors.get(ai)?;
+    let to = if a.kind == AnchorKind::Smooth { "corner" } else { "smooth" };
+    Some(Action::Exec("path.convertAnchor".into(), json!({"id": id.0, "subpath": si, "anchor": ai, "to": to})))
+}
+
+/// Snap targets for dragging anchors `anchors` of subpath `si` of `id` (the rest of the path
+/// pulls).
+fn hold_targets(snap: &mut DrawSnap, cx: &ToolContext, id: NodeId, si: usize, anchors: &[usize]) {
+    let sel = Selection { objects: vec![id], anchors: [(id, anchors.iter().map(|&ai| (si, ai)).collect())].into(), ..Selection::default() };
+    snap.hold(cx, || Targets::for_anchor_drag(cx.doc, &sel));
+}
+
+/// How near a press picks a point.
+fn point_tol(cx: &ToolContext) -> f64 {
+    cx.tol(5.0).max(cx.point_tol())
+}
+
 impl CurvatureTool {
    /// The path being drawn, if it is still the single selected object and matches our points.
    fn active(&self, cx: &ToolContext) -> Option<NodeId> {
@@ -58,12 +323,70 @@ impl CurvatureTool {
        self.id = None;
        self.drag = None;
        self.current = None;
+        self.placed = None;
        self.snap.clear();
    }

-    /// The segment to the next point leaves the last one.
-    fn leave(&self, cx: &ToolContext) -> Option<Leave> {
-        self.pts.last().map(|(p, _)| Leave::segment(cx, *p, false))
+    /// The path the next click goes on (left out of the snap targets, its anchors still pulling)
+    /// and the segment to it: the path being drawn, or the selected one whose end is current.
+    fn leave(&self, cx: &ToolContext) -> Option<(NodeId, Leave)> {
+        match self.active(cx) {
+            Some(id) => self.pts.last().map(|(p, _)| (id, Leave::segment(cx, *p, false))),
+            None => current_end(cx).map(|e| (e.id, Leave::segment(cx, e.p, false))),
+        }
+    }
+
+    /// How end `e` bends into the next segment: as [`Placed`] says for the end the last click
+    /// placed, else it keeps its curve.
+    fn how(&self, e: &End) -> EndCurve {
+        match self.placed {
+            Some(pl) if (pl.id, pl.si, pl.start, pl.anchors) == (e.id, e.si, e.start, e.anchors) => {
+                if pl.corner {
+                    EndCurve::Corner
+                } else {
+                    EndCurve::Smooth
+                }
+            }
+            _ => EndCurve::Keep,
+        }
+    }
+
+    /// A press on a selected path the tool isn't drawing: on the other end of the open path going
+    /// on (it closes), on a point, anywhere while an end is current (the path goes on), or on a
+    /// segment. None elsewhere: a new path starts.
+    fn press_selected(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Option<Vec<Action>> {
+        let (p, tol) = (ev.pos, point_tol(cx));
+        let end = current_end(cx);
+        if let Some(e) = end.filter(|e| e.anchors >= 3 && p.distance(e.other) <= tol) {
+            let how = self.how(&e);
+            self.placed = None;
+            let v = json!({"id": e.id.0, "subpath": e.si, "op": "close", "end": e.name(), "from": how.name()});
+            return Some(vec![Action::Exec(EDIT.into(), v)]);
+        }
+        if let Some(hit) = anchor_in(cx, editable_paths(cx), p, tol) {
+            let mut out = vec![select_point(hit)];
+            if ev.mods.alt {
+                out.extend(toggle(cx, hit));
+                return Some(out);
+            }
+            let (id, si, ai) = hit;
+            hold_targets(&mut self.snap, cx, id, si, &[ai]);
+            self.drag = Some((Grab::Anchor(id, si, ai), p, false));
+            return Some(out);
+        }
+        if let Some(e) = end {
+            let q = self.snap.press(cx, p, &[e.id], Some(&Leave::segment(cx, e.p, false)));
+            let how = self.how(&e);
+            self.placed = Some(Placed { id: e.id, si: e.si, start: e.start, anchors: e.anchors + 1, corner: ev.mods.alt });
+            let v = json!({"id": e.id.0, "subpath": e.si, "op": "extend", "end": e.name(), "x": q.x, "y": q.y, "from": how.name()});
+            return Some(vec![Action::Exec(EDIT.into(), v)]);
+        }
+        let (id, si, seg, t) = segment_in(cx, editable_paths(cx), p, tol)?;
+        let n = subpath(cx, id, si)?.anchors.len().max(1);
+        hold_targets(&mut self.snap, cx, id, si, &[seg, (seg + 1) % n]);
+        self.drag = Some((Grab::Inserted(id, si, seg, t), p, true));
+        let v = json!({"id": id.0, "subpath": si, "op": "insert", "segment": seg, "t": t});
+        Some(vec![Action::Begin("Curvature".into()), Action::Preview(EDIT.into(), v)])
    }
 }

@@ -82,8 +405,8 @@ impl Tool for CurvatureTool {
        }
        match ev.kind {
            PointerKind::Move => {
-                let from = active.and_then(|_| self.leave(cx));
-                self.hover = Some(self.snap.hover(cx, p, active.as_slice(), from.as_ref()));
+                let (on, from) = self.leave(cx).unzip();
+                self.hover = Some(self.snap.hover(cx, p, on.as_slice(), from.as_ref()));
                vec![]
            }
            PointerKind::Down => {
@@ -99,19 +422,21 @@ impl Tool for CurvatureTool {
                            return vec![Action::Exec("path.curvature".into(), self.params())];
                        }
                        // The point dragged and the curve through it move: the rest pull.
-                        let sel = Selection { objects: vec![id], anchors: [(id, [(0, i)].into())].into(), ..Selection::default() };
-                        self.snap.hold(cx, || Targets::for_anchor_drag(cx.doc, &sel));
-                        self.drag = Some((i, p, false));
+                        hold_targets(&mut self.snap, cx, id, 0, &[i]);
+                        self.drag = Some((Grab::Drawn(i), p, false));
                        return vec![];
                    }
                    if !self.closed {
-                        let from = self.leave(cx);
+                        let from = self.leave(cx).map(|l| l.1);
                        let p = self.snap.press(cx, p, &[id], from.as_ref());
                        self.pts.push((p, ev.mods.alt));
                        self.current = Some(self.pts.len() - 1);
                        return vec![Action::Exec("path.curvature".into(), self.params())];
                    }
                }
+                if let Some(out) = self.press_selected(cx, ev) {
+                    return out;
+                }
                // Start a new path.
                self.reset();
                let p = self.snap.press(cx, p, &[], None);
@@ -120,20 +445,30 @@ impl Tool for CurvatureTool {
                vec![Action::Exec("path.curvature".into(), self.params()), Action::Notify("created".into())]
            }
            PointerKind::Drag => {
-                let Some((i, start, began)) = self.drag else { return vec![] };
+                let Some((grab, start, began)) = self.drag else { return vec![] };
                let mut out = vec![];
                if !began {
                    if p.distance(start) < cx.tol(3.0) {
                        return out;
                    }
                    out.push(Action::Begin("Curvature".into()));
-                    self.drag = Some((i, start, true));
+                    self.drag = Some((grab, start, true));
                }
                let p = self.snap.drag(cx, p, None);
-                if let Some(pt) = self.pts.get_mut(i) {
-                    pt.0 = p;
-                }
-                out.push(Action::Preview("path.curvature".into(), self.params()));
+                out.push(match grab {
+                    Grab::Drawn(i) => {
+                        if let Some(pt) = self.pts.get_mut(i) {
+                            pt.0 = p;
+                        }
+                        Action::Preview("path.curvature".into(), self.params())
+                    }
+                    Grab::Anchor(id, si, ai) => {
+                        Action::Preview(EDIT.into(), json!({"id": id.0, "subpath": si, "op": "move", "anchor": ai, "x": p.x, "y": p.y}))
+                    }
+                    Grab::Inserted(id, si, seg, t) => {
+                        Action::Preview(EDIT.into(), json!({"id": id.0, "subpath": si, "op": "insert", "segment": seg, "t": t, "x": p.x, "y": p.y}))
+                    }
+                });
                out
            }
            PointerKind::Up => {
@@ -145,7 +480,7 @@ impl Tool for CurvatureTool {
            }
            PointerKind::DoubleClick => {
                if active.is_none() {
-                    return vec![];
+                    return anchor_in(cx, editable_paths(cx), p, point_tol(cx)).and_then(|hit| toggle(cx, hit)).into_iter().collect();
                }
                let Some(i) = self.hit_point(cx, p) else { return vec![] };
                self.pts[i].1 = !self.pts[i].1;
@@ -158,14 +493,30 @@ impl Tool for CurvatureTool {
            self.id = Some(cx.selection.objects[0]);
        }
    }
+    fn claims_key(&self, cx: &ToolContext, key: ToolKey) -> bool {
+        matches!(key, ToolKey::Backspace | ToolKey::Delete)
+            && self.drag.is_none()
+            && if self.active(cx).is_some() { self.pts.len() > 1 } else { current_point(cx).is_some() }
+    }
    fn key(&mut self, cx: &ToolContext, key: ToolKey, _m: Mods) -> Vec<Action> {
        match key {
            ToolKey::Escape | ToolKey::Enter => {
                let dragging = self.drag.is_some_and(|d| d.2);
+                let drawing = self.active(cx).is_some();
                self.reset();
-                if dragging { vec![Action::Cancel] } else { vec![] }
+                if dragging {
+                    return vec![Action::Cancel];
+                }
+                // A selected path's current point goes: clicks no longer go on from it.
+                if drawing || current_point(cx).is_none() {
+                    return vec![];
+                }
+                vec![Action::Exec("select.set".into(), json!({"ids": crate::json_ids(&cx.selection.objects)}))]
            }
-            ToolKey::Backspace | ToolKey::Delete if self.active(cx).is_some() && self.pts.len() > 1 && self.drag.is_none() => {
+            ToolKey::Backspace | ToolKey::Delete if self.claims_key(cx, key) => {
+                if self.active(cx).is_none() {
+                    return current_point(cx).map(remove_anchor).into_iter().collect();
+                }
                let i = self.current.unwrap_or(self.pts.len() - 1).min(self.pts.len() - 1);
                self.pts.remove(i);
                if self.pts.len() < 3 {
@@ -184,19 +535,34 @@ impl Tool for CurvatureTool {
    }
    fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
        let mut o = self.snap.guides().to_vec();
+        let band = cx.curvature_rubber_band && self.drag.is_none();
+        let mut bp = BezPath::new();
        if self.active(cx).is_none() {
+            // The curve on from the current end of a selected path: its last segment and the next.
+            if band
+                && let (Some(e), Some(h)) = (current_end(cx), self.hover)
+                && let Some(sp) = subpath(cx, e.id, e.si)
+            {
+                let n = sp.anchors.len();
+                let near = if e.start {
+                    sp.anchors.iter().take(2).rev().map(Anchor::reversed).collect()
+                } else {
+                    sp.anchors.iter().skip(n.saturating_sub(2)).copied().collect()
+                };
+                let mut tail = SubPath::new(near, false);
+                curvature_extend(&mut tail, false, h, self.how(&e));
+                tail.to_bezpath_into(&mut bp);
+                o.push(Overlay::Path { path: bp, color: FEEDBACK, width: 1.0, dashed: false });
+            }
            return o;
        }
-        if cx.curvature_rubber_band
+        if band
            && !self.closed
-            && self.drag.is_none()
            && let Some(h) = self.hover
        {
            let mut pts = self.pts.clone();
            pts.push((h, false));
-            let sp = catmull_rom(&pts, false);
-            let mut bp = vectorcraft_geom::BezPath::new();
-            sp.to_bezpath_into(&mut bp);
+            catmull_rom(&pts, false).to_bezpath_into(&mut bp);
            o.push(Overlay::Path { path: bp, color: FEEDBACK, width: 1.0, dashed: false });
        }
        for (i, (p, _)) in self.pts.iter().enumerate() {
@@ -204,7 +570,33 @@ impl Tool for CurvatureTool {
        }
        o
    }
-    fn cursor(&self, _cx: &ToolContext, _p: Point, _m: Mods) -> Cursor {
+    fn cursor(&self, cx: &ToolContext, p: Point, m: Mods) -> Cursor {
+        if self.active(cx).is_some() {
+            return match self.hit_point(cx, p) {
+                Some(0) if !self.closed && self.pts.len() >= 3 => Cursor::PenClose,
+                Some(_) if m.alt => Cursor::PenConvert,
+                Some(_) => Cursor::Move,
+                None => Cursor::Pen,
+            };
+        }
+        let tol = point_tol(cx);
+        let end = current_end(cx);
+        if end.is_some_and(|e| e.anchors >= 3 && p.distance(e.other) <= tol) {
+            return Cursor::PenClose;
+        }
+        if let Some((id, si, ai)) = anchor_in(cx, editable_paths(cx), p, tol) {
+            let open_end = subpath(cx, id, si).is_some_and(|sp| !sp.closed && (ai == 0 || ai + 1 == sp.anchors.len()));
+            return if m.alt {
+                Cursor::PenConvert
+            } else if open_end {
+                Cursor::PenContinue
+            } else {
+                Cursor::Move
+            };
+        }
+        if end.is_none() && segment_in(cx, editable_paths(cx), p, tol).is_some() {
+            return Cursor::PenAdd;
+        }
        Cursor::Pen
    }
 }
@@ -213,7 +605,8 @@ impl Tool for CurvatureTool {
 mod tests {
    use super::*;
    use crate::testutil::*;
-    use vectorcraft_doc::Selection;
+    use vectorcraft_doc::{Appearance, Document, Node, Selection};
+    use vectorcraft_geom::{ParamCurve, PathData};

    #[test]
    fn first_click_creates_then_notify_tracks_path() {
@@ -252,4 +645,266 @@ mod tests {
        t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 202.0, 99.0));
        assert!(t.overlays(&cx).is_empty());
    }
+
+    fn pt(x: f64, y: f64) -> Point {
+        Point::new(x, y)
+    }
+
+    /// An open pen-style path: a corner start, two smooth anchors with uneven handles, a cusp and
+    /// an end with only an incoming handle.
+    fn wave() -> SubPath {
+        SubPath::new(
+            vec![
+                Anchor::corner(pt(0.0, 100.0)),
+                Anchor::with_handles(pt(100.0, 0.0), pt(60.0, 10.0), pt(160.0, -15.0)),
+                Anchor::with_handles(pt(250.0, 80.0), pt(220.0, 30.0), pt(280.0, 130.0)),
+                Anchor::with_handles(pt(350.0, 150.0), pt(320.0, 160.0), pt(380.0, 100.0)),
+                Anchor::with_handles(pt(450.0, 60.0), pt(420.0, 90.0), pt(450.0, 60.0)),
+            ],
+            false,
+        )
+    }
+
+    /// Every point of `a` lies on `b` (within 1e-6), sampled.
+    fn lies_on(a: &SubPath, b: &SubPath) -> bool {
+        let b = PathData::single(b.clone());
+        (0..a.segment_count()).all(|i| (0..=20).all(|k| b.nearest(a.segment(i).eval(k as f64 / 20.0)).is_some_and(|n| n.4 < 1e-6)))
+    }
+
+    fn collinear(a: Vec2, b: Vec2) -> bool {
+        a.cross(b).abs() < 1e-6 * a.hypot().max(1.0) * b.hypot().max(1.0)
+    }
+
+    #[test]
+    fn moving_a_point_recurves_only_its_two_segments() {
+        let before = wave();
+        let mut sp = before.clone();
+        assert_eq!(sp.anchors[2].kind, AnchorKind::Smooth);
+        assert!(curvature_move(&mut sp, 2, pt(260.0, 140.0)));
+        assert_eq!(sp.anchors[2].p, pt(260.0, 140.0));
+        // The segments beyond its neighbours are bit-identical.
+        assert_eq!(sp.segment(0), before.segment(0));
+        assert_eq!(sp.segment(3), before.segment(3));
+        // The neighbours keep their handle directions on its segments, and their other handles.
+        assert!(collinear(sp.anchors[1].h_out - sp.anchors[1].p, before.anchors[1].h_out - before.anchors[1].p));
+        assert!(collinear(sp.anchors[3].h_in - sp.anchors[3].p, before.anchors[3].h_in - before.anchors[3].p));
+        assert_eq!((sp.anchors[1].h_in, sp.anchors[3].h_out), (before.anchors[1].h_in, before.anchors[3].h_out));
+        // The moved smooth point turns along the line through its neighbours.
+        let a = sp.anchors[2];
+        assert_eq!(a.kind, AnchorKind::Smooth);
+        assert!(collinear(a.h_out - a.p, sp.anchors[3].p - sp.anchors[1].p) && collinear(a.h_in - a.p, a.h_out - a.p));
+        assert!((a.h_out - a.p).dot(sp.anchors[3].p - sp.anchors[1].p) > 0.0);
+        // A cusp keeps its handle directions; a moved end changes its one segment only.
+        assert_eq!(sp.anchors[3].kind, AnchorKind::Corner);
+        assert!(curvature_move(&mut sp, 3, pt(360.0, 170.0)));
+        assert!(collinear(sp.anchors[3].h_out - sp.anchors[3].p, before.anchors[3].h_out - before.anchors[3].p));
+        let mut end = before.clone();
+        assert!(curvature_move(&mut end, 4, pt(470.0, 20.0)));
+        assert_eq!(end.segment(2), before.segment(2));
+        assert!(!curvature_move(&mut end, 5, pt(0.0, 0.0)));
+    }
+
+    #[test]
+    fn moving_a_corner_without_handles_keeps_its_sides_straight() {
+        let (d, id) = doc_with_rect();
+        let mut sp = d.node(id).unwrap().path_data().unwrap().subpaths[0].clone();
+        assert!(curvature_move(&mut sp, 0, pt(80.0, 70.0)));
+        assert!((0..sp.segment_count()).all(|i| sp.segment_is_line(i)));
+        assert_eq!(sp.anchors[0], Anchor::corner(pt(80.0, 70.0)));
+    }
+
+    #[test]
+    fn going_on_from_an_end_keeps_the_old_segments() {
+        let before = wave();
+        let mut sp = before.clone();
+        curvature_extend(&mut sp, false, pt(550.0, 120.0), EndCurve::Keep);
+        assert_eq!(sp.anchors.len(), 6);
+        assert!((0..4).all(|i| sp.segment(i) == before.segment(i)));
+        // The old end turns smooth, going on along its incoming handle, a third of the chord out.
+        let e = sp.anchors[4];
+        assert_eq!(e.kind, AnchorKind::Smooth);
+        assert!(collinear(e.h_out - e.p, e.p - e.h_in) && (e.h_out - e.p).dot(e.p - e.h_in) > 0.0);
+        assert!((e.h_out.distance(e.p) - e.p.distance(pt(550.0, 120.0)) / 3.0).abs() < 1e-9);
+        assert_eq!(sp.anchors[5], Anchor::corner(pt(550.0, 120.0)));
+        // The point placed then curves through its neighbours as a drawn path's points do.
+        curvature_extend(&mut sp, false, pt(650.0, 60.0), EndCurve::Smooth);
+        let drawn = catmull_rom(&[(pt(450.0, 60.0), false), (pt(550.0, 120.0), false), (pt(650.0, 60.0), false)], false);
+        assert_eq!((sp.anchors[5].h_in, sp.anchors[5].h_out), (drawn.anchors[1].h_in, drawn.anchors[1].h_out));
+        assert!((0..4).all(|i| sp.segment(i) == before.segment(i)));
+        // A corner stays one.
+        curvature_extend(&mut sp, false, pt(700.0, 100.0), EndCurve::Corner);
+        assert!(!sp.anchors[6].has_in() && !sp.anchors[6].has_out());
+        // From the start: the old segments come one later, and the new end is the first anchor.
+        let mut sp = before.clone();
+        curvature_extend(&mut sp, true, pt(-100.0, 50.0), EndCurve::Keep);
+        assert_eq!(sp.anchors[0], Anchor::corner(pt(-100.0, 50.0)));
+        assert!((0..4).all(|i| sp.segment(i + 1) == before.segment(i)));
+        // A corner end without handles goes on along its segment's tangent.
+        let old = sp.anchors[1];
+        assert!(old.has_in() && !old.has_out());
+        assert!(collinear(old.h_in - old.p, old.p - before.anchors[1].h_in) && (old.h_in - old.p).dot(old.p - before.anchors[1].h_in) > 0.0);
+    }
+
+    #[test]
+    fn closing_keeps_the_old_segments() {
+        let before = wave();
+        let mut sp = before.clone();
+        curvature_close(&mut sp, false, EndCurve::Keep);
+        assert!(sp.closed && sp.anchors.len() == 5);
+        assert!((0..4).all(|i| sp.segment(i) == before.segment(i)));
+        // The first anchor gains an incoming handle along its tangent: no kink there.
+        let f = sp.anchors[0];
+        assert!(f.has_in() && collinear(f.p - f.h_in, before.anchors[1].h_in - f.p));
+    }
+
+    #[test]
+    fn inserting_a_point_keeps_the_shape() {
+        let before = wave();
+        let mut sp = before.clone();
+        assert_eq!(curvature_insert(&mut sp, 1, 0.3), Some(2));
+        assert_eq!(sp.anchors.len(), 6);
+        assert_eq!(sp.anchors[2].kind, AnchorKind::Smooth);
+        assert!(lies_on(&sp, &before) && lies_on(&before, &sp));
+        // On a straight side the point is smooth too, its handles along the side.
+        let (d, id) = doc_with_rect();
+        let rect = d.node(id).unwrap().path_data().unwrap().subpaths[0].clone();
+        let mut sp = rect.clone();
+        let i = curvature_insert(&mut sp, 0, 0.5).unwrap();
+        assert_eq!(sp.anchors[i].kind, AnchorKind::Smooth);
+        assert!(sp.anchors[i].has_in() && sp.anchors[i].has_out());
+        assert!(lies_on(&sp, &rect) && lies_on(&rect, &sp));
+        assert_eq!(curvature_insert(&mut sp, 99, 0.5), None);
+    }
+
+    /// A document with one path, `sp`.
+    fn doc_with(sp: SubPath) -> (Document, NodeId) {
+        let mut d = Document::new(800.0, 600.0);
+        let l = d.layers[0].id;
+        let id = d.alloc_id();
+        d.insert(Some(l), 0, Node::path(id, PathData::single(sp), Appearance::default_art())).unwrap();
+        (d, id)
+    }
+
+    /// Path `id` selected, anchor `current` of its first subpath direct-selected (or none).
+    fn selected(id: NodeId, current: Option<usize>) -> Selection {
+        let mut s = Selection::default();
+        s.set([id]);
+        if let Some(ai) = current {
+            s.anchors.insert(id, [(0, ai)].into());
+        }
+        s
+    }
+
+    /// A context without snapping.
+    fn quiet<'a>(d: &'a Document, s: &'a Selection, p: &'a crate::PaintDefaults) -> ToolContext<'a> {
+        ToolContext { smart_guides: false, snap_to_point: false, ..cx(d, s, p) }
+    }
+
+    fn press(t: &mut CurvatureTool, cx: &ToolContext, x: f64, y: f64, alt: bool) -> Vec<Action> {
+        let ev = PointerEvent::new(PointerKind::Down, x, y).with_mods(Mods { alt, ..Mods::default() });
+        let mut a = t.pointer(cx, &ev);
+        a.extend(t.pointer(cx, &PointerEvent::new(PointerKind::Up, x, y)));
+        a
+    }
+
+    /// The op and params of a `path.curvatureEdit` action.
+    fn edit_op(a: &Action) -> Option<(&str, &Value)> {
+        match a {
+            Action::Exec(c, v) | Action::Preview(c, v) if c == EDIT => Some((v["op"].as_str()?, v)),
+            _ => None,
+        }
+    }
+
+    #[test]
+    fn a_press_on_a_point_selects_it_and_a_drag_moves_it() {
+        let (d, id) = doc_with(wave());
+        let (s, p) = (selected(id, None), paint());
+        let cx = quiet(&d, &s, &p);
+        let mut t = CurvatureTool::default();
+        assert_eq!(t.cursor(&cx, pt(250.0, 81.0), Mods::default()), Cursor::Move);
+        assert_eq!(t.cursor(&cx, pt(450.0, 61.0), Mods::default()), Cursor::PenContinue);
+        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 251.0, 81.0));
+        assert_eq!(a, vec![Action::Exec("select.anchors".into(), json!({"id": id.0, "anchors": [[0, 2]], "mode": "set"}))]);
+        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 260.0, 140.0));
+        assert_eq!(a[0], Action::Begin("Curvature".into()));
+        let moved = edit_op(&a[1]).map(|(op, v)| (op, v["anchor"].clone(), v["x"].clone(), v["y"].clone()));
+        assert_eq!(moved, Some(("move", json!(2), json!(260.0), json!(140.0))));
+        assert!(t.busy());
+        assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 260.0, 140.0)), vec![Action::Commit]);
+        // A press without a drag only selects.
+        assert_eq!(press(&mut t, &cx, 100.0, 0.0, false).len(), 1);
+    }
+
+    #[test]
+    fn alt_click_or_double_click_toggles_and_delete_removes() {
+        let (d, id) = doc_with(wave());
+        let p = paint();
+        let s = selected(id, None);
+        let cx = quiet(&d, &s, &p);
+        let mut t = CurvatureTool::default();
+        let to = |a: &[Action]| a.iter().find(|a| matches!(a, Action::Exec(c, _) if c == "path.convertAnchor")).cloned();
+        let a = press(&mut t, &cx, 100.0, 0.0, true);
+        assert!(matches!(to(&a), Some(Action::Exec(_, v)) if v["anchor"] == 1 && v["to"] == "corner"), "{a:?}");
+        assert_eq!(t.cursor(&cx, pt(100.0, 0.0), Mods { alt: true, ..Mods::default() }), Cursor::PenConvert);
+        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::DoubleClick, 0.0, 100.0));
+        assert!(matches!(to(&a), Some(Action::Exec(_, v)) if v["anchor"] == 0 && v["to"] == "smooth"), "{a:?}");
+        // Delete is the tool's while a point is current, and removes it.
+        assert!(!t.claims_key(&cx, ToolKey::Delete));
+        let s = selected(id, Some(2));
+        let cx = quiet(&d, &s, &p);
+        assert!(t.claims_key(&cx, ToolKey::Backspace));
+        assert_eq!(t.key(&cx, ToolKey::Delete, Mods::default()), vec![remove_anchor((id, 0, 2))]);
+        // Esc lets go of the point.
+        assert_eq!(t.key(&cx, ToolKey::Escape, Mods::default()), vec![Action::Exec("select.set".into(), json!({"ids": [id.0]}))]);
+    }
+
+    #[test]
+    fn a_press_on_a_segment_adds_a_point_and_a_drag_moves_it_in_one_step() {
+        let (d, id) = doc_with(wave());
+        let (s, p) = (selected(id, None), paint());
+        let cx = quiet(&d, &s, &p);
+        let mut t = CurvatureTool::default();
+        let on = wave().segment(1).eval(0.5);
+        assert_eq!(t.cursor(&cx, on, Mods::default()), Cursor::PenAdd);
+        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, on.x, on.y));
+        assert_eq!(a[0], Action::Begin("Curvature".into()));
+        assert!(
+            matches!(edit_op(&a[1]), Some(("insert", v)) if v["segment"] == 1 && (v["t"].as_f64().unwrap() - 0.5).abs() < 1e-3 && v.get("x").is_none())
+        );
+        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, on.x + 1.0, on.y + 40.0));
+        assert!(matches!(edit_op(&a[0]), Some(("insert", v)) if v["segment"] == 1 && v["y"] == on.y + 40.0), "{a:?}");
+        assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, on.x, on.y + 40.0)), vec![Action::Commit]);
+    }
+
+    #[test]
+    fn clicks_go_on_from_a_current_end_and_the_other_end_closes() {
+        let p = paint();
+        let mut sp = wave();
+        let mut t = CurvatureTool::default();
+        let (d, id) = doc_with(sp.clone());
+        let s = selected(id, Some(4));
+        let a = press(&mut t, &quiet(&d, &s, &p), 550.0, 120.0, false);
+        assert!(matches!(edit_op(&a[0]), Some(("extend", v)) if v["end"] == "end" && v["from"] == "keep" && v["x"] == 550.0), "{a:?}");
+        // As the engine does it: the new end is current, and the next click curves through it.
+        curvature_extend(&mut sp, false, pt(550.0, 120.0), EndCurve::Keep);
+        let (d, id) = doc_with(sp.clone());
+        let s = selected(id, Some(5));
+        let cx = quiet(&d, &s, &p);
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Move, 650.0, 60.0));
+        assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Path { .. })), "the rubber band shows");
+        let a = press(&mut t, &cx, 650.0, 60.0, true);
+        assert!(matches!(edit_op(&a[0]), Some(("extend", v)) if v["from"] == "smooth"), "{a:?}");
+        curvature_extend(&mut sp, false, pt(650.0, 60.0), EndCurve::Smooth);
+        let (d, id) = doc_with(sp.clone());
+        let s = selected(id, Some(6));
+        let cx = quiet(&d, &s, &p);
+        // The Alt-clicked point stays a corner; a click on the first point closes.
+        assert_eq!(t.cursor(&cx, pt(0.0, 100.0), Mods::default()), Cursor::PenClose);
+        let a = press(&mut t, &cx, 0.0, 100.0, false);
+        assert!(matches!(edit_op(&a[0]), Some(("close", v)) if v["from"] == "corner" && v["end"] == "end"), "{a:?}");
+        // Any other end keeps its curve; the start goes on from the start.
+        let s = selected(id, Some(0));
+        let a = press(&mut t, &quiet(&d, &s, &p), -50.0, 150.0, false);
+        assert!(matches!(edit_op(&a[0]), Some(("extend", v)) if v["end"] == "start" && v["from"] == "keep"), "{a:?}");
+    }
 }
@@ -365,11 +365,16 @@ impl Targets {
    /// View → Snap to Point: only these targets' anchors pull, and the ruler guides (shown and
    /// unlocked, as the selection tools pick them) pull the pointer into line where they run.
    fn for_snap_to_point(self, cx: &ToolContext) -> Self {
-        let mut t = self.anchors_only();
+        self.anchors_only().with_rulers(cx)
+    }
+
+    /// These targets and the ruler guides, when they are shown (and so unlocked to the selection
+    /// tools): they pull a point into line where they run.
+    fn with_rulers(mut self, cx: &ToolContext) -> Self {
        if cx.guides {
-            t.rulers = cx.doc.guides.iter().map(|g| Ruler { vertical: g.vertical, pos: g.pos, span: cx.doc.guide_span(g) }).collect();
+            self.rulers = cx.doc.guides.iter().map(|g| Ruler { vertical: g.vertical, pos: g.pos, span: cx.doc.guide_span(g) }).collect();
        }
-        t
+        self
    }

    /// What a dragged selection's grabbed point snaps to with View → Snap to Point and Smart
@@ -486,8 +491,10 @@ impl Targets {
            if d.abs() <= 1e-9 {
                continue;
            }
+            // The ruler guides that way count as lines too (#812).
+            let rulers: Vec<(f64, Point, Kind)> = self.rulers.iter().filter(|r| r.vertical == vertical).filter_map(|r| r.line_at(q, reach)).collect();
            // A line that far across the way crosses it at least that far along.
-            for (t, from, _) in lines_near(lines, v, reach) {
+            for (t, from, _) in lines_near(lines, v, reach).iter().chain(&rulers) {
                let s = (t - a) / d;
                // Exactly on the line, whatever the rounding along the way.
                let hit = if vertical { Point::new(*t, at.y + dir.y * s) } else { Point::new(at.x + dir.x * s, *t) };
@@ -827,7 +834,9 @@ impl PointSnap {
        let targets = if cx.snap_to_pixel || cx.snap_to_grid {
            None
        } else if cx.smart_guides {
-            Some((targets().styled(cx), cx.snapping_tolerance))
+            // Snap to Point keeps pulling points onto the ruler guides with Smart Guides on (#812).
+            let t = targets().styled(cx);
+            Some((if cx.snap_to_point { t.with_rulers(cx) } else { t }, cx.snapping_tolerance))
        } else if cx.snap_to_point {
            Some((targets().for_snap_to_point(cx), cx.snap_tolerance))
        } else {
@@ -1397,6 +1406,27 @@ mod tests {
        }
    }

+    /// #812: with Smart Guides on, ruler guides pull a drawn point too (Snap to Point), horizontal
+    /// and vertical alike, also while it slides along a construction guide or Shift's angle.
+    #[test]
+    fn drawn_points_snap_to_ruler_guides_with_smart_guides_on() {
+        let (mut d, _) = doc_with_rect();
+        d.guides.push(vectorcraft_doc::Guide::new(false, 313.0));
+        d.guides.push(vectorcraft_doc::Guide::new(true, 331.0));
+        let (s, p) = (Selection::default(), paint());
+        let c = cx(&d, &s, &p);
+        let mut snap = DrawSnap::default();
+        assert_eq!(snap.press(&c, Point::new(260.0, 315.0), &[], None), Point::new(260.0, 313.0), "the horizontal guide");
+        assert_eq!(snap.press(&c, Point::new(329.0, 260.0), &[], None), Point::new(331.0, 260.0), "the vertical guide");
+        // On the 45° construction guide from (210, 210), where the horizontal guide crosses it.
+        let from = Leave::segment(&c, Point::new(210.0, 210.0), false);
+        let q = snap.press(&c, Point::new(312.0, 311.0), &[], Some(&from));
+        assert!((q - Point::new(313.0, 313.0)).hypot() < 1e-9, "{q:?}");
+        // Snap to Point off: Smart Guides alone don't use the ruler guides.
+        let off = ToolContext { snap_to_point: false, ..cx(&d, &s, &p) };
+        assert_eq!(snap.press(&off, Point::new(260.0, 315.0), &[], None), Point::new(260.0, 315.0));
+    }
+
    /// A drawing tool's snapper reuses its targets while hovering over the same document state, and
    /// gathers them again when it changes, and on every press.
    #[test]
@@ -27,7 +27,7 @@ use vectorcraft_doc::{NodeId, NodeKind};
 use vectorcraft_geom::{BezPath, Point};

 use crate::direct::hit_handle;
-use crate::draw2::AnchorTool;
+use crate::draw2::{AnchorTool, editable_paths};
 use crate::guides::{DrawSnap, Leave};
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};

@@ -122,15 +122,6 @@ fn alt_converts(cx: &ToolContext, p: Point, m: Mods) -> bool {
            || crate::draw2::segment_in(cx, editable_paths(cx), p, cx.pick_tol()).is_some())
 }

-/// The selected paths the pen edits (not guides, nor locked or hidden ones).
-fn editable_paths<'a>(cx: &'a ToolContext) -> impl Iterator<Item = NodeId> + 'a {
-    cx.selection
-        .objects
-        .iter()
-        .copied()
-        .filter(|&id| cx.doc.is_editable(id) && cx.doc.node(id).is_some_and(|n| matches!(n.kind, NodeKind::Path { guide: false, .. })))
-}
-
 /// Preview the outgoing handle of anchor `ai` of subpath `si` at `h`, the incoming one left alone.
 fn set_out_handle(id: NodeId, si: usize, ai: usize, h: Point) -> Action {
    Action::Preview(
@@ -71,6 +71,8 @@ pub struct SelectionTool {
    targets: Option<Targets>,
    moving: Option<MoveSnap>,
    guide: GuideEdit,
+    /// Smart Guides: the centre or anchor under the pointer, and its label ([`Self::hover_point`]).
+    hover: Option<(Point, &'static str)>,
 }

 /// Snapping for the selection moved as a whole, its targets gathered when the move begins: View →
@@ -163,10 +165,36 @@ fn box_hit(cx: &ToolContext, b: &OrientedBox, p: Point) -> Option<BoxHit> {
    in_rotate_zone(b.rect, lp, tol, cx.tol(18.0)).map(|_| BoxHit::Rotate)
 }

+/// How near (screen points) the pointer must come to an object's centre or anchor for Smart Guides
+/// to label it while hovering.
+const HOVER_REACH: f64 = 6.0;
+
 impl SelectionTool {
    fn drag_threshold(cx: &ToolContext) -> f64 {
        cx.tol(3.0)
    }
+
+    /// With Smart Guides on, the anchor or the centre of an object near `p` (the one under the
+    /// pointer, else a selected one) and its label, "anchor" or "center", as Illustrator shows
+    /// them while hovering (#812). A press there grabs the object by that point.
+    fn hover_point(cx: &ToolContext, p: Point) -> Option<(Point, &'static str)> {
+        if !cx.smart_guides {
+            return None;
+        }
+        let reach = cx.tol(HOVER_REACH);
+        let under = hit_test(cx.doc, p, cx.hit_options()).map(|h| h.top_object(cx.isolation));
+        let nearest = |points: &mut dyn Iterator<Item = Point>| {
+            points.filter(|q| q.distance(p) <= reach).min_by(|a, b| a.distance(p).total_cmp(&b.distance(p)))
+        };
+        under.into_iter().chain(cx.selection.objects.iter().copied()).find_map(|id| {
+            let n = cx.doc.node(id)?;
+            let anchor = n.path_data().and_then(|pd| nearest(&mut pd.subpaths.iter().flat_map(|sp| sp.anchors.iter().map(|a| a.p))));
+            anchor.map(|q| (q, "anchor")).or_else(|| {
+                let c = cx.doc.bounds_of(&[id], cx.preview_bounds)?.center();
+                (c.distance(p) <= reach).then_some((c, "center"))
+            })
+        })
+    }
 }

 impl Tool for SelectionTool {
@@ -188,6 +216,11 @@ impl Tool for SelectionTool {
        }
        let p = ev.pos;
        let m = ev.mods;
+        // A press near the hovered centre or anchor grabs the object by it.
+        let grab = self.hover.take().map(|(q, _)| q).filter(|q| q.distance(p) <= cx.tol(HOVER_REACH)).unwrap_or(p);
+        if matches!(ev.kind, PointerKind::Move) && matches!(self.state, State::Idle) {
+            self.hover = Self::hover_point(cx, p);
+        }
        match (ev.kind, self.state.clone()) {
            (PointerKind::DoubleClick, _) => {
                self.state = State::Idle;
@@ -278,7 +311,7 @@ impl Tool for SelectionTool {
                        } else if cx.selection.objects.len() > 1 && !m.cmd && !m.alt {
                            key = Some(top);
                        }
-                        self.state = State::Moving { start: p, began: false, deselect, key };
+                        self.state = State::Moving { start: grab, began: false, deselect, key };
                        out
                    }
                    None => {
@@ -397,6 +430,12 @@ impl Tool for SelectionTool {
        }
        o.extend(self.guides.iter().cloned());
        o.extend(self.guide.overlays(cx));
+        if let (Some((q, label)), State::Idle) = (self.hover, &self.state) {
+            let style = crate::guides::GuideStyle::of(cx);
+            if style.labels {
+                o.push(Overlay::Label { p: q, text: label.into(), color: style.color });
+            }
+        }
        if let Some((p, t)) = &self.measure {
            o.push(Overlay::Measure { p: *p, text: t.clone() });
        }
@@ -483,6 +522,39 @@ mod tests {
        PointerEvent::new(kind, x, y)
    }

+    /// #812: with Smart Guides on, hovering near an object's centre or an anchor labels it, and a
+    /// press there grabs the object by that point.
+    #[test]
+    fn hovering_labels_the_centre_and_anchors_and_a_press_grabs_by_them() {
+        let (d, _) = doc_with_rect();
+        let s = Selection::default();
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let label = |t: &SelectionTool| {
+            t.overlays(&cx).iter().find_map(|o| match o {
+                Overlay::Label { p, text, .. } => Some((*p, text.clone())),
+                _ => None,
+            })
+        };
+        let mut t = SelectionTool::default();
+        t.pointer(&cx, &ev(PointerKind::Move, 152.0, 151.0));
+        assert_eq!(label(&t), Some((Point::new(150.0, 150.0), "center".to_string())));
+        t.pointer(&cx, &ev(PointerKind::Move, 102.0, 101.0));
+        assert_eq!(label(&t), Some((Point::new(100.0, 100.0), "anchor".to_string())));
+        t.pointer(&cx, &ev(PointerKind::Move, 130.0, 170.0));
+        assert_eq!(label(&t), None, "away from both");
+        // Grabbed by its centre, the object's centre follows the pointer.
+        t.pointer(&cx, &ev(PointerKind::Move, 152.0, 151.0));
+        t.pointer(&cx, &ev(PointerKind::Down, 152.0, 151.0));
+        let a = t.pointer(&cx, &ev(PointerKind::Drag, 250.0, 250.0));
+        assert!(a.iter().any(|a| matches!(a, Action::Preview(_, v) if v["matrix"][4] == 100.0 && v["matrix"][5] == 100.0)), "{a:?}");
+        // With Smart Guides off, nothing is labelled.
+        let off = ToolContext { smart_guides: false, ..cx };
+        let mut t = SelectionTool::default();
+        t.pointer(&off, &ev(PointerKind::Move, 152.0, 151.0));
+        assert!(!t.overlays(&off).iter().any(|o| matches!(o, Overlay::Label { .. })));
+    }
+
    #[test]
    fn click_selects_object() {
        let (d, id) = doc_with_rect();
@@ -3355,6 +3355,7 @@ axis	Both	Ambos
@msg	cannot distort a zero-size bounding box	no se puede distorsionar un cuadro delimitador de tamaño cero
@msg	cannot read PDF: {0}	no se puede leer el PDF: {0}
@msg	cannot split an open path at its end point	no se puede dividir un trazado abierto en su punto final
+@msg	closing needs three anchors	cerrar necesita tres puntos de ancla
@msg	check an asset to export	marca un recurso para exportar
@msg	choice must be "merge" or "add", not `{choice}`	choice debe ser "merge" o "add", no `{choice}`
@msg	choose a direction to divide in	elige una dirección en la que dividir
@@ -3352,6 +3352,7 @@ axis	Both	Les deux
@msg	cannot distort a zero-size bounding box	impossible de déformer un cadre de sélection de taille nulle
@msg	cannot read PDF: {0}	impossible de lire le PDF : {0}
@msg	cannot split an open path at its end point	impossible de scinder un tracé ouvert à son extrémité
+@msg	closing needs three anchors	la fermeture nécessite trois points d’ancrage
@msg	check an asset to export	cochez une ressource à exporter
@msg	choice must be "merge" or "add", not `{choice}`	choice doit valoir "merge" ou "add", pas `{choice}`
@msg	choose a direction to divide in	choisissez une direction de division
@@ -3355,6 +3355,7 @@ axis	Both	Entrambi
@msg	cannot distort a zero-size bounding box	impossibile distorcere un riquadro di delimitazione di dimensione zero
@msg	cannot read PDF: {0}	impossibile leggere il PDF: {0}
@msg	cannot split an open path at its end point	impossibile dividere un tracciato aperto nel suo punto finale
+@msg	closing needs three anchors	per chiudere servono tre punti di ancoraggio
@msg	check an asset to export	spunta una risorsa da esportare
@msg	choice must be "merge" or "add", not `{choice}`	choice deve essere "merge" o "add", non `{choice}`
@msg	choose a direction to divide in	scegli una direzione in cui dividere
@@ -3279,6 +3279,7 @@ theme	Appearance	外観
@msg	no saved selections	保存した選択範囲はありません
@msg	no such artboard	指定されたアートボードが見つかりません
@msg	cannot split an open path at its end point	オープンパスは端点で分割できません
+@msg	closing needs three anchors	閉じるには 3 つのアンカーポイントが必要です
@msg	empty brush stroke	ブラシストロークが空です
@msg	no such anchor	指定されたアンカーポイントが見つかりません
@msg	no such segment	指定されたセグメントが見つかりません
@@ -3351,6 +3351,7 @@ axis	Both	Оба
@msg	cannot distort a zero-size bounding box	нельзя исказить ограничительную рамку нулевого размера
@msg	cannot read PDF: {0}	не удалось прочитать PDF: {0}
@msg	cannot split an open path at its end point	нельзя разделить открытый контур в его конечной точке
+@msg	closing needs three anchors	для замыкания нужны три опорные точки
@msg	check an asset to export	отметьте ресурс для экспорта
@msg	choice must be "merge" or "add", not `{choice}`	choice должно быть "merge" или "add", а не `{choice}`
@msg	choose a direction to divide in	выберите направление для разделения
@@ -3338,6 +3338,7 @@ axis	Both	Обидві
@msg	cannot distort a zero-size bounding box	не можна спотворити обмежувальну рамку нульового розміру
@msg	cannot read PDF: {0}	не вдалося прочитати PDF: {0}
@msg	cannot split an open path at its end point	не можна розділити відкритий контур у його кінцевій точці
+@msg	closing needs three anchors	для замикання потрібні три опорні точки
@msg	check an asset to export	позначте ресурс для експорту
@msg	choice must be "merge" or "add", not `{choice}`	choice має бути "merge" або "add", а не `{choice}`
@msg	choose a direction to divide in	виберіть напрямок для поділу
@@ -377,7 +377,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
        "window.swatchLibrary.other",
        "Other Library…",
        "",
-        "{path?} (default: pick a file) load a .vcswatches, .gpl or .ase library, or another document's swatches (engine: swatch.library.load), and open it in the library panel",
+        "{path?} (default: pick a file) load a .vcswatches, .gpl, .ase or .acb (color book) library, or another document's swatches (engine: swatch.library.load), and open it in the library panel",
    ),
    (
        "ui.saveSwatchLibrary",
@@ -1230,6 +1230,26 @@ the path it had begun while that stays selected. Its reply's `tool` is the tool
 {"name":"run_command","arguments":{"command":"path.moveAnchors","params":{"dx":0,"dy":40}}}
 ```

+## Editing a path with the Curvature tool
+
+The Curvature tool edits any selected path, whatever drew it, keeping its shape except where edited (#798). Each edit
+is one undo step and leaves the anchor it edited direct-selected (the tool's current point):
+`path.curvatureEdit {id, subpath?, op, …}` answers `{anchor}`. `op: "move"` with `anchor`, `x`, `y` moves a point and
+re-curves only its two segments: a smooth point turns along the line through its neighbours, and the neighbours'
+handles keep their directions (their lengths scale with the chord), so the segments beyond don't change.
+`op: "insert"` with `segment`, `t` adds a smooth point there without changing the shape (with `x`, `y` it is then
+moved there: the tool's click-and-drag on a segment). `op: "extend"` with `x`, `y` goes on from the `end` (default)
+or the `start` of an open subpath, and `op: "close"` closes it from that end; `from` says how the old end bends into
+the new segment: `"keep"` (default) keeps its curve, `"smooth"` curves it through its neighbours (a point the tool
+placed), `"corner"` leaves it without handles. Alt-click or double-click toggles a point with `path.convertAnchor`, and
+Backspace/Delete removes the current point with `path.removeAnchor`.
+
+```json
+{"name":"run_command","arguments":{"command":"path.curvatureEdit","params":{"id":12,"op":"move","anchor":2,"x":260,"y":140}}}
+{"name":"run_command","arguments":{"command":"path.curvatureEdit","params":{"id":12,"op":"extend","end":"end","x":550,"y":120}}}
+{"name":"run_command","arguments":{"command":"path.curvatureEdit","params":{"id":12,"op":"extend","x":650,"y":60,"from":"smooth"}}}
+```
+
 ## Registration and trim marks

 Every document has the built-in `[Registration]` swatch (listed after None by `swatch.list`): a colour that prints on
Author	SHA1	Message	Date
bflatasticandClaude Opus 5.5	4099ebf3c9	Fix #787 : raster exports keep translucent edges over opaque art opaque The renderer composited in 8-bit integers, so where a partly transparent anti-aliased edge crossed opaque art (or a background colour) the result came out at alpha 254 on some pixels, and PNG, TIFF and WebP files were written with an alpha channel. Raster exports (and Save for Web) now composite in floating point (vello_cpu's f32 pipeline, enabled as a feature), offscreen groups, masks and patterns included; the canvas keeps the faster 8-bit path. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-10 11:12:13 +07:00
bflatasticandClaude Opus 5.5	1db82cbc02	Fix #798 : the Curvature tool edits any selected path The Curvature tool only edited the path it was drawing. It now edits any selected path, whatever drew it, keeping its shape except where edited: a click on a point makes it the current (direct-selected) point and a drag moves it, re-curving only its two segments (the neighbours keep their handle directions); Alt-click or double-click toggles it smooth or corner and Delete removes it; a click on a segment adds a smooth point without changing the shape, and a drag moves it in the same undo step. With an end of an open path current, clicks go on from it (the old segments keep their shape) and a click on the other end closes it. The edits go through a new path.curvatureEdit command (move, insert, extend, close), path.convertAnchor and path.removeAnchor, one undo step each. The tool now claims Delete/Backspace while it has a point to remove, so the key no longer deletes the whole path. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-10 11:12:10 +07:00
bflatasticandClaude Opus 5.5	898c4f7677	Docs: ROADMAP for the 2026-10-10 fixes; Other Library lists color books The ROADMAP's last-updated line names this batch's fixes and the two community PRs that didn't add themselves (#792, #765); the platforms paragraph says Windows starts on Direct3D 12 and loads no Vulkan driver unless asked (#806); the guides row has ruler guides with Smart Guides on and the hover labels (#812). Window › Swatch Libraries › Other Library's description lists .acb color books (#831). Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-10 10:52:27 +07:00
BFlat	6b42a9100c	Merge pull request #887 from storytold/fix/812-hover-labels Part of #812: Smart Guides label an object's centre and anchors on hover	2026-10-10 10:46:53 +07:00
BFlat	1b398978ba	Merge pull request #884 from storytold/fix/827-raster-effect-blend Fix #827: shadows and glows keep their blend modes in PDF	2026-10-10 10:46:45 +07:00
BFlat	449387a62e	Merge pull request #883 from storytold/fix/812-guides-snap Part of #812: ruler guides pull drawn points with Smart Guides on	2026-10-10 10:46:28 +07:00
BFlat	0782972b88	Merge pull request #882 from storytold/fix/785-step-references Part of #785: run and command_batch steps can use earlier results	2026-10-10 10:46:10 +07:00
BFlat	07708f6cca	Merge pull request #881 from storytold/fix/861-open-error-dialog Part of #861: a file the user can't open is reported in a dialog	2026-10-10 10:46:01 +07:00
BFlat	5b26fd4d01	Merge pull request #879 from storytold/fix/831-acb-color-books Fix #831: color books (.acb) open as swatch libraries	2026-10-10 10:45:54 +07:00
BFlat	a05a6d06bf	Merge pull request #878 from storytold/fix/833-isolation-locks-outside Fix #833: isolation mode locks and dims the art around the group	2026-10-10 10:45:48 +07:00
BFlat	fd59778c8f	Merge pull request #877 from storytold/fix/775-properties-paragraph Fix #775: the Properties panel's Paragraph section justifies and hyphenates	2026-10-10 10:45:43 +07:00
BFlat	06d61296f5	Merge pull request #876 from storytold/fix/789-align-to-everywhere Fix #789: every align button aligns to the Align To choice	2026-10-10 10:45:36 +07:00
BFlat	fb4b84c4b9	Merge pull request #875 from storytold/fix/835-gradient-stop-recent Fix #835: a recent colour recolours the selected gradient stop	2026-10-10 10:45:30 +07:00
BFlat	9c0eccb067	Merge pull request #874 from storytold/fix/862-stop-popover-beside-art Fix #862: the gradient stop popover opens beside the art	2026-10-10 10:45:22 +07:00
BFlat	2b01ebcc9e	Merge pull request #873 from storytold/fix/826-rotated-rulers Fix #826: rulers cover their length in a rotated view	2026-10-10 10:45:15 +07:00
BFlat	447fe10edf	Merge pull request #872 from storytold/fix/839-sfw-pixel-size Fix #839: Save for Web accepts a typed width or height	2026-10-10 10:45:09 +07:00
BFlat	9cc0ca866d	Merge pull request #871 from storytold/fix/824-artboard-label Fix #824: the Artboard tool names its artboard once	2026-10-10 10:45:03 +07:00
BFlat	56b3119288	Merge pull request #870 from storytold/fix/806-no-vulkan-on-windows Fix #806: Windows doesn't load Vulkan drivers unless asked	2026-10-10 10:44:58 +07:00
BFlat	0b249c5257	Merge pull request #869 from storytold/fix/758-skip-hopeless-prune Part of #758: .ai import doesn't weigh text objects when the layers can't be used	2026-10-10 10:44:52 +07:00
BFlat	c1bcd0afeb	Merge pull request #863 from storytold/fix/755 Fix #755: blurred type no longer shifts as the view moves	2026-10-10 10:44:41 +07:00
BFlat	5d5db434ea	Merge pull request #860 from storytold/fix/830-app-quit-pending Fix #830: the control channel's app.quit says when it asks first	2026-10-10 10:44:34 +07:00
BFlat	84ae8e90c3	Merge pull request #859 from storytold/fix/828-effect-dropdowns Fix #828: Offset Path's Joins and Zig Zag's Points are dropdowns	2026-10-10 10:44:27 +07:00
BFlat	71d8881186	Merge pull request #753 from storytold/feat/637-type-from-text-document Part of #637: area type, threaded type and type on a path from the text document	2026-10-10 10:44:20 +07:00
bflatasticandClaude Opus 5.5	fdb7d7a183	Part of #812 : Smart Guides label an object's centre and anchors on hover With Smart Guides on, hovering the Selection tool near an object's centre or one of its anchors now labels it ("center", "anchor"), as Illustrator does, and a press there grabs the object by that point, so the point follows the pointer and snaps. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-10 10:28:38 +07:00
bflatasticandClaude Opus 5.5	99671cabd8	Fix #827 : shadows and glows keep their blend modes in PDF A raster effect painted below its object (Drop Shadow, Outer Glow) is written as an image under the object's vector art. The image was rendered over nothing and placed with Normal blending, so a Screen glow or a Multiply shadow came out as Normal in the PDF. Each image is now composited with its effects' blend mode, one image per mode when an object's shadows and glows use several. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-10 10:28:04 +07:00
bflatasticandClaude Opus 5.5	522c1dabd6	Part of #812 : ruler guides pull drawn points with Smart Guides on Drawing with Smart Guides on ignored the ruler guides: only with Smart Guides off did Snap to Point use them (a vertical guide seemed to work when it lay on the artboard's centre line, which Smart Guides follow). With Snap to Point on, the ruler guides now pull drawn and dragged points with Smart Guides on too, also while a point slides along a construction guide or Shift's angle, as in Illustrator. Co-Authored-By: Claude Opus 5.5 <[email protected]>	2026-10-10 10:28:03 +07:00