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 <noreply@anthropic.com>
Fix #798 : the Curvature tool edits any selected path
2026-10-10 11:12:13 +07:00 · 2026-10-10 11:12:10 +07:00
21 changed files with 930 additions and 51 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

@@ -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).
@@ -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> {
@@ -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();
@@ -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:?}");
+    }
 }
@@ -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(
@@ -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	виберіть напрямок для поділу
@@ -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