Docs: type parity has one status line again

Two branches' status lines both landed in a merge; they are one line
again, naming both changes.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

Cargo.lock

@@ -4813,6 +4813,7 @@ dependencies = [
  "unicode-bidi",
  "unicode-general-category",
  "unicode-script",
+ "unicode-segmentation",
  "vectorcraft-doc",
  "vectorcraft-geom",
  "windows-registry",

README.md

@@ -170,12 +170,13 @@ next one. To pick one when starting the app, set `WGPU_POWER_PREF=high` (or `low
 its name, such as `WGPU_ADAPTER_NAME=nvidia` (see [`docs/development.md`](docs/development.md#desktop-graphics-processor)).
 
 On native Wayland, winit 0.30 does not deliver dropped files. To open an SVG, use File › Open;
-to place artwork in the current document, copy and paste the file in a file manager; or run
-under XWayland (`WAYLAND_DISPLAY= vectorcraft`) for file drag-and-drop
+to place artwork in the current document, copy and paste the file in a file manager. For file
+drag-and-drop, set **Preferences › Performance › Linux Display Server** to **X11 (XWayland)** and restart, or start
+the app with `WAYLAND_DISPLAY= vectorcraft`: the window then opens through XWayland, where drops work
 (see [`docs/development.md`](docs/development.md#linux-wayland-and-x11)).
 
 On Linux under KDE Plasma 6.3 or later with Wayland, a drawing tablet's pen moves the cursor but VectorCraft doesn't
-respond to it yet (#491). Start the app under XWayland instead: `WAYLAND_DISPLAY= vectorcraft` (see
+respond to it yet (#491). Open the window through XWayland instead, with the same preference or `WAYLAND_DISPLAY= vectorcraft` (see
 [`docs/development.md`](docs/development.md#linux-wayland-and-x11)).
 
 ### Use it from Claude Code and other agents

ROADMAP.md

@@ -127,7 +127,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). 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). A polar grid with no radial dividers draws none (#1008). Use Precise Cursors also covers the Pen's join pointer (#1009). SVGs with one absolute and one unitless root side import at their size, unstretched (#1010). DXF US survey inches, yards and miles open at their size and name (#1011). A file placed into a document with no other links follows its first change even while the app sits idle (#1031). PDF import keeps the style a font name says when the file doesn't embed the font (#1023). Shift selects ruler guides and art together, and Delete removes both (#1022). Open filled paths are hit by their fill on every side, the rotate cursor bows around the corner it is at, the flip icons match their flips, the Color Picker previews on the selection, and Properties › Transform reaches Scale Corners and Scale Strokes & Effects (#1036). Offset Path and the other booleans finish on outlines where the sweep used to loop until memory ran out (linesweeper 0.5, #1028). Floating panel groups stack into sets that move together, collapse to their tabs and dock as extra dock columns that scroll (#1020). Ruler guides live on layers: listed in the Layers panel, shown, hidden, locked, duplicated, merged and deleted with their layer, and moved between layers (#1021). A `.ai` whose editing data uses global process colours (`Xk`/`XK`) or pattern fills keeps its sublayers: the colours come in as global swatches at their tint, the patterns as pattern swatches (#1025). A `.ai` in PostScript form opens through its layers, read from the program itself, also when it names the prolog defining its operators without including it, as Rhino and other CAD apps write it (#1027). A fill or stroke chosen while the Type tool has characters selected colours just those characters (#1063). Scaled type shows its scaled font size, leading, baseline shift and horizontal scale in the Character panel, and a size typed there is the size you get (#1034). Character panel menu › Proportional Metrics sets Japanese and Chinese full-width glyphs on the font's proportional widths in horizontal type (#966). Align, Distribute, Move, Arrange, Lock, Hide, Ungroup and other Object commands that would change nothing no longer record an undo step or mark the document changed (#1060). Spot colours defined in Lab open with their Lab values from `.ai` and PDF files, instead of as wrong RGB colours or their CMYK equivalents (#1032). Build scripts leave a generated source they wouldn't change untouched, so the next build doesn't compile most of the workspace again where file times lose their sub-second part (#1051). A fill colour recolours the gradient mesh point last clicked with the Mesh tool or Direct Selection, and a Mesh tool click on a mesh's point selects that mesh (#1052). The All Tools drawer stays two tools wide instead of filling a wide window (#1054). Text Wrap's Make, Release and Options refuse a list of object ids with a malformed or unknown id instead of skipping it (#1055). A freeform gradient line with a malformed point index is refused instead of being shortened to the indices that are valid (#1056). The Corners dialog (`ui.corners`) refuses a malformed object id or a listed anchor that isn't a corner instead of editing the selection or the other corners (#1057). New View refuses a centre that isn't exactly [x, y] and a rotation that isn't a number, instead of trimming the one and saving the other as 0° (#1058). The command sweeps try junk scale, spacing and artboard values too, which they had skipped since before those bugs were fixed (#1059). EPS and PostScript `arc` and `arcn` with huge angles no longer hang the import, and an arc whose angles are whole turns apart is empty, as the PostScript reference defines it (#1062). Align and DisLine truncated
+| 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). A polar grid with no radial dividers draws none (#1008). Use Precise Cursors also covers the Pen's join pointer (#1009). SVGs with one absolute and one unitless root side import at their size, unstretched (#1010). DXF US survey inches, yards and miles open at their size and name (#1011). A file placed into a document with no other links follows its first change even while the app sits idle (#1031). PDF import keeps the style a font name says when the file doesn't embed the font (#1023). Shift selects ruler guides and art together, and Delete removes both (#1022). Open filled paths are hit by their fill on every side, the rotate cursor bows around the corner it is at, the flip icons match their flips, the Color Picker previews on the selection, and Properties › Transform reaches Scale Corners and Scale Strokes & Effects (#1036). Offset Path and the other booleans finish on outlines where the sweep used to loop until memory ran out (linesweeper 0.5, #1028). Floating panel groups stack into sets that move together, collapse to their tabs and dock as extra dock columns that scroll (#1020). Ruler guides live on layers: listed in the Layers panel, shown, hidden, locked, duplicated, merged and deleted with their layer, and moved between layers (#1021). A `.ai` whose editing data uses global process colours (`Xk`/`XK`) or pattern fills keeps its sublayers: the colours come in as global swatches at their tint, the patterns as pattern swatches (#1025). A `.ai` in PostScript form opens through its layers, read from the program itself, also when it names the prolog defining its operators without including it, as Rhino and other CAD apps write it (#1027). A fill or stroke chosen while the Type tool has characters selected colours just those characters (#1063). Scaled type shows its scaled font size, leading, baseline shift and horizontal scale in the Character panel, and a size typed there is the size you get (#1034). Character panel menu › Proportional Metrics sets Japanese and Chinese full-width glyphs on the font's proportional widths in horizontal type (#966). Align, Distribute, Move, Arrange, Lock, Hide, Ungroup and other Object commands that would change nothing no longer record an undo step or mark the document changed (#1060). Spot colours defined in Lab open with their Lab values from `.ai` and PDF files, instead of as wrong RGB colours or their CMYK equivalents (#1032). Build scripts leave a generated source they wouldn't change untouched, so the next build doesn't compile most of the workspace again where file times lose their sub-second part (#1051). A fill colour recolours the gradient mesh point last clicked with the Mesh tool or Direct Selection, and a Mesh tool click on a mesh's point selects that mesh (#1052). The All Tools drawer stays two tools wide instead of filling a wide window (#1054). Text Wrap's Make, Release and Options refuse a list of object ids with a malformed or unknown id instead of skipping it (#1055). A freeform gradient line with a malformed point index is refused instead of being shortened to the indices that are valid (#1056). The Corners dialog (`ui.corners`) refuses a malformed object id or a listed anchor that isn't a corner instead of editing the selection or the other corners (#1057). New View refuses a centre that isn't exactly [x, y] and a rotation that isn't a number, instead of trimming the one and saving the other as 0° (#1058). The command sweeps try junk scale, spacing and artboard values too, which they had skipped since before those bugs were fixed (#1059). EPS and PostScript `arc` and `arcn` with huge angles no longer hang the import, and an arc whose angles are whole turns apart is empty, as the PostScript reference defines it (#1062). Align and DisLine truncated
 | 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/tests/cli.rs

@@ -94,6 +94,15 @@ fn mcp_automation_roots() {
     let svg = r#"<svg xmlns="http://www.w3.org/2000/svg" width="40" height="30"><rect width="20" height="10"/></svg>"#;
     std::fs::write(base.join("in/a.svg"), svg).unwrap();
     std::fs::write(base.join("outside/b.svg"), svg).unwrap();
+    std::fs::write(base.join("outside/victim.png"), b"keep this file").unwrap();
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::symlink;
+        symlink(base.join("outside/b.svg"), base.join("in/escape.svg")).unwrap();
+        symlink(base.join("outside"), base.join("out/escape")).unwrap();
+        symlink(base.join("outside/victim.png"), base.join("out/victim.png")).unwrap();
+        symlink(base.join("outside/missing.png"), base.join("out/dangling.png")).unwrap();
+    }
     let dir = |d: &str| base.join(d).to_string_lossy().into_owned();
     let fails = |args: &[&str], why: &str| {
         let out = Command::new(BIN).args(args).stdin(Stdio::null()).output().unwrap();
@@ -114,15 +123,32 @@ fn mcp_automation_roots() {
         .unwrap();
     let call = |id: u64, name: &str, args: Value| json!({"jsonrpc":"2.0","id":id,"method":"tools/call","params":{"name":name,"arguments":args}});
     let file = |d: &str, f: &str| base.join(d).join(f).to_string_lossy().into_owned();
+    let mut calls = vec![
+        call(1, "open_file", json!({"path": file("in", "a.svg")})),
+        call(2, "open_file", json!({"path": file("outside", "b.svg")})),
+        call(3, "export", json!({"path": file("out", "a.png")})),
+        call(4, "export", json!({"path": file("in", "a.png")})),
+        call(5, "save_file", json!({"path": file("outside", "a.vectorcraft")})),
+        call(6, "open_file", json!({"path": file("in", "../outside/b.svg")})),
+        call(7, "export", json!({"path": file("out", "../outside/traversal.png")})),
+    ];
+    let mut expected_errors = vec![false, true, false, true, true, true, true];
+    #[cfg(unix)]
+    {
+        calls.extend([
+            call(8, "open_file", json!({"path": file("in", "escape.svg")})),
+            call(9, "export", json!({"path": file("out", "escape/escaped.png")})),
+            call(10, "export", json!({"path": file("out", "victim.png")})),
+            call(11, "export", json!({"path": file("out", "dangling.png")})),
+        ]);
+        expected_errors.extend([true; 4]);
+    }
+    // An access error is per request: the server continues and can still save inside its root.
+    calls.push(call(12, "save_file", json!({"path": file("out", "allowed.vectorcraft")})));
+    expected_errors.push(false);
     {
         let mut stdin = child.stdin.take().unwrap();
-        for m in [
-            call(1, "open_file", json!({"path": file("in", "a.svg")})),
-            call(2, "open_file", json!({"path": file("outside", "b.svg")})),
-            call(3, "export", json!({"path": file("out", "a.png")})),
-            call(4, "export", json!({"path": file("in", "a.png")})),
-            call(5, "save_file", json!({"path": file("outside", "a.vectorcraft")})),
-        ] {
+        for m in calls {
             writeln!(stdin, "{m}").unwrap();
         }
     }
@@ -130,9 +156,14 @@ fn mcp_automation_roots() {
     assert!(out.status.success());
     let replies: Vec<Value> = String::from_utf8(out.stdout).unwrap().lines().map(|l| serde_json::from_str(l).unwrap()).collect();
     let errors: Vec<bool> = replies.iter().map(|r| r["result"]["isError"] == true).collect();
-    assert_eq!(errors, [false, true, false, true, true], "{replies:?}");
+    assert_eq!(errors, expected_errors, "{replies:?}");
     assert!(replies[1]["result"]["content"][0]["text"].as_str().unwrap().contains("outside the read root"));
     assert!(base.join("out/a.png").is_file() && !base.join("in/a.png").exists() && !base.join("outside/a.vectorcraft").exists());
+    assert!(base.join("out/allowed.vectorcraft").is_file());
+    for denied in ["traversal.png", "escaped.png", "missing.png"] {
+        assert!(!base.join("outside").join(denied).exists(), "{denied}");
+    }
+    assert_eq!(std::fs::read(base.join("outside/victim.png")).unwrap(), b"keep this file");
 }
 
 /// End-to-end protocol sweep over stdio against the compiled binary. The in-process

apps/vectorcraft/src/automation_args.rs

@@ -0,0 +1,90 @@
+//! Parse automation roots before starting any desktop services. A malformed flag must not
+//! silently remove a root and leave the control channel unconfined.
+
+use std::path::PathBuf;
+
+pub struct AutomationArgs {
+    pub read_root: Option<PathBuf>,
+    pub write_root: Option<PathBuf>,
+    read_given: bool,
+    write_given: bool,
+}
+
+impl AutomationArgs {
+    pub fn new(read_root: Option<PathBuf>, write_root: Option<PathBuf>) -> Self {
+        Self { read_root, write_root, read_given: false, write_given: false }
+    }
+
+    /// Returns whether this argument is a root flag. CLI values override environment defaults
+    /// once; a second occurrence is an error, including when the two spellings are mixed.
+    pub fn consume(&mut self, arg: &str, args: &mut impl Iterator<Item = String>) -> Result<bool, String> {
+        let (flag, inline) = arg.split_once('=').map_or((arg, None), |(flag, value)| (flag, Some(value)));
+        let (root, given) = match flag {
+            "--automation-read-root" => (&mut self.read_root, &mut self.read_given),
+            "--automation-write-root" => (&mut self.write_root, &mut self.write_given),
+            _ => return Ok(false),
+        };
+        if *given {
+            return Err(format!("{flag} given twice"));
+        }
+        let value = match inline {
+            Some(value) => value.to_owned(),
+            None => {
+                let value = args.next().ok_or_else(|| format!("{flag} needs a folder"))?;
+                if value.starts_with('-') {
+                    return Err(format!("{flag} needs a folder; use {flag}=<dir> for a folder starting with '-'"));
+                }
+                value
+            }
+        };
+        if value.is_empty() {
+            return Err(format!("{flag} needs a non-empty folder"));
+        }
+        *root = Some(value.into());
+        *given = true;
+        Ok(true)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn roots_override_environment_once_and_leave_other_arguments() {
+        let mut roots = AutomationArgs::new(Some("environment".into()), None);
+        let mut args = ["a folder".to_owned(), "drawing.svg".to_owned()].into_iter();
+        assert!(roots.consume("--automation-read-root", &mut args).unwrap());
+        assert!(roots.consume("--automation-write-root=out", &mut args).unwrap());
+        assert!(!roots.consume("--in-window-menus", &mut args).unwrap());
+        assert_eq!(roots.read_root, Some("a folder".into()));
+        assert_eq!(roots.write_root, Some("out".into()));
+        assert_eq!(args.next().as_deref(), Some("drawing.svg"));
+        assert!(roots.consume("--automation-read-root=other", &mut args).is_err());
+        assert_eq!(roots.read_root, Some("a folder".into()));
+    }
+
+    #[test]
+    fn invalid_operands_preserve_environment_roots() {
+        for flag in ["--automation-read-root", "--automation-write-root"] {
+            for operand in [None, Some(""), Some("--version"), Some("--control"), Some("-folder")] {
+                let mut roots = AutomationArgs::new(Some("read".into()), Some("write".into()));
+                let mut args = operand.map(str::to_owned).into_iter();
+                assert!(roots.consume(flag, &mut args).is_err(), "{flag} {operand:?}");
+                assert_eq!(roots.read_root, Some("read".into()));
+                assert_eq!(roots.write_root, Some("write".into()));
+            }
+            let mut roots = AutomationArgs::new(None, None);
+            assert!(roots.consume(&format!("{flag}="), &mut std::iter::empty()).is_err());
+        }
+    }
+
+    #[test]
+    fn explicit_dash_folder_and_relative_dash_folder_are_valid() {
+        let mut roots = AutomationArgs::new(None, None);
+        assert!(roots.consume("--automation-read-root=-folder", &mut std::iter::empty()).unwrap());
+        assert!(roots.consume("--automation-write-root", &mut ["./-folder".to_owned()].into_iter()).unwrap());
+        assert_eq!(roots.read_root, Some("-folder".into()));
+        assert_eq!(roots.write_root, Some("./-folder".into()));
+    }
+}

apps/vectorcraft/src/main.rs

@@ -21,6 +21,7 @@ compile_error!("windows7 requires --target x86_64-win7-windows-msvc; the ordinar
 #[cfg(all(target_vendor = "win7", not(feature = "windows7")))]
 compile_error!("the win7 target requires --no-default-features --features windows7");
 
+mod automation_args;
 mod clipboard;
 mod control_server;
 #[cfg(feature = "wgpu")]
@@ -39,6 +40,7 @@ mod printing;
 #[cfg(all(windows, not(target_vendor = "win7")))]
 mod system_fonts;
 mod window;
+mod xwayland;
 
 use vectorcraft_engine::Session;
 use vectorcraft_engine::cmd::fileio;
@@ -585,7 +587,36 @@ fn native_options(custom_titlebar: bool) -> eframe::NativeOptions {
 }
 
 fn main() -> std::process::ExitCode {
-    // First, so every start-up warning is recorded (`logging`).
+    // Validate roots before logging, font scans, preferences or the window: a missing value
+    // must not clear an environment root and start the control channel without confinement.
+    let mut control_port: Option<u16> = std::env::var("VECTORCRAFT_CONTROL_PORT").ok().and_then(|p| p.parse().ok());
+    let root_env = |name: &str| std::env::var_os(name).filter(|v| !v.is_empty()).map(std::path::PathBuf::from);
+    let mut roots_args =
+        automation_args::AutomationArgs::new(root_env("VECTORCRAFT_AUTOMATION_READ_ROOT"), root_env("VECTORCRAFT_AUTOMATION_WRITE_ROOT"));
+    let mut files = Vec::new();
+    let mut in_window_menus = std::env::var_os("VECTORCRAFT_IN_WINDOW_MENUS").is_some_and(|v| !v.is_empty() && v != "0");
+    let mut args = std::env::args().skip(1);
+    while let Some(a) = args.next() {
+        match roots_args.consume(&a, &mut args) {
+            Ok(true) => continue,
+            Ok(false) => {}
+            Err(e) => {
+                eprintln!("vectorcraft: {e}");
+                return std::process::ExitCode::FAILURE;
+            }
+        }
+        match a.as_str() {
+            "--control" => control_port = args.next().and_then(|p| p.parse().ok()),
+            "--in-window-menus" => in_window_menus = true,
+            "--version" => {
+                println!("vectorcraft {}", env!("CARGO_PKG_VERSION"));
+                return std::process::ExitCode::SUCCESS;
+            }
+            _ => files.push(a),
+        }
+    }
+    let automation_args::AutomationArgs { read_root, write_root, .. } = roots_args;
+    // Before desktop services, so every start-up warning is recorded (`logging`).
     let logger = logging::install();
     vectorcraft_ui_egui::i18n::detect_system_lang_in_background();
     // Before the first font scan (the app's start): the fonts font services load (#579).
@@ -595,28 +626,6 @@ fn main() -> std::process::ExitCode {
     mac_fonts::install();
     // VectorCraft's own Fonts folder, which text.addFontFiles copies fonts into.
     prefs_dir::install_fonts();
-    let mut control_port: Option<u16> = std::env::var("VECTORCRAFT_CONTROL_PORT").ok().and_then(|p| p.parse().ok());
-    let root_env = |name: &str| std::env::var_os(name).filter(|v| !v.is_empty()).map(std::path::PathBuf::from);
-    let mut read_root = root_env("VECTORCRAFT_AUTOMATION_READ_ROOT");
-    let mut write_root = root_env("VECTORCRAFT_AUTOMATION_WRITE_ROOT");
-    let mut files = Vec::new();
-    let mut in_window_menus = std::env::var_os("VECTORCRAFT_IN_WINDOW_MENUS").is_some_and(|v| !v.is_empty() && v != "0");
-    let mut args = std::env::args().skip(1);
-    while let Some(a) = args.next() {
-        match a.as_str() {
-            "--control" => control_port = args.next().and_then(|p| p.parse().ok()),
-            "--automation-read-root" => read_root = args.next().map(std::path::PathBuf::from),
-            "--automation-write-root" => write_root = args.next().map(std::path::PathBuf::from),
-            _ if a.starts_with("--automation-read-root=") => read_root = a.split_once('=').map(|(_, d)| d.into()),
-            _ if a.starts_with("--automation-write-root=") => write_root = a.split_once('=').map(|(_, d)| d.into()),
-            "--in-window-menus" => in_window_menus = true,
-            "--version" => {
-                println!("vectorcraft {}", env!("CARGO_PKG_VERSION"));
-                return std::process::ExitCode::SUCCESS;
-            }
-            _ => files.push(a),
-        }
-    }
     // The log file lives in the settings directory, next to the preferences; opened after the
     // arguments, so `--version` leaves no file behind. Records logged until now are written to it
     // first. Runs without preferences (agents' test runs) log to standard error only, so they
@@ -674,6 +683,25 @@ fn main() -> std::process::ExitCode {
     let startup = std::sync::Arc::new(gpu::Startup::default());
     let custom_titlebar = custom_titlebar(saved.as_ref());
     let options = native_options(custom_titlebar);
+    // winit picks Wayland whenever `WAYLAND_DISPLAY` is set; Preferences › Performance › Linux
+    // Display Server › X11 opens the window through XWayland instead, where file drops work (#1151).
+    #[cfg(target_os = "linux")]
+    let options = {
+        let mut options = options;
+        let pref = saved.as_ref().and_then(|ui| ui.engine_prefs.get("linuxDisplayServer")).and_then(serde_json::Value::as_str);
+        if xwayland::wanted(pref, |name| std::env::var_os(name)) {
+            if xwayland::x11_libraries_found() {
+                log::info!("opening the window through XWayland (Preferences › Performance › Linux Display Server)");
+                use winit::platform::x11::EventLoopBuilderExtX11 as _;
+                options.event_loop_builder = Some(Box::new(|builder| {
+                    builder.with_x11();
+                }));
+            } else {
+                log::warn!("Linux Display Server is X11, but the X11 libraries aren't all installed: opening the window on Wayland");
+            }
+        }
+        options
+    };
     #[cfg(feature = "wgpu")]
     let options = {
         let mut options = options;

apps/vectorcraft/src/xwayland.rs

@@ -0,0 +1,127 @@
+//! Linux: Preferences › Performance › Linux Display Server › X11 opens the window through XWayland
+//! on a Wayland session, where dropped files arrive (winit 0.30 has no Wayland drag and drop,
+//! #1151). Only when XWayland can run the window: an X display is set and the X11 libraries winit
+//! loads at runtime are installed. Otherwise the window opens on Wayland, so a missing library
+//! never keeps the app from starting.
+//!
+//! The library check comes from PhotoCraft's `linux_libs.rs`: no `dlopen` (that needs `unsafe`),
+//! just the dynamic linker's cache (`ldconfig -p`) and the usual library directories.
+#![cfg_attr(not(target_os = "linux"), allow(dead_code))]
+
+use std::ffi::OsString;
+use std::path::{Path, PathBuf};
+
+/// What winit 0.30 `dlopen`s for an X11 window: x11-dl opens Xlib, Xlib-xcb, Xcursor and XInput2,
+/// x11rb opens libxcb, and xkbcommon-dl opens xkbcommon and xkbcommon-x11.
+const X11_LIBS: &[&str] =
+    &["libX11.so.6", "libX11-xcb.so.1", "libxcb.so.1", "libXcursor.so.1", "libXi.so.6", "libxkbcommon.so.0", "libxkbcommon-x11.so.0"];
+
+/// Whether the saved `linuxDisplayServer` and the environment ask for XWayland: `x11` chosen, a
+/// Wayland session (winit picks Wayland whenever `WAYLAND_DISPLAY` or `WAYLAND_SOCKET` is set)
+/// and an X display to open.
+pub fn wanted(pref: Option<&str>, var: impl Fn(&str) -> Option<OsString>) -> bool {
+    let set = |name: &str| var(name).is_some_and(|v| !v.is_empty());
+    pref == Some("x11") && (set("WAYLAND_DISPLAY") || set("WAYLAND_SOCKET")) && set("DISPLAY")
+}
+
+/// Are all the libraries an X11 window needs found on this system? Libraries the check can't find
+/// count as missing.
+pub fn x11_libraries_found() -> bool {
+    let cache = read_ldconfig();
+    let dirs = search_dirs(std::env::var("LD_LIBRARY_PATH").ok().as_deref());
+    X11_LIBS
+        .iter()
+        .all(|lib| cache.as_deref().is_some_and(|out| ldconfig_has(out, lib, ldconfig_arch_tag())) || dirs.iter().any(|d| d.join(lib).exists()))
+}
+
+/// The `ldconfig -p` architecture tag for this build, when it's one we can tell apart from a
+/// 32-bit library of the same name (`libc6,x86-64` vs plain `libc6` for i386).
+fn ldconfig_arch_tag() -> Option<&'static str> {
+    if cfg!(target_arch = "x86_64") {
+        Some("x86-64")
+    } else if cfg!(target_arch = "aarch64") {
+        Some("AArch64")
+    } else {
+        None
+    }
+}
+
+/// Does `ldconfig -p` output list `soname` for our architecture? Lines look like
+/// `\tlibxkbcommon-x11.so.0 (libc6,x86-64) => /lib/x86_64-linux-gnu/libxkbcommon-x11.so.0`.
+fn ldconfig_has(output: &str, soname: &str, arch_tag: Option<&str>) -> bool {
+    output.lines().any(|line| {
+        let Some((name, rest)) = line.trim_start().split_once(' ') else { return false };
+        if name != soname {
+            return false;
+        }
+        match arch_tag {
+            None => true,
+            Some(tag) => {
+                let flags = rest.split_once('(').and_then(|(_, r)| r.split_once(')')).map_or("", |(f, _)| f);
+                flags.split(',').any(|f| f.trim() == tag)
+            }
+        }
+    })
+}
+
+/// `ldconfig -p`, from the usual locations (`/sbin` isn't on a normal user's PATH on Debian). A
+/// real listing starts with "N libs found in cache".
+fn read_ldconfig() -> Option<String> {
+    ["/sbin/ldconfig", "/usr/sbin/ldconfig", "ldconfig"].into_iter().find_map(|cmd| {
+        let out = std::process::Command::new(cmd).arg("-p").output().ok().filter(|out| out.status.success())?;
+        let text = String::from_utf8_lossy(&out.stdout).into_owned();
+        text.lines().next().is_some_and(|l| l.contains("libs found in cache")).then_some(text)
+    })
+}
+
+/// Library directories to search: `LD_LIBRARY_PATH`, then the usual system and Flatpak paths.
+fn search_dirs(ld_library_path: Option<&str>) -> Vec<PathBuf> {
+    let mut dirs: Vec<PathBuf> = ld_library_path.unwrap_or("").split(':').filter(|d| !d.is_empty()).map(PathBuf::from).collect();
+    let triplet = if cfg!(target_arch = "aarch64") {
+        "aarch64-linux-gnu"
+    } else if cfg!(target_arch = "riscv64") {
+        "riscv64-linux-gnu"
+    } else {
+        "x86_64-linux-gnu"
+    };
+    dirs.extend(["/app/lib", "/usr/local/lib", "/usr/lib64", "/lib64", "/usr/lib", "/lib"].map(PathBuf::from));
+    dirs.push(Path::new("/usr/lib").join(triplet));
+    dirs.push(Path::new("/lib").join(triplet));
+    dirs
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn env(pairs: &'static [(&'static str, &'static str)]) -> impl Fn(&str) -> Option<OsString> {
+        move |k| pairs.iter().find(|(name, _)| *name == k).map(|(_, v)| OsString::from(v))
+    }
+
+    #[test]
+    fn xwayland_only_when_chosen_on_wayland_with_an_x_display() {
+        let wayland = env(&[("WAYLAND_DISPLAY", "wayland-0"), ("DISPLAY", ":0")]);
+        assert!(wanted(Some("x11"), &wayland));
+        assert!(wanted(Some("x11"), env(&[("WAYLAND_SOCKET", "3"), ("DISPLAY", ":0")])));
+        assert!(!wanted(Some("automatic"), &wayland));
+        assert!(!wanted(None, &wayland));
+        assert!(!wanted(Some("wayland"), &wayland));
+        // An X11 session already opens on X11; without an X display there is no XWayland to use.
+        assert!(!wanted(Some("x11"), env(&[("DISPLAY", ":0")])));
+        assert!(!wanted(Some("x11"), env(&[("WAYLAND_DISPLAY", "wayland-0"), ("DISPLAY", "")])));
+        assert!(!wanted(Some("x11"), env(&[("WAYLAND_DISPLAY", "wayland-0")])));
+    }
+
+    #[test]
+    fn ldconfig_parsing_matches_name_and_architecture() {
+        let cache = "12 libs found in cache `/etc/ld.so.cache'\n\
+            \tlibX11.so.6 (libc6,x86-64) => /lib/x86_64-linux-gnu/libX11.so.6\n\
+            \tlibxkbcommon-x11.so.0 (libc6) => /lib/i386-linux-gnu/libxkbcommon-x11.so.0\n";
+        assert!(ldconfig_has(cache, "libX11.so.6", Some("x86-64")));
+        assert!(!ldconfig_has(cache, "libX11.so.6", Some("AArch64")));
+        // Only the 32-bit build is installed: doesn't count for a 64-bit app.
+        assert!(!ldconfig_has(cache, "libxkbcommon-x11.so.0", Some("x86-64")));
+        assert!(ldconfig_has(cache, "libxkbcommon-x11.so.0", None));
+        assert!(!ldconfig_has(cache, "libX11.so", None));
+    }
+}

apps/vectorcraft/tests/automation_args.rs

@@ -0,0 +1,70 @@
+// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness).
+#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+
+use std::process::{Command, Stdio};
+use std::time::{Duration, Instant};
+
+const BIN: &str = env!("CARGO_BIN_EXE_vectorcraft");
+
+/// Invalid roots must exit before desktop initialization on every platform, including a CI
+/// machine with no display. A regression must fail rather than hang with a window open.
+fn rejects(args: &[&str], message: &str) {
+    let mut child = Command::new(BIN)
+        .args(args)
+        .env_remove("VECTORCRAFT_CONTROL_PORT")
+        .env_remove("VECTORCRAFT_AUTOMATION_READ_ROOT")
+        .env_remove("VECTORCRAFT_AUTOMATION_WRITE_ROOT")
+        .env("VECTORCRAFT_NO_PREFS", "1")
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+    let deadline = Instant::now() + Duration::from_secs(5);
+    let timed_out = loop {
+        if child.try_wait().unwrap().is_some() {
+            break false;
+        }
+        if Instant::now() >= deadline {
+            child.kill().unwrap();
+            break true;
+        }
+        std::thread::sleep(Duration::from_millis(10));
+    };
+    let out = child.wait_with_output().unwrap();
+    assert!(!timed_out, "{args:?}: desktop started or did not exit promptly");
+    assert!(!out.status.success(), "{args:?}");
+    assert!(out.stdout.is_empty(), "{args:?}: {:?}", out.stdout);
+    // Exact stderr excludes unrelated startup warnings or display errors that could otherwise
+    // make a malformed invocation fail for an unrelated reason.
+    assert_eq!(String::from_utf8(out.stderr).unwrap(), format!("vectorcraft: {message}\n"), "{args:?}");
+}
+
+#[test]
+fn missing_empty_or_option_operands_fail_before_startup() {
+    for flag in ["--automation-read-root", "--automation-write-root"] {
+        rejects(&["--control", "7979", flag], &format!("{flag} needs a folder"));
+        rejects(&[flag], &format!("{flag} needs a folder"));
+        rejects(&["--control", "7979", &format!("{flag}=")], &format!("{flag} needs a non-empty folder"));
+        rejects(&[flag, ""], &format!("{flag} needs a non-empty folder"));
+        for next in ["--version", "--control", "--automation-write-root", "-folder"] {
+            rejects(&[flag, next], &format!("{flag} needs a folder; use {flag}=<dir> for a folder starting with '-'"));
+        }
+    }
+}
+
+#[test]
+fn duplicate_roots_fail_for_both_spellings() {
+    for flag in ["--automation-read-root", "--automation-write-root"] {
+        rejects(&[flag, ".", &format!("{flag}=.")], &format!("{flag} given twice"));
+        rejects(&[&format!("{flag}=."), flag, "."], &format!("{flag} given twice"));
+    }
+}
+
+#[test]
+fn explicit_dash_folder_does_not_consume_version() {
+    let out = Command::new(BIN).args(["--automation-read-root=-folder", "--automation-write-root", "./-folder", "--version"]).output().unwrap();
+    assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
+    assert_eq!(String::from_utf8(out.stdout).unwrap(), format!("vectorcraft {}\n", env!("CARGO_PKG_VERSION")));
+    assert!(out.stderr.is_empty());
+}

crates/doc/src/hit.rs

@@ -375,6 +375,20 @@ mod tests {
         assert!(hit_test(&d, Point::new(50.5, 25.0), HitOptions::default()).is_some());
     }
 
+    /// #1103: a marquee drawn over a background picks what is on it, not the background, whose
+    /// outline it doesn't touch.
+    #[test]
+    fn a_marquee_inside_a_background_leaves_the_background() {
+        let mut d = Document::new(200.0, 200.0);
+        let l = d.layers[0].id;
+        let (back, small) = (d.alloc_id(), d.alloc_id());
+        d.insert(Some(l), 0, Node::path(back, shapes::rectangle(Rect::new(0.0, 0.0, 200.0, 200.0)), Appearance::default_art())).unwrap();
+        d.insert(Some(l), 1, Node::path(small, shapes::rectangle(Rect::new(50.0, 50.0, 60.0, 60.0)), Appearance::default_art())).unwrap();
+        assert_eq!(marquee(&d, Rect::new(40.0, 40.0, 70.0, 70.0), None, false), vec![small]);
+        // Reaching the background's edge takes it too.
+        assert_eq!(marquee(&d, Rect::new(-5.0, 40.0, 70.0, 70.0), None, false), vec![back, small]);
+    }
+
     #[test]
     fn group_top_object() {
         let mut d = Document::new(200.0, 200.0);

crates/engine/src/cmd/draw2.rs

@@ -825,20 +825,9 @@ fn reshape_segment(s: &mut Session, p: &Value) -> Result<Value> {
     s.edit("Reshape", |d, _| {
         let path = path_mut(d, id)?;
         let sp = path.subpaths.get_mut(si).ok_or_else(|| EngineError::Other("no such subpath".into()))?;
-        if seg >= sp.segment_count() {
+        if !sp.bend_segment(seg, t, dv) {
             return Err(EngineError::Other("no such segment".into()));
         }
-        let n = sp.anchors.len();
-        // Moving both inner control points by v moves B(t) by 3t(1-t)·v. A smooth anchor stays
-        // smooth: its other handle turns with the moved one.
-        let v = dv / (3.0 * t * (1.0 - t));
-        let (i0, i1) = (seg % n, (seg + 1) % n);
-        if let Some(a) = sp.anchors.get_mut(i0) {
-            a.set_handle(true, a.h_out + v, false);
-        }
-        if let Some(b) = sp.anchors.get_mut(i1) {
-            b.set_handle(false, b.h_in + v, false);
-        }
         Ok(())
     })?;
     ok()

crates/engine/src/cmd/edit.rs

@@ -39,6 +39,24 @@ pub fn specs() -> Vec<CommandSpec> {
         ),
         cmd!("edit.undo", "Undo", ["Edit"], Some("Cmd+Z"), "{}", can_undo, undo),
         cmd!("edit.redo", "Redo", ["Edit"], Some("Cmd+Shift+Z"), "{}", can_redo, redo),
+        cmd!(
+            "edit.undoGroup.begin",
+            "Begin Undo Group",
+            [],
+            None,
+            "{label?: string} until edit.undoGroup.end, the edits made in the active document are one undo step, named `label` (else after its first edit): for automation, such as MCP command_batch with `atomic` (#1163)",
+            has_doc,
+            undo_group_begin
+        ),
+        cmd!(
+            "edit.undoGroup.end",
+            "End Undo Group",
+            [],
+            None,
+            "{cancel?: bool} close the undo group: its edits stay one undo step or, with `cancel`, are undone",
+            has_doc,
+            undo_group_end
+        ),
         cmd!("edit.cut", "Cut", ["Edit"], Some("Cmd+X"), "{} (the Artboard tool chosen: artboard.cut)", has_selection_or_artboard_tool, cut),
         cmd!("edit.copy", "Copy", ["Edit"], Some("Cmd+C"), "{} (the Artboard tool chosen: artboard.copy)", has_selection_or_artboard_tool, copy),
         cmd!(
@@ -167,6 +185,22 @@ pub(crate) fn typing_in_progress(s: &Session) -> bool {
     s.active().and_then(|d| d.interaction.as_ref()).is_some_and(|it| it.label == "Typing" && it.preview.is_some())
 }
 
+fn undo_group_begin(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "edit.undoGroup.begin";
+    let label = match p.get("label") {
+        None | Some(Value::Null) => None,
+        Some(Value::String(l)) if !l.trim().is_empty() && l.chars().count() <= 200 => Some(l.trim().to_string()),
+        Some(_) => return Err(bad(C, "`label` must be a non-empty name of at most 200 characters")),
+    };
+    s.begin_named_undo_group(label);
+    ok()
+}
+
+fn undo_group_end(s: &mut Session, p: &Value) -> Result<Value> {
+    s.end_undo_group(bool_or(p, "cancel", false));
+    ok()
+}
+
 fn undo(s: &mut Session, _: &Value) -> Result<Value> {
     // What is still in progress (typing, a drag) is the step to undo: keep it first, so Undo takes
     // back only that and Redo brings it back, instead of dropping it and undoing the step before.

crates/engine/src/cmd/fileio/mod.rs

@@ -87,6 +87,15 @@ pub fn specs() -> Vec<CommandSpec> {
             always,
             load::open
         ),
+        cmd!(
+            query "file.list",
+            "List Folder",
+            [],
+            None,
+            "{path} the files and folders in folder `path`, by name: what an agent may open there (held to the automation read root when one is in force) → {path, entries: [{name, kind: file|folder|link, size? (files, bytes)}], truncated (more than 5000 entries)} (#1163)",
+            always,
+            file_list
+        ),
         cmd!(
             query "document.serialize",
             "Serialize Document",
@@ -783,6 +792,48 @@ pub(crate) fn write_new_file(path: &str, bytes: &[u8]) -> Result<()> {
     })
 }
 
+/// The most entries `file.list` returns.
+const LIST_MAX: usize = 5000;
+
+fn file_list(_: &mut Session, p: &Value) -> Result<Value> {
+    let path = p.get("path").and_then(Value::as_str).filter(|s| !s.is_empty()).ok_or_else(|| bad("file.list", "missing `path`"))?;
+    let (entries, truncated) = list_dir(path, LIST_MAX)?;
+    Ok(json!({ "path": absolute_path(path), "entries": entries, "truncated": truncated }))
+}
+
+/// The entries of folder `path`, sorted by name: at most `max`, and whether there were more. A
+/// link isn't followed: its target may lie outside the automation roots.
+#[cfg(not(target_arch = "wasm32"))]
+fn list_dir(path: &str, max: usize) -> Result<(Vec<Value>, bool)> {
+    may_read(path)?;
+    let dir = std::fs::read_dir(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
+    let mut entries: Vec<(String, Value)> = vec![];
+    let mut truncated = false;
+    for e in dir.flatten() {
+        if entries.len() == max {
+            truncated = true;
+            break;
+        }
+        let name = e.file_name().to_string_lossy().into_owned();
+        let Ok(t) = e.file_type() else { continue };
+        let entry = if t.is_symlink() {
+            json!({ "name": name, "kind": "link" })
+        } else if t.is_dir() {
+            json!({ "name": name, "kind": "folder" })
+        } else {
+            json!({ "name": name, "kind": "file", "size": e.metadata().map(|m| m.len()).ok() })
+        };
+        entries.push((name, entry));
+    }
+    entries.sort_by(|a, b| a.0.cmp(&b.0));
+    Ok((entries.into_iter().map(|(_, v)| v).collect(), truncated))
+}
+
+#[cfg(target_arch = "wasm32")]
+fn list_dir(_: &str, _: usize) -> Result<(Vec<Value>, bool)> {
+    Err(EngineError::Other("no file system here".into()))
+}
+
 /// A file's size (bytes) and modification time (ms since the Unix epoch, when the file system
 /// keeps one); `None` when there is no file at `path` (or automation may not read it).
 #[cfg(not(target_arch = "wasm32"))]

crates/engine/src/cmd/layer.rs

@@ -129,7 +129,15 @@ pub fn specs() -> Vec<CommandSpec> {
             has_doc,
             artboard_new
         ),
-        cmd!("artboard.delete", "Delete Artboard", ["Window", "Artboards"], None, "{index}", has_doc, artboard_delete),
+        cmd!(
+            "artboard.delete",
+            "Delete Artboard",
+            ["Window", "Artboards"],
+            None,
+            "{index | indices: [index…]} delete artboards (with their guides) in one step; one is always left",
+            has_doc,
+            artboard_delete
+        ),
         cmd!(
             "artboard.setProps",
             "Artboard Options…",
@@ -749,17 +757,16 @@ fn artboard_new(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn artboard_delete(s: &mut Session, p: &Value) -> Result<Value> {
-    let i = p.get("index").and_then(Value::as_u64).ok_or_else(|| bad("artboard.delete", "missing index"))? as usize;
+    let indices = super::panelcmds::artboard_indices(&s.doc()?.doc, p, "artboard.delete")?;
     s.edit("Delete Artboard", |d, sel| {
-        if d.artboards.len() <= 1 {
+        if indices.len() >= d.artboards.len() {
             return Err(EngineError::Other("a document needs at least one artboard".into()));
         }
-        if i >= d.artboards.len() {
-            return Err(EngineError::Other("no such artboard".into()));
+        // The last first, so the others keep their places; their guides go with them.
+        for &i in indices.iter().rev() {
+            let id = d.artboards.remove(i).id;
+            d.retain_guides(sel, |_, g| g.artboard != Some(id));
         }
-        // Its guides go with it.
-        let id = d.artboards.remove(i).id;
-        d.retain_guides(sel, |_, g| g.artboard != Some(id));
         Ok(())
     })?;
     ok()

crates/engine/src/cmd/layerpanel.rs

@@ -82,7 +82,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Hide Others",
             ["Window", "Layers"],
             None,
-            "{ids?} hide every top-level layer but those holding the highlighted rows (else the current layer). One undo step → {count}",
+            "{ids?} hide every top-level layer but those holding the highlighted rows (else the current layer), which show. One undo step → {count}",
             has_doc,
             |s, p| others(s, p, Flag::Visible, false)
         ),
@@ -96,7 +96,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Outline Others",
             ["Window", "Layers"],
             None,
-            "{ids?} turn Preview off (outline view) for every top-level layer but those holding the highlighted rows (else the current layer) → {count}",
+            "{ids?} turn Preview off (outline view) for every top-level layer but those holding the highlighted rows (else the current layer), which preview → {count}",
             has_doc,
             |s, p| others(s, p, Flag::Preview, false)
         ),
@@ -114,7 +114,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Lock Others",
             ["Window", "Layers"],
             None,
-            "{ids?} lock every top-level layer but those holding the highlighted rows (else the current layer) → {count}",
+            "{ids?} lock every top-level layer but those holding the highlighted rows (else the current layer), which unlock → {count}",
             has_doc,
             |s, p| others(s, p, Flag::Locked, true)
         ),
@@ -176,23 +176,23 @@ impl Flag {
     }
 }
 
-/// Set `flag` to `v` on `ids` (layers that differ) in one undo step labelled `label` → how many
+/// Set `flag` on each of `changes` (id, value; layers that differ) in one undo step labelled `label` → how many
 /// changed.
-fn set_flag(s: &mut Session, ids: Vec<NodeId>, flag: Flag, v: bool, label: &str) -> Result<Value> {
+fn set_flag(s: &mut Session, changes: Vec<(NodeId, bool)>, flag: Flag, label: &str) -> Result<Value> {
     let d = &s.doc()?.doc;
-    let ids: Vec<NodeId> = ids.into_iter().filter(|id| d.node(*id).is_some_and(|n| flag.get(n) != v)).collect();
-    if !ids.is_empty() {
+    let changes: Vec<(NodeId, bool)> = changes.into_iter().filter(|(id, v)| d.node(*id).is_some_and(|n| flag.get(n) != *v)).collect();
+    if !changes.is_empty() {
         s.edit(label, |d, sel| {
-            for id in &ids {
+            for (id, v) in &changes {
                 if let Some(n) = d.node_mut(*id) {
-                    flag.set(n, v);
+                    flag.set(n, *v);
                 }
             }
             sel.deselect_uneditable(d);
             Ok(())
         })?;
     }
-    Ok(json!({ "count": ids.len() }))
+    Ok(json!({ "count": changes.len() }))
 }
 
 /// The top-level layers holding the rows a command acts on.
@@ -202,20 +202,22 @@ fn kept_layers(s: &Session, p: &Value) -> Result<HashSet<NodeId>> {
     Ok(ids.iter().filter_map(|id| d.layer_of(*id)).collect())
 }
 
+/// Every top-level layer but the kept ones set to `v`, and the kept ones to the opposite: Alt-click
+/// on a hidden layer's eye shows just that layer (#1158).
 fn others(s: &mut Session, p: &Value, flag: Flag, v: bool) -> Result<Value> {
     let keep = kept_layers(s, p)?;
-    let ids: Vec<NodeId> = s.doc()?.doc.layers.iter().map(|l| l.id).filter(|l| !keep.contains(l)).collect();
-    set_flag(s, ids, flag, v, flag.label(v))
+    let changes = s.doc()?.doc.layers.iter().map(|l| (l.id, !keep.contains(&l.id) == v)).collect();
+    set_flag(s, changes, flag, flag.label(v))
 }
 
 fn all(s: &mut Session, flag: Flag, v: bool) -> Result<Value> {
     let mut ids = vec![];
     s.doc()?.doc.walk(|n| {
         if n.is_layer() {
-            ids.push(n.id);
+            ids.push((n.id, v));
         }
     });
-    set_flag(s, ids, flag, v, flag.label(v))
+    set_flag(s, ids, flag, flag.label(v))
 }
 
 fn template(s: &mut Session, p: &Value) -> Result<Value> {

crates/engine/src/cmd/live.rs

@@ -14,7 +14,7 @@ use vectorcraft_doc::live::{
     PreserveShape, Spine,
 };
 use vectorcraft_doc::{Appearance, Document, Node, NodeId, NodeKind, Selection};
-use vectorcraft_geom::{Affine, PathData, Point};
+use vectorcraft_geom::{Affine, PathData, Point, Vec2};
 
 use super::edit::selected_roots;
 use super::expand::gradient_sampler;
@@ -95,6 +95,15 @@ pub fn specs() -> Vec<CommandSpec> {
             has_doc,
             spine_move_anchor
         ),
+        cmd!(
+            "object.blend.spine.reshapeSegment",
+            "Reshape Spine Segment",
+            [],
+            None,
+            "{id? (default: the selected blend), segment: index, t: 0..1, dx, dy} bend a segment of the blend's spine so its point at t moves by (dx, dy), as path.reshapeSegment bends a path's: a straight spine turns into a curve (#1111)",
+            has_doc,
+            spine_reshape_segment
+        ),
         cmd!(
             "object.blend.spine.addAnchor",
             "Add Spine Point",
@@ -640,6 +649,18 @@ fn spine_move_anchor(s: &mut Session, p: &Value) -> Result<Value> {
     ok()
 }
 
+fn spine_reshape_segment(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "object.blend.spine.reshapeSegment";
+    let seg = index_param(p, "segment", C)?;
+    let t = f64_or(p, "t", 0.5).clamp(0.05, 0.95);
+    let dv = Vec2::new(f64_or(p, "dx", 0.0), f64_or(p, "dy", 0.0));
+    if !(t.is_finite() && dv.x.is_finite() && dv.y.is_finite() && dv.hypot() < 1e9) {
+        return Err(bad(C, "t, dx and dy must be finite"));
+    }
+    edit_spine(s, p, C, "Reshape Spine", |sp, _, _| if sp.bend_segment(seg, t, dv) { Ok(()) } else { Err(bad(C, "no such spine segment")) })?;
+    ok()
+}
+
 fn spine_add_anchor(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "object.blend.spine.addAnchor";
     let q = finite_point(p, C)?;

crates/engine/src/cmd/object.rs

@@ -9,7 +9,7 @@ use vectorcraft_color::{BlendMode, Paint};
 use vectorcraft_doc::corners::set_corners;
 use vectorcraft_doc::{Appearance, Document, Knockout, LiveCorners, LiveShape, Node, NodeId, NodeKind, OrientedBox, Scaling};
 use vectorcraft_geom::shapes::CornerKind;
-use vectorcraft_geom::{Affine, FillRule, Point, Rect, Vec2};
+use vectorcraft_geom::{Affine, FillRule, PathData, Point, Rect, Vec2};
 
 use super::edit::{duplicate_in, selected_roots};
 use super::opacitymask::percent;
@@ -106,7 +106,15 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("object.hide", "Selection", ["Object", "Hide"], Some("Cmd+3"), "{}", has_selection, hide),
         cmd!("object.showAll", "Show All", ["Object"], Some("Cmd+Alt+3"), "{}", has_doc, show_all),
         cmd!("object.compoundPath.make", "Make", ["Object", "Compound Path"], Some("Cmd+8"), "{}", has_selection, compound_make),
-        cmd!("object.compoundPath.release", "Release", ["Object", "Compound Path"], Some("Cmd+Alt+Shift+8"), "{}", has_selection, compound_release),
+        cmd!(
+            "object.compoundPath.release",
+            "Release",
+            ["Object", "Compound Path"],
+            Some("Cmd+Alt+Shift+8"),
+            "{} release the selected compound paths into their paths, each with the compound path's paint; a path of several subpaths (an SVG `d` with several `M`s) splits into one path per subpath",
+            has_selection,
+            compound_release
+        ),
         cmd!(
             "object.clippingMask.make",
             "Make",
@@ -196,7 +204,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Live Shape Properties",
             [],
             None,
-            "{id?, ids?, radius?: pt, kind?: \"round\"|\"invertedRound\"|\"chamfer\", corners?: [i…], items?: [{id, corners?: [i…]}] (several objects, each with its own corners, in place of ids and corners: the canvas's corner widgets across a selection), sides?: n, polygonAngle?: degrees (counterclockwise from its first vertex straight up), polygonRadius?: pt (centre to vertex), sideLength?: pt (sets the radius), makeSidesEqual?: true (a polygon scaled unevenly: drops the uneven scale and shear, keeping its centre, angle and mean radius), pieStart?, pieEnd?: degrees (an ellipse's pie, counterclockwise from 3 o'clock; 0 to 360 is the whole ellipse), invertPie?: true (swaps them: the other part of the ellipse)} (Live Corners on any path: radius and kind set its corners (anchors without handles between two straight sides): `corners` (anchor indices of the path with its corners uncut, counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a polygon's from the first vertex clockwise), else the corners with a Direct-Selected anchor, else every corner; each radius is drawn no larger than half the corner's shorter side allows; a path that isn't a live shape keeps its uncut outline so its corners stay editable, and is plain again once none is cut; sides: a polygon's, which keep the radius they shared; the polygon params apply in that order: sides, makeSidesEqual, polygonAngle, then sideLength or else polygonRadius)",
+            "{id?, ids?, radius?: pt, kind?: \"round\"|\"invertedRound\"|\"chamfer\", corners?: [i…], items?: [{id, corners?: [i…]}] (several objects, each with its own corners, in place of ids and corners: the canvas's corner widgets across a selection), sides?: n, polygonAngle?: degrees (counterclockwise from its first vertex straight up), polygonRadius?: pt (centre to vertex), sideLength?: pt (sets the radius), makeSidesEqual?: true (a polygon scaled unevenly: drops the uneven scale and shear, keeping its centre, angle and mean radius), pieStart?, pieEnd?: degrees (an ellipse's pie, counterclockwise from 3 o'clock; 0 to 360 is the whole ellipse), invertPie?: true (swaps them: the other part of the ellipse)} (Live Corners on any path: radius and kind set its corners (anchors that aren't smooth, where two sides, straight or curved (#1144), meet at an angle): `corners` (anchor indices of the path with its corners uncut, counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a polygon's from the first vertex clockwise), else the corners with a Direct-Selected anchor, else every corner; each radius is drawn no larger than half the corner's shorter side allows; a path that isn't a live shape keeps its uncut outline so its corners stay editable, and is plain again once none is cut; sides: a polygon's, which keep the radius they shared; the polygon params apply in that order: sides, makeSidesEqual, polygonAngle, then sideLength or else polygonRadius)",
             has_selection,
             set_live_shape
         ),
@@ -658,26 +666,52 @@ fn compound_make(s: &mut Session, _: &Value) -> Result<Value> {
     Ok(json!({ "id": id.0 }))
 }
 
+/// Is `n` a compound path to release: a compound path, or a path of several subpaths (an SVG `d`
+/// with several `M`s, a PDF path), which is one in Illustrator too (#1163)?
+fn releases(n: &Node) -> bool {
+    match &n.kind {
+        NodeKind::Compound { .. } => true,
+        NodeKind::Path { path, .. } => path.subpaths.len() > 1,
+        _ => false,
+    }
+}
+
 fn compound_release(s: &mut Session, _: &Value) -> Result<Value> {
     let ids = selected_roots(s)?;
     // With no compound path selected, the document, the selection and the undo history stay as
     // they are.
     let d = &s.doc()?.doc;
-    if !ids.iter().any(|id| d.node(*id).is_some_and(|n| matches!(n.kind, NodeKind::Compound { .. }))) {
+    if !ids.iter().any(|id| d.node(*id).is_some_and(releases)) {
         return ok();
     }
     s.edit("Release Compound Path", |d, sel| {
         let mut out = vec![];
         for id in &ids {
-            let Some(n) = d.node(*id).cloned() else { continue };
-            let NodeKind::Compound { children, .. } = &n.kind else { continue };
+            let Some(n) = d.node(*id).cloned().filter(releases) else { continue };
             let (par, idx, _) = d.position(*id).ok_or(EngineError::NoNode(*id))?;
             d.remove(*id)?;
-            for (k, c) in children.iter().enumerate() {
-                let mut c = (**c).clone();
-                c.appearance = n.appearance.clone();
-                out.push(c.id);
-                d.insert(par, idx + k, c)?;
+            match &n.kind {
+                NodeKind::Compound { children, .. } => {
+                    for (k, c) in children.iter().enumerate() {
+                        let mut c = (**c).clone();
+                        c.appearance = n.appearance.clone();
+                        out.push(c.id);
+                        d.insert(par, idx + k, c)?;
+                    }
+                }
+                // Each subpath becomes a path of its own with the path's paint, in the same
+                // stacking order; the first keeps the path's id.
+                NodeKind::Path { path, .. } => {
+                    for (k, sp) in path.subpaths.iter().enumerate() {
+                        let mut c = if k == 0 { n.clone() } else { d.reid(&n) };
+                        if let NodeKind::Path { path, live, .. } = &mut c.kind {
+                            (*path, *live) = (PathData::single(sp.clone()), None);
+                        }
+                        out.push(c.id);
+                        d.insert(par, idx + k, c)?;
+                    }
+                }
+                _ => {}
             }
         }
         sel.set(out);

crates/engine/src/cmd/panelcmds.rs

@@ -78,6 +78,21 @@ fn board_and_art(s: &Session, p: &Value) -> (usize, bool) {
 
 /// The art that goes with artboard `i` when `art`: the objects fully inside it (locked and hidden
 /// ones only with prefs moveLockedWithArtboard), in paint order.
+/// The artboards `cmd` acts on: `indices` (several), else `index` (one), each an artboard of `d`,
+/// in order and once each.
+pub(crate) fn artboard_indices(d: &vectorcraft_doc::Document, p: &Value, cmd: &str) -> Result<Vec<usize>> {
+    let listed = match (p.get("indices"), p.get("index")) {
+        (Some(v), _) => point_indices(v),
+        (None, Some(i)) => point_indices(&json!([i])),
+        (None, None) => return Err(bad(cmd, "missing index")),
+    };
+    let mut indices =
+        listed.filter(|v| !v.is_empty() && v.iter().all(|i| *i < d.artboards.len())).ok_or_else(|| EngineError::Other("no such artboard".into()))?;
+    indices.sort_unstable();
+    indices.dedup();
+    Ok(indices)
+}
+
 pub(crate) fn artboard_art(s: &Session, i: usize, art: bool) -> Result<Vec<NodeId>> {
     let d = &s.doc()?.doc;
     let rect = d.artboards.get(i).map(|a| a.rect).ok_or_else(|| EngineError::Other("no such artboard".into()))?;

crates/engine/src/cmd/prefscmds.rs

@@ -87,6 +87,10 @@ const LINE_STYLE: &[(&str, &str)] = &[("lines", "Lines"), ("dots", "Dots")];
 /// `automatic` (#502).
 pub const GPU_PREFERENCES: &[(&str, &str)] =
     &[("automatic", "Automatic"), ("lowPower", "Power Saving (integrated)"), ("highPerformance", "High Performance (discrete)")];
+/// Performance › Linux Display Server (`linuxDisplayServer`), read by the desktop app at startup:
+/// `x11` opens the window through XWayland on a Wayland session, where dropped files arrive
+/// (winit 0.30 has no Wayland drag and drop, #1151).
+const LINUX_DISPLAY_SERVERS: &[(&str, &str)] = &[("automatic", "Automatic"), ("x11", "X11 (XWayland)")];
 const BLACK: &[(&str, &str)] = &[("accurate", "Display All Blacks Accurately"), ("rich", "Display All Blacks as Rich Black")];
 const BLACK_OUT: &[(&str, &str)] = &[("accurate", "Output All Blacks Accurately"), ("rich", "Output All Blacks as Rich Black")];
 
@@ -290,6 +294,7 @@ pub const PREF_SPECS: &[PrefSpec] = &[
     p!("historyStates", "Performance", "", "History States", int(5, 1000)),
     p!("realTimeDrawing", "Performance", "", "Real-time Drawing and Editing", bool),
     p!("renderThreads", "Performance", "", "Render Threads (-1 = Automatic)", int(-1, 64)),
+    p!("linuxDisplayServer", "Performance", "", "Linux Display Server", choice(LINUX_DISPLAY_SERVERS)),
     // File Handling
     p!("backgroundSave", "File Handling", "", "Enable Background Save", bool),
     p!("backgroundExport", "File Handling", "", "Enable Background Export", bool),

crates/engine/src/cmd/rasterfx.rs

@@ -26,6 +26,9 @@ use vectorcraft_render::{AntiAlias, RenderOptions};
 
 use super::*;
 
+mod report;
+use report::FlattenReport;
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![cmd!(
         "document.rasterEffectsSettings",
@@ -409,9 +412,9 @@ fn needs(n: &Node, which: Which) -> bool {
 }
 
 /// The art of `n`'s opacity mask with its raster effects as images.
-fn walk_mask(out: &mut Document, n: &mut Node, which: Which) {
+fn walk_mask(out: &mut Document, n: &mut Node, report: &mut FlattenReport) {
     if let Some(m) = n.mask.as_mut()
-        && let Some(art) = walk(out, &m.art, which)
+        && let Some(art) = walk(out, &m.art, report)
     {
         m.art = Arc::new(art);
     }
@@ -420,15 +423,23 @@ fn walk_mask(out: &mut Document, n: &mut Node, which: Which) {
 /// `n` with its raster effects (and its members' and its opacity mask's) as images, `None` when it
 /// has none. An object whose effects all paint below it keeps its vector art over an image of
 /// them; one whose effects change it (blur, feather, inner glow) becomes the image.
-fn walk(out: &mut Document, n: &Node, which: Which) -> Option<Node> {
+fn walk(out: &mut Document, n: &Node, report: &mut FlattenReport) -> Option<Node> {
+    let checkpoint = report.checkpoint();
+    let result = walk_inner(out, n, report);
+    report.attribute_since(checkpoint, n);
+    result
+}
+
+fn walk_inner(out: &mut Document, n: &Node, report: &mut FlattenReport) -> Option<Node> {
+    let which = report.which;
     if !needs(n, which) {
         return None;
     }
     if !imaged(n, which) {
         let mut m = n.clone();
-        walk_mask(out, &mut m, which);
+        walk_mask(out, &mut m, report);
         if is_container(&m)
-            && let Some(ch) = walk_all(out, n.children()?, which)
+            && let Some(ch) = walk_all(out, n.children()?, report)
             && let Some(slot) = m.children_mut()
         {
             *slot = ch;
@@ -436,33 +447,41 @@ fn walk(out: &mut Document, n: &Node, which: Which) -> Option<Node> {
         return Some(m);
     }
     if let Some(g) = placed_symbol(out, n) {
-        return Some(walk(out, &g, which).unwrap_or(g));
+        return Some(walk(out, &g, report).unwrap_or(g));
     }
     let below = below_only(n);
     if !below && let Some(g) = split_items(out, n) {
-        return Some(walk(out, &g, which).unwrap_or(g));
+        return Some(walk(out, &g, report).unwrap_or(g));
     }
     // An image that can't be made leaves the object as it is (the writer reports its effects).
     let mut v = n.clone();
     strip_raster(&mut v, false);
     let mut m = if below {
         let images = below_images(out, n)?;
-        let mut m = walk(out, &v, which).unwrap_or(v);
+        for image in &images {
+            report.record(n, image);
+        }
+        let mut m = walk(out, &v, report).unwrap_or(v);
         // Each goes in first: the last one put is the lowest.
         for image in images.into_iter().rev() {
             put_below(out, &mut m, image);
         }
         m
     } else {
-        replace_with_image(v, raster_image(out, n, false, false)?)
+        let image = raster_image(out, n, false, false)?;
+        report.record(n, &image);
+        replace_with_image(v, image)
     };
-    walk_mask(out, &mut m, which);
+    walk_mask(out, &mut m, report);
     Some(m)
 }
 
 /// `nodes` with their raster effects as images, `None` when none has any.
-fn walk_all(out: &mut Document, nodes: &[Arc<Node>], which: Which) -> Option<Vec<Arc<Node>>> {
-    nodes.iter().any(|n| needs(n, which)).then(|| nodes.iter().map(|n| walk(out, n, which).map(Arc::new).unwrap_or_else(|| n.clone())).collect())
+fn walk_all(out: &mut Document, nodes: &[Arc<Node>], report: &mut FlattenReport) -> Option<Vec<Arc<Node>>> {
+    nodes
+        .iter()
+        .any(|n| needs(n, report.which))
+        .then(|| nodes.iter().map(|n| walk(out, n, report).map(Arc::new).unwrap_or_else(|| n.clone())).collect())
 }
 
 /// A copy of `doc` with raster effects turned into images at the document's raster effects
@@ -470,17 +489,18 @@ fn walk_all(out: &mut Document, nodes: &[Arc<Node>], which: Which) -> Option<Vec
 /// type, images, symbol instances, live objects) and on single fills and strokes, in the layers,
 /// opacity masks, symbol definitions and pattern tiles.
 pub fn flatten_raster_effects(doc: &Document) -> Option<Document> {
-    flatten(doc, Which::All)
+    flatten(doc, &mut FlattenReport::new(Which::All, doc))
 }
 
 /// A copy of `doc` in which the objects with Photoshop-style raster effects (Radial Blur, Unsharp
 /// Mask…) are images as [`flatten_raster_effects`] makes them (SVG export: its filters draw the
 /// other raster effects live), or `None` when there are none.
 pub fn flatten_pixel_effects(doc: &Document) -> Option<Document> {
-    flatten(doc, Which::Pixel)
+    flatten(doc, &mut FlattenReport::new(Which::Pixel, doc))
 }
 
-fn flatten(doc: &Document, which: Which) -> Option<Document> {
+fn flatten(doc: &Document, report: &mut FlattenReport) -> Option<Document> {
+    let which = report.which;
     let any = |nodes: &[Arc<Node>]| nodes.iter().any(|n| needs(n, which));
     if !any(&doc.layers) && !doc.symbols.iter().any(|s| needs(&s.art, which)) && !doc.patterns.iter().any(|p| any(&p.art)) {
         return None;
@@ -489,18 +509,18 @@ fn flatten(doc: &Document, which: Which) -> Option<Document> {
     let baked = effects::bake_document(doc);
     let src = baked.as_ref().unwrap_or(doc);
     let mut out = src.clone();
-    if let Some(layers) = walk_all(&mut out, &src.layers, which) {
+    if let Some(layers) = walk_all(&mut out, &src.layers, report) {
         out.layers = layers;
     }
     for i in 0..out.symbols.len() {
-        if let Some(art) = out.symbols.get(i).map(|s| s.art.clone()).and_then(|a| walk(&mut out, &a, which))
+        if let Some(art) = out.symbols.get(i).map(|s| s.art.clone()).and_then(|a| walk(&mut out, &a, report))
             && let Some(s) = out.symbols.get_mut(i)
         {
             s.art = Arc::new(art);
         }
     }
     for i in 0..out.patterns.len() {
-        if let Some(art) = out.patterns.get(i).map(|p| p.art.clone()).and_then(|a| walk_all(&mut out, &a, which))
+        if let Some(art) = out.patterns.get(i).map(|p| p.art.clone()).and_then(|a| walk_all(&mut out, &a, report))
             && let Some(p) = out.patterns.get_mut(i)
         {
             p.art = art;
@@ -520,10 +540,11 @@ pub fn export_pdf_with_report(
     doc: &Document,
     opts: &vectorcraft_pdf::PdfOptions,
 ) -> std::result::Result<vectorcraft_pdf::ExportReport, vectorcraft_pdf::PdfError> {
-    match flatten_raster_effects(doc) {
-        Some(d) => vectorcraft_pdf::export_with_report(&d, opts),
-        None => vectorcraft_pdf::export_with_report(doc, opts),
-    }
+    let mut report = FlattenReport::new(Which::All, doc);
+    let flat = flatten(doc, &mut report);
+    let mut exported = vectorcraft_pdf::export_with_report(flat.as_ref().unwrap_or(doc), opts)?;
+    exported.warnings.extend(report.warnings());
+    Ok(exported)
 }
 
 #[cfg(test)]

crates/engine/src/cmd/rasterfx/report.rs

@@ -0,0 +1,129 @@
+//! The PDF export warnings for raster effects whose images the 64 million pixel cap rendered below
+//! the document's raster effects resolution, one per object of the document.
+
+use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
+
+use super::Which;
+
+pub(super) struct FlattenReport {
+    pub which: Which,
+    requested_ppi: f64,
+    reductions: Vec<Reduction>,
+    /// Ids from here on are the flattening's own (split appearance items, groups under shadows).
+    first_new_id: u64,
+}
+
+struct Reduction {
+    id: NodeId,
+    name: Option<String>,
+    achieved_ppi: f64,
+}
+
+impl FlattenReport {
+    pub fn new(which: Which, doc: &Document) -> Self {
+        Self { which, requested_ppi: super::effects_scale(doc) * 72.0, reductions: vec![], first_new_id: doc.peek_next_id() }
+    }
+
+    /// Note `image` (made for the raster effects of `original`) when the cap lowered its resolution.
+    pub fn record(&mut self, original: &Node, image: &Node) {
+        if let NodeKind::Image(image) = &image.kind {
+            let [pixel_size, ..] = image.xf.as_coeffs();
+            let achieved_ppi = 72.0 / pixel_size;
+            if achieved_ppi + 1e-6 < self.requested_ppi {
+                self.reductions.push(Reduction { id: original.id, name: original.name.clone(), achieved_ppi });
+            }
+        }
+    }
+
+    pub fn checkpoint(&self) -> usize {
+        self.reductions.len()
+    }
+
+    /// Give the reductions recorded since `checkpoint` on pieces the flattening made to `original`,
+    /// a document object (the innermost one, as the walk returns from it).
+    pub fn attribute_since(&mut self, checkpoint: usize, original: &Node) {
+        let first_new_id = self.first_new_id;
+        if original.id.0 >= first_new_id {
+            return;
+        }
+        for reduction in self.reductions.iter_mut().skip(checkpoint) {
+            if reduction.id.0 >= first_new_id {
+                reduction.id = original.id;
+                reduction.name.clone_from(&original.name);
+            }
+        }
+    }
+
+    pub fn warnings(self) -> Vec<String> {
+        let mut lowest: Vec<Reduction> = vec![];
+        for reduction in self.reductions {
+            if let Some(existing) = lowest.iter_mut().find(|r| r.id == reduction.id) {
+                existing.achieved_ppi = existing.achieved_ppi.min(reduction.achieved_ppi);
+            } else {
+                lowest.push(reduction);
+            }
+        }
+        lowest
+            .into_iter()
+            .map(|r| {
+                let name = r.name.map(|name| format!(" ({name})")).unwrap_or_default();
+                format!(
+                    "raster effects on object {}{name}: requested {:.1} ppi, achieved {:.1} ppi due to the 64 million pixel cap",
+                    r.id.0, self.requested_ppi, r.achieved_ppi
+                )
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use vectorcraft_doc::ImageObject;
+    use vectorcraft_geom::Affine;
+
+    fn image(ppi: f64) -> Node {
+        Node::new(
+            NodeId(999),
+            NodeKind::Image(ImageObject {
+                key: "effect".into(),
+                width: 8000,
+                height: 8000,
+                xf: Affine::scale(72.0 / ppi),
+                link: None,
+                placement: Default::default(),
+            }),
+        )
+    }
+
+    #[test]
+    fn lowest_resolution_is_reported_when_multiple_images_belong_to_one_object() {
+        let mut doc = Document::new(100.0, 100.0);
+        doc.raster_effects_ppi = 2400.0;
+        let original = &doc.layers[0];
+        let mut report = FlattenReport::new(Which::All, &doc);
+
+        for ppi in [1800.0, 1200.0, 1500.0] {
+            report.record(original, &image(ppi));
+        }
+
+        let warnings = report.warnings();
+        assert_eq!(warnings.len(), 1);
+        assert!(warnings[0].contains("achieved 1200.0 ppi"), "{:?}", warnings);
+    }
+
+    #[test]
+    fn parent_identity_is_reported_when_generated_pieces_are_attributed() {
+        let doc = Document::new(100.0, 100.0);
+        let original = &doc.layers[0];
+        let generated = Node::group(NodeId(998), vec![]);
+        let mut report = FlattenReport::new(Which::All, &doc);
+
+        report.record(&generated, &image(36.0));
+        report.attribute_since(0, original);
+
+        let warnings = report.warnings();
+        assert_eq!(warnings.len(), 1);
+        assert!(warnings[0].contains(&format!("object {}", original.id.0)), "{:?}", warnings);
+    }
+}

crates/engine/src/cmd/xform.rs

@@ -45,7 +45,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Move Artboard",
             [],
             None,
-            "{index, dx, dy, moveArt?: bool, copy?: bool} move an artboard (and the art fully inside it; locked and hidden art only with prefs moveLockedWithArtboard); `copy` (Alt-drag) leaves them and moves copies → {index, moved: the art moved or the copies}",
+            "{index | indices: [index…], dx, dy, moveArt?: bool, copy?: bool} move artboards (and the art fully inside them; locked and hidden art only with prefs moveLockedWithArtboard), several in one step; `copy` (Alt-drag) leaves them and moves copies → {index (the first), indices: the artboards moved or the copies, moved: the art moved or the copies}",
             has_doc,
             artboard_move
         ),
@@ -366,26 +366,41 @@ fn sample_color(s: &mut Session, p: &Value) -> Result<Value> {
 // ---------- artboards ----------
 
 fn artboard_move(s: &mut Session, p: &Value) -> Result<Value> {
-    let i = p.get("index").and_then(Value::as_u64).ok_or_else(|| bad("artboard.move", "missing index"))? as usize;
+    let indices = super::panelcmds::artboard_indices(&s.doc()?.doc, p, "artboard.move")?;
     let dv = Vec2::new(f64_or(p, "dx", 0.0), f64_or(p, "dy", 0.0));
-    let art = super::panelcmds::artboard_art(s, i, bool_or(p, "moveArt", false))?;
+    let move_art = bool_or(p, "moveArt", false);
+    // Each artboard's art, an object counted once (artboards can overlap).
+    let mut arts: Vec<(usize, Vec<NodeId>)> = vec![];
+    for &i in &indices {
+        let art = super::panelcmds::artboard_art(s, i, move_art)?;
+        let art = art.into_iter().filter(|id| !arts.iter().any(|(_, a)| a.contains(id))).collect();
+        arts.push((i, art));
+    }
     let scale_strokes = s.prefs.scale_strokes;
     let copy = bool_or(p, "copy", false);
     let (index, moved) = s.edit(if copy { "Duplicate Artboard" } else { "Move Artboard" }, |d, _| {
-        // A copy keeps the artboard (and its art) where they are and moves duplicates instead.
-        if copy {
-            return super::panelcmds::copy_artboard(d, i, dv, &art, scale_strokes);
-        }
-        let a = d.artboards.get_mut(i).ok_or_else(|| EngineError::Other("no such artboard".into()))?;
-        a.rect = a.rect + dv;
-        let id = a.id;
-        d.move_artboard_guides(id, dv);
-        for id in &art {
-            if let Some(n) = d.node_mut(*id) {
-                n.transform(Affine::translate(dv), scale_strokes);
+        let (mut index, mut moved) = (vec![], vec![]);
+        for (i, art) in &arts {
+            // A copy keeps the artboard (and its art) where they are and moves duplicates instead.
+            if copy {
+                let (at, copies) = super::panelcmds::copy_artboard(d, *i, dv, art, scale_strokes)?;
+                index.push(at);
+                moved.extend(copies);
+                continue;
             }
+            let a = d.artboards.get_mut(*i).ok_or_else(|| EngineError::Other("no such artboard".into()))?;
+            a.rect = a.rect + dv;
+            let id = a.id;
+            d.move_artboard_guides(id, dv);
+            for id in art {
+                if let Some(n) = d.node_mut(*id) {
+                    n.transform(Affine::translate(dv), scale_strokes);
+                }
+            }
+            index.push(*i);
+            moved.extend(art.iter().copied());
         }
-        Ok((i, art.clone()))
+        Ok((index, moved))
     })?;
-    Ok(json!({ "index": index, "moved": moved.iter().map(|i| i.0).collect::<Vec<_>>() }))
+    Ok(json!({ "index": index.first(), "indices": index, "moved": moved.iter().map(|i| i.0).collect::<Vec<_>>() }))
 }

crates/engine/src/lib.rs

@@ -100,6 +100,8 @@ pub struct UndoGroup {
     first: Option<Arc<Document>>,
     /// The journal's length when the group began: a cancelled group drops the entries after it.
     journal: usize,
+    /// The undo step's name; else the first edit's.
+    label: Option<String>,
 }
 
 /// Per-document editing state.
@@ -285,13 +287,16 @@ impl DocState {
     }
     /// Record undo step `e` (the document before an edit). In an undo group only the group's first
     /// edit records one: the edits after it extend that step.
-    fn push_undo(&mut self, e: HistoryEntry) {
+    fn push_undo(&mut self, mut e: HistoryEntry) {
         if let Some(g) = &mut self.undo_group {
             let recorded = |first: &Arc<Document>| self.history.undo.last().is_some_and(|l| Arc::ptr_eq(&l.doc, first));
             if g.first.as_ref().is_some_and(recorded) {
                 return;
             }
             g.first = Some(e.doc.clone());
+            if let Some(l) = &g.label {
+                e.label = l.clone();
+            }
         }
         self.history.undo.push(e);
         if self.history.undo.len() > self.history.limit {
@@ -564,6 +569,9 @@ pub struct Prefs {
     pub real_time_drawing: bool,
     /// Rasterizer worker threads; -1 = automatic.
     pub render_threads: i32,
+    /// Linux: `automatic` opens the window on the session's display server; `x11` opens it through
+    /// XWayland on a Wayland session, where dropped files arrive (#1151). Read when the app starts.
+    pub linux_display_server: String,
     // File Handling
     pub background_save: bool,
     pub background_export: bool,
@@ -769,6 +777,7 @@ impl Default for Prefs {
             history_states: 500,
             real_time_drawing: true,
             render_threads: -1,
+            linux_display_server: s("automatic"),
             background_save: true,
             background_export: true,
             autosave_recovery: true,
@@ -1413,11 +1422,16 @@ impl Session {
     /// applies each value it passes as its own command, as a typed value is applied; the drag is
     /// one step.
     pub fn begin_undo_group(&mut self) {
+        self.begin_named_undo_group(None);
+    }
+
+    /// [`Session::begin_undo_group`] with the undo step named `label` (else after its first edit).
+    pub fn begin_named_undo_group(&mut self, label: Option<String>) {
         let journal = self.journal.len();
         if let Some(st) = self.active_mut()
             && st.undo_group.is_none()
         {
-            st.undo_group = Some(UndoGroup { first: None, journal });
+            st.undo_group = Some(UndoGroup { first: None, journal, label });
         }
     }
 

crates/engine/src/tests.rs

@@ -381,6 +381,31 @@ fn clipping_and_compound() {
     assert_eq!(s.doc().unwrap().selection.objects, vec![b]);
 }
 
+/// #1163: a path of several subpaths (an SVG `d` with several `M`s) is a compound path to Release:
+/// one path per subpath, each with the path's paint, in its stacking order, in one undo step.
+#[test]
+fn release_splits_a_path_of_several_subpaths() {
+    let mut s = session();
+    let id = NodeId(
+        s.execute("path.create", &json!({"d": "M0 0 L10 0 L10 10 Z M20 0 L30 0 L30 10 Z M40 0 L50 0 L50 10 Z"})).unwrap()["id"].as_u64().unwrap(),
+    );
+    s.execute("paint.setFill", &json!({"color": "#ff0000"})).unwrap();
+    let undo = s.doc().unwrap().history.undo.len();
+    s.execute("object.compoundPath.release", &json!({})).unwrap();
+    let st = s.doc().unwrap();
+    assert_eq!(st.history.undo.len(), undo + 1);
+    let sel = st.selection.objects.clone();
+    assert_eq!((sel.len(), sel[0]), (3, id), "the first keeps its id");
+    let layer = st.doc.layers[0].children().unwrap();
+    for (k, n) in sel.iter().map(|i| st.doc.node(*i).unwrap()).enumerate() {
+        let NodeKind::Path { path, .. } = &n.kind else { panic!("a path") };
+        assert_eq!(path.subpaths.len(), 1);
+        assert_eq!(path.bounds().unwrap().x0, 20.0 * k as f64, "in order");
+        assert_eq!(n.appearance.fill_paint().color().unwrap().to_hex(), "#ff0000", "the path's paint");
+        assert_eq!(layer[k].id, n.id, "stacked bottom to top");
+    }
+}
+
 /// `object.align` without `horizontal` or `vertical` (an unknown key such as `align` counts as
 /// neither) returns an error: nothing moves, and the undo and redo stacks stay as they were.
 #[test]
@@ -1645,3 +1670,32 @@ fn path_commands_reject_bad_anchors_before_modifying_geometry() {
     s.execute("path.setAnchors", &json!({"id": a.0, "subpaths": [{"anchors": [{"x": 0, "y": 0}, {"x": 30, "y": 40}], "closed": false}]})).unwrap();
     assert_eq!(s.doc().unwrap().doc.node(a).unwrap().path_data().unwrap().anchor_count(), 2);
 }
+
+/// #1163: `file.list` lists a folder's files and folders by name, held to the automation read root
+/// when one is in force.
+#[test]
+fn file_list_lists_a_folder_within_the_read_root() {
+    let base = std::env::temp_dir().join(format!("vc-file-list-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&base);
+    for d in ["in/sub", "outside"] {
+        std::fs::create_dir_all(base.join(d)).unwrap();
+    }
+    std::fs::write(base.join("in/b.svg"), "<svg/>").unwrap();
+    std::fs::write(base.join("in/a.pdf"), "1234").unwrap();
+    let path = |d: &str| base.join(d).to_string_lossy().into_owned();
+    let mut s = Session::new();
+    let r = s.execute("file.list", &json!({"path": path("in")})).unwrap();
+    assert_eq!(
+        r["entries"],
+        json!([{"name": "a.pdf", "kind": "file", "size": 4}, {"name": "b.svg", "kind": "file", "size": 6}, {"name": "sub", "kind": "folder"}])
+    );
+    assert_eq!(r["truncated"], false);
+    let roots = crate::file_access::AutomationRoots::new(Some(&base.join("in")), None).unwrap().unwrap();
+    crate::file_access::confine(Some(&roots), || {
+        assert!(s.execute("file.list", &json!({"path": path("in/sub")})).is_ok());
+        assert!(s.execute("file.list", &json!({"path": path("outside")})).is_err(), "outside the read root");
+    });
+    assert!(s.execute("file.list", &json!({"path": path("in/b.svg")})).is_err(), "not a folder");
+    assert!(s.execute("file.list", &json!({})).is_err());
+    let _ = std::fs::remove_dir_all(base);
+}

crates/engine/src/tests_blendspine.rs

@@ -187,3 +187,20 @@ fn key_anchors_round_trip() {
     let old: BlendSpec = serde_json::from_value(json!({"spine": {"subpaths": []}})).unwrap();
     assert!(old.key_anchors.is_empty());
 }
+
+/// #1111: a straight spine's segment bends into a curve, its middle moving where it's dragged, and
+/// the steps follow it; junk segments and deltas are refused.
+#[test]
+fn a_straight_spine_segment_bends_into_a_curve() {
+    let mut s = session();
+    let (_, _, g) = blend(&mut s);
+    s.execute("object.blend.spine.reshapeSegment", &json!({"segment": 0, "t": 0.5, "dx": 0, "dy": 40})).unwrap();
+    let spine = spec(&s, g).spine.unwrap();
+    let seg = spine.subpaths[0].segment(0);
+    use vectorcraft_geom::kurbo::ParamCurve;
+    assert!(seg.eval(0.5).distance(Point::new(55.0, 45.0)) < 1e-9, "{seg:?}");
+    assert!(center(&steps(&s, g)[1]).y > 20.0, "the step follows the curve");
+    for bad in [json!({"segment": 1, "dy": 10}), json!({"segment": 0, "dx": f64::MAX, "dy": f64::MAX}), json!({"segment": -1})] {
+        assert!(s.execute("object.blend.spine.reshapeSegment", &bad).is_err(), "{bad}");
+    }
+}

crates/engine/src/tests_layers.rs

@@ -543,6 +543,23 @@ fn hide_lock_and_outline_others_and_their_all_counterparts() {
     assert_eq!(run(&mut s, "layer.previewAll", json!({}))["count"], 0, "nothing to do: no undo step");
 }
 
+/// #1158: Alt-click on a hidden (locked) layer's eye (lock) isolates it: it shows (unlocks) as the
+/// others hide (lock), in one undo step.
+#[test]
+fn hide_and_lock_others_show_and_unlock_the_layer_kept() {
+    let mut s = session();
+    let l1 = s.doc().unwrap().doc.layers[0].id;
+    let l2 = id(&run(&mut s, "layer.new", json!({})));
+    let flags = |s: &Session, f: fn(&Node) -> bool| [l1, l2].map(|l| f(&node(s, l)));
+    run(&mut s, "layer.setProps", json!({"ids": [l2.0], "visible": false, "locked": true}));
+    assert_eq!(run(&mut s, "layer.hideOthers", json!({"ids": [l2.0]}))["count"], 2);
+    assert_eq!(flags(&s, |n| n.visible), [false, true]);
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(flags(&s, |n| n.visible), [true, false], "one undo step");
+    run(&mut s, "layer.lockOthers", json!({"ids": [l2.0]}));
+    assert_eq!(flags(&s, |n| n.locked), [true, false]);
+}
+
 #[test]
 fn locate_object_highlights_its_row() {
     let mut s = session();

crates/engine/src/tests_pdfraster.rs

@@ -182,3 +182,42 @@ fn shadows_and_glows_keep_their_blend_modes() {
         flat.layers[0].children().unwrap()[0].children().unwrap().iter().filter(|c| matches!(c.kind, NodeKind::Image(_))).map(|c| c.blend).collect();
     assert_eq!(modes, [vectorcraft_color::BlendMode::Multiply, vectorcraft_color::BlendMode::Screen]);
 }
+
+#[test]
+fn pdf_resolution_cap_warns_once_for_original_object_when_appearance_items_split() {
+    let mut d = Document::new(300.0, 300.0);
+    d.raster_effects_ppi = 2400.0;
+    d.raster_effects.anti_alias = false;
+    let mut n = Node::path(
+        d.alloc_id(),
+        shapes::rectangle(Rect::new(20.0, 20.0, 270.0, 270.0)),
+        Appearance::basic(Paint::solid(Color::BLACK), Paint::solid(Color::BLACK), 20.0),
+    );
+    let id = n.id;
+    n.name = Some("Large original".into());
+    for item in &mut n.appearance.items {
+        item.effects_mut().push(Effect { params: json!({"radius": 0.0}), ..blur() });
+    }
+    add(&mut d, n);
+
+    let r = crate::cmd::rasterfx::export_pdf_with_report(&d, &Default::default()).unwrap();
+
+    assert!(String::from_utf8_lossy(&r.bytes).contains("/Subtype/Image"));
+    assert_eq!(r.warnings.len(), 1, "{:?}", r.warnings);
+    let warning = &r.warnings[0];
+    assert!(warning.contains(&format!("object {}", id.0)) && warning.contains("Large original"), "{warning}");
+    assert!(warning.contains("requested 2400.0 ppi") && warning.contains("achieved 1268.7 ppi"), "{warning}");
+}
+
+#[test]
+fn pdf_resolution_cap_stays_quiet_when_small_effect_meets_requested_ppi() {
+    let mut d = Document::new(50.0, 50.0);
+    d.raster_effects_ppi = 300.0;
+    let n = with(rect(&mut d, Rect::new(10.0, 10.0, 30.0, 30.0), Color::BLACK), blur());
+    add(&mut d, n);
+
+    let r = crate::cmd::rasterfx::export_pdf_with_report(&d, &Default::default()).unwrap();
+
+    assert!(String::from_utf8_lossy(&r.bytes).contains("/Subtype/Image"));
+    assert!(r.warnings.is_empty(), "{:?}", r.warnings);
+}

crates/engine/src/tests_prefs.rs

@@ -156,6 +156,23 @@ fn gpu_preference_defaults_to_automatic_and_validates() {
     assert_eq!(s.prefs.gpu_preference, "automatic");
 }
 
+/// Performance › Linux Display Server (#1151): automatic by default, X11 by value or label, and
+/// anything else is an error that changes nothing.
+#[test]
+fn linux_display_server_defaults_to_automatic_and_validates() {
+    let mut s = Session::new();
+    assert_eq!(s.prefs.linux_display_server, "automatic");
+    s.execute("prefs.set", &json!({"key": "linuxDisplayServer", "value": "X11 (XWayland)"})).unwrap();
+    assert_eq!(s.prefs.linux_display_server, "x11");
+    for bad in [json!("wayland"), json!(""), json!(11), json!(null)] {
+        assert!(s.execute("prefs.set", &json!({"key": "linuxDisplayServer", "value": bad})).is_err(), "{bad}");
+        assert_eq!(s.prefs.linux_display_server, "x11");
+    }
+    assert_eq!(s.prefs.to_json()["linuxDisplayServer"], "x11");
+    s.execute("prefs.reset", &json!({"category": "Performance"})).unwrap();
+    assert_eq!(s.prefs.linux_display_server, "automatic");
+}
+
 /// Selection & Anchor Display › Tolerance, Object Selection by Path Only and Command Click to
 /// Select Objects Behind, and General › Double Click To Isolate, as the Selection tool sees them
 /// (#394).

crates/engine/src/tests_xform.rs

@@ -627,3 +627,32 @@ fn distort_rejects_malformed_coordinates_and_ids_without_editing_art() {
     s.execute("object.distort", &json!({"corners": corners, "from": [0, 0, 100, 100], "ids": [a.0]})).unwrap();
     assert_eq!(undo_len(&s), history + 1);
 }
+
+/// `artboard.move` and `artboard.delete` take several artboards at once (#1139): one undo step
+/// each, the art on each moving with it, and one artboard always left.
+#[test]
+fn several_artboards_move_and_delete_together() {
+    let mut s = session();
+    s.execute("artboard.new", &json!({"x": 1000, "y": 0, "width": 200, "height": 200})).unwrap();
+    s.execute("artboard.new", &json!({"x": 1400, "y": 0, "width": 200, "height": 200})).unwrap();
+    let r = rect(&mut s, 1050.0, 50.0, 50.0, 50.0);
+    let before: Vec<Rect> = s.doc().unwrap().doc.artboards.iter().map(|a| a.rect).collect();
+    let out = s.execute("artboard.move", &json!({"indices": [2, 1], "dx": 10, "dy": 20, "moveArt": true})).unwrap();
+    assert_eq!(out["indices"], json!([1, 2]));
+    let d = &s.doc().unwrap().doc;
+    assert_eq!(d.artboards[0].rect, before[0]);
+    assert_eq!(
+        (d.artboards[1].rect, d.artboards[2].rect),
+        (before[1] + vectorcraft_geom::Vec2::new(10.0, 20.0), before[2] + vectorcraft_geom::Vec2::new(10.0, 20.0))
+    );
+    assert_eq!(d.node(r).unwrap().geometric_bounds().unwrap().x0, 1060.0, "the art on artboard 2 moved with it");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().doc.artboards[2].rect, before[2], "one undo step");
+    for bad in [json!({"indices": [1, 9]}), json!({"indices": []}), json!({"indices": [-1]}), json!({"indices": "1"})] {
+        assert!(s.execute("artboard.move", &json!({"indices": bad["indices"], "dx": 1})).is_err(), "{bad}");
+    }
+    assert!(s.execute("artboard.delete", &json!({"indices": [0, 1, 2]})).is_err(), "one is always left");
+    s.execute("artboard.delete", &json!({"indices": [2, 0]})).unwrap();
+    let d = &s.doc().unwrap().doc;
+    assert_eq!(d.artboards.iter().map(|a| a.rect).collect::<Vec<_>>(), [before[1]]);
+}

crates/engine/tests/command_sweep.rs

@@ -367,6 +367,7 @@ fn structured_junk() {
         ("object.blend.options", json!({"spacing": "distance", "value": -1e308, "orientation": 5})),
         ("object.blend.spine.moveAnchor", json!({"id": 2, "anchor": u64::MAX, "x": 1e308, "y": -1e308, "handle": "sideways"})),
         ("object.blend.spine.addAnchor", json!({"id": u64::MAX, "x": 0, "y": 0})),
+        ("object.blend.spine.reshapeSegment", json!({"id": 2, "segment": u64::MAX, "t": f64::NAN, "dx": 1e308, "dy": -1e308})),
         ("object.blend.spine.removeAnchor", json!({"anchor": -1})),
         ("object.puppetWarp", json!({"rest": true, "pins": [], "moved": []})),
         ("object.puppetWarp", json!({"rest": true, "pins": [[1e308, 0]], "moved": [[0, 0]], "expand": -5})),

crates/geom/src/corners.rs

@@ -1,7 +1,8 @@
-//! Live Corners on any path: the anchors where two straight sides meet at an angle, and the path
-//! with those corners cut round, inverted round or chamfered. Rectangles cut theirs the same way.
+//! Live Corners on any path: the anchors where two sides, straight or curved, meet at an angle,
+//! and the path with those corners cut round, inverted round or chamfered (a curved side trimmed
+//! to what the cut leaves of it). Rectangles cut theirs the same way.
 
-use kurbo::{Point, Vec2};
+use kurbo::{CubicBez, ParamCurve, ParamCurveArclen, ParamCurveDeriv, Point, Vec2};
 
 use crate::path::{Anchor, AnchorKind, PathData, SubPath};
 use crate::shapes::{CornerKind, KAPPA};
@@ -11,39 +12,91 @@ const EPS: f64 = 1e-9;
 /// Sides closer than this to straight on (or folded back), as the sine of their angle, make no corner.
 const MIN_SINE: f64 = 1e-6;
 
-/// A corner Live Corners can cut: an anchor without handles between two straight sides that
-/// meet at an angle.
+/// How closely arc lengths along curved sides are measured (points).
+const ARCLEN_ACCURACY: f64 = 1e-6;
+
+/// A side of a corner: the segment from the corner's anchor to its neighbour, as a cubic leaving
+/// the corner (a straight side has its handles at its ends).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Side {
+    pub curve: CubicBez,
+}
+
+impl Side {
+    /// Is the side straight, its handles on its ends?
+    fn straight(&self) -> bool {
+        self.curve.p1.distance(self.curve.p0) <= EPS && self.curve.p2.distance(self.curve.p3) <= EPS
+    }
+
+    /// The unit direction the side leaves the corner in: towards its first control point not on
+    /// the corner. `None` when the side has no length.
+    fn direction(&self) -> Option<Vec2> {
+        let c = self.curve;
+        let d = [c.p1, c.p2, c.p3].into_iter().map(|q| q - c.p0).find(|d| d.hypot() > EPS)?;
+        let d = d / d.hypot();
+        d.x.is_finite().then_some(d)
+    }
+
+    /// The side's length.
+    fn length(&self) -> f64 {
+        if self.straight() { self.curve.p0.distance(self.curve.p3) } else { self.curve.arclen(ARCLEN_ACCURACY) }
+    }
+
+    /// The parameter `s` along the side from the corner, the point there and the direction the
+    /// side runs on in (away from the corner).
+    fn at_length(&self, s: f64, u: Vec2) -> (f64, Point, Vec2) {
+        let c = self.curve;
+        if self.straight() {
+            let len = c.p0.distance(c.p3);
+            let t = if len > EPS { (s / len).clamp(0.0, 1.0) } else { 0.0 };
+            return (t, c.p0 + u * s, u);
+        }
+        let t = c.inv_arclen(s, ARCLEN_ACCURACY).clamp(0.0, 1.0);
+        let d = c.deriv().eval(t).to_vec2();
+        let dir = if d.hypot() > EPS { d / d.hypot() } else { u };
+        (t, c.eval(t), dir)
+    }
+}
+
+/// A corner Live Corners can cut: an anchor that isn't smooth, where two sides (straight or
+/// curved) meet at an angle (#1144).
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct Corner {
     /// The anchor's index in its path, counting the anchors of every subpath in order.
     pub index: usize,
     /// Where the sides meet.
     pub at: Point,
-    /// Unit directions along the sides: towards the previous anchor, then towards the next one.
+    /// Unit directions the sides leave the corner in: towards the previous anchor, then towards
+    /// the next one.
     pub u: Vec2,
     pub v: Vec2,
-    /// The sides' lengths, in the same order.
+    /// The sides' lengths (along curves), in the same order.
     pub lu: f64,
     pub lv: f64,
+    /// The sides themselves, leaving the corner, in the same order.
+    pub side_u: Side,
+    pub side_v: Side,
 }
 
 impl Corner {
     /// The corner of anchor `i` of `sp`, whose index in the path is `index`; `None` when the
-    /// anchor is an end of an open subpath, has handles or is smooth, when a side curves or has
-    /// no length, or when the sides run straight on.
+    /// anchor is an end of an open subpath or is smooth, when a side has no length, or when the
+    /// sides leave it straight on.
     fn of(sp: &SubPath, i: usize, index: usize) -> Option<Self> {
         let n = sp.anchors.len();
         let (prev, next) = if sp.closed { ((i + n).checked_sub(1)? % n, (i + 1) % n) } else { (i.checked_sub(1)?, i + 1) };
         let (a, prev, next) = (sp.anchors.get(i)?, sp.anchors.get(prev)?, sp.anchors.get(next)?);
-        if a.kind == AnchorKind::Smooth || a.has_in() || a.has_out() || prev.has_out() || next.has_in() {
+        if a.kind == AnchorKind::Smooth {
             return None;
         }
-        let (du, dv) = (prev.p - a.p, next.p - a.p);
-        let (lu, lv) = (du.hypot(), dv.hypot());
+        let side_u = Side { curve: CubicBez::new(a.p, a.h_in, prev.h_out, prev.p) };
+        let side_v = Side { curve: CubicBez::new(a.p, a.h_out, next.h_in, next.p) };
+        let (u, v) = (side_u.direction()?, side_v.direction()?);
+        let (lu, lv) = (side_u.length(), side_v.length());
         if !(lu > EPS && lv > EPS && lu.is_finite() && lv.is_finite()) {
             return None;
         }
-        let c = Self { index, at: a.p, u: du / lu, v: dv / lv, lu, lv };
+        let c = Self { index, at: a.p, u, v, lu, lv, side_u, side_v };
         (c.sin() > MIN_SINE).then_some(c)
     }
 
@@ -92,32 +145,47 @@ impl Corner {
         d.dot(self.u + self.v) * self.sin() / (2.0 + 2.0 * self.cos())
     }
 
-    /// The two anchors replacing the corner when cut with `radius` (> 0, fitted): where the cut
-    /// meets the arriving side, then the leaving one.
-    fn cut(&self, radius: f64, kind: CornerKind) -> [Anchor; 2] {
-        let t = self.setback(radius);
-        let (start, end) = (self.at + self.u * t, self.at + self.v * t);
+    /// The cut of radius `radius` (> 0, fitted): where it meets each side, `setback` along it,
+    /// and the cut's own curve between them, its handles leaving the sides smoothly.
+    fn cut(&self, radius: f64, kind: CornerKind) -> Cut {
+        let s = self.setback(radius);
+        let (tu, start, du) = self.side_u.at_length(s, self.u);
+        let (tv, end, dv) = self.side_v.at_length(s, self.v);
+        let cos = du.dot(dv);
         let (h_out, h_in) = match kind {
-            // An arc of `radius` tangent to both sides, turning by 180° less the angle.
+            // An arc tangent to both sides, turning by 180° less the angle between them there.
             CornerKind::Round => {
-                let h = radius * arc_handle(-self.cos());
-                (start - self.u * h, end - self.v * h)
+                let h = radius * arc_handle(-cos);
+                (start - du * h, end - dv * h)
             }
             // An arc centred on the corner through both ends, spanning the angle.
             CornerKind::InvertedRound => {
-                let h = t * arc_handle(self.cos());
-                (start + square_to(self.u, self.v) * h, end + square_to(self.v, self.u) * h)
+                let h = s * arc_handle(cos);
+                (start + square_to(du, dv) * h, end + square_to(dv, du) * h)
             }
             CornerKind::Chamfer => (start, end),
         };
-        [Anchor { p: start, h_in: start, h_out, kind: AnchorKind::Corner }, Anchor { p: end, h_in, h_out: end, kind: AnchorKind::Corner }]
+        Cut { tu, tv, start, h_out, h_in, end }
     }
 }
 
+/// A corner cut: the parameters where it meets its sides (from the corner), its two new anchors
+/// and the handles between them.
+#[derive(Clone, Copy, Debug)]
+struct Cut {
+    tu: f64,
+    tv: f64,
+    start: Point,
+    h_out: Point,
+    h_in: Point,
+    end: Point,
+}
+
 /// The unit direction square to unit `a`, on `b`'s side.
 fn square_to(a: Vec2, b: Vec2) -> Vec2 {
     let w = b - a * a.dot(b);
-    w / w.hypot()
+    let l = w.hypot();
+    if l > EPS { w / l } else { Vec2::ZERO }
 }
 
 /// The handle length, per unit of radius, of a cubic drawing a circular arc that spans an angle
@@ -126,6 +194,7 @@ fn arc_handle(cos: f64) -> f64 {
     if cos.abs() < 1e-12 {
         return KAPPA;
     }
+    let cos = cos.clamp(-1.0, 1.0);
     let (sin_half, cos_half) = (((1.0 - cos) / 2.0).max(0.0).sqrt(), ((1.0 + cos) / 2.0).max(0.0).sqrt());
     4.0 / 3.0 * sin_half / (1.0 + cos_half)
 }
@@ -143,24 +212,55 @@ pub fn path_corners(path: &PathData) -> Vec<Corner> {
 
 /// `path` with each of its corners ([`path_corners`]) cut by the radius in `radii` and the kind in
 /// `kinds` at its anchor index (missing: 0 and round), each radius no larger than fits
-/// ([`Corner::fitted`]). A cut corner becomes two anchors; a closed subpath whose first corner
-/// is cut starts where that cut ends, so the cut closes it. Also returns, per subpath, the
-/// anchor index in `path` each anchor comes from.
+/// ([`Corner::fitted`]). A cut corner becomes two anchors, and a curved side between corners is
+/// trimmed to what is left of it; a closed subpath whose first corner is cut starts where that
+/// cut ends, so the cut closes it. Also returns, per subpath, the anchor index in `path` each
+/// anchor comes from.
 pub fn cut_corners(path: &PathData, radii: &[f64], kinds: &[CornerKind]) -> (PathData, Vec<Vec<usize>>) {
     let corners = path_corners(path);
     let mut corners = corners.iter().peekable();
     let (mut subpaths, mut sources) = (Vec::with_capacity(path.subpaths.len()), Vec::with_capacity(path.subpaths.len()));
     let mut first = 0;
     for sp in &path.subpaths {
-        let (mut anchors, mut from) = (Vec::with_capacity(sp.anchors.len()), Vec::with_capacity(sp.anchors.len()));
+        let n = sp.anchors.len();
+        // The cut of each anchor, if any.
+        let cuts: Vec<Option<Cut>> = (0..n)
+            .map(|i| {
+                let index = first + i;
+                let c = corners.next_if(|c| c.index == index)?;
+                let radius = c.fitted(radii.get(index).copied().unwrap_or(0.0));
+                (radius > EPS).then(|| c.cut(radius, kinds.get(index).copied().unwrap_or_default()))
+            })
+            .collect();
+        // Each segment from anchor j, trimmed to the part the cuts at its ends leave: its handles
+        // (out of its first anchor, into its last), `None` when it is untouched.
+        let trimmed: Vec<Option<(Point, Point)>> = (0..n)
+            .map(|j| {
+                let k = (j + 1) % n;
+                let (a, b) = (sp.anchors.get(j)?, sp.anchors.get(k)?);
+                let (from, to) = (cuts.get(j).copied().flatten(), cuts.get(k).copied().flatten());
+                if (from.is_none() && to.is_none()) || (k == 0 && !sp.closed) {
+                    return None;
+                }
+                // A straight segment stays straight, its handles on its ends.
+                if !a.has_out() && !b.has_in() {
+                    return Some((from.map_or(a.p, |c| c.end), to.map_or(b.p, |c| c.start)));
+                }
+                let (s0, s1) = (from.map_or(0.0, |c| c.tv), to.map_or(1.0, |c| 1.0 - c.tu));
+                let sub = CubicBez::new(a.p, a.h_out, b.h_in, b.p).subsegment(s0..s1.max(s0));
+                Some((sub.p1, sub.p2))
+            })
+            .collect();
+        let (mut anchors, mut from) = (Vec::with_capacity(n), Vec::with_capacity(n));
         let mut closing = None;
         for (i, a) in sp.anchors.iter().enumerate() {
             let index = first + i;
-            let corner = corners.next_if(|c| c.index == index);
-            let radius = corner.map_or(0.0, |c| c.fitted(radii.get(index).copied().unwrap_or(0.0)));
-            match corner {
-                Some(c) if radius > EPS => {
-                    let [start, end] = c.cut(radius, kinds.get(index).copied().unwrap_or_default());
+            let h_in = trimmed.get((i + n - 1) % n).copied().flatten().map_or(a.h_in, |(_, h)| h);
+            let h_out = trimmed.get(i).copied().flatten().map_or(a.h_out, |(h, _)| h);
+            match cuts.get(i).copied().flatten() {
+                Some(c) => {
+                    let start = Anchor { p: c.start, h_in, h_out: c.h_out, kind: AnchorKind::Corner };
+                    let end = Anchor { p: c.end, h_in: c.h_in, h_out, kind: AnchorKind::Corner };
                     if i == 0 && sp.closed {
                         closing = Some(start);
                     } else {
@@ -170,8 +270,8 @@ pub fn cut_corners(path: &PathData, radii: &[f64], kinds: &[CornerKind]) -> (Pat
                     anchors.push(end);
                     from.push(index);
                 }
-                _ => {
-                    anchors.push(*a);
+                None => {
+                    anchors.push(Anchor { h_in, h_out, ..*a });
                     from.push(index);
                 }
             }
@@ -180,7 +280,7 @@ pub fn cut_corners(path: &PathData, radii: &[f64], kinds: &[CornerKind]) -> (Pat
             anchors.push(a);
             from.push(first);
         }
-        first += sp.anchors.len();
+        first += n;
         subpaths.push(SubPath::new(anchors, sp.closed));
         sources.push(from);
     }
@@ -246,11 +346,7 @@ mod tests {
             false,
         ));
         assert_eq!(path_corners(&open).iter().map(|c| c.index).collect::<Vec<_>>(), [2, 3]);
-        // A curve on either side, or handles on the anchor, leave it alone.
-        let mut sp = SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 100.0), Point::new(0.0, 100.0)], true);
-        sp.anchors[1].h_out = Point::new(110.0, 10.0);
-        let p = PathData::single(sp);
-        assert_eq!(path_corners(&p).iter().map(|c| c.index).collect::<Vec<_>>(), [0, 3]);
+        // Smooth anchors aren't corners.
         assert!(path_corners(&shapes::ellipse(Rect::new(0.0, 0.0, 10.0, 10.0))).is_empty());
         // A second subpath counts on from the first one's anchors.
         let two = PathData::new(vec![
@@ -262,6 +358,49 @@ mod tests {
         assert_eq!(cut.anchor_count(), 7);
     }
 
+    /// The square `0..100` with its right side bulging out as a curve (#1144).
+    fn bulging_square() -> PathData {
+        let mut sp = SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 100.0), Point::new(0.0, 100.0)], true);
+        sp.anchors[1].h_out = Point::new(140.0, 30.0);
+        sp.anchors[2].h_in = Point::new(140.0, 70.0);
+        PathData::single(sp)
+    }
+
+    /// Corners where a curve meets a line are cut too: the cut ends on the path, leaves both
+    /// sides smoothly, and what is left of the curve still follows it (#1144).
+    #[test]
+    fn corners_next_to_curves_are_cut_along_them() {
+        let path = bulging_square();
+        let corners = path_corners(&path);
+        assert_eq!(corners.iter().map(|c| c.index).collect::<Vec<_>>(), [0, 1, 2, 3]);
+        let side = kurbo::CubicBez::new(Point::new(100.0, 0.0), Point::new(140.0, 30.0), Point::new(140.0, 70.0), Point::new(100.0, 100.0));
+        // The curved side is longer than its chord, and limits its corners by its length.
+        assert!(corners[1].lv > 100.0 + 1.0);
+        let (cut, from) = cut_corners(&path, &[10.0; 4], &[]);
+        assert_eq!(from, [vec![0, 1, 1, 2, 2, 3, 3, 0]]);
+        let sp = &cut.subpaths[0];
+        let on_side = |p: Point| (0..=1000).map(|i| side.eval(f64::from(i) / 1000.0).distance(p)).fold(f64::MAX, f64::min);
+        // Corner 1's cut ends on the curve and corner 2's starts on it, and the trimmed curve
+        // between them stays on the original one.
+        let (a, b) = (sp.anchors[2], sp.anchors[3]);
+        assert!(on_side(a.p) < 0.1 && on_side(b.p) < 0.1);
+        let trimmed = kurbo::CubicBez::new(a.p, a.h_out, b.h_in, b.p);
+        for t in [0.25, 0.5, 0.75] {
+            assert!(on_side(trimmed.eval(t)) < 0.1);
+        }
+        // Every cut leaves its sides smoothly: each anchor's handles are in line.
+        for (i, x) in sp.anchors.iter().enumerate() {
+            let (into, out) = if x.has_in() && x.has_out() {
+                (x.p - x.h_in, x.h_out - x.p)
+            } else if x.has_out() {
+                (x.p - sp.anchors[(i + sp.anchors.len() - 1) % sp.anchors.len()].p, x.h_out - x.p)
+            } else {
+                (x.h_in - x.p, x.p - sp.anchors[(i + 1) % sp.anchors.len()].p)
+            };
+            assert!(into.normalize().cross(out.normalize()).abs() < 1e-6 && into.dot(out) > 0.0, "anchor {i}");
+        }
+    }
+
     /// Inverted round and chamfer cuts end where the round one does, at any angle.
     #[test]
     fn kinds_share_their_ends() {
@@ -272,8 +411,8 @@ mod tests {
         assert_eq!(ends(CornerKind::Chamfer), round);
         // The inverted arc stays on the circle about the corner.
         let c = path_corners(&star)[0];
-        let [s, e] = c.cut(3.0, CornerKind::InvertedRound);
-        let bez = kurbo::CubicBez::new(s.p, s.h_out, e.h_in, e.p);
+        let cut = c.cut(3.0, CornerKind::InvertedRound);
+        let bez = kurbo::CubicBez::new(cut.start, cut.h_out, cut.h_in, cut.end);
         let r = c.setback(3.0);
         for t in [0.25, 0.5, 0.75] {
             use kurbo::ParamCurve;

crates/geom/src/hit.rs

@@ -66,7 +66,10 @@ pub fn stroke_contains(path: &BezPath, width: f64, tol: f64, p: Point) -> bool {
     quick.contains(p) && distance_to_outline(path, p) <= width / 2.0 + tol
 }
 
-/// Does the path intersect (or lie inside) the rect? Used for marquee selection.
+/// Does the path touch the rect: an anchor inside it, or a segment crossing its edges? Used for
+/// marquee selection, which (as in Illustrator) needs the path itself: a rect wholly inside a
+/// filled shape doesn't touch it, so a marquee drawn over a background picks only what is on it
+/// (#1103).
 pub fn intersects_rect(path: &PathData, r: Rect) -> bool {
     let Some(b) = path.bounds() else { return false };
     if b.intersect(r).area() <= 0.0 && !(b.width() == 0.0 || b.height() == 0.0) {
@@ -83,16 +86,7 @@ pub fn intersects_rect(path: &PathData, r: Rect) -> bool {
         kurbo::Line::new((r.x1, r.y1), (r.x0, r.y1)),
         kurbo::Line::new((r.x0, r.y1), (r.x0, r.y0)),
     ];
-    let bp = path.to_bezpath();
-    for seg in bp.segments() {
-        for e in &edges {
-            if !seg.intersect_line(*e).is_empty() {
-                return true;
-            }
-        }
-    }
-    // Rect entirely inside a closed shape counts as touching it.
-    path.is_closed() && fill_contains(&bp, FillRule::NonZero, r.center())
+    path.to_bezpath().segments().any(|seg| edges.iter().any(|e| !seg.intersect_line(*e).is_empty()))
 }
 
 #[cfg(test)]
@@ -152,8 +146,10 @@ mod tests {
         assert!(!intersects_rect(&p, Rect::new(20.0, 20.0, 30.0, 30.0)));
         // corner region of the bbox that misses the ellipse outline
         assert!(!intersects_rect(&p, Rect::new(0.0, 0.0, 0.5, 0.5)));
-        // fully inside
-        assert!(intersects_rect(&p, Rect::new(4.0, 4.0, 6.0, 6.0)));
+        // Wholly inside the shape, touching neither its anchors nor its outline (#1103).
+        assert!(!intersects_rect(&p, Rect::new(4.0, 4.0, 6.0, 6.0)));
+        // Around the whole shape.
+        assert!(intersects_rect(&p, Rect::new(-1.0, -1.0, 11.0, 11.0)));
         // crossing a line
         let l = shapes::line(Point::new(0.0, 0.0), Point::new(10.0, 10.0));
         assert!(intersects_rect(&l, Rect::new(4.0, 0.0, 6.0, 10.0)));

crates/geom/src/path.rs

@@ -252,6 +252,24 @@ impl SubPath {
             _ => a,
         }
     }
+    /// Bend segment `seg` so its point at `t` moves by `dv`: both inner control points move by
+    /// dv / 3t(1-t), since B(t) moves by 3t(1-t) times that. A smooth anchor stays smooth: its other
+    /// handle turns with the moved one. False when there is no such segment.
+    pub fn bend_segment(&mut self, seg: usize, t: f64, dv: kurbo::Vec2) -> bool {
+        let n = self.anchors.len();
+        if seg >= self.segment_count() || n == 0 {
+            return false;
+        }
+        let v = dv / (3.0 * t * (1.0 - t));
+        if let Some(a) = self.anchors.get_mut(seg % n) {
+            a.set_handle(true, a.h_out + v, false);
+        }
+        if let Some(b) = self.anchors.get_mut((seg + 1) % n) {
+            b.set_handle(false, b.h_in + v, false);
+        }
+        true
+    }
+
     /// Split segment `seg` at parameter `t`, inserting a new anchor. Returns the new anchor index.
     pub fn insert_anchor(&mut self, seg: usize, t: f64) -> usize {
         let n = self.anchors.len();

crates/mcp/src/tests_conventions.rs

@@ -55,6 +55,18 @@ fn conventions_commands_batch_and_bounded_preview() {
         assert_eq!(p["failed"], 1);
         assert_eq!(p["completed"], total - 1);
     }
+    // atomic: the whole batch is one undo step, named by `label` (#1163).
+    let undo_steps = |s: &mut Server| payload(&call(s, "doc_inspect", json!({"depth":0})))["history"].as_array().map_or(0, Vec::len);
+    let before = undo_steps(&mut s);
+    let two = json!([{"id":"shape.rectangle","params":{"x":0,"y":0,"width":5,"height":5}}, {"id":"shape.ellipse","params":{"x":9,"y":0,"width":5,"height":5}}]);
+    let r = call(&mut s, "command_batch", json!({"steps":two,"atomic":true,"label":"Agent build"}));
+    assert_eq!(r["isError"], false, "{r}");
+    assert_eq!(undo_steps(&mut s), before + 1);
+    assert_eq!(payload(&call(&mut s, "run_command", json!({"command":"edit.undo"})))["undone"], "Agent build");
+    assert_eq!(undo_steps(&mut s), before);
+    for bad in [json!({"steps":two,"label":"x"}), json!({"steps":two,"atomic":"yes"}), json!({"steps":two,"atomic":true,"label":""})] {
+        assert_eq!(call(&mut s, "command_batch", bad.clone())["isError"], true, "{bad}");
+    }
     let before = call(&mut s, "doc_inspect", json!({}));
     let r = call(&mut s, "render_preview", json!({"max_side":64}));
     assert_eq!(r["isError"], false, "{r}");
@@ -65,6 +77,17 @@ fn conventions_commands_batch_and_bounded_preview() {
     for max in [json!(0), json!(4097), json!("64")] {
         assert_eq!(call(&mut s, "render_preview", json!({"max_side":max}))["isError"], true);
     }
+    // Another artboard, three times wider than tall, previews by its index (#1163).
+    let r = call(&mut s, "run_command", json!({"command":"artboard.new","params":{"x":2000,"y":0,"width":300,"height":100}}));
+    assert_eq!(r["isError"], false, "{r}");
+    let r = call(&mut s, "render_preview", json!({"max_side":60,"artboard":1}));
+    assert_eq!(r["isError"], false, "{r}");
+    let png = vectorcraft_format::base64_decode(r["content"][0]["data"].as_str().unwrap()).unwrap();
+    let img = image::load_from_memory(&png).unwrap();
+    assert_eq!((img.width(), img.height()), (60, 20));
+    for board in [json!(2), json!(-1), json!("1")] {
+        assert_eq!(call(&mut s, "render_preview", json!({"artboard":board}))["isError"], true, "{board}");
+    }
     for name in ["ui_inspect", "ui_screenshot"] {
         assert_eq!(call(&mut s, name, json!({}))["isError"], true);
     }

crates/mcp/src/tools.rs

@@ -96,9 +96,9 @@ pub fn tool_definitions() -> Vec<Value> {
         tool(
             "command_batch",
             "Run several commands",
-            "Run steps in order; each edit is its own undo step. A param string that is exactly \"$N.path\" (N: 0-based step index) or \"$last.path\" takes that value from an earlier step's result, e.g. {\"id\":\"$1.id\"}; \"$$\" starts a literal \"$\". Returns completed, failed and results. Stops on the first error by default.",
+            "Run steps in order; each edit is its own undo step, or with atomic:true the whole batch is one (named `label`, else after its first edit). A param string that is exactly \"$N.path\" (N: 0-based step index) or \"$last.path\" takes that value from an earlier step's result, e.g. {\"id\":\"$1.id\"}; \"$$\" starts a literal \"$\". Returns completed, failed and results. Stops on the first error by default.",
             obj(
-                json!({"steps": {"type":"array", "items":obj(json!({"id":string("Command id"),"params":{"type":"object"}}), &["id"])}, "stop_on_error":{"type":"boolean", "default":true}}),
+                json!({"steps": {"type":"array", "items":obj(json!({"id":string("Command id"),"params":{"type":"object"}}), &["id"])}, "stop_on_error":{"type":"boolean", "default":true}, "atomic":{"type":"boolean", "default":false, "description":"Make the batch's edits one undo step (needs an open document)"}, "label":string("The undo step's name with atomic")}),
                 &["steps"],
             ),
             false,
@@ -113,8 +113,11 @@ pub fn tool_definitions() -> Vec<Value> {
         tool(
             "render_preview",
             "Render a preview",
-            "Render the first artboard as inline PNG without changing the document. max_side defaults to 1024, limited to 1..4096.",
-            obj(json!({"max_side":{"type":"integer","minimum":1,"maximum":4096}}), &[]),
+            "Render an artboard (default the first) as inline PNG without changing the document. max_side defaults to 1024, limited to 1..4096.",
+            obj(
+                json!({"max_side":{"type":"integer","minimum":1,"maximum":4096},"artboard":{"type":"integer","minimum":0,"description":"0-based artboard (default 0)"}}),
+                &[],
+            ),
             true,
         ),
         tool("ui_inspect", "Inspect the interface", "Inspect the connected desktop interface; returns a tool error in headless mode.", empty(), true),
@@ -200,7 +203,7 @@ pub fn tool_definitions() -> Vec<Value> {
         tool(
             "draw_path",
             "Draw path",
-            "Create a path from points ([[x,y],…] or [{x,y,in?:[x,y],out?:[x,y]},…] with Bézier handles) or SVG path data `d`, then apply optional paint. Returns the new object id.",
+            "Create a path from points ([[x,y],…] or [{x,y,in?:[x,y],out?:[x,y]},…] with Bézier handles) or SVG path data `d`, then apply optional paint. Omitted paint fields inherit the current new-art appearance (initially white fill and 1 pt black stroke). For a filled path without an outline, pass an explicit fill and stroke:\"none\". Returns the new object id.",
             obj(
                 json!({
                     "points": {"type": "array", "description": "Anchors: [x,y] pairs or {x, y, in?, out?, smooth?} objects", "items": {"anyOf": [{"type": "array", "items": {"type": "number"}, "minItems": 2}, {"type": "object"}]}},
@@ -217,7 +220,7 @@ pub fn tool_definitions() -> Vec<Value> {
         tool(
             "draw_shape",
             "Draw shape",
-            "Create a live shape and apply optional paint. rectangle/ellipse: x, y, width, height (rectangle: radius = corner radius). polygon: cx, cy, radius, sides. star: cx, cy, radius1, radius2, points. line: x1, y1, x2, y2. Returns the new object id.",
+            "Create a live shape and apply optional paint. rectangle/ellipse: x, y, width, height (rectangle: radius = corner radius). polygon: cx, cy, radius, sides. star: cx, cy, radius1, radius2, points. line: x1, y1, x2, y2. Omitted paint fields inherit the current new-art appearance (initially white fill and 1 pt black stroke); lines start with no fill and a visible stroke. For a filled shape without an outline, pass an explicit fill and stroke:\"none\". Returns the new object id.",
             obj(
                 json!({
                     "shape": {"type": "string", "enum": ["rectangle", "ellipse", "polygon", "star", "line"]},
@@ -329,7 +332,7 @@ pub fn tool_definitions() -> Vec<Value> {
         tool(
             "export",
             "Export",
-            "Export the active document with the engine's document.export (the same bytes in the app and headless), in any format of the `format` enum: vectors (svg/svgz with the artboard as viewBox, eps, dxf, emf, wmf), pdf (one page per artboard: all, or `artboard` / `range`), rasters (one rendered artboard: png, jpg, webp, gif, png8 as an indexed .png, tiff, bmp, tga, psd with its layers), txt (the stories, back to front), vectorcraft or template (a native copy or template; the document keeps its path). run_command document.formats lists each format's options. `selection: true` exports only the selected objects, cropped to their bounds. Template layers are left out; live effects are kept (geometry baked, SVG filters for shadows/glows/blur). Without `path` the bytes come back as dataBase64.",
+            "Export the active document with the engine's document.export (the same bytes in the app and headless), in any format of the `format` enum: vectors (svg/svgz with the artboard as viewBox, eps, dxf, emf, wmf), pdf (one page per artboard: all, or `artboard` / `range`), rasters (one rendered artboard: png, jpg, webp, gif, png8 as an indexed .png, tiff, bmp, tga, psd with its layers), txt (the stories, back to front), vectorcraft or template (a native copy or template; the document keeps its path). run_command document.formats lists each format's options. For SVG/SVGZ, top-level `outlineText: true` writes text as paths; DXF takes it too (its type is outlined anyway unless `preserve: editability`). PDF instead uses `options.advanced.outlineText: true`, default false (live text). `selection: true` exports only the selected objects, cropped to their bounds. Template layers are left out; live effects are kept (geometry baked, SVG filters for shadows/glows/blur). Without `path` the bytes come back as dataBase64.",
             obj(
                 json!({
                     "format": {"type": "string", "enum": FORMATS.iter().filter(|f| f.write).map(|f| f.id).collect::<Vec<_>>(), "description": "Default: from the path's extension"},
@@ -338,8 +341,8 @@ pub fn tool_definitions() -> Vec<Value> {
                     "artboard": {"type": "integer", "minimum": 0, "description": "0-based artboard (default: the first; PDF default: all)"},
                     "range": string("1-based artboards such as \"1-3, 5\" (PDF: one page each; other formats take one)"),
                     "selection": {"type": "boolean", "description": "Export only the selection, cropped to it"},
-                    "outlineText": {"type": "boolean", "description": "SVG: text as outlines (viewable without the fonts)"},
-                    "options": {"type": "object", "description": "More format options, passed through (see run_command document.formats), e.g. {\"quality\": 80} for jpg"},
+                    "outlineText": {"type": "boolean", "description": "SVG/SVGZ: true writes text as outlines (viewable without the fonts). DXF takes it too (type outlined anyway unless preserve: editability). PDF uses options.advanced.outlineText instead (default false: live text)"},
+                    "options": {"type": "object", "description": "More format options, passed through (see run_command document.formats), e.g. {\"quality\": 80} for jpg or {\"advanced\": {\"outlineText\": true}} for PDF text as outlines (default false: live text)"},
                 }),
                 &[],
             ),
@@ -902,6 +905,16 @@ fn command_batch(b: &mut dyn Backend, a: &Args) -> Result<ToolResult, String> {
         None => true,
         Some(v) => v.as_bool().ok_or("`stop_on_error` must be a boolean")?,
     };
+    let atomic = match a.get("atomic") {
+        None => false,
+        Some(v) => v.as_bool().ok_or("`atomic` must be a boolean")?,
+    };
+    if atomic {
+        let label = a.get("label").cloned().unwrap_or(Value::Null);
+        b.call("engine.execute", json!({"command":"edit.undoGroup.begin","params":{"label":label}}))?;
+    } else if a.get("label").is_some() {
+        return Err("`label` names the undo step of an atomic batch: give atomic:true too".into());
+    }
     let (mut completed, mut failed, mut results) = (0, 0, Vec::new());
     // Each step's result (null for a failed one), for later steps' `"$N.path"` references.
     let mut values: Vec<Value> = vec![];
@@ -936,6 +949,10 @@ fn command_batch(b: &mut dyn Backend, a: &Args) -> Result<ToolResult, String> {
             }
         }
     }
+    // The steps that ran stay, as one undo step.
+    if atomic {
+        b.call("engine.execute", json!({"command":"edit.undoGroup.end","params":{}}))?;
+    }
     let mut r = ToolResult::json(&json!({"completed":completed,"failed":failed,"results":results}));
     r.is_error = failed > 0;
     Ok(r)
@@ -946,8 +963,13 @@ fn render_preview(b: &mut dyn Backend, a: &Args) -> Result<ToolResult, String> {
         None => 1024,
         Some(v) => v.as_u64().filter(|v| (1..=4096).contains(v)).ok_or("`max_side` must be an integer in 1..4096")?,
     };
+    let index = match a.get("artboard") {
+        None => 0,
+        Some(v) => v.as_u64().ok_or("`artboard` must be a 0-based artboard index")?,
+    };
     let doc = b.call("document.inspect", json!({"depth":0}))?;
-    let board = doc.get("artboards").and_then(Value::as_array).and_then(|v| v.first()).ok_or("no such artboard")?;
+    let board =
+        doc.get("artboards").and_then(Value::as_array).and_then(|v| v.get(usize::try_from(index).ok()?)).ok_or(format!("no artboard {index}"))?;
     let width = board.get("width").and_then(Value::as_f64).ok_or("artboard has no width")?;
     let height = board.get("height").and_then(Value::as_f64).ok_or("artboard has no height")?;
     if !width.is_finite() || !height.is_finite() || width <= 0.0 || height <= 0.0 {
@@ -959,7 +981,7 @@ fn render_preview(b: &mut dyn Backend, a: &Args) -> Result<ToolResult, String> {
     if width.max(height) * scale > 4096.0 {
         return Err("artboard is too large for a bounded preview".into());
     }
-    let r = b.call("ui.render", json!({"scale":scale}))?;
+    let r = b.call("ui.render", json!({"scale":scale, "artboard": index}))?;
     let encoded = r.get("pngBase64").and_then(Value::as_str).ok_or("renderer returned no image")?;
     let png = vectorcraft_format::base64_decode(encoded).ok_or("renderer returned bad base64")?;
     let img = image::load_from_memory_with_format(&png, image::ImageFormat::Png).map_err(|e| format!("read preview: {e}"))?;

crates/render/src/lib.rs

@@ -1186,6 +1186,9 @@ impl Renderer {
     }
 
     fn draw_shape(&mut self, ctx: &mut RenderContext, f: &Frame, n: &Node, bp: &BezPath, rule: FillRule) {
+        if !drawable(bp, f.view, n) {
+            return;
+        }
         if fx::has_fx(n) {
             return self.draw_shape_fx(ctx, f, n, bp, rule);
         }
@@ -1700,6 +1703,21 @@ fn mask_value(r: u8, g: u8, b: u8, a: u8, clip: bool, invert: bool) -> u8 {
     (l.clamp(0.0, 1.0) * 255.0 + 0.5) as u8
 }
 
+/// Most pixels from the origin that a shape handed to the rasterizer may reach, or a stroke be
+/// wide. A document's art stays within 4 million points, 2.6 billion pixels at the closest zoom.
+/// Geometry far beyond that (from a malformed file) makes vello_cpu panic on a worker thread or ask
+/// for more memory than there is, either of which ends the app: it is left undrawn.
+const MAX_DEVICE: f64 = 1e10;
+
+/// Can shape `bp` of `n` be drawn through `view`: its control points (finite) within
+/// [`MAX_DEVICE`] pixels, and its visible strokes no wider?
+fn drawable(bp: &BezPath, view: Affine, n: &Node) -> bool {
+    let b = view.transform_rect_bbox(bp.control_box());
+    let scale = view.determinant().abs().sqrt();
+    let widest = n.appearance.items.iter().filter_map(|i| if let AppearanceItem::Stroke(st) = i { Some(st.width) } else { None }).fold(0.0, f64::max);
+    [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite() && v.abs() <= MAX_DEVICE) && (widest * scale).is_finite() && widest * scale <= MAX_DEVICE
+}
+
 /// A render context on the calling thread. vello_cpu's `RenderContext::new` defaults to a
 /// multithreaded dispatcher, which panics on filter effects (glows, shadows, blur).
 pub(crate) fn single_threaded_context(w: u16, h: u16) -> RenderContext {

crates/render/src/paint.rs

@@ -43,7 +43,9 @@ pub(crate) fn set_paint(ctx: &mut RenderContext, p: &Paint, bounds: Rect, f: &Fr
                     peniko::Gradient::new_linear(s, e).with_stops(stops.as_slice())
                 }
             };
-            ctx.set_paint(grad);
+            // Colour and opacity blend each on its own, as the model samples them and as the PDF
+            // and SVG exports draw them (peniko's default premultiplies).
+            ctx.set_paint(grad.with_interpolation_alpha_space(peniko::InterpolationAlphaSpace::Unpremultiplied));
             true
         }
         Paint::Pattern { pattern, xf } => crate::pattern::set_pattern_paint(ctx, pattern, *xf, f),

crates/render/tests/gradient_alpha.rs

@@ -0,0 +1,58 @@
+//! Gradient stops with opacity: colour and opacity blend each on its own (not premultiplied), as
+//! the model samples them ([`Gradient::sample`]) and as the SVG and PDF exports draw them. The colour
+//! of a transparent stop counts: red fading into transparent black darkens as it fades.
+
+use vectorcraft_color::{Color, Gradient, GradientGeom, GradientKind, GradientPaint, GradientStop, Paint};
+use vectorcraft_doc::{Appearance, Document};
+use vectorcraft_geom::{Point, Rect, shapes};
+use vectorcraft_testkit::fixtures::DocBuilder;
+use vectorcraft_testkit::raster::{Image, render_view};
+
+/// A 100 pt square filled with `gradient` on `geom`.
+fn filled(gradient: &Gradient, geom: GradientGeom) -> Document {
+    let mut gp = GradientPaint::new(gradient.clone());
+    gp.geom = Some(geom);
+    let mut b = DocBuilder::new(100.0, 100.0);
+    b.path(shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 100.0)), Appearance::basic(Paint::Gradient(Box::new(gp)), Paint::None, 0.0), |_| {});
+    b.build()
+}
+
+fn stop(offset: f32, color: Color, opacity: f32, midpoint: f32) -> GradientStop {
+    GradientStop { opacity, midpoint, ..GradientStop::new(offset, color) }
+}
+
+/// Every 7th pixel is the model's colour at its opacity over white (pixel centres).
+fn assert_follows_model(img: &Image, gradient: &Gradient, geom: &GradientGeom) {
+    for y in (3..100).step_by(7) {
+        for x in (3..100).step_by(7) {
+            let t = geom.param_at(gradient.kind, Point::new(x as f64 + 0.5, y as f64 + 0.5)).clamp(0.0, 1.0);
+            let (c, o) = gradient.sample(t as f32);
+            let want = c.to_rgb().map(|v| ((v * o + 1.0 - o) * 255.0).round() as u8);
+            let got = img.over_white(x, y);
+            let off = (0..3).map(|k| got[k].abs_diff(want[k])).max().unwrap_or(0);
+            assert!(off <= 4, "{:?} ({x},{y}) t={t:.3}: got {got:?}, want {want:?}", gradient.kind);
+        }
+    }
+}
+
+#[test]
+fn transparent_stops_blend_colour_and_opacity_apart() {
+    let red = Color::rgb(1.0, 0.0, 0.0);
+    let fades = [
+        // Transparent white into black: mid-grey at half opacity halfway, light over white.
+        vec![stop(0.0, Color::WHITE, 0.0, 0.5), stop(1.0, Color::BLACK, 1.0, 0.5)],
+        // Red into transparent black: darker red as it fades.
+        vec![stop(0.0, red, 1.0, 0.5), stop(1.0, Color::BLACK, 0.0, 0.5)],
+        // A midpoint off centre (drawn as an extra stop) follows the same rule.
+        vec![stop(0.0, red, 1.0, 0.3), stop(1.0, Color::BLACK, 0.0, 0.5)],
+    ];
+    for stops in fades {
+        for (kind, geom) in [
+            (GradientKind::Linear, GradientGeom { start: Point::new(0.0, 50.0), end: Point::new(100.0, 50.0), aspect: 1.0, focal: None }),
+            (GradientKind::Radial, GradientGeom { start: Point::new(50.0, 50.0), end: Point::new(100.0, 50.0), aspect: 1.0, focal: None }),
+        ] {
+            let gradient = Gradient { kind, stops: stops.clone() };
+            assert_follows_model(&render_view(&filled(&gradient, geom), 100, 100), &gradient, &geom);
+        }
+    }
+}

crates/render/tests/stroke_geometry.rs

@@ -181,3 +181,30 @@ fn a_head_past_the_end_counts_in_the_visual_bounds_and_is_never_culled() {
     let img = render_region(&d, Rect::new(83.0, 40.0, 100.0, 60.0), S);
     assert!(img.ink() > 0, "the head is drawn");
 }
+
+/// A shape far beyond any document's reach (from a malformed file) is left undrawn instead of
+/// making the rasterizer panic on a worker thread or ask for terabytes, which would end the app;
+/// the art next to it still draws.
+#[test]
+fn shapes_far_beyond_the_page_are_left_undrawn_without_crashing() {
+    let mut d = Document::new(100.0, 100.0);
+    let layer = d.layers[0].id;
+    let mut far = vectorcraft_geom::BezPath::new();
+    far.move_to((13607718712.4, 13.2));
+    far.curve_to((-0.03, 720.96), (-3.08e17, -8.36e20), (-3.35e20, -1.0));
+    far.close_path();
+    let black =
+        || Appearance { items: vec![AppearanceItem::Fill(vectorcraft_doc::FillLayer::new(Paint::solid(Color::BLACK)))], ..Default::default() };
+    for (path, app) in [
+        (vectorcraft_geom::PathData::from_bezpath(&far), black()),
+        (shapes::rectangle(Rect::new(10.0, 10.0, 30.0, 30.0)), black()),
+        (shapes::rectangle(Rect::new(50.0, 50.0, 60.0, 60.0)), stroked(1e30, |_| {})),
+    ] {
+        let id = d.alloc_id();
+        d.insert(Some(layer), usize::MAX, vectorcraft_doc::Node::path(id, path, app)).unwrap();
+    }
+    let img = Renderer::new().render_region(&d, Rect::new(0.0, 0.0, 100.0, 100.0), 1.0, true);
+    let px = |x: usize, y: usize| img.pixels.get((y * img.width as usize + x) * 4).copied().unwrap();
+    assert_eq!(px(20, 20), 0, "the rectangle next to them draws");
+    assert_eq!(px(90, 5), 255, "nothing of the far shape or the huge stroke");
+}

crates/svg/src/import.rs

@@ -965,8 +965,9 @@ impl Importer {
             nodes = rest;
         }
         let mut children: Vec<Arc<Node>> = nodes.iter().filter_map(|c| self.node(c, ts)).map(Arc::new).collect();
+        // Mask art that is all hidden draws nothing: that is an empty mask, not no mask (black all
+        // over when clipped, white when not, inverted when the mask is).
         let art = match children.len() {
-            0 => return None,
             1 => Arc::unwrap_or_clone(children.pop()?),
             _ => self.named("", NodeKind::Group { children, clip: false }),
         };

crates/svg/tests/mask_options.rs

@@ -8,6 +8,7 @@ use vectorcraft_color::{Color, Paint};
 use vectorcraft_doc::{Appearance, Document, Node, OpacityMask};
 use vectorcraft_geom::{Rect, shapes};
 use vectorcraft_svg::{ExportOptions, export, import_with_report};
+use vectorcraft_testkit::raster::{Image, render_artboard};
 
 /// A red square masked by white art over its left half.
 fn masked(clip: bool, invert: bool) -> Document {
@@ -67,3 +68,37 @@ fn foreign_masks_keep_their_art() {
     assert!(m.clip && !m.invert);
     assert_eq!(m.art.children().map(|c| c.len()), Some(2));
 }
+
+/// `svg` drawn by resvg, `w`×`h` on white.
+fn resvg_render(svg: &str, w: u32, h: u32) -> Image {
+    let tree = resvg::usvg::Tree::from_str(svg, &resvg::usvg::Options::default()).expect("parse");
+    let mut pm = resvg::tiny_skia::Pixmap::new(w, h).unwrap();
+    pm.fill(resvg::tiny_skia::Color::WHITE);
+    resvg::render(&tree, resvg::tiny_skia::Transform::identity(), &mut pm.as_mut());
+    Image { width: w, height: h, rgba: pm.data().to_vec() }
+}
+
+#[test]
+fn a_mask_whose_art_is_all_hidden_hides_its_object() {
+    // Hidden mask art draws nothing: the mask is black all over and the red square doesn't show,
+    // as resvg draws the file. The square keeps its (empty) mask, so it can still be edited.
+    for art in [
+        r#"<rect width="100" height="100" fill="white" visibility="hidden"/>"#,
+        r#"<g visibility="hidden"><rect width="100" height="100" fill="white"/></g>"#,
+    ] {
+        let svg = format!(
+            r#"<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100">
+              <mask id="m" maskUnits="userSpaceOnUse" x="0" y="0" width="100" height="100">{art}</mask>
+              <g mask="url(#m)"><rect width="100" height="100" fill="red"/></g></svg>"#
+        );
+        let (d, _) = import_with_report(&svg).unwrap();
+        let [m] = &masks(&d)[..] else { panic!("the square keeps its mask: {svg}") };
+        assert!(m.clip && !m.invert);
+        assert!(m.art.geometric_bounds().is_none(), "no visible art: {:?}", m.art.kind);
+        let (canvas, reference) = (render_artboard(&d), resvg_render(&svg, 100, 100));
+        for (x, y) in [(10, 10), (50, 50), (90, 90)] {
+            assert_eq!(reference.over_white(x, y), [255, 255, 255], "resvg ({x},{y}): {svg}");
+            assert_eq!(canvas.over_white(x, y), [255, 255, 255], "canvas ({x},{y}): {svg}");
+        }
+    }
+}

crates/text/Cargo.toml

@@ -21,6 +21,9 @@ subsetter = { version = "0.2", default-features = false, features = ["variable-f
 unicode-bidi = "0.3.18"
 unicode-general-category = "1"
 unicode-script = "0.5"
+# Grapheme clusters (a Thai consonant with its vowel and tone marks, an accented letter, an emoji
+# sequence) for caret movement; MIT OR Apache-2.0, already in the build.
+unicode-segmentation = "1.13"
 # Builds a small variable font for tests (`test_fonts`; no font file is committed). MIT OR
 # Apache-2.0, already in the build through subsetter.
 write-fonts = { version = "0.48", optional = true }

crates/text/src/edit.rs

@@ -190,6 +190,21 @@ pub fn next_char(s: &str, i: usize) -> usize {
     s[i..].chars().next().map(|c| i + c.len_utf8()).unwrap_or(s.len())
 }
 
+/// The start of the grapheme cluster before `i` (Left arrow): a Thai consonant with its vowel and
+/// tone marks, an accented letter or an emoji sequence is passed over whole.
+pub fn prev_cluster(s: &str, i: usize) -> usize {
+    use unicode_segmentation::GraphemeCursor;
+    let i = floor_char(s, i);
+    GraphemeCursor::new(i, s.len(), true).prev_boundary(s, 0).ok().flatten().unwrap_or(0)
+}
+
+/// The end of the grapheme cluster at `i` (Right arrow, Delete): see [`prev_cluster`].
+pub fn next_cluster(s: &str, i: usize) -> usize {
+    use unicode_segmentation::GraphemeCursor;
+    let i = floor_char(s, i);
+    GraphemeCursor::new(i, s.len(), true).next_boundary(s, 0).ok().flatten().unwrap_or(s.len())
+}
+
 fn is_word_char(c: char) -> bool {
     c.is_alphanumeric() || c == '_' || c == '\'' || c == '’'
 }

crates/text/src/fontdb.rs

@@ -391,6 +391,36 @@ struct SysFallback {
     misses: std::collections::HashSet<char>,
 }
 
+/// Fonts made for Thai, tried first (when installed) for Thai the font in use lacks: Windows
+/// (Leelawadee UI; Tahoma before Windows 8), macOS (Thonburi, Sukhumvit Set) and Linux (Noto,
+/// TLWG).
+pub const THAI_FAMILIES: &[&str] = &[
+    "Leelawadee UI",
+    "Leelawadee",
+    "Tahoma",
+    "Thonburi",
+    "Sukhumvit Set",
+    "Noto Sans Thai",
+    "Noto Sans Thai UI",
+    "Noto Sans Thai Looped",
+    "Waree",
+    "Loma",
+    "Garuda",
+];
+
+/// The families tried first for character `c`, in a script whose text only fonts made for it set
+/// well (Thai, Lao, Khmer, Myanmar); none for other characters.
+fn script_families(c: char) -> &'static [&'static str] {
+    use unicode_script::{Script, UnicodeScript};
+    match c.script() {
+        Script::Thai => THAI_FAMILIES,
+        Script::Lao => &["Lao UI", "Leelawadee UI", "Lao Sangam MN", "Noto Sans Lao", "Noto Sans Lao UI", "Phetsarath OT"],
+        Script::Khmer => &["Khmer UI", "Khmer Sangam MN", "Noto Sans Khmer", "Noto Sans Khmer UI", "Khmer OS"],
+        Script::Myanmar => &["Myanmar Text", "Myanmar Sangam MN", "Noto Sans Myanmar", "Noto Sans Myanmar UI", "Padauk"],
+        _ => &[],
+    }
+}
+
 /// Families tried (when installed) for characters the loaded fonts lack: CJK, symbols, emoji.
 #[cfg(not(target_arch = "wasm32"))]
 const SYSTEM_FALLBACKS: &[&str] = &[
@@ -1917,6 +1947,18 @@ impl FontDb {
     /// First face (fallback family first, then load order) that covers `c`; on native, system
     /// fonts are loaded lazily the first time no loaded face covers a character.
     pub(crate) fn fallback_for(&self, c: char, exclude: u32) -> Option<Arc<FontFace>> {
+        // Thai (Lao, Khmer, Myanmar) takes a font made for it, when one is installed, rather than
+        // whichever face covering it happened to load first (a display face, say).
+        let prefer = script_families(c);
+        if let Some(f) = self.family_fallback(c, exclude, prefer) {
+            return Some(f);
+        }
+        #[cfg(not(target_arch = "wasm32"))]
+        if self.load_families(c, prefer)
+            && let Some(f) = self.family_fallback(c, exclude, prefer)
+        {
+            return Some(f);
+        }
         if let Some(f) = self.loaded_fallback(c, exclude) {
             return Some(f);
         }
@@ -1934,6 +1976,28 @@ impl FontDb {
         self.fallback_for(c, 0)
     }
 
+    /// The loaded face of the first of `families` that covers `c` (upright, nearest Regular).
+    fn family_fallback(&self, c: char, exclude: u32, families: &[&str]) -> Option<Arc<FontFace>> {
+        let faces = self.read_faces();
+        families.iter().find_map(|fam| {
+            faces
+                .iter()
+                .filter(|f| f.id != exclude && f.family.eq_ignore_ascii_case(fam) && f.covers(c))
+                .min_by_key(|f| (f.italic, (f.weight - 400.0).abs() as i32))
+                .cloned()
+        })
+    }
+
+    /// Load the first of the installed `families` not loaded yet that covers `c` (with system
+    /// fallback on). Returns whether one was loaded.
+    #[cfg(not(target_arch = "wasm32"))]
+    fn load_families(&self, c: char, families: &[&str]) -> bool {
+        if families.is_empty() || !self.sys.lock().unwrap_or_else(|e| e.into_inner()).enabled {
+            return false;
+        }
+        families.iter().any(|fam| !self.is_loaded(fam) && self.load_cataloged(fam) && self.family_fallback(c, 0, &[fam]).is_some())
+    }
+
     fn loaded_fallback(&self, c: char, exclude: u32) -> Option<Arc<FontFace>> {
         let faces = self.read_faces();
         let mut order: Vec<&Arc<FontFace>> = faces.iter().filter(|f| f.id != exclude).collect();

crates/text/src/tests_sysfonts.rs

@@ -569,3 +569,23 @@ fn family_display_name_follows_show_font_names_in_english() {
     let face = db.face("ヒラギノ角ゴシック", "Regular").unwrap();
     assert_eq!(face.family, "Hiragino Sans");
 }
+
+/// Thai typed in a font without Thai takes an installed font made for Thai (Leelawadee UI,
+/// Thonburi, Noto Sans Thai…), whatever other face covering Thai loaded first; Latin beside it keeps
+/// the font chosen. Skipped where none of those families is installed.
+#[test]
+fn thai_falls_back_to_a_font_made_for_thai() {
+    let db = FontDb::global();
+    let Some(thai) = crate::fontdb::THAI_FAMILIES.iter().find(|f| db.has_family(f)) else {
+        eprintln!("skipped: no Thai font installed");
+        return;
+    };
+    let st = vectorcraft_doc::CharStyle { size: 20.0, ..Default::default() };
+    let l = layout(db, &TextObject::point(kurbo::Point::ZERO, "Thai ภาษาไทย", st));
+    let family = |g: &PositionedGlyph| db.face_by_id(g.font_id).map(|f| f.family.clone()).unwrap_or_default();
+    let (latin, thai_glyphs) = l.glyphs.split_at(5);
+    assert!(latin.iter().all(|g| family(g) == FALLBACK_FAMILY), "{:?}", latin.iter().map(family).collect::<Vec<_>>());
+    let first = crate::fontdb::THAI_FAMILIES.iter().find(|f| thai_glyphs.iter().all(|g| family(g).eq_ignore_ascii_case(f)));
+    assert!(first.is_some(), "Thai drawn in {:?}; {thai} is installed", thai_glyphs.iter().map(family).collect::<Vec<_>>());
+    assert!(thai_glyphs.iter().all(|g| g.gid != 0), "no .notdef");
+}

crates/text/src/tests_typo.rs

@@ -791,3 +791,17 @@ fn proportional_metrics_set_full_width_glyphs_on_their_proportional_widths() {
     let moved = x0(&half)[1] - x0(&none)[1];
     assert!((moved - 10.0).abs() < 0.01, "〙's empty half goes past the line's end: あ moved {moved}");
 }
+
+/// The arrows pass a Thai consonant with its vowel and tone marks whole (น้ำ: no, mai tho, sara am),
+/// as an accented letter written with a combining mark; plain text moves a character at a time.
+#[test]
+fn caret_moves_over_whole_clusters() {
+    let s = "กน\u{0E49}\u{0E33}e\u{0301}x";
+    let stops: Vec<usize> = std::iter::successors(Some(0), |&i| (i < s.len()).then(|| edit::next_cluster(s, i))).collect();
+    assert_eq!(stops, [0, 3, 12, 15, 16]);
+    let back: Vec<usize> = std::iter::successors(Some(s.len()), |&i| (i > 0).then(|| edit::prev_cluster(s, i))).collect();
+    assert_eq!(back, [16, 15, 12, 3, 0]);
+    // Inside a cluster (a caret left there by a click), the arrows go to its edges.
+    assert_eq!((edit::prev_cluster(s, 6), edit::next_cluster(s, 6)), (3, 12));
+    assert_eq!((edit::next_cluster("", 0), edit::prev_cluster("ab", 99)), (0, 1));
+}

crates/tools/src/corners.rs

@@ -1,6 +1,6 @@
 //! Live Corners: the widgets inside the corners of the selected paths. The Selection tool shows
 //! them on live rectangles and polygons, Direct Selection on any path (a star, a pen path) at each
-//! corner anchor: one without handles between two straight sides. Dragging one rounds (or
+//! corner anchor: one that isn't smooth, where two sides, straight or curved, meet at an angle. Dragging one rounds (or
 //! sharpens) the corners whose widgets show together, on every selected path (#938): every corner
 //! of a path selected whole, those with a selected anchor when Direct Selection picked some. Alt-clicking a widget cycles their corner
 //! kind (round, inverted round, chamfer); double-clicking one opens the Corners dialog. The
@@ -701,7 +701,7 @@ mod tests {
         assert!(red, "six arcs at the limit");
     }
 
-    /// A pen path's middle corner shows a widget; its ends and curved corners don't.
+    /// A pen path's corners show widgets, curved ones too (#1144); its ends don't.
     #[test]
     fn a_pen_path_shows_widgets_on_its_corners_only() {
         let mut sp = vectorcraft_geom::SubPath::polyline(
@@ -713,7 +713,7 @@ mod tests {
         let s = selected(id);
         let p = paint();
         let w = CornerWidgets::for_tool(&cx(&d, &s, &p), true).unwrap();
-        assert_eq!(w.corners(), [1]);
-        assert_eq!(pts(&w), [Point::new(290.0, 110.0)]);
+        assert_eq!(w.corners(), [1, 2]);
+        assert_eq!(pts(&w)[0], Point::new(290.0, 110.0));
     }
 }

crates/tools/src/direct.rs

@@ -90,6 +90,15 @@ enum State {
         start: Point,
         began: bool,
     },
+    /// Dragging a curved segment of a selected blend's spine: it follows the pointer
+    /// (`object.blend.spine.reshapeSegment`, #1111).
+    SpineSegment {
+        id: NodeId,
+        seg: usize,
+        t: f64,
+        start: Point,
+        began: bool,
+    },
     /// Dragging a handle of the clicked spine point.
     SpineHandle {
         id: NodeId,
@@ -170,6 +179,15 @@ fn hit_spine_point(cx: &ToolContext, p: Point, tol: f64) -> Option<(NodeId, usiz
     })
 }
 
+/// The segment of a selected blend's spine passing within `tol` of `p`: (blend, segment, t, whether
+/// it is straight).
+pub(crate) fn hit_spine_segment(cx: &ToolContext, p: Point, tol: f64) -> Option<(NodeId, usize, f64, bool)> {
+    spines(cx).into_iter().filter(|(id, _)| cx.selection.contains(*id)).find_map(|(id, path)| {
+        let (si, seg, t, _, dist) = path.nearest(p)?;
+        (dist <= tol).then(|| (id, seg, t, path.subpaths.get(si).is_some_and(|sp| sp.segment_is_line(seg))))
+    })
+}
+
 /// The spine point `sel` and whether `p` is on its outgoing handle's end (`Some(true)`) or its
 /// incoming one's.
 fn hit_spine_handle(cx: &ToolContext, sel: (NodeId, usize), p: Point, tol: f64) -> Option<bool> {
@@ -402,6 +420,11 @@ impl Tool for DirectSelectionTool {
                 if let Some((id, anchors)) = hit_frame_edge(cx, p, tol) {
                     return self.press_type_area(cx, id, anchors, p, ev.mods.shift);
                 }
+                // A curved segment of a selected blend's spine reshapes, as a path's does.
+                if let Some((id, seg, t, false)) = hit_spine_segment(cx, p, tol) {
+                    self.state = State::SpineSegment { id, seg, t, start: p, began: false };
+                    return vec![];
+                }
                 if let Some(out) = self.guide.press(cx, ev) {
                     self.state = State::Idle;
                     return out;
@@ -546,6 +569,22 @@ impl Tool for DirectSelectionTool {
                 out.push(Action::Preview("object.blend.spine.moveAnchor".into(), json!({"id": id.0, "anchor": anchor, "x": q.x, "y": q.y})));
                 out
             }
+            (PointerKind::Drag, State::SpineSegment { id, seg, t, start, began }) => {
+                let mut out = vec![];
+                if !began {
+                    if p.distance(start) < cx.tol(3.0) {
+                        return out;
+                    }
+                    out.push(Action::Begin("Reshape Spine".into()));
+                    self.state = State::SpineSegment { id, seg, t, start, began: true };
+                }
+                let d = p - start;
+                out.push(Action::Preview(
+                    "object.blend.spine.reshapeSegment".into(),
+                    json!({"id": id.0, "segment": seg, "t": t, "dx": d.x, "dy": d.y}),
+                ));
+                out
+            }
             (PointerKind::Drag, State::SpineHandle { id, anchor, out }) => vec![Action::Preview(
                 "object.blend.spine.moveAnchor".into(),
                 json!({"id": id.0, "anchor": anchor, "handle": if out {"out"} else {"in"}, "x": p.x, "y": p.y, "independent": ev.mods.alt}),
@@ -583,6 +622,7 @@ impl Tool for DirectSelectionTool {
                 | State::MoveObject { began, .. }
                 | State::Segment { began, .. }
                 | State::SpinePoint { began, .. }
+                | State::SpineSegment { began, .. }
                 | State::TypeArea { began, .. },
             ) => {
                 self.state = State::Idle;
@@ -814,6 +854,45 @@ mod tests {
         assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Anchor { filled: true, .. })), "the clicked point shows");
     }
 
+    /// #1111: the Anchor Point tool bends a selected blend's straight spine; Direct Selection
+    /// reshapes a curved spine segment and leaves a straight one alone, as it does a path's.
+    #[test]
+    fn spine_segments_bend_with_the_anchor_point_tool_and_direct_selection() {
+        let (mut d, g, _) = blend_doc();
+        let mut s = Selection::default();
+        s.set([g]);
+        let p = paint();
+        let drag = |t: &mut dyn crate::Tool, cx: &ToolContext| {
+            t.pointer(cx, &PointerEvent::new(PointerKind::Down, 160.0, 311.0));
+            let a = t.pointer(cx, &PointerEvent::new(PointerKind::Drag, 160.0, 351.0));
+            t.pointer(cx, &PointerEvent::new(PointerKind::Up, 160.0, 351.0));
+            a
+        };
+        let straight = cx(&d, &s, &p);
+        let a = drag(crate::create("anchorPoint").as_mut(), &straight);
+        assert!(
+            matches!(a.last(), Some(Action::Preview(c, v)) if c == "object.blend.spine.reshapeSegment" && v["id"] == g.0 && v["segment"] == 0 && v["dy"] == 40.0),
+            "{a:?}"
+        );
+        let a = drag(&mut DirectSelectionTool::new(false), &straight);
+        assert!(!a.iter().any(|x| matches!(x, Action::Preview(c, _) if c == "object.blend.spine.reshapeSegment")), "straight: {a:?}");
+        // The spine bent upward: Direct Selection takes it from where it passes.
+        let mut sp = vectorcraft_geom::SubPath::polyline(&[Point::new(110.0, 310.0), Point::new(210.0, 310.0)], false);
+        sp.bend_segment(0, 0.5, vectorcraft_geom::Vec2::new(0.0, 20.0));
+        let Some(NodeKind::Blend { spec, .. }) = d.node_mut(g).map(|n| &mut n.kind) else { panic!("blend") };
+        (spec.spine, spec.key_anchors) = (Some(PathData::single(sp)), vec![0, 1]);
+        let mut t = DirectSelectionTool::new(false);
+        let curved = cx(&d, &s, &p);
+        t.pointer(&curved, &PointerEvent::new(PointerKind::Down, 160.0, 330.0));
+        let a = t.pointer(&curved, &PointerEvent::new(PointerKind::Drag, 160.0, 345.0));
+        assert_eq!(a[0], Action::Begin("Reshape Spine".into()));
+        assert!(
+            matches!(&a[1], Action::Preview(c, v) if c == "object.blend.spine.reshapeSegment" && v["segment"] == 0 && v["dx"] == 0.0 && v["dy"] == 15.0),
+            "{a:?}"
+        );
+        assert_eq!(t.pointer(&curved, &PointerEvent::new(PointerKind::Up, 160.0, 345.0)), vec![Action::Commit]);
+    }
+
     #[test]
     fn direct_and_group_selection_pick_blend_keys() {
         let (d, g, k1) = blend_doc();

crates/tools/src/draw2/anchor.rs

@@ -4,7 +4,7 @@
 //! Delete: click an anchor to remove it, re-fitting the neighbouring curve (Alt = add).
 //! Anchor Point: click a smooth anchor → corner; drag an anchor → pull out smooth handles; drag a
 //! handle → move it independently (Shift: at 45° steps round its anchor); drag a segment → reshape
-//! the curve.
+//! the curve, a selected blend's spine's too, straight or curved (#1111).
 //! Scissors: click a path to split it there.
 
 use serde_json::json;
@@ -19,9 +19,30 @@ use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, Tool
 #[derive(Clone, Copy, Debug)]
 enum State {
     Idle,
-    Convert { id: NodeId, si: usize, ai: usize, start: Point, began: bool },
-    Handle { id: NodeId, si: usize, ai: usize, out: bool, began: bool },
-    Reshape { id: NodeId, si: usize, seg: usize, t: f64, start: Point, began: bool },
+    Convert {
+        id: NodeId,
+        si: usize,
+        ai: usize,
+        start: Point,
+        began: bool,
+    },
+    Handle {
+        id: NodeId,
+        si: usize,
+        ai: usize,
+        out: bool,
+        began: bool,
+    },
+    /// Bending a segment: a path's, or (`spine`) a selected blend's spine's.
+    Reshape {
+        id: NodeId,
+        si: usize,
+        seg: usize,
+        t: f64,
+        start: Point,
+        began: bool,
+        spine: bool,
+    },
 }
 
 pub struct AnchorTool {
@@ -94,7 +115,9 @@ impl Tool for AnchorTool {
                 } else if let Some((id, si, ai)) = hit_anchor(cx, p, point) {
                     self.state = State::Convert { id, si, ai, start: p, began: false };
                 } else if let Some((id, si, seg, t)) = hit_segment(cx, p, tol) {
-                    self.state = State::Reshape { id, si, seg, t, start: p, began: false };
+                    self.state = State::Reshape { id, si, seg, t, start: p, began: false, spine: false };
+                } else if let Some((id, seg, t, _)) = crate::direct::hit_spine_segment(cx, p, tol) {
+                    self.state = State::Reshape { id, si: 0, seg, t, start: p, began: false, spine: true };
                 }
                 vec![]
             }
@@ -128,6 +151,10 @@ impl Tool for AnchorTool {
                             json!({"id": id.0, "subpath": si, "anchor": ai, "which": if out { "out" } else { "in" }, "x": q.x, "y": q.y, "independent": true}),
                         )
                     }
+                    State::Reshape { id, seg, t, start, spine: true, .. } => Action::Preview(
+                        "object.blend.spine.reshapeSegment".into(),
+                        json!({"id": id.0, "segment": seg, "t": t, "dx": p.x - start.x, "dy": p.y - start.y}),
+                    ),
                     State::Reshape { id, si, seg, t, start, .. } => Action::Preview(
                         "path.reshapeSegment".into(),
                         json!({"id": id.0, "subpath": si, "segment": seg, "t": t, "dx": p.x - start.x, "dy": p.y - start.y}),

crates/tools/src/text.rs

@@ -530,8 +530,10 @@ impl Tool for TypeTool {
                 self.anchor = if word { edit::prev_word(&text, self.caret) } else { edit::prev_char(&text, self.caret) };
                 self.replace(cx, "", None)
             }
+            // Backspace takes back one character (a mistyped Thai tone mark, say); Delete, the
+            // Left and Right arrows a whole cluster.
             ToolKey::Delete if self.caret < len => {
-                self.anchor = if word { edit::next_word(&text, self.caret) } else { edit::next_char(&text, self.caret) };
+                self.anchor = if word { edit::next_word(&text, self.caret) } else { edit::next_cluster(&text, self.caret) };
                 self.replace(cx, "", None)
             }
             ToolKey::Left => {
@@ -549,7 +551,7 @@ impl Tool for TypeTool {
                     if lay.glyphs.iter().any(|g| g.rtl) {
                         vectorcraft_text::caret_horizontal(&lay, self.caret, false)
                     } else {
-                        edit::prev_char(&text, self.caret)
+                        edit::prev_cluster(&text, self.caret)
                     }
                 };
                 self.move_to(to, mods.shift)
@@ -569,7 +571,7 @@ impl Tool for TypeTool {
                     if lay.glyphs.iter().any(|g| g.rtl) {
                         vectorcraft_text::caret_horizontal(&lay, self.caret, true)
                     } else {
-                        edit::next_char(&text, self.caret)
+                        edit::next_cluster(&text, self.caret)
                     }
                 };
                 self.move_to(to, mods.shift)

crates/tools/src/xform/artboard.rs

@@ -1,6 +1,8 @@
 //! Artboard tool (Shift+O).
 //!
-//! Click an artboard to make it active (dashed bounds, 8 handles and its name). Drag inside moves
+//! Click an artboard to make it active (dashed bounds, 8 handles and its name); Shift-click adds
+//! artboards to the selection or takes them out (dashed bounds), and a drag or Delete then acts on
+//! all of them (#1139). Drag inside moves
 //! it (with its artwork when the `moveArt` option is on, Shift constrains; Alt moves a copy and
 //! leaves the artboard where it was), drag a handle resizes it
 //! (Shift proportional, Alt from centre; with the `scaleArt` option on, Scale Artwork with Artboard,
@@ -26,6 +28,8 @@ enum Drag {
     /// last drag event (the step under way is a duplicate).
     Move {
         index: usize,
+        /// Several artboards move together (the selected ones, `index` among them).
+        many: bool,
         start: Point,
         rect: Rect,
         began: bool,
@@ -48,6 +52,8 @@ enum Drag {
 pub struct ArtboardTool {
     /// Index of the active artboard.
     pub active: usize,
+    /// The other selected artboards (Shift-click), in order.
+    pub others: Vec<usize>,
     /// Move artwork with the artboard.
     pub move_art: bool,
     /// Scale artwork with the artboard: a resize takes the art fully inside it along, and keeps the
@@ -69,6 +75,7 @@ impl Default for ArtboardTool {
     fn default() -> Self {
         Self {
             active: 0,
+            others: vec![],
             move_art: true,
             scale_art: false,
             drag: None,
@@ -90,6 +97,31 @@ impl ArtboardTool {
         cx.doc.artboards.get(self.active).map(|a| a.rect)
     }
 
+    /// The selected artboards that are still in the document: the active one and the others,
+    /// in order.
+    fn selected(&self, cx: &ToolContext) -> Vec<usize> {
+        let mut all: Vec<usize> = std::iter::once(self.active).chain(self.others.iter().copied()).filter(|i| *i < cx.doc.artboards.len()).collect();
+        all.sort_unstable();
+        all.dedup();
+        all
+    }
+
+    /// Shift-click on artboard `i`: into the selection, active, or out of it (another becomes
+    /// active).
+    fn toggle(&mut self, cx: &ToolContext, i: usize) {
+        let mut sel = self.selected(cx);
+        if let Some(at) = sel.iter().position(|j| *j == i) {
+            if sel.len() > 1 {
+                sel.remove(at);
+                self.active = if i == self.active { sel.first().copied().unwrap_or(0) } else { self.active };
+            }
+        } else {
+            sel.push(i);
+            self.active = i;
+        }
+        self.others = sel.into_iter().filter(|j| *j != self.active).collect();
+    }
+
     /// Gather the Smart Guide targets for dragging artboard `index` (call before the first preview,
     /// while the document still shows where everything started).
     fn begin_snapping(&mut self, cx: &ToolContext, index: usize, art_moves: bool) {
@@ -199,15 +231,24 @@ impl Tool for ArtboardTool {
                 if let Some(i) = cx.doc.artboard_at(p)
                     && let Some(a) = cx.doc.artboards.get(i)
                 {
-                    self.active = i;
-                    self.drag = Some(Drag::Move { index: i, start: p, rect: a.rect, began: false, copy: false });
+                    if m.shift {
+                        self.toggle(cx, i);
+                    } else if !self.selected(cx).contains(&i) {
+                        // A plain click on an artboard that isn't selected selects just it; on a
+                        // selected one, the selection stays, so the drag moves them all.
+                        self.others.clear();
+                        self.active = i;
+                    }
+                    let many = self.selected(cx).len() > 1 && self.selected(cx).contains(&i);
+                    self.drag = Some(Drag::Move { index: i, many, start: p, rect: a.rect, began: false, copy: false });
                 } else {
+                    self.others.clear();
                     let p = self.draw.press(cx, p, &[], None);
                     self.drag = Some(Drag::Create { start: p, cur: p });
                 }
                 vec![]
             }
-            (PointerKind::Drag, Some(Drag::Move { index, start, rect, began, copy })) => {
+            (PointerKind::Drag, Some(Drag::Move { index, many, start, rect, began, copy })) => {
                 let mut out = vec![];
                 let label = |copy: bool| if copy { "Duplicate Artboard" } else { "Move Artboard" };
                 if !began {
@@ -221,13 +262,14 @@ impl Tool for ArtboardTool {
                     out.push(Action::Cancel);
                     out.push(Action::Begin(label(m.alt).into()));
                 }
-                self.drag = Some(Drag::Move { index, start, rect, began: true, copy: m.alt });
+                self.drag = Some(Drag::Move { index, many, start, rect, began: true, copy: m.alt });
                 let d = self.snap_move(cx, rect, move_delta(start, p, m.shift), m.alt);
                 self.preview = Some(rect + d);
-                out.push(Action::Preview(
-                    "artboard.move".into(),
-                    json!({ "index": index, "dx": d.x, "dy": d.y, "moveArt": self.move_art, "copy": m.alt }),
-                ));
+                let mut v = json!({ "index": index, "dx": d.x, "dy": d.y, "moveArt": self.move_art, "copy": m.alt });
+                if many {
+                    v["indices"] = json!(self.selected(cx));
+                }
+                out.push(Action::Preview("artboard.move".into(), v));
                 out
             }
             (PointerKind::Drag, Some(Drag::Resize { index, handle, rect, grab, began })) => {
@@ -259,10 +301,14 @@ impl Tool for ArtboardTool {
             (PointerKind::Up, Some(d)) => {
                 self.end_drag();
                 match d {
-                    Drag::Move { began: true, copy, .. } => {
-                        // The copy, last in the previewed document, becomes the active artboard.
+                    Drag::Move { began: true, copy, many, .. } => {
+                        // The copies, last in the previewed document, become the selection (the
+                        // last one active).
                         if copy {
-                            self.active = cx.doc.artboards.len().saturating_sub(1);
+                            let n = cx.doc.artboards.len();
+                            let k = if many { self.selected(cx).len().min(n) } else { 1 };
+                            self.active = n.saturating_sub(1);
+                            self.others = (n.saturating_sub(k)..n.saturating_sub(1)).collect();
                         }
                         vec![Action::Commit]
                     }
@@ -300,7 +346,7 @@ impl Tool for ArtboardTool {
     fn claims_key(&self, cx: &ToolContext, key: ToolKey) -> bool {
         matches!(key, ToolKey::Delete | ToolKey::Backspace)
             && self.drag.is_none()
-            && cx.doc.artboards.len() > 1
+            && cx.doc.artboards.len() > self.selected(cx).len()
             && self.active < cx.doc.artboards.len()
     }
 
@@ -310,9 +356,14 @@ impl Tool for ArtboardTool {
                 if !self.claims_key(cx, key) {
                     return vec![];
                 }
-                let i = self.active;
-                self.active = i.saturating_sub(1);
-                vec![Action::Exec("artboard.delete".into(), json!({ "index": i }))]
+                let sel = self.selected(cx);
+                self.active = sel.first().copied().unwrap_or(0).saturating_sub(1);
+                self.others.clear();
+                let params = match sel.as_slice() {
+                    [i] => json!({ "index": i }),
+                    _ => json!({ "indices": sel }),
+                };
+                vec![Action::Exec("artboard.delete".into(), params)]
             }
             ToolKey::Escape => {
                 let busy = matches!(self.drag, Some(Drag::Move { began: true, .. } | Drag::Resize { began: true, .. }));
@@ -326,6 +377,7 @@ impl Tool for ArtboardTool {
     fn notify(&mut self, cx: &ToolContext, what: &str) {
         if what == "created" {
             self.active = cx.doc.artboards.len().saturating_sub(1);
+            self.others.clear();
         }
     }
 
@@ -340,6 +392,10 @@ impl Tool for ArtboardTool {
             }
             return o;
         }
+        // The other selected artboards: dashed bounds (in a drag the document shows them moved).
+        for r in self.others.iter().filter_map(|i| cx.doc.artboards.get(*i)).map(|a| a.rect) {
+            o.push(Overlay::Path { path: polygon(&rect_corners(r), true), color: BLUE, width: 1.0, dashed: true });
+        }
         let Some(ab) = cx.doc.artboards.get(self.active) else { return o };
         let r = self.preview.unwrap_or(ab.rect);
         o.push(Overlay::Path { path: polygon(&rect_corners(r), true), color: BLUE, width: 1.0, dashed: true });
@@ -377,12 +433,24 @@ impl Tool for ArtboardTool {
     }
 
     fn options(&self) -> Value {
-        json!({ "active": self.active, "moveArt": self.move_art, "scaleArt": self.scale_art })
+        json!({ "active": self.active, "selected": std::iter::once(self.active).chain(self.others.iter().copied()).collect::<Vec<_>>(), "moveArt": self.move_art, "scaleArt": self.scale_art })
     }
 
     fn set_option(&mut self, key: &str, value: &Value) {
         match key {
-            "active" => self.active = value.as_u64().unwrap_or(0) as usize,
+            "active" => {
+                self.active = value.as_u64().unwrap_or(0) as usize;
+                self.others.clear();
+            }
+            // The selected artboards, the first active.
+            "selected" => {
+                let all: Vec<usize> =
+                    value.as_array().into_iter().flatten().filter_map(Value::as_u64).filter_map(|i| usize::try_from(i).ok()).collect();
+                if let Some((first, rest)) = all.split_first() {
+                    self.active = *first;
+                    self.others = rest.iter().copied().filter(|i| i != first).collect();
+                }
+            }
             "moveArt" => self.move_art = value.as_bool().unwrap_or(true),
             "scaleArt" => self.scale_art = value.as_bool().unwrap_or(false),
             _ => {}
@@ -523,6 +591,42 @@ mod tests {
         assert_eq!(v["width"].as_f64(), Some(210.0));
     }
 
+    /// Shift-click selects several artboards (#1139): a drag moves them all, Shift-click takes one
+    /// out again, a plain click on an unselected one selects just it, and Delete removes all the
+    /// selected ones (one artboard is always left).
+    #[test]
+    fn shift_click_selects_several_artboards_that_move_and_delete_together() {
+        let mut d = two_boards();
+        let mut third = d.artboards[0].clone();
+        third.rect = Rect::new(0.0, 600.0, 200.0, 800.0);
+        d.artboards.push(third);
+        let (s, p) = (Selection::default(), paint());
+        let c = cx(&d, &s, &p);
+        let shift = Mods { shift: true, ..Default::default() };
+        let click = |t: &mut ArtboardTool, x: f64, y: f64, m: Mods| {
+            t.pointer(&c, &ev(PointerKind::Down, x, y).with_mods(m));
+            t.pointer(&c, &ev(PointerKind::Up, x, y).with_mods(m));
+        };
+        let mut t = ArtboardTool::default();
+        click(&mut t, 450.0, 450.0, Mods::default());
+        click(&mut t, 700.0, 100.0, shift);
+        assert_eq!(t.options()["selected"], json!([1, 0]), "the Shift-clicked one is active");
+        // A drag from either moves both.
+        t.pointer(&c, &ev(PointerKind::Down, 450.0, 450.0));
+        let v = preview_params(&t.pointer(&c, &ev(PointerKind::Drag, 470.0, 450.0)));
+        assert_eq!((v["indices"].clone(), v["dx"].as_f64()), (json!([0, 1]), Some(20.0)));
+        assert_eq!(t.pointer(&c, &ev(PointerKind::Up, 470.0, 450.0)), vec![Action::Commit]);
+        // Delete removes both; with all three selected it can't, so the key isn't taken.
+        assert_eq!(t.key(&c, ToolKey::Delete, Mods::default()), vec![Action::Exec("artboard.delete".into(), json!({"indices": [0, 1]}))]);
+        t.set_option("selected", &json!([0, 1, 2]));
+        assert!(!t.claims_key(&c, ToolKey::Delete));
+        // Shift-click takes one out; a plain click on an unselected one selects just it.
+        click(&mut t, 100.0, 700.0, shift);
+        assert_eq!(t.options()["selected"], json!([0, 1]));
+        click(&mut t, 100.0, 700.0, Mods::default());
+        assert_eq!(t.options()["selected"], json!([2]));
+    }
+
     /// Scale Artwork with Artboard (#602): the resize asks for the art to scale, keeps the artboard's
     /// proportions, and never snaps to the art scaling with it.
     #[test]

crates/trace/src/quantize.rs

@@ -376,10 +376,26 @@ fn refine(used: &[Used], mut centers: Vec<[f64; 3]>) -> Vec<[f64; 3]> {
 
 /// Merge 4-connected same-label components smaller than `min_area` pixels into their most common
 /// neighbouring label. Transparent pixels are never relabelled.
+///
+/// A pass can merge a speck into a small region that it merges away later, leaving the speck behind
+/// as a new island of that region's old label (#819: more noise removal gave more paths). Passes
+/// repeat until one changes nothing: each merge joins two components, so they always end.
 pub fn denoise(labels: &mut [u16], w: usize, h: usize, min_area: usize) {
-    if min_area <= 1 || w == 0 || h == 0 {
+    if min_area <= 1 || w == 0 || h == 0 || labels.len() < w.saturating_mul(h) {
         return;
     }
+    // A backstop only: real images settle in a few passes.
+    const MAX_PASSES: usize = 64;
+    for _ in 0..MAX_PASSES {
+        if !denoise_pass(labels, w, h, min_area) {
+            break;
+        }
+    }
+}
+
+/// One [`denoise`] pass over every component; true when it relabelled any.
+fn denoise_pass(labels: &mut [u16], w: usize, h: usize, min_area: usize) -> bool {
+    let mut changed = false;
     let mut seen = vec![false; w * h];
     let mut stack: Vec<usize> = Vec::new();
     let mut comp: Vec<usize> = Vec::new();
@@ -433,6 +449,8 @@ pub fn denoise(labels: &mut [u16], w: usize, h: usize, min_area: usize) {
             for &i in &comp {
                 labels[i] = to;
             }
+            changed = true;
         }
     }
+    changed
 }

crates/trace/src/tests.rs

@@ -557,3 +557,121 @@ fn create_strokes_survives_noise_and_tiny_images() {
         }
     }
 }
+
+/// The 4-connected same-label components of `labels` (transparent pixels left out): each one's size
+/// and whether it touches a pixel of another opaque label.
+fn components(labels: &[u16], w: usize, h: usize) -> Vec<(usize, bool)> {
+    let mut seen = vec![false; w * h];
+    let mut out = vec![];
+    for start in 0..w * h {
+        if seen[start] || labels[start] == TRANSPARENT {
+            continue;
+        }
+        let l = labels[start];
+        let (mut size, mut touches, mut stack) = (0, false, vec![start]);
+        seen[start] = true;
+        while let Some(i) = stack.pop() {
+            size += 1;
+            let (x, y) = (i % w, i / w);
+            let near = [(x > 0).then(|| i - 1), (x + 1 < w).then(|| i + 1), (y > 0).then(|| i - w), (y + 1 < h).then(|| i + w)];
+            for j in near.into_iter().flatten() {
+                if labels[j] == l {
+                    if !seen[j] {
+                        seen[j] = true;
+                        stack.push(j);
+                    }
+                } else if labels[j] != TRANSPARENT {
+                    touches = true;
+                }
+            }
+        }
+        out.push((size, touches));
+    }
+    out
+}
+
+/// #819: a speck merged into a small region that is itself merged later was left behind as a new
+/// island of the small region's old label.
+#[test]
+fn denoise_leaves_no_island_behind_a_merged_region() {
+    // One row: a 1-pixel speck, a 2-pixel region, then a large one; nothing under 3 pixels may stay.
+    let mut labels = vec![0, 1, 1, 2, 2, 2, 2, 2];
+    denoise(&mut labels, 8, 1, 3);
+    assert_eq!(labels, vec![2; 8]);
+}
+
+/// On noise, Remove Noise leaves no region under the minimum that could be merged, and a larger
+/// minimum never leaves more regions (#819: more noise removal gave more paths).
+#[test]
+fn denoise_merges_every_small_region_and_more_noise_never_means_more_regions() {
+    let (w, h) = (48, 40);
+    let mut seed = 0x2545_f491_u32;
+    let mut next = || {
+        seed ^= seed << 13;
+        seed ^= seed >> 17;
+        seed ^= seed << 5;
+        seed
+    };
+    for colors in [2u16, 3, 5, 8] {
+        // Blocky noise: random 1-4 pixel runs, so regions of every size touch each other.
+        let mut base = vec![0u16; w * h];
+        let mut i = 0;
+        while i < w * h {
+            let (l, run) = ((next() % u32::from(colors)) as u16, 1 + next() as usize % 4);
+            for p in base.iter_mut().skip(i).take(run) {
+                *p = l;
+            }
+            i += run;
+        }
+        let mut last = usize::MAX;
+        for min_area in [1usize, 2, 4, 8, 16, 32, 64, 128] {
+            let mut labels = base.clone();
+            denoise(&mut labels, w, h, min_area);
+            let comps = components(&labels, w, h);
+            if min_area > 1 {
+                assert!(
+                    comps.iter().all(|&(size, touches)| size >= min_area || !touches),
+                    "{colors} colours, min {min_area}: a region under the minimum is left: {comps:?}"
+                );
+            }
+            assert!(comps.len() <= last, "{colors} colours: min {min_area} leaves {} regions, more than the {last} a smaller one left", comps.len());
+            last = comps.len();
+        }
+    }
+}
+
+/// #819: on noisy scan-like images, raising Noise never gives more paths. Before the fix, these
+/// two went from 70 paths to 126 to 206 as Noise rose from 50 to 200 (and 22 to 25).
+#[test]
+fn more_noise_removal_never_gives_more_paths() {
+    for (seed0, colors) in [(15u32, 2usize), (9, 6)] {
+        let mut seed = seed0.wrapping_mul(0x9e37_79b9) | 1;
+        let mut next = move || {
+            seed ^= seed << 13;
+            seed ^= seed >> 17;
+            seed ^= seed << 5;
+            seed
+        };
+        let ink: Vec<[u8; 4]> = (0..colors)
+            .map(|_| {
+                let v = next();
+                [(v & 255) as u8, (v >> 8 & 255) as u8, (v >> 16 & 255) as u8, 255]
+            })
+            .collect();
+        // Diagonal bands of ink with a quarter of the pixels speckled at random.
+        let (w, h) = (121, 101);
+        let px: Vec<[u8; 4]> = (0..w * h)
+            .map(|i| {
+                let band = ((i % w) / 7 + (i / w) / 5) % colors;
+                if next() % 4 == 0 { ink[next() as usize % colors] } else { ink[band] }
+            })
+            .collect();
+        let img = Raster::from_fn(120, 100, |x, y| px[y as usize * w + x as usize]);
+        let mut last = (0, usize::MAX);
+        for noise in [1, 4, 8, 12, 25, 50, 100, 200] {
+            let n = trace(&img, &TraceParams { noise, ..TraceParams::default() }).paths.len();
+            assert!(n <= last.1, "image {seed0}: Noise {noise} gives {n} paths, more than the {} of Noise {}", last.1, last.0);
+            last = (noise, n);
+        }
+    }
+}

crates/ui-egui/src/canvas.rs

@@ -1238,6 +1238,8 @@ fn node_outline(n: &Node) -> BezPath {
             [b, c, d].into_iter().for_each(|q| bp.line_to(q));
             bp.close_path();
         }
+        // A gradient mesh shows its mesh lines (#1111).
+        NodeKind::Mesh(m) => bp.extend(m.lines().to_bezpath()),
         // An envelope shows its mesh (or top object), not its content.
         NodeKind::Envelope { .. } => {
             if let Some((lines, _)) = vectorcraft_doc::live::envelope_overlay(c) {
@@ -1632,9 +1634,15 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
         let partial = st.selection.partial(*id);
         // Path outlines.
         stroke_path(p, &node_outline(n), xf, Stroke::new(1.0, color));
-        // Anchors (and handles for selected anchors in direct mode); a mesh envelope's points.
+        // Anchors (and handles for selected anchors in direct mode); a gradient mesh's or a mesh
+        // envelope's points.
         walk_drawn(n, &mut |c| {
-            if let Some((_, Some(grid))) = vectorcraft_doc::live::envelope_overlay(c) {
+            let envelope = vectorcraft_doc::live::envelope_overlay(c).and_then(|(_, grid)| grid);
+            let grid = match &c.kind {
+                NodeKind::Mesh(m) => Some(m),
+                _ => envelope.as_ref(),
+            };
+            if let Some(grid) = grid {
                 for q in &grid.points {
                     anchor_square(p, xf.to_screen(q.p), color, false, anchor(direct));
                 }
@@ -2548,6 +2556,34 @@ mod tests {
         assert!(points > 200 && squares > 200, "{points} outline points, {squares} squares");
     }
 
+    /// #1111: a selected gradient mesh shows its mesh lines and points to the selection tools, not
+    /// only to the Mesh tool.
+    #[test]
+    fn a_selected_gradient_mesh_shows_its_lines_and_points() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+        app.session.execute("shape.rectangle", &json!({"x": 20, "y": 20, "width": 200, "height": 100})).unwrap();
+        app.session.execute("object.mesh.create", &json!({"rows": 2, "cols": 2})).unwrap();
+        let ctx = egui::Context::default();
+        let drawn = |app: &mut VectorcraftApp| {
+            frame(app, &ctx, vec![]);
+            let shapes = shapes(app, &ctx);
+            let lines = shapes.iter().filter(|s| matches!(s, Shape::Path(ps) if ps.points.len() > 1)).count();
+            (lines, shapes.iter().filter(|s| matches!(s, Shape::Rect(_))).count())
+        };
+        let (none_lines, none_points) = {
+            app.session.execute("select.none", &json!({})).unwrap();
+            drawn(&mut app)
+        };
+        for tool in ["selection", "directSelection"] {
+            app.select_tool(tool);
+            app.session.execute("select.all", &json!({})).unwrap();
+            let (lines, points) = drawn(&mut app);
+            // The outline, two inner lines each way; the 3 × 3 points.
+            assert!(lines >= none_lines + 3 && points >= none_points + 9, "{tool}: {lines} lines, {points} points");
+        }
+    }
+
     /// #541: the key object's outline is drawn thicker than the rest of the selection's.
     #[test]
     fn the_key_object_has_a_thicker_outline() {

crates/ui-egui/src/dialogs/corners.rs

@@ -46,7 +46,7 @@ pub fn open(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
     };
     // Every corner given is one of the path's: none is left out of the edit.
     if corners.is_empty() || !corners.iter().all(|k| live.corner(*k).is_some()) {
-        return Err("give corners of the path: anchors between two straight sides".into());
+        return Err("give corners of the path: anchors where its sides meet at an angle".into());
     }
     let (radius, kind) = live.style(&corners);
     let mut fields = json!({"id": id.0, "corners": corners});

crates/ui-egui/src/dialogs/effect.rs

@@ -138,6 +138,7 @@ fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
         Some(plugin) => form::schema_fields(ui, d, &plugin.manifest().params),
         None if vectorcraft_effects::is_adjustment(&id) => adjust_fields(ui, d),
         None if id == TRANSFORM => transform_fields(ui, d, app.session.general_unit()),
+        None if id == ZIG_ZAG => zig_zag_fields(ui, d, app.session.general_unit()),
         None => {
             let doc = vectorcraft_effects::effect_info(&id).map(|e| e.params).unwrap_or_default();
             let unit = app.session.general_unit();
@@ -313,6 +314,55 @@ fn transform_fields(ui: &mut egui::Ui, d: &mut Dialog, unit: vectorcraft_doc::Un
     values_changed(d)
 }
 
+/// The Zig Zag effect (Effect › Distort & Transform › Zig Zag…).
+const ZIG_ZAG: &str = "distort.zigZag";
+
+/// Zig Zag's dialog (#1133): Size and Ridges per segment as sliders with their fields, Relative or
+/// Absolute and the Points as radio buttons. Returns whether the values differ from those last
+/// previewed.
+fn zig_zag_fields(ui: &mut egui::Ui, d: &mut Dialog, unit: vectorcraft_doc::Unit) -> bool {
+    const LABEL_W: f32 = 124.0;
+    const FIELD_W: f32 = 70.0;
+    let rail = Tokens::get(ui.ctx()).input_border;
+    let track = move |_| rail;
+    let relative = d.bool("relative");
+    widgets::subheader(ui, tl!("Options"));
+    // Size is a share of the object's size (Relative) or a distance (Absolute).
+    widgets::label_row(ui, tl!("Size:"), LABEL_W, |ui| {
+        form::slider_rail(ui, d, "size", 0.0..=100.0, &track);
+        if !relative {
+            form::length(ui, d, "size", unit, FIELD_W);
+        } else if let Some(n) = widgets::range_field(ui, ("zz", "size"), d.f64("size", 10.0), 0.0..=100.0, "%", 0, FIELD_W) {
+            d.fields.insert("size".into(), json!(n));
+        }
+    });
+    ui.horizontal(|ui| {
+        ui.add_space(LABEL_W + ui.spacing().item_spacing.x);
+        for (label, on) in [(tl!("Relative"), true), (tl!("Absolute"), false)] {
+            if widgets::radio(ui, label, relative == on, true) {
+                d.fields.insert("relative".into(), json!(on));
+            }
+        }
+    });
+    widgets::label_row(ui, tl!("Ridges per segment:"), LABEL_W, |ui| {
+        form::slider_rail(ui, d, "ridges", 0.0..=100.0, &track);
+        if let Some(n) = widgets::range_field(ui, ("zz", "ridges"), d.f64("ridges", 4.0), 0.0..=100.0, "", 0, FIELD_W) {
+            d.fields.insert("ridges".into(), json!(n));
+        }
+    });
+    ui.add_space(4.0);
+    widgets::subheader(ui, crate::i18n::tr_ctx(crate::i18n::current(), "effect", "Points"));
+    let points = d.str("points");
+    ui.horizontal(|ui| {
+        for (label, value) in choices(ZIG_ZAG, "points").unwrap_or_default() {
+            if widgets::radio(ui, crate::i18n::tr_ctx(crate::i18n::current(), "effect", label), points == *value, true) {
+                d.fields.insert("points".into(), json!(value));
+            }
+        }
+    });
+    values_changed(d)
+}
+
 /// Curves' graph of its `points` (input across, output up, 0..255): drag a point to move it
 /// between its neighbours, press on the graph away from the points to add one there, drag one
 /// off the graph to remove it (two always stay).

crates/ui-egui/src/dialogs/missing_links.rs

@@ -66,6 +66,7 @@ fn ask_update(app: &mut VectorcraftApp, ids: Vec<Value>) {
 
 /// The same offer for linked files another app changed while the document is open
 /// ([`vectorcraft_engine::link_watch`]).
+#[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn ask_update_changed(app: &mut VectorcraftApp, ids: Vec<Value>) {
     ask(app, ids, tl!("{count} linked image(s) changed on disk. Show the new versions?"));
 }

crates/ui-egui/src/dialogs/path_ops.rs

@@ -40,5 +40,12 @@ fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
 
 fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
     let (id, params) = command(d);
-    if d.kind == "offsetPath" { form::commit_preview(app, id, params) } else { run_and_close(app, id, params) }
+    if d.kind != "offsetPath" {
+        return run_and_close(app, id, params);
+    }
+    let r = form::commit_preview(app, id, params)?;
+    // The fields as the dialog held them, so they show as typed when it opens again.
+    let kept = ["offset", "joins", "miterLimit"].into_iter().filter_map(|k| Some((k.to_string(), d.fields.get(k)?.clone())));
+    app.ui.offset_path = Value::Object(kept.collect());
+    Ok(r)
 }

crates/ui-egui/src/dialogs/tests.rs

@@ -540,3 +540,18 @@ fn artboard_options_position_moves_art_only_with_the_tool_option_on() {
         assert_eq!(*app.session.doc().unwrap().doc, *before);
     }
 }
+
+/// Zig Zag's dialog has Size and Ridges per segment sliders, and Relative / Absolute and Smooth /
+/// Corner as radio buttons, not dropdowns (#1133).
+#[test]
+fn zig_zag_has_sliders_and_radio_buttons() {
+    let mut app = app();
+    app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap();
+    app.run("effect.dialog", json!({"effect": "distort.zigZag"})).unwrap();
+    let text = crate::tests_labels::painted_text(&mut app, |app, ui| show(app, ui.ctx()));
+    let lines: Vec<&str> = text.lines().map(str::trim).collect();
+    for want in ["Size:", "Relative", "Absolute", "Ridges per segment:", "Points", "Smooth", "Corner"] {
+        assert!(lines.contains(&want), "no {want:?} in {lines:?}");
+    }
+    assert!(!lines.contains(&"Ridges:"), "{lines:?}");
+}

crates/ui-egui/src/dialogs/tests_modal.rs

@@ -201,3 +201,19 @@ fn offset_path_previews() {
     cancel(&mut app);
     assert_eq!(count(&app), 1, "rolled back");
 }
+
+/// Offset Path opens on the values it was last confirmed with (#1152).
+#[test]
+fn offset_path_remembers_its_last_values() {
+    let mut app = app_with_selection();
+    app.run("select.all", json!({})).unwrap();
+    crate::menus::invoke(&mut app, "object.path.offsetPath", json!({}));
+    let d = app.ui.dialog.as_mut().unwrap();
+    d.fields.insert("offset".into(), json!(-4.5));
+    d.fields.insert("joins".into(), json!("round"));
+    confirm(&mut app).unwrap();
+    assert!(app.ui.dialog.is_none());
+    crate::menus::invoke(&mut app, "object.path.offsetPath", json!({}));
+    let d = app.ui.dialog.as_ref().unwrap();
+    assert_eq!((d.f64("offset", 0.0), d.str("joins"), d.f64("miterLimit", 0.0)), (-4.5, "round".to_string(), 4.0));
+}

crates/ui-egui/src/font_menu.rs

@@ -131,6 +131,13 @@ impl Row {
     }
 }
 
+/// Keep keyboard/pointer focus on the same font after filtering, loading new fonts or
+/// expanding a family's styles. A row index on its own can now name a different font.
+fn remap_highlight(before: &[Row], selected: Option<usize>, after: &[Row]) -> Option<usize> {
+    let row = before.get(selected?)?;
+    after.iter().position(|candidate| candidate == row)
+}
+
 /// What the rows were listed for: the query, the script, kind and favourites filters, Show Font
 /// Names in English, the expanded families, the favourites and the font list's generation.
 type RowsKey = (String, usize, Option<FontClass>, bool, bool, Vec<String>, Vec<String>, u64);
@@ -285,6 +292,10 @@ fn list(ui: &mut Ui, state_id: egui::Id, st: &mut MenuState, current: &str, samp
                 rows.extend(db.styles(f).into_iter().map(|s| Row::Style(f.clone(), s)));
             }
         }
+        // Filter changes (including un-starring a favourite) may remove rows; expanding
+        // another family or a background font scan can insert rows before the highlight.
+        // Never preview an unrelated family because the old numeric index now points to it.
+        st.highlight = remap_highlight(&st.rows, st.highlight, &rows);
         st.rows = rows.into();
         st.rows_key = Some(key);
     }
@@ -320,7 +331,9 @@ fn list(ui: &mut Ui, state_id: egui::Id, st: &mut MenuState, current: &str, samp
     }
     if rows.is_empty() {
         widgets::dim_label(ui, tl!("No matching fonts"));
-        return None;
+        // A filter or a font rescan can remove the row whose font was previewed.
+        // Do not leave that font applied while the list has no candidate to highlight.
+        return st.previewed.take().map(|_| FontPick::EndPreview);
     }
     // The rows: only those in view are laid out (there are thousands of families). The list is
     // the menu's one scrolling part, under the search field and filters (#555): it fills the
@@ -438,6 +451,7 @@ fn list(ui: &mut Ui, state_id: egui::Id, st: &mut MenuState, current: &str, samp
             st.previewed = Some(pick.clone());
             Some(FontPick::Preview(pick.0, pick.1))
         }
+        None => st.previewed.take().map(|_| FontPick::EndPreview),
         _ => None,
     }
 }
@@ -731,3 +745,35 @@ pub(crate) fn sample_text(app: &VectorcraftApp) -> Option<String> {
     let line = text.lines().map(str::trim).find(|l| !l.is_empty())?;
     Some(line.chars().take(12).collect())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{Row, remap_highlight};
+
+    fn family(name: &str) -> Row {
+        Row::Family(name.to_string())
+    }
+
+    #[test]
+    fn keeps_the_same_family_when_other_rows_are_inserted_or_removed() {
+        let before = [family("Alpha"), family("Bravo"), family("Charlie")];
+        assert_eq!(remap_highlight(&before, Some(2), &[family("Bravo"), family("Charlie")]), Some(1));
+        assert_eq!(remap_highlight(&before, Some(2), &[family("Alpha"), family("New"), family("Bravo"), family("Charlie")]), Some(3));
+    }
+
+    #[test]
+    fn clears_the_highlight_when_its_family_is_filtered_out() {
+        let before = [family("Alpha"), family("Bravo"), family("Charlie")];
+        assert_eq!(remap_highlight(&before, Some(1), &[family("Alpha"), family("Charlie")]), None);
+        assert_eq!(remap_highlight(&before, Some(10), &before), None);
+        assert_eq!(remap_highlight(&before, None, &before), None);
+    }
+
+    #[test]
+    fn expanded_style_rows_do_not_retarget_the_highlight() {
+        let before = [family("Alpha"), family("Bravo")];
+        let after = [family("Alpha"), Row::Style("Alpha".into(), "Bold".into()), family("Bravo")];
+        assert_eq!(remap_highlight(&before, Some(1), &after), Some(2));
+        assert_eq!(remap_highlight(&after, Some(1), &before), None);
+    }
+}

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

@@ -1545,6 +1545,7 @@
 	Move Rows	Zeilen verschieben
 	Move Slices	Slices verschieben
 	Move Spine Point	Achsenpunkt verschieben
+	Reshape Spine Segment	Achsensegment umformen
 	Move Swatch	Farbfeld verschieben
 	Move Up	Nach oben verschieben
 	Move…	Verschieben…
@@ -2100,6 +2101,9 @@
 	Redefine Symbol	Symbol neu definieren
 	Redefine {kind} Style	{kind}format neu definieren
 	Redo	Wiederholen
+	List Folder	Ordner auflisten
+	Begin Undo Group	Rückgängig-Gruppe beginnen
+	End Undo Group	Rückgängig-Gruppe beenden
 	Redo {name}	Wiederholen: {name}
 	Redo {}	Wiederholen: {}
 	Reduce Colors	Farben reduzieren
@@ -2583,6 +2587,8 @@
 	Size Tile to Art	Kachelgröße an Grafik anpassen
 	Size/Leading	Größe/Zeilenabstand
 	Size:	Größe:
+	Ridges per segment:	Zacken pro Segment:
+effect	Points	Punkte
 	Size: {size}  Tracking: {tracking}	Größe: {size}  Laufweite: {tracking}
 	Skew	Neigen
 	Skin Tone Ramps	Hauttonskalen
@@ -3429,7 +3435,7 @@ theme	Appearance	Erscheinungsbild
 @msg	freeform point {i} needs `at` [x, y] and a valid `color`	Freiformpunkt {i} braucht `at` [x, y] und eine gültige `color`
 @msg	freeform line {i} must be an array of point indices	Freiformlinie {i} muss ein Array von Punktindizes sein
 @msg	give both `start` and `end` [x, y] (or neither)	geben Sie sowohl `start` als auch `end` [x, y] an (oder keines von beiden)
-@msg	give corners of the path: anchors between two straight sides	geben Sie Ecken des Pfads an: Ankerpunkte zwischen zwei geraden Seiten
+@msg	give corners of the path: anchors where its sides meet at an angle	geben Sie Ecken des Pfads an: Ankerpunkte, an denen seine Seiten im Winkel aufeinandertreffen
 @msg	give horizontal or vertical	geben Sie horizontal oder vertical an
 @msg	give the path `id` and the width point `index`	geben Sie die `id` des Pfads und den `index` des Breitenpunkts an
 @msg	guides are locked	die Hilfslinien sind gesperrt
@@ -4095,3 +4101,5 @@ theme	Appearance	Erscheinungsbild
 @msg	invalid native panel set	Ungültiger nativer Bedienfeldsatz
 @msg	missing panel layout	Bedienfeldanordnung fehlt
 @msg	unsupported native docking operation	Nicht unterstützte native Docking-Operation
+	Linux Display Server	Linux-Anzeigeserver
+	X11 (XWayland)	X11 (XWayland)

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

@@ -1563,6 +1563,7 @@
 	Move Rows	Mover filas
 	Move Slices	Mover sectores
 	Move Spine Point	Mover punto del eje
+	Reshape Spine Segment	Remodelar segmento del eje
 	Move Swatch	Mover muestra
 	Move Up	Subir
 	Move…	Mover…
@@ -2151,6 +2152,9 @@
 	Redefine Symbol	Redefinir símbolo
 	Redefine {kind} Style	Redefinir estilo de {kind}
 	Redo	Rehacer
+	List Folder	Listar carpeta
+	Begin Undo Group	Iniciar grupo de deshacer
+	End Undo Group	Finalizar grupo de deshacer
 	Redo {name}	Rehacer {name}
 	Redo {}	Rehacer {}
 	Reduce Colors	Reducir colores
@@ -2634,6 +2638,7 @@
 	Size Tile to Art	Ajustar tamaño del mosaico a la ilustración
 	Size/Leading	Tamaño/interlineado
 	Size:	Tamaño:
+	Ridges per segment:	Crestas por segmento:
 	Size: {size}  Tracking: {tracking}	Tamaño: {size}  Espaciado: {tracking}
 	Skew	Sesgar
 	Skin Tone Ramps	Rampas de tonos de piel
@@ -3530,7 +3535,7 @@ axis	Both	Ambos
 @msg	freeform point {i} needs `at` [x, y] and a valid `color`	el punto de forma libre {i} necesita `at` [x, y] y un `color` válido
 @msg	freeform line {i} must be an array of point indices	la línea de forma libre {i} debe ser una lista de índices de puntos
 @msg	give both `start` and `end` [x, y] (or neither)	indica `start` y `end` [x, y] (o ninguno de los dos)
-@msg	give corners of the path: anchors between two straight sides	indica esquinas del trazado: puntos de ancla entre dos lados rectos
+@msg	give corners of the path: anchors where its sides meet at an angle	indica esquinas del trazado: puntos de ancla donde sus lados se unen en ángulo
 @msg	give horizontal or vertical	indica horizontal o vertical
 @msg	give the path `id` and the width point `index`	indica el `id` del trazado y el `index` del punto de anchura
 @msg	guides are locked	las guías están bloqueadas
@@ -4140,3 +4145,5 @@ lighting	Light	Luz
 @msg	invalid native panel set	Conjunto nativo de paneles no válido
 @msg	missing panel layout	Falta la distribución de paneles
 @msg	unsupported native docking operation	Operación nativa de anclaje no admitida
+	Linux Display Server	Servidor de pantalla de Linux
+	X11 (XWayland)	X11 (XWayland)

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

@@ -1562,6 +1562,7 @@
 	Move Rows	Déplacer les lignes
 	Move Slices	Déplacer les tranches
 	Move Spine Point	Déplacer le point de la dorsale
+	Reshape Spine Segment	Modeler le segment de la dorsale
 	Move Swatch	Déplacer la nuance
 	Move Up	Monter
 	Move…	Déplacer…
@@ -2148,6 +2149,9 @@
 	Redefine Symbol	Redéfinir le symbole
 	Redefine {kind} Style	Redéfinir le style de {kind}
 	Redo	Rétablir
+	List Folder	Lister le dossier
+	Begin Undo Group	Commencer un groupe d’annulation
+	End Undo Group	Terminer le groupe d’annulation
 	Redo {name}	Rétablir {name}
 	Redo {}	Rétablir {}
 	Reduce Colors	Réduire les couleurs
@@ -2631,6 +2635,7 @@
 	Size Tile to Art	Ajuster le carreau à l’illustration
 	Size/Leading	Taille/interlignage
 	Size:	Taille :
+	Ridges per segment:	Crêtes par segment :
 	Size: {size}  Tracking: {tracking}	Taille : {size}  Approche : {tracking}
 	Skew	Inclinaison
 	Skin Tone Ramps	Gammes de tons chair
@@ -3527,7 +3532,7 @@ axis	Both	Les deux
 @msg	freeform point {i} needs `at` [x, y] and a valid `color`	le point de forme libre {i} nécessite `at` [x, y] et une `color` valide
 @msg	freeform line {i} must be an array of point indices	la ligne de forme libre {i} doit être un tableau d’indices de points
 @msg	give both `start` and `end` [x, y] (or neither)	indiquez à la fois `start` et `end` [x, y] (ou aucun des deux)
-@msg	give corners of the path: anchors between two straight sides	indiquez des angles du tracé : des points d’ancrage entre deux côtés droits
+@msg	give corners of the path: anchors where its sides meet at an angle	indiquez des angles du tracé : des points d’ancrage où ses côtés se rejoignent en angle
 @msg	give horizontal or vertical	indiquez horizontal ou vertical
 @msg	give the path `id` and the width point `index`	indiquez l’`id` du tracé et l’`index` du point de largeur
 @msg	guides are locked	les repères sont verrouillés
@@ -4150,3 +4155,5 @@ lighting	Light	Lumière
 @msg	invalid native panel set	Ensemble natif de panneaux invalide
 @msg	missing panel layout	Disposition des panneaux manquante
 @msg	unsupported native docking operation	Opération native d’ancrage non prise en charge
+	Linux Display Server	Serveur d’affichage Linux
+	X11 (XWayland)	X11 (XWayland)

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

@@ -1563,6 +1563,7 @@
 	Move Rows	Sposta righe
 	Move Slices	Sposta sezioni
 	Move Spine Point	Sposta punto dorsale
+	Reshape Spine Segment	Rimodella segmento della dorsale
 	Move Swatch	Sposta campione
 	Move Up	Sposta su
 	Move…	Sposta…
@@ -2151,6 +2152,9 @@
 	Redefine Symbol	Ridefinisci simbolo
 	Redefine {kind} Style	Ridefinisci stile {kind}
 	Redo	Ripeti
+	List Folder	Elenca cartella
+	Begin Undo Group	Inizia gruppo di annullamento
+	End Undo Group	Termina gruppo di annullamento
 	Redo {name}	Ripeti {name}
 	Redo {}	Ripeti {}
 	Reduce Colors	Riduci colori
@@ -2634,6 +2638,7 @@
 	Size Tile to Art	Adatta tassello alla grafica
 	Size/Leading	Dimensione/interlinea
 	Size:	Dimensione:
+	Ridges per segment:	Creste per segmento:
 	Size: {size}  Tracking: {tracking}	Dimensione: {size}  Spaziatura caratteri: {tracking}
 	Skew	Inclinazione
 	Skin Tone Ramps	Scale di tonalità della pelle
@@ -3530,7 +3535,7 @@ axis	Both	Entrambi
 @msg	freeform point {i} needs `at` [x, y] and a valid `color`	il punto a forma libera {i} richiede `at` [x, y] e un `color` valido
 @msg	freeform line {i} must be an array of point indices	la linea a forma libera {i} deve essere un array di indici di punti
 @msg	give both `start` and `end` [x, y] (or neither)	specifica sia `start` sia `end` [x, y] (o nessuno dei due)
-@msg	give corners of the path: anchors between two straight sides	specifica angoli del tracciato: punti di ancoraggio tra due lati diritti
+@msg	give corners of the path: anchors where its sides meet at an angle	specifica angoli del tracciato: punti di ancoraggio in cui i suoi lati si incontrano ad angolo
 @msg	give horizontal or vertical	specifica horizontal o vertical
 @msg	give the path `id` and the width point `index`	specifica l'`id` del tracciato e l'`index` del punto di larghezza
 @msg	guides are locked	le guide sono bloccate
@@ -4142,3 +4147,5 @@ lighting	Light	Luce
 @msg	invalid native panel set	Gruppo nativo di pannelli non valido
 @msg	missing panel layout	Disposizione dei pannelli mancante
 @msg	unsupported native docking operation	Operazione nativa di ancoraggio non supportata
+	Linux Display Server	Server di visualizzazione Linux
+	X11 (XWayland)	X11 (XWayland)

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

@@ -101,6 +101,9 @@
 	Edit	編集
 	Undo	取り消し
 	Redo	やり直し
+	List Folder	フォルダーの内容を一覧表示
+	Begin Undo Group	取り消しグループを開始
+	End Undo Group	取り消しグループを終了
 	Cut	切り取り
 	Copy	コピー
 	Paste	貼り付け
@@ -1697,6 +1700,7 @@
 	Move Rows	行を移動
 	Move Slices	スライスを移動
 	Move Spine Point	スパインポイントを移動
+	Reshape Spine Segment	スパインセグメントをシェイプ変形
 	Move Swatch	スウォッチを移動
 	Move Up	上へ移動
 	Move in Perspective	遠近で移動
@@ -2456,6 +2460,7 @@
 	Size Tile to Art	タイルをアートワークのサイズに合わせる
 	Size/Leading	サイズ/行送り
 	Size:	サイズ:
+	Ridges per segment:	セグメントごとの山数:
 	Size: {size}  Tracking: {tracking}	サイズ：{size}  トラッキング：{tracking}
 	Skip Blank Artboards	空白のアートボードをスキップ
 	Slice Options	スライスオプション
@@ -3745,7 +3750,7 @@ theme	Appearance	外観
 @msg	no blend options	ブレンドオプションがありません
 @msg	bad color {v}	カラー {v} が正しくありません
 @msg	Corners edits the corners of a path	「コーナー」で編集できるのはパスの角だけです
-@msg	give corners of the path: anchors between two straight sides	パスの角 (2 本の直線の辺に挟まれたアンカーポイント) を指定してください
+@msg	give corners of the path: anchors where its sides meet at an angle	パスの角 (辺が角度をなして交わるアンカーポイント) を指定してください
 @msg	select one path, or give its `id`	パスを 1 つ選択するか、その `id` を指定してください
 @msg	the drawing is no longer loaded	図面はもう読み込まれていません
 @msg	No saved selections (Select → Save Selection…)	保存した選択範囲はありません (選択 → 選択範囲を保存…)
@@ -4136,3 +4141,5 @@ lighting	Light	ライト
 @msg	invalid native panel set	ネイティブパネルセットが無効です
 @msg	missing panel layout	パネル配置がありません
 @msg	unsupported native docking operation	ネイティブドッキング操作は未対応です
+	Linux Display Server	Linux ディスプレイサーバー
+	X11 (XWayland)	X11 (XWayland)

crates/ui-egui/src/i18n/mod.rs

@@ -266,6 +266,7 @@ pub fn lang_from_tag(tag: &str) -> Option<Lang> {
 
 /// True when `tag` names the generic `C` / `POSIX` locale (or a variant like `C.UTF-8`), which on
 /// macOS means "no particular language" rather than English: the system language list decides.
+#[cfg(not(target_arch = "wasm32"))]
 fn is_c_locale(tag: &str) -> bool {
     let base = tag.split(['.', '@']).next().unwrap_or("").to_ascii_lowercase();
     matches!(base.as_str(), "c" | "posix")

crates/ui-egui/src/i18n/pt-br.tsv

@@ -1334,6 +1334,7 @@
 	Move Plane to Match Object	Mover Plano para Corresponder ao Objeto
 	Move Slices	Mover Fatias
 	Move Spine Point	Mover Ponto de Coluna
+	Reshape Spine Segment	Remodelar Segmento da Coluna
 	Move Swatch	Mover Amostra
 	Move Up	Mover para Cima
 	Move in Perspective	Mover em Perspectiva

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

@@ -1561,6 +1561,7 @@
 	Move Rows	Переместить строки
 	Move Slices	Переместить фрагменты
 	Move Spine Point	Переместить точку остова
+	Reshape Spine Segment	Изменить форму сегмента остова
 	Move Swatch	Переместить образец
 	Move Up	Переместить вверх
 	Move…	Переместить…
@@ -2147,6 +2148,9 @@
 	Redefine Symbol	Переопределить символ
 	Redefine {kind} Style	Переопределить стиль {kind}
 	Redo	Повторить
+	List Folder	Показать содержимое папки
+	Begin Undo Group	Начать группу отмены
+	End Undo Group	Завершить группу отмены
 	Redo {name}	Повторить {name}
 	Redo {}	Повторить {}
 	Reduce Colors	Сократить число цветов
@@ -2630,6 +2634,7 @@
 	Size Tile to Art	Подогнать плитку по рисунку
 	Size/Leading	Размер/интерлиньяж
 	Size:	Размер:
+	Ridges per segment:	Гребней на сегмент:
 	Size: {size}  Tracking: {tracking}	Размер: {size}  Трекинг: {tracking}
 	Skew	Скос
 	Skin Tone Ramps	Шкалы тонов кожи
@@ -3526,7 +3531,7 @@ axis	Both	Оба
 @msg	freeform point {i} needs `at` [x, y] and a valid `color`	произвольной точке {i} нужны `at` [x, y] и допустимый `color`
 @msg	freeform line {i} must be an array of point indices	произвольная линия {i} должна быть массивом индексов точек
 @msg	give both `start` and `end` [x, y] (or neither)	укажите и `start`, и `end` [x, y] (или ни одного)
-@msg	give corners of the path: anchors between two straight sides	укажите углы контура: опорные точки между двумя прямыми сторонами
+@msg	give corners of the path: anchors where its sides meet at an angle	укажите углы контура: опорные точки, в которых его стороны сходятся под углом
 @msg	give horizontal or vertical	укажите horizontal или vertical
 @msg	give the path `id` and the width point `index`	укажите `id` контура и `index` точки ширины
 @msg	guides are locked	направляющие заблокированы
@@ -4138,3 +4143,5 @@ lighting	Light	Свет
 @msg	invalid native panel set	Недопустимый собственный набор панелей
 @msg	missing panel layout	Отсутствует расположение панелей
 @msg	unsupported native docking operation	Неподдерживаемая собственная операция прикрепления
+	Linux Display Server	Дисплейный сервер Linux
+	X11 (XWayland)	X11 (XWayland)

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

@@ -1557,6 +1557,7 @@
 	Move Rows	Перемістити рядки
 	Move Slices	Перемістити фрагменти
 	Move Spine Point	Перемістити точку осі
+	Reshape Spine Segment	Змінити форму сегмента осі
 	Move Swatch	Перемістити зразок
 	Move Up	Перемістити вгору
 	Move…	Перемістити…
@@ -2143,6 +2144,9 @@
 	Redefine Symbol	Перевизначити символ
 	Redefine {kind} Style	Перевизначити стиль {kind}
 	Redo	Повторити
+	List Folder	Показати вміст теки
+	Begin Undo Group	Почати групу скасування
+	End Undo Group	Завершити групу скасування
 	Redo {name}	Повторити {name}
 	Redo {}	Повторити {}
 	Reduce Colors	Скоротити кількість кольорів
@@ -2626,6 +2630,8 @@
 	Size Tile to Art	Підігнати плитку за малюнком
 	Size/Leading	Розмір/інтерліньяж
 	Size:	Розмір:
+	Ridges per segment:	Гребенів на сегмент:
+effect	Points	Точки
 	Size: {size}  Tracking: {tracking}	Розмір: {size} Трекінг: {tracking}
 	Skew	Скіс
 	Skin Tone Ramps	Шкали тонів шкіри
@@ -3513,7 +3519,7 @@ axis	Both	Обидві
 @msg	freeform point {i} needs `at` [x, y] and a valid `color`	довільній точці {i} потрібні `at` [x, y] та допустимий `color`
 @msg	freeform line {i} must be an array of point indices	довільна лінія {i} має бути масивом індексів точок
 @msg	give both `start` and `end` [x, y] (or neither)	вкажіть `start`, `end` [x, y] (або жодного)
-@msg	give corners of the path: anchors between two straight sides	вкажіть кути контуру: опорні точки між двома прямими сторонами
+@msg	give corners of the path: anchors where its sides meet at an angle	вкажіть кути контуру: опорні точки, у яких його сторони сходяться під кутом
 @msg	give horizontal or vertical	вкажіть horizontal або vertical
 @msg	give the path `id` and the width point `index`	вкажіть `id` контуру та `index` точки ширини
 @msg	guides are locked	напрямні заблоковані
@@ -4121,3 +4127,5 @@ lighting	Light	Світло
 @msg	invalid native panel set	Неприпустимий власний набір панелей
 @msg	missing panel layout	Відсутнє розташування панелей
 @msg	unsupported native docking operation	Непідтримувана власна операція прикріплення
+	Linux Display Server	Дисплейний сервер Linux
+	X11 (XWayland)	X11 (XWayland)

crates/ui-egui/src/i18n/zh-hans.tsv

@@ -1494,6 +1494,7 @@
 	Move Plane to Match Object	移动平面以符合对象
 	Move Slices	移动切片
 	Move Spine Point	移动脊线点
+	Reshape Spine Segment	整形脊线线段
 	Move Swatch	移动色板
 	Move Up	上移
 	Move…	移动…
@@ -2076,6 +2077,9 @@
 	Redefine Symbol	重新定义符号
 	Redefine {kind} Style	重新定义{kind}样式
 	Redo	重做
+	List Folder	列出文件夹
+	Begin Undo Group	开始还原组
+	End Undo Group	结束还原组
 	Redo {name}	重做 {name}
 	Redo {}	重做 {}
 	Reduce Colors	减少颜色
@@ -2522,6 +2526,7 @@
 	Size Tile to Art	使拼贴适合图稿
 	Size/Leading	字号/行距
 	Size:	尺寸：
+	Ridges per segment:	每段起伏数：
 	Size: {size}  Tracking: {tracking}	大小：{size}  字距：{tracking}
 	Skew	倾斜
 	Skin Tone Ramps	肤色渐变
@@ -3741,3 +3746,5 @@ lighting	Light	光源
 	Vertical Guide	垂直参考线
 	Horizontal Guide	水平参考线
 	Move Guide to Layer	将参考线移至图层
+	Linux Display Server	Linux 显示服务器
+	X11 (XWayland)	X11 (XWayland)

crates/ui-egui/src/i18n/zh-hant.tsv

@@ -1538,6 +1538,7 @@
 	Move Rows	移動列
 	Move Slices	移動切片
 	Move Spine Point	移動脊線點
+	Reshape Spine Segment	改變脊線線段外框
 	Move Swatch	移動色票
 	Move Up	上移
 	Move…	移動…
@@ -2129,6 +2130,9 @@
 	Redefine Symbol	重新定義符號
 	Redefine {kind} Style	重新定義{kind}樣式
 	Redo	重做
+	List Folder	列出資料夾
+	Begin Undo Group	開始還原群組
+	End Undo Group	結束還原群組
 	Redo {name}	重做 {name}
 	Redo {}	重做 {}
 	Reduce Colors	縮減顏色
@@ -2612,6 +2616,7 @@
 	Size Tile to Art	拼貼符合圖稿大小
 	Size/Leading	大小/行距
 	Size:	大小：
+	Ridges per segment:	每段起伏數：
 	Size: {size}  Tracking: {tracking}	大小：{size}  字距：{tracking}
 	Skew	傾斜
 	Skin Tone Ramps	膚色漸階
@@ -3522,3 +3527,5 @@ lighting	Light	光源
 	Vertical Guide	垂直參考線
 	Horizontal Guide	水平參考線
 	Move Guide to Layer	將參考線移至圖層
+	Linux Display Server	Linux 顯示伺服器
+	X11 (XWayland)	X11 (XWayland)

crates/ui-egui/src/menus.rs

@@ -1331,7 +1331,7 @@ pub fn run_ui_command(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<R
         "ui.spotColors" => crate::dialogs::spot_colors::open(app),
         "ui.menuDialog" => match s("command").as_deref() {
             Some(c) if crate::dialogs::envelope::opens(c) => crate::dialogs::envelope::open(app, c),
-            c => match c.and_then(menu_dialog) {
+            c => match c.and_then(|c| menu_dialog(app, c)) {
                 Some((kind, fields)) => {
                     app.ui.dialog = Some(crate::state::Dialog::new(kind, fields));
                     Ok(Value::Null)
@@ -2976,7 +2976,7 @@ fn queried_dialog(id: &str) -> Option<(&'static str, &'static [&'static str])> {
 }
 
 /// The dialog (kind, fields) the menu item of command `id` opens, as the reference app's does.
-fn menu_dialog(id: &str) -> Option<(&'static str, Value)> {
+fn menu_dialog(app: &VectorcraftApp, id: &str) -> Option<(&'static str, Value)> {
     Some(match id {
         "object.move" => ("move", json!({"dx": "0 pt", "dy": "0 pt"})),
         "object.rotate" => ("rotate", json!({"angle": 0})),
@@ -2985,6 +2985,8 @@ fn menu_dialog(id: &str) -> Option<(&'static str, Value)> {
         "object.reflect" => ("reflect", json!({"axis": "vertical"})),
         "object.shear" => ("shear", json!({"angle": 0, "axis": "horizontal"})),
         "path.average" => ("average", json!({"axis": "both"})),
+        // Offset Path opens on the values it was last confirmed with.
+        "object.path.offsetPath" if app.ui.offset_path.is_object() => ("offsetPath", app.ui.offset_path.clone()),
         "object.path.offsetPath" => ("offsetPath", json!({"offset": "10 pt", "joins": "miter", "miterLimit": 4})),
         "object.path.simplify" => ("simplify", json!({"tolerance": "1 pt"})),
         "object.path.splitIntoGrid" => ("splitIntoGrid", json!({"rows": 2, "columns": 2, "gutter": "12 pt"})),
@@ -3041,7 +3043,7 @@ pub fn invoke(app: &mut VectorcraftApp, id: &str, p: Value) {
     if waits_for_ime(app, id) {
         return;
     }
-    if let Some((kind, fields)) = menu_dialog(id)
+    if let Some((kind, fields)) = menu_dialog(app, id)
         && p.as_object().is_none_or(|o| o.is_empty())
     {
         app.ui.dialog = Some(crate::state::Dialog::new(kind, fields));

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

@@ -5,7 +5,7 @@
 //! fits it in the window.
 
 use egui::{Sense, Ui, pos2, vec2};
-use serde_json::json;
+use serde_json::{Value, json};
 
 use super::{pstate, set_pstate};
 use crate::theme::Tokens;
@@ -40,6 +40,46 @@ pub(crate) fn selected(app: &VectorcraftApp, n: usize) -> usize {
     app.view().map_or(0, |v| v.artboard).min(n.saturating_sub(1))
 }
 
+/// The selected artboards (of `n`): while the Artboard tool is in use, those it has selected
+/// (Shift-click, #1139), else the active one.
+pub(crate) fn picked(app: &VectorcraftApp, n: usize) -> Vec<usize> {
+    let tool = (app.session.tool_id() == "artboard").then(|| app.session.tool_options()["selected"].clone());
+    let mut all: Vec<usize> = tool
+        .iter()
+        .filter_map(Value::as_array)
+        .flatten()
+        .filter_map(Value::as_u64)
+        .filter_map(|i| usize::try_from(i).ok())
+        .filter(|i| *i < n)
+        .collect();
+    if all.is_empty() {
+        all.push(selected(app, n));
+    }
+    all.sort_unstable();
+    all.dedup();
+    all
+}
+
+/// Shift- or Ctrl/Cmd-click on artboard `i`'s row while the Artboard tool is in use: into its
+/// selection or out of it (the active one stays the navigator's).
+fn toggle(app: &mut VectorcraftApp, i: usize, n: usize) {
+    let mut all = picked(app, n);
+    match all.iter().position(|j| *j == i) {
+        Some(at) if all.len() > 1 => {
+            all.remove(at);
+        }
+        Some(_) => return,
+        None => all.insert(0, i),
+    }
+    let active = if all.contains(&i) { i } else { all.first().copied().unwrap_or(0) };
+    all.retain(|j| *j != active);
+    all.insert(0, active);
+    if let Some(v) = app.view_mut() {
+        v.artboard = active;
+    }
+    app.session.set_tool_option("selected", &json!(all));
+}
+
 /// Make artboard `i` the active one, leaving the view where it is: the navigator's and, while it
 /// is the tool, the Artboard tool's.
 pub(crate) fn select(app: &mut VectorcraftApp, i: usize) {
@@ -72,6 +112,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
         return;
     }
     let sel = selected(app, abs.len());
+    let all = picked(app, abs.len());
     let editing: Option<usize> = pstate(ui.ctx(), "ab-edit");
     widgets::list_box(ui, |ui| {
         ui.set_min_height(110.0);
@@ -82,7 +123,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
                 if resp.drag_started() {
                     egui::DragAndDrop::set_payload(ui.ctx(), RowDrag(i));
                 }
-                if i == sel {
+                if all.contains(&i) {
                     ui.painter().rect_filled(r, 0.0, t.row_selected);
                 } else if resp.hovered() {
                     ui.painter().rect_filled(r, 0.0, t.hover);
@@ -120,7 +161,10 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
                     app.select_tool("artboard");
                     select(app, i);
                 }
-                if resp.clicked() {
+                let several = ui.input(|inp| inp.modifiers.shift || inp.modifiers.command);
+                if resp.clicked() && several && app.session.tool_id() == "artboard" {
+                    toggle(app, i, abs.len());
+                } else if resp.clicked() {
                     select(app, i);
                 }
                 // Double-clicking the number goes to the artboard (fits it in the window); the name
@@ -159,8 +203,10 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
         } else if new.clicked() && app.run("artboard.new", json!({})).is_ok() {
             select(app, n);
         }
-        if widgets::icon_button_enabled(ui, "trash-2", tl!("Delete Artboard"), false, n > 1, 24.0).clicked() {
-            app.run("artboard.delete", json!({"index": sel})).ok();
+        if widgets::icon_button_enabled(ui, "trash-2", tl!("Delete Artboard"), false, n > all.len(), 24.0).clicked()
+            && app.run("artboard.delete", json!({ "indices": all })).is_ok()
+        {
+            select(app, all.first().copied().unwrap_or(0).saturating_sub(1));
         }
     });
 }
@@ -255,6 +301,49 @@ mod tests {
         assert_eq!(picked(&mut app, json!({})), json!([a]));
         assert_eq!(picked(&mut app, json!({"artboard": 1})), json!([b]));
     }
+    /// With the Artboard tool, Shift-click on a row adds its artboard to the tool's selection or
+    /// takes it out (#1139), and every selected row is highlighted.
+    #[test]
+    fn shift_clicking_rows_selects_several_artboards() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 200, "height": 150})).unwrap();
+        for x in [400, 800] {
+            app.session.execute("artboard.new", &json!({"x": x, "y": 0, "width": 200, "height": 150})).unwrap();
+        }
+        app.select_tool("artboard");
+        select(&mut app, 0);
+        let ctx = egui::Context::default();
+        let screen = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(240.0, 400.0)));
+        let frame = |app: &mut VectorcraftApp, time: f64, events: Vec<egui::Event>| {
+            let raw = egui::RawInput { events, time: Some(time), screen_rect: screen, ..Default::default() };
+            let mut out = ctx.run_ui(raw, |ui| show(app, ui));
+            out.textures_delta.clear();
+            out.shapes
+        };
+        let shapes = frame(&mut app, 0.0, vec![]);
+        let third = shapes
+            .iter()
+            .find_map(|c| match &c.shape {
+                egui::Shape::Text(t) if t.galley.text() == "Artboard 3" => Some(t.pos + vec2(4.0, 4.0)),
+                _ => None,
+            })
+            .unwrap();
+        let click = |at: egui::Pos2| {
+            let b =
+                |pressed| egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::SHIFT };
+            vec![egui::Event::ModifiersChanged(egui::Modifiers::SHIFT), egui::Event::PointerMoved(at), b(true), b(false)]
+        };
+        frame(&mut app, 1.0, click(third));
+        assert_eq!(picked(&app, 3), [0, 2]);
+        let rows = frame(&mut app, 2.0, vec![egui::Event::ModifiersChanged(egui::Modifiers::NONE)])
+            .iter()
+            .filter(|c| matches!(&c.shape, egui::Shape::Rect(r) if r.fill == Tokens::get(&ctx).row_selected))
+            .count();
+        assert_eq!(rows, 2, "both rows highlighted");
+        frame(&mut app, 3.0, click(third));
+        assert_eq!(picked(&app, 3), [0]);
+    }
+
     /// 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.

crates/ui-egui/src/prefs_dialog.rs

@@ -306,6 +306,8 @@ fn category_fields(ui: &mut egui::Ui, d: &mut Dialog, cat: &str) {
                     }
                 });
             }
+            // Linux only: the other platforms have a single display server.
+            PrefKind::Choice(_) if sp.key == "linuxDisplayServer" && !cfg!(target_os = "linux") => {}
             PrefKind::Choice(opts) => {
                 labeled(ui, sp.label, |ui| {
                     let cur = v.as_str().unwrap_or("");
@@ -315,8 +317,8 @@ fn category_fields(ui: &mut egui::Ui, d: &mut Dialog, cat: &str) {
                         d.fields.insert(sp.key.into(), json!(opts[i].0));
                     }
                 });
-                if sp.key == "gpuPreference" {
-                    // The window's graphics device is chosen once, when the app starts.
+                if sp.key == "gpuPreference" || sp.key == "linuxDisplayServer" {
+                    // The window's graphics device and display server are chosen once, when the app starts.
                     ui.label(egui::RichText::new(tl!("Applies the next time VectorCraft starts.")).color(t.text_dim).size(11.0));
                 }
             }

crates/ui-egui/src/state.rs

@@ -388,6 +388,10 @@ pub struct UiState {
     /// The EPS Options chosen last (`document.exportEps` options; null: never used).
     #[serde(default)]
     pub eps_options: Value,
+    /// The Offset Path fields confirmed last (offset, joins, miterLimit; null: never used): its
+    /// dialog opens on them (#1152).
+    #[serde(default)]
+    pub offset_path: Value,
     /// The DXF Import Options chosen last (fit, scaleLineweights, center, mergeLayers; null:
     /// never used).
     #[serde(default)]
@@ -639,6 +643,7 @@ impl Default for UiState {
             dialog_search: None,
             dxf_options: Value::Null,
             eps_options: Value::Null,
+            offset_path: Value::Null,
             dxf_import: Value::Null,
             home: None,
             layers_panel: Default::default(),

crates/ui-egui/src/tests_font_menu.rs

@@ -224,6 +224,57 @@ fn right_arrow_lists_a_familys_styles_and_they_preview() {
     assert_eq!(picked, Some(FontPick::Chosen("Source Sans 3".into(), Some(styles[1].clone()))));
 }
 
+/// #1116: styles listed above the highlight (a click on another family's triangle) leave it on its
+/// family; it doesn't land on one of those styles and preview it.
+#[test]
+fn styles_listed_above_the_highlight_leave_it_on_its_family() {
+    let ctx = egui::Context::default();
+    crate::theme::install_fonts(&ctx);
+    let frame = |events: Vec<egui::Event>| {
+        let input =
+            egui::RawInput { events, screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(600.0, 800.0))), ..Default::default() };
+        let (mut at, mut picked) = (egui::Pos2::ZERO, None);
+        let mut out = ctx.run_ui(input, |ui| {
+            at = ui.next_widget_position();
+            picked = font_menu(ui, "test-rebuild", "Source Sans 3", 260.0, None, MenuLook::default());
+        });
+        out.textures_delta.clear();
+        // The family's row: the lowest text naming it (the menu's button above names it too).
+        let row = out
+            .shapes
+            .iter()
+            .filter_map(|s| match &s.shape {
+                egui::Shape::Text(t) if t.galley.text() == "Source Sans 3" => Some(t.pos + egui::vec2(0.0, t.galley.size().y * 0.5)),
+                _ => None,
+            })
+            .max_by(|a, b| a.y.total_cmp(&b.y));
+        (at, picked, row)
+    };
+    let (at, ..) = frame(vec![]);
+    let click = at + egui::vec2(40.0, 10.0);
+    let button = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+    frame(vec![egui::Event::PointerMoved(click), button(click, true)]);
+    frame(vec![button(click, false)]);
+    let mut row = None;
+    for _ in 0..5 {
+        row = frame(vec![]).2;
+    }
+    // The family's disclosure triangle, left of its name: hovered, it highlights the family.
+    let triangle = row.expect("the family is listed") - egui::vec2(7.0, 0.0);
+    frame(vec![egui::Event::PointerMoved(triangle)]);
+    let (_, picked, _) = frame(key(egui::Key::ArrowDown));
+    let Some(FontPick::Preview(next, None)) = picked else { panic!("↓ previews the next family: {picked:?}") };
+    // A click on the triangle, the pointer still: the styles are listed between the two families.
+    frame(vec![button(triangle, true)]);
+    frame(vec![button(triangle, false)]);
+    for _ in 0..3 {
+        let (_, picked, _) = frame(vec![]);
+        assert_eq!(picked, None, "{next} stays highlighted and previewed");
+    }
+    let (_, picked, _) = frame(key(egui::Key::Enter));
+    assert_eq!(picked, Some(FontPick::Chosen(next, None)));
+}
+
 #[test]
 fn stars_mark_favourites_and_the_preferences_size_the_rows() {
     let mut app = VectorcraftApp::new(Session::new(), crate::Services::default());

docs/control-protocol.md

@@ -36,6 +36,11 @@ nowhere and Windows device names are refused. A root left out grants none of its
 existing folders, or the app doesn't start; without `--control` they are ignored. See `docs/mcp.md`
 › Confining file access for the details.
 
+Each root flag may be given once; a command-line root overrides its environment default. Missing or
+empty values, another option used as a value, and duplicate flags stop the desktop before it starts
+any services, even without `--control`. For a folder name starting with `-`, use `--flag=-folder`
+or the relative path `./-folder`.
+
 What is confined: the requests themselves, the frames that carry input they inject (`ui.click`, `ui.key`,
 `ui.text`…, so a menu item an agent clicks is confined too), the background saves and exports they start,
 and window captures. The person at the keyboard is not: files opened from the command line, Finder or a
@@ -692,7 +697,9 @@ new blends start with. The Blend tool (`ui.tool.select {tool: "blend"}`): `ui.po
 another, blends them; down on an anchor point blends from that point; each further object clicked joins the blend.
 A selected blend shows its spine. With Direct Selection (`directSelection`) a `ui.pointer` drag from a spine point
 moves it (`object.blend.spine.moveAnchor`, one undo step) and, once a point is clicked, from one of its handles
-reshapes the curve; Direct and Group Selection pick a blend's key objects. With the Pen tool a click on a selected
+reshapes the curve, and a drag on a curved spine segment bends it (`object.blend.spine.reshapeSegment`); the Anchor
+Point tool (`anchorPoint`) bends any segment of a selected blend's spine, straight ones too. Direct and Group Selection
+pick a blend's key objects. With the Pen tool a click on a selected
 blend's spine adds a point (on a point no key sits on, deletes it).
 
 Perspective grid view options: View → Perspective Grid lists Show/Hide Grid, Show/Hide Rulers, Snap to Grid

docs/development.md

@@ -102,8 +102,8 @@ The window runs natively on Wayland (eframe's `wayland` feature) and on X11. On
 - **Clipboard:** under Wayland arboard talks to the compositor through the data-control protocol (wlroots compositors such as Sway and Hyprland, KDE Plasma), so bitmaps (`image/png`), SVG markup and text copied in any app paste (#398). Where the compositor lacks the protocol (GNOME's Mutter, [arboard#223](https://github.com/1Password/arboard/issues/223)), arboard falls back to the X11 clipboard through XWayland, which only holds what X11 apps copied. egui's own text paste into fields goes through smithay-clipboard and works either way.
 - **Clipboard owners that never answer (#510):** reading the clipboard waits on the app that owns it: arboard gives up on an X11 owner after 4 s, and a Wayland read waits for the owner to send its data. So on Linux the check that enables the Paste menu items runs on a background thread with a second clipboard handle (`crates/ui-egui/src/clipboard_probe.rs`, installed as `Services::clipboard_probe`), only while nothing is copied in the app and a document is open, and the window keeps drawing. A paste itself still reads on the UI thread, so pasting from such an owner waits for it once. Windows and macOS keep the check on the UI thread: Windows only asks which formats the clipboard holds, macOS asks the pasteboard server.
 - **Copied files:** files copied in a file manager (`text/uri-list`; `CF_HDROP` on Windows, file URLs on macOS) paste as the first one that is art (SVG, PDF, EMF/WMF or a bitmap), before the clipboard's other formats (which include the files' paths as text).
-- **Dropping files on the window does not work under Wayland:** winit 0.30, which eframe 0.36 runs on, has no Wayland drag and drop ([winit#1881](https://github.com/rust-windowing/winit/issues/1881), added in winit 0.31; [egui#1563](https://github.com/emilk/egui/issues/1563)), so no `dropped_files` arrive. Until eframe moves to winit 0.31: copy the files in the file manager and paste them, use File › Place or Open, or run the app under XWayland, where drops work (`WAYLAND_DISPLAY= vectorcraft`).
-- **Pens and pen displays under Wayland (#491):** winit 0.30 doesn't bind the Wayland tablet protocol (`zwp_tablet_v2`; tablet input arrives in winit 0.31, [winit#4318](https://github.com/rust-windowing/winit/pull/4318), [egui#7731](https://github.com/emilk/egui/pull/7731)). Since Plasma 6.3, KWin no longer turns tablet input into pointer input for such apps ([kwin!6336](https://invent.kde.org/plasma/kwin/-/merge_requests/6336)): the pen moves the compositor's cursor over the window, but the app gets no motion or presses and shows none of its own cursors. Until eframe moves to winit 0.31, either run the app under XWayland, which supports the tablet protocol and hands the pen to X11 apps as a pointer (`WAYLAND_DISPLAY= vectorcraft`, or `env -u WAYLAND_DISPLAY vectorcraft`; for a desktop launcher, put `env WAYLAND_DISPLAY=` before the command in its `Exec=` line), or turn KWin's deprecated emulation back on for the whole session by setting `KWIN_WAYLAND_EMULATE_TABLET=1` in KWin's environment (for example in a file under `~/.config/environment.d/` or in `/etc/environment`) and logging in again. The pen then works as a mouse, without pressure: winit 0.30 reads pen pressure on Windows only (Windows Ink, which reaches the Liquify tools' Use Pressure Pen). Other compositors that don't emulate a pointer for tablets behave the same way.
+- **Dropping files on the window does not work under Wayland:** winit 0.30, which eframe 0.36 runs on, has no Wayland drag and drop ([winit#1881](https://github.com/rust-windowing/winit/issues/1881), added in winit 0.31; [egui#1563](https://github.com/emilk/egui/issues/1563)), so no `dropped_files` arrive. Until eframe moves to winit 0.31: copy the files in the file manager and paste them, use File › Place or Open, or open the window through XWayland, where drops work: set **Preferences › Performance › Linux Display Server** to **X11 (XWayland)** and restart (#1151), or start the app with `WAYLAND_DISPLAY= vectorcraft`. The preference (`linuxDisplayServer`, read at startup in `apps/vectorcraft/src/main.rs`, shown on Linux only) has winit open the window on X11 (`EventLoopBuilderExtX11::with_x11`) when the session is Wayland, `DISPLAY` is set and the X11 libraries winit loads are installed (`apps/vectorcraft/src/xwayland.rs` reads `ldconfig -p` and the usual library directories); otherwise the window opens on Wayland and the log says why. Unlike clearing `WAYLAND_DISPLAY`, it leaves the clipboard on the compositor's own.
+- **Pens and pen displays under Wayland (#491):** winit 0.30 doesn't bind the Wayland tablet protocol (`zwp_tablet_v2`; tablet input arrives in winit 0.31, [winit#4318](https://github.com/rust-windowing/winit/pull/4318), [egui#7731](https://github.com/emilk/egui/pull/7731)). Since Plasma 6.3, KWin no longer turns tablet input into pointer input for such apps ([kwin!6336](https://invent.kde.org/plasma/kwin/-/merge_requests/6336)): the pen moves the compositor's cursor over the window, but the app gets no motion or presses and shows none of its own cursors. Until eframe moves to winit 0.31, either run the app under XWayland, which supports the tablet protocol and hands the pen to X11 apps as a pointer (Preferences › Performance › Linux Display Server › X11 (XWayland), `WAYLAND_DISPLAY= vectorcraft`, or `env -u WAYLAND_DISPLAY vectorcraft`; for a desktop launcher, put `env WAYLAND_DISPLAY=` before the command in its `Exec=` line), or turn KWin's deprecated emulation back on for the whole session by setting `KWIN_WAYLAND_EMULATE_TABLET=1` in KWin's environment (for example in a file under `~/.config/environment.d/` or in `/etc/environment`) and logging in again. The pen then works as a mouse, without pressure: winit 0.30 reads pen pressure on Windows only (Windows Ink, which reaches the Liquify tools' Use Pressure Pen). Other compositors that don't emulate a pointer for tablets behave the same way.
 
 ## Fonts: craft-fonts (optional build input)
 

docs/effects-parity.md

@@ -1,6 +1,6 @@
 # Effects parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-10 · **Change:** major (first checklist, counted from the effects catalogue) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (PDF raster-effect resolution-cap warnings; Zig Zag's dialog with sliders and radio buttons, #1133; earlier: Brush Strokes landed) · **Target:** Adobe Illustrator 2026 (30.x)
 
 Every entry of Illustrator's Effect menu, by its public feature name, against VectorCraft's effects catalogue
 (`effect_catalog()` in `crates/effects/src/lib.rs`) and the Effect menu built from it
@@ -30,7 +30,9 @@ Part of [target-app-parity.md](target-app-parity.md); open work is in [gaps.md](
 | SVG Filters | Apply SVG Filter… and the filter list | 0/1 | the whole submenu (SVG filters on import round-trip already) |
 | Warp | Arc, Arc Lower, Arc Upper, Arch, Bulge, Shell Lower, Shell Upper, Flag, Wave, Fish, Rise, Fisheye, Inflate, Squeeze, Twist | 15/15 | warp point editing in envelopes |
 
-Document Raster Effects Settings exists.
+Document Raster Effects Settings exists. When the 64 million pixel cap on an effect image lowers
+its resolution, PDF export warns once per object with the requested and the lowest achieved ppi
+(`crates/engine/src/tests_pdfraster.rs`).
 
 ## Photoshop effects
 
@@ -72,6 +74,8 @@ rendering, Turntable, 3D export) is 45–75 h, still the largest single gap.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | minor | PDF cap warnings identify original objects after appearance splitting and report the lowest achieved ppi; cap/rendering and scores unchanged |
+| 2026-10-11 | minor | Zig Zag's dialog: Size and Ridges per segment sliders, Points as Smooth / Corner radio buttons (#1133) |
 | 2026-10-11 | minor | Brush Strokes landed (8 filters): 28/57 Photoshop effects |
 | 2026-10-10 | minor | Initial Revolve landed (#846) |
 | 2026-10-10 | major | First checklist, counted from the effects catalogue (20/57 Photoshop effects, 44/50 Illustrator effects) |

docs/hardware-parity.md

@@ -1,6 +1,6 @@
 # Hardware parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-10 · **Change:** major (first checklist) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (Linux Display Server preference opens the window through XWayland, #1151) · **Target:** Adobe Illustrator 2026 (30.x)
 
 What hardware Illustrator uses, per platform, against VectorCraft. Illustrator's side is from its public
 documentation (GPU Performance, touch workspace, pen pressure pages); ours from the code
@@ -19,7 +19,7 @@ on huge documents. Pen input is pressure-only and Windows-first.
 | Multithreaded rendering off the UI thread | partial | yes | yes | yes | single-threaded | beyond Illustrator |
 | Hybrid-graphics GPU choice | automatic | power-saving GPU by default, Preferences › Graphics Processor | same; DX12 then OpenGL; no Vulkan unless asked (#545, #806) | the desktop's GPU | browser | done |
 | Restart on another GPU when the first fails to present | — | yes (#502, #964) | yes | yes | restart on lost device (#369) | done |
-| Pen pressure | yes (Wacom, Windows Ink, macOS tablet events) | **no** (winit reports none, #852) | yes (pointer force via `WM_POINTER`) | X11 only via XWayland; none on Wayland (#491, #764) | browser pointer events | partial: 4–8 h for macOS and Wayland (winit 0.31) |
+| Pen pressure | yes (Wacom, Windows Ink, macOS tablet events) | **no** (winit reports none, #852) | yes (pointer force via `WM_POINTER`) | X11 only via XWayland (Preferences › Performance › Linux Display Server, #1151); none on Wayland (#491, #764) | browser pointer events | partial: 4–8 h for macOS and Wayland (winit 0.31) |
 | Pen tilt, bearing, barrel rotation (6D Art Pen) | yes, drives brushes | no | no | no | no | missing: 4–8 h after the input layer (#372) |
 | Pen eraser end | yes | no | no | no | no | missing |
 | Touch gestures (pinch zoom, two-finger pan, rotate view, Touch workspace) | yes (Windows touch, Surface) | trackpad pinch and scroll | pinch, pan; two-finger tap undo, three-finger redo (#585) | same where winit reports touch | same | partial: touch workspace and rotate gesture missing, 3–5 h |
@@ -33,4 +33,5 @@ on huge documents. Pen input is pressure-only and Windows-first.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | minor | Preferences › Performance › Linux Display Server › X11 (XWayland) opens the window through XWayland on a Wayland session, where pens and dropped files reach the app (#1151); score unchanged (estimated) |
 | 2026-10-10 | major | First checklist from the canvas, touch and graphics code and the open hardware issues |

docs/mcp.md

@@ -69,6 +69,7 @@ the suite) keep the agent to the folders you give it:
 - Every file a command writes must lie inside the **write root**: `save_file`, `export`, the save and
   export commands, Export for Screens, Package, Export for Web, print to file, `screenshot {path}`,
   library and preset saves to a path.
+- `file.list {path}` (through `run_command`) lists a folder's files and folders, held to the read root like any read, so an agent can see what it was given (#1163).
 - Read and write access are separate. Give the same folder twice for both; a root left out grants none
   of its access (with only `--automation-read-root`, nothing can be written to disk, though `export` and
   the save commands without a path still return the bytes). Without either flag nothing changes.
@@ -235,9 +236,9 @@ The older names below remain listed because existing workflows use them.
 |---|---|
 | `command_list` | Optional `filter`, `enabled_only`; returns the command array |
 | `command_run` | `id`, optional `params`; runs the command through the existing backend |
-| `command_batch` | `steps: [{id, params?}]`, optional `stop_on_error` (default true); returns `completed`, `failed`, `results: [{ok, result\|error}]`. Each edit has its own undo step; failures set `isError`. A param string `"$N.path"` or `"$last.path"` takes a value from an earlier step's result (see `run` below) |
+| `command_batch` | `steps: [{id, params?}]`, optional `stop_on_error` (default true), `atomic` and `label`; returns `completed`, `failed`, `results: [{ok, result\|error}]`. Each edit has its own undo step, or with `atomic: true` the batch's edits are one undo step named `label` (else after its first edit; `edit.undoGroup.begin`/`end` underneath); failures set `isError`. A param string `"$N.path"` or `"$last.path"` takes a value from an earlier step's result (see `run` below) |
 | `doc_inspect` | Optional `depth`, `childLimit`; same summary as `inspect_document` |
-| `render_preview` | Optional `max_side` (1–4096, default 1024); inline PNG of the first artboard without editing it. Artboards too large to render within the allocation bound return a tool error |
+| `render_preview` | Optional `max_side` (1–4096, default 1024) and `artboard` (0-based, default 0); inline PNG of that artboard without editing it. Artboards too large to render within the allocation bound return a tool error |
 | `ui_inspect`, `ui_screenshot` | Connected desktop state/window capture; tool errors in headless mode |
 
 Every tool declares read-only, destructive, idempotent and open-world hints. File-writing
@@ -253,6 +254,9 @@ explicit `ids`.
 
 Paint values (`fill`, `stroke`) accept `"#rrggbb"`, `"none"`, `[r,g,b]` (0..1), `{"c","m","y","k"}`, `{"gray"}`,
 or a full `paint.setFill` params object (`{"gradient": …}`, `{"swatch": "name"}`).
+For `draw_shape` and `draw_path`, omitted paint fields inherit the current [new-art appearance](#new-art).
+For a filled shape or path without an outline, pass an explicit `fill` and `stroke: "none"`.
+Lines start with no fill and a visible stroke.
 The Fill/Stroke proxy commands run through `run_command`: `paint.invert` and `paint.complement` recolour the active
 proxy keeping each colour's model, `paint.lastColor` / `paint.lastGradient` re-apply the last solid colour or gradient,
 and `paint.recent` returns the recent colours that every paint command (and the eyedropper) feeds.
@@ -286,6 +290,9 @@ objects' fills or strokes differ (`fillMixed` / `strokeMixed`, drawn as a "?" pr
 | `text_wrap` | `{ids?, offset?, invert?, release?}` | Area type below the objects (same layer) flows around them. |
 | `undo` / `redo` | `{}` | Many calls that change nothing record no undo step, for example `object.align` with nothing to move, `object.move` by 0 without `copy` and `object.showAll` with nothing hidden. `undo` (`edit.undo`) after such a call undoes the step before it. `inspect_document` lists the undo steps as `history`. |
 
+For SVG/SVGZ, `export`'s top-level `outlineText: true` writes text as paths; DXF takes it too (its type is outlined anyway unless `preserve: editability`).
+PDF instead uses `options: {"advanced": {"outlineText": true}}`; its default is false (live text).
+
 With `mods.shift`, a marquee dragged with the Selection tool toggles the objects it reaches (the selected ones leave
 the selection, the others join it, the rest stays), and one dragged with Direct or Group Selection toggles the anchors
 inside it (a path left with none leaves the selection, one with all of them is selected whole). The Lasso adds anchors
@@ -1434,8 +1441,9 @@ size. The journal entry of a scaling command records the `strokes` and `corners`
 ## Live Corners
 
 `object.setLiveShape {id?, ids?, radius?, kind?, corners?, items?}` sets the corners of any path (one undo step): a live
-rectangle's or polygon's, a star's, a pen path's. A corner is an anchor without handles between two straight sides
-(not an open path's ends, not a smooth anchor, not one the sides run straight on through). `radius` (pt) and `kind`
+rectangle's or polygon's, a star's, a pen path's. A corner is an anchor where two sides, straight or curved, meet at an angle
+(not an open path's ends, not a smooth anchor, not one the sides run straight on through); a curved side is trimmed to
+what the cut leaves of it. `radius` (pt) and `kind`
 (`round`, `invertedRound` or `chamfer`) go to the `corners` given, else to the corners holding a Direct-Selected
 anchor (`select.anchors`), else to every corner. `corners` are anchor indices of the path with its corners uncut,
 counting every subpath's anchors in order: a rectangle's 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; a
@@ -1692,6 +1700,7 @@ a pin back restores the original; every pin must be on the art's mesh, and empty
 
 ## New art
 
+Initially (and after `paint.default`) new art has a white fill and a 1 pt black stroke.
 New objects take the fill and stroke proxies (`paint.setFill` / `paint.setStroke` and the weight, whatever is
 selected) on top of a template. With nothing selected, `stroke.set` / `stroke.setAdvanced` (cap, join, dashes,
 arrowheads, profile…) and `graphicStyle.apply` (every fill, stroke and effect, opacity, blend mode and the link to the
@@ -3076,8 +3085,9 @@ among the objects takes the others in as more key objects, keeping its options,
 A blend's spine is the straight lines between its key centres until it is edited. `object.blend.info` lists it
 (`spine.anchors`, `keyAnchors`: the point each key sits on). `object.blend.spine.addAnchor {x, y}` adds a point where
 the spine passes nearest, `object.blend.spine.moveAnchor {anchor, x, y}` moves a point (a key on it moves along; with
-`handle: "in" | "out"` it places that handle) and `object.blend.spine.removeAnchor {anchor}` deletes a point no key
-sits on; the first edit turns the spine into a path. Moving a key moves its end of the spine. Release
+`handle: "in" | "out"` it places that handle), `object.blend.spine.reshapeSegment {segment, t, dx, dy}` bends a segment
+so its point at `t` moves by (dx, dy), turning a straight spine into a curve, and `object.blend.spine.removeAnchor
+{anchor}` deletes a point no key sits on; the first edit turns the spine into a path. Moving a key moves its end of the spine. Release
 (`object.blend.release`) leaves the spine as a path that paints nothing (`spines` in the result):
 
 ```json

docs/releasing.md

@@ -116,11 +116,12 @@ to the target triple, so host build scripts aren't affected.
   candidates replace each other.
 - Double-clicking the MSI opens a setup wizard (WixUI_InstallDir without the licence page):
   Welcome, install folder (remembered for upgrades in `HKLM\Software\VectorCraft\InstallDir`),
-  Ready, a progress page, and a Finish page that says where to find the app, with a ticked "Launch
-  VectorCraft" box. The pages name the full version (`vectorcraft.en-us.wxl`). `package.ps1` draws
-  the wizard's banner and side bitmaps from the app icon, so no WiX stock art ships. `msiexec /qn`
-  still installs silently. Building needs the WiX UI and Util extensions:
-  `wix extension add -g WixToolset.UI.wixext/5.0.2 WixToolset.Util.wixext/5.0.2`.
+  Shortcuts (a ticked "Create a desktop shortcut" box), Ready, a progress page, and a Finish page
+  that says where to find the app, with a ticked "Launch VectorCraft" box. The pages name the full
+  version (`vectorcraft.en-us.wxl`). `package.ps1` draws the wizard's banner and side bitmaps from
+  the app icon, so no WiX stock art ships. `msiexec /qn` still installs silently, with the desktop
+  shortcut unless `INSTALLDESKTOPSHORTCUT=""` is passed. Building needs the WiX UI and Util
+  extensions: `wix extension add -g WixToolset.UI.wixext/5.0.2 WixToolset.Util.wixext/5.0.2`.
 - The ARM64 build is cross-compiled on the x64 runner. `.github/workflows/windows-arm64.yml`
   installs that MSI on a Windows 11 ARM64 runner, checks that both installed programs are ARM64,
   runs `vectorcraft-cli --version` natively and uninstalls.

docs/roadmap.md

@@ -1,6 +1,6 @@
 # Roadmap: milestones and what's next
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (G11 and Current focus: #893 fixed, #937 open; M7: accurate character controls after object/group scaling, #1034) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (M9: PDF raster-effect cap warnings; G11: #893 fixed, #937 open; M7: accurate character controls after scaling, #1034; estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
 
 Forward-looking plan. Where VectorCraft stands is in [`ROADMAP.md`](../ROADMAP.md) and
 [target-app-parity.md](target-app-parity.md); the ranked work list is [gaps.md](gaps.md). Hours are Opus 5.5
@@ -56,7 +56,7 @@ Checked 2026-10-10 from the code, tests and open issues; no workflow fails, so V
 | M6 | Path operations (Pathfinder, Shape Builder, offset…) | ✅ mostly done (Boolean precision on almost-horizontal edges fixed and the property tests made deterministic; Shape Builder gap detection, large-offset bug open) | 3–6 |
 | M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Document-point character controls after object/group scaling (#1034; optional font-size preservation remains separate), Character/Paragraph Styles, per-paragraph paragraph attributes, Area Type Options (with Width/Height, Auto Size and Shrink Text to Fit; overflow reported to agents and vertical Align), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (fonts registered with Windows outside its font folders, the XDG and Flatpak host font folders on Linux, and fonts installed while the app runs, listed when it comes back to the front; searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, filter by script and kind, list a family's styles, and star favourites; the Glyphs panel and Find Font's Replace With use the same menu without the live preview) and found by name on open/import, variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects and Options with draggable start/centre/end brackets (slide, flip), tab stops + Tabs panel (Above Text floats it over the selected text, its ruler at the canvas zoom so stops line up with the columns, #729), inline symbols in text (beyond parity), Hebrew/Arabic bidirectional text, Paragraph Direction, Every-line/Single-line Composer per object (ragged text too) done; tab leaders, spell check, vertical type pending | 45–60 |
 | M8 | Transform & distort (Puppet Warp, Liquify tools, Envelopes, Blends, Perspective Grid) | ✅ done (M8.1–M8.20 on 2026-10-06, fidelity pass): Liquify Tool Options with one shared brush, pen pressure, hold-to-apply, a safe scope and incremental strokes; tool options that last; Puppet Warp rotation, multi-select, Control bar and a rest-shape session that follows Undo; Width tool on compound paths; Envelope dialogs with preview, Reset with Warp/Mesh, full Envelope Options, type/images/symbols/appearance/gradients/patterns distorted on canvas and in every export, warps that keep their frame, Edit Contents, mesh handles and Control bar; Blend Options, anchor-targeted Blend tool, editable spine, keys picked on the canvas, faithful interpolation and knockout; Perspective Grid with Define Grid, presets, lock/snap/rulers, widgets, the 1–4 plane switch, movable planes, Perspective Selection scale/copy/perpendicular/Transform Again, and type and symbols truly projected with Edit Text. Left: Anti-Alias and Preserve Shape output, warp-envelope point editing, brush interpolation in blends, Free Transform/Scale/Reflect along a rotated box | 2–4 |
-| M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder, Color Adjustments and Document Raster Effects Settings; initial Revolve only; SVG Filters, remaining raster effects and 3D pending | 81–130 |
+| M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder, Color Adjustments and Document Raster Effects Settings; PDF export warns when the pixel cap lowers raster-effect resolution; initial Revolve only; SVG Filters, remaining raster effects and 3D pending | 81–130 |
 | M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG `<pattern>`/PDF export) and live Repeat (radial/grid/mirror) done; brushes/symbols in progress | 23–37 |
 | M11 | Artboards & views (artboard panel/tool with Move Artwork for X/Y fields and Artboard Options, Trim View, middle-button pan, print tiling and the status bar's artboard navigator done; multiple windows, presentation polish) | 🟡 | 15–25 |
 | M12 | Advanced color & art (CMYK/ICC, separations, Gradient Mesh, Live Paint, Image Trace, Graphs) | 🟡 Gradient Mesh, Live Paint, Image Trace (13 presets, 18 ms/1k² image; the Flat Logo mode places edges to a fraction of a pixel, restores sharp corners, snaps lines and circles, and refuses gradients), Recolor Artwork, colour management (ICC, soft proofing, separations preview), Graphs (all 9 tools, Graph Data/Type, group-selected series colours persist through regenerate/save/open) done; graph Design/Column/Marker designs pending | 6–10 |
@@ -79,6 +79,7 @@ After placed documents (File › Place of a `.vectorcraft` file, linked), M4.14
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | minor | M9: PDF raster-effect resolution-cap warnings verified with real capped/uncapped exports; scores and hours unchanged |
 | 2026-10-11 | minor | #893 (Shape Builder seams on grids of lines) fixed; G11 keeps #937 and its 8–15 h |
 | 2026-10-10 | minor | M7: document-point character sizes, leading and baseline shift, and resettable horizontal stretching after object/group scaling (#1034). Optional group font-size preservation remains separate; scores/hours unchanged. |
 | 2026-10-10 | minor | M9 row from main: initial Revolve |

docs/target-app-parity.md

@@ -1,6 +1,6 @@
 # Parity with Adobe Illustrator
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (Type advanced: proportional vertical metrics (`vpal`) done, #966; Shape Builder: #893 fixed, merged regions of crossing lines no longer keep seams; scores unchanged while #937 is open; #1034: document-point character controls after object/group scaling; full readiness recomputed as the standard's additive weighted sum, ~62%; per-audience hours; essentials-user score ~75% added; ready-for-real-work re-examined: 50% → 55%, mainstream 65% added; earlier the same day: full re-measure against Illustrator 2026 30.x; merged the ROADMAP's parity estimate, honest assessment and "Shipped so far" into this file) · **Target:** Adobe Illustrator 2026 (30.x; public release notes through 30.7, August 2026)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (PDF export warns when the pixel cap lowers raster-effect resolution; Drawing tools: Live Corners round corners between curved sides, #1144; Type advanced: proportional vertical metrics (`vpal`) done, #966; Shape Builder: #893 fixed, merged regions of crossing lines no longer keep seams; scores unchanged while #937 is open; #1034: document-point character controls after object/group scaling; full readiness recomputed as the standard's additive weighted sum, ~62%; per-audience hours; essentials-user score ~75% added; ready-for-real-work re-examined: 50% → 55%, mainstream 65% added; earlier the same day: full re-measure against Illustrator 2026 30.x; merged the ROADMAP's parity estimate, honest assessment and "Shipped so far" into this file) · **Target:** Adobe Illustrator 2026 (30.x; public release notes through 30.7, August 2026)
 
 The authoritative parity assessment. [`ROADMAP.md`](../ROADMAP.md) summarizes it; [`gaps.md`](gaps.md) is
 the work list made from it. Deep areas have their own checklists: [UI and interaction](ui-parity.md),
@@ -68,7 +68,7 @@ dominate; 3D, graphs and automation are specialist). They sum to 105. Feature de
 | Area | Weight | Done | Main gaps | One agent (h) | Kind |
 |---|---:|---:|---|---:|---|
 | Selection, transform & align tools | 6 | 85% | Free Transform/Scale/Reflect along a rotated box, Start Global Edit, transform nuances | 4–6 | estimated |
-| Drawing tools (Pen, Curvature, Pencil, shapes, Shaper) | 7 | 85% | Shaper construction widget, Pencil/Pen nuances, Blob Brush options, Touch Type, Dimension tool, Live Corners on curved corners; see [ui-parity.md](ui-parity.md) | 8–13 | estimated |
+| Drawing tools (Pen, Curvature, Pencil, shapes, Shaper) | 7 | 85% | Shaper construction widget, Pencil/Pen nuances, Blob Brush options, Touch Type, Dimension tool, Live Corners' Relative rounding; see [ui-parity.md](ui-parity.md) | 8–13 | estimated |
 | Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 80% | Shape Builder misses planar regions in real files (#937), its gap detection and options; Live Paint Gap Options | 4–8 | estimated (lowered from 86%: open issues) |
 | Colour, swatches, gradients, patterns, mesh, recolor | 7 | 92% | 30.0's gradient dither, perceptual blending and gradient presets; freeform and mixed spot/process gradients in SVG/PDF | 4–7 | estimated (lowered from 96%: target moved) |
 | Strokes, brushes, width profiles | 5 | 88% | Art brush Overlap, Pattern brush auto corners, brush libraries, pen pressure on macOS, tilt/bearing/rotation | 8–15 | estimated |
@@ -297,7 +297,7 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Area | Weight | Done | Missing (main items) | One agent (h) |
 |---|---:|---:|---|---:|
 | Selection, transform & align tools | 6 | 85% | Free Transform/Scale/Reflect along a rotated box, Start Global Edit, transform nuances (the rotated persistent bounding box is done) | 4–6 |
-| Drawing tools | 7 | 85% | rough-square Shaper recognition and orientation steps corrected; editable Shaper Groups landed; remaining: Shaper construction widget/gesture refinements, pencil and the remaining pen modifier nuances, the freehand Tool Options' Keep selected, Alt to the Smooth tool, Blob Brush Merge Only with Selection and brush angle/roundness, Touch Type, Live Corners on corners between curved sides (and Relative rounding) | 8–13 |
+| Drawing tools | 7 | 85% | rough-square Shaper recognition and orientation steps corrected; editable Shaper Groups landed; remaining: Shaper construction widget/gesture refinements, pencil and the remaining pen modifier nuances, the freehand Tool Options' Keep selected, Alt to the Smooth tool, Blob Brush Merge Only with Selection and brush angle/roundness, Touch Type, Live Corners' Relative rounding | 8–13 |
 | Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 86% | Live Paint gap options, Shape Builder gap detection, options (Tool Options dialog, clicking a stroke in merge mode) and Shift-drag marquee | 3–6 |
 | Colour, swatches, gradients, patterns, mesh, recolor | 7 | 96% | freeform and mixed spot/process gradients in SVG/PDF (exported as stops or process colours), pattern fills in Expand | 2–4 |
 | Strokes, brushes, width profiles | 5 | 90% | the Art brush's Overlap, auto-generated Pattern brush corners and new tile art in Pattern Brush Options (Brush Options for every brush type done), brush libraries (generated in code), pen pressure on macOS (the windowing layer reports none there), brushes driven by pen tilt, bearing and barrel rotation (6D art pens) | 8–15 |
@@ -353,7 +353,7 @@ since 2026-10-01.
 | **Bundled content:** brush, symbol, style and swatch libraries | ~30% | Ours are original and generated in code, and far fewer than Illustrator ships; brush and symbol libraries are still missing |
 | **Performance** | unverified | Multithreaded, off-thread rendering and caches are in place. The last budget run (2026-10-01, loaded machine) measured 290 ms for a 50k-path fit against a 16 ms budget. Re-run `vectorcraft-cli perf` on an idle machine |
 | **Robustness** | good, new | ~2,840 tests, property tests, no panics in shipped code (lints, the `guard` safety net, import fuzzing), Data Recovery. Missing: a corpus of real-world files, Windows/Linux/browser QA |
-| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); on macOS the menus are in the system menu bar, laid out as a Mac app's, with the in-window menus as a fallback (`--in-window-menus`; verified on Windows and by cross-compilation, not yet by hand on a Mac); hybrid-graphics laptops render on the power-saving GPU by default on Windows and macOS (#306), and Windows starts on Direct3D 12, falling back to OpenGL, and loads no Vulkan driver unless `WGPU_BACKEND` asks for it (#545: Vulkan flickered black on an Intel GPU, DX12 and OpenGL didn't; #806: a faulty Vulkan driver crashed the app before its window appeared; verified by unit tests and the reporter's runs with `WGPU_BACKEND`), and Linux on the GPU the desktop runs on, since a Wayland compositor may refuse frames from the other one; a window that fails on its GPU while starting up starts again on the next one instead of crashing (#502; the dual-GPU Wayland case is verified by unit tests and cross-compilation, not on such hardware); web drops land in the document they were dropped on (#359); desktop drops carry no pointer position (winit 0.30), so a dropped document opens as a tab of its own and a picture or text is placed in the middle of the view, while the web places anything dropped on the canvas and opens what is dropped off it, as Illustrator does (#472); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); on Linux/Wayland the clipboard reads the compositor's own (data-control) and copied image files paste, but files can't be dropped on the window under Wayland until eframe moves to winit 0.31 (#398; the Wayland side is verified by compilation only); on Linux the Paste menu checks the system clipboard on a background thread, so a clipboard owner that never answers no longer freezes the window, while Windows and macOS keep their quick in-line check (#510; the X11 hang verified by the contributor, here by headless tests); on KDE Plasma 6.3+ under Wayland, pens and pen displays reach the app only under XWayland (`WAYLAND_DISPLAY=`) or with KWin's `KWIN_WAYLAND_EMULATE_TABLET=1`, since winit 0.30 has no Wayland tablet input (#491, not verified on hardware); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) |
+| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); on macOS the menus are in the system menu bar, laid out as a Mac app's, with the in-window menus as a fallback (`--in-window-menus`; verified on Windows and by cross-compilation, not yet by hand on a Mac); hybrid-graphics laptops render on the power-saving GPU by default on Windows and macOS (#306), and Windows starts on Direct3D 12, falling back to OpenGL, and loads no Vulkan driver unless `WGPU_BACKEND` asks for it (#545: Vulkan flickered black on an Intel GPU, DX12 and OpenGL didn't; #806: a faulty Vulkan driver crashed the app before its window appeared; verified by unit tests and the reporter's runs with `WGPU_BACKEND`), and Linux on the GPU the desktop runs on, since a Wayland compositor may refuse frames from the other one; a window that fails on its GPU while starting up starts again on the next one instead of crashing (#502; the dual-GPU Wayland case is verified by unit tests and cross-compilation, not on such hardware); web drops land in the document they were dropped on (#359); desktop drops carry no pointer position (winit 0.30), so a dropped document opens as a tab of its own and a picture or text is placed in the middle of the view, while the web places anything dropped on the canvas and opens what is dropped off it, as Illustrator does (#472); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); on Linux/Wayland the clipboard reads the compositor's own (data-control) and copied image files paste, but files can't be dropped on the window under native Wayland until eframe moves to winit 0.31 (#398; the Wayland side is verified by compilation only), so Preferences › Performance › Linux Display Server › X11 (XWayland) opens the window through XWayland, where drops work (#1151; verified by unit tests and cross-compilation, not on a Wayland desktop); on Linux the Paste menu checks the system clipboard on a background thread, so a clipboard owner that never answers no longer freezes the window, while Windows and macOS keep their quick in-line check (#510; the X11 hang verified by the contributor, here by headless tests); on KDE Plasma 6.3+ under Wayland, pens and pen displays reach the app only under XWayland (`WAYLAND_DISPLAY=`) or with KWin's `KWIN_WAYLAND_EMULATE_TABLET=1`, since winit 0.30 has no Wayland tablet input (#491, not verified on hardware); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) |
 | **Agent automation** | beyond Illustrator | Every command, gesture and dialog is drivable over MCP, the CLI and the control channel; what an agent reads and writes on disk can be confined to chosen folders (`--automation-read-root` / `--automation-write-root`, as in PhotoCraft, #832) |
 | **Scrubby numeric fields** | beyond Illustrator | As in Photoshop, dragging a numeric field's label (`W:`, `Opacity:`, the Character panel's icons) left or right steps its value live; one undo step per drag, Escape cancels (#400) |
 
@@ -406,7 +406,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - **Cutting:** Eraser, Scissors, Knife, Mirror & Cut, Line Cut and Rectangle Cut (real geometry, compound paths keep their holes).
   - **Transform:** Rotate, Reflect, Scale, Shear (click or Alt-click snaps the reference point to anchors and centres; Alt-click opens the tool's dialog, and a drag with Alt down at the release, from the press or pressed mid-drag, transforms a copy), Reshape, Free Transform (free and perspective distort and shear, switched by the keys held during a handle drag).
     Align, Distribute, Distribute Spacing, Reflect and Shear return an error for any `horizontal`, `vertical`, `to`, `axis`, `bounds` or `spacing` value they don't take, listing the choices, and Align returns one when a call gives neither `horizontal` nor `vertical`; nothing moves and no undo step is recorded.
-  - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout; with Direct Selection, select corner anchors to show and round just those corners (#381). Each corner keeps its own radius and kind (Round, Inverted Round, Chamfer): Alt-click a widget to cycle the kind, double-click it for the Corners dialog, and the Properties and Transform radius fields set the selected corners (`object.setLiveShape {corners, radius, kind}`). Corners stay circular when the rectangle is scaled unevenly or along its own sides when rotated (the radius keeps its size, or scales by the mean scale with Scale Corners on); only a shear distorts them. On a rectangle that isn't square every corner is the same circle: a radius past half the shorter side stops there for all of them, the widgets sit on the corners as drawn and turn the edited corners red at that limit, CSS export writes the drawn radii, and rectangles saved stretched by older versions get circular corners when their corners are next set (#442). Live Corners work on any path's corners too, as on a rectangle's (#511): a star's, a live polygon's (which also shows them to the Selection tool, has a Corner Radius field in the Properties and Transform panels and keeps its radius as its sides change) and a pen path's, wherever two straight sides meet at an anchor. Direct Selection shows the widgets of every corner, or of the corners holding selected anchors; each corner is a circle tangent to both sides, drawn no larger than takes its cut halfway along its shorter side; a path keeps its uncut outline so its corners stay editable, and the same command, dialog, angle preference and View › Hide Corner Widget apply.
+  - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout; with Direct Selection, select corner anchors to show and round just those corners (#381). Each corner keeps its own radius and kind (Round, Inverted Round, Chamfer): Alt-click a widget to cycle the kind, double-click it for the Corners dialog, and the Properties and Transform radius fields set the selected corners (`object.setLiveShape {corners, radius, kind}`). Corners stay circular when the rectangle is scaled unevenly or along its own sides when rotated (the radius keeps its size, or scales by the mean scale with Scale Corners on); only a shear distorts them. On a rectangle that isn't square every corner is the same circle: a radius past half the shorter side stops there for all of them, the widgets sit on the corners as drawn and turn the edited corners red at that limit, CSS export writes the drawn radii, and rectangles saved stretched by older versions get circular corners when their corners are next set (#442). Live Corners work on any path's corners too, as on a rectangle's (#511): a star's, a live polygon's (which also shows them to the Selection tool, has a Corner Radius field in the Properties and Transform panels and keeps its radius as its sides change) and a pen path's, wherever two sides meet at an angle at an anchor that isn't smooth: curved sides too, trimmed to what the cut leaves of them (#1144). Direct Selection shows the widgets of every corner, or of the corners holding selected anchors; each corner is a circle tangent to both sides, drawn no larger than takes its cut halfway along its shorter side; a path keeps its uncut outline so its corners stay editable, and the same command, dialog, angle preference and View › Hide Corner Widget apply.
   - **Pen:** Alt pressed in the middle of dragging out an anchor splits its handles and keeps the curve already shaped into it (only the outgoing handle follows the pointer); Space held while dragging out an anchor moves it, handles and all. A press on the first anchor of the path being drawn closes it whatever the drag then does: the drag shapes the closing curve (symmetric handles, Alt breaks them) and the release closes the path wherever it ends (#501). Clicking the last anchor of the path being drawn retracts its outgoing handle (convert cursor), and dragging from it pulls out a new one on its own. Auto Add/Delete: over a selected path, a click on a segment adds an anchor and a click on an anchor deletes it (add and delete cursors); Shift held, or Preferences › General › Disable Auto Add/Delete, starts a new path instead. Alt held over a handle end or an anchor of a selected path (the one being drawn too) works as the Anchor Point tool, with its convert cursor: dragging a handle moves it alone, clicking a smooth anchor makes it a corner, dragging an anchor pulls out new symmetric handles, dragging a segment reshapes it; drawing then goes on. Cmd (Ctrl) held drags with the selection tool chosen last, Direct Selection until one is (handles, anchors and segments of the path being drawn or another), and the Pen then goes on drawing its path while that stays selected; the pointer shows that tool's while Cmd is held. The same holds for agents (`pointer_gesture` with `mods.cmd`), as the borrowing now lives in the engine (#494).
   - **Path editing (#494):** the handles shown are the handles that drag: Direct Selection drags those of a path selected as a whole (as the Pen leaves it), the Anchor Point tool and Pen+Alt no longer grab handles that Show handles when multiple anchors are selected hides, a handle shorter than the tolerance leaves its anchor to be picked, and the anchor tools pick within Selection & Anchor Display › Tolerance. A dragged segment keeps a smooth anchor at either end smooth. With Direct Selection, the Pen, the Curvature and the anchor tools, a path selected as a whole shows all its anchors selected, and the Control bar and the Properties panel offer Convert (corner, smooth) for them too; Remove and Cut wait for anchors direct-selected (#504). A handle drag gathers its snap targets once per drag (it took 21 ms per pointer move on a 20,000-path document, now 1 ms; `vectorcraft-cli perf` measures handle and segment drags on a 5,000-anchor path).
   - **Graphs:** Column, Stacked Column, Bar, Stacked Bar, Line, Area, Scatter, Pie and Radar graph tools with Graph Data and Graph Type. A series starts in greyscale; Group Selection's fill and stroke are kept separately on the graph and reapplied when its data, type or size changes, and through save, open and undo. Graph Type's Override Calculated Values (both `axisMin` and `axisMax`) uses exactly that value-axis range, split into the tick count (5 when automatic). Line graphs take Edge-to-Edge Lines (off by default: the points sit at the centres of their categories; graphs saved before the option keep their edge-to-edge lines), and radar graphs follow Mark Data Points and Connect Data Points. Blank cells (an empty CSV cell or `null`) are values left out, not zeros: columns, bars and stacked segments skip them, lines and scatter lines break around them and the value axis ignores them, while area, pie and radar draw them as 0; a number in straight quotes is a label, and the data window writes it back quoted. Graph types combine: Graph Type on series picked with Group Selection (or `series` indexes) draws them as their own type, with column, stacked column, line and area mixing on the vertical value axis and bar and stacked bar on the horizontal one; stacked columns take one slot of the cluster, lines draw in front of columns and areas behind. The value axis goes on the left, the right or both sides (column, stacked column, line, area and scatter graphs; bar graphs keep theirs along the bottom), and Separate Scales gives the series assigned to the right axis a scale of their own with its own tick values. Each value axis takes tick marks of no, short or full (across the plot) length and a count per division, and a prefix and suffix for its numbers; the category axis takes tick marks too (none by default), at or between its labels. Graph Design, Column and Marker artwork remain open.
@@ -455,11 +455,15 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
 - **Performance:** 20k shapes + 1k texts render in 27 ms per full-retina frame (7.8 ms zoomed), 7× faster than the first version. The UI thread never blocks. The web build is 7.1 MB gzipped.
 - **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so any GPU that can show the window will do. Preferences › Performance › Graphics Processor (`gpuPreference`) is Automatic by default: the power-saving GPU on Windows and macOS (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306), and the GPU the desktop runs on under Linux, where KWin on an NVIDIA GPU refused frames from a Ryzen's integrated GPU and 0.5.0 crashed at startup (#502). Power Saving and High Performance pick a kind of GPU; `WGPU_POWER_PREF`, `WGPU_ADAPTER_NAME` and `WGPU_BACKEND` override them. The app picks among the adapters that can present to the window (native backends before OpenGL, hardware before software, and on Windows a GPU's DX12 adapter before its Vulkan one: Intel's Vulkan driver made the whole window flicker black, #545), and if the window fails on one while starting up it starts again without it instead of crashing; Help › About, `ui.inspect` and the log name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369). On Windows and Linux the tools' cursors are OS cursors (bitmaps rasterized once per display scale), which the system moves itself: painted into the window, they trailed the pointer by the frames waiting to be shown, and the window now queues one frame instead of two (#444). macOS and the web still paint them (macOS sizes cursor bitmaps in points, eframe has no bitmap cursors on the web). Pens and touch drive the tools as the mouse does, and a tap pressed and lifted within one frame clicks where it tapped (#491); pen pressure reaches the Liquify tools' Use Pressure Pen on Windows, while winit 0.30 reports none on macOS or Linux and egui none on the web. On Linux, see `docs/development.md` for pens under Wayland.
 - **Tests and robustness:** ~2,840 automated tests: model-based property tests, a junk-parameter sweep over every command, import fuzzing (SVG, PDF, libraries), golden renders, and MCP end-to-end tests over stdio. Shipped code never panics (workspace lints and a rollback safety net; see `docs/development.md`).
+- **Raster-effect resolution in PDF:** when the 64 million pixel cap on an effect image renders an object's raster effects below the document's raster effects resolution, PDF export warns once per object with the requested and the lowest achieved ppi (`crates/engine/src/tests_pdfraster.rs`).
 
 ## Revision history
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | minor | PDF raster-effect cap reductions are reported per original object with requested/achieved ppi; scores and hours unchanged |
+| 2026-10-11 | minor | Platforms: Preferences › Performance › Linux Display Server opens the window through XWayland, where file drops work (#1151); score unchanged (estimated) |
+| 2026-10-11 | minor | Drawing tools: Live Corners on corners between curved sides (#1144) leaves the missing list; score and hours unchanged at this rounding (estimated) |
 | 2026-10-11 | minor | Type advanced: Proportional Metrics in vertical type (`vpal`, #966) leaves the missing list; score and hours unchanged at this rounding (estimated) |
 | 2026-10-11 | minor | Shape Builder #893 fixed (planar-map faces share their corners exactly, so merges leave no seams); Path operations stays 80% and Shape Builder 70% while #937 is open (estimated) |
 | 2026-10-10 | minor | Merged main: initial live Revolve landed (#846). 3D 0% → ~8% (50–85 h), menu stubs 28 → 27; depth, readiness and totals unchanged within rounding |

docs/type-parity.md

@@ -1,6 +1,6 @@
 # Type parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (Proportional Metrics in vertical type, `vpal`, #966; document-point character controls after object/group scaling, #1034) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (the caret steps over whole clusters such as Thai consonants with their marks; Thai typed in a font without Thai falls back to a font made for Thai; earlier: Proportional Metrics in vertical type, `vpal`, #966) · **Target:** Adobe Illustrator 2026 (30.x)
 
 Type is Illustrator's largest single area by use (weight 13 of 105 across "Type core" and "Type advanced" in
 [target-app-parity.md](target-app-parity.md)). This checklist lists the features one by one. Status is from the
@@ -27,6 +27,7 @@ against Illustrator's public documentation; **estimated** unless noted.
 | Preserve font sizes while scaling a group | missing | Separate enhancement; scaling still scales text with the other artwork. |
 | OpenType panel, Glyphs panel, alternates | done | Highlight Alternate Glyphs preference unused (#394) |
 | Font menu: samples, live preview, filters, favourites; font matching by any name; Find Font | done | #339 |
+| Missing glyphs set in an installed font made for their script (Thai, Lao, Khmer, Myanmar first; then any font that has them) | done | Thai: Leelawadee UI, Tahoma, Thonburi, Sukhumvit Set, Noto Sans Thai, TLWG |
 | Variable fonts | partial | named instances as styles; axis sliders missing |
 | Colour fonts (OpenType SVG / COLR) | partial | |
 | Every-line and Single-line composers | done | tuned by eye, never compared side by side |
@@ -36,6 +37,7 @@ against Illustrator's public documentation; **estimated** unless noted.
 | Hidden characters (Show Hidden Characters) | done | `type.hiddenCharacters` |
 | Spell check (Check Spelling, Auto Spell Check, custom dictionary) | missing | menu stubs; needs an openly licensed dictionary |
 | Smart Punctuation, Change Case, Find & Replace | done | |
+| Caret: the arrows and Delete step over whole clusters (Thai consonant with its marks, combining accents, emoji); Backspace removes one character | done | |
 | Touch Type tool | missing | listed in the toolbar, not implemented |
 | Retype (identify fonts in outlines/images) | missing | Illustrator's uses a cloud model |
 | Snap to Glyph | missing | menu stub |
@@ -51,6 +53,8 @@ against Illustrator's public documentation; **estimated** unless noted.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | minor | The Type tool's arrows and Delete move by grapheme cluster, never between a Thai consonant and its vowel or tone marks; score unchanged (estimated) |
+| 2026-10-11 | minor | Thai (Lao, Khmer, Myanmar) missing from the font in use falls back to an installed font made for the script instead of whichever face covering it loaded first; score unchanged (estimated) |
 | 2026-10-11 | minor | Proportional Metrics done: `palt` in horizontal type, `vpal` in vertical type (#966, #1082); ruby and manual tate-chu-yoko still missing |
 | 2026-10-10 | minor | #1034: transformed character controls and regression coverage; preserving group font sizes remains a separate enhancement. Scores/hours unchanged at this rounding. |
 | 2026-10-10 | major | First checklist, split out of the parity table's Type core and Type advanced rows |

docs/ui-parity.md

@@ -1,6 +1,6 @@
 # UI and interaction parity
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (Edit Toolbar: the All Tools drawer beside the toolbar, tools dragged in and out, #1018; earlier: Direct Selection whole-path drags and Alt-drag copies, #1104) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (a marquee needs to touch a path, not just lie inside its fill, #1103; earlier: Live Corners round corners between curved sides, #1144) · **Target:** Adobe Illustrator 2026 (30.x)
 
 How VectorCraft's tools, handles, snapping and panels behave next to Illustrator's. A vector illustrator's
 trust is in the details: where a handle lands, what Shift and Alt do mid-drag, what a smart guide snaps to,
@@ -62,6 +62,7 @@ tools, never checked side by side) isn't captured row by row.
 | Behaviour | Status | Notes |
 |---|---|---|
 | Click/Shift-click anchors; marquee toggles with Shift | done | #483 |
+| A marquee selects the objects whose paths it touches (anchors or segments): drawn inside a filled shape, over a background, it leaves that shape (Preview and Outline) | done | #1103 |
 | Drag a curved segment to bend it, a straight one to move its anchors | done | |
 | Drag by an anchor of a path selected whole moves the whole path; Alt-drag by an anchor or a segment copies it, Alt toggles the copy during the drag, and the copy snaps by the anchor pressed, onto the original too | done | #1104 |
 | Handles shown are the handles that drag; tolerance from Selection & Anchor Display | done | #494 |
@@ -70,7 +71,7 @@ tools, never checked side by side) isn't captured row by row.
 | Convert selected anchors to corner/smooth from the Control bar and Properties | done | |
 | Cut path at selected anchors, Remove Anchor Points, Delete removes segments | done | |
 | Live Corners widgets (radius readout, Alt-click cycles kind, double-click the Corners dialog) | done | clicking a widget without pre-selecting the anchor (#908) missing |
-| Corners between curved sides, Relative rounding | missing | |
+| Corners between curved sides (#1144), Relative rounding | partial | Relative rounding missing |
 | Isolation mode by double-click, breadcrumbs, Esc to exit | done | |
 | "Magnetic" moves of selected anchors with a modifier (#955 request) | missing | not an Illustrator feature as documented; under discussion |
 
@@ -126,6 +127,7 @@ tools, never checked side by side) isn't captured row by row.
 | Space: Hand; Cmd+Space / Cmd+Alt+Space: zoom in/out; middle button pans | done | |
 | Cmd/Ctrl: last-used selection tool; Cmd+Alt: Group Selection inside Direct Selection | partial | |
 | Alt-drag duplicates (objects, artboards with their art) | done | |
+| Shift-click selects several artboards (Artboard tool, Artboards panel); they move, Alt-copy and delete together | done | `artboard.move`/`artboard.delete` `indices` (#1139) |
 | Shape tools: Shift constrains, Alt from centre, Space moves while dragging, arrows change sides/points/rows | done | |
 | Tool double-click opens its options | done | |
 | Per-platform mapping (Cmd ↔ Ctrl, Option ↔ Alt) | done | |
@@ -168,6 +170,9 @@ re-measure of the panels added since.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | minor | A marquee inside a filled shape no longer selects it: only touching its path does (#1103); score unchanged (estimated) |
+| 2026-10-11 | minor | Live Corners: corners between curved sides round too, the curve trimmed to what the cut leaves (#1144); score unchanged (estimated) |
+| 2026-10-11 | minor | Artboards: Shift-click selects several, which move, copy and delete together (#1139); score unchanged (estimated) |
 | 2026-10-11 | minor | Edit Toolbar opens the All Tools drawer beside the toolbar instead of a centred dialog, dims the tools the toolbar holds, and edits the toolbar by drag and drop while it is open (#1018); score unchanged (estimated) |
 | 2026-10-11 | minor | Direct Selection: dragging a path selected whole by an anchor moves it whole; Alt-drag copies by an anchor too, toggles during the drag and snaps onto the original (#1104); score unchanged (estimated) |
 | 2026-10-10 | major | First checklist, built from the tool sources and tests against Illustrator 2026's public documentation |

packaging/windows/vectorcraft.en-us.wxl

@@ -7,5 +7,9 @@
   <String Id="WelcomeDlgTitle" Value="{\WixUI_Font_Bigger}Welcome to the [ProductName] [VectorcraftVersion] Setup Wizard" />
   <String Id="WelcomeDlgDescription" Value="The Setup Wizard will install [ProductName] version [VectorcraftVersion] on your computer. Click Next to continue or Cancel to exit the Setup Wizard." />
   <String Id="VerifyReadyDlgInstallTitle" Value="{\WixUI_Font_Title}Ready to install [ProductName] [VectorcraftVersion]" />
+  <String Id="ShortcutsDlgTitle" Value="{\WixUI_Font_Title}Shortcuts" />
+  <String Id="ShortcutsDlgDescription" Value="Choose where you can start [ProductName] from." />
+  <String Id="ShortcutsDlgDesktop" Value="Create a &amp;desktop shortcut" />
+  <String Id="ShortcutsDlgStartMenu" Value="[ProductName] is always added to the Start menu." />
   <String Id="ExitDialogTitle" Value="{\WixUI_Font_Bigger}Completed the [ProductName] [VectorcraftVersion] Setup Wizard" />
 </WixLocalization>

packaging/windows/vectorcraft.wxs

@@ -10,7 +10,9 @@
   Per-machine install with a setup wizard that names the version: Welcome, install folder (Program Files\VectorCraft by
   default, remembered for upgrades), Ready, a progress page, and a Finish page with a ticked
   "Launch VectorCraft" box. Installs a Start Menu shortcut and an App Paths entry (so `vectorcraft`
-  starts from the Run dialog), plus vectorcraft-cli. `msiexec /qn` still installs silently.
+  starts from the Run dialog), plus vectorcraft-cli. A Shortcuts page after the install folder offers
+  a desktop shortcut (ticked). `msiexec /qn` still installs silently, with the desktop shortcut
+  unless INSTALLDESKTOPSHORTCUT="" is passed.
 -->
 <Wix xmlns="http://wixtoolset.org/schemas/v4/wxs"
      xmlns:ui="http://wixtoolset.org/schemas/v4/wxs/ui">
@@ -39,6 +41,7 @@
       <Directory Id="INSTALLFOLDER" Name="VectorCraft" />
     </StandardDirectory>
     <StandardDirectory Id="ProgramMenuFolder" />
+    <StandardDirectory Id="DesktopFolder" />
 
     <!-- An upgrade installs where the user put the previous version (written by VectorcraftApp). -->
     <Property Id="INSTALLFOLDER">
@@ -47,14 +50,43 @@
 
     <Feature Id="Main" Title="VectorCraft" Level="1">
       <ComponentGroupRef Id="VectorcraftFiles" />
+      <ComponentRef Id="DesktopShortcut" />
     </Feature>
 
+    <!-- A desktop shortcut: the Shortcuts page's box (ticked), or INSTALLDESKTOPSHORTCUT="" on the
+         msiexec command line for none. Secure, so the wizard's choice reaches the install. -->
+    <Property Id="INSTALLDESKTOPSHORTCUT" Value="1" Secure="yes" />
+
     <!-- The setup wizard: WixUI_InstallDir without its licence page (the code is MIT OR
          Apache-2.0; there is nothing to accept). A later NewDialog on the same button wins. -->
     <ui:WixUI Id="WixUI_InstallDir" InstallDirectory="INSTALLFOLDER" />
     <UI>
       <Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="InstallDirDlg" Order="2" Condition="NOT Installed" />
       <Publish Dialog="InstallDirDlg" Control="Back" Event="NewDialog" Value="WelcomeDlg" Order="2" />
+      <!-- The Shortcuts page sits between the install folder and Ready (once the folder is valid). -->
+      <Publish Dialog="InstallDirDlg" Control="Next" Event="NewDialog" Value="ShortcutsDlg" Order="5"
+          Condition="WIXUI_DONTVALIDATEPATH OR WIXUI_INSTALLDIR_VALID=&quot;1&quot;" />
+      <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="ShortcutsDlg" Order="5" Condition="NOT Installed" />
+
+      <Dialog Id="ShortcutsDlg" Width="370" Height="270" Title="!(loc.InstallDirDlg_Title)">
+        <Control Id="Next" Type="PushButton" X="236" Y="243" Width="56" Height="17" Default="yes" Text="!(loc.WixUINext)">
+          <Publish Event="NewDialog" Value="VerifyReadyDlg" />
+        </Control>
+        <Control Id="Back" Type="PushButton" X="180" Y="243" Width="56" Height="17" Text="!(loc.WixUIBack)">
+          <Publish Event="NewDialog" Value="InstallDirDlg" />
+        </Control>
+        <Control Id="Cancel" Type="PushButton" X="304" Y="243" Width="56" Height="17" Cancel="yes" Text="!(loc.WixUICancel)">
+          <Publish Event="SpawnDialog" Value="CancelDlg" />
+        </Control>
+        <Control Id="BannerBitmap" Type="Bitmap" X="0" Y="0" Width="370" Height="44" TabSkip="no" Text="!(loc.InstallDirDlgBannerBitmap)" />
+        <Control Id="BannerLine" Type="Line" X="0" Y="44" Width="370" Height="0" />
+        <Control Id="BottomLine" Type="Line" X="0" Y="234" Width="370" Height="0" />
+        <Control Id="Title" Type="Text" X="15" Y="6" Width="200" Height="15" Transparent="yes" NoPrefix="yes" Text="!(loc.ShortcutsDlgTitle)" />
+        <Control Id="Description" Type="Text" X="25" Y="23" Width="280" Height="15" Transparent="yes" NoPrefix="yes" Text="!(loc.ShortcutsDlgDescription)" />
+        <Control Id="DesktopShortcutCheckBox" Type="CheckBox" X="20" Y="60" Width="330" Height="18"
+            Property="INSTALLDESKTOPSHORTCUT" CheckBoxValue="1" Text="!(loc.ShortcutsDlgDesktop)" />
+        <Control Id="StartMenuNote" Type="Text" X="20" Y="84" Width="330" Height="30" NoPrefix="yes" Text="!(loc.ShortcutsDlgStartMenu)" />
+      </Dialog>
       <Publish Dialog="ExitDialog" Control="Finish" Event="DoAction" Value="LaunchVectorcraft"
           Condition="WIXUI_EXITDIALOGOPTIONALCHECKBOX = 1 AND NOT Installed" />
     </UI>
@@ -92,5 +124,14 @@
         <File Id="VectorcraftCliExe" Source="$(var.BinDir)\vectorcraft-cli.exe" KeyPath="yes" />
       </Component>
     </ComponentGroup>
+
+    <!-- Installed only with INSTALLDESKTOPSHORTCUT set (the Shortcuts page's box); removed with the
+         app. A per-machine install puts it on the common desktop. `wix msi validate` reports ICE38,
+         ICE43 and ICE57 for it: they take a desktop shortcut for per-user data, which it isn't here. -->
+    <Component Id="DesktopShortcut" Directory="DesktopFolder" Guid="498F2D4C-E655-47F6-B406-2D4C449B8D26" Condition="INSTALLDESKTOPSHORTCUT">
+      <Shortcut Id="DesktopShortcut" Name="VectorCraft" Description="VectorCraft vector illustration app"
+          Target="[#VectorcraftExe]" WorkingDirectory="INSTALLFOLDER" Icon="VectorcraftIcon.ico" IconIndex="0" />
+      <RegistryValue Root="HKLM" Key="Software\VectorCraft" Name="DesktopShortcut" Value="1" Type="integer" KeyPath="yes" />
+    </Component>
   </Fragment>
 </Wix>