From 21da73402fd8bc28264a0d13b435faf85c016934 Mon Sep 17 00:00:00 2001
From: dotCooCoo <RobertLeeLW@gmail.com>
Date: Fri, 13 Nov 2026 22:56:22 -0800
Subject: [PATCH 1/7] Live Paint: Make keeps every fill and stroke row that
 draws on the source

Object > Live Paint > Make gave each new face and edge one fresh row
built from only the source's topmost fill or stroke paint and the top
stroke's weight. A lower row that draws was lost, a hidden top row
became visible, and the rows' opacity, blending mode, effects and
stroke settings were dropped.

- A face takes every fill row that draws (shown, with paint and an
  opacity above 0) of its front-most covering source that has one and
  an opacity above 0, in order with their settings. A source in front
  whose fill does not draw no longer hides the fill behind it.
- An edge takes every stroke row of its source that draws (also with a
  weight above 0). Faces and edges take the source's opacity and
  blending mode; gradients keep their fit on the source, and pen
  pressure stays with the source.
- Where a path is cut into several edges, each edge runs the way the
  path does, its dashes go on from where it starts along the path, the
  arrowheads stay at the path's own ends, and a width profile or brush
  stays only on an edge that runs the whole path.
- Rows that draw nothing stay with the stored sources, which Release
  returns unchanged. Merge and Gap Options build their new parts the
  same way.

Docs: livePaint.make params, docs/mcp.md, docs/target-app-parity.md.
---
 crates/engine/src/cmd/buildcmds.rs | 274 +++++++++++++++++++++++++++--
 crates/engine/src/tests/build.rs   | 234 +++++++++++++++++++++++-
 docs/mcp.md                        |  15 +-
 docs/target-app-parity.md          |   1 +
 4 files changed, 510 insertions(+), 14 deletions(-)

diff --git a/crates/engine/src/cmd/buildcmds.rs b/crates/engine/src/cmd/buildcmds.rs
index 3fc5953619..a1c06e6490 100644
--- a/crates/engine/src/cmd/buildcmds.rs
+++ b/crates/engine/src/cmd/buildcmds.rs
@@ -14,7 +14,7 @@ use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
 use serde_json::{Value, json};
-use vectorcraft_color::{Color, Paint};
+use vectorcraft_color::{BlendMode, Color, Paint};
 use vectorcraft_doc::appearance::{AppearanceItem, FillLayer, LineCap, LineJoin, StrokeLayer};
 use vectorcraft_doc::{Appearance, Document, GapOptions, GapSize, LiveShape, Node, NodeId, NodeKind, Selection, TraceView};
 use vectorcraft_geom::{FillRule, PathData, Point, Rect, SubPath};
@@ -72,7 +72,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Make",
             ["Object", "Live Paint"],
             Some("Cmd+Alt+X"),
-            "{ids?|id?} build a Live Paint group from the selected paths (paths, compound paths and groups of them; type, images and other objects are refused, nothing changes); each covered face starts with its front-most covering source's fill; with a Live Paint group among them, add the others to it as livePaint.merge does; a Live Paint group alone has nothing to add, so it is selected and nothing changes (no undo step) → {id, faces, edges}",
+            "{ids?|id?} build a Live Paint group from the selected paths (paths, compound paths and groups of them; type, images and other objects are refused, nothing changes); each covered face starts with the fill rows that draw (shown, with paint and an opacity above 0) of its front-most covering source that has one and an opacity above 0, and each edge with the stroke rows that draw (also a weight above 0) of its source, in order with their settings and with that source's opacity and blending mode (on a path cut into several edges, dashes go on along the path, arrowheads stay at its own ends, and a width profile or brush stays only on an edge that runs the whole path); a face or edge given no such row has one unpainted row; with a Live Paint group among them, add the others to it as livePaint.merge does; a Live Paint group alone has nothing to add, so it is selected and nothing changes (no undo step) → {id, faces, edges}",
             has_selection_or_ids,
             lp_make
         ),
@@ -414,22 +414,256 @@ fn source_nodes(n: &Node) -> Vec<Arc<Node>> {
     if is_live_paint(n) { b::sources(n).and_then(|g| g.children().cloned()).unwrap_or_default() } else { vec![Arc::new(n.clone())] }
 }
 
+/// Does appearance row `i` draw: it is shown, has paint and an opacity above 0, and a stroke also
+/// has a weight above 0?
+fn row_draws(i: &AppearanceItem) -> bool {
+    match i {
+        AppearanceItem::Fill(f) => f.visible && !f.paint.is_none() && f.opacity > 0.0,
+        AppearanceItem::Stroke(s) => s.visible && !s.paint.is_none() && s.opacity > 0.0 && s.width > 0.0,
+    }
+}
+
+/// What a source path gives the faces and edges made from it.
+struct SourceStyle {
+    /// The fill rows that draw, in paint order (none when the path's opacity is 0).
+    fills: Vec<AppearanceItem>,
+    /// The stroke rows that draw, in paint order (none when the path's opacity is 0).
+    strokes: Vec<AppearanceItem>,
+    /// The top stroke's weight, for an edge given no stroke that draws.
+    width: f64,
+    opacity: f32,
+    blend: BlendMode,
+}
+
+impl SourceStyle {
+    /// The style of source path `n`: its rows keep their order and settings, gradients fitted to
+    /// its bounds keep that fit, and the strokes' pen pressure, tilt, bearing and rotation stay
+    /// with the path.
+    fn of(n: &Node) -> Self {
+        let mut a = (*n.appearance).clone().without_pressure();
+        if a.has_unplaced_gradient()
+            && let Some(bounds) = n.geometric_bounds()
+        {
+            a.pin_gradients(bounds);
+        }
+        let width = a.stroke().map_or(1.0, |s| s.width);
+        let (mut fills, mut strokes) = (vec![], vec![]);
+        if n.opacity > 0.0 {
+            for i in a.items.into_iter().filter(row_draws) {
+                if i.is_fill() { fills.push(i) } else { strokes.push(i) }
+            }
+        }
+        Self { fills, strokes, width, opacity: n.opacity, blend: n.blend }
+    }
+
+    /// Give part `n` the rows `rows` of this source with its opacity and blending mode; with no
+    /// rows, `n` keeps the unpainted row it has.
+    fn paint(&self, n: &mut Node, rows: &[AppearanceItem]) {
+        if rows.is_empty() {
+            return;
+        }
+        n.appearance = Appearance { items: rows.to_vec(), ..Default::default() }.into();
+        n.opacity = self.opacity;
+        n.blend = self.blend;
+    }
+}
+
+/// How far, in points, a place on an edge may be from its source path and still be on it.
+const ON_SOURCE: f64 = 0.05;
+
+/// Does stroke row `i` have settings that depend on where along its path a piece of it lies:
+/// dashes, arrowheads, a width profile or a brush?
+fn depends_on_place(i: &AppearanceItem) -> bool {
+    matches!(i, AppearanceItem::Stroke(s) if s.dash.is_some() || s.start_arrow.is_some() || s.end_arrow.is_some() || s.profile.is_some() || s.brush.is_some())
+}
+
+/// One subpath's segments with the length along it where each starts, then its whole length, and
+/// a grid of square cells listing the segments whose bounds, grown by [`ON_SOURCE`], reach into
+/// each cell, so finding the segments near a point does not look at every segment.
+struct Track {
+    segs: Vec<kurbo::PathSeg>,
+    at: Vec<f64>,
+    closed: bool,
+    cell: f64,
+    grid: HashMap<(i64, i64), Vec<usize>>,
+    /// Segments that reach into more than [`Track::MAX_CELLS`] cells, or that come after the grid
+    /// holds [`Track::CELLS_PER_SEGMENT`] entries per segment, looked at for every point.
+    wide: Vec<usize>,
+}
+
+impl Track {
+    const ACCURACY: f64 = 1e-4;
+    const MAX_CELLS: i64 = 4096;
+    const CELLS_PER_SEGMENT: usize = 16;
+
+    fn new(sp: &SubPath) -> Self {
+        use kurbo::{ParamCurveArclen, Shape as _};
+        let mut bp = kurbo::BezPath::new();
+        sp.to_bezpath_into(&mut bp);
+        let segs: Vec<kurbo::PathSeg> = bp.segments().collect();
+        let mut at = Vec::with_capacity(segs.len() + 1);
+        let mut len = 0.0;
+        for s in &segs {
+            at.push(len);
+            len += s.arclen(Self::ACCURACY);
+        }
+        at.push(len);
+        let boxes: Vec<kurbo::Rect> = segs.iter().map(|s| s.bounding_box().inflate(ON_SOURCE, ON_SOURCE)).collect();
+        // Cells about as wide as an average segment's bounds.
+        let mean = boxes.iter().map(|b| b.width().max(b.height())).sum::<f64>() / boxes.len().max(1) as f64;
+        let cell = if mean.is_finite() { mean.max(4.0 * ON_SOURCE) } else { 4.0 * ON_SOURCE };
+        let mut grid: HashMap<(i64, i64), Vec<usize>> = HashMap::new();
+        let mut wide = vec![];
+        // The grid holds at most this many entries in all.
+        let mut budget = boxes.len().saturating_mul(Self::CELLS_PER_SEGMENT);
+        for (k, b) in boxes.iter().enumerate() {
+            let (x0, y0) = Self::cell_of(Point::new(b.x0, b.y0), cell);
+            let (x1, y1) = Self::cell_of(Point::new(b.x1, b.y1), cell);
+            let cells = x1.saturating_sub(x0).saturating_add(1).saturating_mul(y1.saturating_sub(y0).saturating_add(1));
+            let Some(cells) = usize::try_from(cells).ok().filter(|&c| cells <= Self::MAX_CELLS && c <= budget) else {
+                wide.push(k);
+                continue;
+            };
+            budget -= cells;
+            for x in x0..=x1 {
+                for y in y0..=y1 {
+                    grid.entry((x, y)).or_default().push(k);
+                }
+            }
+        }
+        Self { segs, at, closed: sp.closed, cell, grid, wide }
+    }
+
+    fn cell_of(p: Point, cell: f64) -> (i64, i64) {
+        ((p.x / cell).floor() as i64, (p.y / cell).floor() as i64)
+    }
+
+    fn len(&self) -> f64 {
+        self.at.last().copied().unwrap_or(0.0)
+    }
+
+    /// The lengths along the subpath to each of its segments' places nearest `p` that are within
+    /// [`ON_SOURCE`] of it (more than one where the subpath passes `p` again).
+    fn places(&self, p: Point) -> Vec<f64> {
+        use kurbo::{ParamCurve, ParamCurveArclen, ParamCurveNearest};
+        let near = self.grid.get(&Self::cell_of(p, self.cell)).map(Vec::as_slice).unwrap_or_default();
+        let mut out = vec![];
+        for &k in near.iter().chain(&self.wide) {
+            let Some(s) = self.segs.get(k) else { continue };
+            let n = s.nearest(p, 1e-9);
+            if n.distance_sq <= ON_SOURCE * ON_SOURCE {
+                out.push(self.at.get(k).copied().unwrap_or(0.0) + s.subsegment(0.0..n.t).arclen(Self::ACCURACY));
+            }
+        }
+        out
+    }
+
+    /// The signed length from `a` to `b` along the subpath (the shorter way round a closed one).
+    fn step(&self, a: f64, b: f64) -> f64 {
+        let (d, len) = (b - a, self.len());
+        if self.closed && len > 0.0 { d - len * (d / len).round() } else { d }
+    }
+
+    /// Of `places`, the one nearest along the subpath to `target`.
+    fn nearest(&self, places: &[f64], target: f64) -> Option<f64> {
+        places.iter().copied().min_by(|x, y| self.step(*x, target).abs().total_cmp(&self.step(*y, target).abs()))
+    }
+}
+
+/// Where edge `edge` runs along its source path, whose subpaths' tracks are `tracks`: the length
+/// along the source subpath to the edge's start, whether the edge starts at that subpath's start and
+/// ends at its end (an open subpath), and whether it runs the whole subpath. The middle of the
+/// edge's first segment places it, and its ends are taken where they lie that far along the source,
+/// so a path that passes a point twice is told apart. An edge that runs against the direction of its
+/// source is reversed first. `None` when the edge is not a single piece found on the source.
+fn edge_run(tracks: &[Track], edge: &mut PathData) -> Option<(f64, bool, bool, bool)> {
+    use kurbo::{ParamCurve, ParamCurveArclen};
+    let [sp] = edge.subpaths.as_slice() else { return None };
+    if sp.segment_count() == 0 {
+        return None;
+    }
+    let (a, z) = (sp.anchors.first()?.p, if sp.closed { sp.anchors.first()?.p } else { sp.anchors.last()?.p });
+    let first = sp.segment(0);
+    let mid = first.eval(0.5);
+    let half = first.subsegment(0.0..0.5).arclen(Track::ACCURACY);
+    let length = sp.anchor_arc_positions().last().copied().unwrap_or(0.0);
+    let edge_closed = sp.closed;
+    // (how far off the fit is, track, start, end, runs forward) for the subpath that fits best.
+    let mut found: Option<(f64, &Track, f64, f64, bool)> = None;
+    for track in tracks {
+        // The start lies half the first segment before its middle along the source, or after it
+        // when the edge runs the other way: take the place and way that fit best.
+        let starts_at = track.places(a);
+        let mut best: Option<(f64, f64, bool)> = None;
+        for pm in track.places(mid) {
+            for forward in [true, false] {
+                let Some(pa) = track.nearest(&starts_at, if forward { pm - half } else { pm + half }) else { continue };
+                let miss = (if forward { track.step(pa, pm) } else { track.step(pm, pa) } - half).abs();
+                if best.is_none_or(|(m, _, _)| miss < m) {
+                    best = Some((miss, pa, forward));
+                }
+            }
+        }
+        let Some((miss, pa, forward)) = best else { continue };
+        let target = if forward { pa + length } else { pa - length };
+        let Some(pz) = track.nearest(&track.places(z), target) else { continue };
+        let miss = miss + track.step(pz, target).abs();
+        if found.is_none_or(|(m, ..)| miss < m) {
+            found = Some((miss, track, pa, pz, forward));
+        }
+    }
+    let (_, track, pa, pz, forward) = found?;
+    let (from, to) = if forward { (pa, pz) } else { (pz, pa) };
+    if !forward {
+        edge.reverse();
+    }
+    let open = !track.closed;
+    let starts = open && from <= ON_SOURCE;
+    let ends = open && to >= track.len() - ON_SOURCE;
+    let whole = if open { starts && ends } else { edge_closed };
+    Some((from, starts, ends, whole))
+}
+
+/// Fit stroke row `row` of a source path to an edge cut from it, which runs as [`edge_run`] says
+/// (`None`: not known): its dashes go on from where the edge starts along the source, its
+/// arrowheads stay only at the source's own ends, and its width profile and brush, which spread
+/// over the whole path, stay only on an edge that runs the whole path.
+fn fit_to_edge(row: &mut AppearanceItem, run: Option<(f64, bool, bool, bool)>) {
+    let AppearanceItem::Stroke(s) = row else { return };
+    let (from, starts, ends, whole) = run.unwrap_or((0.0, false, false, false));
+    if !whole {
+        if let Some(d) = &mut s.dash
+            && run.is_some()
+        {
+            d.offset += from;
+            d.align_corners = false;
+        }
+        s.profile = None;
+        s.brush = None;
+    }
+    if !starts {
+        s.start_arrow = None;
+    }
+    if !ends {
+        s.end_arrow = None;
+    }
+}
+
 /// The planar map's inputs from `sources` (paths and compound paths, back → front), with the
-/// fill, stroke and stroke width of each.
-fn source_shapes(sources: &[Arc<Node>]) -> (Vec<po::Shape>, Vec<(Paint, Paint, f64)>) {
+/// style of each.
+fn source_shapes(sources: &[Arc<Node>]) -> (Vec<po::Shape>, Vec<SourceStyle>) {
     let mut lv = vec![];
     for n in sources {
         b::leaf_shapes(n, &mut lv);
     }
     let mut shapes = vec![];
-    let mut styles: Vec<(Paint, Paint, f64)> = vec![];
+    let mut styles: Vec<SourceStyle> = vec![];
     for l in lv {
         if let Some((path, rule)) = b::node_outline(l)
             && !path.is_empty()
         {
             shapes.push(po::Shape::new(path, rule, styles.len() as u64));
-            let a = &l.appearance;
-            styles.push((a.fill_paint(), a.stroke_paint(), a.stroke().map(|s| s.width).unwrap_or(1.0)));
+            styles.push(SourceStyle::of(l));
         }
     }
     (shapes, styles)
@@ -462,17 +696,35 @@ fn build_children(d: &mut Document, sources: Vec<Arc<Node>>, max_gap: Option<f64
     let nfaces = regs.len();
     for r in regs {
         let id = d.alloc_id();
-        let fill = r.top().and_then(|t| styles.get(t)).map_or(Paint::None, |s| s.0.clone());
-        let mut n = Node::path(id, r.path, fill_only(fill));
+        let mut n = Node::path(id, r.path, fill_only(Paint::None));
         n.name = Some(FACE_NAME.into());
+        // The front-most covering source with a fill that draws gives the face its fill rows.
+        if let Some(s) = r.sources.iter().rev().filter_map(|&t| styles.get(t)).find(|s| !s.fills.is_empty()) {
+            s.paint(&mut n, &s.fills);
+        }
         children.push(Arc::new(n));
     }
     let nedges = edges.len();
+    // The tracks of the sources whose edges need them, measured once each.
+    let mut tracks: HashMap<usize, Vec<Track>> = HashMap::new();
     for e in edges {
-        let Some((_, stroke, w)) = styles.get(e.key as usize) else { continue };
+        let key = e.key as usize;
+        let Some(s) = styles.get(key) else { continue };
+        let mut path = e.path;
+        let mut rows = s.strokes.clone();
+        if rows.iter().any(depends_on_place) {
+            let source = tracks
+                .entry(key)
+                .or_insert_with(|| shapes.get(key).map(|src| src.path.subpaths.iter().map(Track::new).collect()).unwrap_or_default());
+            let run = edge_run(source, &mut path);
+            for r in &mut rows {
+                fit_to_edge(r, run);
+            }
+        }
         let id = d.alloc_id();
-        let mut n = Node::path(id, e.path, stroke_only(stroke.clone(), *w));
+        let mut n = Node::path(id, path, stroke_only(Paint::None, s.width));
         n.name = Some(EDGE_NAME.into());
+        s.paint(&mut n, &rows);
         children.push(Arc::new(n));
     }
     Ok((children, nfaces, nedges))
diff --git a/crates/engine/src/tests/build.rs b/crates/engine/src/tests/build.rs
index 1c3ad5d8b4..23674e63d0 100644
--- a/crates/engine/src/tests/build.rs
+++ b/crates/engine/src/tests/build.rs
@@ -3,7 +3,8 @@
 use std::sync::Arc;
 
 use serde_json::{Value, json};
-use vectorcraft_color::{Color, Paint};
+use vectorcraft_color::{BlendMode, Color, Paint};
+use vectorcraft_doc::appearance::{Effect, FillLayer, StrokeLayer};
 use vectorcraft_doc::{AppearanceItem, ImageBlob, ImageObject, LineCap, LineJoin, Node, NodeKind};
 use vectorcraft_geom::{Affine, FillRule, PathData, Point, Rect};
 use vectorcraft_testkit::pdf::{PdfPage, pdf};
@@ -2597,6 +2598,237 @@ fn live_paint_make_and_expand_keep_abutting_compound_colors() {
     check_colors(&node(&s, group));
 }
 
+/// Gives `id` the appearance rows `items` (paint order) and returns them.
+fn set_rows(s: &mut Session, id: NodeId, items: Vec<AppearanceItem>) -> Vec<AppearanceItem> {
+    s.edit("t", |d, _| {
+        d.node_mut(id).unwrap().appearance = vectorcraft_doc::Appearance { items: items.clone(), ..Default::default() }.into();
+        Ok(())
+    })
+    .unwrap();
+    items
+}
+
+/// A fill row of `p`, changed by `f`.
+fn fill_row(p: Paint, f: impl FnOnce(&mut FillLayer)) -> AppearanceItem {
+    let mut l = FillLayer::new(p);
+    f(&mut l);
+    AppearanceItem::Fill(l)
+}
+
+/// A stroke row of `p` `width` wide, changed by `f`.
+fn stroke_row(p: Paint, width: f64, f: impl FnOnce(&mut StrokeLayer)) -> AppearanceItem {
+    let mut l = StrokeLayer::new(p, width);
+    f(&mut l);
+    AppearanceItem::Stroke(l)
+}
+
+/// The faces and edges of Live Paint group `g` whose bounds lie within x `x0`..`x1`.
+fn parts_within(s: &Session, g: NodeId, x0: f64, x1: f64) -> (Vec<Node>, Vec<Node>) {
+    let n = node(s, g);
+    let within = |c: &&Arc<Node>| c.geometric_bounds().is_some_and(|b| b.x0 >= x0 - 1e-6 && b.x1 <= x1 + 1e-6);
+    let faces = vectorcraft_tools::builder::faces(&n).into_iter().filter(within).map(|c| (**c).clone()).collect();
+    let edges = vectorcraft_tools::builder::edges(&n).into_iter().filter(within).map(|c| (**c).clone()).collect();
+    (faces, edges)
+}
+
+/// Make gives each edge every stroke row of its source that draws, a lower one under an
+/// unpainted or hidden top row included, with the rows' settings and the source's opacity and
+/// blending mode; rows that draw nothing stay only with the stored source, which Release returns.
+#[test]
+fn live_paint_make_keeps_lower_drawn_stroke_rows() {
+    let mut s = session();
+    let (a, b) = two_at(&mut s, 200.0);
+    let black = Paint::solid(Color::BLACK);
+    let green = Paint::solid(Color::rgb(0.0, 1.0, 0.0));
+    let thick = stroke_row(black.clone(), 3.0, |l| {
+        l.opacity = 0.5;
+        l.blend = BlendMode::Multiply;
+        l.cap = LineCap::Round;
+    });
+    // A: the top stroke has no paint.
+    let a_rows =
+        set_rows(&mut s, a, vec![fill_row(Paint::solid(Color::rgb(1.0, 0.0, 0.0)), |_| {}), thick.clone(), stroke_row(Paint::None, 1.0, |_| {})]);
+    // B: the top stroke is hidden; a zero-weight and a transparent stroke draw nothing either.
+    set_rows(
+        &mut s,
+        b,
+        vec![
+            stroke_row(green.clone(), 2.0, |_| {}),
+            stroke_row(black.clone(), 0.0, |_| {}),
+            stroke_row(black, 2.0, |l| l.opacity = 0.0),
+            stroke_row(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), 5.0, |l| l.visible = false),
+        ],
+    );
+    s.edit("t", |d, _| {
+        let n = d.node_mut(a).unwrap();
+        n.opacity = 0.75;
+        n.blend = BlendMode::Screen;
+        Ok(())
+    })
+    .unwrap();
+    s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
+    let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+    let (_, a_edges) = parts_within(&s, g, 0.0, 100.0);
+    let (_, b_edges) = parts_within(&s, g, 200.0, 300.0);
+    assert!(!a_edges.is_empty() && !b_edges.is_empty());
+    for e in &a_edges {
+        assert_eq!(e.appearance.items, vec![thick.clone()], "A's edge takes the stroke that draws");
+        assert_eq!((e.opacity, e.blend), (0.75, BlendMode::Screen));
+    }
+    for e in &b_edges {
+        assert_eq!(e.appearance.items, vec![stroke_row(green.clone(), 2.0, |_| {})], "B's edge takes only its green stroke");
+        assert_eq!((e.opacity, e.blend), (1.0, BlendMode::Normal));
+    }
+    // Release returns the sources with every row they had.
+    let released = ids(&s.execute("livePaint.release", &json!({})).unwrap());
+    assert!(released.contains(&a));
+    assert_eq!(node(&s, a).appearance.items, a_rows);
+}
+
+/// When Make cuts a dashed stroke with arrowheads, a width profile and a brush into edges, each
+/// edge's dashes go on from where it starts along the path, the arrowheads stay at the path's own
+/// ends, and the profile and brush, which spread over the whole path, are left off the pieces.
+#[test]
+fn live_paint_make_fits_dashes_and_arrowheads_to_each_edge() {
+    use vectorcraft_doc::{Arrowhead, Dash};
+    let mut s = session();
+    let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
+    let l = line(&mut s, (-20.0, 50.0), (120.0, 50.0));
+    let dash = Dash { pattern: vec![10.0, 5.0], offset: 2.0, align_corners: true };
+    let row = stroke_row(Paint::solid(Color::BLACK), 2.0, |st| {
+        st.dash = Some(dash.clone());
+        st.start_arrow = Some(Arrowhead::Triangle);
+        st.end_arrow = Some(Arrowhead::Circle);
+        st.brush = Some("Charcoal".into());
+    });
+    let rows = set_rows(&mut s, l, vec![row]);
+    s.execute("select.set", &json!({"ids": [a.0, l.0]})).unwrap();
+    let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+    let gn = node(&s, g);
+    let mut pieces: Vec<(f64, f64, vectorcraft_doc::StrokeLayer)> = vectorcraft_tools::builder::edges(&gn)
+        .iter()
+        .filter_map(|e| {
+            let st = e.appearance.stroke().filter(|st| st.dash.is_some())?.clone();
+            let sp = e.path_data()?.subpaths.first()?;
+            Some((sp.anchors.first()?.p.x, sp.anchors.last()?.p.x, st))
+        })
+        .collect();
+    pieces.sort_by(|p, q| p.0.total_cmp(&q.0));
+    let ends: Vec<(f64, f64)> = pieces.iter().map(|p| ((p.0 * 1e3).round() / 1e3, (p.1 * 1e3).round() / 1e3)).collect();
+    assert_eq!(ends, vec![(-20.0, 0.0), (0.0, 100.0), (100.0, 120.0)], "each piece runs the way the line does");
+    let offsets: Vec<f64> = pieces.iter().map(|p| (p.2.dash.as_ref().unwrap().offset * 1e3).round() / 1e3).collect();
+    assert_eq!(offsets, vec![2.0, 22.0, 122.0], "the dashes go on along the line");
+    assert!(pieces.iter().all(|p| !p.2.dash.as_ref().unwrap().align_corners && p.2.brush.is_none()));
+    let arrows: Vec<_> = pieces.iter().map(|p| (p.2.start_arrow.clone(), p.2.end_arrow.clone())).collect();
+    assert_eq!(arrows, vec![(Some(Arrowhead::Triangle), None), (None, None), (None, Some(Arrowhead::Circle))]);
+    // A path that crosses itself: the pieces that start at the crossing take their place on the
+    // path from where they run, not from the first time the path passes that point.
+    let mut s3 = session();
+    let anchors = [(0.0, 0.0), (100.0, 100.0), (100.0, 0.0), (0.0, 100.0)].map(|(x, y)| json!({"x": x, "y": y}));
+    let z = NodeId(s3.execute("path.create", &json!({"anchors": anchors, "closed": false})).unwrap()["id"].as_u64().unwrap());
+    set_rows(&mut s3, z, rows.clone());
+    s3.execute("select.set", &json!({"ids": [z.0]})).unwrap();
+    let g3 = NodeId(s3.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+    let mut cut: Vec<(f64, Option<Arrowhead>, Option<Arrowhead>)> = vectorcraft_tools::builder::edges(&node(&s3, g3))
+        .iter()
+        .filter_map(|e| {
+            let st = e.appearance.stroke()?;
+            Some(((st.dash.as_ref()?.offset * 1e3).round() / 1e3, st.start_arrow.clone(), st.end_arrow.clone()))
+        })
+        .collect();
+    cut.sort_by(|p, q| p.0.total_cmp(&q.0));
+    let d = 2.0 + 50.0 * 2f64.sqrt();
+    let r = |v: f64| (v * 1e3).round() / 1e3;
+    assert_eq!(
+        cut,
+        vec![(2.0, Some(Arrowhead::Triangle), None), (r(d), None, None), (r(d + 100.0 + 100.0 * 2f64.sqrt()), None, Some(Arrowhead::Circle))]
+    );
+    // An uncut path keeps all of it.
+    let mut s2 = session();
+    let l2 = line(&mut s2, (0.0, 0.0), (50.0, 0.0));
+    set_rows(&mut s2, l2, rows.clone());
+    s2.execute("select.set", &json!({"ids": [l2.0]})).unwrap();
+    let g2 = NodeId(s2.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+    let edges: Vec<_> = vectorcraft_tools::builder::edges(&node(&s2, g2)).iter().map(|e| e.appearance.items.clone()).collect();
+    assert_eq!(edges, vec![rows]);
+}
+
+/// Make gives each face every fill row of its source that draws, in order and with their
+/// opacity, blending mode, overprint and effects, and the source's gradients keep their fit on
+/// the source; Expand keeps the rows, and Undo and Redo bring the group back with them.
+#[test]
+fn live_paint_make_keeps_all_drawn_fill_rows_and_attributes() {
+    let mut s = session();
+    let (a, b) = two(&mut s);
+    let lower = fill_row(Paint::solid(Color::rgb(1.0, 0.0, 0.0)), |l| {
+        l.opacity = 0.4;
+        l.blend = BlendMode::Multiply;
+        l.overprint = true;
+        l.effects.push(Effect { id: "distort.roughen".into(), params: Value::Null, visible: true });
+    });
+    // A: two fills that draw, with a hidden one between them and an unpainted one above them.
+    set_rows(
+        &mut s,
+        a,
+        vec![
+            lower.clone(),
+            fill_row(Paint::solid(Color::rgb(0.0, 1.0, 0.0)), |l| l.visible = false),
+            fill_row(Paint::None, |_| {}),
+            stroke_row(Paint::None, 1.0, |_| {}),
+        ],
+    );
+    // The top fill (and the stroke) become a gradient fitted to A's bounds.
+    let (want_fill, _) = paint_with_gradients(&mut s, a);
+    s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
+    let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+    let want = vec![lower, fill_row(want_fill, |_| {})];
+    let rows_within = |s: &Session, x0: f64, x1: f64| parts_within(s, g, x0, x1).0.iter().map(|f| f.appearance.items.clone()).collect::<Vec<_>>();
+    assert_eq!(rows_within(&s, 0.0, 50.0), vec![want.clone()], "A's face takes both fills that draw, the gradient at its fit on A");
+    let blue = vec![fill_row(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), |_| {})];
+    assert_eq!(rows_within(&s, 50.0, 100.0), vec![blue], "B is in front");
+    s.execute("livePaint.expand", &json!({})).unwrap();
+    let expanded = node(&s, g);
+    assert!(!vectorcraft_tools::builder::is_live_paint(&expanded));
+    let kept =
+        expanded.children().unwrap().iter().filter(|c| c.geometric_bounds().is_some_and(|b| b.x1 <= 50.0 + 1e-6)).any(|c| c.appearance.items == want);
+    assert!(kept, "Expand keeps both fills");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(rows_within(&s, 0.0, 50.0), vec![want.clone()]);
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("edit.redo", &json!({})).unwrap();
+    assert_eq!(rows_within(&s, 0.0, 50.0), vec![want]);
+}
+
+/// A face takes the fill rows of the front-most covering source whose fill draws: a source in
+/// front whose fill is hidden or transparent, or whose opacity is 0, does not hide the paint of the
+/// source behind it, and a face that no such source covers has no paint.
+#[test]
+fn live_paint_make_uses_frontmost_source_with_drawn_fill() {
+    for front in ["hidden", "clear", "transparent object"] {
+        let mut s = session();
+        let (a, b) = two(&mut s);
+        s.edit("t", |d, _| {
+            let n = d.node_mut(b).unwrap();
+            let mut app = (*n.appearance).clone();
+            match front {
+                "hidden" => app.fill_mut().unwrap().visible = false,
+                "clear" => app.fill_mut().unwrap().opacity = 0.0,
+                _ => n.opacity = 0.0,
+            }
+            n.appearance = app.into();
+            Ok(())
+        })
+        .unwrap();
+        s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
+        let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+        let rows_within = |x0: f64, x1: f64| parts_within(&s, g, x0, x1).0.iter().map(|f| f.appearance.items.clone()).collect::<Vec<_>>();
+        let red = vec![fill_row(Paint::solid(Color::rgb(1.0, 0.0, 0.0)), |_| {})];
+        assert_eq!(rows_within(50.0, 100.0), vec![red], "{front}: the overlap shows A");
+        assert_eq!(rows_within(100.0, 150.0), vec![vec![fill_row(Paint::None, |_| {})]], "{front}: B alone paints nothing");
+        assert_eq!(parts_within(&s, g, 100.0, 150.0).0[0].opacity, 1.0, "{front}");
+    }
+}
+
 #[test]
 fn live_paint_fill_assigns_the_face_under_the_point() {
     let mut s = session();
diff --git a/docs/mcp.md b/docs/mcp.md
index 1ad05ba3df..35a1b4e74f 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -3525,8 +3525,19 @@ already walks Image Trace. Short agent entry points:
   `ui.imageTracePresetDialog {params?, rename?}` opens the Image Trace panel's Save as New Preset… or Rename… dialog.
 - Live Paint: `livePaint.make`, `livePaint.merge`, `livePaint.fill {group?, point}`, `livePaint.strokeEdge`,
   `livePaint.info {group}`, `livePaint.release`, `livePaint.expand`, and `livePaint.gapOptions {ids?, detect?, size?,
-  color?, closeGaps?}` (Object › Live Paint › Gap Options). Make gives each covered face the fill of its front-most
-  covering source, including compound paths with shared curved boundaries. Expand keeps those face fills.
+  color?, closeGaps?}` (Object › Live Paint › Gap Options). Make gives each covered face the fill rows that draw of
+  its front-most covering source that has one, including compound paths with shared curved boundaries, and each edge
+  the stroke rows that draw of its source. A row draws when it is shown and has paint and an opacity above 0; a
+  stroke also needs a weight above 0, and a source whose opacity is 0 has no rows that draw. The rows keep their order
+  and settings (opacity, blending mode, effects, overprint, and a stroke's weight, caps, joins, dashes and alignment),
+  gradients keep their fit on the source, and the face or edge takes the source's opacity and blending mode. Where a
+  path is cut into several edges, each edge runs the way the path does, its dashes go on from where it starts along
+  the path (Align Dashes to Corners is turned off on it), the arrowheads stay only at the path's own ends, and a width
+  profile or brush stays only on an edge that runs the whole path. A gradient applied along a stroke starts again on
+  each cut edge, and an inside or outside stroke is drawn centered on an edge that is an open piece of a closed path.
+  A face or edge given no such row has one unpainted row. Rows that do not draw stay with the stored sources, which
+  `livePaint.release` returns unchanged. The source's object effects and the strokes' pen pressure are not carried.
+  Expand keeps those face fills.
   With `detect: true`, paint stops at the gaps that run
   from a loose end of a path to the nearest path, up to `size` wide (`small` 3 pt, `medium` 6 pt, `large` 12 pt, or a
   number of points up to 72); `closeGaps: true` adds an unpainted path across each of them. `color` (the Gap Preview
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index 2c74302900..eb1623d225 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -1457,6 +1457,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   With the Live Paint Bucket selected, Alt-click on vector art samples its fill, stroke and stroke weight into the paint defaults ([Paint with the Live Paint Bucket tool](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/paint-with-the-live-paint-bucket-tool.html)). On a placed image it samples the image pixel as a solid fill with no stroke. Alt+Shift-click samples only the color under the pointer, including an intermediate gradient color or image pixels, into the active fill or stroke ([Default keyboard shortcuts](https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html)). Neither click paints or changes the selection or selected art, and the next Bucket click paints with the sampled paint. Evidence: `tests_build::live_paint_bucket_alt_sample_paints_next_face_without_changing_selection`.
   Double-clicking the Live Paint Bucket opens Live Paint Bucket Options ([Paint with the Live Paint Bucket tool](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/paint-with-the-live-paint-bucket-tool.html)): Paint Fills (on) and Paint Strokes (off) set whether a click paints faces, edges or both, Highlight turns the outline of the face or edge under the pointer on or off, and Color and Width set it (red and 4 px by default). Faces are outlined at the Width and edges at half of it, as the page says faces are highlighted with a thick line and edges with a thin line. With both on, a click paints the edge within 4 px of the pointer, else the face, and Shift switches to Paint Fills only; with one on, Shift switches to the other. The options last across tool switches and are saved with the preferences (`tool.setOption {tool: "livePaintBucket"}`). Evidence: `builder::tests::{bucket_options_choose_what_a_click_paints, bucket_options_set_the_highlight, bucket_highlights_an_edge_thinner_than_a_face}`, `dialogs::live_paint_bucket::tests::double_clicking_the_tool_opens_its_options_and_ok_sets_them`.
   Live Paint Bucket Options has Cursor Swatch Preview, as the [help page](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/paint-with-the-live-paint-bucket-tool.html) lists: with the Bucket selected, the active fill or stroke shows above the pointer between the color swatches before and after it in the Swatches panel, and the Left and Right arrow keys pick the swatch before or after it, as the page describes. The selected art keeps its paint. As VectorCraft's own rules, the option is on at first, the arrows step the stroke when the Stroke proxy is in front, they wrap around at the ends and still step with the preview off, a color that is no swatch shows alone until Right picks the first swatch or Left the last, and the arrows do nothing during a fill drag or with no color swatch. Evidence: `tests::build::{live_paint_bucket_arrow_keys_step_the_active_paint_through_the_swatches, live_paint_bucket_arrow_keys_handle_unmatched_paint_few_swatches_and_drags, live_paint_bucket_arrow_keys_pass_swatches_of_the_same_color_for_fill_and_stroke, swatch_arrow_keys_leave_modified_arrows_to_the_shortcuts}`.
+  Object › Live Paint › Make turns the selected paths into a Live Paint group of faces and edges ([the help page](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/create-live-paint-groups.html)). As VectorCraft's own rule, each face takes every fill row that draws (shown, with paint and an opacity above 0) of its front-most covering source that has one and an opacity above 0, and each edge every stroke row that draws (also with a weight above 0) of its source, in order with their opacity, blending mode, effects and stroke settings, with gradients kept at their fit on the source and with the source's opacity and blending mode. Where a path is cut into several edges, each edge's dashes go on from where it starts along the path, the arrowheads stay at the path's own ends, and a width profile or brush stays only on an edge that runs the whole path; a gradient applied along a stroke starts again on each cut edge, and an inside or outside stroke is drawn centered on an open piece of a closed path. A painted lower row under an unpainted or hidden top row is kept, a hidden top row does not become visible, and a source in front whose fill does not draw does not hide the fill behind it. Rows that do not draw stay with the stored sources, which Release returns unchanged; the source's object effects are not carried. Evidence: `tests::build::{live_paint_make_keeps_lower_drawn_stroke_rows, live_paint_make_fits_dashes_and_arrowheads_to_each_edge, live_paint_make_keeps_all_drawn_fill_rows_and_attributes, live_paint_make_uses_frontmost_source_with_drawn_fill}`.
   Live Paint Make preserves the front-most covering source's fill when compound paths share a curved boundary, and Expand keeps the face fills. Regression evidence: `planar::tests::coincident_curves_keep_their_source_faces` checks source order, winding, fill rules and nearby boundaries; `tests::build::live_paint_make_and_expand_keep_abutting_compound_colors` checks native compound paths, Make, Expand and Undo/Redo. This preserves VectorCraft's source-fill rule without changing arrangement precision.
   Live Paint Gap Options (Object › Live Paint › Gap Options…, `livePaint.gapOptions`): with Gap Detection on, paint stops at the gaps that run from a loose end of a path to the nearest path, up to Small (3 pt), Medium (6 pt), Large (12 pt) or a custom size; Close Gaps With Paths adds an unpainted path across each gap; Preview applies the options live and draws the gaps in the Gap Preview Color. The options are saved, copied and undone with the group, and Merge keeps the bottom group's options when its Gap Detection is on, or else turns Gap Detection on with Small when another merged group has it on. When Gap Detection is off in every merged group, it stays off.
   View › Show Live Paint Gaps (`view.livePaintGaps`) draws the gaps of the selected Live Paint groups up to their Paint Stops At size, each in its group's Gap Preview Color, until Hide Live Paint Gaps or Hide Edges hides them ([Live Paint gaps](https://web.archive.org/web/20260105111201/https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/find-and-close-gaps-in-live-paint-groups.html)).

From f7d1643a83de10e6598f837c6b6d49cceee38228 Mon Sep 17 00:00:00 2001
From: dotCooCoo <RobertLeeLW@gmail.com>
Date: Sat, 14 Nov 2026 07:56:39 -0800
Subject: [PATCH 2/7] Live Paint: Make keeps the direction of gradient strokes
 along or across the path

A stroke whose only setting that depends on direction is a gradient along or
across the stroke now goes through the same edge fitting as dashed strokes, so
each cut edge runs the way its source path does and the gradient keeps its
direction.
---
 crates/engine/src/cmd/buildcmds.rs |  7 ++++---
 crates/engine/src/tests/build.rs   | 31 ++++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/crates/engine/src/cmd/buildcmds.rs b/crates/engine/src/cmd/buildcmds.rs
index 9e457212ad..13b7a3bd83 100644
--- a/crates/engine/src/cmd/buildcmds.rs
+++ b/crates/engine/src/cmd/buildcmds.rs
@@ -471,10 +471,11 @@ impl SourceStyle {
 /// How far, in points, a place on an edge may be from its source path and still be on it.
 const ON_SOURCE: f64 = 0.05;
 
-/// Does stroke row `i` have settings that depend on where along its path a piece of it lies:
-/// dashes, arrowheads, a width profile or a brush?
+/// Does stroke row `i` have settings that depend on where along its path a piece of it lies or
+/// which way it runs: dashes, arrowheads, a width profile, a brush, or a gradient along or across
+/// the stroke?
 fn depends_on_place(i: &AppearanceItem) -> bool {
-    matches!(i, AppearanceItem::Stroke(s) if s.dash.is_some() || s.start_arrow.is_some() || s.end_arrow.is_some() || s.profile.is_some() || s.brush.is_some())
+    matches!(i, AppearanceItem::Stroke(s) if s.dash.is_some() || s.start_arrow.is_some() || s.end_arrow.is_some() || s.profile.is_some() || s.brush.is_some() || s.gradient_mode != vectorcraft_doc::StrokeGradientMode::Within)
 }
 
 /// One subpath's segments with the length along it where each starts, then its whole length, and
diff --git a/crates/engine/src/tests/build.rs b/crates/engine/src/tests/build.rs
index 8fae2eadd4..0614f63658 100644
--- a/crates/engine/src/tests/build.rs
+++ b/crates/engine/src/tests/build.rs
@@ -2753,6 +2753,37 @@ fn live_paint_make_fits_dashes_and_arrowheads_to_each_edge() {
     assert_eq!(edges, vec![rows]);
 }
 
+/// When Make cuts a stroke whose only setting that depends on direction is a gradient along or
+/// across it, each edge runs the way its source path does, so the gradient keeps its direction.
+#[test]
+fn live_paint_make_keeps_the_direction_of_gradient_strokes() {
+    use vectorcraft_doc::StrokeGradientMode;
+    for mode in [StrokeGradientMode::Along, StrokeGradientMode::Across] {
+        for (x0, x1) in [(-20.0, 120.0), (120.0, -20.0)] {
+            let mut s = session();
+            let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
+            let l = line(&mut s, (x0, 50.0), (x1, 50.0));
+            let gradient = Paint::Gradient(Box::new(vectorcraft_color::GradientPaint::new(vectorcraft_color::Gradient::default())));
+            set_rows(&mut s, l, vec![stroke_row(gradient, 2.0, |st| st.gradient_mode = mode)]);
+            s.execute("select.set", &json!({"ids": [a.0, l.0]})).unwrap();
+            let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+            let pieces: Vec<(f64, f64)> = vectorcraft_tools::builder::edges(&node(&s, g))
+                .iter()
+                .filter_map(|e| {
+                    e.appearance.stroke().filter(|st| st.gradient_mode == mode)?;
+                    let sp = e.path_data()?.subpaths.first()?;
+                    Some((sp.anchors.first()?.p.x, sp.anchors.last()?.p.x))
+                })
+                .collect();
+            assert_eq!(pieces.len(), 3, "{mode:?}, from {x0}");
+            assert!(
+                pieces.iter().all(|&(p, q)| (q - p).signum() == (x1 - x0).signum()),
+                "{mode:?}, from {x0}: each piece runs the way the line does: {pieces:?}"
+            );
+        }
+    }
+}
+
 /// Make gives each face every fill row of its source that draws, in order and with their
 /// opacity, blending mode, overprint and effects, and the source's gradients keep their fit on
 /// the source; Expand keeps the rows, and Undo and Redo bring the group back with them.

From a4c513f101e11709788d42cc045e32c4721e9791 Mon Sep 17 00:00:00 2001
From: dotCooCoo <RobertLeeLW@gmail.com>
Date: Sat, 14 Nov 2026 08:39:47 -0800
Subject: [PATCH 3/7] Live Paint: Make starts a closed edge where its path
 starts

The edge built from a closed path that nothing cuts started at the anchor the
planar map gave it, so dashes, a width profile or a brush began at a different
place than on the path. The edge now starts at the anchor where its path
starts. An edge with no anchor there takes its dashes from its own start and
leaves off the profile and brush.

The command description and the progress doc say that dashes aligned to
corners and path ends are not fitted to cut edges.
---
 crates/engine/src/cmd/buildcmds.rs | 27 ++++++++++++++++++-----
 crates/engine/src/tests/build.rs   | 35 ++++++++++++++++++++++++++++++
 docs/target-app-parity.md          |  2 +-
 3 files changed, 57 insertions(+), 7 deletions(-)

diff --git a/crates/engine/src/cmd/buildcmds.rs b/crates/engine/src/cmd/buildcmds.rs
index 13b7a3bd83..a0decb33d7 100644
--- a/crates/engine/src/cmd/buildcmds.rs
+++ b/crates/engine/src/cmd/buildcmds.rs
@@ -72,7 +72,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Make",
             ["Object", "Live Paint"],
             Some("Cmd+Alt+X"),
-            "{ids?|id?} build a Live Paint group from the selected paths (paths, compound paths and groups of them; type, images and other objects are refused, nothing changes); each covered face starts with the fill rows that draw (shown, with paint and an opacity above 0) of its front-most covering source that has one and an opacity above 0, and each edge with the stroke rows that draw (also a weight above 0) of its source, in order with their settings and with that source's opacity and blending mode (on a path cut into several edges, dashes go on along the path, arrowheads stay at its own ends, and a width profile or brush stays only on an edge that runs the whole path); a face or edge given no such row has one unpainted row; with a Live Paint group among them, add the others to it as livePaint.merge does; a Live Paint group alone has nothing to add, so it is selected and nothing changes (no undo step) → {id, faces, edges}",
+            "{ids?|id?} build a Live Paint group from the selected paths (paths, compound paths and groups of them; type, images and other objects are refused, nothing changes); each covered face starts with the fill rows that draw (shown, with paint and an opacity above 0) of its front-most covering source that has one and an opacity above 0, and each edge with the stroke rows that draw (also a weight above 0) of its source, in order with their settings and with that source's opacity and blending mode (on a path cut into several edges, dashes go on along the path with the lengths set, without the fit of dashes aligned to corners and path ends, arrowheads stay at its own ends, and a width profile or brush stays only on an edge that runs the whole path); a face or edge given no such row has one unpainted row; with a Live Paint group among them, add the others to it as livePaint.merge does; a Live Paint group alone has nothing to add, so it is selected and nothing changes (no undo step) → {id, faces, edges}",
             has_selection_or_ids,
             lp_make
         ),
@@ -576,7 +576,9 @@ impl Track {
 /// ends at its end (an open subpath), and whether it runs the whole subpath. The middle of the
 /// edge's first segment places it, and its ends are taken where they lie that far along the source,
 /// so a path that passes a point twice is told apart. An edge that runs against the direction of its
-/// source is reversed first. `None` when the edge is not a single piece found on the source.
+/// source is reversed first, and a closed edge is started at the anchor where its source starts
+/// (one with no anchor there does not count as running the whole subpath). `None` when the edge is
+/// not a single piece found on the source.
 fn edge_run(tracks: &[Track], edge: &mut PathData) -> Option<(f64, bool, bool, bool)> {
     use kurbo::{ParamCurve, ParamCurveArclen};
     let [sp] = edge.subpaths.as_slice() else { return None };
@@ -621,13 +623,26 @@ fn edge_run(tracks: &[Track], edge: &mut PathData) -> Option<(f64, bool, bool, b
     let open = !track.closed;
     let starts = open && from <= ON_SOURCE;
     let ends = open && to >= track.len() - ON_SOURCE;
-    let whole = if open { starts && ends } else { edge_closed };
-    Some((from, starts, ends, whole))
+    if open {
+        return Some((from, starts, ends, starts && ends));
+    }
+    // A closed edge runs the whole closed subpath, from the anchor the planar map starts it at.
+    // Start it at the anchor where the source starts, so settings that follow the path begin there.
+    let start = track.segs.first().map(|s| s.start())?;
+    let moved = edge_closed
+        && edge.subpaths.first_mut().is_some_and(|sp| match sp.anchors.iter().position(|a| a.p.distance(start) <= ON_SOURCE) {
+            Some(k) => {
+                sp.anchors.rotate_left(k);
+                true
+            }
+            None => false,
+        });
+    Some((if moved { 0.0 } else { from }, false, false, moved))
 }
 
 /// Fit stroke row `row` of a source path to an edge cut from it, which runs as [`edge_run`] says
-/// (`None`: not known): its dashes go on from where the edge starts along the source, its
-/// arrowheads stay only at the source's own ends, and its width profile and brush, which spread
+/// (`None`: not known): its dashes go on from where the edge starts along the source, with the
+/// lengths set and without the fit of dashes aligned to corners and path ends, its arrowheads stay only at the source's own ends, and its width profile and brush, which spread
 /// over the whole path, stay only on an edge that runs the whole path.
 fn fit_to_edge(row: &mut AppearanceItem, run: Option<(f64, bool, bool, bool)>) {
     let AppearanceItem::Stroke(s) = row else { return };
diff --git a/crates/engine/src/tests/build.rs b/crates/engine/src/tests/build.rs
index 0614f63658..960cab107e 100644
--- a/crates/engine/src/tests/build.rs
+++ b/crates/engine/src/tests/build.rs
@@ -2753,6 +2753,41 @@ fn live_paint_make_fits_dashes_and_arrowheads_to_each_edge() {
     assert_eq!(edges, vec![rows]);
 }
 
+/// The edge Make builds from a closed path that nothing cuts starts at the anchor the path starts
+/// at and runs the way the path does, whichever anchor that is, so its dashes and brush lie where
+/// they do on the path, and it keeps the path's stroke row as it is.
+#[test]
+fn live_paint_make_starts_a_closed_edge_where_its_path_starts() {
+    use vectorcraft_doc::Dash;
+    let corners = [(50.0, 0.0), (100.0, 50.0), (50.0, 100.0), (0.0, 50.0)];
+    for clockwise in [true, false] {
+        for start in 0..4 {
+            let mut s = session();
+            let mut pts: Vec<(f64, f64)> = (0..4).map(|k| corners[(k + start) % 4]).collect();
+            if !clockwise {
+                pts.reverse();
+            }
+            let anchors: Vec<_> = pts.iter().map(|(x, y)| json!({"x": x, "y": y})).collect();
+            let z = NodeId(s.execute("path.create", &json!({"anchors": anchors, "closed": true})).unwrap()["id"].as_u64().unwrap());
+            let row = stroke_row(Paint::solid(Color::BLACK), 2.0, |st| {
+                st.dash = Some(Dash { pattern: vec![10.0, 5.0], offset: 2.0, align_corners: false });
+                st.brush = Some("Charcoal".into());
+            });
+            let rows = set_rows(&mut s, z, vec![row]);
+            s.execute("select.set", &json!({"ids": [z.0]})).unwrap();
+            let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+            let gn = node(&s, g);
+            let edges = vectorcraft_tools::builder::edges(&gn);
+            let [e] = edges.as_slice() else { panic!("one edge, got {}", edges.len()) };
+            let sp = e.path_data().unwrap().subpaths.first().unwrap().clone();
+            let at: Vec<(f64, f64)> = sp.anchors.iter().map(|a| ((a.p.x * 1e3).round() / 1e3, (a.p.y * 1e3).round() / 1e3)).collect();
+            assert!(sp.closed);
+            assert_eq!(at, pts, "clockwise {clockwise}, start {start}");
+            assert_eq!(e.appearance.items, rows, "clockwise {clockwise}, start {start}");
+        }
+    }
+}
+
 /// When Make cuts a stroke whose only setting that depends on direction is a gradient along or
 /// across it, each edge runs the way its source path does, so the gradient keeps its direction.
 #[test]
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index da890f6079..11211e2c2e 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -1494,7 +1494,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   With the Live Paint Bucket selected, Alt-click on vector art samples its fill, stroke and stroke weight into the paint defaults ([Paint with the Live Paint Bucket tool](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/paint-with-the-live-paint-bucket-tool.html)). On a placed image it samples the image pixel as a solid fill with no stroke. Alt+Shift-click samples only the color under the pointer, including an intermediate gradient color or image pixels, into the active fill or stroke ([Default keyboard shortcuts](https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html)). Neither click paints or changes the selection or selected art, and the next Bucket click paints with the sampled paint. Evidence: `tests_build::live_paint_bucket_alt_sample_paints_next_face_without_changing_selection`.
   Double-clicking the Live Paint Bucket opens Live Paint Bucket Options ([Paint with the Live Paint Bucket tool](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/paint-with-the-live-paint-bucket-tool.html)): Paint Fills (on) and Paint Strokes (off) set whether a click paints faces, edges or both, Highlight turns the outline of the face or edge under the pointer on or off, and Color and Width set it (red and 4 px by default). Faces are outlined at the Width and edges at half of it, as the page says faces are highlighted with a thick line and edges with a thin line. With both on, a click paints the edge within 4 px of the pointer, else the face, and Shift switches to Paint Fills only; with one on, Shift switches to the other. The options last across tool switches and are saved with the preferences (`tool.setOption {tool: "livePaintBucket"}`). Evidence: `builder::tests::{bucket_options_choose_what_a_click_paints, bucket_options_set_the_highlight, bucket_highlights_an_edge_thinner_than_a_face}`, `dialogs::live_paint_bucket::tests::double_clicking_the_tool_opens_its_options_and_ok_sets_them`.
   Live Paint Bucket Options has Cursor Swatch Preview, as the [help page](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/paint-with-the-live-paint-bucket-tool.html) lists: with the Bucket selected, the active fill or stroke shows above the pointer between the color swatches before and after it in the Swatches panel, and the Left and Right arrow keys pick the swatch before or after it, as the page describes. The selected art keeps its paint. As VectorCraft's own rules, the option is on at first, the arrows step the stroke when the Stroke proxy is in front, they wrap around at the ends and still step with the preview off, a color that is no swatch shows alone until Right picks the first swatch or Left the last, and the arrows do nothing during a fill drag or with no color swatch. Evidence: `tests::build::{live_paint_bucket_arrow_keys_step_the_active_paint_through_the_swatches, live_paint_bucket_arrow_keys_handle_unmatched_paint_few_swatches_and_drags, live_paint_bucket_arrow_keys_pass_swatches_of_the_same_color_for_fill_and_stroke, swatch_arrow_keys_leave_modified_arrows_to_the_shortcuts}`.
-  Object › Live Paint › Make turns the selected paths into a Live Paint group of faces and edges ([the help page](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/create-live-paint-groups.html)). As VectorCraft's own rule, each face takes every fill row that draws (shown, with paint and an opacity above 0) of its front-most covering source that has one and an opacity above 0, and each edge every stroke row that draws (also with a weight above 0) of its source, in order with their opacity, blending mode, effects and stroke settings, with gradients kept at their fit on the source and with the source's opacity and blending mode. Where a path is cut into several edges, each edge's dashes go on from where it starts along the path, the arrowheads stay at the path's own ends, and a width profile or brush stays only on an edge that runs the whole path; a gradient applied along a stroke starts again on each cut edge, and an inside or outside stroke is drawn centered on an open piece of a closed path. A painted lower row under an unpainted or hidden top row is kept, a hidden top row does not become visible, and a source in front whose fill does not draw does not hide the fill behind it. Rows that do not draw stay with the stored sources, which Release returns unchanged; the source's object effects are not carried. Evidence: `tests::build::{live_paint_make_keeps_lower_drawn_stroke_rows, live_paint_make_fits_dashes_and_arrowheads_to_each_edge, live_paint_make_keeps_all_drawn_fill_rows_and_attributes, live_paint_make_uses_frontmost_source_with_drawn_fill}`.
+  Object › Live Paint › Make turns the selected paths into a Live Paint group of faces and edges ([the help page](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/create-live-paint-groups.html)). As VectorCraft's own rule, each face takes every fill row that draws (shown, with paint and an opacity above 0) of its front-most covering source that has one and an opacity above 0, and each edge every stroke row that draws (also with a weight above 0) of its source, in order with their opacity, blending mode, effects and stroke settings, with gradients kept at their fit on the source and with the source's opacity and blending mode. Where a path is cut into several edges, each edge's dashes go on from where it starts along the path with the lengths set (dashes aligned to corners and path ends are not fitted to the cut edges), the arrowheads stay at the path's own ends, and a width profile or brush stays only on an edge that runs the whole path; each edge runs the way its path does, a gradient applied along a stroke starts again on each cut edge, and an inside or outside stroke is drawn centered on an open piece of a closed path. A painted lower row under an unpainted or hidden top row is kept, a hidden top row does not become visible, and a source in front whose fill does not draw does not hide the fill behind it. Rows that do not draw stay with the stored sources, which Release returns unchanged; the source's object effects are not carried. Evidence: `tests::build::{live_paint_make_keeps_lower_drawn_stroke_rows, live_paint_make_fits_dashes_and_arrowheads_to_each_edge, live_paint_make_starts_a_closed_edge_where_its_path_starts, live_paint_make_keeps_the_direction_of_gradient_strokes, live_paint_make_keeps_all_drawn_fill_rows_and_attributes, live_paint_make_uses_frontmost_source_with_drawn_fill}`.
   Live Paint Make preserves the front-most covering source's fill when compound paths share a curved boundary, and Expand keeps the face fills. Regression evidence: `planar::tests::coincident_curves_keep_their_source_faces` checks source order, winding, fill rules and nearby boundaries; `tests::build::live_paint_make_and_expand_keep_abutting_compound_colors` checks native compound paths, Make, Expand and Undo/Redo. This preserves VectorCraft's source-fill rule without changing arrangement precision.
   Object › Live Paint › Expand keeps the faces and edges that draw on the canvas, with all their fill and stroke rows, so the expanded paths look as the painted group did ([Create Live Paint groups](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/create-live-paint-groups.html)). As VectorCraft's own rule, a face or edge draws when it is shown, its opacity is above 0, and any of its fill or stroke rows is shown, has paint and an opacity above 0 (a stroke also needs a weight above 0), whichever row is on top: a painted lower row under an unpainted top row is kept, and a part whose only painted row is hidden is removed. Merge copies the fill and stroke rows, visibility, opacity and blending mode of each face that draws by this rule, and of each edge, to the rebuilt parts, with their gradients kept at their fit on the old outline and without the strokes' pen pressure, tilt, bearing and rotation. Evidence: `tests::build::{live_paint_expand_keeps_the_faces_and_edges_that_draw, live_paint_merge_carries_the_faces_that_draw, live_paint_merge_leaves_pen_pressure_behind, live_paint_merge_keeps_the_fit_of_carried_gradients, live_paint_merge_keeps_the_visibility_opacity_and_blending_of_carried_parts}`.
   Live Paint Gap Options (Object › Live Paint › Gap Options…, `livePaint.gapOptions`): with Gap Detection on, paint stops at the gaps that run from a loose end of a path to the nearest path, up to Small (3 pt), Medium (6 pt), Large (12 pt) or a custom size; Close Gaps With Paths adds an unpainted path across each gap; Preview applies the options live and draws the gaps in the Gap Preview Color. The options are saved, copied and undone with the group, and Merge keeps the bottom group's options when its Gap Detection is on, or else turns Gap Detection on with Small when another merged group has it on. When Gap Detection is off in every merged group, it stays off.

From 6a5e6fa2125dda4af3cf166f865f83bbd52454d8 Mon Sep 17 00:00:00 2001
From: dotCooCoo <RobertLeeLW@gmail.com>
Date: Sat, 14 Nov 2026 12:16:14 -0800
Subject: [PATCH 4/7] Live Paint: Gap Options fits an edge's dashes and
 arrowheads to each piece it cuts

When Gap Options cut an edge in two, each piece took the old edge's
stroke rows unchanged: both arrowheads, the dash phase of the edge's
start, and a brush or width profile spread over the whole edge. Each
piece now takes those rows fitted to its part of the old edge, as Make
fits a source path's rows to the edges cut from it.
---
 crates/engine/src/cmd/buildcmds.rs | 19 +++++++++++--
 crates/engine/src/tests/build.rs   | 44 ++++++++++++++++++++++++++++++
 docs/mcp.md                        |  3 +-
 3 files changed, 63 insertions(+), 3 deletions(-)

diff --git a/crates/engine/src/cmd/buildcmds.rs b/crates/engine/src/cmd/buildcmds.rs
index a0decb33d7..7c404571a5 100644
--- a/crates/engine/src/cmd/buildcmds.rs
+++ b/crates/engine/src/cmd/buildcmds.rs
@@ -749,8 +749,9 @@ fn build_children(d: &mut Document, sources: Vec<Arc<Node>>, max_gap: Option<f64
 /// Give the faces and edges of `g`, a Live Paint group made again from the sources of `old`, the
 /// look of `old`'s face or edge where they lie: each face takes everything but the outline (its
 /// appearance, none included, its transparency and the rest) of the old face its inside point is
-/// in, and each edge that of the old edge its middle lies on. Faces and edges where `old` had none
-/// keep the paint of their sources.
+/// in, and each edge that of the old edge its middle lies on, with the old edge's stroke rows fitted
+/// to the part of it the new edge runs, as [`fit_to_edge`] fits a source's rows. Faces and edges
+/// where `old` had none keep the paint of their sources.
 fn repaint_from(g: &mut Node, old: &Node) {
     /// How far an edge's middle may be from the old edge it lies on.
     const ON_EDGE: f64 = 1e-3;
@@ -773,6 +774,20 @@ fn repaint_from(g: &mut Node, old: &Node) {
             n.id = c.id;
             n.kind = c.kind.clone();
             n.bbox_angle = c.bbox_angle;
+            // An edge cut from the old one takes the old edge's dashes, arrowheads, width profile
+            // and brush as they fall on its part of the old edge.
+            if c.name.as_deref() == Some(EDGE_NAME)
+                && n.appearance.items.iter().any(depends_on_place)
+                && let Some(old_path) = was.path_data()
+            {
+                let tracks: Vec<Track> = old_path.subpaths.iter().map(Track::new).collect();
+                let run = n.path_data_mut().and_then(|path| edge_run(&tracks, path));
+                let mut a = (*n.appearance).clone();
+                for r in &mut a.items {
+                    fit_to_edge(r, run);
+                }
+                n.appearance = a.into();
+            }
             *c = Arc::new(n);
         }
     }
diff --git a/crates/engine/src/tests/build.rs b/crates/engine/src/tests/build.rs
index 960cab107e..e503dfe2fc 100644
--- a/crates/engine/src/tests/build.rs
+++ b/crates/engine/src/tests/build.rs
@@ -2753,6 +2753,50 @@ fn live_paint_make_fits_dashes_and_arrowheads_to_each_edge() {
     assert_eq!(edges, vec![rows]);
 }
 
+/// When Gap Options cuts an edge in two, each piece keeps the edge's dashes going on from where it
+/// starts along the edge, an arrowhead only at the end of the edge it ends at, and no brush.
+#[test]
+fn live_paint_gap_options_fits_an_edge_look_to_each_piece() {
+    use vectorcraft_doc::{Arrowhead, Dash};
+    let mut s = session();
+    let l = line(&mut s, (0.0, 50.0), (100.0, 50.0));
+    let stub = line(&mut s, (50.0, 0.0), (50.0, 48.0));
+    let row = stroke_row(Paint::solid(Color::BLACK), 2.0, |st| {
+        st.dash = Some(Dash { pattern: vec![10.0, 5.0], offset: 2.0, align_corners: false });
+        st.start_arrow = Some(Arrowhead::Triangle);
+        st.end_arrow = Some(Arrowhead::Circle);
+        st.brush = Some("Charcoal".into());
+    });
+    let rows = set_rows(&mut s, l, vec![row]);
+    s.execute("select.set", &json!({"ids": [l.0, stub.0]})).unwrap();
+    let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+    let dashed = |s: &Session| {
+        let mut out: Vec<(f64, f64, vectorcraft_doc::StrokeLayer)> = vectorcraft_tools::builder::edges(&node(s, g))
+            .iter()
+            .filter_map(|e| {
+                let st = e.appearance.stroke().filter(|st| st.dash.is_some())?.clone();
+                let sp = e.path_data()?.subpaths.first()?;
+                Some(((sp.anchors.first()?.p.x * 1e3).round() / 1e3, (sp.anchors.last()?.p.x * 1e3).round() / 1e3, st))
+            })
+            .collect();
+        out.sort_by(|p, q| p.0.total_cmp(&q.0));
+        out
+    };
+    let before = dashed(&s);
+    assert_eq!(before.len(), 1, "nothing cuts the line yet");
+    assert_eq!(vec![AppearanceItem::Stroke(before[0].2.clone())], rows);
+    let r = s.execute("livePaint.gapOptions", &json!({"id": g.0, "closeGaps": true})).unwrap();
+    assert_eq!(r["closed"], json!(1));
+    let pieces = dashed(&s);
+    let ends: Vec<(f64, f64)> = pieces.iter().map(|p| (p.0, p.1)).collect();
+    assert_eq!(ends, vec![(0.0, 50.0), (50.0, 100.0)], "the line is cut where the gap closes");
+    let offsets: Vec<f64> = pieces.iter().map(|p| (p.2.dash.as_ref().unwrap().offset * 1e3).round() / 1e3).collect();
+    assert_eq!(offsets, vec![2.0, 52.0], "the dashes go on along the line");
+    let arrows: Vec<_> = pieces.iter().map(|p| (p.2.start_arrow.clone(), p.2.end_arrow.clone())).collect();
+    assert_eq!(arrows, vec![(Some(Arrowhead::Triangle), None), (None, Some(Arrowhead::Circle))]);
+    assert!(pieces.iter().all(|p| p.2.brush.is_none()), "a brush spreads over the whole line");
+}
+
 /// The edge Make builds from a closed path that nothing cuts starts at the anchor the path starts
 /// at and runs the way the path does, whichever anchor that is, so its dashes and brush lie where
 /// they do on the path, and it keeps the path's stroke row as it is.
diff --git a/docs/mcp.md b/docs/mcp.md
index 86724f5b7f..823c8bc577 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -3614,7 +3614,8 @@ already walks Image Trace. Short agent entry points:
   the path (Align Dashes to Corners is turned off on it), the arrowheads stay only at the path's own ends, and a width
   profile or brush stays only on an edge that runs the whole path. A gradient applied along a stroke starts again on
   each cut edge, and an inside or outside stroke is drawn centered on an edge that is an open piece of a closed path.
-  A face or edge given no such row has one unpainted row. Rows that do not draw stay with the stored sources, which
+  When `livePaint.gapOptions` cuts an edge into pieces, each piece takes the edge's rows fitted to its part of the
+  edge in the same way. A face or edge given no such row has one unpainted row. Rows that do not draw stay with the stored sources, which
   `livePaint.release` returns unchanged. The source's object effects and the strokes' pen pressure are not carried.
   Expand keeps those face fills.
   `livePaint.expand` keeps each face and edge that draws, with all its fill and stroke rows: it is shown, its opacity

From 4d4acd97c3429fca67d4a4507fd9fef14de6fa98 Mon Sep 17 00:00:00 2001
From: dotCooCoo <RobertLeeLW@gmail.com>
Date: Sat, 14 Nov 2026 12:49:39 -0800
Subject: [PATCH 5/7] Live Paint: a loop cut from a self-crossing closed path
 keeps no brush

A closed path that crosses itself is cut into closed loops. The loop
holding the path's first anchor counted as the whole path, so it kept
the path's width profile and brush. A closed edge now counts as the
whole path only when it is as long as the path.
---
 crates/engine/src/cmd/buildcmds.rs |  6 ++++--
 crates/engine/src/tests/build.rs   | 16 ++++++++++++++++
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/crates/engine/src/cmd/buildcmds.rs b/crates/engine/src/cmd/buildcmds.rs
index 7c404571a5..07b178bacc 100644
--- a/crates/engine/src/cmd/buildcmds.rs
+++ b/crates/engine/src/cmd/buildcmds.rs
@@ -576,8 +576,9 @@ impl Track {
 /// ends at its end (an open subpath), and whether it runs the whole subpath. The middle of the
 /// edge's first segment places it, and its ends are taken where they lie that far along the source,
 /// so a path that passes a point twice is told apart. An edge that runs against the direction of its
-/// source is reversed first, and a closed edge is started at the anchor where its source starts
-/// (one with no anchor there does not count as running the whole subpath). `None` when the edge is
+/// source is reversed first, and a closed edge as long as its closed source is started at the anchor
+/// where its source starts (one with no anchor there, or a shorter loop cut from a source that
+/// crosses itself, does not count as running the whole subpath). `None` when the edge is
 /// not a single piece found on the source.
 fn edge_run(tracks: &[Track], edge: &mut PathData) -> Option<(f64, bool, bool, bool)> {
     use kurbo::{ParamCurve, ParamCurveArclen};
@@ -630,6 +631,7 @@ fn edge_run(tracks: &[Track], edge: &mut PathData) -> Option<(f64, bool, bool, b
     // Start it at the anchor where the source starts, so settings that follow the path begin there.
     let start = track.segs.first().map(|s| s.start())?;
     let moved = edge_closed
+        && (length - track.len()).abs() <= ON_SOURCE.max(track.len() * 1e-4)
         && edge.subpaths.first_mut().is_some_and(|sp| match sp.anchors.iter().position(|a| a.p.distance(start) <= ON_SOURCE) {
             Some(k) => {
                 sp.anchors.rotate_left(k);
diff --git a/crates/engine/src/tests/build.rs b/crates/engine/src/tests/build.rs
index e503dfe2fc..f45644d951 100644
--- a/crates/engine/src/tests/build.rs
+++ b/crates/engine/src/tests/build.rs
@@ -2830,6 +2830,22 @@ fn live_paint_make_starts_a_closed_edge_where_its_path_starts() {
             assert_eq!(e.appearance.items, rows, "clockwise {clockwise}, start {start}");
         }
     }
+    // A closed path that crosses itself is cut into loops, and the loop that holds the path's
+    // first anchor is still only part of the path: it keeps no brush.
+    let mut s = session();
+    let anchors = [(0.0, 0.0), (100.0, 100.0), (100.0, 0.0), (0.0, 100.0)].map(|(x, y)| json!({"x": x, "y": y}));
+    let z = NodeId(s.execute("path.create", &json!({"anchors": anchors, "closed": true})).unwrap()["id"].as_u64().unwrap());
+    let row = stroke_row(Paint::solid(Color::BLACK), 2.0, |st| {
+        st.dash = Some(Dash { pattern: vec![10.0, 5.0], offset: 2.0, align_corners: false });
+        st.brush = Some("Charcoal".into());
+    });
+    set_rows(&mut s, z, vec![row]);
+    s.execute("select.set", &json!({"ids": [z.0]})).unwrap();
+    let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+    let gn = node(&s, g);
+    let edges = vectorcraft_tools::builder::edges(&gn);
+    assert!(edges.len() > 1, "the crossing cuts the path, got {} edge", edges.len());
+    assert!(edges.iter().all(|e| e.appearance.stroke().is_some_and(|st| st.brush.is_none())), "no loop is the whole path");
 }
 
 /// When Make cuts a stroke whose only setting that depends on direction is a gradient along or

From 09110ce7bf2b18ceb063561d3dccd8fb1754e3d1 Mon Sep 17 00:00:00 2001
From: dotCooCoo <RobertLeeLW@gmail.com>
Date: Sat, 14 Nov 2026 13:15:07 -0800
Subject: [PATCH 6/7] Live Paint: Merge fits a carried edge look to the piece
 it lands on

When Merge added a path that cut a painted edge, the piece holding the
old edge's middle took the old edge's stroke rows unchanged, so its
dashes started again and it kept both arrowheads. It now takes them
fitted to its part of the old edge, as Gap Options does.
---
 crates/engine/src/cmd/buildcmds.rs            | 25 +++++++++++-----
 crates/engine/src/cmd/buildcmds/live_paint.rs | 18 +++++++-----
 crates/engine/src/tests/build.rs              | 29 +++++++++++++++----
 docs/mcp.md                                   |  4 +--
 4 files changed, 53 insertions(+), 23 deletions(-)

diff --git a/crates/engine/src/cmd/buildcmds.rs b/crates/engine/src/cmd/buildcmds.rs
index 07b178bacc..63acde9722 100644
--- a/crates/engine/src/cmd/buildcmds.rs
+++ b/crates/engine/src/cmd/buildcmds.rs
@@ -779,18 +779,27 @@ fn repaint_from(g: &mut Node, old: &Node) {
             // An edge cut from the old one takes the old edge's dashes, arrowheads, width profile
             // and brush as they fall on its part of the old edge.
             if c.name.as_deref() == Some(EDGE_NAME)
-                && n.appearance.items.iter().any(depends_on_place)
                 && let Some(old_path) = was.path_data()
             {
-                let tracks: Vec<Track> = old_path.subpaths.iter().map(Track::new).collect();
-                let run = n.path_data_mut().and_then(|path| edge_run(&tracks, path));
-                let mut a = (*n.appearance).clone();
-                for r in &mut a.items {
-                    fit_to_edge(r, run);
-                }
-                n.appearance = a.into();
+                fit_to_old_edge(&mut n, old_path);
             }
             *c = Arc::new(n);
         }
     }
 }
+
+/// Fit the stroke rows of edge `n`, which it took from an old edge whose outline is `old`, to the
+/// part of the old edge that `n` runs, as [`fit_to_edge`] fits a source's rows to an edge cut from
+/// it; `n` is reversed when it runs against the old edge.
+fn fit_to_old_edge(n: &mut Node, old: &PathData) {
+    if !n.appearance.items.iter().any(depends_on_place) {
+        return;
+    }
+    let tracks: Vec<Track> = old.subpaths.iter().map(Track::new).collect();
+    let run = n.path_data_mut().and_then(|path| edge_run(&tracks, path));
+    let mut a = (*n.appearance).clone();
+    for r in &mut a.items {
+        fit_to_edge(r, run);
+    }
+    n.appearance = a.into();
+}
diff --git a/crates/engine/src/cmd/buildcmds/live_paint.rs b/crates/engine/src/cmd/buildcmds/live_paint.rs
index 9c3c750996..ac07fb92a3 100644
--- a/crates/engine/src/cmd/buildcmds/live_paint.rs
+++ b/crates/engine/src/cmd/buildcmds/live_paint.rs
@@ -1,7 +1,8 @@
 use super::{
     Appearance, Arc, Beside, Document, EDGE_NAME, EngineError, FACE_NAME, GapOptions, GapSize, LIVE_PAINT_NAME, Node, NodeId, PathData, Point, Rect,
-    Result, SOURCES_NAME, Selection, Session, SubPath, Value, b, bad, build_children, edge_near, face_at, finite, ids_json, is_live_paint, json,
-    number_or, object_param, paint_from, po, point_param, repaint_from, replace_roots, root_ids, source_nodes, source_shapes, switch_or,
+    Result, SOURCES_NAME, Selection, Session, SubPath, Value, b, bad, build_children, edge_near, face_at, finite, fit_to_old_edge, ids_json,
+    is_live_paint, json, number_or, object_param, paint_from, po, point_param, repaint_from, replace_roots, root_ids, source_nodes, source_shapes,
+    switch_or,
 };
 
 /// `options` as stored on a Live Paint group: none for the defaults.
@@ -125,15 +126,15 @@ fn merge_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result
     check_live_paint_takes(d, roots)?;
     let old = d.node(target).cloned().ok_or(EngineError::NoNode(target))?;
     // Paint to carry over: (point inside face, paint) for faces that draw, and (point on edge,
-    // paint) for every edge.
+    // paint, outline) for every edge.
     let keep_faces: Vec<(Point, Carried)> =
         b::faces(&old).iter().filter(|f| draws(f)).filter_map(|f| Some((po::interior_point(f.path_data()?)?, Carried::of(f)))).collect();
-    let keep_edges: Vec<(Point, Carried)> = b::edges(&old)
+    let keep_edges: Vec<(Point, Carried, PathData)> = b::edges(&old)
         .iter()
         .filter_map(|e| {
             let pd = e.path_data()?;
             let sp = pd.subpaths.first().filter(|sp| sp.segment_count() > 0)?;
-            Some((kurbo::ParamCurve::eval(&sp.segment(0), 0.5), Carried::of(e)))
+            Some((kurbo::ParamCurve::eval(&sp.segment(0), 0.5), Carried::of(e), pd.clone()))
         })
         .collect();
     let mut sources = source_nodes(&old);
@@ -161,12 +162,15 @@ fn merge_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result
             carried.onto(Arc::make_mut(f));
         }
     }
-    for (pt, carried) in keep_edges {
+    // An edge that an added path cuts from an old one takes the old edge's rows fitted to its part.
+    for (pt, carried, outline) in keep_edges {
         if let Some(eid) = edge_near(&g, pt, 0.5).map(|e| e.id)
             && let Some(ch) = g.children_mut()
             && let Some(e) = ch.iter_mut().find(|c| c.id == eid)
         {
-            carried.onto(Arc::make_mut(e));
+            let e = Arc::make_mut(e);
+            carried.onto(e);
+            fit_to_old_edge(e, &outline);
         }
     }
     let mut merged = Beside::replacing(d, roots);
diff --git a/crates/engine/src/tests/build.rs b/crates/engine/src/tests/build.rs
index f45644d951..e6a548647b 100644
--- a/crates/engine/src/tests/build.rs
+++ b/crates/engine/src/tests/build.rs
@@ -2753,10 +2753,10 @@ fn live_paint_make_fits_dashes_and_arrowheads_to_each_edge() {
     assert_eq!(edges, vec![rows]);
 }
 
-/// When Gap Options cuts an edge in two, each piece keeps the edge's dashes going on from where it
-/// starts along the edge, an arrowhead only at the end of the edge it ends at, and no brush.
+/// When Gap Options or Merge cuts an edge in two, each piece keeps the edge's dashes going on from
+/// where it starts along the edge, an arrowhead only at the end of the edge it ends at, and no brush.
 #[test]
-fn live_paint_gap_options_fits_an_edge_look_to_each_piece() {
+fn live_paint_gap_options_and_merge_fit_an_edge_look_to_each_piece() {
     use vectorcraft_doc::{Arrowhead, Dash};
     let mut s = session();
     let l = line(&mut s, (0.0, 50.0), (100.0, 50.0));
@@ -2770,7 +2770,7 @@ fn live_paint_gap_options_fits_an_edge_look_to_each_piece() {
     let rows = set_rows(&mut s, l, vec![row]);
     s.execute("select.set", &json!({"ids": [l.0, stub.0]})).unwrap();
     let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
-    let dashed = |s: &Session| {
+    let dashed = |s: &Session, g: NodeId| {
         let mut out: Vec<(f64, f64, vectorcraft_doc::StrokeLayer)> = vectorcraft_tools::builder::edges(&node(s, g))
             .iter()
             .filter_map(|e| {
@@ -2782,12 +2782,12 @@ fn live_paint_gap_options_fits_an_edge_look_to_each_piece() {
         out.sort_by(|p, q| p.0.total_cmp(&q.0));
         out
     };
-    let before = dashed(&s);
+    let before = dashed(&s, g);
     assert_eq!(before.len(), 1, "nothing cuts the line yet");
     assert_eq!(vec![AppearanceItem::Stroke(before[0].2.clone())], rows);
     let r = s.execute("livePaint.gapOptions", &json!({"id": g.0, "closeGaps": true})).unwrap();
     assert_eq!(r["closed"], json!(1));
-    let pieces = dashed(&s);
+    let pieces = dashed(&s, g);
     let ends: Vec<(f64, f64)> = pieces.iter().map(|p| (p.0, p.1)).collect();
     assert_eq!(ends, vec![(0.0, 50.0), (50.0, 100.0)], "the line is cut where the gap closes");
     let offsets: Vec<f64> = pieces.iter().map(|p| (p.2.dash.as_ref().unwrap().offset * 1e3).round() / 1e3).collect();
@@ -2795,6 +2795,23 @@ fn live_paint_gap_options_fits_an_edge_look_to_each_piece() {
     let arrows: Vec<_> = pieces.iter().map(|p| (p.2.start_arrow.clone(), p.2.end_arrow.clone())).collect();
     assert_eq!(arrows, vec![(Some(Arrowhead::Triangle), None), (None, Some(Arrowhead::Circle))]);
     assert!(pieces.iter().all(|p| p.2.brush.is_none()), "a brush spreads over the whole line");
+    // Merge: the piece of the edge that an added path cuts off, which takes the edge's look, gets
+    // it fitted to where it lies along the edge in the same way.
+    let mut s = session();
+    let l = line(&mut s, (0.0, 50.0), (100.0, 50.0));
+    set_rows(&mut s, l, rows.clone());
+    s.execute("select.set", &json!({"ids": [l.0]})).unwrap();
+    let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+    let cut = line(&mut s, (25.0, 0.0), (25.0, 100.0));
+    s.execute("livePaint.merge", &json!({"ids": [g.0, cut.0]})).unwrap();
+    let pieces = dashed(&s, g);
+    let ends: Vec<(f64, f64)> = pieces.iter().map(|p| (p.0, p.1)).collect();
+    assert_eq!(ends, vec![(0.0, 25.0), (25.0, 100.0)], "the added line cuts the edge");
+    let offsets: Vec<f64> = pieces.iter().map(|p| (p.2.dash.as_ref().unwrap().offset * 1e3).round() / 1e3).collect();
+    assert_eq!(offsets, vec![2.0, 27.0], "the dashes go on along the line");
+    let arrows: Vec<_> = pieces.iter().map(|p| (p.2.start_arrow.clone(), p.2.end_arrow.clone())).collect();
+    assert_eq!(arrows, vec![(Some(Arrowhead::Triangle), None), (None, Some(Arrowhead::Circle))]);
+    assert!(pieces.iter().all(|p| p.2.brush.is_none()), "a brush spreads over the whole line");
 }
 
 /// The edge Make builds from a closed path that nothing cuts starts at the anchor the path starts
diff --git a/docs/mcp.md b/docs/mcp.md
index 823c8bc577..4a85f8b671 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -3614,8 +3614,8 @@ already walks Image Trace. Short agent entry points:
   the path (Align Dashes to Corners is turned off on it), the arrowheads stay only at the path's own ends, and a width
   profile or brush stays only on an edge that runs the whole path. A gradient applied along a stroke starts again on
   each cut edge, and an inside or outside stroke is drawn centered on an edge that is an open piece of a closed path.
-  When `livePaint.gapOptions` cuts an edge into pieces, each piece takes the edge's rows fitted to its part of the
-  edge in the same way. A face or edge given no such row has one unpainted row. Rows that do not draw stay with the stored sources, which
+  When `livePaint.gapOptions` or `livePaint.merge` cuts an edge into pieces, a piece that takes the edge's rows takes
+  them fitted to its part of the edge in the same way. A face or edge given no such row has one unpainted row. Rows that do not draw stay with the stored sources, which
   `livePaint.release` returns unchanged. The source's object effects and the strokes' pen pressure are not carried.
   Expand keeps those face fills.
   `livePaint.expand` keeps each face and edge that draws, with all its fill and stroke rows: it is shown, its opacity

From de5a46a2ab448104a734d9991aafa9d37abeee23 Mon Sep 17 00:00:00 2001
From: dotCooCoo <RobertLeeLW@gmail.com>
Date: Sat, 14 Nov 2026 14:56:41 -0800
Subject: [PATCH 7/7] Live Paint: Merge keeps a painted edge's look on every
 piece an added path cuts

Merge carried each old edge's paint only to the new edge nearest the old
edge's middle, so when an added path cut a repainted edge, the other
piece went back to its source's stroke. Every new edge whose middle lies
on an old edge now takes that edge's paint, with its rows fitted to its
part of the edge, as Gap Options does.
---
 crates/engine/src/cmd/buildcmds/live_paint.rs | 43 +++++++++++--------
 crates/engine/src/tests/build.rs              | 21 +++++++++
 docs/mcp.md                                   |  4 +-
 3 files changed, 47 insertions(+), 21 deletions(-)

diff --git a/crates/engine/src/cmd/buildcmds/live_paint.rs b/crates/engine/src/cmd/buildcmds/live_paint.rs
index ac07fb92a3..88057c9b57 100644
--- a/crates/engine/src/cmd/buildcmds/live_paint.rs
+++ b/crates/engine/src/cmd/buildcmds/live_paint.rs
@@ -85,6 +85,9 @@ pub(super) fn lp_make(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({ "id": id.0, "faces": faces, "edges": edges }))
 }
 
+/// How far, in points, the middle of an edge Merge makes may be from the old edge it lies on.
+const ON_OLD_EDGE: f64 = 1e-3;
+
 /// What Merge carries from a face or edge to the part it makes again in its place, another path:
 /// the appearance, visibility, opacity and blending mode. Gradients fitted to the old outline keep
 /// that fit, and the strokes' pen pressure, tilt, bearing and rotation stay behind.
@@ -125,18 +128,11 @@ fn merge_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result
         .ok_or_else(|| EngineError::Other("Live Paint Merge: select a Live Paint group and the paths to add".into()))?;
     check_live_paint_takes(d, roots)?;
     let old = d.node(target).cloned().ok_or(EngineError::NoNode(target))?;
-    // Paint to carry over: (point inside face, paint) for faces that draw, and (point on edge,
-    // paint, outline) for every edge.
+    // Paint to carry over: (point inside face, paint) for faces that draw; edges are matched to the
+    // old edges below.
     let keep_faces: Vec<(Point, Carried)> =
         b::faces(&old).iter().filter(|f| draws(f)).filter_map(|f| Some((po::interior_point(f.path_data()?)?, Carried::of(f)))).collect();
-    let keep_edges: Vec<(Point, Carried, PathData)> = b::edges(&old)
-        .iter()
-        .filter_map(|e| {
-            let pd = e.path_data()?;
-            let sp = pd.subpaths.first().filter(|sp| sp.segment_count() > 0)?;
-            Some((kurbo::ParamCurve::eval(&sp.segment(0), 0.5), Carried::of(e), pd.clone()))
-        })
-        .collect();
+    let old_parts = old.clone();
     let mut sources = source_nodes(&old);
     for r in roots {
         if *r != target {
@@ -162,15 +158,24 @@ fn merge_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result
             carried.onto(Arc::make_mut(f));
         }
     }
-    // An edge that an added path cuts from an old one takes the old edge's rows fitted to its part.
-    for (pt, carried, outline) in keep_edges {
-        if let Some(eid) = edge_near(&g, pt, 0.5).map(|e| e.id)
-            && let Some(ch) = g.children_mut()
-            && let Some(e) = ch.iter_mut().find(|c| c.id == eid)
-        {
-            let e = Arc::make_mut(e);
-            carried.onto(e);
-            fit_to_old_edge(e, &outline);
+    // Each edge whose middle lies on an old edge, every piece of an edge an added path cuts
+    // included, takes the old edge's paint, with its rows fitted to its part of the old edge.
+    if let Some(ch) = g.children_mut() {
+        for c in ch.iter_mut().filter(|c| c.name.as_deref() == Some(EDGE_NAME)) {
+            let Some(mid) = c
+                .path_data()
+                .and_then(|pd| pd.subpaths.first())
+                .filter(|sp| sp.segment_count() > 0)
+                .map(|sp| kurbo::ParamCurve::eval(&sp.segment(0), 0.5))
+            else {
+                continue;
+            };
+            let Some(was) = edge_near(&old_parts, mid, ON_OLD_EDGE) else { continue };
+            let e = Arc::make_mut(c);
+            Carried::of(was).onto(e);
+            if let Some(outline) = was.path_data() {
+                fit_to_old_edge(e, outline);
+            }
         }
     }
     let mut merged = Beside::replacing(d, roots);
diff --git a/crates/engine/src/tests/build.rs b/crates/engine/src/tests/build.rs
index e6a548647b..83d685aeba 100644
--- a/crates/engine/src/tests/build.rs
+++ b/crates/engine/src/tests/build.rs
@@ -2812,6 +2812,27 @@ fn live_paint_gap_options_and_merge_fit_an_edge_look_to_each_piece() {
     let arrows: Vec<_> = pieces.iter().map(|p| (p.2.start_arrow.clone(), p.2.end_arrow.clone())).collect();
     assert_eq!(arrows, vec![(Some(Arrowhead::Triangle), None), (None, Some(Arrowhead::Circle))]);
     assert!(pieces.iter().all(|p| p.2.brush.is_none()), "a brush spreads over the whole line");
+    // A repainted edge that Merge cuts keeps its paint on every piece.
+    let mut s = session();
+    let l = line(&mut s, (0.0, 50.0), (100.0, 50.0));
+    s.execute("select.set", &json!({"ids": [l.0]})).unwrap();
+    let g = NodeId(s.execute("livePaint.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+    s.execute("livePaint.strokeEdge", &json!({"group": g.0, "point": [50, 50], "color": "#ff0000", "width": 3})).unwrap();
+    let cut = line(&mut s, (50.0, 0.0), (50.0, 100.0));
+    s.execute("livePaint.merge", &json!({"ids": [g.0, cut.0]})).unwrap();
+    let gn = node(&s, g);
+    let red = Paint::solid(Color::from_hex("#ff0000").unwrap());
+    let mut on_line: Vec<(f64, bool)> = vectorcraft_tools::builder::edges(&gn)
+        .iter()
+        .filter_map(|e| {
+            let sp = e.path_data()?.subpaths.first()?;
+            let (a, z) = (sp.anchors.first()?.p, sp.anchors.last()?.p);
+            ((a.y - 50.0).abs() < 1e-6 && (z.y - 50.0).abs() < 1e-6)
+                .then(|| ((a.x.min(z.x) * 1e3).round() / 1e3, e.appearance.stroke().is_some_and(|st| st.paint == red)))
+        })
+        .collect();
+    on_line.sort_by(|p, q| p.0.total_cmp(&q.0));
+    assert_eq!(on_line, vec![(0.0, true), (50.0, true)], "both pieces keep the edge's paint");
 }
 
 /// The edge Make builds from a closed path that nothing cuts starts at the anchor the path starts
diff --git a/docs/mcp.md b/docs/mcp.md
index 4a85f8b671..730ba3a68e 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -3614,8 +3614,8 @@ already walks Image Trace. Short agent entry points:
   the path (Align Dashes to Corners is turned off on it), the arrowheads stay only at the path's own ends, and a width
   profile or brush stays only on an edge that runs the whole path. A gradient applied along a stroke starts again on
   each cut edge, and an inside or outside stroke is drawn centered on an edge that is an open piece of a closed path.
-  When `livePaint.gapOptions` or `livePaint.merge` cuts an edge into pieces, a piece that takes the edge's rows takes
-  them fitted to its part of the edge in the same way. A face or edge given no such row has one unpainted row. Rows that do not draw stay with the stored sources, which
+  When `livePaint.gapOptions` or `livePaint.merge` cuts an edge into pieces, each piece takes the edge's paint, with
+  its rows fitted to its part of the edge in the same way. A face or edge given no such row has one unpainted row. Rows that do not draw stay with the stored sources, which
   `livePaint.release` returns unchanged. The source's object effects and the strokes' pen pressure are not carried.
   Expand keeps those face fills.
   `livePaint.expand` keeps each face and edge that draws, with all its fill and stroke rows: it is shown, its opacity