From 1869fc4ae875e1f9767416e35955847017d03274 Mon Sep 17 00:00:00 2001 From: yoriswind Date: Wed, 11 Nov 2026 12:40:24 -0800 Subject: [PATCH] M2: scope open-path erasing to fill-only artwork --- crates/engine/src/cmd/draw2/common.rs | 18 +- crates/engine/src/cmd/draw2/cut.rs | 148 +------- crates/engine/tests/eraser_open_fill.rs | 479 +----------------------- docs/gaps.md | 6 +- docs/roadmap.md | 6 +- docs/target-app-parity.md | 8 +- docs/ui-parity.md | 6 +- 7 files changed, 46 insertions(+), 625 deletions(-) diff --git a/crates/engine/src/cmd/draw2/common.rs b/crates/engine/src/cmd/draw2/common.rs index 89a0f44007..8ded54e072 100644 --- a/crates/engine/src/cmd/draw2/common.rs +++ b/crates/engine/src/cmd/draw2/common.rs @@ -319,17 +319,25 @@ pub(super) fn target_paths(doc: &Document, sel: &Selection, area: Rect) -> Vec bool { n.appearance.items.iter().any(|item| item.is_fill() && item.visible() && !item.paint().is_none()) } -/// [`target_paths`] for tools that cut fills, with geometry and fill rule. Closed compound paths -/// act as one shape so their holes stay holes. With `open_fills`, filled compounds with open -/// members do too; callers that only cut closed paths leave that off. +/// A visible painted stroke keeps open paths on the existing outline-erasure route. +pub(super) fn has_painted_stroke(n: &Node) -> bool { + n.appearance.items.iter().any( + |item| matches!(item, vectorcraft_doc::AppearanceItem::Stroke(stroke) if stroke.visible && !stroke.paint.is_none() && stroke.width > 0.0), + ) +} + +/// [`target_paths`] for the tools that cut fills, with each target's geometry and fill rule: the +/// members of a compound path whose members are all closed paths give the compound path itself, +/// once, so its fill (holes included) is cut as one shape under its own fill rule. +/// With `open_fills`, an open compound with a visible fill and no painted visible stroke does too. pub(super) fn fill_targets(doc: &Document, sel: &Selection, area: Rect, open_fills: bool) -> Result> { let area_compound = |n: &Node| { - let filled = open_fills && has_fill(n); + let filled = open_fills && has_fill(n) && !has_painted_stroke(n); matches!(&n.kind, NodeKind::Compound { children, .. } if children.iter().all(|c| matches!(&c.kind, NodeKind::Path { path, .. } if path.is_closed() || filled))) }; diff --git a/crates/engine/src/cmd/draw2/cut.rs b/crates/engine/src/cmd/draw2/cut.rs index 31d4198277..284b233b84 100644 --- a/crates/engine/src/cmd/draw2/cut.rs +++ b/crates/engine/src/cmd/draw2/cut.rs @@ -1,12 +1,11 @@ use super::common::{ - dist_to_polyline, fill_targets, has_fill, ids_json, path_mut, path_of, points_param, poly_bounds, pressure_region, replace_with_pieces, - samples_param, sibling_with, size_pressure, target_paths, usize_opt, + dist_to_polyline, fill_targets, has_fill, has_painted_stroke, ids_json, path_mut, path_of, points_param, poly_bounds, pressure_region, + replace_with_pieces, samples_param, sibling_with, size_pressure, target_paths, usize_opt, }; use super::{ - Anchor, AnchorKind, Appearance, Arc, Beside, BezPath, BoolOp, Cap, Document, EngineError, FillRule, Join, Node, NodeId, NodeKind, ParamCurve, - PathData, Point, Result, Session, SubPath, Value, bad, eraser_area, eraser_tip, f64_or, fill_contains, id_param, json, number_or, po, + Anchor, AnchorKind, Beside, BezPath, BoolOp, Cap, EngineError, FillRule, Join, NodeId, NodeKind, ParamCurve, PathData, Point, Result, Session, + SubPath, Value, bad, eraser_area, eraser_tip, f64_or, fill_contains, id_param, json, number_or, po, }; -use vectorcraft_doc::AppearanceItem; /// Split a filled path into connected pieces (each outer contour with its holes). pub(in super::super) fn components(pd: &PathData) -> Vec { @@ -305,124 +304,26 @@ pub(super) fn erase_region(s: &mut Session, p: &Value) -> Result { Some(bp) => fill_contains(bp, FillRule::NonZero, q), None => dist_to_polyline(&round, squash * q) <= r, }; - let mut plan = vec![]; + let mut plan: Vec<(NodeId, Vec)> = vec![]; for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, reach), true)? { - let closed = pd.is_closed(); - let node = st.doc.node(id).ok_or(EngineError::NoNode(id))?; - let painted_stroke = node - .appearance - .items - .iter() - .any(|item| matches!(item, AppearanceItem::Stroke(stroke) if stroke.visible && !stroke.paint.is_none() && stroke.width > 0.0)); - if !closed && has_fill(node) && painted_stroke && !needs_legacy_eraser(&st.doc, id) { - let fill_changed = po::area(&po::boolean(&pd, rule, ®ion, FillRule::NonZero, BoolOp::Intersect), FillRule::NonZero) > 1e-6; - let stroke = erase_outline(&pd, short / 2.0, &under); - if fill_changed || stroke.is_some() { - // Fill closes open contours implicitly; a stroke must keep only the original - // explicit segments. Keep every stroke subpath together so its paint is applied once. - let fill = po::boolean(&pd, rule, ®ion, FillRule::NonZero, BoolOp::Difference); - let stroke = stroke.map_or(pd, |pieces| PathData::new(pieces.into_iter().flat_map(|piece| piece.subpaths).collect())); - plan.push((id, ErasedPieces::Paint { fill, stroke, rule })); + // An unaggregated compound member keeps the outline route: its own appearance does not + // paint it. Eligible fill-only compounds were collected as one parent target above. + let compound_member = + st.doc.parent_of(id).and_then(|parent| st.doc.node(parent)).is_some_and(|parent| matches!(parent.kind, NodeKind::Compound { .. })); + let filled_open = !compound_member && st.doc.node(id).is_some_and(|node| has_fill(node) && !has_painted_stroke(node)); + if pd.is_closed() || filled_open { + if po::area(&po::boolean(&pd, rule, ®ion, FillRule::NonZero, BoolOp::Intersect), FillRule::NonZero) <= 1e-6 { + continue; } - continue; - } - let single = pd.subpaths.len() == 1; - let filled = !closed && st.doc.node(id).is_some_and(has_fill) && po::area(&pd, rule) > 0.0; - // Fill implicitly closes an open contour. Keep zero-area open lines - // separate: the fill Boolean would otherwise discard their stroke geometry. - let (areas, lines): (Vec<_>, Vec<_>) = - pd.subpaths.into_iter().partition(|sp| closed || (filled && (single || po::area(&PathData::single(sp.clone()), rule) > 0.0))); - let (areas, lines) = (PathData::new(areas), PathData::new(lines)); - let mut changed = false; - let mut pieces = vec![]; - if !areas.is_empty() { - if po::area(&po::boolean(&areas, rule, ®ion, FillRule::NonZero, BoolOp::Intersect), FillRule::NonZero) > 1e-6 { - changed = true; - pieces.extend(components(&po::boolean(&areas, rule, ®ion, FillRule::NonZero, BoolOp::Difference))); - } else { - pieces.push(areas); - } - } - if !lines.is_empty() { - if let Some(rest) = erase_outline(&lines, short / 2.0, &under) { - changed = true; - // Partitioning must not turn one compound outline into independently filled objects. - if single { - pieces.extend(rest); - } else if !rest.is_empty() { - pieces.push(PathData::new(rest.into_iter().flat_map(|path| path.subpaths).collect())); - } - } else { - pieces.push(lines); - } - } - if changed { - plan.push((id, ErasedPieces::Geometry(pieces))); + plan.push((id, components(&po::boolean(&pd, rule, ®ion, FillRule::NonZero, BoolOp::Difference)))); + } else if let Some(pieces) = erase_outline(&pd, short / 2.0, &under) { + plan.push((id, pieces)); } } apply_plan(s, "Eraser", plan) } -enum ErasedPieces { - Geometry(Vec), - Paint { fill: PathData, stroke: PathData, rule: FillRule }, -} - -/// Splitting paint changes effect seeds, item indices and geometry contexts. Keep targets -/// with visible effects of their own or on an ancestor on the existing route. Clipping-source -/// subtrees also stay there: groups change their mask geometry and do not supply clip paint. -fn needs_legacy_eraser(d: &Document, id: NodeId) -> bool { - let Some(ancestry) = d.ancestry(id) else { return true }; - let mut parent: Option<&Node> = None; - for id in ancestry { - let Some(node) = d.node(id) else { return true }; - if parent.is_some_and(|p| p.clips() && p.children().and_then(|children| children.first()).is_some_and(|first| first.id == id)) { - return true; - } - if node.appearance.effects.iter().any(|effect| effect.visible) - || node.appearance.items.iter().any(|item| item.effects().iter().any(|effect| effect.visible)) - { - return true; - } - parent = Some(node); - } - false -} - -/// Paint fill and explicit stroke geometry in the original stack order, with object-level -/// transparency, effects and metadata on one wrapper rather than on each painted part. -fn separate_eraser_paints(d: &mut Document, id: NodeId, fill: PathData, stroke: PathData, rule: FillRule) -> Result { - let mut root = d.node(id).cloned().ok_or(EngineError::NoNode(id))?; - // Pin before the two geometries get different bounds, so their gradients stay in place. - root.pin_gradients(); - let mut runs: Vec> = vec![]; - for item in &root.appearance.items { - if let Some(run) = runs.last_mut().filter(|run| run.first().is_some_and(|first| first.is_fill() == item.is_fill())) { - run.push(item.clone()); - } else { - runs.push(vec![item.clone()]); - } - } - let mut children = vec![]; - for items in runs { - let is_fill = items.first().is_some_and(AppearanceItem::is_fill); - let path = if is_fill { &fill } else { &stroke }; - if path.is_empty() { - continue; - } - let mut child = Node::path(d.alloc_id(), path.clone(), Appearance { items, ..Default::default() }); - if let NodeKind::Path { rule: child_rule, .. } = &mut child.kind { - *child_rule = if is_fill { FillRule::NonZero } else { rule }; - } - children.push(Arc::new(child)); - } - root.kind = NodeKind::Group { children, clip: false }; - root.appearance.items.clear(); - root.appearance.contents_index = None; - Ok(root) -} - -fn apply_plan(s: &mut Session, label: &str, plan: Vec<(NodeId, ErasedPieces)>) -> Result { +fn apply_plan(s: &mut Session, label: &str, plan: Vec<(NodeId, Vec)>) -> Result { if plan.is_empty() { return Ok(json!({ "ids": [] })); } @@ -430,18 +331,7 @@ fn apply_plan(s: &mut Session, label: &str, plan: Vec<(NodeId, ErasedPieces)>) - let mut all = vec![]; let mut cut = Beside::replacing(d, &plan.iter().map(|(id, _)| *id).collect::>()); for (id, pieces) in plan { - match pieces { - ErasedPieces::Geometry(pieces) => all.extend(replace_with_pieces(d, &mut cut, id, pieces)?), - ErasedPieces::Paint { fill, stroke, rule } => { - let root = separate_eraser_paints(d, id, fill, stroke, rule)?; - if root.children().is_some_and(Vec::is_empty) { - cut.put(d, id, vec![])?; - } else { - cut.put(d, id, vec![root])?; - all.push(id); - } - } - } + all.extend(replace_with_pieces(d, &mut cut, id, pieces)?); } cut.finish(d)?; sel.set(all.iter().copied()); @@ -462,7 +352,7 @@ pub(super) fn erase_segments(s: &mut Session, p: &Value) -> Result { for id in target_paths(&st.doc, &st.selection, poly_bounds(&pts, w)) { let (pd, _) = path_of(&st.doc, id)?; if let Some(pieces) = erase_outline(&pd, w / 2.0, &|q| dist_to_polyline(&pts, q) <= w / 2.0) { - plan.push((id, ErasedPieces::Geometry(pieces))); + plan.push((id, pieces)); } } apply_plan(s, "Path Eraser", plan) diff --git a/crates/engine/tests/eraser_open_fill.rs b/crates/engine/tests/eraser_open_fill.rs index fa7b2d90e5..d7e88e9a23 100644 --- a/crates/engine/tests/eraser_open_fill.rs +++ b/crates/engine/tests/eraser_open_fill.rs @@ -1,4 +1,4 @@ -//! Filled open-path Eraser regressions through the public engine and CPU renderer. +//! Fill-only open-path Eraser regressions through the public engine and CPU renderer. // Integration tests may unwrap and panic on failure (AGENTS.md). #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] @@ -30,26 +30,6 @@ fn paths(s: &Session) -> Vec { paths } -/// Geometric area of paths that own a visible fill, excluding stroke-only children. -/// This does not infer inherited paint from compound paths or containers. -fn own_filled_path_area(s: &Session) -> f64 { - let mut area = 0.0; - s.doc().unwrap().doc.walk(|node| { - if let NodeKind::Path { path, rule, .. } = &node.kind - && node - .appearance - .items - .iter() - .any(|item| matches!(item, vectorcraft_doc::AppearanceItem::Fill(fill) if fill.visible && !fill.paint.is_none())) - { - area += vectorcraft_pathops::area(path, *rule); - } - }); - area -} - -/// #6582: an open contour fills its implicitly closed area. Erasing a strip removes only that -/// strip, just as for the closed rectangle, rather than changing its fill to diagonal chords. #[test] fn eraser_preserves_the_fill_of_an_open_rectangle() { let samples = [(110.0, 125.0), (190.0, 125.0), (110.0, 175.0), (190.0, 175.0)]; @@ -95,92 +75,6 @@ fn eraser_preserves_the_fill_of_an_open_rectangle() { } } -fn total_line_length(paths: &[PathData], x: f64) -> f64 { - paths - .iter() - .flat_map(|path| &path.subpaths) - .filter(|subpath| !subpath.closed && subpath.anchors.len() >= 2 && subpath.anchors.iter().all(|anchor| (anchor.p.x - x).abs() < 0.01)) - .map(|subpath| subpath.anchors.windows(2).map(|pair| pair[0].p.distance(pair[1].p)).sum::()) - .sum() -} - -#[test] -fn eraser_keeps_mixed_fill_and_zero_area_strokes_with_one_undo() { - for filled_open in [true, false] { - let mut s = session(); - let id = NodeId(s.execute("path.create", &json!({"anchors": [{"x": 100, "y": 100}]})).unwrap()["id"].as_u64().unwrap()); - s.execute( - "path.setAnchors", - &json!({"id": id.0, "subpaths": [ - {"closed": !filled_open, "anchors": [{"x": 100, "y": 100}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200}]}, - {"closed": false, "anchors": [{"x": 250, "y": 100}, {"x": 250, "y": 200}]}, - {"closed": false, "anchors": [{"x": 250, "y": 220}, {"x": 250, "y": 270}]} - ]}), - ) - .unwrap(); - if filled_open { - s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); - } else { - s.execute("paint.setFill", &json!({"ids": [id.0], "none": true})).unwrap(); - } - s.execute("paint.setStroke", &json!({"ids": [id.0], "color": "#ff0000"})).unwrap(); - s.execute("stroke.set", &json!({"ids": [id.0], "weight": 2})).unwrap(); - s.execute("select.none", &json!({})).unwrap(); - - let before_miss = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); - let miss_history = s.doc().unwrap().history.undo.len(); - let miss = s.execute("path.eraseRegion", &json!({"points": [[50, 20], [250, 20]], "size": 10})).unwrap(); - assert_eq!(miss["ids"], json!([])); - assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before_miss, "a non-intersecting Eraser leaves the document unchanged"); - assert_eq!(s.doc().unwrap().history.undo.len(), miss_history, "a miss adds no history entry"); - - let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); - let before_selection = s.doc().unwrap().selection.clone(); - let before_history = s.doc().unwrap().history.undo.len(); - s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap(); - let after = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); - let after_selection = s.doc().unwrap().selection.clone(); - assert_eq!(s.doc().unwrap().history.undo.len(), before_history + 1); - - let remaining = paths(&s); - let line_length = total_line_length(&remaining, 250.0); - assert!((line_length - 140.0).abs() < 0.1, "filled_open={filled_open}: retained open strokes {line_length}"); - assert!( - remaining - .iter() - .flat_map(|path| &path.subpaths) - .filter(|sp| sp.anchors.iter().all(|a| (a.p.x - 250.0).abs() < 0.01)) - .all(|sp| !sp.closed) - ); - let image = - vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()); - for (x, y) in [(250, 120), (250, 180), (250, 240)] { - let pixel = image.pixel(x, y); - assert!(pixel[0] > 200 && pixel[1] < 60 && pixel[2] < 60 && pixel[3] > 200, "retained red stroke at ({x},{y}): {pixel:?}"); - } - if filled_open { - let area = own_filled_path_area(&s); - assert!((area - 9000.0).abs() < 1.0, "retained fill area {area}"); - for (x, y) in [(110, 125), (190, 125), (110, 175), (190, 175)] { - assert!(image.pixel(x, y)[3] > 240, "retained fill pixel ({x},{y})"); - } - assert_eq!(image.pixel(150, 150)[3], 0, "the fill erase band is empty"); - } else { - let outline_length: f64 = remaining.iter().map(PathData::length).sum(); - assert!((outline_length - 520.0).abs() < 1.0, "unfilled closed rectangle and two open lines retain 520 pt of stroke: {outline_length}"); - assert!(remaining.iter().flat_map(|path| &path.subpaths).all(|subpath| !subpath.closed), "unfilled outline survivors stay open"); - assert_eq!(image.pixel(150, 145)[3], 0, "outline splitting does not add a stroke across the rectangle interior"); - } - - s.execute("edit.undo", &json!({})).unwrap(); - assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before, "one Undo restores the exact document"); - assert_eq!(s.doc().unwrap().selection, before_selection); - s.execute("edit.redo", &json!({})).unwrap(); - assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), after, "one Redo restores the exact erased document"); - assert_eq!(s.doc().unwrap().selection, after_selection); - } -} - #[test] fn eraser_keeps_open_compound_holes_with_both_fill_rules() { for rule in ["nonZero", "evenOdd"] { @@ -280,374 +174,3 @@ fn eraser_removes_only_the_swept_strip_from_a_zero_signed_area_open_bowtie() { let area: f64 = paths(&s).iter().map(|path| vectorcraft_pathops::area(path, FillRule::NonZero)).sum(); assert!((area - 4500.0).abs() < 1.0, "retained bowtie area {area}"); } - -/// Even-Odd can cancel a nonzero signed area: that open path still has an erasable stroke. -#[test] -fn eraser_cuts_the_outline_when_even_odd_cancels_an_open_paths_fill() { - let mut s = session(); - let made = s.execute("path.create", &json!({"d": "M100 100H200V200H100V100H200V200H100V100"})).unwrap(); - let id = NodeId(made["id"].as_u64().unwrap()); - s.execute("paint.setFill", &json!({"color": "#000000"})).unwrap(); - s.execute("paint.setStroke", &json!({"color": "#ff0000"})).unwrap(); - s.execute("stroke.set", &json!({"weight": 2})).unwrap(); - s.execute("path.setFillRule", &json!({"rule": "evenOdd"})).unwrap(); - s.execute("select.none", &json!({})).unwrap(); - let original = path(&s, id); - assert!(!original.is_closed()); - assert!(original.subpaths.first().unwrap().signed_area().abs() > 10000.0); - assert!(vectorcraft_pathops::area(original, FillRule::EvenOdd) < 1e-9, "Even-Odd cancels the two laps"); - assert!((original.length() - 800.0).abs() < 1e-9); - assert_eq!(render_erased(&s).pixel(150, 125)[3], 0, "the cancelled interior is transparent before Eraser"); - - s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap(); - let length: f64 = paths(&s).iter().map(PathData::length).sum(); - assert!((length - 760.0).abs() < 0.1, "both laps lose their crossed stroke portions: {length}"); - assert_eq!(render_erased(&s).pixel(150, 125)[3], 0, "Eraser does not paint the cancelled interior outside its sweep"); -} - -/// Hidden fills retain open outlines, while a lower visible fill beneath None still paints. -#[test] -fn eraser_hidden_fill_keeps_only_the_explicit_open_outline() { - let render = |s: &Session| { - vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()) - }; - for lower_fill in [false, true] { - let mut s = session(); - let id = NodeId( - s.execute( - "path.create", - &json!({"anchors": [ - {"x": 100, "y": 100}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200} - ]}), - ) - .unwrap()["id"] - .as_u64() - .unwrap(), - ); - s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); - s.execute("paint.setStroke", &json!({"ids": [id.0], "color": "#ff0000"})).unwrap(); - s.execute("stroke.set", &json!({"ids": [id.0], "weight": 2})).unwrap(); - if lower_fill { - // The basic black Fill remains visible underneath this added top Fill set to None. - s.execute("appearance.addFill", &json!({"ids": [id.0]})).unwrap(); - s.execute("appearance.setItem", &json!({"ids": [id.0], "index": 2, "none": true})).unwrap(); - } else { - // Basic appearance order is Fill 0, Stroke 1; hiding Fill 0 leaves only open strokes. - s.execute("appearance.setItem", &json!({"ids": [id.0], "index": 0, "visible": false})).unwrap(); - } - s.execute("select.none", &json!({})).unwrap(); - let before = render(&s); - if lower_fill { - assert!(before.pixel(150, 125)[3] > 240, "the lower black fill remains visible under top None"); - } else { - assert_eq!(before.pixel(150, 125)[3], 0, "hidden fill leaves the interior empty"); - assert_eq!(before.pixel(100, 125)[3], 0, "the open path has no implicit left stroke"); - } - assert!(before.pixel(200, 125)[0] > 200 && before.pixel(200, 125)[1] < 60, "the explicit right stroke is visible"); - - s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap(); - let after = render(&s); - if lower_fill { - assert!(after.pixel(150, 125)[3] > 240, "visible lower fill survives above the erased band"); - assert!(after.pixel(150, 175)[3] > 240, "visible lower fill survives below the erased band"); - assert_eq!(after.pixel(150, 150)[3], 0, "the Eraser band is empty"); - } else { - let survivors = paths(&s); - assert!(survivors.iter().all(|path| !path.is_closed()), "unfilled survivors remain open"); - let length: f64 = survivors.iter().map(PathData::length).sum(); - assert!((length - 290.0).abs() < 0.1, "only the crossed explicit right edge loses 10 pt: {length}"); - assert_eq!(after.pixel(150, 125)[3], 0, "hidden fill leaves the interior empty"); - assert_eq!(after.pixel(100, 125)[3], 0, "the missing implicit left stroke remains absent"); - } - } -} - -/// The original compound's cancelled outline stays grouped beside its filled contour. -#[test] -fn eraser_even_odd_cancellation_survives_beside_a_filled_subpath() { - let mut s = session(); - let id = NodeId( - s.execute("path.create", &json!({"d": "M100 100H200V200H100V100H200V200H100V100 M230 100H280V200H230"})).unwrap()["id"].as_u64().unwrap(), - ); - s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); - s.execute("paint.setStroke", &json!({"ids": [id.0], "color": "#ff0000"})).unwrap(); - s.execute("stroke.set", &json!({"ids": [id.0], "weight": 2})).unwrap(); - s.execute("path.setFillRule", &json!({"ids": [id.0], "rule": "evenOdd"})).unwrap(); - s.execute("select.none", &json!({})).unwrap(); - assert_eq!(path(&s, id).subpaths.len(), 2, "one node holds both open subpaths"); - assert!(path(&s, id).subpaths.iter().all(|subpath| !subpath.closed)); - let render = |s: &Session| { - vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()) - }; - let before = render(&s); - assert_eq!(before.pixel(150, 125)[3], 0, "the twice-traced open subpath cancels under Even-Odd"); - assert_eq!(before.pixel(150, 175)[3], 0, "the cancelled lower run is empty before Eraser"); - assert!(before.pixel(250, 125)[3] > 240, "the disjoint open rectangle fills"); - assert_eq!(before.pixel(230, 125), [0, 0, 0, 255], "the second contour has fill but no explicit left stroke"); - assert_eq!(before.pixel(229, 125), [0, 0, 0, 0], "there is no stroke outside its implicit closing edge"); - - s.execute("path.eraseRegion", &json!({"points": [[50, 150], [290, 150]], "size": 10})).unwrap(); - let after = render(&s); - assert_eq!(after.pixel(150, 175)[3], 0, "the cancelled interior stays empty below the sweep"); - assert!(after.pixel(250, 125)[3] > 240, "the disjoint filled subpath survives"); - assert_eq!(after.pixel(250, 150)[3], 0, "the swept band through the filled subpath is empty"); - for (x, y) in [(230, 125), (229, 125)] { - assert_eq!(after.pixel(x, y), before.pixel(x, y), "the implicit closing edge stays unstroked at ({x},{y})"); - } - for (x, y) in [(100, 125), (200, 125), (280, 125)] { - let pixel = after.pixel(x, y); - assert!(pixel[0] > 200 && pixel[1] < 60 && pixel[2] < 60 && pixel[3] > 200, "open outline survivor ({x},{y}): {pixel:?}"); - } -} -#[test] -fn eraser_preserves_the_missing_edge_of_a_filled_open_stroke() { - let mut failures = vec![]; - for (opacity, expected_alpha) in [(100, 255u8), (50, 128u8)] { - for closed in [true, false] { - let (mut s, id) = painted_open_rectangle(closed); - s.execute("transparency.set", &json!({"ids": [id.0], "opacity": opacity})).unwrap(); - s.execute("select.none", &json!({})).unwrap(); - let mut check = |ok: bool, message: String| { - if !ok { - failures.push(format!("closed={closed} opacity={opacity}: {message}")); - } - }; - let before = render_erased(&s); - for y in [125, 175] { - check(before.pixel(150, y)[3].abs_diff(expected_alpha) <= 1, format!("original fill at y={y}: {:?}", before.pixel(150, y))); - } - let before_left = before.pixel(99, 125); - if closed { - check(before_left[0] > before_left[1] && before_left[3] > 0, format!("closed control's explicit red left edge: {before_left:?}")); - } else { - check(before_left[3] == 0, format!("open source has no implicit left stroke: {before_left:?}")); - } - let before_overlap = before.pixel(199, 125); - check(before_overlap[3].abs_diff(expected_alpha) <= 1, format!("object opacity is applied once before Eraser: {before_overlap:?}")); - check(before_overlap[0] > before_overlap[1] && before_overlap[3] > 0, format!("visible fill and red stroke overlap: {before_overlap:?}")); - s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap(); - let after = render_erased(&s); - for y in [125, 175] { - check( - after.pixel(150, y) == before.pixel(150, y), - format!("retained fill at y={y}: before {:?}, after {:?}", before.pixel(150, y), after.pixel(150, y)), - ); - } - check(after.pixel(150, 150)[3] == 0, format!("Eraser band is empty: {:?}", after.pixel(150, 150))); - let after_left = after.pixel(99, 125); - check(after_left == before_left, format!("left-edge stroke: before {before_left:?}, after {after_left:?}")); - let after_overlap = after.pixel(199, 125); - check(after_overlap == before_overlap, format!("unaffected fill/stroke overlap: before {before_overlap:?}, after {after_overlap:?}")); - check(after_overlap[0] > after_overlap[1] && after_overlap[3] > 0, format!("explicit right stroke remains visible: {after_overlap:?}")); - } - } - assert!(failures.is_empty(), "{}", failures.join("\n")); -} - -fn render_erased(s: &Session) -> vectorcraft_render::Rendered { - vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 300, 300, vectorcraft_geom::Affine::IDENTITY, &Default::default()) -} - -fn painted_open_rectangle(closed: bool) -> (Session, NodeId) { - let mut s = session(); - let id = NodeId( - s.execute( - "path.create", - &json!({"closed": closed, "anchors": [ - {"x": 100, "y": 100}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200} - ]}), - ) - .unwrap()["id"] - .as_u64() - .unwrap(), - ); - s.execute("paint.setFill", &json!({"ids": [id.0], "color": "#000000"})).unwrap(); - s.execute("paint.setStroke", &json!({"ids": [id.0], "color": "#ff0000"})).unwrap(); - s.execute("stroke.set", &json!({"ids": [id.0], "weight": 2})).unwrap(); - (s, id) -} - -fn assert_eraser_history(s: &mut Session, before: &serde_json::Value, before_selection: &vectorcraft_doc::Selection) { - let after = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); - let after_selection = s.doc().unwrap().selection.clone(); - let after_pixels = render_erased(s).pixels; - s.execute("edit.undo", &json!({})).unwrap(); - assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), *before, "one Undo restores the exact source"); - assert_eq!(s.doc().unwrap().selection, *before_selection); - s.execute("edit.redo", &json!({})).unwrap(); - assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), after, "one Redo restores the exact erased document"); - assert_eq!(s.doc().unwrap().selection, after_selection); - assert_eq!(render_erased(s).pixels, after_pixels, "Redo restores the rendered appearance"); -} - -#[test] -fn eraser_keeps_object_metadata_and_mask_once_around_separate_fill_and_stroke() { - let (mut s, id) = painted_open_rectangle(false); - let mask = NodeId(s.execute("shape.rectangle", &json!({"x": 80, "y": 80, "width": 140, "height": 140})).unwrap()["id"].as_u64().unwrap()); - s.execute("paint.setFill", &json!({"ids": [mask.0], "color": "#ffffff"})).unwrap(); - s.execute("paint.setStroke", &json!({"ids": [mask.0], "none": true})).unwrap(); - s.execute("transparency.makeOpacityMask", &json!({"ids": [id.0, mask.0]})).unwrap(); - s.execute( - "transparency.set", - &json!({"ids": [id.0], "opacity": 50, "blend": "multiply", "isolate": true, "knockout": "off", "knockoutShape": true}), - ) - .unwrap(); - s.execute("attributes.set", &json!({"ids": [id.0], "note": "Eraser source", "showCenter": true})).unwrap(); - // A stored object axis is independent of this axis-aligned fixture's geometry. - s.edit("Fixture metadata", |doc, _| { - let n = doc.node_mut(id).unwrap(); - n.name = Some("Filled open stroke".into()); - n.bbox_angle = 17.0; - Ok(()) - }) - .unwrap(); - s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); - let original = s.doc().unwrap().doc.node(id).unwrap().clone(); - let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); - let before_selection = s.doc().unwrap().selection.clone(); - let before_history = s.doc().unwrap().history.undo.len(); - let before_image = render_erased(&s); - assert!(before_image.pixel(150, 125)[3].abs_diff(128) <= 1); - s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap(); - assert_eq!(s.doc().unwrap().history.undo.len(), before_history + 1); - let root = s.doc().unwrap().doc.node(id).unwrap(); - let NodeKind::Group { children, clip: false } = &root.kind else { panic!("fill and stroke share one ordinary object wrapper") }; - assert_eq!( - (&root.name, root.opacity, root.blend, root.isolate, root.knockout, root.knockout_shape, root.bbox_angle), - (&original.name, original.opacity, original.blend, original.isolate, original.knockout, original.knockout_shape, original.bbox_angle) - ); - assert_eq!(root.extras(), original.extras(), "the mask and Attributes remain on the object"); - assert!(!children.is_empty()); - for child in children { - assert!(child.name.is_none() && child.has_default_transparency(), "paint lanes do not repeat object metadata or transparency"); - assert_eq!(child.bbox_angle, 0.0); - assert_eq!(child.extras(), &vectorcraft_doc::NodeExtras::default()); - } - let after = render_erased(&s); - for (x, y) in [(99, 125), (150, 125), (150, 175), (199, 125)] { - assert_eq!(after.pixel(x, y), before_image.pixel(x, y), "object appearance outside the sweep at ({x},{y})"); - } - assert_eq!(after.pixel(150, 150)[3], 0); - assert_eraser_history(&mut s, &before, &before_selection); -} - -#[test] -fn eraser_keeps_a_painted_clipping_source_on_the_legacy_path_route() { - let mut results = vec![]; - for closed in [true, false] { - let mut s = session(); - let art = NodeId(s.execute("shape.rectangle", &json!({"x": 90, "y": 90, "width": 60, "height": 120})).unwrap()["id"].as_u64().unwrap()); - s.execute("paint.setFill", &json!({"ids": [art.0], "color": "#ff0000"})).unwrap(); - s.execute("paint.setStroke", &json!({"ids": [art.0], "none": true})).unwrap(); - let clip = NodeId( - s.execute( - "path.create", - &json!({"closed": closed, "anchors": [ - {"x": 100, "y": 100}, {"x": 200, "y": 100}, {"x": 200, "y": 200}, {"x": 100, "y": 200} - ]}), - ) - .unwrap()["id"] - .as_u64() - .unwrap(), - ); - let group = NodeId(s.execute("object.clippingMask.make", &json!({"ids": [art.0, clip.0]})).unwrap()["id"].as_u64().unwrap()); - s.execute("paint.setFill", &json!({"ids": [clip.0], "color": "#0000ff"})).unwrap(); - s.execute("paint.setStroke", &json!({"ids": [clip.0], "color": "#00ff00"})).unwrap(); - s.execute("stroke.set", &json!({"ids": [clip.0], "weight": 2})).unwrap(); - s.execute("select.set", &json!({"ids": [clip.0]})).unwrap(); - let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); - let before_selection = s.doc().unwrap().selection.clone(); - let image = render_erased(&s); - assert_eq!(image.pixel(110, 125), [255, 0, 0, 255], "clipped art paints above the clipping fill"); - assert_eq!(image.pixel(180, 125), [0, 0, 255, 255], "clipping fill paints behind the art"); - assert_eq!(image.pixel(199, 125), [0, 255, 0, 255], "clipping stroke paints over the fill"); - assert_eq!(image.pixel(90, 125)[3], 0, "art outside the clip is hidden"); - s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap(); - let doc = &s.doc().unwrap().doc; - let NodeKind::Group { children, clip: true } = &doc.node(group).unwrap().kind else { panic!("the clipping group is retained") }; - let source = children.first().unwrap(); - assert_eq!(source.id, clip); - assert!(matches!(source.kind, NodeKind::Path { .. }), "the actual clipping source stays a path"); - let paint = source.clip_paint(); - assert!(paint.fill.is_some() && paint.stroke.is_some(), "the clipping source keeps its fill and stroke paint"); - assert_eq!(render_erased(&s).pixel(150, 150)[3], 0, "the clipping region loses the sweep band"); - // Legacy fill Booleans close both source contours. This deliberately pins that existing - // painted-clip behavior against the unchanged closed-source route, not the ordinary fix. - results.push(render_erased(&s).pixels); - assert_eraser_history(&mut s, &before, &before_selection); - } - assert_eq!(results[0], results[1], "open clipping sources retain the existing closed-fill Boolean behavior"); -} - -#[test] -fn eraser_separates_an_ordinary_open_stroke_inside_a_clipping_group() { - let (mut s, art) = painted_open_rectangle(false); - let clip = NodeId(s.execute("shape.rectangle", &json!({"x": 80, "y": 80, "width": 140, "height": 140})).unwrap()["id"].as_u64().unwrap()); - s.execute("object.clippingMask.make", &json!({"ids": [art.0, clip.0]})).unwrap(); - s.execute("select.set", &json!({"ids": [art.0]})).unwrap(); - let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); - let before_selection = s.doc().unwrap().selection.clone(); - let original_clip = s.doc().unwrap().doc.node(clip).unwrap().clone(); - let before_image = render_erased(&s); - assert_eq!(before_image.pixel(99, 125)[3], 0); - assert_eq!(before_image.pixel(150, 125), [0, 0, 0, 255]); - s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap(); - assert_eq!(s.doc().unwrap().doc.node(clip).unwrap(), &original_clip, "the actual clipping source is untouched"); - let after = render_erased(&s); - for (x, y) in [(99, 125), (150, 125), (150, 175), (199, 125)] { - assert_eq!(after.pixel(x, y), before_image.pixel(x, y), "ordinary clipped art retains its appearance at ({x},{y})"); - } - assert_eq!(after.pixel(150, 150)[3], 0); - assert_eraser_history(&mut s, &before, &before_selection); -} - -#[test] -fn eraser_keeps_a_live_outline_strokes_original_appearance_context() { - let mut results = vec![]; - for closed in [true, false] { - let (mut s, id) = painted_open_rectangle(closed); - s.execute("stroke.set", &json!({"ids": [id.0], "weight": 10})).unwrap(); - s.execute("effect.apply", &json!({"ids": [id.0], "effect": "path.outlineStroke", "item": null, "params": {}})).unwrap(); - s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); - let original = s.doc().unwrap().doc.node(id).unwrap(); - assert_eq!(original.appearance.stroke().unwrap().width, 10.0); - assert!(original.appearance.effects.iter().any(|effect| effect.visible && effect.id == "path.outlineStroke")); - let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap(); - let before_selection = s.doc().unwrap().selection.clone(); - s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap(); - let after = render_erased(&s); - assert!(after.pixels.as_chunks::<4>().0.iter().any(|pixel| pixel[3] > 0), "the live effect still paints"); - results.push(after.pixels); - assert_eraser_history(&mut s, &before, &before_selection); - } - // The legacy fill Booleans produce identical closed survivors and retain the 10 pt context. - assert_eq!(results[0], results[1], "an open source with a live effect retains the closed legacy rendering"); -} - -#[test] -fn eraser_preserves_a_translucent_fill_above_the_stroke() { - use vectorcraft_color::{Color, Paint}; - use vectorcraft_doc::{AppearanceItem, FillLayer}; - let (mut s, id) = painted_open_rectangle(false); - s.edit("Fixture top fill", |doc, _| { - let node = doc.node_mut(id).unwrap(); - assert!(matches!(node.appearance.items.last(), Some(AppearanceItem::Stroke(_)))); - let mut fill = FillLayer::new(Paint::solid(Color::WHITE)); - fill.opacity = 0.5; - node.appearance.items.push(AppearanceItem::Fill(fill)); - Ok(()) - }) - .unwrap(); - s.execute("select.set", &json!({"ids": [id.0]})).unwrap(); - let before = render_erased(&s); - let near = |actual: [u8; 4], expected: [u8; 4]| actual.iter().zip(expected).all(|(a, e)| a.abs_diff(e) <= 1); - assert!(near(before.pixel(199, 125), [255, 128, 128, 255]), "half-opacity white covers red: {:?}", before.pixel(199, 125)); - assert!(near(before.pixel(150, 125), [128, 128, 128, 255]), "half-opacity white covers black: {:?}", before.pixel(150, 125)); - assert_eq!(before.pixel(99, 125), [0, 0, 0, 0]); - s.execute("path.eraseRegion", &json!({"points": [[50, 150], [250, 150]], "size": 10})).unwrap(); - let after = render_erased(&s); - for (x, y) in [(199, 125), (150, 125), (99, 125)] { - assert_eq!(after.pixel(x, y), before.pixel(x, y), "paint order and item opacity survive at ({x},{y})"); - } - assert_eq!(after.pixel(150, 150)[3], 0, "the swept band is empty"); -} diff --git a/docs/gaps.md b/docs/gaps.md index 71df386984..5222bab0ac 100644 --- a/docs/gaps.md +++ b/docs/gaps.md @@ -4,7 +4,7 @@ ## Feature submission evidence -> **Eraser fill update (2026-11-11):** ordinary filled open paths retain fill and explicit strokes outside the sweep (#6582); clipping sources and live effects retain legacy behavior; scores and estimates unchanged. +> **Eraser fill update (2026-11-11):** filled open paths without a visible painted stroke retain fill outside the sweep (#6582); stroked paths retain main behavior; scores and estimates unchanged. **Feature evidence last updated:** 2026-11-03. @@ -307,7 +307,7 @@ macOS cursor delivery (#2292) is narrowed to a native host adapter using the exi ## G11 Correctness bugs in core tools -- **Improved (#6582):** the Eraser subtracts its swept area from filled open contours, preserving fill outside the stroke. Open compound members keep their holes under either fill rule; zero-area open lines keep outline splitting. Ordinary filled open paths with visible strokes keep separate fill and explicit-stroke geometry in their original paint order, preserving missing closing edges, Even-Odd cancellation and object opacity. Thirteen engine integration regressions check rendered pixels, geometry, paint order, masks, mixed paths and history. Clipping-source subtrees and paths with visible appearance effects on themselves or an ancestor retain the existing route; its stroke-closure and canceled-fill limitations remain open pending the scope decision. Scores and estimates unchanged. +- **Improved (#6582), fill-only scope:** the Eraser subtracts its swept area from filled open contours with no visible painted stroke, preserving fill outside the sweep. Fill-only open compound members are cut together under their compound fill rule so holes stay empty. The result keeps the existing path/compound piece structure and whole appearance. Filled-and-stroked open paths deliberately retain the outline-splitting behavior from main. Public reference semantics for those stroked paths were not established, and their fill behavior is not claimed fixed here. Focused engine integration tests cover fill-only open/closed geometry and pixels, compound holes and self-crossing fill. Scores and estimates unchanged. - **Export-only improvement (#6309):** PDF export keeps harakat and zero-advance Noto Arabic dot glyphs in one compatible batch per layout line, with per-glyph vertical offsets (#6309). `crates/pdf/src/tests/realtext.rs` (`mark_text_*`) checks decoded cluster mappings, mixed Arabic/Latin/digits, contour placement against outline export, vertical columns, differing path rotations and PDF/X-1a/3/4. Editable-text import preserves authored ActualText separately (#6165), with cross-line/style layout limits; separately styled or differently rotated clusters and external viewer search/copy remain outside this export-only evidence. Broader G11 scope, scores and estimates unchanged. @@ -861,7 +861,7 @@ trap, and the defaults (0.25 pt, 100%, 40%) are VectorCraft's own, the pages giv | 2026-11-11 | minor | G5: built-in Energy Beams brush library (Laser Bolt, Plasma Arc, Charge Wave, Spark Trail); Missing trimmed; estimate 5–15 → 4–14 h; MCP Brush libraries list Energy Beams. | | 2026-11-11 | minor | G5: built-in Skill Icons symbol library (Attack, Defend, Heal, Buff, Ult); Missing trimmed; estimate 6–16 → 5–15 h; MCP Symbol libraries list Skill Icons. | | 2026-11-10 | minor | G6: MCP catalogue (#6460): headless lists `UI_COMMANDS` (`ui: true`), eight prompts, effect vs command ids, 33 tools, commands/reference; estimate unchanged. | -| 2026-11-11 | minor | Eraser: filled open contours and compound holes use area cutting; ordinary fills and explicit strokes keep separate geometry; clipping sources and live effects retain legacy behavior (#6582). Scores and estimates unchanged. | +| 2026-11-11 | minor | Eraser: fill-only open contours and compound holes use area cutting; stroked open paths retain main behavior (#6582). Scores and estimates unchanged. | | 2026-11-11 | minor | G5: built-in Status Effects graphic style library (Poison Tint, Freeze Edge, Burn Aura, Stun Pulse, Stealth Fade, Shield Buff); Missing trimmed; estimate 7–17 → 6–16 h; MCP docs list UI Frames and Map Markers under Symbol libraries. | | 2026-11-11 | minor | G5: built-in Inventory Icons symbol library (Sword, Shield, Potion, Key, Gem; no default 9-slice); Missing trimmed; estimate 8–18 → 7–17 h. | | 2026-11-10 | minor | G4 type: Edit › Edit Custom Dictionary… adds, deletes and changes the custom dictionary's words, #4936; the Check Spelling dialog remains; scores and estimates unchanged. | diff --git a/docs/roadmap.md b/docs/roadmap.md index d22b08caff..7807fa9b18 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -4,7 +4,7 @@ > > Vector Halftone preview update (2026-11-10): temporary dot selection marks are hidden, and the bounding box stays available (#6369). > -> **Eraser fill update (2026-11-11):** ordinary filled open paths retain fill and explicit strokes outside the sweep (#6582); clipping sources and live effects retain legacy behavior; scores and estimates unchanged. +> **Eraser fill update (2026-11-11):** filled open paths without a visible painted stroke retain fill outside the sweep (#6582); stroked paths retain main behavior; scores and estimates unchanged. > > **Flyout update:** 2026-11-06 — resizable icon-strip flyouts and bottom-aligned panel footers (#5713); scores and estimates unchanged. > @@ -55,7 +55,7 @@ M7 type: Touch Type moves a right-to-left character along its line and up from i | 2026-11-08 | minor | Character Styles panel: a double-click on a user style's row opens its Character Style Options (`ui.charStyleOptions`); the dialog keeps a fixed width and scrolls its sections in a shorter window, so OK and Cancel stay on screen. Tests `panels::text_styles::tests::double_clicking_a_character_style_row_opens_its_options` and `dialogs::char_style_options::tests::the_sections_scroll_in_a_window_shorter_than_the_general_list`. Scores and estimates unchanged. | | 2026-11-08 | minor | #3380, deletion only: preserve gradient placement and exact surviving geometry; consume owned subpaths with a shared original-node snapshot; consolidate status/evidence and document command/helper contracts. Compound behavior and the existing M2 status entry are retained. Endpoint highlighting remains open; scores and estimates unchanged. | | 2026-11-10 | minor | M13 / G6: MCP catalogue (#6460): headless lists UI commands, eight prompts, 33 tools, effect vs command ids; scores and estimates unchanged. | -| 2026-11-11 | minor | Eraser: filled open contours and compound holes use area cutting; ordinary fills and explicit strokes keep separate geometry; clipping sources and live effects retain legacy behavior (#6582). Scores and estimates unchanged. | +| 2026-11-11 | minor | Eraser: fill-only open contours and compound holes use area cutting; stroked open paths retain main behavior (#6582). Scores and estimates unchanged. | | 2026-11-07 | minor | #3380 (deletion only): independent surviving path objects; transformed appearance, stacking, selection, cubic handles and Undo/Redo covered by `delete_path_pieces`; compound semantics retained. Endpoint highlighting remains open; scores and estimates unchanged. | | 2026-11-02 | minor | Selection QoL: saved marquee modes, screen drag direction with a 3 px dead zone, and translated mode/E feedback (#5313); VectorCraft addition, scores and estimates unchanged. | | 2026-11-07 | minor | Indian-language hyphenation (#4947): eleven MIT-licensed pattern sets, with grapheme and shaping-cluster protection in both composers and existing paragraph limits. Assamese and Sanskrit are selectable; Sanskrit automatic patterns remain pending an allowlisted source. Scores and estimates unchanged. | @@ -144,7 +144,7 @@ native wording review, layout checks and a web Devanagari font remain. [Notes](l |---|---|---|---| | M0 | Skeleton + vertical slice | ✅ done | — | | M1 | Selection, transform, layers, MCP (common command tools, strict keys, session resources and version-aware result hints) | ✅ mostly done (document-tab artwork drag with lossless resource transfer and one target Undo; malformed MCP app replies discard the connection without replay, #1761; bounded control socket waits and connection-slot recovery, #1726; bounded synthetic control input, #1709; no-op anchor Align keeps Undo, Redo and saved state (#1180 follow-up); transform reference point snaps to anchors/centres; rotated objects keep a rotated bounding box and their angle; Free Transform, Scale and Reflect along a rotated box pending; the Transform fields take one Tab each, the W/H link after them) | 4–6 | -| M2 | Drawing tools + smart guides | ✅ mostly done (Eraser preserves fill outside its sweep on open paths and keeps compound holes and ordinary explicit strokes; clipping-source/live-effect follow-up remains open (#6582); #3380 deletion creates independent selected path pieces and keeps bounds-fitted gradients in place; endpoint highlighting remains open; Polygon/Star exact-size count persistence, with repeated-drag, tool-switch and Cancel regression coverage; Curvature point markers without direction handles (#1236, in part); Direct Selection segment click/Delete preserves neighboring edges, #1278; Flare, Reshape, Live Corners widget dragging and per-corner radii and kinds landed, on any path's corners; Shaper rough-shape recognition and orientation steps, the remaining Pen modifier nuances; Shaper Groups with editable sources and separate fill/stroke edits landed; custom ruler origin with drag preview, active-artboard reset, relative X/Y fields and native round-trip (#1212); construction widget/refinements pending); a shape just drawn moves by its centre point and turns from the zone outside a corner with its tool still active (#5477); Tangent and straight-segment perpendicular snapping use saved Smart Guides Geometric Guides preferences and Control bar quick access (#2537), including the existing Snap to Glyph and Alignment Guides toggles (#6164); no View submenu; Copy and Cut with the Pen or Curvature tool take the anchors a Cmd/Ctrl-lent Direct Selection picked (#6123) | 12–18 | +| M2 | Drawing tools + smart guides | ✅ mostly done (Eraser preserves fill outside its sweep on fill-only open paths and keeps their compound holes; stroked open paths retain main behavior (#6582); #3380 deletion creates independent selected path pieces and keeps bounds-fitted gradients in place; endpoint highlighting remains open; Polygon/Star exact-size count persistence, with repeated-drag, tool-switch and Cancel regression coverage; Curvature point markers without direction handles (#1236, in part); Direct Selection segment click/Delete preserves neighboring edges, #1278; Flare, Reshape, Live Corners widget dragging and per-corner radii and kinds landed, on any path's corners; Shaper rough-shape recognition and orientation steps, the remaining Pen modifier nuances; Shaper Groups with editable sources and separate fill/stroke edits landed; custom ruler origin with drag preview, active-artboard reset, relative X/Y fields and native round-trip (#1212); construction widget/refinements pending); a shape just drawn moves by its centre point and turns from the zone outside a corner with its tool still active (#5477); Tangent and straight-segment perpendicular snapping use saved Smart Guides Geometric Guides preferences and Control bar quick access (#2537), including the existing Snap to Glyph and Alignment Guides toggles (#6164); no View submenu; Copy and Cut with the Pen or Curvature tool take the anchors a Cmd/Ctrl-lent Direct Selection picked (#6123) | 12–18 | | M3 | Paint & appearance (swatches, color, gradient, stroke, appearance, transparency, styles) | ✅ done (M3.7–M3.98): swatches, groups, libraries, tints, Lab spots and Registration; Eyedropper styles highlighted text only (atomic transparency rejection); Eyedropper reads visible locked and outside-isolation sources (#1251); Color Picker, Color panel, Color Guide, Color Themes, Edit Colors and Recolor Artwork (screen-bounded Edit chip list, #3416); gradients that follow every transform, the annotator, linked stops, freeform gradients, focal points, gradients on strokes and Expand; visible strokes when paint is added to inherited None/zero-width art (#1253); stroke geometry, arrowheads, dashes fitted to corners, stroke on type, width profiles and the Width tool (Shift-double-click enables adjoining adjustment in Width Point Edit; finite-arithmetic follow-up regressions and full CI passed ([Validation evidence](target-app-parity.md#evidence-what-ships-today-by-area))), Scale Strokes and preview bounds; Appearance targeting, container appearance, target circles, Expand Appearance; knockout, isolation, blend accuracy, CMYK blending, overprint, Attributes, masks and clipping, Flatten Transparency; graphic styles, links and libraries; CSS library export preserves fractional linear and radial gradient stop positions. Left: freeform gradients in SVG/PDF, mixed spot/process gradients in SVG and PDF gradients mixing a spot color with RGB or Lab stops export as stops or process colors; PDF export writes dithered gradient fills with spot stops, and Perceptual spot gradients with RGB or Lab stops other than white or more than 4,096 stops on their curve, as images in process colors; confirm the Scale Strokes & Effects default; Recolor model selection is available through the engine and MCP only (#2520); the dialog retains its existing controls | 4–8 | | M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | PDF authored ActualText preserved once in editable import (#6165; first-glyph line/style, bounded input; estimates unchanged); PDF export keeps harakat and zero-advance Noto Arabic dot glyphs in one compatible batch per layout line, with per-glyph vertical offsets (#6309). `crates/pdf/src/tests/realtext.rs` (`mark_text_*`) checks decoded cluster mappings, mixed Arabic/Latin/digits, contour placement against outline export, vertical columns, differing path rotations and PDF/X-1a/3/4. Editable-text import preserves authored ActualText separately (#6165), with cross-line/style layout limits; separately styled or differently rotated clusters and external viewer search/copy remain outside this export-only evidence. `.ai`/EPS type from the text document keeps its paragraphs' tab stops (#6147); `.ai`/EPS type from the text document keeps auto leading per line, its hyphenation options, and may show more of the last lines the file sets in an area frame of its own, when growing the frame by its lines' deepest descent plus 0.05 pt shows them (#6137); ✅ done (M4.14–M4.98 on 2026-10-05): Save As/Save a Copy/Revert/templates, Data Recovery and background save, SVG import and export fidelity (units, text, symbols, filters, SVGZ, Preserve Editing, SVG Options), shared guarded PDF writer and windowed reader ([pdf-backend.md](pdf-backend.md)), PDF import (colours, layers, masks, editable text, security) and export (presets, marks, bleed, ICC and output intent, raster effects, subset fonts, PDF/X-1a, X-3 and X-4, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3), Place and Links, Package, EPS and DXF in and out (EPS legacy mesh corners, vector opacity masks and raster page comparison verified; closed SPLINE flags round-trip and circular paths export as native CIRCLE/ARC, #1299), EMF/WMF, TIFF/BMP/Targa/PSD/GIF/PNG-8 export, Print and print presets, slices, Save for Web, TIFF in Export for Screens and Asset Export, clipboard flavours, File Info; AF.1–AF.4 add Affinity import (native layers, artboards, vectors, text and images from Affinity 1–3 files; the embedded preview only as a warned fallback; AF.4 expands current `.af` fixtures and every-board round-trip validation); EPS Save and Save As keep an opened EPS as EPS with its page frame and complete editable VectorCraft document (2026-10-26; G9 import fidelity unchanged). Left: DWG (use DXF), PSD placement as layers, overprint read back from PDF, Affinity export, polish; SVG CSS classes survive export and repeated import in all four styling modes (#2480); current-main integration retains event attributes and scripts; SVG CSS classes survive export and repeated import in all four styling modes (#2480); current-main integration retains event attributes and scripts | 3–6 (existing scope; Affinity export unestimated) | | M5 | Performance | 🟡 background render + caches + MT done; `vectorcraft-cli bench` and `vectorcraft-cli perf` (budget suite); opaque solid-fill knockout paths draw once in hard-edge/supersampled raster export, with analytical-AA compositing unchanged; file format v2 opens 3× faster (50k paths: 722 → 244 ms); raster effects (glows, shadows, blur, feather) no longer force the whole frame single-threaded (filtered offscreen per effect, verified equal to the single-threaded reference); Craquelure/Mosaic Tiles/Stained Glass distance searches optimized with pixel-invariance checks and the `texture_drag_perf` probe (#1257); effect-heavy demos need a clean-machine benchmark; dirty-region rendering, GPU backend spike pending | 15–25 | diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index 189da23121..b5297c98de 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -4,7 +4,7 @@ > > Vector Halftone preview update (2026-11-10): temporary dot selection marks are hidden, and the bounding box stays available (#6369). > -> **Eraser fill update (2026-11-11):** ordinary filled open paths retain fill and explicit strokes outside the sweep (#6582); clipping sources and live effects retain legacy behavior; scores and estimates unchanged. +> **Eraser fill update (2026-11-11):** filled open paths without a visible painted stroke retain fill outside the sweep (#6582); stroked paths retain main behavior; scores and estimates unchanged. > > **Flyout update:** 2026-11-06 — resizable icon-strip flyouts and bottom-aligned panel footers (#5713); scores and estimates unchanged. @@ -217,7 +217,7 @@ dominate; 3D, graphs and automation are specialist). They sum to 105. Feature de | Area | Weight | Done | Main gaps | One agent (h) | Kind | |---|---:|---:|---|---:|---| | Selection, transform & align tools | 6 | 85% | Direct Selection segment click/Delete corrected (#1278); deletion splits an ordinary contour into selected sibling objects with bounds-fitted gradients kept in place (#3380, deletion only; `crates/engine/tests/it/delete_path_pieces.rs`); open-path anchor Delete keeps gaps; Select › Start Global Edit finds the paths, compound paths and symbol instances of the selected object's shape (Appearance, Size and artboard options) and gives an edit of one to all of them in proportion, as one undo step (#3521), and on a group the groups like it, an edit inside one reaching the same object in the others (#4939), and a Shift-click on a highlighted match leaves it out; the Align panel menu's Align to Glyph Bounds › Point Text and Area Text measure type by its glyphs' ink for Align and Distribute (#4231); remaining: Free Transform/Scale/Reflect along a rotated box, Global Edit of rotated copies, transform nuances (no-op anchor Align history regression-tested, #1180 follow-up) | 4–6 | estimated; Global Edit regression-tested (`crates/engine/src/tests/globaledit.rs`; Quick Action, menu label and Escape in `panels::properties::tests::start_global_edit_quick_action_and_escape`) | -| Drawing tools (Pen, Curvature, Pencil, shapes, Shaper) | 7 | 85% | Shaper construction widget, Pencil/Pen nuances, Blob Brush options, Touch Type, Dimension tool; see [ui-parity.md](ui-parity.md) | 8–13 | estimated; Curvature point display regression-tested (#1236, in part); Polygon/Star exact-size count persistence regression-covered; Live Corners' Relative rounding done (#3091), score unchanged; Copy and Cut with the Pen or Curvature tool take the anchors a Cmd/Ctrl-lent Direct Selection picked (#6123), score and hours unchanged; Eraser preserves ordinary filled open-path area and explicit strokes outside its sweep, including compound holes and mixed stroked lines; clipping-source/live-effect correction remains open (#6582; `crates/engine/tests/eraser_open_fill.rs`), score and hours unchanged | +| Drawing tools (Pen, Curvature, Pencil, shapes, Shaper) | 7 | 85% | Shaper construction widget, Pencil/Pen nuances, Blob Brush options, Touch Type, Dimension tool; see [ui-parity.md](ui-parity.md) | 8–13 | estimated; Curvature point display regression-tested (#1236, in part); Polygon/Star exact-size count persistence regression-covered; Live Corners' Relative rounding done (#3091), score unchanged; Copy and Cut with the Pen or Curvature tool take the anchors a Cmd/Ctrl-lent Direct Selection picked (#6123), score and hours unchanged; Eraser preserves fill-only open-path area outside its sweep, including compound holes; stroked open paths retain main behavior and result structure (#6582; `crates/engine/tests/eraser_open_fill.rs`), score and hours unchanged | | Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 80% | Shape Builder on the reporter's file (#937: art past 4,096 segments is cut by lines again; unconfirmed on the file itself); gap detection shares Live Paint’s finder, with a 72 pt custom cap and the existing options; Live Paint Gap Options | 4–8 | estimated; Shape Builder Gap Detection shares Live Paint’s spatial gap finder and temporary merge bridges (#2526); Custom is capped at 72 pt in the existing options dialog (lowered from 86%: open issues); compound attributes regression-tested (#1197); single-result source names survive SVG export/import (#1293), with [SVG ID semantics](https://www.w3.org/TR/SVG2/struct.html#IDAttribute) and original-shape tests; Simplify component selection and preview regression-tested (#1272); Simplify of a Direct Selection part of a path regression-tested (`tests/simplify_part.rs`); Divide open-cutting-path geometry and appearance regression-tested (#1307); the Shape Builder's edge-source grid is bounded in memory and files a segment once per cell (`planar.rs` test `rect_index_holds_a_bounded_number_of_references`); live compound shapes (Make, Alt-click, member Shape Modes, Release, Expand, saved and exported) regression-tested (#4522) | | Colour, swatches, gradients, patterns, mesh, recolor | 7 | 92% | 30.0's gradient additions are done (dither, perceptual blending, presets); freeform gradients in SVG/PDF, mixed spot/process gradients in SVG, PDF gradients mixing a spot color with RGB or Lab stops, and dithered spot gradient fills and Perceptual spot gradients with RGB or Lab stops other than white or more than 4,096 stops on their curve, which PDF export writes as images in process colors | 4–7 | estimated; Recolor model selection is available through the engine and MCP (#2520), and the dialog's color sliders (HSB, RGB, CMYK, Lab, Tint for a spot color) edit the selected row's new color in its mode, and the Edit tab's Global Adjust sliders (Saturation, Brightness, Temperature, Luminosity, -100% to 100%) change every recolored color at once (lowered from 96%: target moved); unpainted zero-width stroke restoration fixed (#1253), score and hours unchanged; Eyedropper source reads regression-tested (#1251); screen-bounded Recolor Edit chip list (#3416), score and hours unchanged | | Strokes, brushes, width profiles | 5 | 88% | Shift-double-click adjoining adjustment is implemented; brush libraries are done (six generated libraries including Game Trails and Energy Beams, User Defined, Other Library…, Save Brushes); Art brush Overlap and Pattern brush auto corners are done; remaining: pen pressure on macOS, Stylus Wheel, more built-in brush libraries, tilt, bearing and rotation for Art, Pattern and Bristle brushes and on native Wayland and the web | 8–15 | estimated; width-point creation and adjoining adjustment regression-tested; dialog layout reviewed; evidence below; finite-arithmetic follow-up regressions and full CI passed (evidence below) | @@ -945,7 +945,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur While a spiral is dragged out, Alt adds or removes whole winds of four segments and Ctrl/Cmd changes the decay. The spiral's inner end keeps the distance from the center it had on the first modified drag event, while the outer end follows the pointer. The [default keyboard shortcuts](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html) (archived copy) list Alt-drag to add or subtract winds and Ctrl-drag to change the decay rate; [Draw spirals](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/draw-shapes/draw-spirals.html) defines four segments per full wind and Decay as the amount each wind decreases. An 80% spiral has 80% of its outer radius after four segments; newly drawn spirals with the same settings wind more broadly than in earlier VectorCraft builds. Rounding the fitted count to whole winds from the count on the first Alt-only drag event, the held inner radius, the ranges (2…1000 segments, 5…99.99 % decay), Ctrl/Cmd taking precedence when both are held, and the new values staying as Spiral tool options are our own rules. Switching back to Alt uses the current count as its new base while keeping the held inner end. Escape while an arc, spiral or grid is dragged out cancels it and puts back the options its keys, Alt and Ctrl/Cmd changed (slope, open or closed, base axis, segments, decay, dividers and skews), so the next drag and the tool's options start from the values before the canceled drag; a drag that is let go keeps them, and an option set with `tool.setOption` during the drag stays. This is VectorCraft's own rule. - **Cutting:** Eraser, Scissors, Knife, Mirror & Cut, Line Cut and Rectangle Cut (real geometry, compound paths keep their holes). - The Eraser cuts filled open contours as areas (#6582), retaining fill outside its sweep. Open compound members are cut together under their compound fill rule so holes stay empty. Ordinary filled open paths keep closed fill geometry separate from their original explicit stroke segments, with the original paint order and object transparency on one wrapper. Canceled Even-Odd fill stays empty; zero-area open lines retain outline splitting. Thirteen tests in `crates/engine/tests/eraser_open_fill.rs` check open/closed shapes, retained/erased pixels, self-crossing fill, compound holes, missing stroke edges, object/item opacity, masks, mixed strokes and Undo/Redo. Painted clipping-source subtrees and paths with visible self/ancestor appearance effects deliberately retain the legacy route; that route can still add closing-edge strokes or reveal canceled fill. Their broader correction remains an open scope decision. Scores and hours are unchanged. + The Eraser cuts fill-only open contours as areas (#6582), retaining fill outside its sweep. An eligible appearance has a visible non-None fill and no visible non-None stroke of positive width. Fill-only open compound members are cut together under their compound fill rule so holes stay empty. Cut pieces keep the existing path/compound representation and whole appearance. Filled-and-stroked open paths retain the outline-splitting behavior from main. `crates/engine/tests/eraser_open_fill.rs` covers fill-only open/closed geometry and raster output, compound holes and self-crossing fill. This deliberately scoped fix does not claim to repair filled-and-stroked open-path fill behavior. Scores and hours are unchanged. A Scissors cut (`path.split`) leaves one of the two new end points selected and the rest of the path unselected, as [Cut paths](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/modify-paths/split-paths.html) and the "Split a path" section of the [CS3 user guide](https://help.adobe.com/archive/en_US/illustrator/cs3/illustrator_cs3_help.pdf) describe: the two end points lie on top of each other, and a Direct Selection drag from them moves the selected one with its handles and no other anchor. A closed path cut once stays one open path. While Alt is held, the Scissors tool works as the Add Anchor Point tool ([Default keyboard shortcuts](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html)): a click on a segment adds an anchor point without cutting (`path.insertAnchor`), and the pointer shows the Add Anchor Point cursor. When Alt is let go, a click cuts again. Alt-drag with the Knife cuts in a straight line, and Shift+Alt-drag cuts at 45° or 90°, as [Cut objects using the Knife and Scissors tools](https://web.archive.org/web/20260926095638/https://helpx.adobe.com/illustrator/desktop/manage-objects/edit-objects/cut-objects.html) and [Default keyboard shortcuts](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html) describe. Alt counts only when held at the press; the dashed line runs from the press point to the pointer, stays straight after Alt is let go, and release sends `path.knife` with those two points. Alt pressed after the press leaves the cut freehand. Shift+Alt keeps the endpoint at 45° steps from the horizontal and vertical, whatever the Constrain Angle. @@ -1982,7 +1982,7 @@ Edit › Copy and Cut put the selected ruler guides on the clipboard, with the s | 2026-11-11 | minor | Bundled content: built-in Energy Beams brush library (Laser Bolt, Plasma Arc, Charge Wave, Spark Trail); brush libraries evidence updated; ~44% → ~46%; more built-in brush libraries remain. | | 2026-11-11 | minor | Bundled content: built-in Skill Icons symbol library (Attack, Defend, Heal, Buff, Ult); symbol libraries evidence updated; ~42% → ~44%; more built-in symbol libraries remain. | | 2026-11-10 | minor | Automation: MCP tool count 33; headless `command_list` lists `UI_COMMANDS` (`ui: true`); eight prompts; effect-id vs command-id clarified (#6460); scores and hours unchanged. | -| 2026-11-11 | minor | Eraser: filled open contours and compound holes use area cutting; ordinary fills and explicit strokes keep separate geometry; clipping sources and live effects retain legacy behavior (#6582). Scores and estimates unchanged. | +| 2026-11-11 | minor | Eraser: fill-only open contours and compound holes use area cutting; stroked open paths retain main behavior (#6582). Scores and estimates unchanged. | | 2026-11-11 | minor | Bundled content: built-in Status Effects graphic style library; style libraries evidence updated; ~40% → ~42%; MCP Symbol libraries list UI Frames and Map Markers; more built-in graphic-style libraries remain. | | 2026-11-11 | minor | Bundled content: built-in Inventory Icons symbol library (Sword, Shield, Potion, Key, Gem); symbol libraries evidence updated; ~38% → ~40%; more built-in symbol libraries remain. | | 2026-11-10 | minor | Type advanced: the Edit Custom Dictionary dialog, #4936; evidence added; the Check Spelling dialog remains; scores and hours unchanged. | diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 5443d19623..9e82932395 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -4,7 +4,7 @@ > > Vector Halftone preview update (2026-11-10): temporary dot selection marks are hidden, and the bounding box stays available (#6369). > -> **Eraser fill update (2026-11-11):** ordinary filled open paths retain fill and explicit strokes outside the sweep (#6582); clipping sources and live effects retain legacy behavior; scores and estimates unchanged. +> **Eraser fill update (2026-11-11):** filled open paths without a visible painted stroke retain fill outside the sweep (#6582); stroked paths retain main behavior; scores and estimates unchanged. > > Numeric spinner update (2026-11-10): held mouse arrows repeat past the click timeout; scores and estimates unchanged (#6307). @@ -160,7 +160,7 @@ tools, never checked side by side) isn't captured row by row. | Anchor Point and Curvature tools' own cursors | done | the caret on the anchor it converts; the pen nib with a curve badge | | Free Transform's Cmd/Ctrl side-shear cursor | done | two arrows passing along the side (ShearH, ShearV), instead of the resize arrow across it | | Cursors of their own for Lasso, Magic Wand, the freehand tools, Shaper, Live Paint Bucket, Measure, Print Tiling, the symbolism tools, vertical type, Scissors (over a segment and away), Mesh and Puppet Warp | partial | each tool returns its own cursor and Use Precise Cursors turns them into the crosshair; until they're drawn they borrow the crosshair, the I-beam, the Pen's add cursor or not-allowed | -| Eraser: filled open paths and compound holes | partial | Area cutting preserves fill outside the swept region (#6582). Ordinary filled open paths preserve explicit strokes, paint order, opacity and canceled fill with separate fill/stroke geometry; zero-area open lines retain outline splitting. Thirteen engine integration tests cover rendered pixels, geometry, holes, masks, mixed strokes and history. Clipping-source/live-effect correction remains open; see G11 in [gaps.md](gaps.md#g11-correctness-bugs-in-core-tools). | +| Eraser: filled open paths and compound holes | partial | Fill-only open paths preserve fill outside the sweep and compound holes under their fill rule (#6582). Focused engine tests cover open/closed geometry, raster output, compound holes and self-crossing fill. Filled-and-stroked open paths retain main behavior; that fill behavior is not claimed fixed. See G11 in [gaps.md](gaps.md#g11-correctness-bugs-in-core-tools). | | Blob Brush and Eraser: the tip's outline at the pointer | done | before a press and while painting, the outline of the tip (its size, angle and roundness, at the zoom) follows the pointer, black on a white halo, round a small centre dot; `[` / `]` and Tool Options change it at once; precise cursors (Caps Lock) show only the crosshair; it goes when the pointer leaves the canvas, while Cmd/Ctrl lends a selection tool and while Alt lends the Blob Brush the Smooth tool (#4977); `crates/tools/src/draw2/gesture.rs` and its tests While the button is down a round Blob Brush shows the outline of the area it will add, rounded at both ends, not a line as wide as the brush that ends square (#4343). | | Busy cursor during long operations | done | Background open, save and export show the system progress cursor (gap G1) | | Each anchor snaps to Smart Guides and construction angles | done | `DrawSnap` | @@ -514,7 +514,7 @@ separate. Scores and hours unchanged. [Behavior and command details](development | Date | Change | Summary | |---|---|---| -| 2026-11-11 | minor | Eraser: filled open contours and compound holes use area cutting; ordinary fills and explicit strokes keep separate geometry; clipping sources and live effects retain legacy behavior (#6582). Scores and estimates unchanged. | +| 2026-11-11 | minor | Eraser: fill-only open contours and compound holes use area cutting; stroked open paths retain main behavior (#6582). Scores and estimates unchanged. | | 2026-11-11 | minor | Outline view: a click on a path's outline selects it through an image or a gradient mesh in front, which Outline draws as a frame or mesh lines (#6437). | | 2026-11-11 | minor | A middle-click on a document tab (or its ×) closes it as the × does; closing a document's last view with unsaved changes asks to save first (#6506). VectorCraft addition; scores and estimates unchanged. | | 2026-11-03 | minor | A double-click on a ruler adds a guide at the pointer (#5239): a vertical one on the top ruler, a horizontal one on the left ruler; scores and estimates unchanged. |