#1007: Reverse Gradient mirrors off-centre midpoints

Reversal read the midpoints after Gradient::reverse had reordered the stops, so each stop
took the wrong segment's midpoint: red-to-blue with its midpoint at 20% reversed to a 50%
midpoint instead of 80%, moving the transition.

Gradient::reverse now mirrors each segment's midpoint with it, so a reversed gradient is the
same ramp the other way round; paint.editGradient's own (wrong) pass is gone, and the SVG
importer's reflect spread, which had a correct copy of the same mirroring, uses it too.

Tests: two- and three-stop gradients with off-centre midpoints sample the same reversed (t vs
1 - t) and come back after two reversals; paint.editGradient reverse turns a 0.2 midpoint into
0.8.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

# Conflicts:
#	ROADMAP.md

ROADMAP.md

@@ -123,7 +123,7 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
 
 | Date | What landed |
 |---|---|
-| 2026-10-11 | Effect › Brush Strokes: Accented Edges, Angled Strokes, Crosshatch, Dark Strokes, Ink Outlines, Spatter, Sprayed Strokes, Sumi-e (G2) Command parameters from agents and files checked before anything changes (paint, place, cuts, dashes, crop, asset ids, anchors, paths, distort; #984–#999); command dialogs keep whole numbers whole, so Create Object Mosaic takes the tiles typed (#1000); stepper arrows take Shift (×10) and Ctrl/Cmd (÷10) like the arrow keys (#991). Exports and Rasterize supersample Art Optimized edges, so shapes meeting edge to edge leave no seam (#983). |
+| 2026-10-11 | Effect › Brush Strokes: Accented Edges, Angled Strokes, Crosshatch, Dark Strokes, Ink Outlines, Spatter, Sprayed Strokes, Sumi-e (G2). Command parameters from agents and files checked before anything changes (paint, place, cuts, dashes, crop, asset ids, anchors, paths, distort; #984–#999); command dialogs keep whole numbers whole, so Create Object Mosaic takes the tiles typed (#1000); stepper arrows take Shift (×10) and Ctrl/Cmd (÷10) like the arrow keys (#991). Exports and Rasterize supersample Art Optimized edges, so shapes meeting edge to edge leave no seam (#983). Character and paragraph styles take leading, kerning, mojikumi and the other attributes left out at their defaults (#1001). Drawing, typing and pasting with no layer shown and unlocked is refused instead of adding art to a hidden or locked layer (#1002). MCP `add_text` gives type on or in a path the colour asked for (#1003). MCP `screenshot` of a connected app renders the artboard asked for (#1004). `vectorcraft-cli run` ends quietly when its reader closes early (#1005). Select › All on Active Artboard selects on the artboard made active, not always the first (#1006). Reverse Gradient keeps off-centre midpoints, mirrored (#1007). |
 | 2026-10-10 | Initial live Revolve (Effect › 3D and Materials, #846, #605), in its own `three-d` crate. Progress docs re-measured and restructured to the craftrules standard (this page, `docs/target-app-parity.md`, `gaps.md`, `ui-parity.md`, the format, hardware, localization, effects and type checklists). Same day: v0.8.0; Effect › Distort, Pixelate and Texture filters (13); German interface; Variables (data merge); Graph Type value axes and tick marks; restart when the first frame never reaches the screen (#964) |
 | 2026-10-09 | Radial Blur, Smart Blur, Unsharp Mask (gap 2 begins); 340 commits, the busiest day |
 | 2026-10-08 | v0.5.0–v0.7.0; community contributions: Pen and shape-tool modifiers, Layers, Artboards, Japanese composition, Hebrew/Arabic type, interface languages, saved selections |

apps/vectorcraft-cli/src/main.rs

@@ -292,7 +292,21 @@ fn run(args: &[String]) -> Result<(), String> {
 
     let mut h = Headless::new();
     let mut out = std::io::stdout().lock();
-    let mut emit = |v: Value| writeln!(out, "{v}").map_err(|e| e.to_string());
+    // A reader that stopped early (a closed pipe) isn't an error, and the batch goes on: its later
+    // steps (an export…) still run, unprinted.
+    let mut closed = false;
+    let mut emit = |v: Value| {
+        if closed {
+            return Ok(());
+        }
+        match writeln!(out, "{v}") {
+            Err(e) if e.kind() == std::io::ErrorKind::BrokenPipe => {
+                closed = true;
+                Ok(())
+            }
+            r => r.map_err(|e| e.to_string()),
+        }
+    };
     if let Some(path) = &input {
         let r = h.call("app.open", json!({"path": path})).map_err(|e| format!("open {path}: {e}"))?;
         emit(json!({"step": "open", "path": path, "result": r}))?;

apps/vectorcraft-cli/tests/cli.rs

@@ -297,3 +297,21 @@ fn closed_stdout_ends_quietly() {
     let err = String::from_utf8_lossy(&out.stderr);
     assert!(out.status.success() && !err.contains("panicked"), "{:?}: {err}", out.status);
 }
+
+/// #1005: `run` whose reader has gone (`vectorcraft-cli run … | true`) ends quietly with status 0,
+/// and its later steps still run; a failing step still fails.
+#[test]
+fn run_with_a_closed_stdout_ends_quietly_and_finishes_the_batch() {
+    let svg = tmp("closed-run.svg");
+    let _ = std::fs::remove_file(&svg);
+    let rect = r#"{"x":1,"y":1,"width":5,"height":5}"#;
+    let args = ["run", "--cmd", "document.json", "--cmd", "shape.rectangle", "--params", rect, "--export", svg.to_str().unwrap()];
+    let mut child = Command::new(BIN).args(args).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();
+    drop(child.stdout.take());
+    let out = child.wait_with_output().unwrap();
+    let err = String::from_utf8_lossy(&out.stderr);
+    assert!(out.status.success() && err.is_empty(), "{:?}: {err}", out.status);
+    assert!(svg.is_file(), "the export after the closed reader still ran");
+    let out = Command::new(BIN).args(["run", "--cmd", "not-a-command"]).stdout(Stdio::null()).output().unwrap();
+    assert!(!out.status.success());
+}

crates/color/src/gradient.rs

@@ -131,10 +131,18 @@ impl Gradient {
             std::iter::once((s.offset, s.color, s.opacity, None)).chain(mid)
         })
     }
+    /// The same ramp the other way round: the stops in reverse order at mirrored offsets, each
+    /// segment's midpoint mirrored with it.
     pub fn reverse(&mut self) {
         self.stops.reverse();
-        for s in &mut self.stops {
-            s.offset = 1.0 - s.offset;
+        for i in 0..self.stops.len() {
+            // A midpoint belongs to the segment after its stop: reversed, stop i's segment is the
+            // one the next stop (not yet mirrored) had, measured from the other end.
+            let mid = self.stops.get(i + 1).map_or(0.5, |n| 1.0 - n.midpoint);
+            if let Some(s) = self.stops.get_mut(i) {
+                s.offset = 1.0 - s.offset;
+                s.midpoint = mid;
+            }
         }
     }
     pub fn sort(&mut self) {
@@ -569,6 +577,32 @@ mod tests {
         assert_eq!(g.stops[0].offset, 0.0);
     }
 
+    /// #1007: reversing mirrors off-centre midpoints with their segments, so the ramp is the same
+    /// the other way round.
+    #[test]
+    fn reverse_mirrors_midpoints() {
+        let stop = |offset, hex, midpoint| GradientStop { midpoint, ..GradientStop::new(offset, Color::from_hex(hex).unwrap()) };
+        let two = Gradient { kind: GradientKind::Linear, stops: vec![stop(0.0, "#ff0000", 0.2), stop(1.0, "#0000ff", 0.5)] };
+        let three =
+            Gradient { kind: GradientKind::Linear, stops: vec![stop(0.0, "#ff0000", 0.2), stop(0.3, "#00ff00", 0.8), stop(1.0, "#0000ff", 0.5)] };
+        for g in [two, three] {
+            let mut r = g.clone();
+            r.reverse();
+            let mids: Vec<f32> = r.stops.iter().map(|s| s.midpoint).collect();
+            let want: Vec<f32> = g.stops.iter().rev().skip(1).map(|s| 1.0 - s.midpoint).chain([0.5]).collect();
+            assert!(mids.iter().zip(&want).all(|(a, b)| (a - b).abs() < 1e-6), "{mids:?} {want:?}");
+            for i in 0..=20 {
+                let t = i as f32 / 20.0;
+                let ((a, ao), (b, bo)) = (g.sample(t), r.sample(1.0 - t));
+                let same = a.to_rgba8(1.0).iter().zip(b.to_rgba8(1.0)).all(|(x, y)| x.abs_diff(y) <= 1);
+                assert!(same && (ao - bo).abs() < 1e-6, "t {t}: {a:?} vs {b:?}");
+            }
+            r.reverse();
+            let back = r.stops.iter().zip(&g.stops).all(|(a, b)| (a.offset - b.offset).abs() < 1e-6 && (a.midpoint - b.midpoint).abs() < 1e-6);
+            assert!(back, "reversed twice, it is as it was: {:?}", r.stops);
+        }
+    }
+
     fn close(a: Point, b: Point) -> bool {
         a.distance(b) < 1e-9
     }

crates/engine/src/cmd/brushsym.rs

@@ -603,7 +603,7 @@ fn symbol_place(s: &mut Session, p: &Value) -> Result<Value> {
     let centre = d.artboards.first().map(|a| a.rect.center()).unwrap_or(Point::ZERO);
     let c = Point::new(f64_or(p, "x", centre.x), f64_or(p, "y", centre.y));
     let size = natural_size(d, &name);
-    let parent = s.doc()?.insertion_parent();
+    let parent = s.doc()?.target_parent()?;
     let id = s.edit("Place Symbol Instance", |d, sel| {
         let id = d.alloc_id();
         d.insert(parent, usize::MAX, Node::new(id, NodeKind::SymbolInstance { symbol: name.clone(), xf: place_xf(c, size) }))?;
@@ -843,7 +843,8 @@ fn symbol_spray(s: &mut Session, p: &Value) -> Result<Value> {
     let alt = bool_or(p, "alt", false);
     let size = natural_size(&st.doc, &name);
     let set = st.selection.objects.first().copied().filter(|id| st.selection.len() == 1 && st.doc.node(*id).is_some_and(is_symbol_set));
-    let parent = st.insertion_parent();
+    // Only a new Symbol Set needs a layer that takes new art.
+    let parent = if alt || set.is_some() { st.insertion_parent() } else { st.target_parent()? };
     if alt {
         // Remove instances of this symbol under the brush (within the set, or anywhere).
         let d = &st.doc;

crates/engine/src/cmd/create.rs

@@ -79,7 +79,7 @@ pub(crate) fn add_node(s: &mut Session, label: &str, kind: NodeKind, appearance:
 
 /// Insert a new object looking like `look` (drawing modes apply); select it.
 pub(crate) fn add_look(s: &mut Session, label: &str, kind: NodeKind, look: NewArt, name: Option<String>) -> Result<Value> {
-    let parent = s.doc()?.insertion_parent();
+    let parent = s.doc()?.target_parent()?;
     let mode = s.draw_mode;
     let inside = s.draw_inside;
     let behind_of = s.doc()?.selection.in_paint_order(&s.doc()?.doc).first().copied();
@@ -298,7 +298,7 @@ fn flare(s: &mut Session, p: &Value) -> Result<Value> {
         };
         parts.push(("Ring", circle(at, rr), radial(at, rr, stops), 1.0));
     }
-    let parent = s.doc()?.insertion_parent();
+    let parent = s.doc()?.target_parent()?;
     let id = s.edit("Flare", |d, sel| {
         let children = parts
             .into_iter()
@@ -352,7 +352,7 @@ fn arc(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn grid_group(s: &mut Session, label: &str, paths: Vec<PathData>) -> Result<Value> {
-    let parent = s.doc()?.insertion_parent();
+    let parent = s.doc()?.target_parent()?;
     let look = s.new_art_look(vectorcraft_color::Paint::None, s.paint.stroke.clone(), s.paint.stroke_width);
     let id = s.edit(label, |d, sel| {
         let children = paths

crates/engine/src/cmd/edit.rs

@@ -346,7 +346,7 @@ fn paste_clip(s: &mut Session, p: &Value, mode: PasteMode, clip: &Clipboard, cho
     let off = s.prefs.paste_offset;
     let st = s.doc()?;
     let same_doc = clip.source_doc == Some(st.uid);
-    let parent = st.insertion_parent();
+    let parent = st.target_parent()?;
     // A copied artboard comes back with its art: right of the last artboard, or where it was
     // (Paste in Place, in Front, in Back). Paste on All Artboards pastes only the art.
     let board = clip

crates/engine/src/cmd/gradient.rs

@@ -270,13 +270,8 @@ pub(crate) fn apply_gradient_edit_in(
         gp.swatch = None;
     }
     if bool_or(p, "reverse", false) {
+        // Midpoints mirrored with their segments.
         gp.gradient.reverse();
-        // Midpoints belong to the segment to the right; mirror them.
-        let n = gp.gradient.stops.len();
-        let mids: Vec<f32> = gp.gradient.stops.iter().map(|s| s.midpoint).collect();
-        for i in 0..n {
-            gp.gradient.stops[i].midpoint = if i + 1 < n { 1.0 - mids[n - 2 - i] } else { 0.5 };
-        }
     }
     // Angle and aspect edits keep the focal point in its place in the extent ellipse.
     let before = gp.geom;

crates/engine/src/cmd/graph.rs

@@ -831,7 +831,7 @@ fn create(s: &mut Session, p: &Value) -> Result<Value> {
         spec.categories = vec!["A".into(), "B".into(), "C".into(), "D".into()];
         spec.rows = vec![vec![3.0, 2.0], vec![5.0, 4.0], vec![4.0, 6.0], vec![7.0, 5.0]];
     }
-    let parent = s.doc()?.insertion_parent();
+    let parent = s.doc()?.target_parent()?;
     let id = s.edit("Graph", |d, sel| {
         let gid = d.alloc_id();
         let mut g = Node::group(gid, vec![]);

crates/engine/src/cmd/menucmds.rs

@@ -702,7 +702,7 @@ fn trim_marks(s: &mut Session, p: &Value) -> Result<Value> {
     if rects.is_empty() {
         return Err(bad(C, "nothing to mark"));
     }
-    let parent = s.doc()?.insertion_parent();
+    let parent = s.doc()?.target_parent()?;
     let ids = s.edit("Create Trim Marks", |d, sel| {
         let mut ids = vec![];
         for r in &rects {

crates/engine/src/cmd/textedit.rs

@@ -45,7 +45,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Area / Path Type",
             [],
             None,
-            "{path: id, mode: \"area\"|\"onPath\", text?: \"\", vertical?: bool = false, at?: [x, y] (on-path start: nearest point), size?, font?, fit?: none|autoHeight|shrinkText, fitMinPercent? (area: as text.areaOptions; default autoHeight when the autoSizeAreaType preference is on), placeholder?: bool (placeholder text instead, as text.create), leadingModel?, charAlign? (as text.create)} turn a path into an area-type frame or a type-on-a-path baseline (the path's paint is dropped) → {id}",
+            "{path: id, mode: \"area\"|\"onPath\", text?: \"\", vertical?: bool = false, at?: [x, y] (on-path start: nearest point), size?, font?, style?, color? (as text.create), fit?: none|autoHeight|shrinkText, fitMinPercent? (area: as text.areaOptions; default autoHeight when the autoSizeAreaType preference is on), placeholder?: bool (placeholder text instead, as text.create), leadingModel?, charAlign? (as text.create)} turn a path into an area-type frame or a type-on-a-path baseline (the path's paint is dropped) → {id}",
             has_doc,
             create_in_path
         ),
@@ -485,16 +485,7 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
     if !on_path && !path.is_closed() && path.bounds().is_none_or(|b| b.width() < 1.0 || b.height() < 1.0) {
         return Err(bad(C, "area type needs a path that encloses an area"));
     }
-    let mut style = CharStyle::default();
-    if let Some(v) = p.get("size").and_then(Value::as_f64) {
-        style.size = v.clamp(0.1, 1296.0);
-    }
-    if let Some(f) = str_param(p, "font") {
-        style.font_family = f.to_string();
-    }
-    if !s.paint.fill.is_none() && s.paint.fill != Paint::solid(vectorcraft_color::Color::WHITE) {
-        style.fill = s.paint.fill.clone();
-    }
+    let style = super::create::new_type_style(s, p);
     let text = str_param(p, "text").unwrap_or("").to_string();
     let start = match point_param(p, "at") {
         Some(at) if on_path => vectorcraft_geom::ArcPath::new(path).fraction_at(at).unwrap_or(0.0),

crates/engine/src/cmd/textstyles.rs

@@ -133,14 +133,44 @@ fn to_attrs<T: Serialize>(v: &T) -> Map<String, Value> {
     m
 }
 
+/// Every attribute name `T` reads, including those its JSON leaves out at their defaults (Auto
+/// leading and kerning, no mojikumi…): the field names serde's derive hands `deserialize_struct`.
+/// Not `justify_auto`, which [`to_map`] turns into `"justify": "Auto"`.
+fn attr_names<T: DeserializeOwned>() -> Vec<&'static str> {
+    use serde::de::{Error as _, Visitor, value::Error};
+
+    struct Names<'a>(&'a mut &'static [&'static str]);
+    impl<'de> serde::Deserializer<'de> for Names<'_> {
+        type Error = Error;
+        fn deserialize_any<V: Visitor<'de>>(self, _: V) -> std::result::Result<V::Value, Error> {
+            Err(Error::custom("not a struct"))
+        }
+        fn deserialize_struct<V: Visitor<'de>>(self, _: &'static str, fields: &'static [&'static str], _: V) -> std::result::Result<V::Value, Error> {
+            *self.0 = fields;
+            Err(Error::custom("field names only"))
+        }
+        serde::forward_to_deserialize_any! {
+            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string bytes byte_buf option unit
+            unit_struct newtype_struct seq tuple tuple_struct map enum identifier ignored_any
+        }
+    }
+
+    let mut fields: &'static [&'static str] = &[];
+    // Always an error: the probe only records the names.
+    let _ = T::deserialize(Names(&mut fields));
+    fields.iter().copied().filter(|&f| f != "justify_auto").collect()
+}
+
 /// `base` with `attrs` written over it (unknown or ill-typed attributes are an error).
 fn with_attrs<T: Serialize + DeserializeOwned>(base: &T, attrs: &Map<String, Value>, cmd: &str) -> Result<T> {
     let mut m = to_attrs(base);
     if let Some(full) = to_map(base) {
         m.insert("style_name".into(), full.get("style_name").cloned().unwrap_or(Value::Null));
     }
+    let names = attr_names::<T>();
     for (k, v) in attrs {
-        if !m.contains_key(k) {
+        // Not only the keys `base` writes: those at their defaults (Auto leading…) are left out.
+        if !m.contains_key(k) && !names.contains(&k.as_str()) {
             return Err(bad(cmd, format!("unknown attribute `{k}`")));
         }
         m.insert(k.clone(), v.clone());
@@ -575,6 +605,44 @@ mod tests {
         assert_eq!(s.doc().unwrap().doc.char_styles.iter().find(|d| d.name == "Pink").unwrap().attrs["fill"], fill);
     }
 
+    /// #1001: attributes their JSON leaves out at the defaults (Auto leading and kerning, no
+    /// mojikumi) are still attributes a style can set, and a style captured with one applies to
+    /// text at the default, is duplicated and comes back out of a library.
+    #[test]
+    fn styles_take_attributes_left_out_at_their_defaults() {
+        let (mut s, id) = session_with_text("A");
+        s.execute("charStyle.new", &json!({"name": "Kerned", "attrs": {"kerning": 40, "leading": 30}})).unwrap();
+        s.execute("charStyle.setAttrs", &json!({"name": "Kerned", "attrs": {"kerning": 20, "small_caps": 70}})).unwrap();
+        s.execute("paraStyle.new", &json!({"name": "Punctuation", "attrs": {"mojikumi": "lineEndHalf"}})).unwrap();
+        s.execute("paraStyle.setAttrs", &json!({"name": "Punctuation", "attrs": {"direction": "rightToLeft"}})).unwrap();
+        for bad in [json!({"nope": 1}), json!({"justify_auto": true})] {
+            assert!(s.execute("paraStyle.new", &json!({"name": "Bad", "attrs": bad})).is_err(), "{bad}");
+        }
+        // Captured from text with explicit leading, applied to fresh Auto-leading text.
+        s.execute("text.setStyle", &json!({"leading": 30})).unwrap();
+        s.execute("charStyle.new", &json!({"name": "Spaced"})).unwrap();
+        let fresh = s.execute("text.create", &json!({"x": 10, "y": 90, "text": "B"})).unwrap()["id"].as_u64().unwrap();
+        assert_eq!(runs(&s, fresh)[0].style.leading, None);
+        for clear in [false, true] {
+            s.execute("charStyle.apply", &json!({"name": "Spaced", "id": fresh, "clearOverrides": clear})).unwrap();
+            assert_eq!(runs(&s, fresh)[0].style.leading, Some(30.0));
+        }
+        let copy = s.execute("charStyle.duplicate", &json!({"name": "Spaced"})).unwrap()["name"].as_str().unwrap().to_string();
+        assert_eq!(s.doc().unwrap().doc.char_styles.iter().find(|d| d.name == copy).unwrap().attrs["leading"], 30.0);
+        s.execute("charStyle.apply", &json!({"name": "Kerned", "id": fresh})).unwrap();
+        let st = runs(&s, fresh)[0].style.clone();
+        assert_eq!((st.kerning, st.small_caps), (Some(20.0), Some(70.0)));
+        s.execute("paraStyle.apply", &json!({"name": "Punctuation", "id": id})).unwrap();
+        let NodeKind::Text(t) = &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind else { panic!() };
+        assert_eq!((t.para.mojikumi, t.para.direction), (vectorcraft_doc::Mojikumi::LineEndHalf, Some(vectorcraft_doc::ParaDirection::RightToLeft)));
+        // A library keeps the captured attributes and makes the style again where it's used.
+        s.execute("select.set", &json!({"ids": [id]})).unwrap();
+        let lib = s.execute("library.add", &json!({"kind": "charStyle", "name": "Lib Spaced"})).unwrap();
+        let other = s.execute("text.create", &json!({"x": 10, "y": 150, "text": "C"})).unwrap()["id"].as_u64().unwrap();
+        s.execute("library.use", &json!({"library": lib["library"], "kind": "charStyle", "item": lib["name"]})).unwrap();
+        assert_eq!(runs(&s, other)[0].style.leading, Some(30.0));
+    }
+
     #[test]
     fn paragraph_styles_and_survive_save() {
         let (mut s, id) = session_with_text("Body");

crates/engine/src/lib.rs

@@ -346,6 +346,14 @@ impl DocState {
         // A sublayer takes new art only while it and the layers around it are shown and unlocked.
         self.active_layer.filter(|l| self.doc.node(*l).is_some_and(|n| n.is_layer()) && self.doc.is_editable(*l)).or_else(|| self.doc.default_layer())
     }
+    /// [`Self::insertion_parent`] for new art, which a locked or hidden layer never takes: an error
+    /// when no layer is shown and unlocked, so the art is refused rather than hidden or locked away.
+    pub fn target_parent(&self) -> Result<Option<NodeId>> {
+        match self.insertion_parent() {
+            Some(p) if !self.doc.is_editable(p) => Err(EngineError::Other("the target layer is locked or hidden".into())),
+            parent => Ok(parent),
+        }
+    }
     /// The highlighted Layers panel rows that still exist (ids are reused after undo, so a
     /// remembered row must still be in the document).
     pub fn highlighted_rows(&self) -> Vec<NodeId> {

crates/engine/src/tests_layers.rs

@@ -78,6 +78,36 @@ fn art_in_a_sublayer_is_selected_as_objects_not_the_sublayer() {
     assert!(s.doc().unwrap().doc.node(a).is_none());
 }
 
+/// #1002: with no layer shown and unlocked, new art is refused (the document unchanged) rather
+/// than put on a hidden or locked layer; another layer that takes art still gets it.
+#[test]
+fn new_art_is_refused_when_no_layer_is_shown_and_unlocked() {
+    for prop in ["visible", "locked"] {
+        let mut s = session();
+        let layer = s.doc().unwrap().doc.layers[0].id;
+        let copied = rect(&mut s, 0.0);
+        run(&mut s, "select.set", json!({"ids": [copied.0]}));
+        run(&mut s, "edit.copy", json!({}));
+        run(&mut s, "select.none", json!({}));
+        run(&mut s, "layer.setProps", json!({"ids": [layer.0], prop: prop == "locked"}));
+        let before = s.doc().unwrap().doc.clone();
+        for (cmd, p) in [
+            ("shape.ellipse", json!({"x": 10, "y": 10, "width": 20, "height": 20})),
+            ("shape.polarGrid", json!({"x": 10, "y": 10, "width": 20, "height": 20})),
+            ("text.create", json!({"x": 10, "y": 40, "text": "A"})),
+            ("edit.paste", json!({})),
+        ] {
+            let e = s.execute(cmd, &p).unwrap_err();
+            assert_eq!(e.to_string(), "the target layer is locked or hidden", "{prop} {cmd}");
+        }
+        assert_eq!(s.doc().unwrap().doc.layers, before.layers, "{prop}: nothing was added");
+        let other = id(&run(&mut s, "layer.new", json!({})));
+        run(&mut s, "layer.setCurrent", json!({"id": layer.0}));
+        let n = rect(&mut s, 50.0);
+        assert_eq!(parent(&s, n), Some(other), "{prop}");
+    }
+}
+
 #[test]
 fn clicking_rows_at_any_depth_highlights_them_and_sets_the_current_layer() {
     let mut s = session();

crates/engine/src/tests_panelcmds.rs

@@ -56,6 +56,13 @@ fn edit_gradient_angle_reverse_and_errors() {
     s.execute("paint.editGradient", &json!({"stroke": false, "reverse": true})).unwrap();
     let Paint::Gradient(g) = node(&s, id).appearance.fill_paint() else { panic!() };
     assert_eq!(g.gradient.stops[0].color.to_hex(), "#000000");
+    // #1007: an off-centre midpoint is mirrored, not reset.
+    let stops = json!([{"offset": 0, "color": "#ff0000", "midpoint": 0.2}, {"offset": 1, "color": "#0000ff"}]);
+    s.execute("paint.editGradient", &json!({"stroke": false, "stops": stops})).unwrap();
+    s.execute("paint.editGradient", &json!({"stroke": false, "reverse": true})).unwrap();
+    let Paint::Gradient(g) = node(&s, id).appearance.fill_paint() else { panic!() };
+    assert_eq!(g.gradient.stops[0].color.to_hex(), "#0000ff");
+    assert!((g.gradient.stops[0].midpoint - 0.8).abs() < 1e-6, "{:?}", g.gradient.stops);
     assert!(s.execute("paint.editGradient", &json!({"stops": [{"offset": 0, "color": "#fff"}]})).is_err());
     assert!(s.execute("paint.editGradient", &json!({"kind": "conic"})).is_err());
 }

crates/mcp/src/tests.rs

@@ -312,6 +312,22 @@ fn inspect_document_reports_the_paint_of_type() {
     assert_eq!((t["fill"].as_str(), t["stroke"].as_str(), t["strokeWidth"].as_f64()), (Some("#0000ff"), Some("#00ff00"), Some(3.0)), "{t}");
 }
 
+/// #1003: type made on or in a path takes add_text's `color` too, over the current fill.
+#[test]
+fn add_text_on_or_in_a_path_takes_its_color() {
+    for mode in ["onPath", "area"] {
+        let mut s = server();
+        let r = call(&mut s, 2, "draw_shape", json!({"shape": "rectangle", "x": 40, "y": 40, "width": 180, "height": 60, "fill": "#0000ff"}));
+        let path = serde_json::from_str::<Value>(&text_of(&r)).unwrap()["id"].clone();
+        let r = call(&mut s, 3, "add_text", json!({"text": "Hello", "path": path, "mode": mode, "color": "#ff0000"}));
+        assert_eq!(r["isError"], false, "{r}");
+        let id = serde_json::from_str::<Value>(&text_of(&r)).unwrap()["id"].clone();
+        let v: Value = serde_json::from_str(&text_of(&call(&mut s, 4, "inspect_document", json!({})))).unwrap();
+        let t = v["layers"][0]["children"].as_array().unwrap().iter().find(|c| c["id"] == id).cloned().unwrap();
+        assert_eq!(t["fill"].as_str(), Some("#ff0000"), "{mode}: {t}");
+    }
+}
+
 /// save_file says it saves in the document's own format or the one the path's extension picks.
 #[test]
 fn save_file_describes_the_formats_it_writes() {

crates/mcp/src/tools.rs

@@ -574,7 +574,7 @@ fn select_ids(b: &mut dyn Backend, a: &Args) -> Result<(), String> {
 fn add_text(b: &mut dyn Backend, a: &Args) -> Result<Value, String> {
     let text = a.get("text").and_then(Value::as_str).ok_or("missing string argument `text`")?;
     let mut style = json!({});
-    for k in ["size", "font"] {
+    for k in ["size", "font", "color"] {
         if let Some(v) = a.get(k) {
             style[k] = v.clone();
         }
@@ -592,9 +592,6 @@ fn add_text(b: &mut dyn Backend, a: &Args) -> Result<Value, String> {
         for (k, v) in style.as_object().into_iter().flatten() {
             p[k.as_str()] = v.clone();
         }
-        if let Some(c) = a.get("color") {
-            p["color"] = c.clone();
-        }
         if let (Some(w), Some(h)) = (a.get("width"), a.get("height")) {
             p["area"] = json!({"width": w, "height": h});
         }

crates/svg/src/import/spread.rs

@@ -2,7 +2,7 @@
 //! repeated (every other period mirrored, for reflect) as many times as the painted area needs,
 //! and the gradient stretched over those periods.
 
-use vectorcraft_color::{GradientGeom, GradientKind, GradientStop};
+use vectorcraft_color::{Gradient, GradientGeom, GradientKind, GradientStop};
 use vectorcraft_geom::{Point, Rect};
 
 /// Most periods a gradient is expanded to.
@@ -80,17 +80,9 @@ fn whole_period(stops: &[GradientStop]) -> Vec<GradientStop> {
 
 /// A period mirrored: the stops in reverse, each midpoint measured from the other side.
 fn mirror(period: &[GradientStop]) -> Vec<GradientStop> {
-    let rev: Vec<&GradientStop> = period.iter().rev().collect();
-    rev.iter()
-        .enumerate()
-        .map(|(i, s)| GradientStop {
-            offset: 1.0 - s.offset,
-            // The midpoint from this stop to the next one is the mirror of the one the next stop
-            // had towards this one.
-            midpoint: rev.get(i + 1).map_or(0.5, |next| 1.0 - next.midpoint),
-            ..(*s).clone()
-        })
-        .collect()
+    let mut g = Gradient { kind: GradientKind::Linear, stops: period.to_vec() };
+    g.reverse();
+    g.stops
 }
 
 #[cfg(test)]

crates/ui-egui/src/control.rs

@@ -16,8 +16,8 @@
 //! - `ui.dialog.set {field, value}` / `ui.dialog.confirm` / `ui.dialog.cancel`
 //! - `ui.resize {width, height}`, `ui.focus`, `ui.screenshot {path?, data?}` (`data: true`: the PNG
 //!   comes back as `pngBase64` as well)
-//! - `ui.render {path?, scale?, data?}`: render the active artboard headlessly (PNG; without a path,
-//!   or with `data: true`, as `pngBase64`)
+//! - `ui.render {path?, scale?, artboard?, data?}`: render an artboard headlessly (`artboard`: its
+//!   0-based index, default the first; PNG; without a path, or with `data: true`, as `pngBase64`)
 //! - `app.open {path}` (any readable format) / `app.save {path?, svg?: {…SVG options}}` / `app.quit`
 //!   (`file.close`, `file.closeAll` and `app.quit` first open a `saveChanges` dialog for each
 //!   modified document: `ui.dialog.confirm` saves, set `discard: true` then confirm to discard)
@@ -321,7 +321,9 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context, req: &ControlReques
         "ui.render" => {
             let Some(st) = app.session.active() else { return err("no document") };
             let doc = st.doc.clone();
-            let Some(r) = doc.artboards.first().map(|a| a.rect) else { return err("no artboard") };
+            // The artboard asked for (0-based, as headless), else the first.
+            let index = p.get("artboard").and_then(Value::as_u64).map_or(Some(0), |i| usize::try_from(i).ok());
+            let Some(r) = index.and_then(|i| doc.artboards.get(i)).map(|a| a.rect) else { return err("no such artboard") };
             let scale = p.get("scale").and_then(Value::as_f64).unwrap_or(1.0);
             if let Err(e) = vectorcraft_render::raster_size(r, scale) {
                 return err(e);
@@ -390,3 +392,42 @@ pub fn save_screenshot(app: &mut VectorcraftApp, image: &egui::ColorImage, path:
         None => json!({"ok": false, "error": "no writer configured"}),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{Value, json};
+    use vectorcraft_engine::Session;
+
+    use super::ControlRequest;
+    use crate::{Services, VectorcraftApp};
+
+    /// #1004: `ui.render` (the MCP `screenshot` of a connected app) renders the artboard asked
+    /// for, at the scale asked for; the first without one.
+    #[test]
+    fn render_takes_the_artboard_asked_for() {
+        let (tx, rx) = std::sync::mpsc::channel();
+        let mut app = VectorcraftApp::new(Session::new(), Services::default()).with_control(rx);
+        let mut request = |method: &str, params: Value| {
+            let (req, reply) = ControlRequest::new(method, params);
+            tx.send(req).unwrap();
+            app.drain_control(&egui::Context::default());
+            reply.try_recv().unwrap()
+        };
+        let new = json!({"width": 64, "height": 64, "units": "Points", "artboards": 2});
+        request("engine.execute", json!({"command": "file.new", "params": new}));
+        let board = json!({"index": 1, "x": 100, "y": 0, "width": 96, "height": 48});
+        let r = request("engine.execute", json!({"command": "artboard.setProps", "params": board}));
+        assert_eq!(r["ok"], true, "{r}");
+        for (params, size) in [
+            (json!({}), [64, 64]),
+            (json!({"artboard": 0}), [64, 64]),
+            (json!({"artboard": 1}), [96, 48]),
+            (json!({"artboard": 1, "scale": 0.5}), [48, 24]),
+        ] {
+            let r = request("ui.render", params.clone());
+            let got = [&r["result"]["width"], &r["result"]["height"]].map(Value::as_u64);
+            assert_eq!(got, size.map(Some), "{params}: {r}");
+        }
+        assert!(request("ui.render", json!({"artboard": 2}))["error"].is_string());
+    }
+}

crates/ui-egui/src/i18n/de.tsv

@@ -3656,6 +3656,7 @@ theme	Appearance	Erscheinungsbild
 @msg	the image's pixels don't match its size	die Pixel des Bilds passen nicht zu seiner Größe
 @msg	the layer has no objects to clip by	die Ebene hat keine Objekte, an denen beschnitten werden könnte
 @msg	the layer or group is locked	die Ebene oder Gruppe ist gesperrt
+@msg	the target layer is locked or hidden	die Zielebene ist gesperrt oder ausgeblendet
 @msg	the layer to flatten into is hidden	die Ebene, auf die reduziert werden soll, ist ausgeblendet
 @msg	the object already has an opacity mask	das Objekt hat bereits eine Deckkraftmaske
 @msg	the object has no geometry	das Objekt hat keine Geometrie

crates/ui-egui/src/i18n/es.tsv

@@ -3759,6 +3759,7 @@ axis	Both	Ambos
 @msg	the image's pixels don't match its size	los píxeles de la imagen no coinciden con su tamaño
 @msg	the layer has no objects to clip by	la capa no tiene objetos con los que recortar
 @msg	the layer or group is locked	la capa o el grupo está bloqueado
+@msg	the target layer is locked or hidden	la capa de destino está bloqueada u oculta
 @msg	the layer to flatten into is hidden	la capa en la que acoplar está oculta
 @msg	the object already has an opacity mask	el objeto ya tiene una máscara de opacidad
 @msg	the object has no geometry	el objeto no tiene geometría

crates/ui-egui/src/i18n/fr.tsv

@@ -3756,6 +3756,7 @@ axis	Both	Les deux
 @msg	the image's pixels don't match its size	les pixels de l’image ne correspondent pas à sa taille
 @msg	the layer has no objects to clip by	le calque n’a aucun objet servant à l’écrêtage
 @msg	the layer or group is locked	le calque ou le groupe est verrouillé
+@msg	the target layer is locked or hidden	le calque cible est verrouillé ou masqué
 @msg	the layer to flatten into is hidden	le calque de destination de l’aplatissement est masqué
 @msg	the object already has an opacity mask	l’objet a déjà un masque d’opacité
 @msg	the object has no geometry	l’objet n’a pas de géométrie

crates/ui-egui/src/i18n/it.tsv

@@ -3759,6 +3759,7 @@ axis	Both	Entrambi
 @msg	the image's pixels don't match its size	i pixel dell'immagine non corrispondono alle sue dimensioni
 @msg	the layer has no objects to clip by	il livello non ha oggetti con cui ritagliare
 @msg	the layer or group is locked	il livello o il gruppo è bloccato
+@msg	the target layer is locked or hidden	il livello di destinazione è bloccato o nascosto
 @msg	the layer to flatten into is hidden	il livello in cui appiattire è nascosto
 @msg	the object already has an opacity mask	l'oggetto ha già una maschera di opacità
 @msg	the object has no geometry	l'oggetto non ha geometria

crates/ui-egui/src/i18n/ja.tsv

@@ -3497,6 +3497,7 @@ theme	Appearance	外観
 @msg	no selection bounds	選択範囲に境界がありません
 @msg	the layer has no objects to clip by	レイヤーにクリッピングマスクとして使えるオブジェクトがありません
 @msg	the layer or group is locked	レイヤーまたはグループがロックされています
+@msg	the target layer is locked or hidden	ターゲットレイヤーがロックされているか非表示です
 @msg	the layer to flatten into is hidden	統合先のレイヤーが非表示になっています
 @msg	there are no objects to release	レイヤーに分配するオブジェクトがありません
 @msg	no library `{id}`	ライブラリ `{id}` が見つかりません

crates/ui-egui/src/i18n/ru.tsv

@@ -3755,6 +3755,7 @@ axis	Both	Оба
 @msg	the image's pixels don't match its size	пиксели изображения не соответствуют его размеру
 @msg	the layer has no objects to clip by	в слое нет объектов для обрезки
 @msg	the layer or group is locked	слой или группа заблокированы
+@msg	the target layer is locked or hidden	целевой слой заблокирован или скрыт
 @msg	the layer to flatten into is hidden	слой для объединения скрыт
 @msg	the object already has an opacity mask	у объекта уже есть непрозрачная маска
 @msg	the object has no geometry	у объекта нет геометрии

crates/ui-egui/src/i18n/uk.tsv

@@ -3742,6 +3742,7 @@ axis	Both	Обидві
 @msg	the image's pixels don't match its size	пікселі зображення не відповідають його розміру
 @msg	the layer has no objects to clip by	у шарі немає об’єктів для обрізки
 @msg	the layer or group is locked	шар чи група заблоковані
+@msg	the target layer is locked or hidden	цільовий шар заблокований або прихований
 @msg	the layer to flatten into is hidden	шар для об’єднання прихований
 @msg	the object already has an opacity mask	об’єкт вже має маску непрозорості.
 @msg	the object has no geometry	об’єкт не має геометрії

crates/ui-egui/src/lib.rs

@@ -579,6 +579,16 @@ impl VectorcraftApp {
             return r;
         }
         let mut params = params;
+        // Paste in place, in front, in back (#693) and Select › All on Active Artboard (#1006): onto
+        // or on the active artboard, the view's.
+        if matches!(id, "edit.pasteInPlace" | "edit.pasteInFront" | "edit.pasteInBack" | "select.allOnArtboard")
+            && params.get("artboard").is_none()
+            && self.view().is_some()
+            && let Some(n) = self.session.active().map(|d| d.doc.artboards.len())
+            && let Some(p) = params.as_object_mut()
+        {
+            p.insert("artboard".into(), serde_json::json!(panels::artboards::selected(self, n)));
+        }
         if id.starts_with("edit.paste") {
             if let Err(e) = self.adopt_system_clipboard() {
                 self.ui.status = e.clone();
@@ -592,14 +602,6 @@ impl VectorcraftApp {
             {
                 p.insert("center".into(), serde_json::json!([c.x, c.y]));
             }
-            // In place, in front, in back: onto the active artboard (#693).
-            if matches!(id, "edit.pasteInPlace" | "edit.pasteInFront" | "edit.pasteInBack")
-                && params.get("artboard").is_none()
-                && let Some(i) = self.view().map(|v| v.artboard)
-                && let Some(p) = params.as_object_mut()
-            {
-                p.insert("artboard".into(), serde_json::json!(i));
-            }
             if let Some(r) = dialogs::swatch_conflict::ask(self, id, &params) {
                 return r;
             }

crates/ui-egui/src/panels/artboards.rs

@@ -235,6 +235,26 @@ mod tests {
         crate::menus::invoke(&mut app, "view.goToArtboard", json!({"index": "previous"}));
         assert_eq!(selected(&app, 2), 0, "and the panel follows the navigator");
     }
+
+    /// #1006: Select › All on Active Artboard selects the art of the artboard made active here,
+    /// and an explicit artboard still wins.
+    #[test]
+    fn all_on_active_artboard_takes_the_active_artboard() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 100, "height": 100, "units": "Points", "artboards": 2})).unwrap();
+        let mut rect = |x| app.session.execute("shape.rectangle", &json!({"x": x, "y": 10, "width": 20, "height": 20})).unwrap()["id"].clone();
+        let (a, b) = (rect(10), rect(130));
+        let picked = |app: &mut VectorcraftApp, params| {
+            crate::menus::invoke(app, "select.allOnArtboard", params);
+            let ids: Vec<u64> = app.session.active().unwrap().selection.objects.iter().map(|n| n.0).collect();
+            json!(ids)
+        };
+        select(&mut app, 1);
+        assert_eq!(picked(&mut app, json!({})), json!([b]));
+        select(&mut app, 0);
+        assert_eq!(picked(&mut app, json!({})), json!([a]));
+        assert_eq!(picked(&mut app, json!({"artboard": 1})), json!([b]));
+    }
     /// Double-clicking a row's number goes to its artboard and its name renames it; a row's
     /// Options button edits that artboard with the Artboard tool, and the tool's artboard is the
     /// active one.

docs/control-protocol.md

@@ -56,7 +56,7 @@ the two can still win that race.
 | `ui.set` | `{brightness?, panel?, rulers?, outline?, grid?, smartGuides?, boundingBox?, controlBar?}` | |
 | `ui.dialog.set` / `.confirm` / `.cancel` | `{field, value}` | fill and submit the open dialog |
 | `ui.screenshot` | `{path?, data?}` | capture the window (PNG), written to `path`; `data: true` sends it back as `pngBase64` too. Needs a presented frame: with the screen locked or the window minimized/covered it fails after ~8 s with an explanatory error |
-| `ui.render` | `{path?, scale?, data?}` | render the artboard headlessly (PNG): written to `path`, else (or with `data: true` as well) sent back as `pngBase64` |
+| `ui.render` | `{path?, scale?, artboard?, data?}` | render an artboard headlessly (PNG; `artboard`: its 0-based index, default the first): written to `path`, else (or with `data: true` as well) sent back as `pngBase64` |
 | `ui.resize` / `ui.focus` | | |
 | `app.open` / `app.save` / `app.export` / `app.quit` | `{path}` / `{path?}` / `{path?, format?, artboard?, range?, scale?, …}` | `app.open` reads every format `document.open` reads (see `document.formats`) and returns its result (`{index, title, format, warnings, …}`; `warnings` say what didn't come in as it was, such as an EPS shown as its preview image and why its PostScript couldn't be read), or null when a dialog asks first or a library loads. `app.export` encodes through the engine's `document.export` (same options; the document keeps its path) and writes `path` through the host; without `path` it returns `{dataBase64, format, bytes}`, as headless mode does. `app.quit`, `file.close` and `file.closeAll` first open a `saveChanges` dialog for each modified document (they return `{"pending": "saveChanges"}`): `ui.dialog.confirm` saves, `ui.dialog.set {field: "discard", value: true}` then confirm discards, `ui.dialog.cancel` cancels the whole close or quit |
 | `app.export` with `useArtboards` | `{path, useArtboards: true, range? \| artboards?, …}` | Export As: PNG, JPEG and WebP write one file per chosen artboard (default all; SVG does so for a `range`), `<path stem>-<artboard>.<ext>`, and return `{path, files: [path…]}`; a PDF keeps them as pages of `path`. `useArtboards: false` covers the bounds of the visible art. The menu's Export As… is `file.exportAs`: the `exportAs` dialog (`format`, `useArtboards`, `all`, `range`), then a save dialog and the format's options: `pngOptions` / `jpgOptions` / `webpOptions`, `svgOptions`, or `savePdf` for a PDF with Use Artboards |