diff --git a/ROADMAP.md b/ROADMAP.md
index fe325ff849..fe038ec97a 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -123,6 +123,7 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
 
 - 2026-11-05: Window › Toolbars › Keep Tools Beside the Canvas, off by default, docks the Tools panel between left-side panels and the canvas instead of at the window's left edge, and the canvas's left edge then also docks a floating Tools panel (`window.toolsBesideCanvas`, #5395). Workspaces keep the setting; workspaces saved without it keep Tools at the window's edge. An optional VectorCraft layout choice; headline numbers unchanged.
 - 2026-11-12: Stencil Bridges in the Cutting Tools add-on (Object › Plug-ins › Cutting Tools): strips of a set width are cut out of the selected art so that every island of a stencil cut from it (the inside of an O, a hole in a shape) stays attached to the sheet, by the shortest crossings first, vertical, horizontal or the shortest among 12 directions 15° apart, with up to 16 bridges per island; type is measured by its glyph outlines and stays type, and the original goes to a hidden layer or is replaced. One undo step (`addon.cutting.bridges`). A VectorCraft addition: headline numbers unchanged.
+- 2026-11-13: Banner Hems and Grommets in the Cutting Tools add-on (Object › Plug-ins › Cutting Tools): on the chosen sides of the selected art's bounds, or of each artboard, a hem line at a set depth inside the edge and grommet marks (a circle with a cross) at a set inset, one at each end of a side and the rest spread evenly at most a set spacing apart, stroked in a chosen swatch; a dialog with Preview, one undo step (`addon.cutting.banner`). A VectorCraft addition: headline numbers unchanged.
 - 2026-11-05: Release Type on a Path joins the Type Tools add-on (Object › Plug-ins › Type Tools): each selected type on a path splits into point type with the same text and attributes, on one straight line starting where its first character sat, and the plain path it was set on, with its exact shape and place in the stacking order and no paint; or keeps only the path or only the text, optionally leaving the original. A dialog with Preview, one undo step (`addon.type.releasePath`, #5532). A VectorCraft addition: headline numbers unchanged.
 - 2026-11-04: New Document: the units chosen in Preset Details now belong to the chosen document, as the pane's options are listed for the selected preset; the chosen card shows them, every other Recent and Saved card keeps the units its document or preset was made in, and the built-in tabs still follow the chosen units, so switching between inches and millimetres no longer restyles every recent template. Scores and estimates unchanged.
 - 2026-11-02: Mouse wheel over a closed font-family field in Character, Properties or Control changes selected text through the family list using saved font filters (excluding search text), one undo step per notch, stopping at the ends (#5253). Scores and estimates unchanged.
diff --git a/crates/doc/src/blend.rs b/crates/doc/src/blend.rs
index d936891514..b84de1cac3 100644
--- a/crates/doc/src/blend.rs
+++ b/crates/doc/src/blend.rs
@@ -1464,7 +1464,7 @@ pub fn pin_spine(keys: &[Arc<Node>], spec: &BlendSpec) -> Option<(PathData, Vec<
 }
 
 /// Do `keys` sit where a spine from Replace Spine spreads them: evenly along `spine` by arc length
-/// (within a hundredth of a point, as [`anchor_at_length`] matches anchors)?
+/// (within a hundredth of a point, as [`SpreadLengths::anchor_at_length`] matches anchors)?
 fn keys_spread_along(keys: &[Arc<Node>], spine: &Spine) -> bool {
     let k = keys.len();
     keys.iter().enumerate().all(|(i, key)| {
@@ -1489,40 +1489,204 @@ fn open_at_start(sp: &mut SubPath, ka: &mut [usize]) {
 }
 
 /// The anchors of `path`'s first subpath that `k` keys spread evenly along it by arc length sit
-/// on, splitting segments where none is.
+/// on, splitting segments where none is. `None`, leaving `path` as it was, when the subpath has no
+/// length to spread along, when its length is not finite (a path so large its length overflows),
+/// or when an arc length it would split at is not finite.
 fn spread_anchors(path: &mut PathData, k: usize) -> Option<Vec<usize>> {
-    let total = Spine::new(path)?.length();
-    let closed = path.subpaths.first().is_some_and(|s| s.closed);
+    spread_anchors_with(path, k, |_| {})
+}
+
+/// [`spread_anchors`], calling `work` for each step of work it does.
+fn spread_anchors_with(path: &mut PathData, k: usize, mut work: impl FnMut(SpreadWork)) -> Option<Vec<usize>> {
+    let sp = path.subpaths.first_mut()?;
+    let lengths = SpreadLengths::new(sp, &mut work);
+    let total = lengths.total().filter(|t| t.is_finite())?;
+    let targets = (1..k.saturating_sub(1)).map(|i| total * i as f64 / (k - 1) as f64);
     let mut out = vec![0usize];
-    for i in 1..k.saturating_sub(1) {
-        let s = total * i as f64 / (k - 1) as f64;
-        out.push(anchor_at_length(path, s)?);
-    }
-    let last = path.subpaths.first().map_or(0, |sp| if closed { 0 } else { sp.anchors.len().saturating_sub(1) });
-    out.push(last);
+    out.extend(anchors_at_lengths(sp, lengths, targets, &mut work)?);
+    out.push(if sp.closed { 0 } else { sp.anchors.len().saturating_sub(1) });
     Some(out)
 }
 
-/// The anchor of the first subpath at arc length `s`: an existing one within a hundredth of a
-/// point, else a new one splitting the segment there.
-fn anchor_at_length(path: &mut PathData, s: f64) -> Option<usize> {
-    let spine = Spine::new(path)?;
-    let sp = path.subpaths.first_mut()?;
-    let n = sp.segment_count();
-    let seg = (0..n).rev().find(|i| spine.anchor_length(*i).is_some_and(|l| l <= s)).unwrap_or(0);
-    let from = spine.anchor_length(seg).unwrap_or(0.0);
-    let to = spine.anchor_length(seg + 1).unwrap_or(spine.length());
-    if s - from < 0.01 {
-        return Some(seg);
+/// The anchors of `sp` at each arc length in `targets`, in order, splitting segments where none is
+/// (see [`SpreadLengths::anchor_at_length`]); `lengths` measures `sp`. The splits are made on a copy
+/// of `sp`, which replaces it only when every target has its anchor: `None` leaves `sp` as it was.
+fn anchors_at_lengths(
+    sp: &mut SubPath,
+    mut lengths: SpreadLengths,
+    targets: impl IntoIterator<Item = f64>,
+    work: &mut impl FnMut(SpreadWork),
+) -> Option<Vec<usize>> {
+    let mut split = sp.clone();
+    let mut out = Vec::new();
+    for s in targets {
+        out.push(lengths.anchor_at_length(&mut split, s, work)?);
     }
-    if to - s < 0.01 {
-        return Some((seg + 1) % sp.anchors.len().max(1));
+    *sp = split;
+    Some(out)
+}
+
+/// A step of the work [`spread_anchors_with`] does.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum SpreadWork {
+    /// Flattening every segment of the subpath.
+    WholePath,
+    /// Flattening one segment after a split.
+    Segment,
+    /// Adding one segment's flattened points to the arc lengths.
+    Measure,
+    /// Comparing an anchor's arc length with the one looked for.
+    Compare,
+}
+
+/// Where the measurement of a subpath's flattened points stands at the start of a segment: the last
+/// point kept, the arc length there (0 before any point), and how many points were kept.
+#[derive(Clone, Copy)]
+struct Measured {
+    last: Option<Point>,
+    len: f64,
+    kept: usize,
+}
+
+impl Measured {
+    const START: Self = Self { last: None, len: 0.0, kept: 0 };
+
+    /// The measurement after `pts`, keeping each point more than 1e-9 from the last one kept, as
+    /// [`Spine::new`] does.
+    fn then(mut self, pts: &[Point]) -> Self {
+        for &p in pts {
+            if self.last.is_none_or(|q| q.distance(p) > 1e-9) {
+                self.len = match self.last {
+                    Some(q) => self.len + q.distance(p),
+                    None => 0.0,
+                };
+                self.last = Some(p);
+                self.kept += 1;
+            }
+        }
+        self
+    }
+}
+
+/// The arc lengths of a subpath's anchors, as [`Spine::new`] measures them, kept up to date while
+/// [`spread_anchors`] splits its segments. Each segment is flattened once, and again only when it
+/// is split. A split leaves the arc lengths of the anchors before it as they are; those after it
+/// are measured again, in order from the split, only as far as the next arc length looked for, so
+/// the sums are the same as [`Spine::new`]'s on the split subpath.
+struct SpreadLengths {
+    /// The finite points the segments flatten to, each segment's in one run.
+    pts: Vec<Point>,
+    /// Where each segment's run is in `pts`. A split segment's halves get runs at the end, and its
+    /// old run is not used again.
+    flat: Vec<std::ops::Range<usize>>,
+    /// The measurement at the start of each segment, up to the first one not measured since the
+    /// last split; after the last segment too once every segment is measured.
+    marks: Vec<Measured>,
+}
+
+impl SpreadLengths {
+    /// Flatten and measure every segment of `sp`.
+    fn new(sp: &SubPath, work: &mut impl FnMut(SpreadWork)) -> Self {
+        work(SpreadWork::WholePath);
+        let n = sp.segment_count();
+        let mut lengths = Self { pts: Vec::new(), flat: Vec::with_capacity(n), marks: Vec::with_capacity(n + 1) };
+        for i in 0..n {
+            let run = lengths.flatten(sp, i);
+            lengths.flat.push(run);
+        }
+        lengths.marks.push(Measured::START);
+        lengths.measure_to(f64::INFINITY, work);
+        lengths
+    }
+
+    /// Flatten segment `i` of `sp` as [`Spine::new`] does, adding its finite points to `pts`, and
+    /// return where they are.
+    fn flatten(&mut self, sp: &SubPath, i: usize) -> std::ops::Range<usize> {
+        let start = self.pts.len();
+        let c = sp.segment(i);
+        let mut bp = BezPath::new();
+        bp.move_to(c.p0);
+        if sp.segment_is_line(i) {
+            bp.line_to(c.p3);
+        } else {
+            bp.curve_to(c.p1, c.p2, c.p3);
+        }
+        vectorcraft_geom::kurbo::flatten(bp.iter(), 0.1, |el| {
+            if let vectorcraft_geom::PathEl::MoveTo(p) | vectorcraft_geom::PathEl::LineTo(p) = el
+                && p.x.is_finite()
+                && p.y.is_finite()
+            {
+                self.pts.push(p);
+            }
+        });
+        start..self.pts.len()
+    }
+
+    /// The subpath's flattened length, `None` when it flattens to fewer than two points.
+    fn total(&self) -> Option<f64> {
+        self.marks.last().filter(|m| self.marks.len() > self.flat.len() && m.kept >= 2).map(|m| m.len)
+    }
+
+    /// Measure the segments that are not measured, from the first, until one starts past `s` (with
+    /// two points kept before it) or every one is measured.
+    fn measure_to(&mut self, s: f64, work: &mut impl FnMut(SpreadWork)) {
+        while let Some(run) = self.flat.get(self.marks.len() - 1) {
+            let Some(&m) = self.marks.last() else { return };
+            if self.marks.len() >= 2 && m.kept >= 2 && m.len > s {
+                return;
+            }
+            work(SpreadWork::Measure);
+            self.marks.push(m.then(self.pts.get(run.clone()).unwrap_or_default()));
+        }
+    }
+
+    /// The anchor of `sp` at arc length `s`: an existing one within a hundredth of a point, else a
+    /// new one splitting the segment there. The segment is the last one starting at or before `s`
+    /// (the first one when none does), found by a binary search. `None`, leaving `sp` as it was,
+    /// when `s` or the arc length at the end of the segment is not finite, or when `sp` flattens
+    /// to fewer than two points.
+    fn anchor_at_length(&mut self, sp: &mut SubPath, s: f64, work: &mut impl FnMut(SpreadWork)) -> Option<usize> {
+        if !s.is_finite() {
+            return None;
+        }
+        self.measure_to(s, work);
+        let n = self.flat.len();
+        if self.marks.last().is_none_or(|m| m.kept < 2) {
+            return None;
+        }
+        let starts = &self.marks[..self.marks.len().min(n)];
+        let seg = starts
+            .partition_point(|m| {
+                work(SpreadWork::Compare);
+                m.len <= s
+            })
+            .saturating_sub(1);
+        let from = self.marks.get(seg)?.len;
+        let to = self.marks.get(seg + 1)?.len;
+        if s - from < 0.01 {
+            return Some(seg);
+        }
+        if to - s < 0.01 {
+            return Some((seg + 1) % sp.anchors.len().max(1));
+        }
+        if !from.is_finite() || !to.is_finite() {
+            return None;
+        }
+        let c = sp.segment(seg);
+        // The flattened length and the curve's own differ slightly: scale into the curve's.
+        let arc = c.arclen(1e-4).max(1e-12);
+        let t = c.inv_arclen((s - from) / (to - from).max(1e-12) * arc, 1e-4).clamp(1e-4, 1.0 - 1e-4);
+        if !t.is_finite() {
+            return None;
+        }
+        let at = sp.insert_anchor(seg, t);
+        work(SpreadWork::Segment);
+        work(SpreadWork::Segment);
+        let halves = [self.flatten(sp, seg), self.flatten(sp, seg + 1)];
+        self.flat.splice(seg..=seg, halves);
+        self.marks.truncate(seg + 1);
+        Some(at)
     }
-    let c = sp.segment(seg);
-    // The flattened length and the curve's own differ slightly: scale into the curve's.
-    let arc = c.arclen(1e-4).max(1e-12);
-    let t = c.inv_arclen((s - from) / (to - from).max(1e-12) * arc, 1e-4).clamp(1e-4, 1.0 - 1e-4);
-    Some(sp.insert_anchor(seg, t))
 }
 
 /// Where a blend's keys and steps go along its spine (see [`blend_spine`]).
@@ -2012,6 +2176,150 @@ mod tests {
         }
     }
 
+    /// [`spread_anchors`] by measuring the whole spine again for each key and walking its segments
+    /// from the last, as a reference for the measurement kept up to date between keys.
+    fn rebuilt_spread_anchors(path: &mut PathData, k: usize) -> Option<Vec<usize>> {
+        let total = Spine::new(path)?.length();
+        let closed = path.subpaths.first().is_some_and(|s| s.closed);
+        let mut out = vec![0usize];
+        for i in 1..k.saturating_sub(1) {
+            let s = total * i as f64 / (k - 1) as f64;
+            let spine = Spine::new(path)?;
+            let sp = path.subpaths.first_mut()?;
+            let n = sp.segment_count();
+            let seg = (0..n).rev().find(|i| spine.anchor_length(*i).is_some_and(|l| l <= s)).unwrap_or(0);
+            let from = spine.anchor_length(seg).unwrap_or(0.0);
+            let to = spine.anchor_length(seg + 1).unwrap_or(spine.length());
+            out.push(if s - from < 0.01 {
+                seg
+            } else if to - s < 0.01 {
+                (seg + 1) % sp.anchors.len().max(1)
+            } else {
+                let c = sp.segment(seg);
+                let arc = c.arclen(1e-4).max(1e-12);
+                let t = c.inv_arclen((s - from) / (to - from).max(1e-12) * arc, 1e-4).clamp(1e-4, 1.0 - 1e-4);
+                sp.insert_anchor(seg, t)
+            });
+        }
+        let last = path.subpaths.first().map_or(0, |sp| if closed { 0 } else { sp.anchors.len().saturating_sub(1) });
+        out.push(last);
+        Some(out)
+    }
+
+    /// Spreading keys along a spine measured once and kept up to date gives the same anchors and
+    /// the same spine as measuring it again for each key: on open and closed polylines and curves,
+    /// zero-length segments, keys exactly on anchors, keys within, at and just past a hundredth of
+    /// a point from an anchor, a closed curve whose keys go round past its first anchor, many keys
+    /// in one segment, and paths with no segment. The closed spines open as [`pin_spine`] opens
+    /// them.
+    #[test]
+    fn spreading_keys_matches_measuring_the_spine_for_each_key() {
+        let p = Point::new;
+        let bow = SubPath::new(
+            vec![Anchor::smooth(p(0.0, 0.0), p(50.0, 50.0)), Anchor::smooth(p(100.0, 0.0), p(150.0, -50.0)), Anchor::corner(p(200.0, 0.0))],
+            false,
+        );
+        let mut spines = vec![
+            PathData::default(),
+            PathData::single(SubPath::default()),
+            PathData::single(SubPath::polyline(&[p(5.0, 5.0)], false)),
+            PathData::single(SubPath::polyline(&[p(5.0, 5.0), p(5.0, 5.0)], false)),
+            PathData::single(SubPath::polyline(&[p(0.0, 0.0), p(100.0, 0.0)], false)),
+            PathData::single(SubPath::polyline(&[p(0.0, 0.0), p(100.0, 0.0)], true)),
+            PathData::single(SubPath::polyline(&[p(0.0, 0.0), p(10.0, 0.0), p(20.0, 0.0), p(30.0, 0.0)], false)),
+            PathData::single(SubPath::polyline(&[p(0.0, 0.0), p(10.0, 0.0), p(10.0, 0.0), p(10.0, 0.0), p(30.0, 5.0), p(30.0, 5.0)], false)),
+            PathData::single(SubPath::polyline(&[p(0.0, 0.0), p(0.0, 0.0), p(40.0, 0.0), p(40.0, 30.0)], true)),
+            PathData::single(SubPath::polyline(&[p(0.0, 0.0), p(40.0, 0.0), p(40.0, 30.0), p(0.0, 0.0)], true)),
+            PathData::single(bow.clone()),
+            PathData::single(SubPath { closed: true, ..bow }),
+            shapes::ellipse(Rect::new(0.0, 0.0, 120.0, 80.0)),
+        ];
+        // An anchor near where the middle of three keys goes, 10 along a spine 20 long.
+        for d in [0.0, 0.005, 0.0099, 0.01, 0.0101, 0.02] {
+            for x in [10.0 - d, 10.0 + d] {
+                spines.push(PathData::single(SubPath::polyline(&[p(0.0, 0.0), p(x, 0.0), p(20.0, 0.0)], false)));
+            }
+        }
+        let mut compared = 0;
+        for spine in &spines {
+            for k in (0..=12).chain([17, 50, 200]) {
+                let (mut a, mut b) = (spine.clone(), spine.clone());
+                let (ka, kb) = (spread_anchors(&mut a, k), rebuilt_spread_anchors(&mut b, k));
+                assert_eq!(ka, kb, "{k} keys on {spine:?}");
+                assert_eq!(a, b, "{k} keys on {spine:?}");
+                if let (Some(mut ka), Some(mut kb)) = (ka, kb) {
+                    let (mut sa, mut sb) = (a.subpaths[0].clone(), b.subpaths[0].clone());
+                    open_at_start(&mut sa, &mut ka);
+                    open_at_start(&mut sb, &mut kb);
+                    assert_eq!((sa, ka), (sb, kb), "{k} keys on {spine:?}, opened");
+                    compared += 1;
+                }
+            }
+        }
+        assert!(compared > 200, "{compared} spreads compared");
+    }
+
+    /// Spreading 1,000 keys along a spine of 4,096 segments flattens the spine once and then only
+    /// the two halves of each split segment, finds each key's segment in a few comparisons, and
+    /// measures about as many segments as the spine ends up with, not the whole spine per key.
+    #[test]
+    fn spreading_keys_measures_the_spine_once() {
+        let pts: Vec<Point> = (0..=4096).map(|i| Point::new(i as f64, if i % 2 == 0 { 0.0 } else { 1.0 })).collect();
+        let mut path = PathData::single(SubPath::polyline(&pts, false));
+        let (mut whole, mut segments, mut measured, mut compared) = (0, 0, 0, 0);
+        let ka = spread_anchors_with(&mut path, 1000, |w| match w {
+            SpreadWork::WholePath => whole += 1,
+            SpreadWork::Segment => segments += 1,
+            SpreadWork::Measure => measured += 1,
+            SpreadWork::Compare => compared += 1,
+        })
+        .unwrap();
+        assert_eq!(ka.len(), 1000);
+        let n = path.subpaths[0].segment_count();
+        assert!(n > 4096 + 900, "{n} segments");
+        assert_eq!(whole, 1);
+        assert!(segments <= 2 * 998, "{segments} segments flattened");
+        assert!(compared <= 998 * 14, "{compared} comparisons");
+        assert!(measured <= 4096 + n + 3 * 1000, "{measured} segments measured for {n}");
+        let mut reference = PathData::single(SubPath::polyline(&pts, false));
+        assert_eq!(rebuilt_spread_anchors(&mut reference, 1000), Some(ka));
+        assert_eq!(reference, path);
+    }
+
+    /// A spine so large that its length overflows spreads no keys, and is left as it was, rather
+    /// than getting an anchor split at a parameter that is not a number. Two keys, which split
+    /// nothing, get no anchors either.
+    #[test]
+    fn spreading_keys_along_a_spine_whose_length_overflows_changes_nothing() {
+        let p = Point::new;
+        for closed in [false, true] {
+            for k in [2, 3, 5] {
+                let spine = PathData::single(SubPath::polyline(&[p(-1e308, 0.0), p(0.0, 0.0), p(1e308, 0.0)], closed));
+                let mut path = spine.clone();
+                assert_eq!(spread_anchors(&mut path, k), None, "closed {closed}, {k} keys");
+                assert_eq!(path, spine);
+                assert!(path.subpaths[0].anchors.iter().all(|a| a.p.x.is_finite() && a.h_in.x.is_finite() && a.h_out.x.is_finite()));
+            }
+        }
+    }
+
+    /// When a later arc length has no anchor (here one that is not finite, as when a spine's length
+    /// overflows only after earlier splits), the splits already made are dropped with it.
+    #[test]
+    fn a_failed_anchor_keeps_none_of_the_earlier_splits() {
+        let sp = SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(100.0, 0.0)], false);
+        for bad in [f64::NAN, f64::INFINITY] {
+            let mut split = sp.clone();
+            let lengths = SpreadLengths::new(&split, &mut |_| {});
+            assert_eq!(anchors_at_lengths(&mut split, lengths, [25.0, 50.0, bad], &mut |_| {}), None);
+            assert_eq!(split, sp);
+        }
+        let mut split = sp.clone();
+        let lengths = SpreadLengths::new(&split, &mut |_| {});
+        assert_eq!(anchors_at_lengths(&mut split, lengths, [25.0, 50.0], &mut |_| {}), Some(vec![1, 2]));
+        assert_eq!(split.anchors.len(), 4);
+    }
+
     #[test]
     fn easing_keeps_the_ends_and_stays_monotone() {
         use crate::live::{BlendEase, BlendEaseType as K};
diff --git a/crates/doc/src/canvas_range.rs b/crates/doc/src/canvas_range.rs
index 491b79f158..d920c51332 100644
--- a/crates/doc/src/canvas_range.rs
+++ b/crates/doc/src/canvas_range.rs
@@ -3,6 +3,7 @@
 //! the ruler origin and the objects an edit touches), so a file holding something beyond it could be
 //! opened but not edited: one object, artboard or guide out there made every move fail.
 
+use std::collections::BTreeSet;
 use std::sync::Arc;
 
 use vectorcraft_geom::{Point, Rect};
@@ -72,27 +73,41 @@ fn clipping(n: &Node) -> Option<bool> {
     }
 }
 
-/// Does `n`, or any object in it, reach beyond the canvas? A container is looked into object by
-/// object: its own bounds leave out a layer's hidden objects and, when it clips, all but its
-/// clipping path.
-fn reaches_beyond(n: &Node) -> bool {
-    match clipping(n) {
-        None => beyond(n),
-        Some(_) => n.children().is_some_and(|c| c.iter().any(|c| reaches_beyond(c))),
+/// The objects of a layer or group that a walk picked, by index in order, each with what was
+/// picked inside it (nothing for an object that is not a container).
+#[derive(Debug, Default)]
+struct Picked(Vec<(usize, Picked)>);
+
+/// What in `n` reaches beyond the canvas, by `far`, or `None` when nothing does. A container is
+/// looked into object by object: its own bounds leave out a layer's hidden objects and, when it
+/// clips, all but its clipping path. Each object is measured once, and the objects a clipping
+/// path beyond the canvas clips are not measured: they go with it (see [`clips_beyond`]).
+fn reach(n: &Node, far: &impl Fn(&Node) -> bool) -> Option<Picked> {
+    let Some(clip) = clipping(n) else { return far(n).then(Picked::default) };
+    let mut inner = Vec::new();
+    for (i, c) in n.children().into_iter().flatten().enumerate() {
+        if let Some(p) = reach(c, far) {
+            inner.push((i, p));
+            if clip && i == 0 {
+                break;
+            }
+        }
     }
+    (!inner.is_empty()).then_some(Picked(inner))
 }
 
-/// Does `n` clip by a path that reaches beyond the canvas? Then the path and the objects it clips
-/// go together, so no other object becomes the clipping path.
-fn clips_beyond(n: &Node) -> bool {
-    clipping(n) == Some(true) && n.children().and_then(|c| c.first()).is_some_and(|c| reaches_beyond(c))
+/// Does `n`, whose objects beyond the canvas are `found`, clip by a path that reaches beyond it?
+/// Then the path and the objects it clips go together, so no other object becomes the clipping
+/// path.
+fn clips_beyond(n: &Node, found: &Picked) -> bool {
+    clipping(n) == Some(true) && found.0.first().is_some_and(|(i, _)| *i == 0)
 }
 
 /// Add the ids of `n` and the layers in it, if it is a layer, to `layers`: their layer guides go
 /// with them.
-fn layers_in(n: &Node, layers: &mut Vec<NodeId>) {
+fn layers_in(n: &Node, layers: &mut BTreeSet<NodeId>) {
     if matches!(n.kind, NodeKind::Layer { .. }) {
-        layers.push(n.id);
+        layers.insert(n.id);
     }
     if clipping(n).is_some() {
         for c in n.children().into_iter().flatten() {
@@ -109,22 +124,22 @@ fn guides_in(n: &Node) -> usize {
     }
 }
 
-/// Remove the objects in `node` that reach beyond the canvas: a layer or group keeps those of its
-/// objects within it, unless its clipping path reaches beyond (see [`clips_beyond`]); anything
-/// else goes whole. Only containers holding such an object are copied. Recursion follows the
-/// nesting, which [`Document::limit_depth`] bounds. The layers removed are added to `layers`, and
-/// the ruler guides they held to `guides`.
-fn drop_children_beyond(node: &mut Arc<Node>, dropped: &mut usize, layers: &mut Vec<NodeId>, guides: &mut usize) {
-    if !node.children().is_some_and(|c| c.iter().any(|c| reaches_beyond(c))) {
-        return;
-    }
+/// Remove the objects in `node` that reach beyond the canvas, which [`reach`] `found`: a layer or
+/// group keeps those of its objects within it, unless its clipping path reaches beyond (see
+/// [`clips_beyond`]); anything else goes whole. Only containers holding such an object are
+/// copied, and only those are visited again. Recursion follows the nesting, which
+/// [`Document::limit_depth`] bounds. The layers removed are added to `layers`, and the ruler
+/// guides they held to `guides`.
+fn drop_children_beyond(node: &mut Arc<Node>, found: Picked, dropped: &mut usize, layers: &mut BTreeSet<NodeId>, guides: &mut usize) {
     let Some(children) = Arc::make_mut(node).children_mut() else { return };
+    let mut found = found.0.into_iter().peekable();
+    let mut next = 0;
     children.retain_mut(|c| {
-        if !reaches_beyond(c) {
-            return true;
-        }
-        if clipping(c).is_some() && !clips_beyond(c) {
-            drop_children_beyond(c, dropped, layers, guides);
+        let at = next;
+        next += 1;
+        let Some((_, inner)) = found.next_if(|(i, _)| *i == at) else { return true };
+        if clipping(c).is_some() && !clips_beyond(c, &inner) {
+            drop_children_beyond(c, inner, dropped, layers, guides);
             return true;
         }
         layers_in(c, layers);
@@ -134,21 +149,49 @@ fn drop_children_beyond(node: &mut Arc<Node>, dropped: &mut usize, layers: &mut
     });
 }
 
+/// Is `id` unset, or not one of `ids`? The check takes time logarithmic in the number of ids.
+fn not_in<T: Ord>(id: Option<T>, ids: &BTreeSet<T>) -> bool {
+    id.is_none_or(|i| !ids.contains(&i))
+}
+
 /// Remove the ruler guides of layer `layer` and of its sublayers that `out` picks, adding how many
-/// to `dropped`. Only layers holding one are copied.
+/// to `dropped`. `out` looks at each object in the layers once. Only layers holding one are
+/// copied.
 fn drop_guides(layer: &mut Arc<Node>, out: &impl Fn(&Node) -> bool, dropped: &mut usize) {
-    fn holds(n: &Node, out: &impl Fn(&Node) -> bool) -> bool {
-        n.is_layer() && n.children().is_some_and(|ch| ch.iter().any(|c| out(c) || holds(c, out)))
+    /// The objects of `n`, if it is a layer, that `out` picks (with nothing inside), and its
+    /// sublayers holding one (with what they hold), or `None` when it holds none.
+    fn holds(n: &Node, out: &impl Fn(&Node) -> bool) -> Option<Picked> {
+        if !n.is_layer() {
+            return None;
+        }
+        let inner: Vec<(usize, Picked)> = n
+            .children()
+            .into_iter()
+            .flatten()
+            .enumerate()
+            .filter_map(|(i, c)| if out(c) { Some((i, Picked::default())) } else { holds(c, out).map(|p| (i, p)) })
+            .collect();
+        (!inner.is_empty()).then_some(Picked(inner))
     }
-    if !holds(layer, out) {
-        return;
+    fn drop(layer: &mut Arc<Node>, held: Picked, dropped: &mut usize) {
+        let Some(children) = Arc::make_mut(layer).children_mut() else { return };
+        let mut held = held.0.into_iter().peekable();
+        let mut next = 0;
+        children.retain_mut(|c| {
+            let at = next;
+            next += 1;
+            let Some((_, inner)) = held.next_if(|(i, _)| *i == at) else { return true };
+            // A sublayer holds something; an object picked itself has nothing inside.
+            if inner.0.is_empty() {
+                *dropped += 1;
+                return false;
+            }
+            drop(c, inner, dropped);
+            true
+        });
     }
-    let Some(children) = Arc::make_mut(layer).children_mut() else { return };
-    let before = children.len();
-    children.retain(|c| !out(c));
-    *dropped += before - children.len();
-    for c in children.iter_mut().filter(|c| c.is_layer()) {
-        drop_guides(c, out, dropped);
+    if let Some(held) = holds(layer, out) {
+        drop(layer, held, dropped);
     }
 }
 
@@ -162,9 +205,10 @@ impl Document {
     /// whose artboards were all removed has none left.
     pub fn drop_beyond_canvas(&mut self) -> BeyondCanvas {
         let mut gone = BeyondCanvas::default();
-        let mut layers = vec![];
+        let mut layers = BTreeSet::new();
         for layer in &mut self.layers {
-            if clips_beyond(layer) {
+            let Some(found) = reach(layer, &beyond) else { continue };
+            if clips_beyond(layer, &found) {
                 let layer = Arc::make_mut(layer);
                 if let NodeKind::Layer { children, clip, .. } = &mut layer.kind {
                     for c in children.iter() {
@@ -177,7 +221,7 @@ impl Document {
                     *clip = false;
                 }
             } else {
-                drop_children_beyond(layer, &mut gone.objects, &mut layers, &mut gone.guides);
+                drop_children_beyond(layer, found, &mut gone.objects, &mut layers, &mut gone.guides);
             }
         }
         if gone.objects > 0 {
@@ -192,13 +236,13 @@ impl Document {
             self.retire_artboard_id(*id);
         }
         gone.artboards = removed.len();
+        let removed: BTreeSet<u32> = removed.into_iter().collect();
         // The saved list, when the guides are not nodes yet ([`Document::guides_into_nodes`]).
         let guides = self.saved_guides.len();
-        self.saved_guides
-            .retain(|g| in_range(g.pos) && g.artboard.is_none_or(|a| !removed.contains(&a)) && g.layer.is_none_or(|l| !layers.contains(&l)));
+        self.saved_guides.retain(|g| in_range(g.pos) && not_in(g.artboard, &removed) && not_in(g.layer, &layers));
         gone.guides += guides - self.saved_guides.len();
         let out = |n: &Node| match n.kind {
-            NodeKind::RulerGuide { pos, artboard, .. } => !in_range(pos) || artboard.is_some_and(|a| removed.contains(&a)),
+            NodeKind::RulerGuide { pos, artboard, .. } => !in_range(pos) || !not_in(artboard, &removed),
             _ => false,
         };
         for layer in &mut self.layers {
@@ -392,4 +436,153 @@ mod tests {
         assert_eq!(d.assets.iter().map(|a| (a.id, a.nodes.clone())).collect::<Vec<_>>(), [(2, vec![NodeId(10)])]);
         assert_eq!(d.variables.bindings.keys().copied().collect::<Vec<_>>(), [NodeId(10)]);
     }
+
+    #[test]
+    fn guides_of_many_removed_artboards_and_layers_go_and_the_rest_keep_their_order() {
+        let probe = Document::new(1.0, 1.0);
+        // Sublayers 40 to 43 clip by a path beyond the canvas, so they go whole; 50 stays.
+        let far: Vec<Arc<Node>> = (40..44).map(|id| sublayer(&probe, id, vec![rect(id * 10, 1e17), rect(id * 10 + 1, 0.0)], true)).collect();
+        let near = sublayer(&probe, 50, vec![rect(500, 0.0)], false);
+        let mut d = doc(far.into_iter().chain([near, rect(10, 0.0)]).collect());
+        let kept = d.artboards[0].id;
+        for id in 9..13 {
+            d.artboards.push(Artboard { id, rect: Rect::new(0.0, 1e17, 100.0, 1e17 + 100.0), ..d.artboards[0].clone() });
+        }
+        let top = d.layers[0].id;
+        let guide = |pos: f64, artboard: Option<u32>, layer: Option<NodeId>| Guide { artboard, layer, ..Guide::new(false, pos) };
+        d.saved_guides = vec![
+            guide(1.0, Some(9), None),
+            guide(2.0, None, None),
+            guide(3.0, Some(kept), Some(NodeId(41))),
+            guide(4.0, Some(kept), None),
+            guide(5.0, Some(12), None),
+            guide(6.0, None, Some(NodeId(50))),
+            guide(7.0, None, Some(NodeId(43))),
+            guide(8.0, Some(10), Some(top)),
+            guide(9.0, None, Some(top)),
+        ];
+        d.saved_selections = vec![crate::records::SavedSelection { name: "s".into(), objects: vec![NodeId(42), NodeId(10), NodeId(500)] }].into();
+        let mut nodes = d.clone();
+        assert_eq!(nodes.guides_into_nodes(), 9);
+        let gone = d.drop_beyond_canvas();
+        assert_eq!(gone, BeyondCanvas { objects: 4, artboards: 4, guides: 5, ruler_origin: false });
+        assert_eq!(d.artboards.iter().map(|a| a.id).collect::<Vec<_>>(), [kept]);
+        let left: Vec<f64> = d.saved_guides.iter().map(|g| g.pos).collect();
+        assert_eq!(left, [2.0, 4.0, 6.0, 9.0], "the guides that stay keep their order");
+        assert_eq!(d.saved_selections[0].objects, [NodeId(10), NodeId(500)]);
+        assert_eq!(nodes.drop_beyond_canvas(), gone, "guide nodes go as saved guides do");
+        let mut left: Vec<f64> = nodes.ruler_guides().iter().map(|g| g.pos).collect();
+        left.sort_by(f64::total_cmp);
+        assert_eq!(left, [2.0, 4.0, 6.0, 9.0]);
+        assert_eq!(nodes.saved_selections, d.saved_selections);
+    }
+
+    thread_local! {
+        static COMPARISONS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+    }
+
+    /// An id that counts how often it is compared.
+    #[derive(Debug)]
+    struct Counted(u32);
+
+    impl Ord for Counted {
+        fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+            COMPARISONS.with(|c| c.set(c.get() + 1));
+            self.0.cmp(&other.0)
+        }
+    }
+
+    impl PartialOrd for Counted {
+        fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+            Some(self.cmp(other))
+        }
+    }
+
+    impl PartialEq for Counted {
+        fn eq(&self, other: &Self) -> bool {
+            self.cmp(other) == std::cmp::Ordering::Equal
+        }
+    }
+
+    impl Eq for Counted {}
+
+    #[test]
+    fn a_guide_is_checked_without_scanning_every_removed_id() {
+        let per_guide = |removed: u32| {
+            let ids: BTreeSet<Counted> = (0..removed).map(|i| Counted(i * 2)).collect();
+            COMPARISONS.with(|c| c.set(0));
+            // Guides on removed ids, on ids between them, on ids past them and on none.
+            let guides: Vec<Option<Counted>> = (0..64).map(|i| (i % 4 != 3).then(|| Counted(i * 31 % (removed * 2 + 8)))).collect();
+            let kept = guides.into_iter().filter(|g| not_in(g.as_ref().map(|c| Counted(c.0)), &ids)).count();
+            assert!(kept > 0 && kept < 64);
+            COMPARISONS.with(|c| c.get()) as f64 / 64.0
+        };
+        let small = per_guide(16);
+        let large = per_guide(16_384);
+        // A sorted lookup grows with the depth of the tree; a scan of 16,384 ids compares thousands per guide.
+        assert!(large < small * 32.0 && large < 256.0, "{small} comparisons per guide among 16 ids, {large} among 16,384");
+    }
+
+    #[test]
+    fn each_object_is_measured_once_however_deep_the_nesting() {
+        // 32 groups, each inside the one before and holding an object within the canvas; the
+        // innermost also holds one beyond it. Beside them, a group with nothing beyond and a clip
+        // group whose clipping path reaches beyond.
+        let mut chain = Arc::new(Node::group(NodeId(100), vec![rect(200, 0.0), rect(201, 1e17)]));
+        for depth in 1..32 {
+            chain = Arc::new(Node::group(NodeId(100 + depth), vec![rect(300 + depth, 0.0), chain]));
+        }
+        let still = Arc::new(Node::group(NodeId(400), vec![rect(401, 0.0), rect(402, 5.0)]));
+        let clip = Arc::new(Node::new(NodeId(600), NodeKind::Group { children: vec![rect(601, 1e17), rect(602, 0.0), rect(603, 0.0)], clip: true }));
+        let mut d = doc(vec![chain, Arc::clone(&still), clip]);
+        let mut whole = d.clone();
+        let measured = std::cell::Cell::new(0_usize);
+        let far = |n: &Node| {
+            measured.set(measured.get() + 1);
+            beyond(n)
+        };
+        let layer = &mut d.layers[0];
+        let found = reach(layer, &far).unwrap();
+        assert_eq!(
+            measured.get(),
+            36,
+            "the 33 objects in the groups, the 2 beside them and the clipping path, each measured once; not what the path clips"
+        );
+        assert!(!clips_beyond(layer, &found));
+        let (mut dropped, mut layers, mut guides) = (0, BTreeSet::new(), 0);
+        drop_children_beyond(layer, found, &mut dropped, &mut layers, &mut guides);
+        assert_eq!(measured.get(), 36, "removing measures nothing again");
+        assert_eq!((dropped, layers.len(), guides), (2, 0, 0));
+        assert!(d.layers[0].children().is_some_and(|c| Arc::ptr_eq(&c[1], &still)), "a group with nothing beyond is not copied");
+        assert_eq!(whole.drop_beyond_canvas(), BeyondCanvas { objects: 2, ..Default::default() });
+        assert_eq!(ids(&whole), ids(&d));
+        assert!(!ids(&d).contains(&201) && !ids(&d).contains(&600) && ids(&d).contains(&200) && ids(&d).contains(&331));
+    }
+
+    #[test]
+    fn each_object_is_looked_at_once_when_guides_go_from_nested_layers() {
+        let guide = |id: u64, pos: f64| Arc::new(Node::new(NodeId(id), NodeKind::RulerGuide { vertical: false, pos, artboard: None }));
+        let probe = Document::new(1.0, 1.0);
+        // 32 sublayers, each inside the one before, each holding a guide within the canvas and one
+        // beyond it. Beside them, a sublayer with nothing to remove.
+        let mut chain = sublayer(&probe, 100, vec![guide(200, 5.0), guide(201, 1e17)], false);
+        for depth in 1..32 {
+            chain = sublayer(&probe, 100 + depth, vec![guide(300 + depth * 2, 5.0), guide(301 + depth * 2, 1e17), chain], false);
+        }
+        let still = sublayer(&probe, 500, vec![guide(501, 5.0), rect(502, 0.0)], false);
+        let mut d = doc(vec![chain, Arc::clone(&still)]);
+        let looked = std::cell::Cell::new(0_usize);
+        let out = |n: &Node| {
+            looked.set(looked.get() + 1);
+            matches!(n.kind, NodeKind::RulerGuide { pos, .. } if !in_range(pos))
+        };
+        let mut dropped = 0;
+        drop_guides(&mut d.layers[0], &out, &mut dropped);
+        assert_eq!(dropped, 32);
+        assert_eq!(looked.get(), 2 + 2 + 31 * 3 + 2, "each object in the layers is looked at once");
+        assert!(d.layers[0].children().is_some_and(|c| Arc::ptr_eq(&c[1], &still)), "a sublayer with nothing to remove is not copied");
+        let left = d.ruler_guides();
+        assert_eq!(left.len(), 33);
+        assert!(left.iter().all(|g| g.pos == 5.0));
+    }
 }
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index 480072a5cc..c51e099840 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -117,6 +117,7 @@ pub use slices::{CellAlign, CellVAlign, Slice, SliceArea, SliceKind, SliceOption
 pub use style_libs::StyleLibrary;
 pub use text::FontHeightReference;
 pub use text::GlyphChoice;
+pub use text::WarichuAlign;
 pub use text::{
     AreaFit, AreaOptions, Burasagari, CharAlign, CharPosition, CharStyle, Composer, Digits, FirstBaseline, HyphenationOptions, InlineArt,
     JustificationOptions, Justify, Kinsoku, KinsokuShoriType, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathAlign, PathEffect, RubyAlign,
diff --git a/crates/doc/src/text.rs b/crates/doc/src/text.rs
index d69da9bae2..440c379283 100644
--- a/crates/doc/src/text.rs
+++ b/crates/doc/src/text.rs
@@ -17,7 +17,10 @@ mod wrap;
 
 pub use area::{AreaFit, AreaOptions, PathAlign, PathEffect, TextFlow, TextWrap, VerticalAlign, WrapShape};
 use char_style::yes;
-pub use char_style::{CharAlign, CharPosition, CharStyle, Digits, FontHeightReference, GlyphChoice, MAX_AKI, ScriptMetrics};
+pub use char_style::{
+    CharAlign, CharPosition, CharStyle, Digits, FontHeightReference, GlyphChoice, MAX_AKI, MAX_WARICHU_GAP, ScriptMetrics, WARICHU_LINES,
+    WARICHU_SCALE, WarichuAlign,
+};
 pub use composite::{
     COMPOSITE_BASELINE, COMPOSITE_FONTS_MAX, COMPOSITE_NAME_MAX, COMPOSITE_SCALE, COMPOSITE_SIZE, CharClass, CompositeFont, CompositePart,
     CompositeParts,
diff --git a/crates/doc/src/text/char_style.rs b/crates/doc/src/text/char_style.rs
index a880a2a2bc..16b63e0809 100644
--- a/crates/doc/src/text/char_style.rs
+++ b/crates/doc/src/text/char_style.rs
@@ -145,6 +145,29 @@ pub struct CharStyle {
     /// <https://helpx.adobe.com/illustrator/using/formatting-asian-characters.html>
     #[serde(default, rename = "standardVerticalRoman", skip_serializing_if = "crate::skip::is_default")]
     pub standard_vertical_roman: bool,
+    /// Warichu (Character panel menu, East Asian options): these characters are set at
+    /// [`Self::warichu_scale`] percent of their size and stacked on [`Self::warichu_lines`] lines
+    /// inside their line, one above the other in horizontal type and side by side in vertical type.
+    /// A stretch of marked characters is one block that takes the settings of its first character
+    /// and stays whole on one line. Type on a path sets them at their own size on the path.
+    /// <https://helpx.adobe.com/illustrator/using/formatting-asian-characters.html>
+    #[serde(default, skip_serializing_if = "crate::skip::is_default")]
+    pub warichu: bool,
+    /// Warichu Settings › Lines: how many lines a warichu block is stacked on, within
+    /// [`WARICHU_LINES`]. Saved only when not 2.
+    #[serde(default = "two", rename = "warichuLines", skip_serializing_if = "is_two")]
+    pub warichu_lines: u8,
+    /// Warichu Settings › Line Gap, in points from 0 to [`MAX_WARICHU_GAP`]: the space between the
+    /// lines of a warichu block. Saved only when not 0.
+    #[serde(default, rename = "warichuGap", skip_serializing_if = "crate::skip::is_default")]
+    pub warichu_gap: f64,
+    /// Warichu Settings › Scale: the size of warichu characters as a percentage of their size,
+    /// within [`WARICHU_SCALE`]. Saved only when not 50.
+    #[serde(default = "fifty", rename = "warichuScale", skip_serializing_if = "is_fifty")]
+    pub warichu_scale: f64,
+    /// Warichu Settings › Alignment: how the lines of a warichu block line up along the block.
+    #[serde(default, rename = "warichuAlign", skip_serializing_if = "crate::skip::is_default")]
+    pub warichu_align: WarichuAlign,
     /// Digits (Character panel menu, Middle Eastern options): the numeral system the digits of
     /// these characters are drawn in, whatever digits were typed.
     #[serde(default, skip_serializing_if = "crate::skip::is_default")]
@@ -417,6 +440,82 @@ fn hundred() -> f64 {
 /// The largest Insert Aki Left or Right ([`CharStyle::aki_left`]), in 1/1000 em: one em.
 pub const MAX_AKI: f64 = 1000.0;
 
+/// The number of lines a warichu block may be stacked on ([`CharStyle::warichu_lines`]).
+pub const WARICHU_LINES: std::ops::RangeInclusive<u8> = 1..=6;
+
+/// The largest Warichu Settings Line Gap ([`CharStyle::warichu_gap`]), in points.
+pub const MAX_WARICHU_GAP: f64 = 100.0;
+
+/// The Warichu Settings Scale ([`CharStyle::warichu_scale`]) range, in percent of the size.
+pub const WARICHU_SCALE: std::ops::RangeInclusive<f64> = 10.0..=100.0;
+
+fn two() -> u8 {
+    2
+}
+
+fn is_two(v: &u8) -> bool {
+    *v == 2
+}
+
+fn fifty() -> f64 {
+    50.0
+}
+
+fn is_fifty(v: &f64) -> bool {
+    *v == 50.0
+}
+
+/// How the lines of a warichu block line up along the block ([`CharStyle::warichu_align`]):
+/// each line set flush left (top, in vertical type), centered or flush right (bottom), or spread
+/// to the block's length with the last line set flush left, centered or flush right, or spread as
+/// well. Auto is the default and sets the lines as [`WarichuAlign::JustifyLeft`] does.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum WarichuAlign {
+    #[default]
+    Auto,
+    Left,
+    Center,
+    Right,
+    JustifyLeft,
+    JustifyCenter,
+    JustifyRight,
+    JustifyAll,
+}
+
+impl WarichuAlign {
+    /// Every alignment, in the order Warichu Settings lists them.
+    pub const ALL: [WarichuAlign; 8] = [
+        WarichuAlign::Auto,
+        WarichuAlign::Left,
+        WarichuAlign::Center,
+        WarichuAlign::Right,
+        WarichuAlign::JustifyLeft,
+        WarichuAlign::JustifyCenter,
+        WarichuAlign::JustifyRight,
+        WarichuAlign::JustifyAll,
+    ];
+
+    /// The name files and commands give this alignment (as it is saved).
+    pub fn id(self) -> &'static str {
+        match self {
+            WarichuAlign::Auto => "auto",
+            WarichuAlign::Left => "left",
+            WarichuAlign::Center => "center",
+            WarichuAlign::Right => "right",
+            WarichuAlign::JustifyLeft => "justifyLeft",
+            WarichuAlign::JustifyCenter => "justifyCenter",
+            WarichuAlign::JustifyRight => "justifyRight",
+            WarichuAlign::JustifyAll => "justifyAll",
+        }
+    }
+
+    /// The alignment [`WarichuAlign::id`] names; `None` for any other name.
+    pub fn from_id(id: &str) -> Option<WarichuAlign> {
+        WarichuAlign::ALL.into_iter().find(|a| a.id() == id)
+    }
+}
+
 pub(super) fn yes() -> bool {
     true
 }
@@ -464,6 +563,11 @@ impl Default for CharStyle {
             tcy_up_down: 0.0,
             tcy_left_right: 0.0,
             standard_vertical_roman: false,
+            warichu: false,
+            warichu_lines: 2,
+            warichu_gap: 0.0,
+            warichu_scale: 50.0,
+            warichu_align: WarichuAlign::Auto,
             small_caps: None,
             digits: Digits::Default,
             font_height_reference: FontHeightReference::EmBox,
@@ -484,7 +588,10 @@ impl CharStyle {
     /// becomes the nearer end. A leading of 0, which legacy `.ai` import stores, stays, and a
     /// baseline shift that is not a number becomes 0. The Tate-chu-yoko Up/Down and Left/Right
     /// offsets are kept as the baseline shift is. Insert Aki Left and Right are kept from 0 to
-    /// [`MAX_AKI`], and one that is not a number becomes 0.
+    /// [`MAX_AKI`], and one that is not a number becomes 0. The Warichu Settings Lines and Scale
+    /// are kept to [`WARICHU_LINES`] and [`WARICHU_SCALE`]; a gap or scale that is not a number becomes its default. The gap is kept to 0 to
+    /// [`crate::MAX_COORD`], as the baseline shift is, since a scaled type object holds it in its
+    /// own units.
     pub fn keep_dimensions_in_range(&mut self) {
         let default = Self::default();
         let within = |v: f64, or: f64| if v > 0.0 { v.min(crate::MAX_COORD) } else { or };
@@ -499,6 +606,10 @@ impl CharStyle {
         let aki = |v: f64| if v.is_nan() { 0.0 } else { v.clamp(0.0, MAX_AKI) };
         self.aki_left = aki(self.aki_left);
         self.aki_right = aki(self.aki_right);
+        self.warichu_lines = self.warichu_lines.clamp(*WARICHU_LINES.start(), *WARICHU_LINES.end());
+        self.warichu_gap = if self.warichu_gap.is_nan() { default.warichu_gap } else { self.warichu_gap.clamp(0.0, crate::MAX_COORD) };
+        self.warichu_scale =
+            if self.warichu_scale.is_nan() { default.warichu_scale } else { self.warichu_scale.clamp(*WARICHU_SCALE.start(), *WARICHU_SCALE.end()) };
     }
     /// Do the characters draw a stroke (a paint and a positive weight)?
     pub fn has_stroke(&self) -> bool {
diff --git a/crates/doc/src/text/object.rs b/crates/doc/src/text/object.rs
index 68f41abd5b..dd4002dd60 100644
--- a/crates/doc/src/text/object.rs
+++ b/crates/doc/src/text/object.rs
@@ -34,10 +34,19 @@ impl TextObject {
         style.baseline_shift *= scale.points;
         style.tcy_up_down *= scale.points;
         style.tcy_left_right *= scale.points;
+        style.warichu_gap *= scale.points;
         style.h_scale *= scale.horizontal;
-        if ![style.size, style.leading.unwrap_or(0.0), style.baseline_shift, style.tcy_up_down, style.tcy_left_right, style.h_scale]
-            .iter()
-            .all(|v| v.is_finite())
+        if ![
+            style.size,
+            style.leading.unwrap_or(0.0),
+            style.baseline_shift,
+            style.tcy_up_down,
+            style.tcy_left_right,
+            style.warichu_gap,
+            style.h_scale,
+        ]
+        .iter()
+        .all(|v| v.is_finite())
         {
             return None;
         }
@@ -114,6 +123,12 @@ impl TextObject {
     pub fn plain_text(&self) -> String {
         self.runs.iter().map(|r| r.text.as_str()).collect()
     }
+    /// Does layout stack some of this type's characters as warichu ([`CharStyle::warichu`])? Not
+    /// on a path, which sets them as they are. Exports that write live text write such type as
+    /// outlines, as they do ruby: their text can't place the stacked lines.
+    pub fn stacks_warichu(&self) -> bool {
+        !matches!(self.kind, TextKind::OnPath { .. }) && self.runs.iter().any(|r| r.style.warichu && !r.text.is_empty())
+    }
     /// Clamp the ruby spans to the plain text, drop empty/empty-reading ones and sort them.
     ///
     /// Called after loading and editing text: ranges from a file or an edit are untrusted, and a
@@ -492,8 +507,23 @@ impl crate::Document {
             st.tcy_left_right = num("tcyLeftRight").unwrap_or(st.tcy_left_right);
             st.aki_left = num("akiLeft").unwrap_or(st.aki_left);
             st.aki_right = num("akiRight").unwrap_or(st.aki_right);
+            st.warichu_gap = num("warichuGap").unwrap_or(st.warichu_gap);
+            st.warichu_scale = num("warichuScale").unwrap_or(st.warichu_scale);
             st.keep_dimensions_in_range();
+            // Lines is a whole number: a stored number outside the range, or with a fraction,
+            // becomes the nearest whole number within it.
+            if let Some(old) = def.attrs.get_mut("warichuLines")
+                && old.is_number()
+                && old.as_u64().is_none_or(|v| !super::WARICHU_LINES.contains(&u8::try_from(v).unwrap_or(u8::MAX)))
+            {
+                let (lo, hi) = (*super::WARICHU_LINES.start(), *super::WARICHU_LINES.end());
+                let v = old.as_f64().filter(|v| v.is_finite()).map_or(2.0, |v| v.round().clamp(f64::from(lo), f64::from(hi)));
+                // Within 1..6 after the clamp, so the cast keeps the value.
+                *old = (v as u8).into();
+            }
             let kept = [
+                ("warichuGap", Some(st.warichu_gap)),
+                ("warichuScale", Some(st.warichu_scale)),
                 ("size", Some(st.size)),
                 ("h_scale", Some(st.h_scale)),
                 ("v_scale", Some(st.v_scale)),
diff --git a/crates/doc/src/text/tabs_lists.rs b/crates/doc/src/text/tabs_lists.rs
index 4fcaa8d078..b8531b402d 100644
--- a/crates/doc/src/text/tabs_lists.rs
+++ b/crates/doc/src/text/tabs_lists.rs
@@ -357,7 +357,7 @@ impl ParaList {
 
     /// The style the marker is set in: `first` (the style of the paragraph's first character)
     /// without its baseline shift, rotation, superscript or subscript, tracking, manual kerning,
-    /// Insert Aki, tate-chu-yoko, underline and strikethrough.
+    /// Insert Aki, tate-chu-yoko, warichu, underline and strikethrough.
     pub fn marker_style(first: &CharStyle) -> CharStyle {
         CharStyle {
             baseline_shift: 0.0,
@@ -370,6 +370,7 @@ impl ParaList {
             aki_right: 0.0,
             optical_kerning: first.optical_kerning,
             tate_chu_yoko: false,
+            warichu: false,
             underline: false,
             strikethrough: false,
             ..first.clone()
diff --git a/crates/effects/src/solids.rs b/crates/effects/src/solids.rs
index 2642fca878..a68ff9529f 100644
--- a/crates/effects/src/solids.rs
+++ b/crates/effects/src/solids.rs
@@ -209,6 +209,19 @@ pub(crate) fn solid_paints(n: &Node) -> Vec<AppearanceItem> {
     runs
 }
 
+/// [`solid_paints`] with, for each paint, the item of `n` it copies: the item a live-effect plug-in
+/// before the paint's own 3D effect is told it sits on. The paints of a type's first run copy no
+/// item of `n` and have none.
+pub(crate) fn solid_paint_sources(n: &Node) -> (Vec<Option<&AppearanceItem>>, Vec<AppearanceItem>) {
+    let own: Vec<&AppearanceItem> = n.appearance.items.iter().filter(|i| crate::paints(i)).collect();
+    if own.is_empty() {
+        let paints = solid_paints(n);
+        return (vec![None; paints.len()], paints);
+    }
+    let paints = own.iter().map(|i| (*i).clone()).collect();
+    (own.into_iter().map(Some).collect(), paints)
+}
+
 fn facets(id: &str, path: &PathData, rule: FillRule, bounds: Rect, p: &Value) -> Result<Vec<Facet>, String> {
     let view = view_options(p);
     match id {
@@ -1771,7 +1784,7 @@ pub fn solid_art_in(doc: Option<&Document>, n: &Node) -> Option<Node> {
     }
     let (path, rule) = profile(n)?;
     let ctx = GeomContext::of(n);
-    let paints = solid_paints(n);
+    let (sources, paints) = solid_paint_sources(n);
     let mut children = vec![];
     let remaining: Vec<Effect>;
     if let Some((index, fx)) = solid(&n.appearance.effects) {
@@ -1789,9 +1802,9 @@ pub fn solid_art_in(doc: Option<&Document>, n: &Node) -> Option<Node> {
         crate::raster::follow_paints(&mut paints, &n.appearance.effects);
         // Every item's shadow goes behind every item's art.
         let mut shadows = vec![];
-        for item in &paints {
+        for (source, item) in sources.into_iter().zip(&paints) {
             if let Some((index, fx)) = solid(item.effects()) {
-                let p = geometry(&path, item.effects().get(..index)?, &ctx.item(item));
+                let p = geometry(&path, item.effects().get(..index)?, &ctx.item(source.unwrap_or(item)));
                 let (shadow, surfaces) = art_for(doc, n, fx, &[Profile { path: p, rule, items: vec![item.clone()], opacity: 1.0, scopes: vec![] }])?;
                 let later: Vec<Effect> = item.effects().iter().skip(index + 1).filter(|e| !is_three_d(&e.id)).cloned().collect();
                 let with_later = |mut art: Arc<Node>| {
@@ -2086,16 +2099,16 @@ fn meshes_within(doc: Option<&Document>, n: &Node, total: &mut usize, limit: usi
     } else {
         let (path, rule) = object_profile(n, label)?;
         let ctx = GeomContext::of(n);
-        let paints = solid_paints(n);
+        let (sources, paints) = solid_paint_sources(n);
         if let Some((index, fx)) = solid(&n.appearance.effects) {
             let path = geometry(&path, n.appearance.effects.get(..index).unwrap_or_default(), &ctx);
             meshes_for(fx, &[Profile { path, rule, items: paints, opacity: 1.0, scopes: vec![] }], total, limit)?
         } else {
             let path = geometry(&path, &n.appearance.effects, &ctx);
             let mut out = vec![];
-            for item in &paints {
+            for (source, item) in sources.into_iter().zip(&paints) {
                 if let Some((index, fx)) = solid(item.effects()) {
-                    let p = geometry(&path, item.effects().get(..index).unwrap_or_default(), &ctx.item(item));
+                    let p = geometry(&path, item.effects().get(..index).unwrap_or_default(), &ctx.item(source.unwrap_or(item)));
                     out.extend(meshes_for(fx, &[Profile { path: p, rule, items: vec![item.clone()], opacity: 1.0, scopes: vec![] }], total, limit)?);
                 }
             }
diff --git a/crates/effects/src/solids/wireframe.rs b/crates/effects/src/solids/wireframe.rs
index 00e741bfe6..e6e7d89ab5 100644
--- a/crates/effects/src/solids/wireframe.rs
+++ b/crates/effects/src/solids/wireframe.rs
@@ -10,7 +10,7 @@ use vectorcraft_three_d::Facet;
 
 use super::{
     Profile, ROTATE, built_solids, facets, geometry, has_solid, is_container, is_plane, is_three_d, label_of, members, object_profile, region,
-    reshape_members, resolve, resolve_for, solid, solid_paints, solid_parts, union_bounds,
+    reshape_members, resolve, resolve_for, solid, solid_paint_sources, solid_parts, union_bounds,
 };
 use crate::{GeomContext, is_geometry};
 
@@ -105,16 +105,16 @@ fn solid_face_paths(doc: Option<&Document>, n: &Node) -> Result<Vec<PathData>, S
     let label = n.appearance.effects.iter().find(|e| e.visible && is_three_d(&e.id)).map_or("This effect", |e| label_of(&e.id));
     let (path, rule) = object_profile(n, label)?;
     let ctx = GeomContext::of(n);
-    let paints = solid_paints(n);
+    let (sources, paints) = solid_paint_sources(n);
     if let Some((index, fx)) = solid(&n.appearance.effects) {
         let path = geometry(&path, n.appearance.effects.get(..index).unwrap_or_default(), &ctx);
         return facet_paths(fx, &[Profile { path, rule, items: paints, opacity: 1.0, scopes: vec![] }]);
     }
     let path = geometry(&path, &n.appearance.effects, &ctx);
     let mut out = vec![];
-    for item in &paints {
+    for (source, item) in sources.into_iter().zip(&paints) {
         if let Some((index, fx)) = solid(item.effects()) {
-            let p = geometry(&path, item.effects().get(..index).unwrap_or_default(), &ctx.item(item));
+            let p = geometry(&path, item.effects().get(..index).unwrap_or_default(), &ctx.item(source.unwrap_or(item)));
             let faces = facet_paths(fx, &[Profile { path: p, rule, items: vec![item.clone()], opacity: 1.0, scopes: vec![] }])?;
             out.extend(reshaped(faces, item.effects().get(index + 1..).unwrap_or_default(), &GeomContext { doc, ..ctx }));
         }
diff --git a/crates/effects/src/tests.rs b/crates/effects/src/tests.rs
index 48665539d9..627cc1be03 100644
--- a/crates/effects/src/tests.rs
+++ b/crates/effects/src/tests.rs
@@ -8,6 +8,7 @@ mod imageoutline;
 mod painted;
 mod rasterfollow;
 mod scale;
+mod solidcontext;
 mod transformfx;
 
 fn fx(id: &str, params: Value) -> Effect {
diff --git a/crates/effects/src/tests/solidcontext.rs b/crates/effects/src/tests/solidcontext.rs
new file mode 100644
index 0000000000..2de212dba1
--- /dev/null
+++ b/crates/effects/src/tests/solidcontext.rs
@@ -0,0 +1,74 @@
+//! A live-effect plug-in before a fill's or stroke's own 3D effect is told which fill or stroke it
+//! is on, in the drawn art, the exported meshes and the wireframe.
+
+use serde_json::json;
+use vectorcraft_color::{Color, Paint};
+use vectorcraft_doc::{Appearance, AppearanceItem, Effect, FillLayer, Node, NodeId};
+use vectorcraft_geom::{PathData, Rect, shapes};
+use vectorcraft_plugins::wat as tpl;
+
+use crate::{EXTRUDE, solid_art, three_d_meshes_in, three_d_wireframe_in};
+
+/// Widths the plug-in's squares are drawn at: `LARGE` when it is told it is on the item it looks
+/// for, `SMALL` otherwise.
+const LARGE: f64 = 600.0;
+const SMALL: f64 = 6.0;
+
+/// A rectangle with a fill, a 1 pt stroke and a second fill on top. The item at `at` (an index in
+/// its appearance items) has, in its own effects, live-effect plug-in `name` and then Extrude &
+/// Bevel. The plug-in returns a `LARGE` square when it is given `item`, and a `SMALL` one otherwise.
+fn plugin_then_extrude(name: &str, at: usize, item: &str) -> Node {
+    let square = |w: f64| shapes::rectangle(Rect::new(0.0, 0.0, w, w));
+    let id = format!("test.effects.solidcontext.{name}");
+    let manifest = format!(r#"{{"id":"{id}","name":"Test {id}","version":"1","kind":"effect","params":{{}}}}"#);
+    let (large, small) = (json!({"objects": [{"path": square(LARGE)}]}).to_string(), json!({"objects": [{"path": square(SMALL)}]}).to_string());
+    let module = wat::parse_str(tpl::when_given_else(&manifest, tpl::Given::Params, item, &large, &small)).unwrap();
+    vectorcraft_plugins::registry::install_bytes(&module).unwrap();
+    let mut appearance = Appearance::basic(Paint::solid(Color::rgb(1.0, 0.0, 0.0)), Paint::solid(Color::BLACK), 1.0);
+    appearance.items.push(AppearanceItem::Fill(FillLayer::new(Paint::solid(Color::rgb(0.0, 0.0, 1.0)))));
+    let effects = appearance.items[at].effects_mut();
+    effects.push(Effect { id: format!("plugin.{id}"), params: json!({}), visible: true });
+    effects.push(crate::new_effect(EXTRUDE, &json!({})).unwrap());
+    Node::path(NodeId(7), shapes::rectangle(Rect::new(0.0, 0.0, 20.0, 20.0)), appearance)
+}
+
+/// The width of the union of `paths`' bounds.
+fn width(paths: impl IntoIterator<Item = PathData>) -> f64 {
+    paths.into_iter().filter_map(|p| p.bounds()).reduce(|a, b| a.union(b)).map_or(0.0, |b| b.width())
+}
+
+/// Whether each of the art, the meshes and the wireframe `n`'s 3D effect draws is wider than half
+/// of `LARGE`, with the widths.
+fn drawn_large(n: &Node) -> ([bool; 3], [f64; 3]) {
+    let art = solid_art(n).unwrap();
+    let mut paths = vec![];
+    art.walk(&mut |c| paths.extend(c.path_data().cloned()));
+    let meshes = three_d_meshes_in(None, n).unwrap();
+    let xs = meshes.iter().flat_map(|m| m.mesh.positions.iter().map(|p| p[0]));
+    let mesh_width = xs.clone().fold(f64::NEG_INFINITY, f64::max) - xs.fold(f64::INFINITY, f64::min);
+    let widths = [width(paths), mesh_width, width(three_d_wireframe_in(None, n).unwrap())];
+    (widths.map(|w| w > LARGE / 2.0), widths)
+}
+
+/// A plug-in before the second fill's Extrude & Bevel is given `{"fill": 1}`, not `"object"`, so
+/// the art, meshes and wireframe are all built from the square it returns for that fill.
+#[test]
+fn a_plugin_before_a_fills_extrude_is_told_its_fill() {
+    let (large, widths) = drawn_large(&plugin_then_extrude("fill", 2, r#""item":{"fill":1}"#));
+    assert_eq!(large, [true; 3], "the art, meshes and wireframe are {widths:?} wide");
+}
+
+/// A plug-in before the stroke's Extrude & Bevel is given `{"stroke": 0}`.
+#[test]
+fn a_plugin_before_a_strokes_extrude_is_told_its_stroke() {
+    let (large, widths) = drawn_large(&plugin_then_extrude("stroke", 1, r#""item":{"stroke":0}"#));
+    assert_eq!(large, [true; 3], "the art, meshes and wireframe are {widths:?} wide");
+}
+
+/// A plug-in on a fill is not told it is on the object: the square it returns otherwise is the one
+/// extruded.
+#[test]
+fn a_plugin_on_a_fill_is_not_told_it_is_on_the_object() {
+    let (large, widths) = drawn_large(&plugin_then_extrude("object", 2, r#""item":"object""#));
+    assert_eq!(large, [false; 3], "the art, meshes and wireframe are {widths:?} wide");
+}
diff --git a/crates/engine/src/cmd.rs b/crates/engine/src/cmd.rs
index 166436b0c8..94d8add68b 100644
--- a/crates/engine/src/cmd.rs
+++ b/crates/engine/src/cmd.rs
@@ -46,7 +46,7 @@ pub mod importmatches;
 pub(crate) mod inline;
 mod interactivity;
 mod intertwine;
-mod layer;
+pub(crate) mod layer;
 mod layerpanel;
 pub mod library;
 pub mod linkfiles;
diff --git a/crates/engine/src/cmd/addons/arrange.rs b/crates/engine/src/cmd/addons/arrange.rs
index 735d721335..d7cae868ed 100644
--- a/crates/engine/src/cmd/addons/arrange.rs
+++ b/crates/engine/src/cmd/addons/arrange.rs
@@ -20,7 +20,9 @@ use vectorcraft_doc::{Node, NodeId, OrientedBox};
 use vectorcraft_geom::{Affine, Point, Rect};
 use vectorcraft_render::effects;
 
+use super::super::appearance::series_children_in_paint_order;
 use super::super::edit::selected_roots;
+use super::super::graph::capture_series_object_opacity;
 use super::super::menucmds::whole_or;
 use super::super::object::{choice, object_bounds_transform, scaling, transform_node, transform_patterns};
 use super::super::typecmd::refresh_bounds_of;
@@ -90,7 +92,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Randomize Opacity",
             ["Object", "Plug-ins", "Arrange Tools"],
             None,
-            "{min?: % 0..100 (30), max?: % 0..100 (100; not less than min), seed?: whole number (0; the same seed, objects and range give the same opacities), ids?: [id…] (default: the selection)} give each selected object (the top-level ones) its own opacity, picked at random and evenly from min to max, as one undo step; it is the object's opacity, as the Transparency panel sets it → {count}",
+            "{min?: % 0..100 (30), max?: % 0..100 (100; not less than min), seed?: whole number (0; the same seed, objects and range give the same opacities), ids?: [id…] (default: the selection)} give each selected object (the top-level ones) its own opacity, picked at random and evenly from min to max, as one undo step; it is the object's opacity, as the Transparency panel sets it. On paths directly in a graph series whose opacity changes, the graph stores the opacity and blend mode of the frontmost of them for its next redraw (docs/mcp.md) → {count}",
             has_selection,
             randomize_opacity
         ),
@@ -99,7 +101,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Sort Objects",
             ["Object", "Plug-ins", "Arrange Tools"],
             None,
-            "{by?: \"width\" | \"height\" | \"area\" (width × height) | \"x\" (left edge) | \"y\" (top edge) | \"opacity\" (%) | \"stacking\" (stacking order, from the back) (\"area\"), apply?: one of the same (\"stacking\"), order?: \"ascending\" (small to large) | \"descending\" (large to small) | \"random\" (\"ascending\"), distribute?: false (true: the values step evenly from the smallest to the largest; false: the objects trade the values they have), seed?: whole number (0; the order \"random\" picks), scaleStrokes?: the Scale Strokes & Effects preference (width, height and area), ids?: [id…] (default: the selection)} sort the selected objects (the top-level ones, at most 20000) by the attribute `by` and give them the values of `apply` in that order, as one undo step: the first in order gets the smallest value. Sizes and places are measured and set as object.setBounds measures them (Use Preview Bounds), a width, height or area about each object's centre (an area in proportion); stacking order always trades places, and only among the objects in the same layer or group. A run that changes nothing makes no step → {count}",
+            "{by?: \"width\" | \"height\" | \"area\" (width × height) | \"x\" (left edge) | \"y\" (top edge) | \"opacity\" (%) | \"stacking\" (stacking order, from the back) (\"area\"), apply?: one of the same (\"stacking\"), order?: \"ascending\" (small to large) | \"descending\" (large to small) | \"random\" (\"ascending\"), distribute?: false (true: the values step evenly from the smallest to the largest; false: the objects trade the values they have), seed?: whole number (0; the order \"random\" picks), scaleStrokes?: the Scale Strokes & Effects preference (width, height and area), ids?: [id…] (default: the selection)} sort the selected objects (the top-level ones, at most 20000) by the attribute `by` and give them the values of `apply` in that order, as one undo step: the first in order gets the smallest value. Sizes and places are measured and set as object.setBounds measures them (Use Preview Bounds), a width, height or area about each object's centre (an area in proportion); stacking order always trades places, and only among the objects in the same layer or group. With apply \"opacity\", on paths directly in a graph series whose opacity changes, the graph stores the opacity and blend mode of the frontmost of them for its next redraw (docs/mcp.md). A run that changes nothing makes no step → {count}",
             has_multi,
             sort
         ),
@@ -396,17 +398,30 @@ fn randomize_opacity(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let (lo, hi) = ((min / 100.0) as f32, (max / 100.0) as f32);
     s.edit("Randomize Opacity", |d, _| {
+        let mut changed = vec![];
         for id in &ids {
             let o = rng.range(lo, hi);
-            if let Some(n) = d.node_mut(*id) {
+            if let Some(n) = d.node_mut(*id)
+                && n.opacity != o
+            {
                 n.opacity = o;
+                changed.push(*id);
             }
         }
+        keep_series_opacity(d, &changed);
         Ok(())
     })?;
     Ok(json!({ "count": ids.len() }))
 }
 
+/// Store on their graphs the opacity just given to the paths among `changed` (objects whose opacity changed) that are
+/// directly in a graph series, with their blend mode, so that every path of the series has them when the graph is drawn
+/// again; the frontmost of them in a series sets them.
+fn keep_series_opacity(d: &mut vectorcraft_doc::Document, changed: &[NodeId]) {
+    let marks = series_children_in_paint_order(d, changed);
+    capture_series_object_opacity(d, &marks);
+}
+
 /// An object Sort Objects sorts: its layer or group, its place in it, its box as
 /// `object.setBounds` measures it and its opacity (%).
 struct Sorted {
@@ -510,6 +525,8 @@ fn sort(s: &mut Session, p: &Value) -> Result<Value> {
                     n.opacity = (v / 100.0) as f32;
                 }
             }
+            let changed: Vec<NodeId> = wanted.iter().filter(|(o, v)| (o.opacity - v).abs() >= 1e-6).map(|(o, _)| o.id).collect();
+            keep_series_opacity(d, &changed);
             Ok(())
         })?;
         return Ok(count);
diff --git a/crates/engine/src/cmd/addons/cleanup/checks.rs b/crates/engine/src/cmd/addons/cleanup/checks.rs
index 52b20cdddc..be32cf0a83 100644
--- a/crates/engine/src/cmd/addons/cleanup/checks.rs
+++ b/crates/engine/src/cmd/addons/cleanup/checks.rs
@@ -10,7 +10,7 @@ use vectorcraft_geom::{PathData, Point, Rect};
 use vectorcraft_pathops::addons as po;
 
 use super::super::super::edit::outermost;
-use super::super::super::layer::empty_artboards;
+use super::super::super::layer::{empty_artboards, remove_artboards};
 use crate::Result;
 
 /// Sine of the turn below which an anchor on a straight run is collinear.
@@ -508,35 +508,6 @@ fn artboards(d: &mut Document, sel: &mut Selection, scope: &Scope) -> Result<Out
     if empty.is_empty() {
         return Ok(Outcome::default());
     }
-    // `empty` is in artboard order: one walk drops them and the others keep their order.
-    let mut gone: HashSet<u32> = HashSet::with_capacity(empty.len());
-    let mut i = 0;
-    d.artboards.retain(|a| {
-        let keep = empty.binary_search(&i).is_err();
-        i += 1;
-        if !keep {
-            gone.insert(a.id);
-        }
-        keep
-    });
-    count_artboard_pass();
-    for &id in &gone {
-        d.retire_artboard_id(id);
-    }
-    d.retain_guides(sel, |g| !g.artboard.is_some_and(|a| gone.contains(&a)));
-    count_artboard_pass();
+    remove_artboards(d, sel, &empty)?;
     Ok(Outcome { count: empty.len(), ids: vec![], artboards: empty })
 }
-
-#[cfg(test)]
-thread_local! {
-    /// Tests: how many walks [`artboards`] made over the artboards and the ruler guides on this
-    /// thread.
-    pub(super) static ARTBOARD_PASSES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
-}
-
-/// Tests: count one walk over the artboards or the ruler guides.
-fn count_artboard_pass() {
-    #[cfg(test)]
-    ARTBOARD_PASSES.set(ARTBOARD_PASSES.get() + 1);
-}
diff --git a/crates/engine/src/cmd/addons/cleanup/tests.rs b/crates/engine/src/cmd/addons/cleanup/tests.rs
index 2ccdce9dad..4d4ed6461b 100644
--- a/crates/engine/src/cmd/addons/cleanup/tests.rs
+++ b/crates/engine/src/cmd/addons/cleanup/tests.rs
@@ -502,7 +502,7 @@ fn removing_many_selected_objects_looks_at_each_root_once_a_pass() {
 
 #[test]
 fn deleting_many_empty_artboards_walks_the_artboards_and_guides_once() {
-    use super::checks::ARTBOARD_PASSES;
+    use crate::cmd::layer::ARTBOARD_PASSES;
     let mut s = session();
     rect(&mut s, 200.0, 20.0, 80.0, 60.0);
     let (keep, gone) = s
diff --git a/crates/engine/src/cmd/addons/cleanup/text.rs b/crates/engine/src/cmd/addons/cleanup/text.rs
index 7d7dcbb197..052ba901ed 100644
--- a/crates/engine/src/cmd/addons/cleanup/text.rs
+++ b/crates/engine/src/cmd/addons/cleanup/text.rs
@@ -206,11 +206,31 @@ struct Source {
     text: String,
 }
 
+#[cfg(test)]
+thread_local! {
+    /// Tests: how many times [`thread_index`] went through the document's threads on this thread.
+    static THREAD_SCANS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+/// Each object the document's text threads list, with the index of the first thread that lists it.
+fn thread_index(d: &Document) -> std::collections::HashMap<NodeId, usize> {
+    #[cfg(test)]
+    THREAD_SCANS.with(|c| c.set(c.get() + 1));
+    let mut out = std::collections::HashMap::new();
+    for (i, thread) in d.text_threads.iter().enumerate() {
+        for id in thread {
+            out.entry(*id).or_insert(i);
+        }
+    }
+    out
+}
+
 impl Source {
-    /// Horizontal point or area type that isn't threaded and whose text all fits; None otherwise.
-    fn of(d: &Document, id: NodeId) -> Option<Self> {
+    /// Horizontal point or area type that isn't threaded (`threaded` false) and whose text all
+    /// fits; None otherwise.
+    fn of(d: &Document, id: NodeId, threaded: bool) -> Option<Self> {
         let t = text_of(d, id)?;
-        if t.vertical || matches!(t.kind, TextKind::OnPath { .. }) || d.text_threads.iter().any(|th| th.contains(&id)) {
+        if t.vertical || matches!(t.kind, TextKind::OnPath { .. }) || threaded {
             return None;
         }
         let lay = layout(t);
@@ -376,8 +396,10 @@ fn break_text(s: &mut Session, p: &Value) -> Result<Value> {
     };
     let d = &s.doc()?.doc;
     let (mut items, mut skipped, mut count) = (vec![], vec![], 0);
-    for id in texts_under(d, &checked_ids_or_selection(s, p, C)?)? {
-        let (Some(src), Some(node)) = (Source::of(d, id), d.node(id)) else {
+    let ids = texts_under(d, &checked_ids_or_selection(s, p, C)?)?;
+    let threads = thread_index(d);
+    for id in ids {
+        let (Some(src), Some(node)) = (Source::of(d, id, threads.contains_key(&id)), d.node(id)) else {
             skipped.push(id);
             continue;
         };
@@ -405,7 +427,8 @@ fn split_text(s: &mut Session, _: &Value) -> Result<Value> {
         return Err(EngineError::Other("Click in type with a Type tool to split it".into()));
     };
     let d = &s.doc()?.doc;
-    let (Some(src), Some(node)) = (Source::of(d, id), d.node(id).filter(|_| d.is_editable(id))) else {
+    let threaded = d.text_threads.iter().any(|th| th.contains(&id));
+    let (Some(src), Some(node)) = (Source::of(d, id, threaded), d.node(id).filter(|_| d.is_editable(id))) else {
         return Err(EngineError::Other("Select horizontal point or area type whose text fits".into()));
     };
     let text = &src.text;
@@ -821,13 +844,17 @@ fn remove_breaks(s: &mut Session, p: &Value) -> Result<Value> {
             let ids = texts_under(d, &checked_ids_or_selection(s, p, C)?)?;
             // A threaded story whose frames are all among them is read as one text, once.
             let named: std::collections::HashSet<NodeId> = ids.iter().copied().collect();
+            let threads = thread_index(d);
             let mut done = std::collections::HashSet::new();
             let mut out: Vec<(NodeId, Vec<(usize, bool)>)> = vec![];
             for &id in &ids {
                 if !done.insert(id) {
                     continue;
                 }
-                let story = crate::cmd::threads::story_of(d, id);
+                let story = match threads.get(&id).and_then(|&i| d.text_threads.get(i)) {
+                    Some(thread) => crate::cmd::threads::story_in(d, thread, id),
+                    None => vec![],
+                };
                 if !story.is_empty() && story.iter().all(|f| named.contains(f)) {
                     done.extend(story.iter().copied());
                     out.extend(story_cuts(d, &story, brk));
diff --git a/crates/engine/src/cmd/addons/cleanup/text/tests.rs b/crates/engine/src/cmd/addons/cleanup/text/tests.rs
index 3769cf3b42..cfa78a5ce5 100644
--- a/crates/engine/src/cmd/addons/cleanup/text/tests.rs
+++ b/crates/engine/src/cmd/addons/cleanup/text/tests.rs
@@ -158,6 +158,62 @@ fn break_text_refuses_what_it_cannot_break() {
     assert!(matches!(r, Err(EngineError::BadParams { .. })), "{r:?}");
 }
 
+/// Two area frames threaded together, with `story` flowing through them → (first, second).
+fn threaded(s: &mut Session, story: &str) -> (NodeId, NodeId) {
+    let a = text(s, json!({"x": 10, "y": 300, "text": story, "size": 12, "area": {"width": 150, "height": 60}}));
+    let b = NodeId(s.execute("shape.rectangle", &json!({"x": 200, "y": 300, "width": 150, "height": 60})).unwrap()["id"].as_u64().unwrap());
+    select(s, &[a, b]);
+    s.execute("text.thread.create", &json!({})).unwrap();
+    (a, b)
+}
+
+fn thread_scans() -> usize {
+    super::THREAD_SCANS.with(|c| c.get())
+}
+
+/// Threaded frames in the selection stay as they are and are reported as skipped; the other type
+/// is broken. The document's threads are gone through once for the whole selection, not once
+/// per object.
+#[test]
+fn break_text_skips_threaded_frames_and_reads_the_threads_once() {
+    let mut s = session();
+    let (a, b) = threaded(&mut s, "Threaded story text");
+    let mut plain = vec![];
+    for i in 0..6 {
+        plain.push(text(&mut s, json!({"x": 20, "y": 30 + 30 * i, "text": "Two words", "size": 14})));
+    }
+    let was = glyphs(&s, &plain);
+    let frames = (obj(&s, a), obj(&s, b));
+    let before = doc_json(&s);
+    let steps = undo_steps(&s);
+    let mut all = vec![a, b];
+    all.extend(&plain);
+    select(&mut s, &all);
+    let scans = thread_scans();
+    let r = s.execute("addon.cleanup.breakText", &json!({"by": "words"})).unwrap();
+    assert_eq!(thread_scans() - scans, 1, "the threads are gone through once");
+    assert_eq!(ids(&json!({"ids": r["skipped"]})), [a, b]);
+    assert_eq!((obj(&s, a), obj(&s, b)), frames, "the threaded frames stay as they are");
+    let pieces = ids(&r);
+    assert_eq!(pieces.len(), 12);
+    assert_eq!(s.doc().unwrap().selection.objects.len(), 12, "the pieces are selected");
+    assert_same_places(&was, &glyphs(&s, &pieces));
+    assert_eq!(undo_steps(&s), steps + 1);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(doc_json(&s), before);
+}
+
+#[test]
+fn split_text_refuses_a_threaded_frame() {
+    let mut s = session();
+    let (a, _) = threaded(&mut s, "Threaded story text");
+    select(&mut s, &[a]);
+    edit_text(&mut s, a, 9, 9);
+    let before = doc_json(&s);
+    assert!(other(s.execute("addon.cleanup.splitText", &json!({}))).contains("point or area type"));
+    assert_eq!(doc_json(&s), before);
+}
+
 #[test]
 fn combine_puts_glyph_pieces_back_together_where_they_were() {
     let mut s = session();
@@ -300,6 +356,29 @@ fn remove_breaks_with_ids_null_in_the_characters_a_type_tool_selected() {
     assert_eq!(obj(&s, id).plain_text(), "a b\nc");
 }
 
+/// Remove Breaks reads a threaded story whose frames are all selected as one text and each other
+/// object on its own, going through the document's threads once for the whole selection.
+#[test]
+fn remove_breaks_reads_the_threads_once() {
+    let mut s = session();
+    let (a, b) = threaded(&mut s, "one\ntwo");
+    let mut plain = vec![];
+    for i in 0..6 {
+        plain.push(text(&mut s, json!({"x": 20, "y": 30 + 30 * i, "text": "a\nb", "size": 12})));
+    }
+    let mut all = vec![a, b];
+    all.extend(&plain);
+    select(&mut s, &all);
+    let scans = thread_scans();
+    let r = s.execute("addon.cleanup.removeBreaks", &json!({"kind": "paragraph"})).unwrap();
+    assert_eq!(thread_scans() - scans, 1, "the threads are gone through once");
+    assert_eq!(r["removed"], 7);
+    assert_eq!(obj(&s, a).plain_text(), "one two");
+    for id in plain {
+        assert_eq!(obj(&s, id).plain_text(), "a b");
+    }
+}
+
 #[test]
 fn split_at_the_cursor_and_around_a_selection() {
     for (anchor, caret, want) in [(6, 6, &["Split", "here please"][..]), (6, 10, &["Split", "here", "please"][..])] {
diff --git a/crates/engine/src/cmd/addons/cutting.rs b/crates/engine/src/cmd/addons/cutting.rs
index 2734ca10b3..37e9f2fa79 100644
--- a/crates/engine/src/cmd/addons/cutting.rs
+++ b/crates/engine/src/cmd/addons/cutting.rs
@@ -1,9 +1,10 @@
 //! Cutting Tools (`addon.cutting.*`), a built-in add-on that prepares art for cutting. Stencil
 //! Bridges cuts bridges out of the selected art so that a stencil cut from it holds together
 //! ([`stencil`]), and Weed Box and Lines adds a weed box and weeding lines around the selected art
-//! for vinyl cutting ([`weed`]). Its submenu (Object › Plug-ins › Cutting Tools) and dialogs are
-//! the UI's.
+//! for vinyl cutting ([`weed`]). Banner Hems and Grommets marks the hems and grommets of a banner
+//! ([`banner`]). Its submenu (Object › Plug-ins › Cutting Tools) and dialogs are the UI's.
 
+mod banner;
 mod stencil;
 mod weed;
 
@@ -12,5 +13,6 @@ use super::super::CommandSpec;
 pub fn specs() -> Vec<CommandSpec> {
     let mut v = stencil::specs();
     v.extend(weed::specs());
+    v.extend(banner::specs());
     v
 }
diff --git a/crates/engine/src/cmd/addons/cutting/banner.rs b/crates/engine/src/cmd/addons/cutting/banner.rs
new file mode 100644
index 0000000000..f4ae71ed54
--- /dev/null
+++ b/crates/engine/src/cmd/addons/cutting/banner.rs
@@ -0,0 +1,228 @@
+//! Banner Hems and Grommets (`addon.cutting.banner`), a command of the built-in Cutting Tools
+//! add-on for finishing a printed banner: on each chosen side of the banner it adds a hem line,
+//! where the edge is folded back and sewn (<https://en.wikipedia.org/wiki/Hem>), and grommet
+//! marks, where rings are set into the material to hang it
+//! (<https://en.wikipedia.org/wiki/Grommet>), spread evenly at most a set spacing apart. The
+//! banner is the selected art's bounds, or each artboard.
+
+#[cfg(test)]
+mod tests;
+
+use std::sync::Arc;
+
+use serde_json::{Value, json};
+use vectorcraft_color::Paint;
+use vectorcraft_color::swatch::REGISTRATION;
+use vectorcraft_doc::{Appearance, Node};
+use vectorcraft_geom::{Point, Rect, shapes};
+
+use super::super::super::edit::selected_roots;
+use super::super::super::paint::swatch_solid;
+use super::super::super::pathops::length_given;
+use super::super::super::{CommandSpec, bad, cmd, has_doc, switch_or, text_param};
+use super::weed::outside_clips;
+use crate::{Result, Session};
+
+/// Banner Hems and Grommets' command.
+pub const BANNER: &str = "addon.cutting.banner";
+/// The sides of a banner, in the order the grommets go round it.
+const SIDES: [&str; 4] = ["top", "right", "bottom", "left"];
+/// The largest hem, inset or spacing, in points.
+const MAX_DISTANCE: f64 = 100_000.0;
+/// The most grommets one run adds.
+const MAX_GROMMETS: usize = 100_000;
+/// Two grommet centers closer than this are one grommet (the corner that two sides share).
+const SAME: f64 = 1e-6;
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![cmd!(
+        "addon.cutting.banner",
+        "Banner Hems and Grommets…",
+        ["Object", "Plug-ins", "Cutting Tools"],
+        None,
+        "{hem?: pt 0..100000 (72: from each edge to its hem line; 0: no hem lines), grommets?: bool (true), spacing?: pt more than 0 and at most 100000 (1728: the most the grommets on a side are apart), grommetInset?: pt 0..100000 (36: from each edge to the grommets' centers), diameter?: pt 0.01..1000 (27: each grommet mark's circle), top?, right?, bottom?, left?: bool (true: the sides that get a hem and grommets), weight?: pt 0.01..1000 (0.3), swatch?: a color swatch the marks are stroked in (\"[Registration]\"), allArtboards?: bool (default: true when nothing is selected)} mark the hems and grommets of a banner, the selected art's bounds or each artboard: a hem line `hem` inside each chosen edge, running the edge's whole length, and grommet marks (a circle with a cross at its center) `grommetInset` inside each chosen edge, one at each end of the side and the rest spread evenly between them, as few as keep them at most `spacing` apart. One group named Banner Marks per banner, stroked with no fill, on top of the current layer, selected, as one undo step → {id: the first group, ids, hems (hem lines), grommets (grommet marks)}",
+        has_doc,
+        banner
+    )]
+}
+
+/// The distance `p` gives for `key` (0..[`MAX_DISTANCE`]), or `default`.
+fn distance(p: &Value, key: &str, default: f64) -> Result<f64> {
+    match length_given(p, key, BANNER)? {
+        None => Ok(default),
+        Some(v) if (0.0..=MAX_DISTANCE).contains(&v) => Ok(v),
+        Some(_) => Err(bad(BANNER, format!("`{key}` must be from 0 to {MAX_DISTANCE} pt"))),
+    }
+}
+
+/// The length `p` gives for `key` (0.01..1000), or `default`.
+fn size(p: &Value, key: &str, default: f64) -> Result<f64> {
+    match length_given(p, key, BANNER)? {
+        None => Ok(default),
+        Some(v) if (0.01..=1000.0).contains(&v) => Ok(v),
+        Some(_) => Err(bad(BANNER, format!("`{key}` must be from 0.01 to 1000 pt"))),
+    }
+}
+
+/// Which sides are on, in [`SIDES`] order.
+type Sides = [bool; 4];
+
+/// Whether marks `depth` inside a banner's near and far edges, `len` apart, fit: they stay inside
+/// the banner, and when both edges are chosen the two sets stay apart.
+fn fits(depth: f64, len: f64, near: bool, far: bool) -> bool {
+    match (near, far) {
+        (true, true) => 2.0 * depth < len,
+        (true, false) | (false, true) => depth < len,
+        (false, false) => true,
+    }
+}
+
+/// The hem lines of banner `r`: one `hem` inside each chosen edge, from one end of the edge to the
+/// other.
+fn hem_lines(r: Rect, hem: f64, sides: Sides) -> Vec<(Point, Point)> {
+    if hem <= 0.0 {
+        return vec![];
+    }
+    let lines = [
+        (Point::new(r.x0, r.y0 + hem), Point::new(r.x1, r.y0 + hem)),
+        (Point::new(r.x1 - hem, r.y0), Point::new(r.x1 - hem, r.y1)),
+        (Point::new(r.x0, r.y1 - hem), Point::new(r.x1, r.y1 - hem)),
+        (Point::new(r.x0 + hem, r.y0), Point::new(r.x0 + hem, r.y1)),
+    ];
+    lines.into_iter().zip(sides).filter(|(_, on)| *on).map(|(l, _)| l).collect()
+}
+
+/// The grommet centers of banner `r`: on each chosen side, `inset` inside the edge, one at each end
+/// (`inset` from the edges across it) and the rest spread evenly between them, as few as keep them
+/// at most `spacing` apart. They go round the banner clockwise from the top left; a corner that two
+/// chosen sides share has one grommet. `None` when there would be more than `limit`.
+fn grommet_centers(r: Rect, inset: f64, spacing: f64, sides: Sides, limit: usize) -> Option<Vec<Point>> {
+    let (l, t, rt, b) = (r.x0 + inset, r.y0 + inset, r.x1 - inset, r.y1 - inset);
+    // Each side from its start to its end, clockwise.
+    let runs = [
+        (Point::new(l, t), Point::new(rt, t)),
+        (Point::new(rt, t), Point::new(rt, b)),
+        (Point::new(rt, b), Point::new(l, b)),
+        (Point::new(l, b), Point::new(l, t)),
+    ];
+    let mut out: Vec<Point> = vec![];
+    for ((a, z), on) in runs.into_iter().zip(sides) {
+        if !on {
+            continue;
+        }
+        let gaps = ((z - a).hypot() / spacing - 1e-9).ceil().max(1.0);
+        if !gaps.is_finite() || gaps > limit as f64 {
+            return None;
+        }
+        let gaps = gaps as usize;
+        for i in 0..=gaps {
+            let p = a.lerp(z, i as f64 / gaps as f64);
+            // A side starts where the one before it ends, and the last one ends where the first
+            // starts.
+            let shared = |q: Option<&Point>| q.is_some_and(|q| (*q - p).hypot() < SAME);
+            if !shared(out.last()) && !shared(out.first()) {
+                out.push(p);
+            }
+            if out.len() > limit {
+                return None;
+            }
+        }
+    }
+    Some(out)
+}
+
+fn banner(s: &mut Session, p: &Value) -> Result<Value> {
+    let hem = distance(p, "hem", 72.0)?;
+    let inset = distance(p, "grommetInset", 36.0)?;
+    let spacing = match length_given(p, "spacing", BANNER)? {
+        None => 1728.0,
+        Some(v) if v > 0.0 && v <= MAX_DISTANCE => v,
+        Some(_) => return Err(bad(BANNER, format!("`spacing` must be more than 0 and at most {MAX_DISTANCE} pt"))),
+    };
+    let diameter = size(p, "diameter", 27.0)?;
+    let weight = size(p, "weight", 0.3)?;
+    let with_grommets = switch_or(p, "grommets", true, BANNER)?;
+    let mut sides = [true; 4];
+    for (on, key) in sides.iter_mut().zip(SIDES) {
+        *on = switch_or(p, key, true, BANNER)?;
+    }
+    if !sides.contains(&true) {
+        return Err(bad(BANNER, "turn on at least one side"));
+    }
+    if hem == 0.0 && !with_grommets {
+        return Err(bad(BANNER, "with no hem and no grommets there is nothing to mark"));
+    }
+    let swatch = text_param(p, "swatch", BANNER)?.unwrap_or(REGISTRATION);
+    let stroke = swatch_solid(&s.doc()?.doc, swatch, None).map_err(|e| bad(BANNER, e))?;
+    let all = switch_or(p, "allArtboards", s.doc()?.selection.is_empty(), BANNER)?;
+    let banners: Vec<Rect> = if all {
+        s.doc()?.doc.artboards.iter().map(|a| a.rect).collect()
+    } else {
+        let roots = selected_roots(s)?;
+        if roots.is_empty() {
+            return Err(bad(BANNER, "select the banner, or mark every artboard"));
+        }
+        s.doc()?.doc.bounds_of(&roots, false).into_iter().collect()
+    };
+    if banners.is_empty() {
+        return Err(bad(BANNER, "there is no banner to mark"));
+    }
+    let [top, right, bottom, left] = sides;
+    let mut marks = vec![];
+    let mut total = 0;
+    for r in &banners {
+        let (w, h) = (r.width(), r.height());
+        if !(w.is_finite() && h.is_finite()) || w <= 0.0 || h <= 0.0 {
+            return Err(bad(BANNER, "the banner has no width or height"));
+        }
+        // A hem line must stay inside the banner and apart from the hem line on the far side.
+        if hem > 0.0 && !(fits(hem, h, top, bottom) && fits(hem, w, left, right)) {
+            return Err(bad(BANNER, "the hem is too deep for the banner"));
+        }
+        let centers = if with_grommets {
+            // The grommets on a side run from `inset` past one end to `inset` before the other,
+            // stay inside the banner and stay apart from the grommets on the far side.
+            let runs_fit = (!(top || bottom) || 2.0 * inset <= w) && (!(left || right) || 2.0 * inset <= h);
+            if !(runs_fit && fits(inset, h, top, bottom) && fits(inset, w, left, right)) {
+                return Err(bad(BANNER, "the grommet inset is too large for the banner"));
+            }
+            grommet_centers(*r, inset, spacing, sides, MAX_GROMMETS - total)
+                .ok_or_else(|| bad(BANNER, format!("the spacing makes more than {MAX_GROMMETS} grommets")))?
+        } else {
+            vec![]
+        };
+        total += centers.len();
+        marks.push((hem_lines(*r, hem, sides), centers));
+    }
+    let parent = outside_clips(&s.doc()?.doc, s.doc()?.target_parent()?);
+    let ap = Appearance::basic(Paint::None, stroke, weight);
+    let half = diameter / 2.0;
+    let (ids, hems) = s.edit("Banner Hems and Grommets", |d, sel| {
+        let (mut ids, mut hems) = (vec![], 0);
+        for (lines, centers) in &marks {
+            let mut children = vec![];
+            for (a, b) in lines {
+                let mut n = Node::path(d.alloc_id(), shapes::line(*a, *b), ap.clone());
+                n.name = Some("Hem".into());
+                children.push(Arc::new(n));
+            }
+            hems += lines.len();
+            for c in centers {
+                let ring = Node::path(d.alloc_id(), shapes::ellipse(Rect::new(c.x - half, c.y - half, c.x + half, c.y + half)), ap.clone());
+                let across = Node::path(d.alloc_id(), shapes::line(Point::new(c.x - half, c.y), Point::new(c.x + half, c.y)), ap.clone());
+                let down = Node::path(d.alloc_id(), shapes::line(Point::new(c.x, c.y - half), Point::new(c.x, c.y + half)), ap.clone());
+                let mut g = Node::group(d.alloc_id(), vec![Arc::new(ring), Arc::new(across), Arc::new(down)]);
+                g.name = Some("Grommet".into());
+                children.push(Arc::new(g));
+            }
+            let mut g = Node::group(d.alloc_id(), children);
+            g.name = Some("Banner Marks".into());
+            ids.push(g.id);
+            d.insert(parent, usize::MAX, g)?;
+        }
+        sel.set(ids.iter().copied());
+        Ok((ids, hems))
+    })?;
+    let first = ids.first().map(|i| i.0);
+    Ok(json!({ "id": first, "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>(), "hems": hems, "grommets": total }))
+}
diff --git a/crates/engine/src/cmd/addons/cutting/banner/tests.rs b/crates/engine/src/cmd/addons/cutting/banner/tests.rs
new file mode 100644
index 0000000000..b186720b45
--- /dev/null
+++ b/crates/engine/src/cmd/addons/cutting/banner/tests.rs
@@ -0,0 +1,263 @@
+//! Tests for `addon.cutting.banner`: hem lines and grommet marks on the sides of a banner.
+
+use std::sync::Arc;
+
+use serde_json::{Value, json};
+use vectorcraft_color::Paint;
+use vectorcraft_doc::{Appearance, Node, NodeKind};
+use vectorcraft_geom::{Point, Rect, shapes};
+
+use super::{grommet_centers, hem_lines};
+use crate::*;
+
+fn session() -> Session {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
+    s
+}
+
+fn id_of(v: &Value) -> NodeId {
+    NodeId(v["id"].as_u64().unwrap())
+}
+
+fn rect(s: &mut Session, x: f64, y: f64, w: f64, h: f64) -> NodeId {
+    id_of(&s.execute("shape.rectangle", &json!({"x": x, "y": y, "width": w, "height": h})).unwrap())
+}
+
+fn node(s: &Session, id: NodeId) -> Node {
+    s.doc().unwrap().doc.node(id).cloned().unwrap()
+}
+
+/// Runs Banner Hems and Grommets with `p` and gives the first group it made.
+fn banner(s: &mut Session, p: Value) -> (Value, Node) {
+    let r = s.execute("addon.cutting.banner", &p).unwrap();
+    let g = node(s, id_of(&r));
+    (r, g)
+}
+
+fn round(p: Point) -> (f64, f64) {
+    let r = |v: f64| (v * 1000.0).round() / 1000.0;
+    (r(p.x), r(p.y))
+}
+
+/// The hem lines in group `g` as their two ends.
+fn hems(g: &Node) -> Vec<((f64, f64), (f64, f64))> {
+    g.children()
+        .unwrap()
+        .iter()
+        .filter(|c| c.name.as_deref() == Some("Hem"))
+        .map(|c| match &c.kind {
+            NodeKind::Path { path, .. } => {
+                let a: Vec<Point> = path.anchors().map(|(_, _, a)| a.p).collect();
+                assert_eq!(a.len(), 2, "a hem line is one straight segment");
+                (round(a[0]), round(a[1]))
+            }
+            other => panic!("not a path: {other:?}"),
+        })
+        .collect()
+}
+
+/// The grommet marks in group `g` as their centers.
+fn grommets(g: &Node) -> Vec<(f64, f64)> {
+    g.children().unwrap().iter().filter(|c| c.name.as_deref() == Some("Grommet")).map(|c| round(c.geometric_bounds().unwrap().center())).collect()
+}
+
+#[test]
+fn hems_and_grommets_go_round_a_selected_banner() {
+    let mut s = session();
+    rect(&mut s, 0.0, 0.0, 400.0, 200.0);
+    let undo = s.doc().unwrap().history.undo.len();
+    let (r, g) = banner(&mut s, json!({"hem": 20, "grommetInset": 10, "spacing": 150, "diameter": 8}));
+    assert_eq!(g.name.as_deref(), Some("Banner Marks"));
+    assert_eq!(
+        hems(&g),
+        vec![((0.0, 20.0), (400.0, 20.0)), ((380.0, 0.0), (380.0, 200.0)), ((0.0, 180.0), (400.0, 180.0)), ((20.0, 0.0), (20.0, 200.0))]
+    );
+    // 380 pt along the top and bottom need 3 gaps at most 150 apart, 180 down the sides 2; the
+    // corners are shared.
+    assert_eq!(
+        grommets(&g),
+        vec![
+            (10.0, 10.0),
+            (136.667, 10.0),
+            (263.333, 10.0),
+            (390.0, 10.0),
+            (390.0, 100.0),
+            (390.0, 190.0),
+            (263.333, 190.0),
+            (136.667, 190.0),
+            (10.0, 190.0),
+            (10.0, 100.0)
+        ]
+    );
+    assert_eq!(r["hems"], 4);
+    assert_eq!(r["grommets"], 10);
+    assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1, "one undo step");
+    assert_eq!(s.doc().unwrap().selection.objects, [g.id]);
+}
+
+#[test]
+fn a_grommet_is_a_circle_with_a_cross_stroked_in_registration() {
+    let mut s = session();
+    rect(&mut s, 0.0, 0.0, 100.0, 100.0);
+    let (_, g) = banner(&mut s, json!({"hem": 0, "grommetInset": 10, "diameter": 6, "weight": 0.5}));
+    let first = g.children().unwrap().iter().find(|c| c.name.as_deref() == Some("Grommet")).cloned().unwrap();
+    assert_eq!(first.geometric_bounds(), Some(Rect::new(7.0, 7.0, 13.0, 13.0)));
+    let parts = first.children().unwrap();
+    assert_eq!(parts.len(), 3, "a circle and two lines");
+    for c in parts.iter() {
+        assert!(matches!(c.kind, NodeKind::Path { .. }), "a path");
+        assert_eq!(c.appearance.fill_paint(), Paint::None);
+        assert!(c.appearance.stroke_paint().is_registration());
+        assert_eq!(c.appearance.stroke_width(), 0.5);
+    }
+}
+
+#[test]
+fn every_artboard_is_marked_when_nothing_is_selected() {
+    let mut s = session();
+    s.execute("artboard.new", &json!({"x": 900, "y": 0, "width": 200, "height": 150})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    let r = s.execute("addon.cutting.banner", &json!({"grommets": false})).unwrap();
+    let ids: Vec<NodeId> = r["ids"].as_array().unwrap().iter().map(|v| NodeId(v.as_u64().unwrap())).collect();
+    assert_eq!(ids.len(), 2);
+    let second = node(&s, ids[1]);
+    assert_eq!(hems(&second)[0], ((900.0, 72.0), (1100.0, 72.0)), "the default hem is 72 pt");
+    assert!(grommets(&second).is_empty());
+    assert_eq!(r["grommets"], 0);
+}
+
+#[test]
+fn only_the_chosen_sides_are_marked() {
+    let mut s = session();
+    rect(&mut s, 0.0, 0.0, 300.0, 100.0);
+    let (_, g) = banner(&mut s, json!({"hem": 10, "grommetInset": 5, "spacing": 1000, "right": false, "bottom": false, "left": false}));
+    assert_eq!(hems(&g), vec![((0.0, 10.0), (300.0, 10.0))]);
+    assert_eq!(grommets(&g), vec![(5.0, 5.0), (295.0, 5.0)]);
+}
+
+#[test]
+fn units_are_read_and_bad_params_are_refused() {
+    let mut s = session();
+    rect(&mut s, 0.0, 0.0, 400.0, 400.0);
+    let (_, g) = banner(&mut s, json!({"hem": "1 in", "grommetInset": "0.5 in", "spacing": "10 in"}));
+    assert_eq!(hems(&g)[0], ((0.0, 72.0), (400.0, 72.0)));
+    assert_eq!(grommets(&g)[0], (36.0, 36.0));
+    let before = s.doc().unwrap().history.undo.len();
+    for p in [
+        json!({"hem": -1}),
+        json!({"hem": "x"}),
+        json!({"spacing": 0}),
+        json!({"diameter": 0}),
+        json!({"weight": 1e9}),
+        json!({"top": "yes"}),
+        json!({"top": false, "right": false, "bottom": false, "left": false}),
+        json!({"hem": 0, "grommets": false}),
+        json!({"hem": 250}),
+        json!({"grommetInset": 250}),
+        json!({"spacing": 0.001}),
+        json!({"swatch": "no such swatch"}),
+    ] {
+        assert!(s.execute("addon.cutting.banner", &p).is_err(), "{p} is refused");
+    }
+    assert_eq!(s.doc().unwrap().history.undo.len(), before, "a refused run changes nothing");
+}
+
+#[test]
+fn hems_and_grommets_on_one_side_may_go_past_the_middle() {
+    let mut s = session();
+    rect(&mut s, 0.0, 0.0, 300.0, 100.0);
+    let one = json!({"right": false, "bottom": false, "left": false, "spacing": 1000});
+    let with = |extra: Value| {
+        let mut p = one.clone();
+        p.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
+        p
+    };
+    let (_, g) = banner(&mut s, with(json!({"hem": 60, "grommetInset": 70})));
+    assert_eq!(hems(&g), vec![((0.0, 60.0), (300.0, 60.0))]);
+    assert_eq!(grommets(&g), vec![(70.0, 70.0), (230.0, 70.0)]);
+    for p in [with(json!({"hem": 100})), with(json!({"hem": 0, "grommetInset": 100})), with(json!({"grommetInset": 151}))] {
+        assert!(s.execute("addon.cutting.banner", &p).is_err(), "{p} reaches the far edge or past the ends");
+    }
+    // A grommet inset of half the width puts the grommets of a side on one point: one grommet.
+    let mut s = session();
+    rect(&mut s, 0.0, 0.0, 100.0, 300.0);
+    let (_, g) = banner(&mut s, with(json!({"hem": 0, "grommetInset": 50, "spacing": 10})));
+    assert_eq!(grommets(&g), vec![(50.0, 50.0)]);
+}
+
+#[test]
+fn hems_and_grommets_on_opposite_sides_stay_apart() {
+    let mut s = session();
+    rect(&mut s, 0.0, 0.0, 300.0, 100.0);
+    let pair = |p: Value| {
+        let mut q = json!({"right": false, "left": false, "spacing": 1000});
+        q.as_object_mut().unwrap().extend(p.as_object().unwrap().clone());
+        q
+    };
+    // Half the height would put the top and bottom marks on the same line.
+    let refused = [
+        pair(json!({"hem": 50})),
+        pair(json!({"hem": 0, "grommetInset": 50})),
+        json!({"hem": 0, "grommetInset": 150, "top": false, "bottom": false}),
+    ];
+    for p in refused {
+        assert!(s.execute("addon.cutting.banner", &p).is_err(), "{p} is refused");
+    }
+    let (_, g) = banner(&mut s, pair(json!({"hem": 49.5, "grommetInset": 49.5})));
+    assert_eq!(hems(&g), vec![((0.0, 49.5), (300.0, 49.5)), ((0.0, 50.5), (300.0, 50.5))]);
+    assert_eq!(grommets(&g), vec![(49.5, 49.5), (250.5, 49.5), (250.5, 50.5), (49.5, 50.5)]);
+}
+
+#[test]
+fn the_marks_go_outside_a_clip_group_edited_in_isolation() {
+    let mut s = session();
+    let parent = s.doc().unwrap().target_parent().unwrap();
+    let (g, art) = s
+        .edit("clip group", |d, _| {
+            let clip = Arc::new(Node::path(d.alloc_id(), shapes::rectangle(Rect::new(100.0, 100.0, 150.0, 140.0)), Appearance::default()));
+            let art = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(0.0, 0.0, 400.0, 200.0)), Appearance::default());
+            let art_id = art.id;
+            let mut g = Node::group(d.alloc_id(), vec![clip, Arc::new(art)]);
+            if let NodeKind::Group { clip, .. } = &mut g.kind {
+                *clip = true;
+            }
+            let id = g.id;
+            d.insert(parent, usize::MAX, g)?;
+            Ok((id, art_id))
+        })
+        .unwrap();
+    s.execute("object.isolate", &json!({"id": g.0})).unwrap();
+    s.execute("select.set", &json!({"ids": [art.0]})).unwrap();
+    let (_, marks) = banner(&mut s, json!({"hem": 20, "grommets": false}));
+    // The clipping path would hide marks inside the clip group.
+    assert_eq!(s.doc().unwrap().doc.parent_of(marks.id), parent);
+    assert_eq!(hems(&marks)[0], ((0.0, 20.0), (400.0, 20.0)), "the selected art is the banner");
+}
+
+#[test]
+fn all_artboards_marks_the_artboards_even_with_a_selection() {
+    let mut s = session();
+    rect(&mut s, 10.0, 10.0, 100.0, 100.0);
+    let (_, g) = banner(&mut s, json!({"allArtboards": true, "grommets": false}));
+    assert_eq!(hems(&g)[0], ((0.0, 72.0), (800.0, 72.0)));
+}
+
+#[test]
+fn an_empty_document_has_no_banner_to_mark_when_artboards_are_off() {
+    let mut s = session();
+    assert!(s.execute("addon.cutting.banner", &json!({"allArtboards": false})).is_err());
+}
+
+#[test]
+fn a_side_shorter_than_the_spacing_has_a_grommet_at_each_end() {
+    let r = Rect::new(0.0, 0.0, 100.0, 50.0);
+    let c = grommet_centers(r, 0.0, 1000.0, [true, false, false, false], 10).unwrap();
+    assert_eq!(c, vec![Point::new(0.0, 0.0), Point::new(100.0, 0.0)]);
+    // Spacing that divides the side exactly does not add a grommet, even when the division
+    // rounds up (2.1 / 0.3 is 7.000000000000001).
+    let c = grommet_centers(Rect::new(0.0, 0.0, 2.1, 1.0), 0.0, 0.3, [true, false, false, false], 100).unwrap();
+    assert_eq!(c.len(), 8);
+    assert!(grommet_centers(r, 0.0, 1.0, [true; 4], 10).is_none(), "over the limit");
+    assert!(hem_lines(r, 0.0, [true; 4]).is_empty());
+}
diff --git a/crates/engine/src/cmd/addons/cutting/weed.rs b/crates/engine/src/cmd/addons/cutting/weed.rs
index 8a6375a595..183a66ad57 100644
--- a/crates/engine/src/cmd/addons/cutting/weed.rs
+++ b/crates/engine/src/cmd/addons/cutting/weed.rs
@@ -72,7 +72,7 @@ fn lines_across(length: f64, count: Option<usize>, spacing: Option<f64>) -> Resu
 /// Where the Weeding group goes: `parent`, or, when `parent` is inside a clip group or clipping
 /// sublayer (a group edited in isolation), the container around the outermost of them. A clipping
 /// path would hide the lines and the box, which lie outside the art.
-fn outside_clips(d: &Document, parent: Option<NodeId>) -> Option<NodeId> {
+pub(super) fn outside_clips(d: &Document, parent: Option<NodeId>) -> Option<NodeId> {
     let clips = |id: NodeId| d.node(id).is_some_and(|n| matches!(n.kind, NodeKind::Group { clip: true, .. } | NodeKind::Layer { clip: true, .. }));
     let (mut at, mut out) = (parent, parent);
     while let Some(p) = at {
diff --git a/crates/engine/src/cmd/addons/pathtools.rs b/crates/engine/src/cmd/addons/pathtools.rs
index 9ddcc43559..8a271557a9 100644
--- a/crates/engine/src/cmd/addons/pathtools.rs
+++ b/crates/engine/src/cmd/addons/pathtools.rs
@@ -2,8 +2,8 @@
 //! the Extend Path tool's extension, the Measure & Inspect tool's readouts, the Anchor Inspector's
 //! anchor edits, Split / Add Points at Crossings, Slide Anchor Along Path, the Corner Tool's corners
 //! ([`corners`]), the Parametric Shape Tool's shapes ([`shape`]), the Shared Edge Merge Tool's
-//! merges with Keep Shared Points Together ([`shared_edge`]), Divide into Dashes and Expand Dashes
-//! into Paths.
+//! merges with Keep Shared Points Together ([`shared_edge`]), Divide into Dashes, Expand Dashes
+//! into Paths and Trim at Crossings ([`trim`]).
 //! Its tools, panels and submenu (Object › Plug-ins › Path Precision Tools) are the tools crate's
 //! and the UI's.
 
@@ -14,6 +14,7 @@ mod shape;
 mod shared_edge;
 #[cfg(test)]
 mod tests;
+mod trim;
 
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -143,7 +144,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Add Points at Crossings",
             ["Object", "Plug-ins", "Path Precision Tools"],
             None,
-            "{cut?: bool (false: add anchors where the paths cross; true: also cut them there), selfCrossings?: bool (false: where a path crosses itself too), ids?: [id…] (default: the selection)} where the paths under the objects cross one another, as one undo step; at most 10000 segments → {ids, crossings (anchors placed)}",
+            "{cut?: bool (false: add anchors where the paths cross; true: also cut them there), selfCrossings?: bool (false: where a path crosses itself too, a curved segment that loops over itself included), ids?: [id…] (default: the selection)} where the paths under the objects cross one another, as one undo step; at most 10000 segments → {ids, crossings (anchors placed)}",
             has_selection,
             crossings
         ),
@@ -178,6 +179,7 @@ pub fn specs() -> Vec<CommandSpec> {
     v.extend(shape::specs());
     v.extend(corners::specs());
     v.extend(shared_edge::specs());
+    v.extend(trim::specs());
     v
 }
 
@@ -609,7 +611,7 @@ fn remove_keep_shape(s: &mut Session, _: &Value) -> Result<Value> {
 fn picked_segments(segments: Option<&BTreeSet<(usize, usize)>>, si: usize, sp: &SubPath, anchors: &BTreeSet<usize>) -> BTreeSet<usize> {
     let n = sp.anchors.len().max(1);
     match segments.filter(|set| !set.is_empty()) {
-        Some(set) => set.iter().filter(|(s, _)| *s == si).map(|(_, k)| *k).collect(),
+        Some(set) => super::super::path::subpath_refs(set, si).collect(),
         None => (0..sp.segment_count()).filter(|k| anchors.contains(k) && anchors.contains(&((k + 1) % n))).collect(),
     }
 }
@@ -681,6 +683,18 @@ pub(super) fn close(s: &mut Session, p: &Value) -> Result<Value> {
 
 // ---------- Split / Add Points at Crossings ----------
 
+/// The crossing places `on` of one path, as `(segment, t)` for each of its `subpaths` subpaths in
+/// the order they come in `on`. A place on a subpath past the last is left out.
+fn places_by_subpath(on: &[(usize, usize, f64)], subpaths: usize) -> Vec<Vec<(usize, f64)>> {
+    let mut by_sub = vec![vec![]; subpaths];
+    for &(si, seg, t) in on {
+        if let Some(here) = by_sub.get_mut(si) {
+            here.push((seg, t));
+        }
+    }
+    by_sub
+}
+
 fn crossings(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "addon.pathtools.crossings";
     let (cut, self_crossings) = (switch_or(p, "cut", false, C)?, switch_or(p, "selfCrossings", false, C)?);
@@ -702,8 +716,7 @@ fn crossings(s: &mut Session, p: &Value) -> Result<Value> {
         }
         let mut subs = vec![];
         let mut marks = vec![];
-        for (si, sp) in path.subpaths.iter().enumerate() {
-            let here: Vec<(usize, f64)> = on.iter().filter(|(s, ..)| *s == si).map(|&(_, seg, t)| (seg, t)).collect();
+        for (sp, here) in path.subpaths.iter().zip(places_by_subpath(&on, path.subpaths.len())) {
             let (out, m) = pt::insert_at(sp, &here);
             count += m.len();
             subs.push(out);
diff --git a/crates/engine/src/cmd/addons/pathtools/tests.rs b/crates/engine/src/cmd/addons/pathtools/tests.rs
index e31aadf56e..f98880e204 100644
--- a/crates/engine/src/cmd/addons/pathtools/tests.rs
+++ b/crates/engine/src/cmd/addons/pathtools/tests.rs
@@ -6,7 +6,7 @@ use std::collections::BTreeSet;
 use serde_json::{Value, json};
 use vectorcraft_doc::{LiveCorners, LiveShape, NodeId};
 use vectorcraft_geom::shapes::CornerKind;
-use vectorcraft_geom::{AnchorKind, PathData, Point};
+use vectorcraft_geom::{AnchorKind, PathData, Point, SubPath};
 use vectorcraft_tools::{PointerEvent, PointerKind};
 
 use crate::{Session, ViewInfo};
@@ -275,6 +275,152 @@ fn crossings_add_anchors_or_cut_in_one_step() {
     refuses(&mut s, "addon.pathtools.crossings", &[json!({"cut": "yes"}), json!({"ids": [123456]})]);
 }
 
+/// A selected path with an open polyline subpath through each of `subs`; an empty list makes an
+/// empty subpath.
+fn compound(s: &mut Session, subs: &[&[(f64, f64)]]) -> NodeId {
+    let id = line(s, &[(0.0, 0.0), (1.0, 0.0)], false);
+    let pd =
+        PathData::new(subs.iter().map(|pts| SubPath::polyline(&pts.iter().map(|&(x, y)| Point::new(x, y)).collect::<Vec<_>>(), false)).collect());
+    s.edit("Test", |d, _| {
+        super::set_path(d, id, pd);
+        Ok(())
+    })
+    .unwrap();
+    select(s, &[id]);
+    id
+}
+
+/// The anchor points of each subpath of `pd`, rounded to a millionth.
+fn points(pd: &PathData) -> Vec<Vec<(f64, f64)>> {
+    let r = |v: f64| (v * 1e6).round() / 1e6;
+    pd.subpaths.iter().map(|sp| sp.anchors.iter().map(|a| (r(a.p.x), r(a.p.y))).collect()).collect()
+}
+
+/// A path's subpaths: A (0), an empty one (1), C (2) and D (3, the last).
+const SUBS: [&[(f64, f64)]; 4] =
+    [&[(0.0, 0.0), (100.0, 0.0), (200.0, 0.0)], &[], &[(0.0, 50.0), (100.0, 50.0)], &[(0.0, 100.0), (100.0, 100.0), (200.0, 100.0)]];
+
+/// Direct-select `segments` of `id` and the anchors `anchors`.
+fn select_segments(s: &mut Session, id: NodeId, anchors: &[(usize, usize)], segments: &[(usize, usize)]) {
+    s.select(|_, sel| {
+        sel.set([id]);
+        sel.anchors.insert(id, anchors.iter().copied().collect());
+        sel.segments.insert(id, segments.iter().copied().collect());
+    })
+    .unwrap();
+}
+
+#[test]
+fn picked_segments_reads_only_its_own_subpath() {
+    let set: BTreeSet<(usize, usize)> = [(0, 0), (0, 2), (1, 1), (3, 0), (3, 1)].into();
+    let sp = SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(1.0, 0.0), Point::new(2.0, 0.0), Point::new(3.0, 0.0)], false);
+    let all: BTreeSet<usize> = (0..4).collect();
+    let picked = |si| super::picked_segments(Some(&set), si, &sp, &all).into_iter().collect::<Vec<_>>();
+    assert_eq!([picked(0), picked(1), picked(2), picked(3), picked(4)], [vec![0, 2], vec![1], vec![], vec![0, 1], vec![]]);
+    // Without direct-selected segments, the segments between two selected anchors.
+    let anchors: BTreeSet<usize> = [0, 1, 3].into();
+    for none in [None, Some(&BTreeSet::new())] {
+        assert_eq!(super::picked_segments(none, 0, &sp, &anchors).into_iter().collect::<Vec<_>>(), [0]);
+    }
+}
+
+#[test]
+fn places_by_subpath_keeps_the_order_and_leaves_out_missing_subpaths() {
+    let on = [(3, 1, 0.75), (0, 0, 0.5), (3, 1, 0.25), (7, 0, 0.5), (0, 1, 0.1), (3, 0, 0.5), (0, 0, 0.2)];
+    let by_sub = super::places_by_subpath(&on, 4);
+    assert_eq!(by_sub, [vec![(0, 0.5), (1, 0.1), (0, 0.2)], vec![], vec![], vec![(1, 0.75), (1, 0.25), (0, 0.5)]]);
+    // The same places as filtering the whole list for each subpath.
+    for (si, here) in by_sub.iter().enumerate() {
+        let filtered: Vec<(usize, f64)> = on.iter().filter(|(s, ..)| *s == si).map(|&(_, seg, t)| (seg, t)).collect();
+        assert_eq!(*here, filtered);
+    }
+    assert!(super::places_by_subpath(&on, 0).is_empty());
+}
+
+#[test]
+fn add_points_adds_to_the_selected_segments_of_each_subpath() {
+    let mut s = session();
+    let c = compound(&mut s, &SUBS);
+    let before = path(&s, c);
+    // The first segment of A and the second of D; a segment of C without its anchors selected.
+    select_segments(&mut s, c, &[(0, 0), (0, 1), (0, 2), (3, 0), (3, 1), (3, 2)], &[(0, 0), (2, 0), (3, 1)]);
+    let n = steps(&s);
+    assert_eq!(s.execute("addon.pathtools.addPoints", &json!({})).unwrap()["added"], json!(2));
+    let want = vec![
+        vec![(0.0, 0.0), (50.0, 0.0), (100.0, 0.0), (200.0, 0.0)],
+        vec![],
+        vec![(0.0, 50.0), (100.0, 50.0)],
+        vec![(0.0, 100.0), (100.0, 100.0), (150.0, 100.0), (200.0, 100.0)],
+    ];
+    let after = path(&s, c);
+    assert_eq!(points(&after), want);
+    assert_eq!(steps(&s), n + 1);
+    let st = s.doc().unwrap();
+    assert_eq!((st.selection.objects.clone(), st.selection.anchors.get(&c), st.selection.segments.get(&c)), (vec![c], None, None));
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(path(&s, c), before);
+    s.execute("edit.redo", &json!({})).unwrap();
+    assert_eq!(path(&s, c), after);
+    // Without selected segments: those between two selected anchors, here on the last subpath only.
+    for segments in [None, Some(BTreeSet::new())] {
+        s.execute("edit.undo", &json!({})).unwrap();
+        s.select(|_, sel| {
+            sel.set([c]);
+            sel.anchors.insert(c, [(0, 0), (3, 1), (3, 2)].into());
+            sel.segments.remove(&c);
+            if let Some(set) = segments.clone() {
+                sel.segments.insert(c, set);
+            }
+        })
+        .unwrap();
+        assert_eq!(s.execute("addon.pathtools.addPoints", &json!({})).unwrap()["added"], json!(1));
+        assert_eq!(
+            points(&path(&s, c)),
+            [points(&before)[..3].to_vec(), vec![vec![(0.0, 100.0), (100.0, 100.0), (150.0, 100.0), (200.0, 100.0)]]].concat()
+        );
+    }
+}
+
+#[test]
+fn crossings_add_anchors_on_each_subpath_of_a_compound_path() {
+    let mut s = session();
+    // A and the last subpath cross both lines; the empty subpath and C, which ends short of them, do not.
+    let c = compound(&mut s, &[&[(0.0, 50.0), (200.0, 50.0)], &[], &[(0.0, 150.0), (40.0, 150.0)], &[(0.0, 250.0), (400.0, 250.0)]]);
+    let q = line(&mut s, &[(100.0, 0.0), (100.0, 300.0)], false);
+    let r = line(&mut s, &[(150.0, 0.0), (150.0, 300.0)], false);
+    select(&mut s, &[c, q, r]);
+    let n = steps(&s);
+    assert_eq!(s.execute("addon.pathtools.crossings", &json!({})).unwrap()["crossings"], json!(8));
+    let want = vec![
+        vec![(0.0, 50.0), (100.0, 50.0), (150.0, 50.0), (200.0, 50.0)],
+        vec![],
+        vec![(0.0, 150.0), (40.0, 150.0)],
+        vec![(0.0, 250.0), (100.0, 250.0), (150.0, 250.0), (400.0, 250.0)],
+    ];
+    assert_eq!(points(&path(&s, c)), want);
+    assert_eq!(points(&path(&s, q)), [vec![(100.0, 0.0), (100.0, 50.0), (100.0, 250.0), (100.0, 300.0)]]);
+    assert_eq!(steps(&s), n + 1);
+    s.execute("edit.undo", &json!({})).unwrap();
+    // Cut: the compound path keeps its pieces as subpaths, in order; each line becomes three paths.
+    let out = ids(&s.execute("addon.pathtools.crossings", &json!({"cut": true})).unwrap());
+    assert_eq!(out.len(), 7);
+    assert_eq!(out[0], c);
+    let pieces = vec![
+        vec![(0.0, 50.0), (100.0, 50.0)],
+        vec![(100.0, 50.0), (150.0, 50.0)],
+        vec![(150.0, 50.0), (200.0, 50.0)],
+        vec![],
+        vec![(0.0, 150.0), (40.0, 150.0)],
+        vec![(0.0, 250.0), (100.0, 250.0)],
+        vec![(100.0, 250.0), (150.0, 250.0)],
+        vec![(150.0, 250.0), (400.0, 250.0)],
+    ];
+    assert_eq!(points(&path(&s, c)), pieces);
+    let qs: Vec<Vec<Vec<(f64, f64)>>> = out[1..4].iter().map(|id| points(&path(&s, *id))).collect();
+    assert_eq!(qs, [[vec![(100.0, 0.0), (100.0, 50.0)]], [vec![(100.0, 50.0), (100.0, 250.0)]], [vec![(100.0, 250.0), (100.0, 300.0)]]]);
+    assert_eq!(steps(&s), n + 1);
+}
+
 // ---------- Parametric Shape Tool ----------
 
 /// The parametric shape object `id` is now, as the tool reads it.
@@ -887,6 +1033,35 @@ fn divide_into_dashes_divides_only_the_selected_segments() {
     assert_eq!(layer, pieces, "in the path's place, in order");
 }
 
+#[test]
+fn divide_into_dashes_divides_the_selected_segments_of_each_subpath() {
+    let mut s = session();
+    let c = compound(&mut s, &SUBS);
+    let before = path(&s, c);
+    // The first segment of A and the second of D; a segment of C without its anchors selected.
+    select_segments(&mut s, c, &[(0, 0), (0, 1), (0, 2), (3, 0), (3, 1), (3, 2)], &[(0, 0), (2, 0), (3, 1)]);
+    let n = steps(&s);
+    let r = s.execute("addon.pathtools.divideDashes", &json!({"dash": 25})).unwrap();
+    assert_eq!(steps(&s), n + 1);
+    assert_eq!(r["dashes"], json!(8));
+    let made: Vec<Vec<Vec<(f64, f64)>>> = ids(&r).iter().map(|id| points(&path(&s, *id))).collect();
+    let piece = |x0: f64, x1: f64, y: f64| vec![vec![(x0, y), (x1, y)]];
+    let mut want = vec![vec![vec![], vec![(0.0, 50.0), (100.0, 50.0)]]];
+    want.extend([(0.0, 25.0), (25.0, 50.0), (50.0, 75.0), (75.0, 100.0)].map(|(a, b)| piece(a, b, 0.0)));
+    want.push(vec![vec![(100.0, 0.0), (200.0, 0.0)]]);
+    want.push(vec![vec![(0.0, 100.0), (100.0, 100.0)]]);
+    want.extend([(100.0, 125.0), (125.0, 150.0), (150.0, 175.0), (175.0, 200.0)].map(|(a, b)| piece(a, b, 100.0)));
+    assert_eq!(made, want, "what stays of the path, then each subpath's pieces in order");
+    assert_eq!(s.doc().unwrap().selection.objects, ids(&r));
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(path(&s, c), before);
+    // With no segments selected: those between two selected anchors, here on the last subpath only.
+    select_segments(&mut s, c, &[(0, 0), (3, 1), (3, 2)], &[]);
+    let r = s.execute("addon.pathtools.divideDashes", &json!({"dash": 25})).unwrap();
+    assert_eq!((ids(&r).len(), r["dashes"].clone()), (6, json!(4)));
+    assert_eq!(points(&path(&s, ids(&r)[0])), points(&before)[..3]);
+}
+
 #[test]
 fn divide_into_dashes_refuses_bad_params_and_too_many_pieces() {
     let mut s = session();
diff --git a/crates/engine/src/cmd/addons/pathtools/trim.rs b/crates/engine/src/cmd/addons/pathtools/trim.rs
new file mode 100644
index 0000000000..134edc6607
--- /dev/null
+++ b/crates/engine/src/cmd/addons/pathtools/trim.rs
@@ -0,0 +1,321 @@
+//! Trim at Crossings: remove the stretch of a path between the places where other paths, or the
+//! path itself, cross it. The command takes the stretch at a point, every stretch a rectangle
+//! touches, or every stretch a line through some points crosses. It works on every path that can
+//! be edited, selected or not.
+
+use std::collections::HashSet;
+
+use serde_json::{Value, json};
+use vectorcraft_doc::{Document, NodeId, NodeKind};
+use vectorcraft_geom::kurbo::{Line, PathSeg};
+use vectorcraft_geom::{PathData, Point, Rect, SubPath, hit};
+use vectorcraft_pathops::addons::pathtools as pt;
+
+use super::super::super::draw2::replace_with_pieces;
+use super::super::super::pathops::Beside;
+use super::super::super::{CommandSpec, bad, cmd, finite_numbers, has_doc, number_or};
+use crate::{Result, Session};
+
+#[cfg(test)]
+mod tests;
+
+/// The undo step's name.
+const LABEL: &str = "Trim at Crossings";
+/// How near `at` a path counts as under it by default (pt), and the most.
+const TOLERANCE: f64 = 3.0;
+const MAX_TOLERANCE: f64 = 100.0;
+/// Most points of `points`.
+const MAX_POINTS: usize = 100_000;
+/// The farthest coordinate the command takes.
+const MAX_COORD: f64 = 1e7;
+
+pub(super) fn specs() -> Vec<CommandSpec> {
+    vec![cmd!(
+        "addon.pathtools.trim",
+        "Trim at Crossings",
+        [],
+        None,
+        "{at: [x, y], tolerance?: pt 0..100 (3; how near `at` a path counts as under it)} or {rect: [x, y, width, height]} or {points: [[x, y]…] (2 to 100000 points)} remove stretches of paths, a stretch running between two neighboring places where the path is crossed by another path or by itself, or from such a place to an open end: `at` removes the stretch of the nearest path at that point, `rect` every stretch the rectangle touches, `points` every stretch the line through the points crosses. Give exactly one of the three. Every path that can be edited takes part, selected or not, compound path members included; hidden and locked paths, guides and clipping paths (compound ones' members included) are neither trimmed nor counted as crossing; in isolation mode only paths inside the isolated object are trimmed. A path that ends on another marks a place on the other; paths that lie along each other don't cross. A closed path that loses a stretch becomes open, an open path that loses a middle stretch becomes two paths with its appearance in its place in the stacking order, and a path nothing crosses is removed whole; a live shape becomes a plain path. One undo step, none when nothing is removed → {ids (the paths left of those trimmed), removed (stretches)}",
+        has_doc,
+        trim
+    )]
+}
+
+/// What picks the stretches to remove.
+enum Pick {
+    /// The stretch of the nearest path within the tolerance of the point.
+    At(Point, f64),
+    /// Every stretch the rectangle touches.
+    Rect(Rect),
+    /// Every stretch the line through the points crosses.
+    Line(Vec<Point>, Rect),
+}
+
+fn pick(p: &Value) -> Result<Pick> {
+    const C: &str = "addon.pathtools.trim";
+    let given = |key: &str| p.get(key).filter(|v| !v.is_null());
+    let within = |v: &[f64]| v.iter().all(|x| x.abs() <= MAX_COORD);
+    match (given("at"), given("rect"), given("points")) {
+        (Some(at), None, None) => {
+            let [x, y] = finite_numbers(at).filter(|v| within(v)).ok_or_else(|| bad(C, "`at` must be a point [x, y]"))?;
+            let tolerance = number_or(p, "tolerance", TOLERANCE, C)?;
+            if !(0.0..=MAX_TOLERANCE).contains(&tolerance) {
+                return Err(bad(C, "`tolerance` must be from 0 to 100 pt"));
+            }
+            Ok(Pick::At(Point::new(x, y), tolerance))
+        }
+        (None, Some(rect), None) => {
+            let [x, y, w, h] = finite_numbers(rect).filter(|v| within(v)).ok_or_else(|| bad(C, "`rect` must be [x, y, width, height]"))?;
+            Ok(Pick::Rect(Rect::new(x, y, x + w, y + h).abs()))
+        }
+        (None, None, Some(points)) => {
+            let list = points.as_array().ok_or_else(|| bad(C, "`points` must be a list of [x, y] points"))?;
+            if !(2..=MAX_POINTS).contains(&list.len()) {
+                return Err(bad(C, "`points` must hold from 2 to 100000 points"));
+            }
+            let pts = list
+                .iter()
+                .map(|v| {
+                    finite_numbers(v)
+                        .filter(|xy| within(xy))
+                        .map(|[x, y]| Point::new(x, y))
+                        .ok_or_else(|| bad(C, format!("bad point {v}: expected [x, y]")))
+                })
+                .collect::<Result<Vec<Point>>>()?;
+            let bounds = pts.iter().fold(None, |r: Option<Rect>, q| Some(r.map_or(Rect::from_points(*q, *q), |r| r.union_pt(*q))));
+            Ok(Pick::Line(pts, bounds.unwrap_or_default()))
+        }
+        _ => Err(bad(C, "give exactly one of `at`, `rect` and `points`")),
+    }
+}
+
+/// A path that takes part: its id, geometry and control-point box.
+type Part<'a> = (NodeId, &'a PathData, Rect);
+
+/// The paths that take part, bottom to top: the ones that can be edited, without guides and
+/// clipping paths. The clipping path of a clip group or a clipped layer is left out whole, the
+/// members of a compound clipping path included.
+fn parts(d: &Document) -> Vec<Part<'_>> {
+    let editable = d.editable();
+    let mut masks = HashSet::new();
+    d.walk(|n| {
+        if n.clips()
+            && let Some(first) = n.children().and_then(|c| c.first())
+        {
+            first.walk(&mut |m| {
+                masks.insert(m.id);
+            });
+        }
+    });
+    let mut out = vec![];
+    d.walk(|n| {
+        if let NodeKind::Path { path, guide: false, clipping: false, .. } = &n.kind
+            && !masks.contains(&n.id)
+            && let Some(b) = path.control_bounds()
+            && editable(n.id)
+        {
+            out.push((n.id, path, b));
+        }
+    });
+    out
+}
+
+/// Most box tests one command makes between a line's pieces and the paths' segments.
+const MAX_LINE_TESTS: usize = 60_000_000;
+/// Most tests one command makes between the boxes of the paths to trim and of the other paths.
+const MAX_BOX_TESTS: usize = 50_000_000;
+
+/// Does the line through `pts` cross `sp`? Each piece of the line compared costs one of `budget`;
+/// `None` once it is spent.
+fn crossed_by_line(sp: &SubPath, pts: &[Point], budget: &mut usize) -> Option<bool> {
+    let segs: Vec<_> = (0..sp.segment_count())
+        .map(|i| {
+            let c = sp.segment(i);
+            (c, Rect::from_points(c.p0, c.p1).union_pt(c.p2).union_pt(c.p3).inflate(1e-9, 1e-9))
+        })
+        .collect();
+    let Some(reach) = segs.iter().map(|s| s.1).reduce(|a, b| a.union(b)) else { return Some(false) };
+    for w in pts.windows(2) {
+        let [a, b] = w else { continue };
+        let piece = Rect::from_points(*a, *b);
+        *budget = budget.checked_sub(1)?;
+        if !reach.overlaps(piece) {
+            continue;
+        }
+        for (c, r) in &segs {
+            *budget = budget.checked_sub(1)?;
+            if r.overlaps(piece) && !PathSeg::Cubic(*c).intersect_line(Line::new(*a, *b)).is_empty() {
+                return Some(true);
+            }
+        }
+    }
+    Some(false)
+}
+
+/// Does the rectangle or line of `pick` touch the outline of `piece`? Never for `Pick::At`.
+fn touches(piece: &SubPath, pick: &Pick, budget: &mut usize) -> Result<bool> {
+    match pick {
+        Pick::At(..) => Ok(false),
+        Pick::Rect(r) => Ok(hit::intersects_rect(&PathData::single(piece.clone()), *r)),
+        Pick::Line(pts, _) => crossed_by_line(piece, pts, budget)
+            .ok_or_else(|| bad("addon.pathtools.trim", "the line is too long, or the paths it passes too many, to check")),
+    }
+}
+
+/// `path` without the stretches `pick` takes (`on`: the place of `Pick::At` on it): its subpaths
+/// then, and how many stretches went. `None` when none does. A rectangle or a line that touches no
+/// part of `path` leaves it out before its crossings are looked for.
+fn trimmed(
+    path: &PathData,
+    others: &[&PathData],
+    pick: &Pick,
+    on: Option<pt::Place>,
+    budget: &mut usize,
+    work: &mut pt::Work,
+) -> Result<Option<(Vec<SubPath>, usize)>> {
+    const C: &str = "addon.pathtools.trim";
+    let reached = match pick {
+        Pick::At(..) => true,
+        Pick::Rect(r) => hit::intersects_rect(path, *r),
+        Pick::Line(..) => {
+            let mut any = false;
+            for sp in &path.subpaths {
+                if touches(sp, pick, budget)? {
+                    any = true;
+                    break;
+                }
+            }
+            any
+        }
+    };
+    if !reached {
+        return Ok(None);
+    }
+    let places =
+        pt::crossings_on_within(path, others, work).ok_or_else(|| bad(C, "the paths are too many or too tangled to find where they cross"))?;
+    let mut subs = vec![];
+    let mut removed = 0;
+    for (si, sp) in path.subpaths.iter().enumerate() {
+        // The places come in subpath order: this subpath's are one run of them.
+        let run = places.partition_point(|p| p.0 < si)..places.partition_point(|p| p.0 <= si);
+        let here: Vec<(usize, f64)> = places.get(run).unwrap_or_default().iter().map(|&(_, seg, t)| (seg, t)).collect();
+        let spans = pt::spans(sp, &here);
+        let marks: Vec<bool> = match pick {
+            Pick::At(..) => {
+                let at = on.filter(|(s, ..)| *s == si).and_then(|(_, seg, t)| pt::span_at(sp, &spans, seg, t));
+                (0..spans.len()).map(|i| Some(i) == at).collect()
+            }
+            _ => spans.iter().map(|s| touches(&pt::slice(sp, *s), pick, budget)).collect::<Result<_>>()?,
+        };
+        match pt::without_spans(sp, &spans, &marks) {
+            Some(pieces) => {
+                removed += marks.iter().filter(|m| **m).count();
+                subs.extend(pieces);
+            }
+            None => subs.push(sp.clone()),
+        }
+    }
+    Ok((removed > 0).then_some((subs, removed)))
+}
+
+fn trim(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "addon.pathtools.trim";
+    let pick = pick(p)?;
+    let st = s.doc()?;
+    let d = &st.doc;
+    let parts = parts(d);
+    // In isolation mode only the isolated object's paths are trimmed; paths outside it still cross them.
+    let root = crate::cmd::ordinary_isolation(st);
+    let in_scope = |id: NodeId| root.is_none_or(|r| id == r || crate::cmd::inside_isolation(d, r, id));
+    // The paths to trim, each with the place `at` falls on.
+    let targets: Vec<(usize, Option<pt::Place>)> = match &pick {
+        Pick::At(at, tolerance) => {
+            let mut best: Option<(usize, pt::Place, f64)> = None;
+            for (i, (id, path, b)) in parts.iter().enumerate() {
+                if !in_scope(*id) {
+                    continue;
+                }
+                let b = b.inflate(*tolerance, *tolerance);
+                if !(b.x0 <= at.x && at.x <= b.x1 && b.y0 <= at.y && at.y <= b.y1) {
+                    continue;
+                }
+                // Of paths equally near, the one on top.
+                if let Some((si, seg, t, _, dist)) = path.nearest(*at)
+                    && dist <= *tolerance
+                    && best.is_none_or(|b| dist <= b.2)
+                {
+                    best = Some((i, (si, seg, t), dist));
+                }
+            }
+            best.map(|(i, on, _)| (i, Some(on))).into_iter().collect()
+        }
+        Pick::Rect(r) | Pick::Line(_, r) => {
+            parts.iter().enumerate().filter(|(_, (id, _, b))| in_scope(*id) && b.overlaps(*r)).map(|(i, _)| (i, None)).collect()
+        }
+    };
+    // Each path to trim has its box tested against every other path's.
+    if targets.len().saturating_mul(parts.len()) > MAX_BOX_TESTS {
+        return Err(bad(C, "the rectangle or line reaches too many paths to check"));
+    }
+    let mut plan: Vec<(NodeId, Vec<PathData>)> = vec![];
+    let mut removed = 0;
+    let mut budget = MAX_LINE_TESTS;
+    // One budget of crossing work for every path the command trims.
+    let mut work = pt::Work::default();
+    for (i, on) in targets {
+        let Some((id, path, b)) = parts.get(i) else { continue };
+        let reach = b.inflate(1e-3, 1e-3);
+        let others: Vec<&PathData> =
+            parts.iter().enumerate().filter(|(j, (_, _, ob))| *j != i && reach.overlaps(*ob)).map(|(_, (_, o, _))| *o).collect();
+        let Some((subs, n)) = trimmed(path, &others, &pick, on, &mut budget, &mut work)? else { continue };
+        removed += n;
+        // A path of one subpath becomes a path per piece; the pieces of one with more stay its subpaths.
+        let pieces = match (path.subpaths.len(), subs.is_empty()) {
+            (_, true) => vec![],
+            (1, false) => subs.into_iter().map(PathData::single).collect(),
+            _ => vec![PathData::new(subs)],
+        };
+        plan.push((*id, pieces));
+    }
+    if plan.is_empty() {
+        return Ok(json!({ "ids": [], "removed": 0 }));
+    }
+    let ids = s.edit(LABEL, |d, sel| {
+        let trimmed: Vec<NodeId> = plan.iter().map(|(id, _)| *id).collect();
+        // The compound paths that may lose their last member.
+        let mut compounds: Vec<NodeId> = trimmed
+            .iter()
+            .filter_map(|id| d.parent_of(*id))
+            .filter(|c| matches!(d.node(*c).map(|n| &n.kind), Some(NodeKind::Compound { .. })))
+            .collect();
+        compounds.dedup();
+        let mut beside = Beside::replacing(d, &trimmed);
+        let mut all = vec![];
+        for (id, pieces) in plan {
+            let selected = sel.contains(id);
+            sel.anchors.remove(&id);
+            sel.segments.remove(&id);
+            let made = replace_with_pieces(d, &mut beside, id, pieces)?;
+            // The pieces of a selected path are selected; what was not selected stays so.
+            if made.is_empty() {
+                sel.remove(id);
+            } else if selected {
+                for n in &made {
+                    if !sel.contains(*n) {
+                        sel.add(*n);
+                    }
+                }
+            }
+            all.extend(made);
+        }
+        beside.finish(d)?;
+        for c in compounds {
+            if d.node(c).is_some_and(|n| n.children().is_some_and(|ch| ch.is_empty())) {
+                d.remove(c)?;
+                sel.remove(c);
+            }
+        }
+        Ok(all)
+    })?;
+    Ok(json!({ "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>(), "removed": removed }))
+}
diff --git a/crates/engine/src/cmd/addons/pathtools/trim/tests.rs b/crates/engine/src/cmd/addons/pathtools/trim/tests.rs
new file mode 100644
index 0000000000..42adb70ab9
--- /dev/null
+++ b/crates/engine/src/cmd/addons/pathtools/trim/tests.rs
@@ -0,0 +1,527 @@
+//! Trim at Crossings: the stretch at a point, the stretches a rectangle touches or a line crosses,
+//! one undo step, and what takes no part.
+
+use serde_json::{Value, json};
+use vectorcraft_doc::{NodeId, NodeKind};
+use vectorcraft_geom::{PathData, Point};
+
+use crate::Session;
+
+const TRIM: &str = "addon.pathtools.trim";
+
+fn session() -> Session {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+    s
+}
+
+fn line(s: &mut Session, pts: &[(f64, f64)], closed: bool) -> NodeId {
+    let anchors: Vec<Value> = pts.iter().map(|(x, y)| json!({"x": x, "y": y})).collect();
+    let id = NodeId(s.execute("path.create", &json!({"anchors": anchors, "closed": closed})).unwrap()["id"].as_u64().unwrap());
+    s.execute("select.none", &json!({})).unwrap();
+    id
+}
+
+/// A line across at y = 100 from x = 0 to 300, and two uprights across it at x = 100 and x = 200.
+fn across_and_uprights(s: &mut Session) -> (NodeId, NodeId, NodeId) {
+    let h = line(s, &[(0.0, 100.0), (300.0, 100.0)], false);
+    let v1 = line(s, &[(100.0, 50.0), (100.0, 150.0)], false);
+    let v2 = line(s, &[(200.0, 50.0), (200.0, 150.0)], false);
+    (h, v1, v2)
+}
+
+fn path(s: &Session, id: NodeId) -> PathData {
+    s.doc().unwrap().doc.node(id).unwrap().path_data().unwrap().clone()
+}
+
+fn exists(s: &Session, id: NodeId) -> bool {
+    s.doc().unwrap().doc.node(id).is_some()
+}
+
+/// The first and last anchor of the path's only subpath.
+fn ends(s: &Session, id: NodeId) -> (Point, Point) {
+    let p = path(s, id);
+    assert_eq!(p.subpaths.len(), 1);
+    (p.subpaths[0].anchors.first().unwrap().p, p.subpaths[0].anchors.last().unwrap().p)
+}
+
+fn near(p: Point, x: f64, y: f64) -> bool {
+    p.distance(Point::new(x, y)) < 1e-6
+}
+
+fn steps(s: &Session) -> usize {
+    s.doc().unwrap().history.undo.len()
+}
+
+fn ids(v: &Value) -> Vec<NodeId> {
+    v["ids"].as_array().unwrap().iter().map(|x| NodeId(x.as_u64().unwrap())).collect()
+}
+
+/// The ids of the first layer's objects, bottom to top.
+fn stack(s: &Session) -> Vec<NodeId> {
+    s.doc().unwrap().doc.layers[0].children().unwrap().iter().map(|n| n.id).collect()
+}
+
+fn set_flags(s: &mut Session, id: NodeId, locked: bool, visible: bool) {
+    s.edit("flags", |d, _| {
+        let n = d.node_mut(id).unwrap();
+        n.locked = locked;
+        n.visible = visible;
+        Ok(())
+    })
+    .unwrap();
+}
+
+#[test]
+fn a_point_between_two_crossings_removes_that_stretch_and_splits_the_path() {
+    let mut s = session();
+    let (h, v1, v2) = across_and_uprights(&mut s);
+    let look = s.doc().unwrap().doc.node(h).unwrap().appearance.clone();
+    let (before, n) = (stack(&s), steps(&s));
+    let r = s.execute(TRIM, &json!({"at": [150, 101]})).unwrap();
+    assert_eq!(r["removed"], json!(1));
+    let made = ids(&r);
+    assert_eq!(made.len(), 2, "{r}");
+    assert_eq!(made[0], h, "the first piece keeps the id");
+    let (a, b) = (ends(&s, made[0]), ends(&s, made[1]));
+    assert!(near(a.0, 0.0, 100.0) && near(a.1, 100.0, 100.0), "{a:?}");
+    assert!(near(b.0, 200.0, 100.0) && near(b.1, 300.0, 100.0), "{b:?}");
+    // Both pieces look as the path did and stand where it stood, under the uprights.
+    assert!(made.iter().all(|id| s.doc().unwrap().doc.node(*id).unwrap().appearance == look));
+    assert_eq!(stack(&s), [made[0], made[1], v1, v2]);
+    assert_eq!(before, [h, v1, v2]);
+    // The uprights are as they were, nothing got selected, and it is one undo step.
+    assert_eq!((path(&s, v1).anchor_count(), path(&s, v2).anchor_count()), (2, 2));
+    assert!(s.doc().unwrap().selection.is_empty());
+    assert_eq!(steps(&s), n + 1);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(stack(&s), before);
+    assert!(near(ends(&s, h).1, 300.0, 100.0));
+}
+
+#[test]
+fn an_end_stretch_runs_to_the_open_end_and_the_rest_stays_one_path() {
+    let mut s = session();
+    let (h, ..) = across_and_uprights(&mut s);
+    let r = s.execute(TRIM, &json!({"at": [40, 100]})).unwrap();
+    assert_eq!((ids(&r), r["removed"].clone()), (vec![h], json!(1)));
+    let e = ends(&s, h);
+    assert!(near(e.0, 100.0, 100.0) && near(e.1, 300.0, 100.0), "{e:?}");
+    // No anchor is added at the crossing the rest runs through.
+    assert_eq!(path(&s, h).anchor_count(), 2);
+    // A point on no path within the tolerance removes nothing and makes no step.
+    let n = steps(&s);
+    assert_eq!(s.execute(TRIM, &json!({"at": [250, 110]})).unwrap(), json!({"ids": [], "removed": 0}));
+    assert_eq!(s.execute(TRIM, &json!({"at": [250, 110], "tolerance": 0})).unwrap()["removed"], json!(0));
+    assert_eq!(steps(&s), n);
+    assert_eq!(s.execute(TRIM, &json!({"at": [250, 110], "tolerance": 12})).unwrap()["removed"], json!(1));
+    assert!(near(ends(&s, h).1, 200.0, 100.0));
+}
+
+#[test]
+fn a_closed_path_that_loses_a_stretch_opens() {
+    let mut s = session();
+    let sq = NodeId(s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 100, "height": 100})).unwrap()["id"].as_u64().unwrap());
+    s.execute("select.none", &json!({})).unwrap();
+    line(&mut s, &[(50.0, 150.0), (250.0, 150.0)], false);
+    // The top half of the square's outline, between the two places the line crosses it.
+    let r = s.execute(TRIM, &json!({"at": [150, 100]})).unwrap();
+    assert_eq!((ids(&r), r["removed"].clone()), (vec![sq], json!(1)));
+    let p = path(&s, sq);
+    assert_eq!(p.subpaths.len(), 1);
+    assert!(!p.subpaths[0].closed);
+    let pts: Vec<Point> = p.subpaths[0].anchors.iter().map(|a| a.p).collect();
+    assert_eq!(pts.len(), 4, "{pts:?}");
+    assert!(pts.iter().all(|q| q.y >= 150.0 - 1e-6), "only the lower half is left: {pts:?}");
+    assert!(pts.iter().any(|q| near(*q, 100.0, 200.0)) && pts.iter().any(|q| near(*q, 200.0, 200.0)));
+    // It is a plain path now.
+    assert!(matches!(&s.doc().unwrap().doc.node(sq).unwrap().kind, NodeKind::Path { live: None, .. }));
+}
+
+#[test]
+fn a_rectangle_removes_every_stretch_it_touches_as_one_step() {
+    let mut s = session();
+    let (h, v1, v2) = across_and_uprights(&mut s);
+    let h2 = line(&mut s, &[(0.0, 120.0), (300.0, 120.0)], false);
+    let n = steps(&s);
+    // Over the middle of both lines across, touching neither upright.
+    let r = s.execute(TRIM, &json!({"rect": [140, 90, 20, 40]})).unwrap();
+    assert_eq!(r["removed"], json!(2));
+    assert_eq!(ids(&r).len(), 4);
+    assert_eq!(steps(&s), n + 1, "one undo step");
+    assert!(near(ends(&s, h).1, 100.0, 100.0) && near(ends(&s, h2).1, 100.0, 120.0));
+    assert_eq!((path(&s, v1).anchor_count(), path(&s, v2).anchor_count()), (2, 2));
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert!(near(ends(&s, h).1, 300.0, 100.0) && near(ends(&s, h2).1, 300.0, 120.0));
+    // A rectangle given from its far corner is the same one; one over empty space removes nothing.
+    assert_eq!(s.execute(TRIM, &json!({"rect": [160, 130, -20, -40]})).unwrap()["removed"], json!(2));
+    let n = steps(&s);
+    assert_eq!(s.execute(TRIM, &json!({"rect": [300, 200, 50, 50]})).unwrap()["removed"], json!(0));
+    assert_eq!(steps(&s), n);
+    // An upright's stretches: above the upper line, between the two, below the lower. A rectangle
+    // over its top end takes the first only.
+    assert_eq!(s.execute(TRIM, &json!({"rect": [95, 45, 10, 10]})).unwrap()["removed"], json!(1));
+    assert!(near(ends(&s, v1).0, 100.0, 100.0) && near(ends(&s, v1).1, 100.0, 150.0));
+}
+
+#[test]
+fn a_line_through_points_removes_the_stretches_it_crosses() {
+    let mut s = session();
+    let (h, v1, v2) = across_and_uprights(&mut s);
+    let n = steps(&s);
+    // Down through the middle of the line across, then right through the lower end of the second upright.
+    let r = s.execute(TRIM, &json!({"points": [[150, 80], [150, 130], [250, 130]]})).unwrap();
+    assert_eq!(r["removed"], json!(2));
+    assert_eq!(steps(&s), n + 1);
+    assert!(near(ends(&s, h).1, 100.0, 100.0));
+    assert!(near(ends(&s, v2).0, 200.0, 50.0) && near(ends(&s, v2).1, 200.0, 100.0));
+    assert_eq!(path(&s, v1).anchor_count(), 2);
+}
+
+#[test]
+fn locked_and_hidden_paths_are_not_trimmed_and_do_not_count_as_crossing() {
+    let mut s = session();
+    let (h, v1, v2) = across_and_uprights(&mut s);
+    set_flags(&mut s, v1, true, true);
+    set_flags(&mut s, v2, false, false);
+    let n = steps(&s);
+    // On the locked upright, and a rectangle over the hidden one's top end: nothing goes.
+    assert_eq!(s.execute(TRIM, &json!({"at": [100, 60]})).unwrap()["removed"], json!(0));
+    assert_eq!(s.execute(TRIM, &json!({"rect": [195, 45, 10, 10]})).unwrap()["removed"], json!(0));
+    assert_eq!(steps(&s), n);
+    assert_eq!((path(&s, v1).anchor_count(), path(&s, v2).anchor_count()), (2, 2));
+    // Neither marks a place on the line across: with nothing else crossing it, it goes whole.
+    assert_eq!(s.execute(TRIM, &json!({"at": [150, 100]})).unwrap(), json!({"ids": [], "removed": 1}));
+    assert!(!exists(&s, h) && exists(&s, v1) && exists(&s, v2));
+    // A guide doesn't count either.
+    s.execute("edit.undo", &json!({})).unwrap();
+    set_flags(&mut s, v1, false, true);
+    s.execute("select.set", &json!({"ids": [v1.0]})).unwrap();
+    s.execute("view.guides.make", &json!({})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    s.execute(TRIM, &json!({"at": [150, 100]})).unwrap();
+    assert!(!exists(&s, h));
+}
+
+#[test]
+fn a_path_of_two_subpaths_loses_the_stretch_on_the_subpath_under_the_point() {
+    let mut s = session();
+    // Lines of different lengths, so the places on one fall at other parameters than on the other.
+    let line_at = |x0: f64, x1: f64, y: f64| vectorcraft_geom::SubPath::polyline(&[Point::new(x0, y), Point::new(x1, y)], false);
+    let two = s
+        .edit("two", |d, _| {
+            let layer = d.layers[0].id;
+            let id = d.alloc_id();
+            let both = PathData::new(vec![line_at(0.0, 300.0, 100.0), line_at(50.0, 250.0, 120.0)]);
+            d.insert(Some(layer), 0, vectorcraft_doc::Node::path(id, both, Default::default()))?;
+            Ok(id)
+        })
+        .unwrap();
+    line(&mut s, &[(100.0, 50.0), (100.0, 150.0)], false);
+    line(&mut s, &[(200.0, 50.0), (200.0, 150.0)], false);
+    // The middle of the lower subpath goes; the upper one stays whole, both in the one path.
+    assert_eq!(s.execute(TRIM, &json!({"at": [150, 120]})).unwrap()["removed"], json!(1));
+    let p = path(&s, two);
+    let spans: Vec<(Point, Point)> = p.subpaths.iter().map(|sp| (sp.anchors[0].p, sp.anchors.last().unwrap().p)).collect();
+    assert_eq!(spans.len(), 3, "{spans:?}");
+    assert!(near(spans[0].0, 0.0, 100.0) && near(spans[0].1, 300.0, 100.0), "{spans:?}");
+    assert!(near(spans[1].0, 50.0, 120.0) && near(spans[1].1, 100.0, 120.0), "{spans:?}");
+    assert!(near(spans[2].0, 200.0, 120.0) && near(spans[2].1, 250.0, 120.0), "{spans:?}");
+}
+
+#[test]
+fn a_clipping_path_is_not_trimmed_and_does_not_count_as_crossing() {
+    let mut s = session();
+    let (h, v1, _) = across_and_uprights(&mut s);
+    s.edit("clip", |d, _| {
+        if let NodeKind::Path { clipping, .. } = &mut d.node_mut(v1).unwrap().kind {
+            *clipping = true;
+        }
+        Ok(())
+    })
+    .unwrap();
+    assert_eq!(s.execute(TRIM, &json!({"at": [100, 60]})).unwrap()["removed"], json!(0));
+    assert_eq!(path(&s, v1).anchor_count(), 2);
+    // The line across is crossed by the second upright only: its stretch from the start goes.
+    assert_eq!(s.execute(TRIM, &json!({"at": [150, 100]})).unwrap()["removed"], json!(1));
+    assert!(near(ends(&s, h).0, 200.0, 100.0) && near(ends(&s, h).1, 300.0, 100.0));
+    // Type over the rest of it takes no part either: nothing crosses the rest, and it goes whole.
+    let t = NodeId(s.execute("text.create", &json!({"x": 220, "y": 115, "text": "HHHH", "size": 40})).unwrap()["id"].as_u64().unwrap());
+    s.execute("select.none", &json!({})).unwrap();
+    assert_eq!(s.execute(TRIM, &json!({"rect": [215, 70, 70, 50]})).unwrap(), json!({"ids": [], "removed": 1}));
+    assert!(!exists(&s, h) && exists(&s, t));
+}
+
+#[test]
+fn the_members_of_a_compound_clipping_path_are_not_trimmed_and_do_not_count_as_crossing() {
+    let mut s = session();
+    let (h, v1, _) = across_and_uprights(&mut s);
+    let extra = line(&mut s, &[(250.0, 250.0), (260.0, 260.0)], false);
+    s.execute("select.set", &json!({"ids": [v1.0, extra.0]})).unwrap();
+    let compound = NodeId(s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+    s.execute("select.set", &json!({"ids": [h.0, compound.0]})).unwrap();
+    s.execute("object.clippingMask.make", &json!({})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    let n = steps(&s);
+    // A click on the clipping path's member changes nothing, and the rectangle over it neither.
+    assert_eq!(s.execute(TRIM, &json!({"at": [100, 60]})).unwrap()["removed"], json!(0));
+    assert_eq!(s.execute(TRIM, &json!({"rect": [245, 245, 20, 20]})).unwrap()["removed"], json!(0));
+    assert_eq!((steps(&s), path(&s, v1).anchor_count(), path(&s, extra).anchor_count()), (n, 2, 2));
+    // The clipped line across is crossed by the second upright only: its stretch from the start goes.
+    assert_eq!(s.execute(TRIM, &json!({"at": [150, 100]})).unwrap()["removed"], json!(1));
+    assert!(near(ends(&s, h).0, 200.0, 100.0) && near(ends(&s, h).1, 300.0, 100.0));
+}
+
+#[test]
+fn in_isolation_mode_only_the_isolated_objects_paths_are_trimmed() {
+    let mut s = session();
+    let (h, v1, v2) = across_and_uprights(&mut s);
+    s.execute("select.set", &json!({"ids": [v1.0, v2.0]})).unwrap();
+    let g = NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap());
+    s.execute("object.isolate", &json!({"id": g.0})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    // The line across is outside the group: a click or a rectangle on it leaves it whole.
+    assert_eq!(s.execute(TRIM, &json!({"at": [150, 100]})).unwrap()["removed"], json!(0));
+    assert_eq!(s.execute(TRIM, &json!({"rect": [140, 90, 20, 20]})).unwrap()["removed"], json!(0));
+    assert!(near(ends(&s, h).0, 0.0, 100.0) && near(ends(&s, h).1, 300.0, 100.0));
+    // It still crosses the uprights: a rectangle over the tops of both removes them down to it.
+    assert_eq!(s.execute(TRIM, &json!({"rect": [90, 40, 120, 20]})).unwrap()["removed"], json!(2));
+    assert!(near(ends(&s, v1).0, 100.0, 100.0) && near(ends(&s, v2).0, 200.0, 100.0));
+    assert!(near(ends(&s, h).0, 0.0, 100.0) && near(ends(&s, h).1, 300.0, 100.0));
+    // An isolated path is trimmed itself.
+    s.execute("object.exitIsolation", &json!({})).unwrap();
+    s.execute("object.isolate", &json!({"id": h.0})).unwrap();
+    assert_eq!(s.execute(TRIM, &json!({"at": [150, 100]})).unwrap()["removed"], json!(1));
+    assert!(near(ends(&s, h).1, 100.0, 100.0));
+}
+
+#[test]
+fn a_rectangle_over_too_many_paths_to_check_is_refused() {
+    let mut s = session();
+    // 7,072 short lines apart from each other: each of them against every other is past the limit.
+    s.edit("many", |d, _| {
+        let layer = d.layers[0].id;
+        for i in 0..7072 {
+            let (x, y) = ((i % 100) as f64 * 3.0, (i / 100) as f64 * 3.0);
+            let sp = vectorcraft_geom::SubPath::polyline(&[Point::new(x, y), Point::new(x + 1.0, y)], false);
+            let id = d.alloc_id();
+            let top = d.node(layer).unwrap().children().unwrap().len();
+            d.insert(Some(layer), top, vectorcraft_doc::Node::path(id, PathData::single(sp), Default::default()))?;
+        }
+        Ok(())
+    })
+    .unwrap();
+    let n = steps(&s);
+    let err = s.execute(TRIM, &json!({"rect": [-10, -10, 400, 300]})).unwrap_err().to_string();
+    assert!(err.contains("too many paths"), "{err}");
+    assert_eq!((steps(&s), stack(&s).len()), (n, 7072));
+    // A rectangle over a few of them is checked.
+    assert_eq!(s.execute(TRIM, &json!({"rect": [-1, -1, 5, 2]})).unwrap()["removed"], json!(2));
+}
+
+#[test]
+fn a_path_too_large_to_search_is_refused_only_when_touched() {
+    let mut s = session();
+    let (h, ..) = across_and_uprights(&mut s);
+    // A border of 10,001 segments round all of them, more than a path to trim may have.
+    let mut border: Vec<(f64, f64)> = (0..=10_001).map(|i| (-500.0 + i as f64 * 0.2, -500.0)).collect();
+    border.push((-500.0, 1500.0));
+    let b = line(&mut s, &border, true);
+    // A rectangle and a line over the middle of the line across reach inside the border's box only.
+    assert_eq!(s.execute(TRIM, &json!({"rect": [140, 90, 20, 20]})).unwrap()["removed"], json!(1));
+    assert!(near(ends(&s, h).1, 100.0, 100.0));
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(s.execute(TRIM, &json!({"points": [[150, 80], [150, 120]]})).unwrap()["removed"], json!(1));
+    // A rectangle on the border is refused, and changes nothing.
+    let n = steps(&s);
+    let err = s.execute(TRIM, &json!({"rect": [-510, 0, 20, 20]})).unwrap_err().to_string();
+    assert!(err.contains("too many or too tangled"), "{err}");
+    assert_eq!((steps(&s), path(&s, b).anchor_count()), (n, 10_003));
+}
+
+#[test]
+fn a_path_nothing_crosses_goes_whole_open_or_closed() {
+    let mut s = session();
+    let open = line(&mut s, &[(0.0, 10.0), (50.0, 10.0), (50.0, 40.0)], false);
+    let closed = line(&mut s, &[(100.0, 10.0), (150.0, 10.0), (150.0, 40.0)], true);
+    let n = steps(&s);
+    assert_eq!(s.execute(TRIM, &json!({"at": [25, 10]})).unwrap(), json!({"ids": [], "removed": 1}));
+    assert_eq!(s.execute(TRIM, &json!({"at": [125, 10]})).unwrap(), json!({"ids": [], "removed": 1}));
+    assert!(!exists(&s, open) && !exists(&s, closed));
+    assert_eq!(steps(&s), n + 2);
+}
+
+#[test]
+fn a_path_that_ends_on_another_marks_a_place_and_paths_along_each_other_do_not() {
+    let mut s = session();
+    let h = line(&mut s, &[(0.0, 100.0), (300.0, 100.0)], false);
+    let stub = line(&mut s, &[(150.0, 100.0), (150.0, 160.0)], false);
+    // The stub ends on the line: the line's stretch stops there, and the stub is one stretch.
+    s.execute(TRIM, &json!({"at": [50, 100]})).unwrap();
+    assert!(near(ends(&s, h).0, 150.0, 100.0) && near(ends(&s, h).1, 300.0, 100.0));
+    assert_eq!(s.execute(TRIM, &json!({"at": [150, 130]})).unwrap()["removed"], json!(1));
+    assert!(!exists(&s, stub));
+    // A second line along the first doesn't mark it: the lower one goes whole.
+    let along = line(&mut s, &[(200.0, 100.0), (260.0, 100.0)], false);
+    s.execute(TRIM, &json!({"rect": [270, 90, 10, 20]})).unwrap();
+    assert!(!exists(&s, h) && exists(&s, along));
+}
+
+#[test]
+fn a_self_crossing_path_loses_its_loop() {
+    let mut s = session();
+    // A bow: its first and third segments cross at (50, 50).
+    let bow = line(&mut s, &[(0.0, 0.0), (100.0, 100.0), (100.0, 0.0), (0.0, 100.0)], false);
+    let r = s.execute(TRIM, &json!({"at": [100, 50]})).unwrap();
+    assert_eq!(r["removed"], json!(1));
+    let made = ids(&r);
+    assert_eq!(made.len(), 2);
+    assert_eq!(made[0], bow);
+    assert!(near(ends(&s, made[0]).1, 50.0, 50.0) && near(ends(&s, made[1]).0, 50.0, 50.0));
+}
+
+#[test]
+fn compound_path_members_are_trimmed_and_an_emptied_compound_path_goes() {
+    let mut s = session();
+    let a = line(&mut s, &[(0.0, 100.0), (300.0, 100.0)], false);
+    let b = line(&mut s, &[(100.0, 50.0), (100.0, 150.0)], false);
+    s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
+    let compound = NodeId(s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+    s.execute("select.none", &json!({})).unwrap();
+    let members = |s: &Session| s.doc().unwrap().doc.node(compound).map(|n| n.children().unwrap().len());
+    assert_eq!(members(&s), Some(2));
+    // The members cross each other: a middle stretch splits one member in the compound path.
+    assert_eq!(s.execute(TRIM, &json!({"at": [100, 75]})).unwrap()["removed"], json!(1));
+    assert_eq!(members(&s), Some(2));
+    assert_eq!(s.execute(TRIM, &json!({"at": [100, 125]})).unwrap()["removed"], json!(1));
+    assert_eq!(members(&s), Some(1));
+    assert_eq!(s.execute(TRIM, &json!({"at": [200, 100]})).unwrap()["removed"], json!(1));
+    assert_eq!(members(&s), None, "the emptied compound path is removed");
+    assert!(stack(&s).is_empty());
+}
+
+#[test]
+fn the_selection_stays_as_it_was_and_the_pieces_of_a_selected_path_are_selected() {
+    let mut s = session();
+    let (_, v1, _) = across_and_uprights(&mut s);
+    s.execute("select.set", &json!({"ids": [v1.0]})).unwrap();
+    s.execute(TRIM, &json!({"at": [150, 100]})).unwrap();
+    assert_eq!(s.doc().unwrap().selection.objects, [v1], "the trimmed path was not selected");
+    let mut s = session();
+    let (h, ..) = across_and_uprights(&mut s);
+    s.execute("select.set", &json!({"ids": [h.0]})).unwrap();
+    let made = ids(&s.execute(TRIM, &json!({"at": [150, 100]})).unwrap());
+    assert_eq!(made.len(), 2);
+    let sel = &s.doc().unwrap().selection;
+    assert!(made.iter().all(|id| sel.contains(*id)), "{:?}", sel.objects);
+    // The second piece now ends on an upright: nothing crosses it, and it goes whole.
+    s.execute("select.set", &json!({"ids": [made[1].0]})).unwrap();
+    assert_eq!(s.execute(TRIM, &json!({"at": [250, 100]})).unwrap(), json!({"ids": [], "removed": 1}));
+    assert!(s.doc().unwrap().selection.is_empty(), "a removed path leaves the selection");
+}
+
+#[test]
+fn many_paths_far_from_the_trimmed_one_cost_no_crossing_search() {
+    let mut s = session();
+    let (h, ..) = across_and_uprights(&mut s);
+    // 3,000 short lines far below, each crossing its neighbor.
+    s.edit("many", |d, _| {
+        let layer = d.layers[0].id;
+        for i in 0..3000 {
+            let x = (i % 100) as f64 * 3.0;
+            let y = 1000.0 + (i / 100) as f64 * 3.0;
+            let sp = vectorcraft_geom::SubPath::polyline(
+                &[Point::new(x, y), Point::new(x + 5.0, y + 5.0), Point::new(x + 5.0, y), Point::new(x, y + 5.0)],
+                false,
+            );
+            let id = d.alloc_id();
+            let top = d.node(layer).unwrap().children().unwrap().len();
+            d.insert(Some(layer), top, vectorcraft_doc::Node::path(id, PathData::single(sp), Default::default()))?;
+        }
+        Ok(())
+    })
+    .unwrap();
+    assert_eq!(s.execute(TRIM, &json!({"at": [150, 100]})).unwrap()["removed"], json!(1));
+    assert!(near(ends(&s, h).1, 100.0, 100.0));
+    // A rectangle over all of them takes every stretch it touches.
+    let r = s.execute(TRIM, &json!({"rect": [-10, 990, 400, 200]})).unwrap();
+    assert!(r["removed"].as_u64().unwrap() >= 3000, "{}", r["removed"]);
+    assert_eq!(stack(&s).len(), 4, "the line across in two pieces and the uprights");
+}
+
+#[test]
+fn the_tool_trims_on_release_as_one_step_and_escape_drops_a_drag() {
+    use vectorcraft_tools::{Mods, PointerEvent, PointerKind, ToolKey};
+    let mut s = session();
+    let (h, v1, _) = across_and_uprights(&mut s);
+    let h2 = line(&mut s, &[(0.0, 120.0), (300.0, 120.0)], false);
+    let view = crate::ViewInfo { smart_guides: false, ..crate::ViewInfo::default() };
+    s.select_tool("trimAtCrossings", view).unwrap();
+    assert_eq!(s.tool_id(), "trimAtCrossings");
+    let n = steps(&s);
+    // A drag over the middle of both lines across: nothing changes until the release.
+    s.pointer(&PointerEvent::new(PointerKind::Down, 140.0, 90.0), view).unwrap();
+    s.pointer(&PointerEvent::new(PointerKind::Drag, 160.0, 130.0), view).unwrap();
+    assert!(near(ends(&s, h).1, 300.0, 100.0));
+    s.pointer(&PointerEvent::new(PointerKind::Up, 160.0, 130.0), view).unwrap();
+    assert!(near(ends(&s, h).1, 100.0, 100.0) && near(ends(&s, h2).1, 100.0, 120.0));
+    assert_eq!(steps(&s), n + 1, "one undo step for the drag");
+    // Escape during a drag: the release removes nothing.
+    s.pointer(&PointerEvent::new(PointerKind::Down, 90.0, 40.0), view).unwrap();
+    s.pointer(&PointerEvent::new(PointerKind::Drag, 110.0, 60.0), view).unwrap();
+    s.tool_key(ToolKey::Escape, Mods::default(), view).unwrap();
+    s.pointer(&PointerEvent::new(PointerKind::Up, 110.0, 60.0), view).unwrap();
+    assert_eq!(steps(&s), n + 1);
+    assert!(near(ends(&s, v1).0, 100.0, 50.0));
+    // A click on the upright's top stretch removes it.
+    s.pointer(&PointerEvent::new(PointerKind::Down, 100.0, 70.0), view).unwrap();
+    s.pointer(&PointerEvent::new(PointerKind::Up, 100.0, 70.0), view).unwrap();
+    assert!(near(ends(&s, v1).0, 100.0, 100.0));
+    assert_eq!(steps(&s), n + 2);
+}
+
+#[test]
+fn a_line_too_long_to_check_against_the_paths_is_refused() {
+    let mut s = session();
+    // A zigzag of 1,000 segments, and a line of 100,000 points inside its box that crosses none.
+    let zigzag: Vec<(f64, f64)> = (0..=1000).map(|i| (i as f64 * 0.3, (i % 2) as f64 * 200.0)).collect();
+    let z = line(&mut s, &zigzag, false);
+    let (before, n) = (s.doc().unwrap().doc.clone(), steps(&s));
+    let points: Vec<Value> = (0..100_000).map(|i| json!([150.0 + (i % 2) as f64 * 0.01, 150.0])).collect();
+    let err = s.execute(TRIM, &json!({ "points": points })).unwrap_err().to_string();
+    assert!(err.contains("too long"), "{err}");
+    assert_eq!(steps(&s), n);
+    assert!(*s.doc().unwrap().doc == *before);
+    // A short line there is checked, and removes nothing.
+    assert_eq!(s.execute(TRIM, &json!({"points": [[150.0, 150.0], [150.01, 150.0]]})).unwrap()["removed"], json!(0));
+    assert!(exists(&s, z));
+}
+
+#[test]
+fn bad_params_are_refused_and_change_nothing() {
+    let mut s = session();
+    across_and_uprights(&mut s);
+    let (before, n) = (s.doc().unwrap().doc.clone(), steps(&s));
+    for bad in [
+        json!({}),
+        json!({"at": null}),
+        json!({"at": [150]}),
+        json!({"at": [150, "y"]}),
+        json!({"at": [150, 1e308]}),
+        json!({"at": [150, 100], "tolerance": -1}),
+        json!({"at": [150, 100], "tolerance": 101}),
+        json!({"at": [150, 100], "tolerance": "3"}),
+        json!({"at": [150, 100], "rect": [140, 90, 20, 40]}),
+        json!({"rect": [140, 90, 20]}),
+        json!({"rect": "all"}),
+        json!({"rect": [0, 0, 1e9, 5]}),
+        json!({"points": [[150, 80]]}),
+        json!({"points": [[150, 80], [150]]}),
+        json!({"points": "x"}),
+        json!({"points": [[150, 80], [150, 130]], "at": [1, 2]}),
+    ] {
+        assert!(s.execute(TRIM, &bad).is_err(), "{bad}");
+    }
+    assert_eq!(steps(&s), n);
+    assert!(*s.doc().unwrap().doc == *before);
+}
diff --git a/crates/engine/src/cmd/appearance.rs b/crates/engine/src/cmd/appearance.rs
index 7395db5cea..94b35e9f93 100644
--- a/crates/engine/src/cmd/appearance.rs
+++ b/crates/engine/src/cmd/appearance.rs
@@ -813,12 +813,18 @@ pub(super) fn capture_series_writes(
 /// and objects the edit left as they were keep what the graph stores. When the edit changes several marks of one series,
 /// the frontmost one sets what the graph stores, whatever order `ids` are in. Returns whether the stored paint changed.
 pub(crate) fn capture_series_changes(before: &vectorcraft_doc::Document, d: &mut vectorcraft_doc::Document, ids: &[NodeId]) -> bool {
+    let marks = series_children_in_paint_order(d, ids);
+    !marks.is_empty() && capture_series_writes(before, d, &marks, (false, false), (false, false), false, false)
+}
+
+/// Each of `ids` directly in a series group, from the back to the front: a later mark's capture replaces an earlier
+/// one's, so the frontmost one sets what the graph stores.
+pub(crate) fn series_children_in_paint_order(d: &vectorcraft_doc::Document, ids: &[NodeId]) -> Vec<NodeId> {
     // Only objects directly in a series group can be marks: other edits skip the search of the document for graphs.
     let in_series = |id: &NodeId| d.parent_of(*id).and_then(|p| d.node(p)).is_some_and(|g| g.extras().series_index.is_some());
     let mut marks: Vec<NodeId> = ids.iter().copied().filter(in_series).collect();
-    // A later mark's capture replaces an earlier one's: take them in paint order.
     marks.sort_by_cached_key(|id| d.index_path(*id));
-    !marks.is_empty() && capture_series_writes(before, d, &marks, (false, false), (false, false), false, false)
+    marks
 }
 
 /// Store on the graph the paint that an edit of `ids` (from `before` to `d`) leaves on the topmost visible fill and stroke
@@ -1666,6 +1672,7 @@ fn copied_character_styles<'a>(source: &Node, targets: impl Iterator<Item = &'a
         local.baseline_shift /= scale.points;
         local.tcy_up_down /= scale.points;
         local.tcy_left_right /= scale.points;
+        local.warichu_gap /= scale.points;
         local.h_scale /= scale.horizontal;
         // As with dimensional type commands, reject overflow and underflow before layout.
         if !copied_dimensions_fit(&effective, &local) {
@@ -1684,6 +1691,7 @@ fn copied_dimensions_fit(from: &CharStyle, to: &CharStyle) -> bool {
         (from.baseline_shift, to.baseline_shift),
         (from.tcy_up_down, to.tcy_up_down),
         (from.tcy_left_right, to.tcy_left_right),
+        (from.warichu_gap, to.warichu_gap),
         (from.h_scale, to.h_scale),
     ]
     .iter()
diff --git a/crates/engine/src/cmd/docinfo.rs b/crates/engine/src/cmd/docinfo.rs
index f1bd5ceb2c..54da0562b1 100644
--- a/crates/engine/src/cmd/docinfo.rs
+++ b/crates/engine/src/cmd/docinfo.rs
@@ -18,7 +18,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Document Info",
             ["Window", "Document Info"],
             None,
-            "{selectionOnly?, category?: document|objects|graphicStyles|brushes|spotColors|patterns|gradients|symbols|fonts|fontDetails|linkedImages|embeddedImages|repeats (only that one in sections and the text), format?: \"text\" (→ {text}: the report Document Info › Save… and Package write)} → {document, objects: {paths, compoundPaths, groups, …}, pathLength: pt (the paths' total length, compound paths' included, guides left out), fonts (the type in opacity masks and in the art of symbols and patterns included; with selectionOnly: the selected type's), images, swatches, graphicStyleNames (with selectionOnly: the styles the selected objects are linked to), brushNames (the brushes the art's drawn strokes use, each once; with selectionOnly: those the selected objects' strokes use), brushes: [{name, type: calligraphic|scatter|art|pattern|bristle|null}] (those brushes with their types; null: not in the Brushes panel), panelBrushNames (the Brushes panel's brushes), repeatObjects: [{id, name, type: radial|grid|mirror, instances, rows?, cols?}] (the Repeat objects, those in groups and other repeats included; with selectionOnly: those in the selection), spotObjects: [{id, name, spotColors}] (the objects filled or stroked with a spot color swatch, as a solid color or in the stops of a gradient with a stop above opacity 0, at a tint above 0, and grayscale images colorized with one, each once, by the rules patternObjects follows, with the spot colors they use; Registration and process colors are not spot colors; objects.spots counts them), spotColorNames and spotColors (the spot colors those objects use), patternObjects: [{id, name, patterns}] (the objects filled or stroked with a pattern, each once, those in groups and type whose drawn characters use one included, hidden fills and strokes, fills and strokes at an opacity of 0, strokes with no width, guides, compound path members' own fills and strokes, images' fills and strokes without a shape and characters that draw nothing left out, with the patterns they use, which objects.patterns counts; with selectionOnly: those in the selection), patternNames (the patterns those objects use), gradientObjects: [{id, name, gradients}] (the objects filled or stroked with a gradient, by the same rules, with the gradients they use: a linked gradient swatch's name, else Linear gradient, Radial gradient or Freeform gradient; objects.gradients counts them), gradientNames (the gradients those objects use), …, sections: [{id, title, rows: [[label, value]]}] (the panel's categories; fontDetails: each font's file and whether its license lets it be embedded)}. An image linked to a file outside the automation read roots has link null, and its Linked Images row names the file alone. brushNames, brushes, spotObjects, patternObjects and gradientObjects leave out hidden objects, objects at an opacity of 0 and the objects inside a hidden group or layer or one at an opacity of 0 (with selectionOnly too), their characters' paints and colorized images included; objects still counts them as paths, groups and the other kinds",
+            "{selectionOnly?, category?: document|objects|graphicStyles|brushes|spotColors|patterns|gradients|symbols|fonts|fontDetails|linkedImages|embeddedImages|repeats (only that one in sections and the text), format?: \"text\" (→ {text}: the report Document Info › Save… and Package write)} → {document: {…, units (English), unitId: the units' Preferences › Units id (points, millimeters, feetInches, …), rasterEffectsPpi}, objects: {paths, compoundPaths, groups, …}, pathLength: pt (the paths' total length, compound paths' included, guides left out), fonts (the type in opacity masks and in the art of symbols and patterns included; with selectionOnly: the selected type's), fontDetails: [{font, match: exact|style|missingWithFallback|missing, family, style, file, embedding: allowed|editing|previewPrint|forbidden|null}] (each font of fonts, in order: how it was found, the face shown (null when none), that face's file name (null for a built-in face) and what its license allows), images, imageObjects: [{name, width, height, linked, file}] (the image objects in the order Linked Images and Embedded Images list them; file: what a linked image's row shows, null for an embedded one), swatches, graphicStyleNames (with selectionOnly: the styles the selected objects are linked to), brushNames (the brushes the art's drawn strokes use, each once; with selectionOnly: those the selected objects' strokes use), brushes: [{name, type: calligraphic|scatter|art|pattern|bristle|null}] (those brushes with their types; null: not in the Brushes panel), panelBrushNames (the Brushes panel's brushes), repeatObjects: [{id, name, type: radial|grid|mirror, instances, rows?, cols?}] (the Repeat objects, those in groups and other repeats included; with selectionOnly: those in the selection), spotObjects: [{id, name, spotColors}] (the objects filled or stroked with a spot color swatch, as a solid color or in the stops of a gradient that color a part of it above opacity 0 (a stop at opacity 0 counts only where it mixes with a stop above opacity 0 over a stretch of some width), at a tint above 0, and grayscale images colorized with one, each once, by the rules patternObjects follows, with the spot colors they use; Registration and process colors are not spot colors; objects.spots counts them), spotColorNames and spotColors (the spot colors those objects use), patternObjects: [{id, name, patterns}] (the objects filled or stroked with a pattern, each once, those in groups and type whose drawn characters use one included, hidden fills and strokes, fills and strokes at an opacity of 0, strokes with no width, guides, compound path members' own fills and strokes, images' fills and strokes without a shape and characters that draw nothing left out, with the patterns they use, which objects.patterns counts; with selectionOnly: those in the selection), patternNames (the patterns those objects use), gradientObjects: [{id, name, gradients, kinds}] (the objects filled or stroked with a gradient, by the same rules, with the gradients they use: a linked gradient swatch's name, else its kind's name, such as Linear gradient; kinds gives each one's kind, linear|radial|conic|diamond|freeform, when it is named by its kind, else null; objects.gradients counts them), gradientNames (the gradients those objects use), …, sections: [{id, title, rows: [[label, value]]}] (the panel's categories; fontDetails: each font's file and whether its license lets it be embedded)}. An image linked to a file outside the automation read roots has link null, and its Linked Images row names the file alone. brushNames, brushes, spotObjects, patternObjects and gradientObjects leave out hidden objects, objects at an opacity of 0 and the objects inside a hidden group or layer or one at an opacity of 0 (with selectionOnly too), their characters' paints and colorized images included; objects still counts them as paths, groups and the other kinds",
             has_doc,
             info
         ),
@@ -85,17 +85,65 @@ pub struct Section {
 /// What a font's `fsType` lets a copy of it do, read as exports read it ([`Embedding`]): the
 /// most permissive usage bit wins, and bitmap-only fonts may not be embedded.
 pub fn embedding_label(fs_type: u16) -> &'static str {
-    if Embedding::from_fs_type(fs_type) == Embedding::Forbidden {
-        "embedding not allowed"
-    } else if fs_type & 0x0008 != 0 {
-        "embedding for editing"
-    } else if fs_type & 0x0004 != 0 {
-        "embedding for preview and print"
-    } else {
-        "embedding allowed"
+    match embedding_id(fs_type) {
+        "forbidden" => "embedding not allowed",
+        "editing" => "embedding for editing",
+        "previewPrint" => "embedding for preview and print",
+        _ => "embedding allowed",
     }
 }
 
+/// [`embedding_label`] as the `embedding` value of a `fontDetails` entry: `forbidden`, `editing`,
+/// `previewPrint` or `allowed`.
+pub fn embedding_id(fs_type: u16) -> &'static str {
+    if Embedding::from_fs_type(fs_type) == Embedding::Forbidden {
+        "forbidden"
+    } else if fs_type & 0x0008 != 0 {
+        "editing"
+    } else if fs_type & 0x0004 != 0 {
+        "previewPrint"
+    } else {
+        "allowed"
+    }
+}
+
+/// A font as Font Details lists it: its `fontDetails` entry and its row. The row gives the file
+/// the font is drawn from (`built in` for a face with no file) and whether its license lets it be
+/// embedded; for a style the family lacks, the face shown in its place; for a font that is not
+/// installed, the face shown instead, or `missing`. The entry holds the same facts as values
+/// (`match`: `exact`, `style`, `missingWithFallback` or `missing`), so the panel can show them in
+/// the interface language.
+fn font_detail(used: &super::fonts::UsedFont) -> (Value, (String, String)) {
+    let db = vectorcraft_text::FontDb::global();
+    let (family, style, version) = used;
+    let label = super::fonts::font_label(used);
+    // Found by any of its names (in the version the type names); a style the family lacks shows in
+    // another.
+    let resolved = db.resolve(family, style).map(|(f, m)| (db.face_version(family, style, version.as_deref()).unwrap_or(f), m));
+    let (entry, detail) = match resolved {
+        Some((f, m)) if m != vectorcraft_text::FontMatch::Missing => {
+            let file = f.path().and_then(|p| p.file_name()).map(|n| n.to_string_lossy().into_owned());
+            let found = format!("{}; {}", file.as_deref().unwrap_or("built in"), embedding_label(f.fs_type()));
+            let substituted = m == vectorcraft_text::FontMatch::Style;
+            let entry = json!({
+                "font": label,
+                "match": if substituted { "style" } else { "exact" },
+                "family": f.family,
+                "style": f.style,
+                "file": file,
+                "embedding": embedding_id(f.fs_type()),
+            });
+            (entry, if substituted { format!("substituted: shown in {} {} ({found})", f.family, f.style) } else { found })
+        }
+        Some((f, _)) => (
+            json!({ "font": label, "match": "missingWithFallback", "family": f.family, "style": f.style, "file": null, "embedding": null }),
+            format!("missing: shown in {} {}", f.family, f.style),
+        ),
+        None => (json!({ "font": label, "match": "missing", "family": null, "style": null, "file": null, "embedding": null }), "missing".into()),
+    };
+    (entry, (label, detail))
+}
+
 /// An image object as Document Info lists it: (name, width, height, linked file).
 type ImageRow = (String, u32, u32, Option<String>);
 
@@ -131,14 +179,15 @@ fn repeat_entry(d: &Document, n: &Node, spec: &RepeatSpec) -> (Value, (String, S
 }
 
 /// The Document Info categories of `d` (only `category` when given) from `info` (what
-/// `document.info` reports), its fonts, its image objects, the rows of the brushes its art uses, the
-/// rows of its Repeat objects and the rows of its objects filled or stroked with a spot color, with a
-/// pattern and with a gradient.
+/// `document.info` reports), its fonts and their Font Details rows, its image objects, the rows of
+/// the brushes its art uses, the rows of its Repeat objects and the rows of its objects filled or
+/// stroked with a spot color, with a pattern and with a gradient.
 #[allow(clippy::too_many_arguments)]
 fn sections(
     d: &Document,
     info: &Value,
     fonts: &BTreeSet<super::fonts::UsedFont>,
+    font_details: &[(String, String)],
     images: &[ImageRow],
     brushes: &[(String, String)],
     repeats: &[(String, String)],
@@ -192,34 +241,7 @@ fn sections(
                 "gradients" => gradient_objects.to_vec(),
                 "symbols" => names("symbols"),
                 "fonts" => fonts.iter().map(|f| (super::fonts::font_label(f), String::new())).collect(),
-                "fontDetails" => {
-                    let db = vectorcraft_text::FontDb::global();
-                    fonts
-                        .iter()
-                        .map(|used| {
-                            let (family, style, version) = used;
-                            // Found by any of its names (in the version the type names); a style the
-                            // family lacks shows in another.
-                            let resolved =
-                                db.resolve(family, style).map(|(f, m)| (db.face_version(family, style, version.as_deref()).unwrap_or(f), m));
-                            let detail = match resolved {
-                                Some((f, m)) if m != vectorcraft_text::FontMatch::Missing => {
-                                    let file =
-                                        f.path().and_then(|p| p.file_name()).map_or_else(|| "built in".into(), |n| n.to_string_lossy().into_owned());
-                                    let found = format!("{file}; {}", embedding_label(f.fs_type()));
-                                    if m == vectorcraft_text::FontMatch::Style {
-                                        format!("substituted: shown in {} {} ({found})", f.family, f.style)
-                                    } else {
-                                        found
-                                    }
-                                }
-                                Some((f, _)) => format!("missing: shown in {} {}", f.family, f.style),
-                                None => "missing".into(),
-                            };
-                            (super::fonts::font_label(used), detail)
-                        })
-                        .collect()
-                }
+                "fontDetails" => font_details.to_vec(),
                 "linkedImages" => {
                     images.iter().filter_map(|(name, w, h, link)| Some((name.clone(), format!("{w} × {h} px — {}", link.as_ref()?)))).collect()
                 }
@@ -277,6 +299,39 @@ fn gradient_label(p: &Paint) -> Option<String> {
     }
 }
 
+/// Where [`gradient_label`]'s name for gradient paint `p` comes from: `swatch:<name>` for a
+/// gradient linked to a swatch, else `kind:<kind>` (`linear`, `radial`, `conic`, `diamond` or
+/// `freeform`). The two prefixes keep a swatch's name apart from a kind's name it reads like.
+fn gradient_source(p: &Paint) -> Option<String> {
+    match p {
+        Paint::Gradient(g) => Some(match g.swatch.as_deref().filter(|s| !s.is_empty()) {
+            Some(swatch) => format!("swatch:{swatch}"),
+            None => format!("kind:{}", g.gradient.kind.label().to_ascii_lowercase()),
+        }),
+        _ => None,
+    }
+}
+
+/// For each of `names` (an object's [`gradient_label`]s), the kind it names when only a kind
+/// gives that name: a name one of `sources` (the object's [`gradient_source`]s) gives as a kind's
+/// and none gives as a swatch's, else null. A swatch named like a kind keeps its name even where
+/// a gradient of that kind is listed under the same name.
+fn gradient_kinds(names: &[String], sources: &[String]) -> Vec<Value> {
+    names
+        .iter()
+        .map(|name| {
+            if sources.iter().any(|s| s.strip_prefix("swatch:") == Some(name.as_str())) {
+                return Value::Null;
+            }
+            sources
+                .iter()
+                .filter_map(|s| s.strip_prefix("kind:"))
+                .find(|k| vectorcraft_color::GradientKind::parse(k).is_some_and(|kind| *name == format!("{} gradient", kind.label())))
+                .map_or(Value::Null, |k| json!(k))
+        })
+        .collect()
+}
+
 /// The names of `d`'s spot color swatches: the swatches whose prints go to a plate of their own
 /// ([`vectorcraft_doc::inks::inks`]). A name held by several swatches is the first one's, as
 /// [`Document::swatch`] finds it, and the Registration swatch prints on every plate, so it is not
@@ -289,10 +344,46 @@ fn spot_swatches(d: &Document) -> HashSet<&str> {
     first.into_iter().filter(|&(name, spot)| spot && name != vectorcraft_color::swatch::REGISTRATION).map(|(name, _)| name).collect()
 }
 
+/// Which of gradient `g`'s stops color some part of it that draws, by the stretches
+/// [`vectorcraft_color::Gradient::sample`] mixes in, for stops in any order: the pair of stop `k`
+/// and stop `k + 1` covers the offsets above every offset of stops `0..=k` up to stop `k + 1`'s,
+/// and both its stops count when that stretch has positive width and either stop is above opacity
+/// 0. The first stop also counts when it is above opacity 0, since it colors the offsets up to its
+/// own, and so does the last stop, since it colors the offsets above every stop's. Any other stop,
+/// opaque or not, counts only through a pair: a stop out of order whose pairs have no width
+/// (another stop before it reaches past both ends) colors nothing. A freeform gradient draws from
+/// its points, so each of its stops counts while any stop is above opacity 0.
+fn drawn_stops(g: &vectorcraft_color::Gradient) -> Vec<bool> {
+    let stops = &g.stops;
+    if g.kind == vectorcraft_color::GradientKind::Freeform {
+        let any = stops.iter().any(|s| s.opacity > 0.0);
+        return vec![any; stops.len()];
+    }
+    let mut drawn = vec![false; stops.len()];
+    if let (Some(first), Some(d)) = (stops.first(), drawn.first_mut()) {
+        *d = first.opacity > 0.0;
+    }
+    if let (Some(last), Some(d)) = (stops.last(), drawn.last_mut()) {
+        *d |= last.opacity > 0.0;
+    }
+    // `f32::max` skips a NaN offset, which the sampler never picks either.
+    let mut reach = f32::NEG_INFINITY;
+    for k in 0..stops.len().saturating_sub(1) {
+        reach = reach.max(stops[k].offset);
+        let (a, b) = (&stops[k], &stops[k + 1]);
+        if b.offset > reach && (a.opacity > 0.0 || b.opacity > 0.0) {
+            drawn[k] = true;
+            drawn[k + 1] = true;
+        }
+    }
+    drawn
+}
+
 /// The spot colors paint `p` prints (`spots`: [`spot_swatches`]): the spot swatch a solid color is
-/// linked to, or those a gradient's stops are linked to, each once, in the order of the stops. A
-/// link at a tint of 0 prints no ink, a gradient whose stops are all at an opacity of 0 draws
-/// nothing, and a color that only looks like a spot color is not linked to one.
+/// linked to, or those a gradient's drawn stops ([`drawn_stops`]) are linked to, each once, in the
+/// order of the stops. A link at a tint of 0 prints no ink, a stop that colors only parts of a
+/// gradient at an opacity of 0 prints none, and a color that only looks like a spot color is not
+/// linked to one.
 fn spot_labels(spots: &HashSet<&str>, p: &Paint) -> Vec<String> {
     let mut out: Vec<String> = vec![];
     let mut add = |swatch: &Option<String>, tint: f32| {
@@ -306,7 +397,10 @@ fn spot_labels(spots: &HashSet<&str>, p: &Paint) -> Vec<String> {
     };
     match p {
         Paint::Solid { swatch, tint, .. } => add(swatch, *tint),
-        Paint::Gradient(g) if g.gradient.stops.iter().any(|s| s.opacity > 0.0) => g.gradient.stops.iter().for_each(|s| add(&s.swatch, s.tint)),
+        Paint::Gradient(g) => {
+            let drawn = drawn_stops(&g.gradient);
+            g.gradient.stops.iter().zip(drawn).filter(|&(_, d)| d).for_each(|(s, _)| add(&s.swatch, s.tint));
+        }
         _ => {}
     }
     out
@@ -447,9 +541,11 @@ fn node_and_drawn<'a>(d: &'a Document, path: &[usize]) -> Option<(&'a Node, bool
 /// The spot colors, the patterns and the gradients (`spots`: [`spot_swatches`]) that object `n`
 /// paints, each once: those of its own fills and strokes ([`own_paints`], `members` included), of
 /// its drawn characters and, for a grayscale or 1-bit image, of the color it is colorized with.
-fn object_paints(d: &Document, spots: &HashSet<&str>, members: &HashSet<*const Node>, n: &Node) -> [Vec<String>; 3] {
+/// The fourth list gives where each gradient comes from: a swatch or a kind ([`gradient_source`]).
+fn object_paints(d: &Document, spots: &HashSet<&str>, members: &HashSet<*const Node>, n: &Node) -> [Vec<String>; 4] {
     let (spot, pattern, gradient) = (|p: &Paint| spot_labels(spots, p), one_label(pattern_label), one_label(gradient_label));
-    let labels: [&PaintNames<'_>; 3] = [&spot, &pattern, &gradient];
+    let gradient_from = one_label(gradient_source);
+    let labels: [&PaintNames<'_>; 4] = [&spot, &pattern, &gradient, &gradient_from];
     let painted_runs = painted_runs(d, spots, n);
     let mut used = labels.map(|label| own_paints(d, n, members, painted_runs.as_ref(), label));
     // The characters' own paints: an inline graphic draws no outline and does not take its run's
@@ -615,8 +711,10 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
             if let Some(k) = k {
                 *counts.entry(k).or_default() += 1;
             }
-            // The spot colors, the patterns and the gradients this object paints, each once; none when it does not draw.
-            let [used_spots, used_patterns, used_gradients] = if drawn { object_paints(d, &spot_swatches, &members, n) } else { Default::default() };
+            // The spot colors, the patterns and the gradients this object paints, each once, and where each gradient comes from;
+            // none when it does not draw.
+            let [used_spots, used_patterns, used_gradients, used_sources] =
+                if drawn { object_paints(d, &spot_swatches, &members, n) } else { Default::default() };
             // Objects counts the objects that Spot Color Objects, Pattern Objects and Gradient Objects list.
             if !used_spots.is_empty() {
                 let name = n.display_name();
@@ -636,7 +734,8 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
                 let name = n.display_name();
                 gradients.extend(used_gradients.iter().cloned());
                 gradient_rows.push((name.clone(), used_gradients.join(", ")));
-                gradient_objects.push(json!({ "id": n.id.0, "name": name, "gradients": used_gradients }));
+                let kinds = gradient_kinds(&used_gradients, &used_sources);
+                gradient_objects.push(json!({ "id": n.id.0, "name": name, "gradients": used_gradients, "kinds": kinds }));
                 *counts.entry("gradients").or_default() += 1;
             }
             if n.extras().mask.is_some() {
@@ -671,6 +770,14 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
         fonts.extend(super::fonts::art_texts_of(d).into_iter().flat_map(|(_, t, _)| t.runs.iter().map(|r| super::fonts::font_of(&r.style))));
     }
     let font_names: Vec<String> = fonts.iter().map(super::fonts::font_label).collect();
+    let (font_entries, font_rows): (Vec<Value>, Vec<(String, String)>) = fonts.iter().map(font_detail).unzip();
+    // The image objects in walk order, as Linked Images and Embedded Images list them: `file` is a
+    // linked image's row value (its path, or its file name alone when the request may not read it),
+    // and null for an embedded one.
+    let image_objects: Vec<Value> = image_rows
+        .iter()
+        .map(|(name, w, h, file)| json!({ "name": name, "width": w, "height": h, "linked": file.is_some(), "file": file }))
+        .collect();
     // Each brush the art uses with its type, found by name in the Brushes panel as the renderer finds it (the first of two
     // brushes with one name); a brush the panel does not hold draws as a plain stroke and has no type. A row names the type
     // as the New Brush dialog does (`Art Brush`), and the panel translates these values when it shows them.
@@ -688,7 +795,9 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
         "objects": counts,
         "pathLength": path_length,
         "fonts": font_names,
+        "fontDetails": font_entries,
         "images": images,
+        "imageObjects": image_objects,
         "symbols": symbols,
         "spotColors": spot,
         "spotColorNames": spot,
@@ -710,7 +819,7 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
     });
     // The document's name: its file's, else its title.
     out["document"]["name"] = json!(st.title());
-    let sections = sections(d, &out, &fonts, &image_rows, &brush_rows, &repeat_rows, &spot_rows, &pattern_rows, &gradient_rows, category);
+    let sections = sections(d, &out, &fonts, &font_rows, &image_rows, &brush_rows, &repeat_rows, &spot_rows, &pattern_rows, &gradient_rows, category);
     if text {
         return Ok(json!({ "text": report_text(&st.title(), selection_only, &sections) }));
     }
@@ -724,6 +833,7 @@ fn document_summary(d: &Document) -> Value {
         "title": d.title,
         "colorMode": match d.color_mode { ColorMode::Rgb => "RGB", ColorMode::Cmyk => "CMYK" },
         "units": d.units.label(),
+        "unitId": d.units.key(),
         "artboards": d.artboards.iter().map(|a| json!({ "name": a.name, "width": a.rect.width() / u, "height": a.rect.height() / u })).collect::<Vec<_>>(),
         "rasterEffectsPpi": d.raster_effects_ppi,
     })
@@ -1250,11 +1360,11 @@ mod tests {
         assert_eq!(
             i["gradientObjects"],
             json!([
-                {"id": a, "name": "Both", "gradients": ["Ramp", "Linear gradient"]},
-                {"id": b, "name": "<Rectangle>", "gradients": ["Radial gradient"]},
-                {"id": f, "name": "<Rectangle>", "gradients": ["Freeform gradient"]},
-                {"id": t, "name": "Type", "gradients": ["Ramp"]},
-                {"id": bar, "name": "Bar", "gradients": ["Ramp"]},
+                {"id": a, "name": "Both", "gradients": ["Ramp", "Linear gradient"], "kinds": [null, "linear"]},
+                {"id": b, "name": "<Rectangle>", "gradients": ["Radial gradient"], "kinds": ["radial"]},
+                {"id": f, "name": "<Rectangle>", "gradients": ["Freeform gradient"], "kinds": ["freeform"]},
+                {"id": t, "name": "Type", "gradients": ["Ramp"], "kinds": [null]},
+                {"id": bar, "name": "Bar", "gradients": ["Ramp"], "kinds": [null]},
             ])
         );
         assert_eq!(i["gradientNames"], json!(["Freeform gradient", "Linear gradient", "Radial gradient", "Ramp"]));
@@ -1493,6 +1603,95 @@ mod tests {
         assert_eq!(spots(&mut s), (vec![], None, None));
     }
 
+    /// Spot Color Objects leaves out a spot color linked only from gradient stops at an opacity of 0
+    /// whose stretches all lead to other stops at an opacity of 0 or have no width, while another
+    /// part of the gradient draws: an inner stop, an end stop and a stop at the offset of an opaque
+    /// stop. A clear stop next to an opaque stop tints the stretch between them, so it stays listed.
+    /// Type whose characters draw such a gradient follows the same rule, with and without Selection
+    /// Only, and the report writes the same rows.
+    #[test]
+    fn spot_color_objects_skip_spot_stops_only_in_clear_stretches() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+        let ink = |c: f64| json!({"model": "cmyk", "c": c, "m": 0.5, "y": 0.0, "k": 0.0});
+        for (k, name) in ["Ink", "Near", "Far", "Edge", "Seam"].into_iter().enumerate() {
+            s.execute("swatch.new", &json!({"name": name, "color": ink(0.2 * k as f64), "spot": true})).unwrap();
+        }
+        let stop = |offset: f64, swatch: Option<&str>, opacity: f64| match swatch {
+            Some(sw) => json!({"offset": offset, "color": "#000", "swatch": sw, "opacity": opacity}),
+            None => json!({"offset": offset, "color": "#fff", "opacity": opacity}),
+        };
+        let fill = |s: &mut Session, id: &Value, stops: Value| {
+            s.execute("paint.setFill", &json!({"ids": [id], "gradient": {"kind": "linear", "stops": stops}})).unwrap();
+            s.execute("paint.setStroke", &json!({"ids": [id], "none": true})).unwrap();
+        };
+        let square =
+            |s: &mut Session, x: f64| s.execute("shape.rectangle", &json!({"x": x, "y": 0, "width": 10, "height": 10})).unwrap()["id"].clone();
+        // Near borders the opaque Ink stop; Far sits between clear stops; Edge ends the ramp after a
+        // clear stop.
+        let ramp = square(&mut s, 0.0);
+        fill(
+            &mut s,
+            &ramp,
+            json!([stop(0.0, Some("Ink"), 1.0), stop(0.4, Some("Near"), 0.0), stop(0.6, Some("Far"), 0.0), stop(1.0, Some("Edge"), 0.0)]),
+        );
+        s.execute("layer.setProps", &json!({"id": ramp, "name": "Ramp"})).unwrap();
+        // Seam meets the opaque half only at one offset, where nothing between them has width.
+        let seam = square(&mut s, 20.0);
+        fill(&mut s, &seam, json!([stop(0.0, None, 0.0), stop(0.5, Some("Seam"), 0.0), stop(0.5, None, 1.0), stop(1.0, None, 1.0)]));
+        let t = s.execute("text.create", &json!({"x": 0, "y": 200, "text": "Hi"})).unwrap()["id"].clone();
+        fill(&mut s, &t, json!([stop(0.0, Some("Ink"), 1.0), stop(0.5, None, 0.0), stop(1.0, Some("Far"), 0.0)]));
+        s.execute("layer.setProps", &json!({"id": t, "name": "Type"})).unwrap();
+        let check = |s: &mut Session, params: Value| {
+            let i = s.execute("document.info", &params).unwrap();
+            let listed: Vec<(String, Value)> =
+                i["spotObjects"].as_array().unwrap().iter().map(|o| (o["name"].as_str().unwrap().to_string(), o["spotColors"].clone())).collect();
+            assert_eq!(listed, vec![("Ramp".to_string(), json!(["Ink", "Near"])), ("Type".to_string(), json!(["Ink"]))], "{params}");
+            assert_eq!((i["spotColorNames"].clone(), i["objects"]["spots"].as_u64()), (json!(["Ink", "Near"]), Some(2)), "{params}");
+            let rows = i["sections"].as_array().unwrap().iter().find(|c| c["id"] == "spotColors").unwrap()["rows"].clone();
+            assert_eq!(rows, json!([["Ramp", "Ink, Near"], ["Type", "Ink"]]), "{params}");
+        };
+        check(&mut s, json!({}));
+        s.execute("select.set", &json!({"ids": [ramp, seam, t]})).unwrap();
+        check(&mut s, json!({"selectionOnly": true}));
+        let text = s.execute("document.info", &json!({"category": "spotColors", "format": "text"})).unwrap()["text"].as_str().unwrap().to_string();
+        assert!(text.contains("\nSPOT COLOR OBJECTS\nRamp: Ink, Near\nType: Ink\n"), "{text}");
+        assert!(!["Far", "Edge", "Seam"].iter().any(|n| text.contains(n)), "{text}");
+    }
+
+    /// A gradient's stops print where they color a stretch that draws, for stops in any order: the
+    /// sampler mixes stop `k` with stop `k + 1` above every offset of the stops before it, so an
+    /// out-of-order stop's pair can have no width.
+    #[test]
+    fn drawn_stops_follow_the_sampled_stretches() {
+        use vectorcraft_color::{Color, Gradient, GradientKind, GradientStop};
+        let stop = |offset: f32, opacity: f32| GradientStop { opacity, ..GradientStop::new(offset, Color::BLACK) };
+        let g = |stops: Vec<GradientStop>| Gradient::new(GradientKind::Linear, stops);
+        // In order: the clear stop next to the opaque one, not the one after it.
+        assert_eq!(drawn_stops(&g(vec![stop(0.0, 1.0), stop(0.5, 0.0), stop(1.0, 0.0)])), vec![true, true, false]);
+        // Out of order: the pair (0.8, 0.3) has no width, so the clear stop at 0.3 mixes only with
+        // the clear stop at 0.8 before it, and the pair (0.3, 1.0) is sampled above 0.8.
+        assert_eq!(drawn_stops(&g(vec![stop(0.0, 0.0), stop(0.8, 0.0), stop(0.3, 0.0), stop(1.0, 1.0)])), vec![false, false, true, true]);
+        // An opaque stop out of order: the pairs (0, 0.8) and (0.7, 1) cover every offset, so the
+        // pairs next to the stop at 0.3 have no width and it colors nothing.
+        let out_of_order = |o: f32| g(vec![stop(0.0, 0.0), stop(0.8, o), stop(0.3, 1.0), stop(0.7, 0.0), stop(1.0, 0.0)]);
+        assert_eq!(drawn_stops(&out_of_order(0.0)), vec![false; 5]);
+        // With the stop at 0.8 opaque, the pairs next to it with width are drawn.
+        assert_eq!(drawn_stops(&out_of_order(1.0)), vec![true, true, false, false, false]);
+        // The last stop colors the offsets above every stop's, even when it is out of order.
+        assert_eq!(drawn_stops(&g(vec![stop(0.0, 0.0), stop(0.6, 0.0), stop(0.5, 1.0)])), vec![false, false, true]);
+        // The first stop colors the offsets up to its own.
+        assert_eq!(drawn_stops(&g(vec![stop(0.0, 1.0), stop(0.0, 0.0), stop(1.0, 0.0)])), vec![true, false, false]);
+        // One stop, every stop clear, and no stops at all.
+        assert_eq!(drawn_stops(&g(vec![stop(0.5, 1.0)])), vec![true]);
+        assert_eq!(drawn_stops(&g(vec![stop(0.0, 0.0), stop(1.0, 0.0)])), vec![false, false]);
+        assert!(drawn_stops(&g(vec![])).is_empty());
+        // A freeform gradient draws from its points: its stops count while any is above opacity 0.
+        let mut free = g(vec![stop(0.0, 1.0), stop(0.5, 0.0), stop(1.0, 0.0)]);
+        free.kind = GradientKind::Freeform;
+        assert_eq!(drawn_stops(&free), vec![true, true, true]);
+    }
+
     /// Brushes, Spot Color Objects, Pattern Objects and Gradient Objects leave out a hidden object,
     /// an object at an opacity of 0 and the objects inside a hidden layer or a group at an opacity of
     /// 0, with Selection Only too: their fills, strokes, characters and colorized pixels paint no
@@ -1672,6 +1871,112 @@ mod tests {
         assert_eq!(embedding_label(0x0003), "embedding not allowed");
         assert_eq!(embedding_label(0x0006), "embedding for preview and print");
         assert_eq!(embedding_label(0x000c), "embedding for editing");
+        // `fontDetails` names each permission by id.
+        assert_eq!(
+            [0, 0x0002, 0x0104, 0x0008, 0x0200, 0x000c].map(embedding_id),
+            ["allowed", "forbidden", "previewPrint", "editing", "forbidden", "editing"]
+        );
+    }
+
+    /// `fontDetails` gives each Font Details row's facts as values, in the rows' order: how the
+    /// font was found, the face shown, its file (null for a built-in face) and its embedding
+    /// permission. The rows and the report stay in English.
+    #[test]
+    fn info_exposes_structured_font_details_without_changing_english_rows() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 200, "height": 100})).unwrap();
+        s.execute("text.create", &json!({"x": 10, "y": 20, "text": "Hi"})).unwrap();
+        s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Heavy", "font": "Source Sans 3", "style": "Black Wide"})).unwrap();
+        s.execute("text.create", &json!({"x": 10, "y": 80, "text": "Gone", "font": "Qx Absent Family"})).unwrap();
+        let i = s.execute("document.info", &json!({"category": "fontDetails"})).unwrap();
+        let (entries, rows) = (i["fontDetails"].as_array().unwrap(), i["sections"][0]["rows"].as_array().unwrap());
+        assert_eq!(entries.iter().map(|e| e["font"].clone()).collect::<Vec<_>>(), rows.iter().map(|r| r[0].clone()).collect::<Vec<_>>());
+        let at = |prefix: &str| entries.iter().position(|e| e["font"].as_str().unwrap().starts_with(prefix)).unwrap();
+        let regular = at("Source Sans 3 Regular");
+        assert_eq!(
+            entries[regular],
+            json!({"font": "Source Sans 3 Regular", "match": "exact", "family": "Source Sans 3", "style": "Regular", "file": null, "embedding": "allowed"})
+        );
+        assert_eq!(rows[regular][1], "built in; embedding allowed");
+        let (wide, e) = (at("Source Sans 3 Black Wide"), &entries[at("Source Sans 3 Black Wide")]);
+        assert_eq!((e["match"].as_str(), e["family"].as_str()), (Some("style"), Some("Source Sans 3")), "{e}");
+        let file = e["file"].as_str().unwrap_or("built in");
+        let fs_type = [("allowed", 0), ("forbidden", 0x0002), ("previewPrint", 0x0004), ("editing", 0x0008)]
+            .into_iter()
+            .find_map(|(id, bits)| (e["embedding"] == id).then_some(bits))
+            .unwrap();
+        let found = format!("{file}; {}", embedding_label(fs_type));
+        assert_eq!(rows[wide][1], format!("substituted: shown in Source Sans 3 {} ({found})", e["style"].as_str().unwrap()));
+        let (gone, e) = (at("Qx Absent Family"), &entries[at("Qx Absent Family")]);
+        assert!(e["file"].is_null() && e["embedding"].is_null(), "{e}");
+        match e["match"].as_str() {
+            Some("missingWithFallback") => {
+                assert_eq!(rows[gone][1], format!("missing: shown in {} {}", e["family"].as_str().unwrap(), e["style"].as_str().unwrap()))
+            }
+            Some("missing") => assert_eq!((rows[gone][1].as_str(), e["family"].is_null()), (Some("missing"), true)),
+            m => panic!("{m:?}"),
+        }
+        let text = s.execute("document.info", &json!({"category": "fontDetails", "format": "text"})).unwrap()["text"].as_str().unwrap().to_string();
+        assert!(text.contains("Source Sans 3 Regular: built in; embedding allowed\n"), "{text}");
+    }
+
+    /// `document.unitId` names the document's units as Preferences › Units does, beside the English
+    /// `units`, and `imageObjects` lists the image objects in the order Embedded Images and Linked
+    /// Images list them, with the file a linked one shows (null for an embedded one).
+    #[test]
+    fn info_exposes_ordered_images_and_unit_id() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 200, "height": 100})).unwrap();
+        s.edit("Units", |d, _| {
+            d.units = vectorcraft_doc::Unit::Millimeters;
+            Ok(())
+        })
+        .unwrap();
+        for x in [0.0, 50.0] {
+            let r = s.execute("shape.rectangle", &json!({"x": x, "y": 0, "width": 20, "height": 10})).unwrap()["id"].clone();
+            s.execute("select.set", &json!({"ids": [r]})).unwrap();
+            s.execute("object.rasterize", &json!({"ppi": 72})).unwrap();
+        }
+        let i = s.execute("document.info", &json!({})).unwrap();
+        assert_eq!((i["document"]["units"].as_str(), i["document"]["unitId"].as_str()), (Some("Millimeters"), Some("millimeters")));
+        let section = |id: &str| i["sections"].as_array().unwrap().iter().find(|s| s["id"] == id).unwrap()["rows"].as_array().unwrap().clone();
+        assert!(section("document").iter().any(|r| *r == json!(["Units", "Millimeters"])));
+        let embedded = section("embeddedImages");
+        let objects = i["imageObjects"].as_array().unwrap();
+        assert_eq!(objects.len(), 2, "{objects:?}");
+        for (o, r) in objects.iter().zip(&embedded) {
+            assert_eq!((o["linked"].clone(), o["file"].clone(), o["name"].clone()), (json!(false), Value::Null, r[0].clone()), "{o}");
+            assert_eq!(r[1], format!("{} × {} px", o["width"], o["height"]));
+        }
+        assert!(section("linkedImages").is_empty());
+    }
+
+    /// A `gradientObjects` entry's `kinds` gives the kind of each gradient listed by its kind
+    /// rather than by a swatch, and null for a swatch's name, even one that reads like a kind and
+    /// one an object's gradient of that kind shares; a type object's characters count as its own.
+    #[test]
+    fn gradient_kinds_tell_kinds_from_swatch_names() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 200, "height": 100})).unwrap();
+        let ramp = |kind: &str| json!({"kind": kind, "stops": [{"offset": 0, "color": "#000"}, {"offset": 1, "color": "#fff"}]});
+        s.execute("swatch.new", &json!({"name": "Radial gradient", "gradient": ramp("linear")})).unwrap();
+        let r = s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap()["id"].clone();
+        s.execute("paint.setFill", &json!({"ids": [r], "swatch": "Radial gradient"})).unwrap();
+        s.execute("paint.setStroke", &json!({"ids": [r], "gradient": ramp("conic")})).unwrap();
+        let t = s.execute("text.create", &json!({"x": 10, "y": 40, "text": "Hi"})).unwrap()["id"].clone();
+        s.execute("paint.setFill", &json!({"ids": [t], "gradient": ramp("diamond")})).unwrap();
+        // The swatch's name and a radial gradient's kind name are listed once, as the name.
+        let both = s.execute("shape.rectangle", &json!({"x": 20, "y": 0, "width": 10, "height": 10})).unwrap()["id"].clone();
+        s.execute("paint.setFill", &json!({"ids": [both], "swatch": "Radial gradient"})).unwrap();
+        s.execute("paint.setStroke", &json!({"ids": [both], "gradient": ramp("radial")})).unwrap();
+        let i = s.execute("document.info", &json!({})).unwrap();
+        let entry = |id: &Value| i["gradientObjects"].as_array().unwrap().iter().find(|e| e["id"] == *id).unwrap().clone();
+        assert_eq!(
+            (entry(&r)["gradients"].clone(), entry(&r)["kinds"].clone()),
+            (json!(["Radial gradient", "Conic gradient"]), json!([null, "conic"]))
+        );
+        assert_eq!((entry(&t)["gradients"].clone(), entry(&t)["kinds"].clone()), (json!(["Diamond gradient"]), json!(["diamond"])));
+        assert_eq!((entry(&both)["gradients"].clone(), entry(&both)["kinds"].clone()), (json!(["Radial gradient"]), json!([null])));
     }
 
     #[test]
diff --git a/crates/engine/src/cmd/draw2/commands.rs b/crates/engine/src/cmd/draw2/commands.rs
index 400e13baab..53949fdaf0 100644
--- a/crates/engine/src/cmd/draw2/commands.rs
+++ b/crates/engine/src/cmd/draw2/commands.rs
@@ -110,7 +110,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Smooth",
             [],
             None,
-            "{points: [[x,y]…], radius?: pt (12), fidelity?: pt (2.5)} smooth selected paths near the drag → {ids, before, after}",
+            "{points: [[x,y]…], radius?: pt (12), fidelity?: pt (2.5; kept within 0.000078125 and about 3195, the Smooth tool's 0.05 to 100 px at the highest and the lowest zoom: the tool sends its Fidelity in screen pixels divided by the zoom)} smooth selected paths near the drag → {ids, before, after}",
             has_selection,
             smooth_region
         ),
diff --git a/crates/engine/src/cmd/draw2/smooth.rs b/crates/engine/src/cmd/draw2/smooth.rs
index 660e5b8370..560990cec1 100644
--- a/crates/engine/src/cmd/draw2/smooth.rs
+++ b/crates/engine/src/cmd/draw2/smooth.rs
@@ -15,15 +15,27 @@ const SMOOTH_SPREAD: f64 = 1.0 / 3.0;
 
 /// The options the Smooth tool refits with: the path smoothed along its length by a Gaussian of
 /// spread `sigma` (none at 0), then refitted within `tol` of that and within twice the distance the
-/// smoothing moved it, keeping a corner only where the path turns back on itself.
-fn refit_options(tol: f64, sigma: f64) -> SimplifyOptions {
-    SimplifyOptions { tolerance: tol, corner_angle_deg: 179.0, straight_lines: false, smooth: sigma, smooth_moved_only: true }
+/// smoothing moved it, keeping a corner only where the path turns back on itself. `free` says whether
+/// the start and the end of the stretch refitted are ends of an open path, whose direction then
+/// follows the smoothed path within the reach rather than the first or last segment.
+fn refit_options(tol: f64, sigma: f64, free: [bool; 2]) -> SimplifyOptions {
+    SimplifyOptions {
+        tolerance: tol,
+        corner_angle_deg: 179.0,
+        straight_lines: false,
+        smooth: sigma,
+        smooth_moved_only: true,
+        free_start: free[0],
+        free_end: free[1],
+    }
 }
 
 /// Smooth and refit the anchors of an open run `a[lo..=hi]` keeping its end points and outer handles.
-fn refit_run(anchors: &[Anchor], tol: f64, sigma: f64) -> Vec<Anchor> {
+/// `free` says whether its first and last anchors are ends of an open path: the curve leaving or
+/// arriving at such an end can turn.
+fn refit_run(anchors: &[Anchor], tol: f64, sigma: f64, free: [bool; 2]) -> Vec<Anchor> {
     let piece = PathData::single(SubPath::new(anchors.to_vec(), false));
-    let fitted = po::simplify_with(&piece, &refit_options(tol, sigma));
+    let fitted = po::simplify_with(&piece, &refit_options(tol, sigma, free));
     let Some(mut out) = fitted.subpaths.into_iter().next().map(|s| s.anchors).filter(|a| a.len() >= 2) else { return anchors.to_vec() };
     let (f, l) = (anchors[0], anchors[anchors.len() - 1]);
     let last = out.len() - 1;
@@ -228,7 +240,7 @@ fn smooth_subpath(sp: &SubPath, pts: &[Point], radius: f64, share: usize, tol: f
     if sp.closed {
         let Some(k) = marked.iter().position(|m| !m) else {
             // Everything is in range: smooth the whole closed path, across its start too.
-            let f = po::simplify_with(&PathData::single(sp.clone()), &refit_options(tol, sigma));
+            let f = po::simplify_with(&PathData::single(sp.clone()), &refit_options(tol, sigma, [false; 2]));
             return f.subpaths.into_iter().next();
         };
         // Rotate so an untouched anchor comes first, duplicate it at the end and treat as open.
@@ -239,14 +251,14 @@ fn smooth_subpath(sp: &SubPath, pts: &[Point], radius: f64, share: usize, tol: f
         open.anchors.push(open.anchors[0]);
         m.push(false);
         open.closed = false;
-        let mut res = smooth_open(&open.anchors, &m, near, tol, sigma);
+        let mut res = smooth_open(&open.anchors, &m, near, tol, sigma, false);
         let l = res.pop()?;
         if let Some(r0) = res.first_mut() {
             r0.h_in = l.h_in;
         }
         return Some(SubPath::new(res, true));
     }
-    Some(SubPath::new(smooth_open(&sp.anchors, &marked, near, tol, sigma), false))
+    Some(SubPath::new(smooth_open(&sp.anchors, &marked, near, tol, sigma, true), false))
 }
 
 /// The segment `c`, which ends in the drag's reach (`near`) and starts outside it, split where it
@@ -278,8 +290,10 @@ fn split_at_reach(c: CubicBez, near: &dyn Fn(Point) -> bool) -> Option<(CubicBez
 /// `anchors` with each run of `marked` ones smoothed by a Gaussian of spread `sigma` and refitted
 /// within `tol`, together with the stretch of the segments leading into the run that is in the
 /// drag's reach (`near`): a short drag smooths what is under it, and the rest of a long segment next
-/// to it stays as it was (#1512).
-fn smooth_open(anchors: &[Anchor], marked: &[bool], near: &dyn Fn(Point) -> bool, tol: f64, sigma: f64) -> Vec<Anchor> {
+/// to it stays as it was (#1512). With `open`, `anchors` are an open path, and the curve at its first
+/// or last anchor turns with the smoothing when a run's refit reaches that anchor; a run's other ends,
+/// and those of the open run a closed path is cut into, keep their direction.
+fn smooth_open(anchors: &[Anchor], marked: &[bool], near: &dyn Fn(Point) -> bool, tol: f64, sigma: f64, open: bool) -> Vec<Anchor> {
     let n = anchors.len();
     let mut runs = vec![];
     let mut i = 0;
@@ -319,7 +333,8 @@ fn smooth_open(anchors: &[Anchor], marked: &[bool], near: &dyn Fn(Point) -> bool
             head = Some(Anchor { h_out: far.p1, ..*outer });
             *outer = Anchor::with_handles(far.p3, far.p2, reach.p1);
         }
-        let new = refit_run(&piece, tol, sigma);
+        let free = [open && lo == 0 && head.is_none(), open && hi == n - 1 && tail.is_none()];
+        let new = refit_run(&piece, tol, sigma, free);
         out.splice(lo..=hi, head.into_iter().chain(new).chain(tail));
     }
     out
@@ -329,7 +344,7 @@ pub(super) fn smooth_region(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "path.smoothRegion";
     let pts = points_param(p, "points", C)?;
     let radius = number_or(p, "radius", 12.0, C)?.max(0.0);
-    let tol = number_or(p, "fidelity", 2.5, C)?.clamp(vectorcraft_tools::draw2::SMOOTH_MIN_FIDELITY, 100.0);
+    let tol = number_or(p, "fidelity", 2.5, C)?.clamp(vectorcraft_tools::draw2::SMOOTH_MIN_TOLERANCE, vectorcraft_tools::draw2::SMOOTH_MAX_TOLERANCE);
     let sigma = radius * SMOOTH_SPREAD;
     let st = s.doc()?;
     let mut plan = vec![];
diff --git a/crates/engine/src/cmd/fileio/native.rs b/crates/engine/src/cmd/fileio/native.rs
index 4e2e9a85fd..382f06bc5f 100644
--- a/crates/engine/src/cmd/fileio/native.rs
+++ b/crates/engine/src/cmd/fileio/native.rs
@@ -133,7 +133,7 @@ pub const AI_OPTIONS: &[FormatOption] = &[
         name: "outlineText",
         ty: "boolean",
         default: "false",
-        description: "with aiVersion 7, type as its outlines instead of text (which apps reading the file set in the fonts it names: they need them installed); type 8-bit text can't hold (characters outside Windows Latin-1, vertical type, ruby, inline graphics, gradient or pattern fills) and type with rotated characters are always outlines",
+        description: "with aiVersion 7, type as its outlines instead of text (which apps reading the file set in the fonts it names: they need them installed); type 8-bit text can't hold (characters outside Windows Latin-1, vertical type, ruby, warichu, inline graphics, gradient or pattern fills) and type with rotated characters are always outlines",
     },
 ];
 
diff --git a/crates/engine/src/cmd/fileio/pdf.rs b/crates/engine/src/cmd/fileio/pdf.rs
index ec7d43472d..c834e653e4 100644
--- a/crates/engine/src/cmd/fileio/pdf.rs
+++ b/crates/engine/src/cmd/fileio/pdf.rs
@@ -128,7 +128,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Export PDF",
             [],
             None,
-            "{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), useArtboards?: true (false: one page, the bounds of the visible art, as document.export writes it; artboard, artboards and range are then ignored, Preserve Editing is left out (with a warning when it is on), and a document with no visible art is refused), standard?: none|pdfA2b|pdfX1a (CMYK, grey and spot colours only: colours and images converted to output.destination or the CMYK output intent, untagged; transparency flattened with flattenerPreset; PDF 1.3)|pdfX3 (colours ICC-tagged; transparency flattened; PDF 1.3)|pdfX4 (transparency and layers kept; colours ICC-tagged; PDF 1.6 at most) (PDF/X: a /GTS_PDFX output intent, by default the CMYK profile in effect, embedded; TrimBox, Trapped, GTS_PDFXVersion, title and dates; fonts embedded or outlined), compatibility?: 1.3 (no transparency: it is flattened with flattenerPreset, without the layers the file leaves out; images keep no see-through pixels)|1.4|1.5|1.6|1.7 (default)|2.0 (choosing a standard sets its version: 1.7 for pdfA2b, 1.6 for pdfX4, 1.3 for pdfX1a and pdfX3, which write 1.4 as 1.3 too; pdfA2b refuses 1.3; in pdfA2b files, and with longPagesInPoints: false, a page with a side longer than 14,400 pt keeps its size with a UserUnit from 1.6 on: 1.5 is then written as 1.6, with 1.5's encryption, and so is 1.4 in pdfA2b files, with a warning; PDF/X files and other 1.3 and 1.4 files write it in points, and 1.3 and 1.4 (pdfX1a and pdfX3 too) refuse a page past 32,767 pt whose size or art needs a real number past 32,767; a page whose short side is 3 pt or longer but would be under 3 units at that UserUnit gets a smaller one that keeps the short side at 3 units; a warning gives each such page's size), longPagesInPoints?: true (such a page is written at its size in points, without a UserUnit, at every version, and 1.5 stays 1.5, in files without a standard (PDF/A files keep the UserUnit); apps that keep to the limit cut it to 200 in; false: the UserUnit as above), preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, a standard refuses it), thumbnails? (each page drawn as a /Thumb image, 106 px on its long side), fastWebView? (a linearised file: the first page shows while the rest downloads; it stays linearised when encrypted), viewAfterSaving? (the app opens the written file), createLayers? (each layer and sublayer but template layers as a PDF layer, an optional content group listed under its layer's: hidden layers off, non-printing ones /PrintState /OFF, locked ones locked; needs 1.5 or later; they reopen as layers; choosing pdfX1a or pdfX3 turns it off; they refuse it), includeNonPrinting? (keep layers whose Print option is off; left out by default unless createLayers), flattenerPreset?: \"\" (High Resolution) | high | medium | low | a saved preset (flattener.presets.list): what PDF 1.3 files flatten transparency with, flattener?: {object.flattenTransparency options over it}, compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength} (black-and-white images), compressText?: true} (images above abovePpi are resampled to ppi; auto keeps JPEGs JPEG, the others lossless; JPEG needs opaque images; none, jpeg2000, CCITT and runLength are written as ZIP with a warning), marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25 (trim marks and targets), offset: 6 (pt from the artboard, at least the bleed)} (printer's marks in [Registration], every plate: trim marks, registration targets mid-side, CMYK/spot/black-tint colour bars on top, page information (title, artboard, date UTC) below), bleed?: {useDocument (the document's bleed, document.setup), top, bottom, left, right} (pt; art in the bleed is kept; a PDF/X file with no bleed on a side where the document's bleed has one comes back with a warning). Each page: TrimBox = artboard, BleedBox = artboard + bleed, MediaBox = that + the marks' room (art clipped to the BleedBox), output?: {conversion: none (default)|destination (every colour into the destination profile's model, CMYK or RGB, also colours of that model in another profile)|preserveNumbers (only colours of the other model and Lab; those in the destination's model keep their numbers) (grey stays grey; images are converted too, printer's marks are not), destination: profile name (edit.colorSettings lists them; default: the document's profile for its colour mode), profiles: none (device colours)|all|destination|taggedSource (documents assigned a profile: edit.assignProfile) (ICC-based colours: CMYK with the destination or document CMYK profile, RGB as sRGB, grey with the sRGB tone curve; PDF/A, pdfX3 and pdfX4 always, whatever profiles says), outputIntent: profile name (embedded as the catalog's /GTS_PDFX output intent; a name that isn't a profile is only named, which pdfX1a and pdfX3 allow only with a registry and pdfX4 refuses; pdfX1a needs a CMYK one), outputCondition, outputConditionId (default: outputIntent), registry, trapped (/Trapped /True; /False when an output intent is written)} (PDF/A files keep their own output intent), advanced?: {fontSubsetPercent: 100 (below 100 is accepted with a warning: fonts are always embedded as subsets), outlineText: false (type as real, selectable and searchable text in embedded subset fonts with a ToUnicode map; fonts whose licence forbids embedding, or allows only whole fonts, stay outlines with a warning; true: every glyph as an outline), overprint: preserve (overprinting fills and strokes set /OP /op true, /OPM 1; white ones knock out with document.setup discardWhiteOverprint)|discard (they knock out)}, security?: {openPassword, permissionsPassword, printing: none|low|high, changes: none|pages|forms|comments|any, copy, screenReader, plaintextMetadata}, acknowledgeLoss?: bool (write over the file the document was read from although reading it left things out), format?: \"pdf\"} → {path, bytes, warnings}; no path → {dataBase64, bytes, warnings}. The options apply over the preset (null keeps its value); options accepted but not applied yet come back as warnings; a standard with a PDF version it doesn't allow and a password with a standard are refused, and so is a PDF/X file that would still break its standard (transparency the flattener left, RGB in pdfX1a, a font not embedded) or a PDF 1.3 file with transparency left. document.export {format: pdf} takes the same options. A key PDF doesn't take, and an unknown key inside one of the option objects, are refused",
+            "{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), useArtboards?: true (false: one page, the bounds of the visible art, as document.export writes it; artboard, artboards and range are then ignored, Preserve Editing is left out (with a warning when it is on), and a document with no visible art is refused), standard?: none|pdfA2b|pdfX1a (CMYK, grey and spot colours only: colours and images converted to output.destination or the CMYK output intent, untagged; transparency flattened with flattenerPreset; PDF 1.3)|pdfX3 (colours ICC-tagged; transparency flattened; PDF 1.3)|pdfX4 (transparency and layers kept; colours ICC-tagged; PDF 1.6 at most) (PDF/X: a /GTS_PDFX output intent, by default the CMYK profile in effect, embedded; TrimBox, Trapped, GTS_PDFXVersion, title and dates; fonts embedded or outlined), compatibility?: 1.3 (no transparency: it is flattened with flattenerPreset, without the layers the file leaves out; images keep no see-through pixels)|1.4|1.5|1.6|1.7 (default)|2.0 (choosing a standard sets its version: 1.7 for pdfA2b, 1.6 for pdfX4, 1.3 for pdfX1a and pdfX3, which write 1.4 as 1.3 too; pdfA2b refuses 1.3; in pdfA2b files, and with longPagesInPoints: false, a page with a side longer than 14,400 pt keeps its size with a UserUnit from 1.6 on: 1.5 is then written as 1.6, with 1.5's encryption, and so is 1.4 in pdfA2b files, with a warning; PDF/X files and other 1.3 and 1.4 files write it in points, and 1.3 and 1.4 (pdfX1a and pdfX3 too) refuse a page past 32,767 pt whose size or art needs a real number past 32,767; a page whose short side is 3 pt or longer but would be under 3 units at that UserUnit gets a smaller one that keeps the short side at 3 units; a warning gives each such page's size), longPagesInPoints?: true (such a page is written at its size in points, without a UserUnit, at every version, and 1.5 stays 1.5, in files without a standard (PDF/A files keep the UserUnit); apps that keep to the limit cut it to 200 in; false: the UserUnit as above, with a warning that names this option), preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, a standard refuses it), thumbnails? (each page drawn as a /Thumb image, 106 px on its long side), fastWebView? (a linearised file: the first page shows while the rest downloads; it stays linearised when encrypted), viewAfterSaving? (the app opens the written file), createLayers? (each layer and sublayer but template layers as a PDF layer, an optional content group listed under its layer's: hidden layers off, non-printing ones /PrintState /OFF, locked ones locked; needs 1.5 or later; they reopen as layers; choosing pdfX1a or pdfX3 turns it off; they refuse it), includeNonPrinting? (keep layers whose Print option is off; left out by default unless createLayers), flattenerPreset?: \"\" (High Resolution) | high | medium | low | a saved preset (flattener.presets.list): what PDF 1.3 files flatten transparency with, flattener?: {object.flattenTransparency options over it}, compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength} (black-and-white images), compressText?: true} (images above abovePpi are resampled to ppi; auto keeps JPEGs JPEG, the others lossless; JPEG needs opaque images; none, jpeg2000, CCITT and runLength are written as ZIP with a warning), marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25 (trim marks and targets), offset: 6 (pt from the artboard, at least the bleed)} (printer's marks in [Registration], every plate: trim marks, registration targets mid-side, CMYK/spot/black-tint colour bars on top, page information (title, artboard, date UTC) below), bleed?: {useDocument (the document's bleed, document.setup), top, bottom, left, right} (pt; art in the bleed is kept; a PDF/X file with no bleed on a side where the document's bleed has one comes back with a warning). Each page: TrimBox = artboard, BleedBox = artboard + bleed, MediaBox = that + the marks' room (art clipped to the BleedBox), output?: {conversion: none (default)|destination (every colour into the destination profile's model, CMYK or RGB, also colours of that model in another profile)|preserveNumbers (only colours of the other model and Lab; those in the destination's model keep their numbers) (grey stays grey; images are converted too, printer's marks are not), destination: profile name (edit.colorSettings lists them; default: the document's profile for its colour mode), profiles: none (device colours)|all|destination|taggedSource (documents assigned a profile: edit.assignProfile) (ICC-based colours: CMYK with the destination or document CMYK profile, RGB as sRGB, grey with the sRGB tone curve; PDF/A, pdfX3 and pdfX4 always, whatever profiles says), outputIntent: profile name (embedded as the catalog's /GTS_PDFX output intent; a name that isn't a profile is only named, which pdfX1a and pdfX3 allow only with a registry and pdfX4 refuses; pdfX1a needs a CMYK one), outputCondition, outputConditionId (default: outputIntent), registry, trapped (/Trapped /True; /False when an output intent is written)} (PDF/A files keep their own output intent), advanced?: {fontSubsetPercent: 100 (below 100 is accepted with a warning: fonts are always embedded as subsets), outlineText: false (type as real, selectable and searchable text in embedded subset fonts with a ToUnicode map; fonts whose licence forbids embedding, or allows only whole fonts, stay outlines with a warning; true: every glyph as an outline), overprint: preserve (overprinting fills and strokes set /OP /op true, /OPM 1; white ones knock out with document.setup discardWhiteOverprint)|discard (they knock out)}, security?: {openPassword, permissionsPassword, printing: none|low|high, changes: none|pages|forms|comments|any, copy, screenReader, plaintextMetadata}, acknowledgeLoss?: bool (write over the file the document was read from although reading it left things out), format?: \"pdf\"} → {path, bytes, warnings}; no path → {dataBase64, bytes, warnings}. The options apply over the preset (null keeps its value); options accepted but not applied yet come back as warnings; a standard with a PDF version it doesn't allow and a password with a standard are refused, and so is a PDF/X file that would still break its standard (transparency the flattener left, RGB in pdfX1a, a font not embedded) or a PDF 1.3 file with transparency left. document.export {format: pdf} takes the same options. A key PDF doesn't take, and an unknown key inside one of the option objects, are refused",
             has_doc,
             export_pdf
         ),
@@ -305,6 +305,15 @@ pub(super) fn encode_art_page(cmd: &str, doc: &Document, p: &Value) -> Result<Op
 /// ([`vectorcraft_pdf::PdfSettings::leaves_out_bleed`]).
 pub const BLEED_LEFT_OUT: &str = "the document sets a bleed that this PDF/X file leaves out: turn on Use document bleed settings";
 
+/// The end of the writer's warning for a page longer than 14,400 pt written with a `UserUnit`
+/// above 1.
+const SHOWN_SMALLER: &str = "so apps that ignore UserUnit show it that many times smaller";
+
+/// What a PDF without a standard adds to the warning that ends in [`SHOWN_SMALLER`]: the option
+/// that writes such a page in points. PDF/A files keep the `UserUnit` with the option on, and
+/// `.ai` saves don't have the option.
+pub const LONG_PAGES_IN_POINTS: &str = ": turn on Write pages longer than 200 in at full size in points";
+
 /// Encode `doc` as PDF with the options in `p` → (bytes, notes). Raster effects are rendered
 /// to images at the document's raster effects resolution. Preserve Editing embeds `doc` itself
 /// when the PDF has every artboard (a PDF of some reopens as just those).
@@ -319,6 +328,11 @@ pub(super) fn encode_at(cmd: &str, doc: &Document, p: &Value, modified: Option<i
     let mut notes: Vec<Note> = placed.into_iter().map(Note::loss).collect();
     let (bytes, drawn) = encode_carrying_at(cmd, &full, p, modified, || Ok(vectorcraft_format::save(doc, false)), || Ok(None))?;
     notes.extend(drawn);
+    if notes.iter().any(|n| n.text.ends_with(SHOWN_SMALLER)) && options(cmd, &full, p)?.settings.standard == Standard::None {
+        for n in notes.iter_mut().filter(|n| n.text.ends_with(SHOWN_SMALLER)) {
+            n.text.push_str(LONG_PAGES_IN_POINTS);
+        }
+    }
     notes.extend(overflow_warning(cmd, &full, p)?.map(Note::loss));
     Ok((bytes, notes))
 }
diff --git a/crates/engine/src/cmd/fileio/tests_pdf.rs b/crates/engine/src/cmd/fileio/tests_pdf.rs
index 91fe9701e7..bd52fe71c7 100644
--- a/crates/engine/src/cmd/fileio/tests_pdf.rs
+++ b/crates/engine/src/cmd/fileio/tests_pdf.rs
@@ -103,6 +103,70 @@ fn use_artboards_false_writes_one_page_of_the_arts_bounds() {
     }
 }
 
+/// In a PDF without a standard, the warning for a page longer than 14,400 pt written with a
+/// `UserUnit` above 1 names "Write pages longer than 200 in at full size in points": at PDF 1.5
+/// (written as 1.6) and later, through `document.exportPdf`, `document.export`, a page of the
+/// art's bounds and the Summary's export, with one such warning per page. PDF/A files and `.ai`
+/// saves keep the warning without the option's name. Pages written in points (the option on, PDF
+/// 1.4, PDF/X, a page too narrow for a `UserUnit` above 1) and a page too long and narrow for
+/// 14,400 units have other warnings, which don't name it.
+#[test]
+fn a_page_with_a_user_unit_names_the_option_that_writes_it_in_points() {
+    use super::pdf::LONG_PAGES_IN_POINTS;
+    const SMALLER: &str = "so apps that ignore UserUnit show it that many times smaller";
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 20_000, "height": 1_000})).unwrap();
+    s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 19_000, "height": 500})).unwrap();
+    let warnings = |v: &Value| -> Vec<String> {
+        v["warnings"].as_array().unwrap().iter().filter_map(|w| w.as_str()).filter(|w| w.contains("UserUnit")).map(str::to_string).collect()
+    };
+    let named = |v: &Value| warnings(v).iter().any(|w| w.contains(LONG_PAGES_IN_POINTS));
+    for p in [
+        json!({"longPagesInPoints": false}),
+        json!({"longPagesInPoints": false, "compatibility": "1.5"}),
+        json!({"longPagesInPoints": false, "compatibility": "2.0"}),
+        json!({"longPagesInPoints": false, "useArtboards": false}),
+    ] {
+        let mut q = p.clone();
+        q["includeDocument"] = json!(true);
+        for v in [export(&mut s, p.clone()), s.execute("document.export", &as_export(&p)).unwrap(), s.execute("document.pdfSettings", &q).unwrap()] {
+            let page: Vec<String> = warnings(&v).into_iter().filter(|w| w.starts_with("the page of artboard")).collect();
+            assert_eq!(page.len(), 1, "{p}: {v}");
+            assert!(page[0].ends_with(&format!("{SMALLER}{LONG_PAGES_IN_POINTS}")), "{p}: {page:?}");
+            assert_eq!(warnings(&v).iter().filter(|w| w.contains("apps that ignore UserUnit")).count(), 1, "{p}: {v}");
+        }
+    }
+    for p in [
+        json!({"longPagesInPoints": true}),
+        json!({"longPagesInPoints": false, "compatibility": "1.4"}),
+        json!({"longPagesInPoints": false, "preset": "PDF/X-4:2010"}),
+    ] {
+        assert!(!named(&export(&mut s, p.clone())), "{p}");
+    }
+    for p in
+        [json!({"longPagesInPoints": false, "standard": "pdfA2b"}), json!({"longPagesInPoints": false, "standard": "pdfA2b", "compatibility": "1.4"})]
+    {
+        let v = export(&mut s, p.clone());
+        assert!(warnings(&v).iter().any(|w| w.ends_with(SMALLER)) && !named(&v), "{p}: {v}");
+    }
+    let ai = s.execute("document.export", &json!({"format": "ai", "longPagesInPoints": false})).unwrap();
+    assert!(warnings(&ai).iter().any(|w| w.ends_with(SMALLER)) && !named(&ai), "{ai}");
+    // The art's bounds are within 14,400 pt.
+    s.execute("select.all", &json!({})).unwrap();
+    s.execute("edit.clear", &json!({})).unwrap();
+    s.execute("shape.rectangle", &json!({"x": 100, "y": 100, "width": 500, "height": 500})).unwrap();
+    assert!(!named(&export(&mut s, json!({"longPagesInPoints": false, "useArtboards": false}))));
+    // A page 3 pt high keeps a UserUnit of 1, so it is written in points either way; a page
+    // 85,040 × 17 pt gets a UserUnit above 1 that leaves its long side past 14,400 units.
+    for (w, h) in [(20_000, 3), (85_040, 17)] {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": w, "height": h})).unwrap();
+        s.execute("shape.rectangle", &json!({"x": 100, "y": 0, "width": w - 1_000, "height": h})).unwrap();
+        let v = export(&mut s, json!({"longPagesInPoints": false}));
+        assert!(!named(&v), "{w} × {h}: {v}");
+    }
+}
+
 /// A PDF of the art's bounds carries no Preserve Editing data, through `document.exportPdf`,
 /// `document.export` and the Summary's export in memory, and says so in a warning: reopened, its
 /// editing data would replace the document's artboards with the one around the art. A PDF of the
diff --git a/crates/engine/src/cmd/globaledit.rs b/crates/engine/src/cmd/globaledit.rs
index 98f53b102e..f454d7133b 100644
--- a/crates/engine/src/cmd/globaledit.rs
+++ b/crates/engine/src/cmd/globaledit.rs
@@ -49,6 +49,10 @@
 //!   member with another order, and any other change to the list (items moved, or several added
 //!   or removed at once), takes the model's whole list of fills and strokes.
 //!
+//! A path directly in a graph series that takes an edit from another member (a graph's paths are
+//! members only while the graph is isolated) also has what changed stored on its graph, so that
+//! every path of the series takes it when the graph is drawn again (docs/mcp.md).
+//!
 //! Members that are hidden or locked at the time are left as they are. An edit that would take any
 //! member past the canvas (beyond [`vectorcraft_doc::MAX_COORD`]) is refused whole, as one that
 //! takes the selection there is. Whenever the document is put back (Undo, Redo, a cancelled drag
@@ -432,16 +436,24 @@ fn can_toggle(s: &Session) -> std::result::Result<(), String> {
     let [id] = st.selection.objects.as_slice() else {
         return Err(if st.selection.is_empty() { "nothing selected" } else { "select one object" }.into());
     };
-    // A group's contents are checked when Global Edit starts: measuring them here would walk
-    // every object in it each time the menu or the Properties panel asks. Other objects are
-    // measured ([`supported`]), not reduced to their form: the Control bar asks every frame.
-    match st.doc.node(*id) {
-        Some(n) if n.extras().mask.is_none() && plain_group(n) => Ok(()),
-        Some(n) if supported(n) => Ok(()),
-        _ => Err(UNSUPPORTED.into()),
-    }
+    // The object, a group's contents included, is measured ([`supported`]), not reduced to its
+    // form, and the answer is kept until the document's revision moves: the Control bar asks
+    // every frame, and a group's walk takes time with the anchors in it.
+    let ok = match st.global_edit_support.get() {
+        Some((rev, key, ok)) if rev == st.revision && key == *id => ok,
+        _ => {
+            let ok = st.doc.node(*id).is_some_and(supported);
+            st.global_edit_support.set(Some((st.revision, *id, ok)));
+            ok
+        }
+    };
+    if ok { Ok(()) } else { Err(UNSUPPORTED.into()) }
 }
 
+/// [`can_toggle`]'s answer for the one selected object: the revision and the object it was found
+/// for, and whether Global Edit supports it.
+pub type SupportCache = std::cell::Cell<Option<(u64, NodeId, bool)>>;
+
 fn toggle(s: &mut Session, p: &Value) -> Result<Value> {
     if s.doc()?.global_edit.is_some() {
         let st = s.doc_mut()?;
@@ -778,9 +790,22 @@ pub(crate) fn propagate(before: &Document, d: &mut Document, ge: &GlobalEdit, se
         }
         super::object::keep_compound_aligned(d, *id, Scaling::default());
     }
+    keep_series_changes(before, d, &edited);
     edited
 }
 
+/// Store on their graphs what the members `edited`, and the objects in them, took on the paths directly in a graph
+/// series, for the graph's next redraw. The edited member is left to the edit's own command.
+fn keep_series_changes(before: &Document, d: &mut Document, edited: &[NodeId]) {
+    let mut taken = vec![];
+    for id in edited {
+        if let Some(n) = d.node(*id) {
+            n.walk(&mut |c: &Node| taken.push(c.id));
+        }
+    }
+    super::appearance::capture_series_changes(before, d, &taken);
+}
+
 /// The outlines of the members of the active document's Global Edit that are not selected, hold
 /// no selected object and sit inside no selected object, in their layer's colour: the canvas
 /// highlights them while Global Edit is on. While it is off, with one supported object selected,
@@ -989,8 +1014,7 @@ mod tests {
                 continue;
             }
             asked += 1;
-            let today = n.extras().mask.is_none() && plain_group(&n) || by_form(&n);
-            assert_eq!(can_toggle(&s).is_ok(), today, "seed {seed}");
+            assert_eq!(can_toggle(&s).is_ok(), by_form(&n), "seed {seed}");
             match s.execute(C, &json!({})) {
                 Ok(_) => {
                     assert!(by_form(&n), "seed {seed}");
diff --git a/crates/engine/src/cmd/graph/tests.rs b/crates/engine/src/cmd/graph/tests.rs
index a4bcb7e637..1f128009f8 100644
--- a/crates/engine/src/cmd/graph/tests.rs
+++ b/crates/engine/src/cmd/graph/tests.rs
@@ -572,6 +572,124 @@ fn an_object_opacity_a_series_mark_already_shows_replaces_the_kept_opacity() {
     assert!(spec(&s, id).series_paints.iter().all(|p| p.opacity.is_none()));
 }
 
+/// Randomize Opacity on marks of one series stores the opacity of the frontmost of them on the graph in the same undo
+/// step, and every mark of the series has it when the graph is drawn again.
+#[test]
+fn a_random_opacity_on_series_marks_survives_regeneration() {
+    let (mut s, id, _, marks) = column_marks();
+    s.execute("addon.arrange.randomizeOpacity", &json!({"ids": [marks[1].0, marks[0].0], "min": 30, "max": 60, "seed": 7})).unwrap();
+    let front = s.doc().unwrap().doc.node(marks[1]).unwrap().opacity;
+    assert!(front < 1.0);
+    assert_eq!(spec(&s, id).series_paints[0].opacity, Some(front));
+    s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
+    assert!(transparency_of(&s, id, 0).iter().all(|t| t.0 == front), "{:?}", transparency_of(&s, id, 0));
+    assert!(transparency_of(&s, id, 1).iter().all(|t| t.0 == 1.0), "{:?}", transparency_of(&s, id, 1));
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert!(spec(&s, id).series_paints.is_empty(), "undo takes back the opacities and what the graph stored");
+}
+
+/// Sort Objects giving series marks new opacities stores the opacity of the frontmost of them on the graph, in place of
+/// the one another mark left there.
+#[test]
+fn an_opacity_sort_objects_gives_series_marks_survives_regeneration() {
+    let (mut s, id, _, marks) = column_marks();
+    s.execute("object.setProps", &json!({"id": marks[2].0, "opacity": 30})).unwrap();
+    assert_eq!(spec(&s, id).series_paints[0].opacity, Some(0.3));
+    // From left to right the three columns get 30%, 65% and 100%: the frontmost, the rightmost, is fully opaque.
+    let ids = [marks[0].0, marks[1].0, marks[2].0];
+    s.execute("addon.arrange.sort", &json!({"ids": ids, "by": "x", "apply": "opacity", "distribute": true})).unwrap();
+    let opacities: Vec<f32> = marks[..3].iter().map(|m| s.doc().unwrap().doc.node(*m).unwrap().opacity).collect();
+    assert_eq!(opacities, [0.3, 0.65, 1.0]);
+    assert_eq!(spec(&s, id).series_paints[0].opacity, None);
+    s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
+    assert!(transparency_of(&s, id, 0).iter().all(|t| t.0 == 1.0), "{:?}", transparency_of(&s, id, 0));
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(spec(&s, id).series_paints[0].opacity, Some(0.3), "undo takes back the sort and what the graph stored");
+}
+
+/// Sort Objects stores the opacity of the frontmost series mark whose opacity it changes: a mark in front that keeps its
+/// opacity leaves the stored value to the marks it changed.
+#[test]
+fn an_opacity_sort_objects_stores_the_frontmost_mark_it_changes() {
+    let (mut s, id, _, marks) = column_marks();
+    s.execute("object.setProps", &json!({"id": marks[0].0, "opacity": 60})).unwrap();
+    s.execute("object.setProps", &json!({"id": marks[1].0, "opacity": 30})).unwrap();
+    assert_eq!(spec(&s, id).series_paints[0].opacity, Some(0.3));
+    // From left to right the columns trade 60%, 30% and 100% for 30%, 60% and 100%: the frontmost keeps its 100%.
+    let ids = [marks[0].0, marks[1].0, marks[2].0];
+    s.execute("addon.arrange.sort", &json!({"ids": ids, "by": "x", "apply": "opacity"})).unwrap();
+    let opacities: Vec<f32> = marks[..3].iter().map(|m| s.doc().unwrap().doc.node(*m).unwrap().opacity).collect();
+    assert_eq!(opacities, [0.3, 0.6, 1.0]);
+    assert_eq!(spec(&s, id).series_paints[0].opacity, Some(0.6));
+}
+
+/// An object opacity, blend mode, fill, stroke and weight that Global Edit gives a mark of another series from the mark
+/// that was edited are stored on the graph for that series in the same undo step, and every mark of the series has them
+/// when the graph is drawn again.
+#[test]
+fn what_global_edit_gives_series_marks_survives_regeneration() {
+    let (mut s, id, _, _) = column_marks();
+    // Equal values: the first column of each series has the same shape.
+    s.execute("graph.setData", &json!({"rows": [[3, 3], [5, 2]]})).unwrap();
+    let n = s.doc().unwrap().doc.node(id).unwrap().clone();
+    let (first, other) = (series(&n, 0).children().unwrap()[0].id, series(&n, 1).children().unwrap()[0].id);
+    s.execute("object.isolate", &json!({"id": id.0})).unwrap();
+    s.execute("select.set", &json!({"ids": [first.0]})).unwrap();
+    let r = s.execute("select.globalEdit", &json!({})).unwrap();
+    assert!(r["ids"].as_array().unwrap().contains(&json!(other.0)), "{r}");
+    let steps = s.doc().unwrap().history.undo.len();
+    s.execute("transparency.set", &json!({"ids": [first.0], "opacity": 40, "blend": "multiply"})).unwrap();
+    s.execute("paint.setFill", &json!({"ids": [first.0], "color": "#e8573f"})).unwrap();
+    s.execute("paint.setStroke", &json!({"ids": [first.0], "color": "#1f4e9c"})).unwrap();
+    s.execute("stroke.set", &json!({"ids": [first.0], "weight": 5})).unwrap();
+    let mark = s.doc().unwrap().doc.node(other).unwrap().clone();
+    assert_eq!((mark.opacity, mark.blend), (0.4, BlendMode::Multiply), "Global Edit reaches the other series' mark");
+    let kept = spec(&s, id).series_paints[1].clone();
+    assert_eq!((kept.opacity, kept.blend), (Some(0.4), Some(BlendMode::Multiply)));
+    assert_eq!(kept.fill, Some(mark.appearance.fill_paint()));
+    assert_eq!((kept.stroke, kept.stroke_width), (Some(mark.appearance.stroke_paint()), Some(5.0)));
+    s.execute("object.exitIsolation", &json!({})).unwrap();
+    s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
+    let normal = BlendMode::Normal;
+    assert!(transparency_of(&s, id, 1).iter().all(|t| *t == (0.4, BlendMode::Multiply, normal, normal)), "{:?}", transparency_of(&s, id, 1));
+    let n = s.doc().unwrap().doc.node(id).unwrap().clone();
+    assert!(series(&n, 1).children().unwrap().iter().all(|m| m.appearance.fill_paint() == mark.appearance.fill_paint()));
+    while s.doc().unwrap().history.undo.len() > steps {
+        s.execute("edit.undo", &json!({})).unwrap();
+    }
+    assert!(spec(&s, id).series_paints.iter().all(|p| *p == vectorcraft_doc::SeriesPaint::default()), "{:?}", spec(&s, id).series_paints);
+}
+
+/// With a whole series group picked and Global Edit on, the other series groups of the same form take the edit of its
+/// marks, and the graph stores it for their series too.
+#[test]
+fn what_global_edit_gives_the_marks_of_another_series_group_survives_regeneration() {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({})).unwrap();
+    // Series without names draw no legend, so each series group holds only its columns, laid out like the other's.
+    let csv = ",,\nQ1,3,3\nQ2,5,5";
+    let made = s.execute("graph.create", &json!({"type": "column", "x": 100, "y": 100, "width": 300, "height": 200, "csv": csv})).unwrap();
+    let id = NodeId(made["id"].as_u64().unwrap());
+    let n = s.doc().unwrap().doc.node(id).unwrap().clone();
+    let (first, other) = (series(&n, 0).clone(), series(&n, 1).id);
+    s.execute("object.isolate", &json!({"id": id.0})).unwrap();
+    s.execute("select.set", &json!({"ids": [first.id.0]})).unwrap();
+    let r = s.execute("select.globalEdit", &json!({})).unwrap();
+    assert!(r["ids"].as_array().unwrap().contains(&json!(other.0)), "{r}");
+    let marks: Vec<u64> = first.children().unwrap().iter().map(|m| m.id.0).collect();
+    s.execute("paint.setFill", &json!({"ids": marks, "color": "#e8573f"})).unwrap();
+    let n = s.doc().unwrap().doc.node(id).unwrap().clone();
+    let given = series(&n, 1).children().unwrap()[0].appearance.fill_paint();
+    assert_eq!(given, series(&n, 0).children().unwrap()[0].appearance.fill_paint(), "Global Edit reaches the other group");
+    assert_eq!(spec(&s, id).series_paints[1].fill, Some(given.clone()));
+    s.execute("object.exitIsolation", &json!({})).unwrap();
+    s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
+    let n = s.doc().unwrap().doc.node(id).unwrap().clone();
+    assert!(series(&n, 1).children().unwrap().iter().all(|m| m.appearance.fill_paint() == given));
+}
+
 /// A blend mode set on the top fill or stroke row of one series mark is kept by the graph and drawn on every mark of
 /// the series again; Normal forgets it.
 #[test]
diff --git a/crates/engine/src/cmd/layer.rs b/crates/engine/src/cmd/layer.rs
index f589ea62da..83f27cdd61 100644
--- a/crates/engine/src/cmd/layer.rs
+++ b/crates/engine/src/cmd/layer.rs
@@ -994,20 +994,53 @@ fn artboard_delete(s: &mut Session, p: &Value) -> Result<Value> {
     ok()
 }
 
-/// Delete artboards `indices` (sorted) of `d` with their guides; at least one must be left.
-fn remove_artboards(d: &mut Document, sel: &mut vectorcraft_doc::Selection, indices: &[usize]) -> Result<()> {
+/// Delete artboards `indices` (sorted, each once) of `d` with their guides; at least one must be
+/// left. The other artboards keep their order, no later artboard takes a deleted one's id, and
+/// `sel` forgets the deleted guides. One walk over the artboards and one over the ruler guides,
+/// however many go. Delete Artboard, Delete Empty Artboards, Cut Artboard and Artwork Cleanup's
+/// Empty Artboards.
+pub(crate) fn remove_artboards(d: &mut Document, sel: &mut vectorcraft_doc::Selection, indices: &[usize]) -> Result<()> {
+    if indices.iter().any(|i| *i >= d.artboards.len()) {
+        return Err(EngineError::Other("no such artboard".into()));
+    }
     if indices.len() >= d.artboards.len() {
         return Err(EngineError::Other("a document needs at least one 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.retire_artboard_id(id);
-        d.retain_guides(sel, |g| g.artboard != Some(id));
+    if indices.is_empty() {
+        return Ok(());
     }
+    let mut gone: HashSet<u32> = HashSet::with_capacity(indices.len());
+    let mut i = 0;
+    d.artboards.retain(|a| {
+        let keep = indices.binary_search(&i).is_err();
+        i += 1;
+        if !keep {
+            gone.insert(a.id);
+        }
+        keep
+    });
+    count_artboard_pass();
+    for &id in &gone {
+        d.retire_artboard_id(id);
+    }
+    d.retain_guides(sel, |g| !g.artboard.is_some_and(|a| gone.contains(&a)));
+    count_artboard_pass();
     Ok(())
 }
 
+#[cfg(test)]
+thread_local! {
+    /// Tests: how many walks [`remove_artboards`] made over the artboards and the ruler guides on
+    /// this thread.
+    pub(crate) static ARTBOARD_PASSES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+/// Tests: count one walk over the artboards or the ruler guides.
+fn count_artboard_pass() {
+    #[cfg(test)]
+    ARTBOARD_PASSES.set(ARTBOARD_PASSES.get() + 1);
+}
+
 /// The artboards Delete Empty Artboards deletes: those with no artwork
 /// ([`Document::artboard_has_art`]) that aren't locked, but artboard 1 when every artboard is one
 /// of them (a document keeps one, as Delete Artboards keeps artboard 1).
diff --git a/crates/engine/src/cmd/object/shape.rs b/crates/engine/src/cmd/object/shape.rs
index 2b32c59980..e3909c5935 100644
--- a/crates/engine/src/cmd/object/shape.rs
+++ b/crates/engine/src/cmd/object/shape.rs
@@ -135,9 +135,7 @@ pub(super) fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
                 .map_err(|_| bad("object.setLiveShape", format!("`kind` must be \"round\", \"invertedRound\" or \"chamfer\", not {v}")))
         })
         .transpose()?;
-    let radius = p.get("radius").and_then(Value::as_f64);
     let relative_radii = p.get("relativeRadii").and_then(Value::as_bool);
-    let sides = p.get("sides").and_then(Value::as_u64);
     // A number that must be `what` (None when absent).
     let number = |k: &str, ok: fn(f64) -> bool, what: &str| -> Result<Option<f64>> {
         match p.get(k) {
@@ -151,6 +149,9 @@ pub(super) fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
     };
     let angle = |k: &str| Ok::<_, EngineError>(number(k, |_| true, "an angle in degrees")?.map(|a| a.rem_euclid(360.0)));
     let length = |k: &str| number(k, |x| x > 0.0 && x <= crate::MAX_COORD, "a length in points above 0");
+    let radius = number("radius", |r| r >= 0.0, "a radius of 0 or more")?;
+    // A polygon's side count: a whole number from 3 to 1000.
+    let sides = number("sides", |n| n.fract() == 0.0 && (3.0..=1000.0).contains(&n), "a whole number from 3 to 1000")?.map(|n| n as u64);
     // An ellipse's pie (Ellipse Properties: Pie Start and End Angle, degrees; Invert Pie swaps them).
     let (pie_start, pie_end) = (angle("pieStart")?, angle("pieEnd")?);
     let invert = p.get("invertPie").and_then(Value::as_bool) == Some(true);
diff --git a/crates/engine/src/cmd/panelcmds.rs b/crates/engine/src/cmd/panelcmds.rs
index 5910435a75..f9c4b10049 100644
--- a/crates/engine/src/cmd/panelcmds.rs
+++ b/crates/engine/src/cmd/panelcmds.rs
@@ -67,7 +67,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Character / Paragraph",
             [],
             None,
-            "{ids?|id?, kerning?: 1/1000 em|\"auto\"|\"optical\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg counter-clockwise (0: upright), underline?, strikethrough?, allCaps?, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), antiAlias?: \"none\"|\"sharp\"|\"crisp\"|\"strong\" (Character panel › Anti-aliasing Method, how the type's edges are drawn as pixels; it sets each targeted type object, with or without a range; each frame of a thread keeps its own method; graph labels keep it for every label of their kind when the graph is drawn again; new type: \"sharp\"), leftIndent?, rightIndent?, firstLineIndent?, spaceBefore?, spaceAfter?: pt (±1296), list?: \"none\"|\"bullet\"|\"number\", bullet?: \"none\"|\"dot\"|\"dash\"|\"circle\"|\"square\", number?: \"none\"|\"arabic\"|\"upperLetters\"|\"lowerLetters\"|\"upperRoman\"|\"lowerRoman\"|\"twoDigits\"|\"threeDigits\", listAlign?: \"left\"|\"right\", listLevel?: 1..9 (Paragraph panel › Bullets and Numbered List: each paragraph of a list starts with its marker, drawn in the font, size and color of the paragraph's first character, and its text starts at the next tab stop after the marker, the left indent counting as a stop; a bulleted list's marker is its bullet, and a numbered list's is the paragraph's number and a period: 1, 2, 3; A to Z, then AA, BB; a to z, then aa, bb; I, II, III; i, ii, iii; 01 to 99, then 100; 001 to 999, then 1000; letters and roman numerals past 3999 in Arabic digits; the numbers count the story's numbered paragraphs, its threaded frames included, from 1 after a paragraph in no list, and an empty or bulleted paragraph is not counted; list \"bullet\" keeps a list's bullet, else a dot, and list \"number\" keeps a numbered list's style, else arabic; without list, a number style makes a numbered list and a bullet makes a bulleted one; \"none\" in any of the three turns the list off; a paragraph that joins a list with left and first-line indents of 0 gets 18 and -18 unless the call sets an indent; a horizontal right-to-left list paragraph has its indents mirrored, measured from the right; listAlign \"right\" (Bullets and Numbering…'s Alignment) puts the marker against the text, and \"left\" (the default) puts it at the first line's start, the text starting at the same place with either; it sets the paragraphs that are in a list or that the call puts in one, and a list keeps it when it changes between bullets and numbers; listLevel (Tab and Shift+Tab at the start of a list paragraph, Bullets and Numbering…'s Level) is a whole number from 1 to 9 that sets the paragraphs in a list or that the call puts in one, a list keeping it when it changes between bullets and numbers, and a list turned on without listLevel starting at level 1; each level past the first sets the paragraph 18 pt further in than its left indent, and each level counts its own numbers: a list paragraph with text sets the counts of the levels deeper than its own back to 0, so a deeper numbered paragraph after it counts from 1, and a paragraph back at a shallower level goes on with that level's count), hyphenate?: bool, wordsLongerThan?: letters 1..25 (5), afterFirst?, beforeLast?: letters 1..15 (3), hyphenLimit?: lines 0..25 (0: no limit), hyphenationZone?: pt 0..1296 (0; Single-line Composer only), hyphenateCapitalized?: bool (true) (Paragraph panel menu › Hyphenation…: only words longer than wordsLongerThan break, keeping afterFirst letters before the hyphen and beforeLast after it; at most hyphenLimit lines in a row end with a hyphen; a line whose text already ends within hyphenationZone of its right edge breaks before the next word instead of hyphenating it; the counts are rounded, and every value is clamped to its range), wordSpacing?: % 0..1000 (80, 100, 133), letterSpacing?: % of a word space -100..500 (0, 0, 0), glyphScaling?: % 50..200 (100, 100, 100): each [min, desired, max] or {min?, desired?, max?} (Paragraph panel menu › Justification…: Desired applies to every line, Minimum and Maximum bound what justified lines may use; values are clamped to their range, and Minimum ≤ Desired ≤ Maximum must hold afterwards or nothing changes), autoLeading?: % of the size 0..500 (120; the leading of characters whose leading is Auto), singleWordJustification?: \"fullJustify\"|\"alignLeft\"|\"alignCenter\"|\"alignRight\" (a justified line holding one word), mojikumi?: \"none\"|\"yakumonoHankaku\"|\"gyomatsuYakumonoHankaku\"|\"gyomatsuYakumonoZenkaku\"|\"yakumonoZenkaku\"|\"lineEndHalf\" (Mojikumi Set: Japanese punctuation spacing), kinsoku?: \"none\"|\"hard\"|\"soft\" (Kinsoku Set: Soft lets 々, ー and small kana start a line), kinsokuType?: \"pushInFirst\"|\"pushOutFirst\"|\"pushOutOnly\" (Paragraph panel menu › Kinsoku Shori Type: how area type keeps those characters off a line's ends; pushInFirst sets them on the line when its gaps next to CJK characters can close up enough, by at most a tenth of an em each, pushOutFirst does so only when moving the character before them to the next line would leave the line more than an em short, and pushOutOnly, the default, moves it unless Burasagari hangs an overflowing comma or full stop; no effect with kinsoku \"none\"), bunriKinshi?: bool (Paragraph panel menu › Bunri-Kinshi: a line never breaks inside an inseparable pair, two em dashes, two horizontal ellipses, two two-dot leaders or the two halves of a vertical kana repeat mark, and justification adds no space inside one; kept but without effect with kinsoku \"none\"; off by default), direction?: \"auto\"|\"leftToRight\"|\"rightToLeft\" (paragraph direction; auto: from each paragraph's first strong character), leadingModel?: \"romanBaseline\"|\"emBoxTop\" (leading measured baseline to baseline, or em box top to top), charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\"|\"icfTop\"|\"icfBottom\" (where characters smaller than the largest on their line line up with it), proportionalMetrics?: bool (full-width glyphs on the font's proportional widths: `palt` in horizontal type, `vpal` in vertical type), tateChuYoko?: bool (Character panel menu › Tate-chu-yoko, with Show East Asian Options: in vertical type those characters stand side by side across one em of the column; kept on the characters and ignored in horizontal type), tcyUpDown?, tcyLeftRight?: pt -1296..1296 (Character panel menu › Tate-chu-yoko Settings, as text.setRangeStyle: a tate-chu-yoko block moves up or down, right or left, and on a vertical path toward or away from the path's start, to its left or right), akiLeft?, akiRight?: 1/1000 em 0..1000 (Character panel › Insert Aki Left and Right, with Show East Asian Options, as text.setRangeStyle: space before and after each character in reading order), standardVerticalRoman?: bool (Character panel menu › Standard Vertical Roman Alignment, as text.setRangeStyle), noBreak?: bool (Character panel menu › No Break: these characters stay on one line, including across a space inside the run), kashidas?: bool (Character panel menu › Kashidas: selected characters allow insertion only when both joined neighbors have it on; on by default), charDirection?: \"default\"|\"leftToRight\"|\"rightToLeft\" (Character panel menu › Character Direction: the characters are set left to right or right to left inside their paragraph, as a Unicode bidi embedding; default: as the bidi algorithm sets them), digits?: \"default\"|\"arabic\"|\"hindi\"|\"farsi\"|\"devanagari\"|\"bengali\"|\"gurmukhi\"|\"gujarati\"|\"odia\"|\"tamil\"|\"telugu\"|\"kannada\"|\"malayalam\" (Character panel menu › Digits: the numeral system every digit is drawn in, whatever was typed: Western, Arabic-Indic (hindi), Eastern Arabic-Indic (farsi) or an Indic script's own digits), fontHeightReference?: \"emBox\"|\"capHeight\"|\"xHeight\"|\"icfBox\" (Character panel › Set Font Height Reference, as text.setRangeStyle: the height of the font that the size measures), language?: name|tag (Character panel › Language, as text.setRangeStyle), fontAxes?: {\"wght\": 650, …} (Character panel › Variable Font, as text.setRangeStyle: each axis named set in its units and clamped to its range, null back to the style's own setting), burasagari?: \"none\"|\"standard\"|\"forced\" (Paragraph panel menu › Burasagari None/Regular/Force: an East Asian comma or full stop ending an area type line hangs outside it: when it doesn't fit, or always; new type: \"standard\"), romanHangingPunctuation?: bool (Paragraph panel menu › Roman Hanging Punctuation: quotation marks, hyphens, full stops and commas starting or ending a line hang outside the margin, asterisks, tildes, ellipses, dashes, colons and semicolons by half; off by default), koreanLineBreakAnywhere?: bool (Paragraph panel menu › Korean Line Break Anywhere: a line may break between any two Hangul syllables; off, a word with Hangul in it breaks only at its spaces and punctuation, or where it is wider than the line; new type: false, paragraphs saved before the option: true), kashida?: \"none\"|\"short\"|\"medium\"|\"long\"|\"stylistic\" (Paragraph panel › Insert Kashidas: justified lines of horizontal area type lengthen each Arabic word with a kashida between its last pair of joined letters, at most a quarter, half or whole em long, or whole tatweels up to an em for stylistic, before they widen their word spaces; none by default), composer?: \"singleLine\"|\"everyLine\" (line breaking, Every-line by default), start?: byte, end?: byte} (baselineShift is in document points and hScale includes the object transform; groups include their text descendants; with a range: the character attributes style that range and the paragraph attributes apply to the paragraphs it touches; without: all the text, and graph labels keep the character and paragraph attributes for every label of their kind when the graph is drawn again, the graph still setting each label's alignment; a number or switch given as another type fails the call, and a null value leaves its attribute as it is, so a call with only null values fails with nothing to change; a call that gives the values the text already has records no undo step). Or {paragraphIndents: [{id, start: byte where the paragraph starts, leftIndent?, firstLineIndent?: pt -1296..1296}…]} alone (Tabs panel indent markers over paragraphs with indents of their own): each entry sets one paragraph of a type object, at least one indent each, at most 100000 entries; every entry is checked before anything changes, and an unknown key, a value out of range, an object that is not type, a byte where no paragraph starts or two entries for one paragraph with other values fail the call; all of it is one edit, a threaded story flowing again once, and when no paragraph's indents change nothing is recorded → {ids}",
+            "{ids?|id?, kerning?: 1/1000 em|\"auto\"|\"optical\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg counter-clockwise (0: upright), underline?, strikethrough?, allCaps?, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), antiAlias?: \"none\"|\"sharp\"|\"crisp\"|\"strong\" (Character panel › Anti-aliasing Method, how the type's edges are drawn as pixels; it sets each targeted type object, with or without a range; each frame of a thread keeps its own method; graph labels keep it for every label of their kind when the graph is drawn again; new type: \"sharp\"), leftIndent?, rightIndent?, firstLineIndent?, spaceBefore?, spaceAfter?: pt (±1296), list?: \"none\"|\"bullet\"|\"number\", bullet?: \"none\"|\"dot\"|\"dash\"|\"circle\"|\"square\", number?: \"none\"|\"arabic\"|\"upperLetters\"|\"lowerLetters\"|\"upperRoman\"|\"lowerRoman\"|\"twoDigits\"|\"threeDigits\", listAlign?: \"left\"|\"right\", listLevel?: 1..9 (Paragraph panel › Bullets and Numbered List: each paragraph of a list starts with its marker, drawn in the font, size and color of the paragraph's first character, and its text starts at the next tab stop after the marker, the left indent counting as a stop; a bulleted list's marker is its bullet, and a numbered list's is the paragraph's number and a period: 1, 2, 3; A to Z, then AA, BB; a to z, then aa, bb; I, II, III; i, ii, iii; 01 to 99, then 100; 001 to 999, then 1000; letters and roman numerals past 3999 in Arabic digits; the numbers count the story's numbered paragraphs, its threaded frames included, from 1 after a paragraph in no list, and an empty or bulleted paragraph is not counted; list \"bullet\" keeps a list's bullet, else a dot, and list \"number\" keeps a numbered list's style, else arabic; without list, a number style makes a numbered list and a bullet makes a bulleted one; \"none\" in any of the three turns the list off; a paragraph that joins a list with left and first-line indents of 0 gets 18 and -18 unless the call sets an indent; a horizontal right-to-left list paragraph has its indents mirrored, measured from the right; listAlign \"right\" (Bullets and Numbering…'s Alignment) puts the marker against the text, and \"left\" (the default) puts it at the first line's start, the text starting at the same place with either; it sets the paragraphs that are in a list or that the call puts in one, and a list keeps it when it changes between bullets and numbers; listLevel (Tab and Shift+Tab at the start of a list paragraph, Bullets and Numbering…'s Level) is a whole number from 1 to 9 that sets the paragraphs in a list or that the call puts in one, a list keeping it when it changes between bullets and numbers, and a list turned on without listLevel starting at level 1; each level past the first sets the paragraph 18 pt further in than its left indent, and each level counts its own numbers: a list paragraph with text sets the counts of the levels deeper than its own back to 0, so a deeper numbered paragraph after it counts from 1, and a paragraph back at a shallower level goes on with that level's count), hyphenate?: bool, wordsLongerThan?: letters 1..25 (5), afterFirst?, beforeLast?: letters 1..15 (3), hyphenLimit?: lines 0..25 (0: no limit), hyphenationZone?: pt 0..1296 (0; Single-line Composer only), hyphenateCapitalized?: bool (true) (Paragraph panel menu › Hyphenation…: only words longer than wordsLongerThan break, keeping afterFirst letters before the hyphen and beforeLast after it; at most hyphenLimit lines in a row end with a hyphen; a line whose text already ends within hyphenationZone of its right edge breaks before the next word instead of hyphenating it; the counts are rounded, and every value is clamped to its range), wordSpacing?: % 0..1000 (80, 100, 133), letterSpacing?: % of a word space -100..500 (0, 0, 0), glyphScaling?: % 50..200 (100, 100, 100): each [min, desired, max] or {min?, desired?, max?} (Paragraph panel menu › Justification…: Desired applies to every line, Minimum and Maximum bound what justified lines may use; values are clamped to their range, and Minimum ≤ Desired ≤ Maximum must hold afterwards or nothing changes), autoLeading?: % of the size 0..500 (120; the leading of characters whose leading is Auto), singleWordJustification?: \"fullJustify\"|\"alignLeft\"|\"alignCenter\"|\"alignRight\" (a justified line holding one word), mojikumi?: \"none\"|\"yakumonoHankaku\"|\"gyomatsuYakumonoHankaku\"|\"gyomatsuYakumonoZenkaku\"|\"yakumonoZenkaku\"|\"lineEndHalf\" (Mojikumi Set: Japanese punctuation spacing), kinsoku?: \"none\"|\"hard\"|\"soft\" (Kinsoku Set: Soft lets 々, ー and small kana start a line), kinsokuType?: \"pushInFirst\"|\"pushOutFirst\"|\"pushOutOnly\" (Paragraph panel menu › Kinsoku Shori Type: how area type keeps those characters off a line's ends; pushInFirst sets them on the line when its gaps next to CJK characters can close up enough, by at most a tenth of an em each, pushOutFirst does so only when moving the character before them to the next line would leave the line more than an em short, and pushOutOnly, the default, moves it unless Burasagari hangs an overflowing comma or full stop; no effect with kinsoku \"none\"), bunriKinshi?: bool (Paragraph panel menu › Bunri-Kinshi: a line never breaks inside an inseparable pair, two em dashes, two horizontal ellipses, two two-dot leaders or the two halves of a vertical kana repeat mark, and justification adds no space inside one; kept but without effect with kinsoku \"none\"; off by default), direction?: \"auto\"|\"leftToRight\"|\"rightToLeft\" (paragraph direction; auto: from each paragraph's first strong character), leadingModel?: \"romanBaseline\"|\"emBoxTop\" (leading measured baseline to baseline, or em box top to top), charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\"|\"icfTop\"|\"icfBottom\" (where characters smaller than the largest on their line line up with it), proportionalMetrics?: bool (full-width glyphs on the font's proportional widths: `palt` in horizontal type, `vpal` in vertical type), tateChuYoko?: bool (Character panel menu › Tate-chu-yoko, with Show East Asian Options: in vertical type those characters stand side by side across one em of the column; kept on the characters and ignored in horizontal type), tcyUpDown?, tcyLeftRight?: pt -1296..1296 (Character panel menu › Tate-chu-yoko Settings, as text.setRangeStyle: a tate-chu-yoko block moves up or down, right or left, and on a vertical path toward or away from the path's start, to its left or right), warichu?: bool, warichuLines?: 1..6, warichuGap?: pt 0..100, warichuScale?: % 10..100, warichuAlign?: \"auto\"|\"left\"|\"center\"|\"right\"|\"justifyLeft\"|\"justifyCenter\"|\"justifyRight\"|\"justifyAll\" (Character panel menu › Warichu and Warichu Settings, as text.setRangeStyle: the characters set smaller and stacked on lines inside their line), akiLeft?, akiRight?: 1/1000 em 0..1000 (Character panel › Insert Aki Left and Right, with Show East Asian Options, as text.setRangeStyle: space before and after each character in reading order), standardVerticalRoman?: bool (Character panel menu › Standard Vertical Roman Alignment, as text.setRangeStyle), noBreak?: bool (Character panel menu › No Break: these characters stay on one line, including across a space inside the run), kashidas?: bool (Character panel menu › Kashidas: selected characters allow insertion only when both joined neighbors have it on; on by default), charDirection?: \"default\"|\"leftToRight\"|\"rightToLeft\" (Character panel menu › Character Direction: the characters are set left to right or right to left inside their paragraph, as a Unicode bidi embedding; default: as the bidi algorithm sets them), digits?: \"default\"|\"arabic\"|\"hindi\"|\"farsi\"|\"devanagari\"|\"bengali\"|\"gurmukhi\"|\"gujarati\"|\"odia\"|\"tamil\"|\"telugu\"|\"kannada\"|\"malayalam\" (Character panel menu › Digits: the numeral system every digit is drawn in, whatever was typed: Western, Arabic-Indic (hindi), Eastern Arabic-Indic (farsi) or an Indic script's own digits), fontHeightReference?: \"emBox\"|\"capHeight\"|\"xHeight\"|\"icfBox\" (Character panel › Set Font Height Reference, as text.setRangeStyle: the height of the font that the size measures), language?: name|tag (Character panel › Language, as text.setRangeStyle), fontAxes?: {\"wght\": 650, …} (Character panel › Variable Font, as text.setRangeStyle: each axis named set in its units and clamped to its range, null back to the style's own setting), burasagari?: \"none\"|\"standard\"|\"forced\" (Paragraph panel menu › Burasagari None/Regular/Force: an East Asian comma or full stop ending an area type line hangs outside it: when it doesn't fit, or always; new type: \"standard\"), romanHangingPunctuation?: bool (Paragraph panel menu › Roman Hanging Punctuation: quotation marks, hyphens, full stops and commas starting or ending a line hang outside the margin, asterisks, tildes, ellipses, dashes, colons and semicolons by half; off by default), koreanLineBreakAnywhere?: bool (Paragraph panel menu › Korean Line Break Anywhere: a line may break between any two Hangul syllables; off, a word with Hangul in it breaks only at its spaces and punctuation, or where it is wider than the line; new type: false, paragraphs saved before the option: true), kashida?: \"none\"|\"short\"|\"medium\"|\"long\"|\"stylistic\" (Paragraph panel › Insert Kashidas: justified lines of horizontal area type lengthen each Arabic word with a kashida between its last pair of joined letters, at most a quarter, half or whole em long, or whole tatweels up to an em for stylistic, before they widen their word spaces; none by default), composer?: \"singleLine\"|\"everyLine\" (line breaking, Every-line by default), start?: byte, end?: byte} (baselineShift is in document points and hScale includes the object transform; groups include their text descendants; with a range: the character attributes style that range and the paragraph attributes apply to the paragraphs it touches; without: all the text, and graph labels keep the character and paragraph attributes for every label of their kind when the graph is drawn again, the graph still setting each label's alignment; a number or switch given as another type fails the call, and a null value leaves its attribute as it is, so a call with only null values fails with nothing to change; a call that gives the values the text already has records no undo step). Or {paragraphIndents: [{id, start: byte where the paragraph starts, leftIndent?, firstLineIndent?: pt -1296..1296}…]} alone (Tabs panel indent markers over paragraphs with indents of their own): each entry sets one paragraph of a type object, at least one indent each, at most 100000 entries; every entry is checked before anything changes, and an unknown key, a value out of range, an object that is not type, a byte where no paragraph starts or two entries for one paragraph with other values fail the call; all of it is one edit, a threaded story flowing again once, and when no paragraph's indents change nothing is recorded → {ids}",
             has_doc,
             set_format
         ),
@@ -345,15 +345,7 @@ pub(crate) fn artboard_copy(s: &mut Session, p: &Value, cut: bool) -> Result<Val
     let copied = clip.nodes.len();
     if cut {
         s.edit("Cut Artboard", |d, sel| {
-            if indices.iter().any(|i| *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 gone = d.artboards.remove(i).id;
-                d.retire_artboard_id(gone);
-                d.retain_guides(sel, |g| g.artboard != Some(gone));
-            }
+            super::layer::remove_artboards(d, sel, &indices)?;
             d.remove_many(&art)?;
             sel.prune(d);
             Ok(())
@@ -465,6 +457,23 @@ fn list_level_param(p: &Value, cmd: &str) -> Result<Option<u8>> {
     }
 }
 
+/// Set the Warichu and Warichu Settings of `st` that are given: Warichu on or off, Lines, Line Gap
+/// (in the type's own units), Scale and Alignment.
+fn set_warichu(
+    st: &mut vectorcraft_doc::CharStyle,
+    on: Option<bool>,
+    lines: Option<u8>,
+    gap: Option<f64>,
+    scale: Option<f64>,
+    align: Option<vectorcraft_doc::WarichuAlign>,
+) {
+    st.warichu = on.unwrap_or(st.warichu);
+    st.warichu_lines = lines.unwrap_or(st.warichu_lines);
+    st.warichu_gap = gap.unwrap_or(st.warichu_gap);
+    st.warichu_scale = scale.unwrap_or(st.warichu_scale);
+    st.warichu_align = align.unwrap_or(st.warichu_align);
+}
+
 fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "text.setFormat";
     if p.get("paragraphIndents").is_some() {
@@ -479,6 +488,7 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
             "allCaps",
             "proportionalMetrics",
             "tateChuYoko",
+            "warichu",
             "standardVerticalRoman",
             "noBreak",
             "kashidas",
@@ -571,6 +581,11 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
         "tateChuYoko",
         "tcyUpDown",
         "tcyLeftRight",
+        "warichu",
+        "warichuLines",
+        "warichuGap",
+        "warichuScale",
+        "warichuAlign",
         "akiLeft",
         "akiRight",
         "standardVerticalRoman",
@@ -617,6 +632,10 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
     let tcy_left_right = super::textedit::tcy_offset_param(p, "tcyLeftRight", C)?;
     let aki_left = super::textedit::aki_param(p, "akiLeft", C)?;
     let aki_right = super::textedit::aki_param(p, "akiRight", C)?;
+    let warichu_lines = super::textedit::warichu_lines_param(p, C)?;
+    let warichu_gap = super::textedit::warichu_number_param(p, "warichuGap", C)?;
+    let warichu_scale = super::textedit::warichu_number_param(p, "warichuScale", C)?;
+    let warichu_align = super::textedit::warichu_align_param(p, C)?;
     let mojikumi = match p.get("mojikumi") {
         None | Some(Value::Null) => None,
         Some(v) => Some(match v.as_str() {
@@ -726,9 +745,13 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
     // A paragraph whose Minimum, Desired and Maximum would no longer be in order.
     let mut out_of_order: Option<&str> = None;
     let range = super::typecmd::TextRange::parse(p, C)?;
-    // The character attributes, given the baseline shift, horizontal scale and Tate-chu-yoko
-    // offsets in the type's own units.
-    let chars = |st: &mut vectorcraft_doc::CharStyle, baseline_shift: Option<f64>, h_scale: Option<f64>, tcy: (Option<f64>, Option<f64>)| {
+    // The character attributes, given the baseline shift, horizontal scale, Tate-chu-yoko offsets
+    // and warichu Line Gap in the type's own units.
+    let chars = |st: &mut vectorcraft_doc::CharStyle,
+                 baseline_shift: Option<f64>,
+                 h_scale: Option<f64>,
+                 tcy: (Option<f64>, Option<f64>),
+                 gap: Option<f64>| {
         if let Some(k) = kerning {
             st.kerning = k;
         }
@@ -786,6 +809,7 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
         if let Some(v) = tcy.1 {
             st.tcy_left_right = v;
         }
+        set_warichu(st, flag("warichu"), warichu_lines, gap, warichu_scale, warichu_align);
         if let Some(v) = aki_left {
             st.aki_left = v;
         }
@@ -851,7 +875,9 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
             let h_scale = num("hScale").map(|v| super::typecmd::local_type_value(t, v, (1.0, 10000.0), true, C)).transpose()?;
             let local = |v: Option<f64>| v.map(|v| super::typecmd::local_type_value(t, v, (-1296.0, 1296.0), false, C)).transpose();
             let tcy = (local(tcy_up_down)?, local(tcy_left_right)?);
-            super::typecmd::style_chars(t, range, |st| chars(st, baseline_shift, h_scale, tcy));
+            let gap =
+                warichu_gap.map(|v| super::typecmd::local_type_value(t, v, (0.0, vectorcraft_doc::text::MAX_WARICHU_GAP), false, C)).transpose()?;
+            super::typecmd::style_chars(t, range, |st| chars(st, baseline_shift, h_scale, tcy, gap));
             let span = super::typecmd::para_span(range, t);
             let paras = |para: &mut vectorcraft_doc::ParaStyle, out_of_order: &mut Option<&'static str>| {
                 if let Some(v) = num("leftIndent") {
@@ -960,7 +986,7 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
         if range.is_none() {
             let shift = num("baselineShift").map(|v| v.clamp(-1296.0, 1296.0));
             let scale = num("hScale").map(|v| v.clamp(1.0, 10000.0));
-            changed |= super::graph::capture_label_styles(d, &ids, &|st| chars(st, shift, scale, (tcy_up_down, tcy_left_right)));
+            changed |= super::graph::capture_label_styles(d, &ids, &|st| chars(st, shift, scale, (tcy_up_down, tcy_left_right), warichu_gap));
             if let Some(paras) = para_change {
                 // The kept attributes are checked too: they may differ from the labels'.
                 changed |= super::graph::capture_label_paragraphs(d, &ids, &|para| {
diff --git a/crates/engine/src/cmd/params.rs b/crates/engine/src/cmd/params.rs
index dd59db4d81..20e5054aeb 100644
--- a/crates/engine/src/cmd/params.rs
+++ b/crates/engine/src/cmd/params.rs
@@ -8,7 +8,9 @@
 //! (`…settings as file.new`), or, naming none, any key (the options of the format an export picks). Objects inside a value aren't
 //! described key by key, so only the top level is checked, except in the options of an export, a
 //! save or Export for Screens: those are checked against the options of the formats the command
-//! can write, in `marks`, `bleed` and the other objects too ([`check_export_options`]).
+//! can write, in `marks`, `bleed` and the other objects too ([`check_export_options`]); and in the
+//! objects of an array whose keys `MEMBER_KEYS` lists, such as the `items` of
+//! `object.setLiveShape`.
 //!
 //! [`Session::execute`] answers a key the description doesn't name with a parameter error
 //! ([`check_params`]), for every caller (the app, the control channel, MCP, the CLI) and for the
@@ -269,6 +271,41 @@ pub(crate) fn unknown(id: &str, key: &str, keys: &[&str]) -> crate::EngineError
     )
 }
 
+/// Commands whose params hold an array of objects with keys of their own: the command, the key of
+/// the array and the keys each of its objects takes.
+const MEMBER_KEYS: &[(&str, &str, &[&str])] = &[("object.setLiveShape", "items", &["id", "corners"])];
+
+/// Each object in the arrays [`MEMBER_KEYS`] names for command `id` has only the keys it lists, or
+/// the parameter error naming the first other one with its place (`items[0].corner`), and the
+/// nearest accepted key or the accepted ones. A member that isn't an object is the command's to
+/// report.
+fn check_member_keys(id: &str, params: &Value) -> Result<()> {
+    for (_, list, keys) in MEMBER_KEYS.iter().filter(|(c, ..)| *c == id) {
+        let Some(members) = params.get(*list).and_then(Value::as_array) else { continue };
+        for (i, member) in members.iter().enumerate() {
+            let Value::Object(given) = member else { continue };
+            let Some(key) = given.keys().find(|k| !keys.contains(&k.as_str())) else { continue };
+            let at = |k: &str| format!("{list}[{i}].{k}");
+            let near = nearest(key, keys);
+            let key = at(&shown_key(key));
+            return Err(bad(
+                id,
+                match near {
+                    Some(near) => {
+                        let near = at(near);
+                        format!("unknown parameter `{key}`; did you mean `{near}`?")
+                    }
+                    None => {
+                        let keys = keys.iter().map(|k| at(k)).collect::<Vec<_>>().join(", ");
+                        format!("unknown parameter `{key}`; the command takes: {keys}")
+                    }
+                },
+            ));
+        }
+    }
+    Ok(())
+}
+
 /// `params` of built-in effect `effect`, as command `id` was given them (#1592): only keys the
 /// effect takes (those of its dialog defaults and of its params description), each of the type
 /// the effect reads ([`check_effect_types`]), a `color` the effect can draw ([`check_effect_color`])
@@ -526,7 +563,6 @@ pub const UNCHECKED: &[&str] = &[
     "object.rasterize",
     "object.repeat.options",
     "object.setBounds",
-    "object.setLiveShape",
     "object.setOverprint",
     "object.setProps",
     "object.slice.divide",
@@ -833,6 +869,7 @@ fn check_params_in(id: &str, params: &Value, in_batch: bool) -> Result<()> {
         return Ok(());
     }
     check_keys(id, spec.params, params)?;
+    check_member_keys(id, params)?;
     if in_batch {
         crate::schemas::check(spec, params, false)?;
     }
diff --git a/crates/engine/src/cmd/path.rs b/crates/engine/src/cmd/path.rs
index 2dee458930..33bde936bf 100644
--- a/crates/engine/src/cmd/path.rs
+++ b/crates/engine/src/cmd/path.rs
@@ -314,6 +314,15 @@ fn set_handle(s: &mut Session, p: &Value) -> Result<Value> {
     let out = str_param(p, "which") != Some("in");
     let pos = Point::new(f64_req(p, "x", "path.setHandle")?, f64_req(p, "y", "path.setHandle")?);
     let independent = switch_or(p, "independent", false, "path.setHandle")?;
+    // A handle already there, on an anchor already of the kind it would get, changes nothing and
+    // records no undo step.
+    if let Some(a) = anchor_of(s, id, si, ai)? {
+        let mut b = a;
+        b.set_handle(out, pos, independent);
+        if b == a {
+            return ok();
+        }
+    }
     s.edit("Reshape", |d, _| {
         let path = path_mut(d, id)?;
         let a = path.anchor_mut(si, ai).ok_or_else(|| EngineError::Other("no such anchor".into()))?;
@@ -330,6 +339,12 @@ fn move_anchor(s: &mut Session, p: &Value) -> Result<Value> {
     let si = usize_opt(p, "subpath", "path.moveAnchor")?.unwrap_or(0);
     let ai = p.get("anchor").and_then(Value::as_u64).map(index).ok_or_else(|| bad("path.moveAnchor", "missing anchor"))?;
     let pos = Point::new(f64_req(p, "x", "path.moveAnchor")?, f64_req(p, "y", "path.moveAnchor")?);
+    // An anchor already at (x, y) changes nothing and records no undo step.
+    if let Some(a) = anchor_of(s, id, si, ai)?
+        && a.transform(vectorcraft_geom::Affine::translate(pos - a.p)) == a
+    {
+        return ok();
+    }
     s.edit("Move", |d, _| {
         let path = path_mut(d, id)?;
         let a = path.anchor_mut(si, ai).ok_or_else(|| EngineError::Other("no such anchor".into()))?;
@@ -345,6 +360,16 @@ fn move_anchor(s: &mut Session, p: &Value) -> Result<Value> {
     ok()
 }
 
+/// Anchor `ai` of subpath `si` of path `id` in the active document, when `id` is a path that has it.
+/// Busy while a script runs, as [`Session::edit`] is.
+fn anchor_of(s: &Session, id: NodeId, si: usize, ai: usize) -> Result<Option<Anchor>> {
+    if s.script_running() {
+        return Err(EngineError::Busy);
+    }
+    let d = &s.doc()?.doc;
+    Ok(d.node(id).and_then(|n| n.path_data()).and_then(|path| path.subpaths.get(si)).and_then(|sp| sp.anchors.get(ai)).copied())
+}
+
 fn set_anchors(s: &mut Session, p: &Value) -> Result<Value> {
     let id = object_param(p, "id", "path.setAnchors")?.ok_or_else(|| bad("path.setAnchors", "missing id"))?;
     let subs = p.get("subpaths").and_then(Value::as_array).ok_or_else(|| bad("path.setAnchors", "missing subpaths"))?;
diff --git a/crates/engine/src/cmd/pathops.rs b/crates/engine/src/cmd/pathops.rs
index b4ce273dad..0085c2d9d6 100644
--- a/crates/engine/src/cmd/pathops.rs
+++ b/crates/engine/src/cmd/pathops.rs
@@ -803,35 +803,59 @@ fn offset_path(s: &mut Session, p: &Value) -> Result<Value> {
     let miter = number_given(p, "miterLimit", C)?.unwrap_or(4.0).clamp(1.0, 500.0);
     let roots = selected_roots(s)?;
     let ids = s.edit("Offset Path", |d, sel| {
-        let (mut out, mut above) = (vec![], vec![]);
-        let mut paths = false;
+        // Each selected root, whether it is a group, and the style of each of its leaf paths; the
+        // paths themselves go to `sources` in the same order.
+        let (mut roots_found, mut sources) = (vec![], vec![]);
         for id in &roots {
-            let Some(n) = d.node(*id).cloned() else { continue };
-            let mut lv = vec![];
-            leaves(&n, &mut lv);
+            let Some(n) = d.node(*id) else { continue };
+            let mut styles = vec![];
+            each_leaf(n, &mut |l| {
+                if !matches!(l.kind, NodeKind::Text(_))
+                    && let Some((path, rule)) = node_path(l)
+                {
+                    styles.push(Style::of(l));
+                    sources.push((path, rule, matches!(l.kind, NodeKind::Compound { .. })));
+                }
+            });
+            roots_found.push((*id, matches!(n.kind, NodeKind::Group { .. }), styles));
+        }
+        let paths = !sources.is_empty();
+        let offset = |(path, rule, compound): &(PathData, FillRule, bool)| {
+            let normalized;
+            let base = if *compound && path.is_closed() {
+                normalized = po::normalize(path, *rule);
+                &normalized
+            } else {
+                path
+            };
+            match po::try_offset_path(base, delta, join, miter) {
+                Ok(p) => Ok(Some(p)),
+                Err(po::PathOpsError::NonFinite) => Ok(None),
+                Err(e) => Err(e),
+            }
+        };
+        // The offsets are worked out together; the nodes are made here, in selection order, so
+        // the ids, the stacking and the first error are those of one path after another.
+        let (offsets, _) = ordered_map(&sources, offset_threads(), offset, std::result::Result::is_err);
+        let mut offsets = offsets.into_iter();
+        let (mut out, mut above) = (vec![], vec![]);
+        for (id, group, styles) in roots_found {
             let mut made = vec![];
-            for l in lv.iter().filter(|l| !matches!(l.kind, NodeKind::Text(_))) {
-                let Some((path, rule)) = node_path(l) else { continue };
-                paths = true;
-                let base = if matches!(l.kind, NodeKind::Compound { .. }) && path.is_closed() { po::normalize(&path, rule) } else { path };
-                let off = match po::try_offset_path(&base, delta, join, miter) {
-                    Ok(p) => p,
-                    Err(po::PathOpsError::NonFinite) => continue,
-                    Err(po::PathOpsError::TooComplex) => {
+            for style in &styles {
+                match offsets.next().flatten() {
+                    Some(Ok(Some(off))) if !off.is_empty() => made.push(shape_node_styled(d, off, style)),
+                    Some(Err(po::PathOpsError::TooComplex)) => {
                         return Err(EngineError::Other("Offset Path: the path is too complex to offset".into()));
                     }
-                    Err(e) => return Err(EngineError::Other(format!("Offset Path: {e}"))),
-                };
-                if off.is_empty() {
-                    continue;
+                    Some(Err(e)) => return Err(EngineError::Other(format!("Offset Path: {e}"))),
+                    _ => {}
                 }
-                made.push(shape_node(d, off, Some(l)));
             }
             if made.is_empty() {
                 continue;
             }
             let new = if made.len() == 1
-                && !matches!(n.kind, NodeKind::Group { .. })
+                && !group
                 && let Some(one) = made.pop()
             {
                 one
@@ -840,7 +864,7 @@ fn offset_path(s: &mut Session, p: &Value) -> Result<Value> {
                 Node::group(gid, made.into_iter().map(Arc::new).collect())
             };
             out.push(new.id);
-            above.push((*id, vec![new]));
+            above.push((id, vec![new]));
         }
         if out.is_empty() && paths {
             return Err(EngineError::Other("Offset Path: the offset leaves nothing of the selected paths (an inset larger than the shapes)".into()));
@@ -855,6 +879,86 @@ fn offset_path(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(ids_json(&ids))
 }
 
+/// The threads [`offset_path`] works on: the logical CPUs, or one on the web.
+fn offset_threads() -> usize {
+    #[cfg(target_arch = "wasm32")]
+    {
+        1
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        std::thread::available_parallelism().map_or(1, std::num::NonZero::get)
+    }
+}
+
+/// `f` of each of `items`, in their order. The items are split into runs whose sizes differ by
+/// at most one, as many as `threads` or the items allow and at least one. This thread works
+/// on the first run, and a thread of its own works on each other run (this thread does when that
+/// one can't start). Once `stop` accepts a result, the items after it are left out (`None`); every
+/// item before the first such result has its result. Returns the results and the number of
+/// threads that worked on them.
+pub(crate) fn ordered_map<T: Sync, R: Send>(
+    items: &[T],
+    threads: usize,
+    f: impl Fn(&T) -> R + Sync,
+    stop: impl Fn(&R) -> bool + Sync,
+) -> (Vec<Option<R>>, usize) {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    let mut out: Vec<Option<R>> = std::iter::repeat_with(|| None).take(items.len()).collect();
+    let stopped = AtomicUsize::new(usize::MAX);
+    let run = |from: usize, its: &[T], out: &mut [Option<R>]| {
+        for (i, (item, slot)) in its.iter().zip(out).enumerate() {
+            let at = from + i;
+            if at > stopped.load(Ordering::Relaxed) {
+                return;
+            }
+            let r = f(item);
+            if stop(&r) {
+                stopped.fetch_min(at, Ordering::Relaxed);
+            }
+            *slot = Some(r);
+        }
+    };
+    let runs = threads.clamp(1, items.len().max(1));
+    if runs == 1 {
+        run(0, items, &mut out);
+        return (out, 1);
+    }
+    // Run `k` holds the items from `start(k)` up to `start(k + 1)`.
+    let start = |k: usize| k * items.len() / runs;
+    let mut unstarted = vec![];
+    let used = std::thread::scope(|s| {
+        let mut rest = out.as_mut_slice();
+        let mut first = None;
+        let mut used = 1;
+        for k in 0..runs {
+            let (from, to) = (start(k), start(k + 1));
+            let Some((o, tail)) = std::mem::take(&mut rest).split_at_mut_checked(to - from) else { break };
+            rest = tail;
+            let its = items.get(from..to).unwrap_or_default();
+            if k == 0 {
+                first = Some((o, its));
+                continue;
+            }
+            let run = &run;
+            match std::thread::Builder::new().spawn_scoped(s, move || run(from, its, o)) {
+                Ok(_) => used += 1,
+                Err(_) => unstarted.push(k),
+            }
+        }
+        if let Some((o, its)) = first {
+            run(0, its, o);
+        }
+        used
+    });
+    for (from, to) in unstarted.into_iter().map(|k| (start(k), start(k + 1))) {
+        if let (Some(o), Some(its)) = (out.get_mut(from..to), items.get(from..to)) {
+            run(from, its, o);
+        }
+    }
+    (out, used)
+}
+
 // ---------- Outline Stroke ----------
 
 /// Can Outline Stroke turn `st` into filled art?
diff --git a/crates/engine/src/cmd/plugin_call/reviewed.rs b/crates/engine/src/cmd/plugin_call/reviewed.rs
index c99cf556e2..5329f23331 100644
--- a/crates/engine/src/cmd/plugin_call/reviewed.rs
+++ b/crates/engine/src/cmd/plugin_call/reviewed.rs
@@ -32,6 +32,7 @@ pub(super) const ALLOWED: &[&str] = &[
     "addon.color.strokeToFill",
     "addon.color.swatchLegend",
     "addon.contour.set",
+    "addon.cutting.banner",
     "addon.cutting.bridges",
     "addon.cutting.weed",
     "addon.image.applyColorMask",
@@ -58,6 +59,7 @@ pub(super) const ALLOWED: &[&str] = &[
     "addon.pathtools.shape.set",
     "addon.pathtools.slideAnchor",
     "addon.pathtools.smooth",
+    "addon.pathtools.trim",
     "addon.pen.append",
     "addon.pen.close",
     "addon.pen.closeJoin",
diff --git a/crates/engine/src/cmd/recovery.rs b/crates/engine/src/cmd/recovery.rs
index c1c7f789fe..de4d145840 100644
--- a/crates/engine/src/cmd/recovery.rs
+++ b/crates/engine/src/cmd/recovery.rs
@@ -576,13 +576,25 @@ pub fn store(s: &Session) -> Option<Arc<dyn RecoveryStore>> {
     }
     #[cfg(not(target_arch = "wasm32"))]
     {
-        let folder = Some(s.prefs.recovery_folder.trim()).filter(|f| !f.is_empty()).map(str::to_string).or_else(|| s.recovery.default_folder.clone());
-        folder.map(|f| Arc::new(FolderStore::new(f)) as Arc<dyn RecoveryStore>)
+        folder(s).map(|(f, _)| Arc::new(FolderStore::new(f)) as Arc<dyn RecoveryStore>)
     }
     #[cfg(target_arch = "wasm32")]
     None
 }
 
+/// The folder copies go to now, and whether the `recoveryFolder` preference names it (else it is
+/// the folder the app sets). `None` when they go to a store the host installed (browser storage)
+/// or nowhere.
+pub fn folder(s: &Session) -> Option<(String, bool)> {
+    if s.recovery.store.is_some() || cfg!(target_arch = "wasm32") {
+        return None;
+    }
+    match s.prefs.recovery_folder.trim() {
+        "" => s.recovery.default_folder.clone().map(|f| (f, false)),
+        set => Some((set.to_string(), true)),
+    }
+}
+
 fn has_store(s: &Session) -> std::result::Result<(), String> {
     match store(s) {
         Some(_) => Ok(()),
diff --git a/crates/engine/src/cmd/textedit.rs b/crates/engine/src/cmd/textedit.rs
index 6fc8b12edc..0fd7c7d97d 100644
--- a/crates/engine/src/cmd/textedit.rs
+++ b/crates/engine/src/cmd/textedit.rs
@@ -40,7 +40,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Character",
             [],
             None,
-            "{id? (default: the one selected type object), start?: byte, end?: byte (default: all text), story?: bool = false (all the text of every frame of the threaded story `id` is a frame of, in one undo step; no `start` or `end`), font?, style?, size?: pt 0.1..1296 (outside it: an error), leading?: pt|\"auto\", tracking?, kerning?: 1/1000 em|\"auto\"|\"optical\" (the space after each character), kerningBefore?: 1/1000 em -1000..10000 (the space before a character that starts a line by itself: the first character of the text, of a paragraph or after a forced line break; no effect elsewhere; 0 by default), baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg counter-clockwise (0: upright), fill?: colour|\"none\", stroke?: colour|\"none\" (#rrggbbaa and #rgba are refused in both), keepModel?: bool (fill and stroke, as paint.setFill), strokeWidth?: pt, strokeOptions?: {weight?, cap?, join?, miterLimit?, align?, dash?, dashOffset?, alignDashes?} (as stroke.set: the character stroke), underline?, strikethrough?, allCaps?: bool, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), features?: [\"dlig\", \"-liga\", \"salt=2\", …] (swsh, ss01–ss20, salt, titl, pnum, lnum, sups, subs, numr, dnom and aalt take the font's alternate number as `tag=N`, N 0–65535: \"salt=2\" draws the second alternate of each glyph that has one, \"salt\" is \"salt=1\", \"-salt\" and \"salt=0\" are off; the range is shaped with its word, so a letter's alternate keeps it joined to its neighbours), featureChanges?: [\"tnum\", \"-onum\", \"salt=2\", …] (OpenType features turned on, or with - off, on top of each character's own, a value replacing the feature's last one; its other features are kept), charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\"|\"icfTop\"|\"icfBottom\", proportionalMetrics?: bool (full-width glyphs on the font's proportional widths: `palt` in horizontal type, `vpal` in vertical type), tateChuYoko?: bool (Character panel menu › Tate-chu-yoko, with Show East Asian Options: in vertical type those characters stand side by side across one em of the column; kept on the characters and ignored in horizontal type), tcyUpDown?, tcyLeftRight?: pt -1296..1296 (Character panel menu › Tate-chu-yoko Settings: in vertical type a block of tate-chu-yoko characters moves up by a positive Up/Down and down by a negative one, right by a positive Left/Right and left by a negative one, as one piece with the values of its first character; on a vertical path a positive Up/Down moves it toward the path's start and a positive Left/Right to the path's left; 0 by default; automatic digit blocks and horizontal type do not move; neither turns tateChuYoko on), akiLeft?, akiRight?: 1/1000 em 0..1000 (Character panel › Insert Aki Left and Right, with Show East Asian Options: space before and after each character in reading order, on its left and right in left-to-right type, on its right and left in right-to-left type, above and below it in vertical type; a ligature or a letter with its marks takes the values of its first character; line wrapping counts it, alignment keeps it at a line's ends and justification does not stretch or narrow it; 0 by default; a value that is not a number or is outside the range is refused, naming the key), standardVerticalRoman?: bool (Character panel menu › Standard Vertical Roman Alignment, with Show East Asian Options: in vertical type those half-width characters, such as Latin letters and digits, stand upright one below the other instead of being rotated; spaces and tate-chu-yoko blocks are not changed; kept on the characters and ignored in horizontal type; off by default), noBreak?: bool (Character panel menu › No Break: these characters stay on one line, including across a space inside the run), kashidas?: bool (Character panel menu › Kashidas: selected characters allow insertion only when both joined neighbors have it on; on by default), charDirection?: \"default\"|\"leftToRight\"|\"rightToLeft\" (Character panel menu › Character Direction: the characters are set left to right or right to left inside their paragraph, as a Unicode bidi embedding; default: as the bidi algorithm sets them), digits?: \"default\"|\"arabic\"|\"hindi\"|\"farsi\"|\"devanagari\"|\"bengali\"|\"gurmukhi\"|\"gujarati\"|\"odia\"|\"tamil\"|\"telugu\"|\"kannada\"|\"malayalam\" (Character panel menu › Digits: the numeral system every digit is drawn in, whatever was typed: Western, Arabic-Indic (hindi), Eastern Arabic-Indic (farsi) or an Indic script's own digits), fontHeightReference?: \"emBox\"|\"capHeight\"|\"xHeight\"|\"icfBox\" (Character panel › Set Font Height Reference: the height of the font that size measures, the em box by default; with a font that has no such height, or one outside 0.1 to 2 em, the em box), language?: name|tag (Character panel › Language: one of Document Setup's languages by name or BCP 47 tag, case-insensitive, such as \"Turkish\" or \"tr\"; the characters are shaped in it, so the font uses that language's forms (OpenType `locl`); saved as the tag, English: USA, the default, as none; new type takes the document's language), fontAxes?: {\"wght\": 650, …} (Character panel › Variable Font: the setting of each variation axis named, in the axis's units and clamped to its range; null: back to the style's own setting; other axes keep theirs; tags the font has no axis for are left out; a font or style change clears them; text.fontList {family, style} lists the axes), glyphAlternate?: null (takes away the glyph choice text.setGlyphAlternate made on the characters, in the same undo step as the other attributes; any other value is refused)} style a character range (size/leading/baselineShift are document points and hScale includes the object transform; runs are split at the range ends) → {id, runs, warning?: text (the font or style set isn't available: its type is drawn in the fallback font or the family's closest style)}",
+            "{id? (default: the one selected type object), start?: byte, end?: byte (default: all text), story?: bool = false (all the text of every frame of the threaded story `id` is a frame of, in one undo step; no `start` or `end`), font?, style?, size?: pt 0.1..1296 (outside it: an error), leading?: pt|\"auto\", tracking?, kerning?: 1/1000 em|\"auto\"|\"optical\" (the space after each character), kerningBefore?: 1/1000 em -1000..10000 (the space before a character that starts a line by itself: the first character of the text, of a paragraph or after a forced line break; no effect elsewhere; 0 by default), baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg counter-clockwise (0: upright), fill?: colour|\"none\", stroke?: colour|\"none\" (#rrggbbaa and #rgba are refused in both), keepModel?: bool (fill and stroke, as paint.setFill), strokeWidth?: pt, strokeOptions?: {weight?, cap?, join?, miterLimit?, align?, dash?, dashOffset?, alignDashes?} (as stroke.set: the character stroke), underline?, strikethrough?, allCaps?: bool, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), features?: [\"dlig\", \"-liga\", \"salt=2\", …] (swsh, ss01–ss20, salt, titl, pnum, lnum, sups, subs, numr, dnom and aalt take the font's alternate number as `tag=N`, N 0–65535: \"salt=2\" draws the second alternate of each glyph that has one, \"salt\" is \"salt=1\", \"-salt\" and \"salt=0\" are off; the range is shaped with its word, so a letter's alternate keeps it joined to its neighbours), featureChanges?: [\"tnum\", \"-onum\", \"salt=2\", …] (OpenType features turned on, or with - off, on top of each character's own, a value replacing the feature's last one; its other features are kept), charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\"|\"icfTop\"|\"icfBottom\", proportionalMetrics?: bool (full-width glyphs on the font's proportional widths: `palt` in horizontal type, `vpal` in vertical type), tateChuYoko?: bool (Character panel menu › Tate-chu-yoko, with Show East Asian Options: in vertical type those characters stand side by side across one em of the column; kept on the characters and ignored in horizontal type), tcyUpDown?, tcyLeftRight?: pt -1296..1296 (Character panel menu › Tate-chu-yoko Settings: in vertical type a block of tate-chu-yoko characters moves up by a positive Up/Down and down by a negative one, right by a positive Left/Right and left by a negative one, as one piece with the values of its first character; on a vertical path a positive Up/Down moves it toward the path's start and a positive Left/Right to the path's left; 0 by default; automatic digit blocks and horizontal type do not move; neither turns tateChuYoko on), warichu?: bool (Character panel menu › Warichu, with Show East Asian Options: the characters are set at warichuScale percent of their size and stacked on warichuLines lines inside their line, one above the other in horizontal type and side by side in vertical type, the first line above or to the right; a stretch of them is one block with the settings of its first character that stays whole on one line and may run past its end; type on a path sets them at their own size), warichuLines?: 1..6 (default 2), warichuGap?: pt 0..100 (the space between the lines, default 0), warichuScale?: % 10..100 (default 50), warichuAlign?: \"auto\"|\"left\"|\"center\"|\"right\"|\"justifyLeft\"|\"justifyCenter\"|\"justifyRight\"|\"justifyAll\" (Warichu Settings: how the lines line up along the block, which is as long as its longest line; the justify values spread every line but the last, which is set left, centered or right, or spread with justifyAll; auto, the default, sets them as justifyLeft; left and right are top and bottom in vertical type; none of them turns warichu on), akiLeft?, akiRight?: 1/1000 em 0..1000 (Character panel › Insert Aki Left and Right, with Show East Asian Options: space before and after each character in reading order, on its left and right in left-to-right type, on its right and left in right-to-left type, above and below it in vertical type; a ligature or a letter with its marks takes the values of its first character; line wrapping counts it, alignment keeps it at a line's ends and justification does not stretch or narrow it; 0 by default; a value that is not a number or is outside the range is refused, naming the key), standardVerticalRoman?: bool (Character panel menu › Standard Vertical Roman Alignment, with Show East Asian Options: in vertical type those half-width characters, such as Latin letters and digits, stand upright one below the other instead of being rotated; spaces and tate-chu-yoko blocks are not changed; kept on the characters and ignored in horizontal type; off by default), noBreak?: bool (Character panel menu › No Break: these characters stay on one line, including across a space inside the run), kashidas?: bool (Character panel menu › Kashidas: selected characters allow insertion only when both joined neighbors have it on; on by default), charDirection?: \"default\"|\"leftToRight\"|\"rightToLeft\" (Character panel menu › Character Direction: the characters are set left to right or right to left inside their paragraph, as a Unicode bidi embedding; default: as the bidi algorithm sets them), digits?: \"default\"|\"arabic\"|\"hindi\"|\"farsi\"|\"devanagari\"|\"bengali\"|\"gurmukhi\"|\"gujarati\"|\"odia\"|\"tamil\"|\"telugu\"|\"kannada\"|\"malayalam\" (Character panel menu › Digits: the numeral system every digit is drawn in, whatever was typed: Western, Arabic-Indic (hindi), Eastern Arabic-Indic (farsi) or an Indic script's own digits), fontHeightReference?: \"emBox\"|\"capHeight\"|\"xHeight\"|\"icfBox\" (Character panel › Set Font Height Reference: the height of the font that size measures, the em box by default; with a font that has no such height, or one outside 0.1 to 2 em, the em box), language?: name|tag (Character panel › Language: one of Document Setup's languages by name or BCP 47 tag, case-insensitive, such as \"Turkish\" or \"tr\"; the characters are shaped in it, so the font uses that language's forms (OpenType `locl`); saved as the tag, English: USA, the default, as none; new type takes the document's language), fontAxes?: {\"wght\": 650, …} (Character panel › Variable Font: the setting of each variation axis named, in the axis's units and clamped to its range; null: back to the style's own setting; other axes keep theirs; tags the font has no axis for are left out; a font or style change clears them; text.fontList {family, style} lists the axes), glyphAlternate?: null (takes away the glyph choice text.setGlyphAlternate made on the characters, in the same undo step as the other attributes; any other value is refused)} style a character range (size/leading/baselineShift are document points and hScale includes the object transform; runs are split at the range ends) → {id, runs, warning?: text (the font or style set isn't available: its type is drawn in the fallback font or the family's closest style)}",
             has_doc,
             set_range_style
         ),
@@ -459,6 +459,12 @@ pub(crate) struct CharChange {
     /// Tate-chu-yoko Settings › Up/Down and Left/Right, in points.
     tcy_up_down: Option<f64>,
     tcy_left_right: Option<f64>,
+    warichu: Option<bool>,
+    /// Warichu Settings › Lines, Line Gap (points), Scale (percent) and Alignment.
+    warichu_lines: Option<u8>,
+    warichu_gap: Option<f64>,
+    warichu_scale: Option<f64>,
+    warichu_align: Option<vectorcraft_doc::WarichuAlign>,
     /// Insert Aki Left and Right, in 1/1000 em.
     aki_left: Option<f64>,
     aki_right: Option<f64>,
@@ -495,6 +501,41 @@ pub(crate) fn tcy_offset_param(p: &Value, key: &str, cmd: &str) -> Result<Option
     if (lo..=hi).contains(&v) { Ok(Some(v)) } else { Err(bad(cmd, format!("`{key}` must be from {lo} to {hi}"))) }
 }
 
+/// `warichuLines` (Warichu Settings › Lines): a whole number within
+/// [`vectorcraft_doc::text::WARICHU_LINES`]. Any other value is an error.
+pub(crate) fn warichu_lines_param(p: &Value, cmd: &str) -> Result<Option<u8>> {
+    let Some(v) = p.get("warichuLines").filter(|v| !v.is_null()) else { return Ok(None) };
+    let range = vectorcraft_doc::text::WARICHU_LINES;
+    let error = || bad(cmd, format!("`warichuLines` must be a whole number from {} to {}", range.start(), range.end()));
+    let n = v.as_u64().and_then(|n| u8::try_from(n).ok()).filter(|n| range.contains(n)).ok_or_else(error)?;
+    Ok(Some(n))
+}
+
+/// `warichuGap` (Warichu Settings › Line Gap, points from 0 to
+/// [`vectorcraft_doc::text::MAX_WARICHU_GAP`]) or `warichuScale` (Warichu Settings › Scale, percent
+/// within [`vectorcraft_doc::text::WARICHU_SCALE`]). Any other value is an error.
+pub(crate) fn warichu_number_param(p: &Value, key: &str, cmd: &str) -> Result<Option<f64>> {
+    let Some(v) = p.get(key).filter(|v| !v.is_null()) else { return Ok(None) };
+    let v = v.as_f64().filter(|v| v.is_finite()).ok_or_else(|| bad(cmd, format!("`{key}` must be a number")))?;
+    let (lo, hi) = match key {
+        "warichuScale" => (*vectorcraft_doc::text::WARICHU_SCALE.start(), *vectorcraft_doc::text::WARICHU_SCALE.end()),
+        _ => (0.0, vectorcraft_doc::text::MAX_WARICHU_GAP),
+    };
+    if (lo..=hi).contains(&v) { Ok(Some(v)) } else { Err(bad(cmd, format!("`{key}` must be from {lo} to {hi}"))) }
+}
+
+/// `warichuAlign: "auto"|"left"|"center"|"right"|"justifyLeft"|"justifyCenter"|"justifyRight"|"justifyAll"`
+/// ([`vectorcraft_doc::WarichuAlign::id`]) → the Warichu Settings Alignment.
+pub(crate) fn warichu_align_param(p: &Value, cmd: &str) -> Result<Option<vectorcraft_doc::WarichuAlign>> {
+    use vectorcraft_doc::WarichuAlign;
+    let Some(v) = p.get("warichuAlign").filter(|v| !v.is_null()) else { return Ok(None) };
+    let Some(a) = v.as_str().and_then(WarichuAlign::from_id) else {
+        let ids: Vec<String> = WarichuAlign::ALL.iter().map(|a| format!("\"{}\"", a.id())).collect();
+        return Err(bad(cmd, format!("`warichuAlign` must be one of {}", ids.join(", "))));
+    };
+    Ok(Some(a))
+}
+
 /// `akiLeft` or `akiRight` (Insert Aki Left and Right): a number of thousandths of an em from 0 to
 /// [`vectorcraft_doc::text::MAX_AKI`]. Any other value is an error.
 pub(crate) fn aki_param(p: &Value, key: &str, cmd: &str) -> Result<Option<f64>> {
@@ -712,7 +753,17 @@ impl CharChange {
         check_numbers(p, &["size", "tracking", "kerningBefore", "baselineShift", "hScale", "vScale", "rotation", "strokeWidth"], cmd)?;
         check_switches(
             p,
-            &["underline", "strikethrough", "allCaps", "proportionalMetrics", "tateChuYoko", "standardVerticalRoman", "noBreak", "kashidas"],
+            &[
+                "underline",
+                "strikethrough",
+                "allCaps",
+                "proportionalMetrics",
+                "tateChuYoko",
+                "warichu",
+                "standardVerticalRoman",
+                "noBreak",
+                "kashidas",
+            ],
             cmd,
         )?;
         let num = |k: &str| p.get(k).and_then(Value::as_f64);
@@ -766,6 +817,11 @@ impl CharChange {
             tate_chu_yoko: flag("tateChuYoko"),
             tcy_up_down: tcy_offset_param(p, "tcyUpDown", cmd)?,
             tcy_left_right: tcy_offset_param(p, "tcyLeftRight", cmd)?,
+            warichu: flag("warichu"),
+            warichu_lines: warichu_lines_param(p, cmd)?,
+            warichu_gap: warichu_number_param(p, "warichuGap", cmd)?,
+            warichu_scale: warichu_number_param(p, "warichuScale", cmd)?,
+            warichu_align: warichu_align_param(p, cmd)?,
             aki_left: aki_param(p, "akiLeft", cmd)?,
             aki_right: aki_param(p, "akiRight", cmd)?,
             standard_vertical_roman: flag("standardVerticalRoman"),
@@ -825,6 +881,11 @@ impl CharChange {
             && self.tate_chu_yoko.is_none()
             && self.tcy_up_down.is_none()
             && self.tcy_left_right.is_none()
+            && self.warichu.is_none()
+            && self.warichu_lines.is_none()
+            && self.warichu_gap.is_none()
+            && self.warichu_scale.is_none()
+            && self.warichu_align.is_none()
             && self.aki_left.is_none()
             && self.aki_right.is_none()
             && self.standard_vertical_roman.is_none()
@@ -843,6 +904,7 @@ impl CharChange {
         self.baseline_shift = self.baseline_shift.map(|v| local_type_value(t, v, (-1296.0, 1296.0), false, cmd)).transpose()?;
         self.tcy_up_down = self.tcy_up_down.map(|v| local_type_value(t, v, (-1296.0, 1296.0), false, cmd)).transpose()?;
         self.tcy_left_right = self.tcy_left_right.map(|v| local_type_value(t, v, (-1296.0, 1296.0), false, cmd)).transpose()?;
+        self.warichu_gap = self.warichu_gap.map(|v| local_type_value(t, v, (0.0, vectorcraft_doc::text::MAX_WARICHU_GAP), false, cmd)).transpose()?;
         self.h_scale = self.h_scale.map(|v| local_type_value(t, v, (1.0, 10000.0), true, cmd)).transpose()?;
         self.stroke_scale = Some(vectorcraft_doc::Scaling::factor(t.xf).filter(|k| k.is_finite() && *k > 1e-12).unwrap_or(1.0));
         Ok(())
@@ -893,6 +955,21 @@ impl CharChange {
         if let Some(v) = self.tcy_left_right {
             st.tcy_left_right = v;
         }
+        if let Some(v) = self.warichu {
+            st.warichu = v;
+        }
+        if let Some(v) = self.warichu_lines {
+            st.warichu_lines = v;
+        }
+        if let Some(v) = self.warichu_gap {
+            st.warichu_gap = v;
+        }
+        if let Some(v) = self.warichu_scale {
+            st.warichu_scale = v;
+        }
+        if let Some(v) = self.warichu_align {
+            st.warichu_align = v;
+        }
         if let Some(v) = self.aki_left {
             st.aki_left = v;
         }
diff --git a/crates/engine/src/cmd/textstyles.rs b/crates/engine/src/cmd/textstyles.rs
index 8134976144..ea1a7a22bd 100644
--- a/crates/engine/src/cmd/textstyles.rs
+++ b/crates/engine/src/cmd/textstyles.rs
@@ -215,6 +215,11 @@ pub fn char_attrs(v: &CharStyle) -> Map<String, Value> {
         ("tateChuYoko", json!(v.tate_chu_yoko)),
         ("tcyUpDown", json!(v.tcy_up_down)),
         ("tcyLeftRight", json!(v.tcy_left_right)),
+        ("warichu", json!(v.warichu)),
+        ("warichuLines", json!(v.warichu_lines)),
+        ("warichuGap", json!(v.warichu_gap)),
+        ("warichuScale", json!(v.warichu_scale)),
+        ("warichuAlign", json!(v.warichu_align)),
         ("akiLeft", json!(v.aki_left)),
         ("akiRight", json!(v.aki_right)),
         ("standardVerticalRoman", json!(v.standard_vertical_roman)),
@@ -573,6 +578,19 @@ fn attrs_param(d: &Document, p: &Value, kind: Kind, verb: &str, kept: Option<&Ma
                             return Err(bad(&c, format!("`{key}` must be from {lo} to {hi}")));
                         }
                     }
+                    let lines = vectorcraft_doc::text::WARICHU_LINES;
+                    if changed("warichuLines") && !lines.contains(&st.warichu_lines) {
+                        return Err(bad(&c, format!("`warichuLines` must be a whole number from {} to {}", lines.start(), lines.end())));
+                    }
+                    let scale = vectorcraft_doc::text::WARICHU_SCALE;
+                    for (key, value, lo, hi) in [
+                        ("warichuGap", st.warichu_gap, 0.0, vectorcraft_doc::text::MAX_WARICHU_GAP),
+                        ("warichuScale", st.warichu_scale, *scale.start(), *scale.end()),
+                    ] {
+                        if changed(key) && !(lo..=hi).contains(&value) {
+                            return Err(bad(&c, format!("`{key}` must be from {lo} to {hi}")));
+                        }
+                    }
                     // A language of the list, stored as its tag (as text.setFormat takes it).
                     if let Some(l) = &st.language
                         && kept.and_then(|k| k.get("language")) != m.get("language")
@@ -1057,12 +1075,12 @@ fn unused(s: &mut Session, kind: Kind) -> Result<Value> {
 
 /// The styles of `kind` in `src` that load, with their source names so that art in the file keeps
 /// referring to them: not the Normal style, and not one whose attributes don't read, whose sizes,
-/// scales, leading, shifts, Insert Aki or stroke width are out of the range `charStyle.new` takes, whose
+/// scales, leading, shifts, Insert Aki, Warichu Settings or stroke width are out of the range `charStyle.new` takes, whose
 /// indents, spacing, Hyphenation or Justification options or tab stops are out of the range
 /// `paraStyle.new` takes, or whose name is empty, which are skipped. → (the styles, the names in
 /// `src` of those skipped)
 fn loadable(src: &Document, kind: Kind) -> (Vec<TextStyleDef>, Vec<String>) {
-    const RANGED: [&str; 18] = [
+    const RANGED: [&str; 21] = [
         "size",
         "h_scale",
         "v_scale",
@@ -1072,6 +1090,9 @@ fn loadable(src: &Document, kind: Kind) -> (Vec<TextStyleDef>, Vec<String>) {
         "akiRight",
         "tcyUpDown",
         "tcyLeftRight",
+        "warichuLines",
+        "warichuGap",
+        "warichuScale",
         "stroke_width",
         "left_indent",
         "right_indent",
diff --git a/crates/engine/src/cmd/textstyles/tests.rs b/crates/engine/src/cmd/textstyles/tests.rs
index 188f2ed49e..3e0727ce4a 100644
--- a/crates/engine/src/cmd/textstyles/tests.rs
+++ b/crates/engine/src/cmd/textstyles/tests.rs
@@ -824,8 +824,8 @@ fn load_all_styles_loads_both_kinds_in_one_step() {
     assert_eq!(s.doc().unwrap().doc, before);
 }
 
-/// A loaded character style whose size, scale, leading, shift or stroke width is out of the range
-/// `charStyle.new` takes is skipped.
+/// A loaded character style whose size, scale, leading, shift, warichu Line Gap or stroke width is
+/// out of the range `charStyle.new` takes is skipped.
 #[test]
 fn loaded_styles_out_of_range_are_skipped() {
     let (mut s, _) = session_with_text("Title");
@@ -834,11 +834,12 @@ fn loaded_styles_out_of_range_are_skipped() {
         ("Flat", json!({"h_scale": 0.5})),
         ("Shifted", json!({"baseline_shift": 5000.0})),
         ("Thick", json!({"stroke_width": -2.0})),
+        ("Gapped", json!({"warichuGap": 500.0})),
         ("Fine", json!({"size": 12.0, "h_scale": 50.0})),
     ];
     let data = styles_file(&file, &[]);
     let r = s.execute("charStyle.load", &json!({"dataBase64": data, "name": "Other.vectorcraft"})).unwrap();
-    assert_eq!(r, json!({"added": ["Fine"], "existing": [], "skipped": ["Huge", "Flat", "Shifted", "Thick"]}));
+    assert_eq!(r, json!({"added": ["Fine"], "existing": [], "skipped": ["Huge", "Flat", "Shifted", "Thick", "Gapped"]}));
     assert_eq!(listed(&mut s, "charStyle"), [NORMAL_CHAR, "Fine"]);
 }
 
diff --git a/crates/engine/src/cmd/textwrap.rs b/crates/engine/src/cmd/textwrap.rs
index caeb1f8fcf..c7c9adb261 100644
--- a/crates/engine/src/cmd/textwrap.rs
+++ b/crates/engine/src/cmd/textwrap.rs
@@ -17,7 +17,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Make",
             ["Object", "Text Wrap"],
             None,
-            "{offset?: pt (6), invert?: bool, ids?} area type below the selected objects (same layer) wraps around them → {ids}",
+            "{offset?: pt (6), invert?: bool, ids?} area type below the selected objects (same layer) wraps around them; a negative offset (to -1000) lets the text that far into them → {ids}",
             has_selection,
             make
         ),
@@ -27,7 +27,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Text Wrap Options…",
             ["Object", "Text Wrap"],
             None,
-            "{offset?: pt, invert?: bool, ids?} set the options of the selected wrap objects; no options → the current {offset, invert}",
+            "{offset?: pt, invert?: bool, ids?} set the options of the selected wrap objects (offset -1000 to 1000; a negative one lets text into the objects); no options → the current {offset, invert}",
             has_selection,
             options
         ),
@@ -186,6 +186,33 @@ mod tests {
         assert_eq!(lines(&s, t), plain);
     }
 
+    /// A negative offset from Text Wrap Options lets the lines beside a wrap object run that far
+    /// into it, the options report it, and one undo puts back the offset before it.
+    #[test]
+    fn text_wrap_options_negative_offset_reflows_and_round_trips() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 600, "height": 600})).unwrap();
+        let t = s
+            .execute("text.create", &json!({"x": 0, "y": 0, "text": "word ".repeat(200), "size": 12, "area": {"width": 400, "height": 400}}))
+            .unwrap()["id"]
+            .as_u64()
+            .unwrap();
+        let r = s.execute("shape.rectangle", &json!({"x": -50, "y": 50, "width": 250, "height": 100})).unwrap()["id"].as_u64().unwrap();
+        s.execute("select.set", &json!({"ids": [r]})).unwrap();
+        s.execute("object.textWrap.make", &json!({})).unwrap();
+        let beside = |s: &Session| lines(s, t).into_iter().filter(|l| l.0 > 1.0).map(|l| l.0).collect::<Vec<_>>();
+        assert!(!beside(&s).is_empty() && beside(&s).iter().all(|x| (x - 206.0).abs() < 1e-6), "{:?}", beside(&s));
+        assert_eq!(s.execute("object.textWrap.options", &json!({"offset": -20})).unwrap()["offset"], json!(-20.0));
+        assert!(!beside(&s).is_empty() && beside(&s).iter().all(|x| (x - 180.0).abs() < 1e-6), "{:?}", beside(&s));
+        assert_eq!(s.execute("object.textWrap.options", &json!({})).unwrap()["offset"], json!(-20.0));
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(s.execute("object.textWrap.options", &json!({})).unwrap()["offset"], json!(6.0));
+        assert!(beside(&s).iter().all(|x| (x - 206.0).abs() < 1e-6), "{:?}", beside(&s));
+        // An offset past -1000 is kept at -1000: the whole object lets text through.
+        assert_eq!(s.execute("object.textWrap.options", &json!({"offset": -5000})).unwrap()["offset"], json!(-1000.0));
+        assert!(lines(&s, t).iter().all(|l| l.0 < 1.0 && l.1 > 300.0));
+    }
+
     #[test]
     fn text_flows_on_both_sides_of_a_centred_object() {
         let mut s = Session::new();
diff --git a/crates/engine/src/cmd/threads.rs b/crates/engine/src/cmd/threads.rs
index c1c3801e40..35f67f64c2 100644
--- a/crates/engine/src/cmd/threads.rs
+++ b/crates/engine/src/cmd/threads.rs
@@ -68,11 +68,8 @@ pub fn specs() -> Vec<CommandSpec> {
 fn has_thread_selection(s: &Session) -> std::result::Result<(), String> {
     has_selection(s)?;
     let st = s.active().ok_or("no document open")?;
-    if st.selection.objects.iter().any(|id| st.doc.text_threads.iter().any(|t| t.contains(id))) {
-        Ok(())
-    } else {
-        Err("no threaded text selected".into())
-    }
+    let selected: Ids = st.selection.objects.iter().copied().collect();
+    if st.doc.text_threads.iter().flatten().any(|id| selected.contains(id)) { Ok(()) } else { Err("no threaded text selected".into()) }
 }
 
 /// The text object `id` when it can be a frame of a thread: area type or type on a path.
@@ -87,6 +84,43 @@ fn text_of(d: &Document, id: NodeId) -> Option<&TextObject> {
 thread_local! {
     /// Tests: how many threads' stories [`reflow`] copied on this thread.
     static COPIED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+    /// Tests: how many frames [`leave_threads`] passed to [`continued_marks`] on this thread.
+    static MARK_VISITS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+    /// Tests: how many lookups and insertions [`Ids`] made on this thread.
+    static ID_LOOKS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+/// A set of node ids, for the threaded-text commands to test whether a frame is selected, already
+/// listed or in a thread in the same time however many ids the set holds.
+#[derive(Clone, Default)]
+struct Ids(std::collections::HashSet<NodeId>);
+
+impl Ids {
+    fn contains(&self, id: &NodeId) -> bool {
+        #[cfg(test)]
+        ID_LOOKS.with(|c| c.set(c.get() + 1));
+        self.0.contains(id)
+    }
+
+    /// Add `id` to the set; whether it was not in it already.
+    fn insert(&mut self, id: NodeId) -> bool {
+        #[cfg(test)]
+        ID_LOOKS.with(|c| c.set(c.get() + 1));
+        self.0.insert(id)
+    }
+}
+
+impl FromIterator<NodeId> for Ids {
+    fn from_iter<I: IntoIterator<Item = NodeId>>(ids: I) -> Self {
+        Self(ids.into_iter().collect())
+    }
+}
+
+/// [`vectorcraft_text::thread::continued`] for the frames of a thread that [`leave_threads`] marks.
+fn continued_marks(frames: &[&TextObject]) -> Vec<bool> {
+    #[cfg(test)]
+    MARK_VISITS.with(|c| c.set(c.get() + frames.len()));
+    vectorcraft_text::thread::continued(frames)
 }
 
 /// Re-flow every thread with a frame that changed between `before` and `doc` (structural sharing
@@ -361,20 +395,74 @@ pub(crate) fn mark_continued(doc: &mut Document) {
     }
 }
 
+#[cfg(test)]
+thread_local! {
+    /// Tests: how many times [`story_of`] and [`ThreadIndex::of`] went through the document's
+    /// threads on this thread.
+    static THREAD_SCANS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+/// Tests: how many times [`story_of`] and [`ThreadIndex::of`] have gone through the document's
+/// threads on this thread.
+#[cfg(test)]
+pub(crate) fn thread_scans() -> usize {
+    THREAD_SCANS.with(std::cell::Cell::get)
+}
+
 /// The frames of the thread that `id` is a frame of, in thread order, each area type or type on a
 /// path; empty when `id` is in no thread or the thread has fewer than two such frames.
 pub(crate) fn story_of(d: &Document, id: NodeId) -> Vec<NodeId> {
+    #[cfg(test)]
+    THREAD_SCANS.with(|c| c.set(c.get() + 1));
     let Some(thread) = d.text_threads.iter().find(|t| t.contains(&id)) else { return vec![] };
+    story_in(d, thread, id)
+}
+
+/// [`story_of`] for `id` in `thread`, the first of the document's threads that lists it.
+pub(crate) fn story_in(d: &Document, thread: &[NodeId], id: NodeId) -> Vec<NodeId> {
     let frames: Vec<NodeId> = thread.iter().copied().filter(|f| text_of(d, *f).is_some()).collect();
     if frames.len() >= 2 && frames.contains(&id) { frames } else { vec![] }
 }
 
+/// A document's text threads looked up by frame, built in one pass over them, for a command that
+/// asks [`ThreadIndex::threaded`] of each of many objects.
+pub(crate) struct ThreadIndex<'a> {
+    doc: &'a Document,
+    /// Each object the threads list, with the index of the first thread that lists it.
+    first: std::collections::HashMap<NodeId, usize>,
+    /// Each thread's count of entries that are area type or type on a path.
+    live: Vec<usize>,
+}
+
+impl<'a> ThreadIndex<'a> {
+    pub(crate) fn of(doc: &'a Document) -> Self {
+        #[cfg(test)]
+        THREAD_SCANS.with(|c| c.set(c.get() + 1));
+        let mut first = std::collections::HashMap::new();
+        let mut live = Vec::with_capacity(doc.text_threads.len());
+        for (i, thread) in doc.text_threads.iter().enumerate() {
+            for id in thread {
+                first.entry(*id).or_insert(i);
+            }
+            live.push(thread.iter().filter(|id| text_of(doc, **id).is_some()).count());
+        }
+        Self { doc, first, live }
+    }
+
+    /// Whether `id` is a frame of a thread: [`story_of`] is not empty for it.
+    pub(crate) fn threaded(&self, id: NodeId) -> bool {
+        self.first.get(&id).and_then(|i| self.live.get(*i)).is_some_and(|n| *n >= 2) && text_of(self.doc, id).is_some()
+    }
+}
+
 /// `ids` followed by the other frames of the threads they are in, each once, in thread order.
 pub(crate) fn with_threads(d: &Document, ids: &[NodeId]) -> Vec<NodeId> {
+    let given: Ids = ids.iter().copied().collect();
+    let mut listed = given.clone();
     let mut out = ids.to_vec();
-    for thread in d.text_threads.iter().filter(|t| t.iter().any(|id| ids.contains(id))) {
+    for thread in d.text_threads.iter().filter(|t| t.iter().any(|id| given.contains(id))) {
         for id in thread {
-            if !out.contains(id) && text_of(d, *id).is_some() {
+            if text_of(d, *id).is_some() && listed.insert(*id) {
                 out.push(*id);
             }
         }
@@ -399,13 +487,14 @@ pub(crate) fn frames(d: &Document) -> Vec<(NodeId, TextObject)> {
 /// threaded and the frames before it end inside one. A threaded frame whose mark changes lays out
 /// its first line again, so its thread re-flows after the edit.
 pub(crate) fn leave_threads(d: &mut Document, was: &[(NodeId, TextObject)]) {
-    let gone: Vec<(NodeId, &TextObject, Option<NodeId>)> =
-        was.iter().filter(|(id, _)| text_of(d, *id).is_none()).map(|(id, t)| (*id, t, kept_type(d, *id))).collect();
+    // Each frame that left, with the type that takes its place.
+    let gone: std::collections::HashMap<NodeId, (&TextObject, Option<NodeId>)> =
+        was.iter().filter(|(id, _)| text_of(d, *id).is_none()).map(|(id, t)| (*id, (t, kept_type(d, *id)))).collect();
     if gone.is_empty() {
         return;
     }
-    let find = |id: &NodeId| gone.iter().find(|(g, _, _)| g == id);
-    let mut stayed = vec![];
+    let find = |id: &NodeId| gone.get(id);
+    let mut changed = vec![];
     for i in 0..d.text_threads.len() {
         let thread = d.text_threads[i].clone();
         if !thread.iter().any(|id| find(id).is_some()) {
@@ -414,28 +503,33 @@ pub(crate) fn leave_threads(d: &mut Document, was: &[(NodeId, TextObject)]) {
         let keep: Vec<NodeId> = thread
             .iter()
             .filter_map(|id| match find(id) {
-                Some((_, _, kept)) => *kept,
+                Some((_, kept)) => *kept,
                 None => Some(*id),
             })
             .collect();
-        if let (Some((_, last, None)), Some(stay)) = (thread.last().and_then(find), keep.last()) {
+        if let (Some((last, None)), Some(stay)) = (thread.last().and_then(find), keep.last()) {
             take_overflow(d, *stay, last);
         }
-        stayed.extend(keep.iter().copied());
+        changed.push(keep.clone());
         d.text_threads[i] = keep;
     }
     d.text_threads.retain(|t| t.len() >= 2);
-    let marks: Vec<(NodeId, bool)> = stayed
-        .iter()
-        .map(|id| {
-            let on = d.text_threads.iter().find(|t| t.contains(id)).is_some_and(|t| {
-                let live: Vec<(NodeId, &TextObject)> = t.iter().filter_map(|i| Some((*i, text_of(d, *i)?))).collect();
-                let frames: Vec<&TextObject> = live.iter().map(|(_, f)| *f).collect();
-                live.iter().zip(vectorcraft_text::thread::continued(&frames)).any(|((i, _), on)| on && i == id)
-            });
-            (*id, on)
-        })
-        .collect();
+    // One pass over each changed thread: a frame left alone continues nothing, and the area type and
+    // type on a path of a thread that stays take their marks in thread order.
+    let mut marks: Vec<(NodeId, bool)> = vec![];
+    for keep in &changed {
+        if keep.len() < 2 {
+            marks.extend(keep.iter().map(|id| (*id, false)));
+            continue;
+        }
+        let live: Vec<(NodeId, &TextObject)> = keep.iter().filter_map(|i| Some((*i, text_of(d, *i)?))).collect();
+        let frames: Vec<&TextObject> = live.iter().map(|(_, f)| *f).collect();
+        let mut on: std::collections::HashMap<NodeId, bool> = std::collections::HashMap::new();
+        for ((id, _), mark) in live.iter().zip(continued_marks(&frames)) {
+            *on.entry(*id).or_default() |= mark;
+        }
+        marks.extend(keep.iter().map(|id| (*id, on.get(id).copied().unwrap_or(false))));
+    }
     for (id, on) in marks {
         if text_of(d, id).is_some_and(|t| t.first_para_continues != on)
             && let Some(NodeKind::Text(t)) = d.node_mut(id).map(|n| &mut n.kind)
@@ -450,21 +544,23 @@ pub(crate) fn leave_threads(d: &mut Document, was: &[(NodeId, TextObject)]) {
 /// thread with frames outside `art`, to the text it shows. When such a frame leaves its thread,
 /// [`leave_threads`] puts the text it has no room for after the text of the last frame that stays.
 pub(crate) fn keep_shown_text(d: &Document, art: &mut Node) {
-    let mut inside = vec![];
-    art.walk(&mut |n| inside.push(n.id));
-    let last: Vec<NodeId> = d
+    let mut inside = Ids::default();
+    art.walk(&mut |n| {
+        inside.insert(n.id);
+    });
+    let last: Ids = d
         .text_threads
         .iter()
         .filter(|t| t.iter().any(|id| !inside.contains(id)))
         .filter_map(|t| t.last().copied().filter(|id| inside.contains(id)))
         .collect();
-    if !last.is_empty() {
+    if !last.0.is_empty() {
         cut_to_shown(art, &last);
     }
 }
 
 /// Cut the area type and type on a path `ids` in `n` to the text each one shows.
-fn cut_to_shown(n: &mut Node, ids: &[NodeId]) {
+fn cut_to_shown(n: &mut Node, ids: &Ids) {
     if ids.contains(&n.id)
         && let NodeKind::Text(t) = &mut n.kind
         && !matches!(t.kind, TextKind::Point)
@@ -567,21 +663,35 @@ fn create(s: &mut Session, _: &Value) -> Result<Value> {
                 *d.node_mut(*id).ok_or(EngineError::NoNode(*id))? = f;
             }
         }
-        // Existing threads containing any of these frames merge into the new one, keeping order.
+        // Existing threads containing any of these frames merge into the new one, keeping order:
+        // each frame takes in the first thread not yet taken in that lists it.
+        let mut threads: Vec<Option<Vec<NodeId>>> = std::mem::take(&mut d.text_threads).into_iter().map(Some).collect();
+        let mut listing: std::collections::HashMap<NodeId, Vec<usize>> = std::collections::HashMap::new();
+        for (i, t) in threads.iter().enumerate() {
+            for id in t.iter().flatten() {
+                listing.entry(*id).or_default().push(i);
+            }
+        }
         let mut order: Vec<NodeId> = vec![];
+        let mut listed = Ids::default();
         for id in &ids {
-            match d.text_threads.iter().position(|t| t.contains(id)) {
-                Some(i) => {
-                    for x in d.text_threads.remove(i) {
-                        if !order.contains(&x) {
+            let thread = listing.get(id).and_then(|at| at.iter().find_map(|i| threads[*i].take()));
+            match thread {
+                Some(thread) => {
+                    for x in thread {
+                        if listed.insert(x) {
                             order.push(x);
                         }
                     }
                 }
-                None if !order.contains(id) => order.push(*id),
-                None => {}
+                None => {
+                    if listed.insert(*id) {
+                        order.push(*id);
+                    }
+                }
             }
         }
+        d.text_threads = threads.into_iter().flatten().collect();
         d.text_threads.push(order);
         // Force a re-flow of the new thread on this edit.
         touch(d, ids[0]);
@@ -706,11 +816,12 @@ fn touch(d: &mut Document, id: NodeId) {
 }
 
 fn release(s: &mut Session, _: &Value) -> Result<Value> {
-    let ids = selected_roots(s)?;
+    let ids: Ids = selected_roots(s)?.into_iter().collect();
     s.edit("Release Threaded Text", |d, _| {
         // The released frames' text joins the rest of the story (they become empty).
-        for thread in d.text_threads.clone() {
-            let (out, keep): (Vec<NodeId>, Vec<NodeId>) = thread.iter().partition(|i| ids.contains(i));
+        for i in 0..d.text_threads.len() {
+            let thread = d.text_threads[i].clone();
+            let (out, keep): (Vec<NodeId>, Vec<NodeId>) = thread.iter().partition(|id| ids.contains(id));
             if out.is_empty() {
                 continue;
             }
@@ -750,7 +861,6 @@ fn release(s: &mut Session, _: &Value) -> Result<Value> {
                 t.first_para_continues = false;
                 refresh_bounds(t);
             }
-            let i = d.text_threads.iter().position(|t| *t == thread).unwrap_or(0);
             d.text_threads[i] = keep;
         }
         d.text_threads.retain(|t| t.len() >= 2);
@@ -760,7 +870,7 @@ fn release(s: &mut Session, _: &Value) -> Result<Value> {
 }
 
 fn remove(s: &mut Session, _: &Value) -> Result<Value> {
-    let ids = selected_roots(s)?;
+    let ids: Ids = selected_roots(s)?.into_iter().collect();
     s.edit("Remove Threading", |d, _| {
         let (gone, kept): (Vec<Vec<NodeId>>, Vec<Vec<NodeId>>) =
             std::mem::take(&mut d.text_threads).into_iter().partition(|t| t.iter().any(|i| ids.contains(i)));
diff --git a/crates/engine/src/cmd/threads/tests.rs b/crates/engine/src/cmd/threads/tests.rs
index a622901c01..2694a61e6c 100644
--- a/crates/engine/src/cmd/threads/tests.rs
+++ b/crates/engine/src/cmd/threads/tests.rs
@@ -245,6 +245,28 @@ fn a_frame_left_alone_by_a_dropped_repeat_stops_continuing() {
     assert_eq!(t.plain_text(), "Tail");
 }
 
+/// [`ThreadIndex::threaded`] answers as [`story_of`] does, by the first thread that lists an
+/// object, also for threads listed more than once, with point type, other art and missing ids.
+#[test]
+fn thread_index_matches_story_of() {
+    let (mut s, a, b) = setup();
+    s.execute("text.thread.create", &json!({})).unwrap();
+    let c = s.execute("text.create", &json!({"x": 400, "y": 10, "text": "C", "area": {"width": 150, "height": 60}})).unwrap()["id"].as_u64().unwrap();
+    let p = s.execute("text.create", &json!({"x": 10, "y": 250, "text": "Point"})).unwrap()["id"].as_u64().unwrap();
+    let r = s.execute("shape.rectangle", &json!({"x": 400, "y": 200, "width": 50, "height": 50})).unwrap()["id"].as_u64().unwrap();
+    let mut d = (*s.doc().unwrap().doc).clone();
+    let [fa, fb, fc, fp, fr, fx] = [a, b, c, p, r, 9_999_999].map(NodeId);
+    // a's first thread has one frame beside point type, c's has one beside a rectangle, and b's
+    // lists a twice.
+    d.text_threads = vec![vec![fp, fa], vec![fa, fb, fa], vec![fc, fr], vec![fc, fb], vec![fx, fb]];
+    let index = ThreadIndex::of(&d);
+    let got: Vec<(bool, bool)> = [fa, fb, fc, fp, fr, fx].iter().map(|id| (index.threaded(*id), !story_of(&d, *id).is_empty())).collect();
+    let want: Vec<(bool, bool)> = [false, true, false, false, false, false].iter().map(|t| (*t, *t)).collect();
+    assert_eq!(got, want);
+    d.text_threads.clear();
+    assert!(!ThreadIndex::of(&d).threaded(fb));
+}
+
 #[test]
 fn edits_copy_only_the_stories_of_threads_whose_frames_changed() {
     let (mut s, a, b) = setup();
@@ -1053,6 +1075,246 @@ fn a_frame_that_starts_its_thread_after_outlining_has_its_first_line_indent() {
     }
 }
 
+/// Whether frame `id` of `d` is marked as continuing a paragraph.
+fn marked(d: &Document, id: NodeId) -> bool {
+    text_of(d, id).unwrap().first_para_continues
+}
+
+/// The marks of `thread`'s frames, each found from the frames before it: a frame continues a
+/// paragraph when the last of them with text does not end with a paragraph break. A frame left
+/// alone continues nothing.
+fn marks_by_scan(d: &Document, thread: &[NodeId]) -> Vec<bool> {
+    (0..thread.len())
+        .map(|k| {
+            thread.len() >= 2
+                && thread[..k]
+                    .iter()
+                    .rev()
+                    .map(|id| text_of(d, *id).unwrap().plain_text())
+                    .find(|t| !t.is_empty())
+                    .is_some_and(|t| !t.ends_with('\n'))
+        })
+        .collect()
+}
+
+/// When frames leave their threads (from the start, the middle or the end of a thread, outlined or
+/// with their type under a new id, leaving a thread with one frame), each frame that stays takes
+/// the mark found from the frames before it, and a thread that lost no frame keeps its marks.
+#[test]
+fn frames_that_stay_after_others_leave_their_threads_take_the_marks_of_their_place() {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
+    let mut frame = |text: &str| {
+        NodeId(new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": text, "area": {"width": 150, "height": 60}})).unwrap()))
+    };
+    let [a1, a2, a3, a4, a5] = ["One", "", "Two\n", "Three", "Four"].map(&mut frame);
+    let [b1, b2] = ["Alpha", "Beta"].map(&mut frame);
+    let [c1, c2] = ["x", "y"].map(&mut frame);
+    let [d1, d2, d3, d4] = ["M", "N\n", "O", "P"].map(&mut frame);
+    let rect = NodeId(new_id(s.execute("shape.rectangle", &json!({"x": 400, "y": 400, "width": 20, "height": 20})).unwrap()));
+    let mut d = (*s.doc().unwrap().doc).clone();
+    d.text_threads = vec![vec![a1, a2, a3, a4, a5], vec![b1, b2], vec![c1, c2], vec![d1, d2, d3, d4]];
+    // Every mark is the opposite of what it becomes, or (in the thread that loses no frame) wrong.
+    for id in [a1, a2, a3, a4, a5, b1, b2, c1, d1, d2, d3, d4] {
+        if let Some(NodeKind::Text(t)) = d.node_mut(id).map(|n| &mut n.kind) {
+            t.first_para_continues = true;
+        }
+    }
+    let shown: Vec<(NodeId, String)> = d.text_threads.iter().flatten().map(|id| (*id, text_of(&d, *id).unwrap().plain_text())).collect();
+    let was = frames(&d);
+    // a1, b2 and d3 become a rectangle; a4 becomes a group holding its type under a new id.
+    let outline = d.node(rect).unwrap().kind.clone();
+    for id in [a1, b2, d3] {
+        d.node_mut(id).unwrap().kind = outline.clone();
+    }
+    let mut kept = d.node(a4).unwrap().clone();
+    kept.id = d.alloc_id();
+    let new_a4 = kept.id;
+    let layer = d.parent_of(a4);
+    d.remove(a4).unwrap();
+    d.insert(layer, usize::MAX, Node::group(a4, vec![std::sync::Arc::new(kept)])).unwrap();
+    leave_threads(&mut d, &was);
+    assert_eq!(d.text_threads, vec![vec![a2, a3, new_a4, a5], vec![c1, c2], vec![d1, d2, d4]]);
+    for thread in [&[a2, a3, new_a4, a5][..], &[b1], &[d1, d2, d4]] {
+        let want = marks_by_scan(&d, thread);
+        assert_eq!(thread.iter().map(|id| marked(&d, *id)).collect::<Vec<_>>(), want, "{thread:?}");
+    }
+    assert_eq!([a2, a3, new_a4, a5, b1, d1, d2, d4].map(|id| marked(&d, id)), [false, false, false, true, false, false, true, false]);
+    assert_eq!([c1, c2].map(|id| marked(&d, id)), [true, false], "a thread that lost no frame keeps its marks");
+    assert!(!matches!(d.node(a4).unwrap().kind, NodeKind::Text(_)), "the group in the frame's place is not type");
+    for (id, before) in shown {
+        let now = if id == a4 { new_a4 } else { id };
+        if let Some(t) = text_of(&d, now) {
+            assert_eq!(t.plain_text(), before, "frame {id:?} keeps its text");
+        }
+    }
+}
+
+/// The frames that stay in a long thread after one leaves are marked in one pass over the thread.
+#[test]
+fn a_long_thread_is_marked_in_one_pass_when_a_frame_leaves() {
+    const FRAMES: usize = 256;
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
+    let first = NodeId(new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": "w0", "area": {"width": 150, "height": 60}})).unwrap()));
+    let rect = NodeId(new_id(s.execute("shape.rectangle", &json!({"x": 400, "y": 200, "width": 20, "height": 20})).unwrap()));
+    let mut d = (*s.doc().unwrap().doc).clone();
+    let layer = d.parent_of(first);
+    let model = d.node(first).unwrap().clone();
+    let mut thread = vec![first];
+    for k in 1..FRAMES {
+        let mut n = model.clone();
+        n.id = d.alloc_id();
+        if let NodeKind::Text(t) = &mut n.kind {
+            t.runs.truncate(1);
+            t.runs[0].text = format!("w{k}");
+            t.first_para_continues = true;
+        }
+        thread.push(d.insert(layer, usize::MAX, n).unwrap());
+    }
+    d.text_threads = vec![thread.clone()];
+    let was = frames(&d);
+    let out = thread[FRAMES / 2];
+    d.node_mut(out).unwrap().kind = d.node(rect).unwrap().kind.clone();
+    MARK_VISITS.with(|c| c.set(0));
+    leave_threads(&mut d, &was);
+    let visits = MARK_VISITS.with(std::cell::Cell::get);
+    let rest: Vec<NodeId> = thread.iter().copied().filter(|id| *id != out).collect();
+    assert_eq!(d.text_threads, vec![rest.clone()]);
+    assert!(visits <= FRAMES, "{visits} frames visited to mark a thread of {} frames", rest.len());
+    assert_eq!(rest.iter().map(|id| marked(&d, *id)).collect::<Vec<_>>(), marks_by_scan(&d, &rest));
+}
+
+/// `count` threads of `per` area type frames each, made in one edit, each frame holding a word.
+fn many_threads(count: usize, per: usize) -> (Session, Vec<Vec<NodeId>>) {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 600, "height": 300})).unwrap();
+    let first = NodeId(new_id(s.execute("text.create", &json!({"x": 10, "y": 10, "text": "w", "area": {"width": 150, "height": 60}})).unwrap()));
+    let threads = s
+        .edit("Make", |d, _| {
+            let layer = d.parent_of(first);
+            let model = d.node(first).unwrap().clone();
+            let mut threads = vec![];
+            for _ in 0..count {
+                let mut thread = vec![];
+                for _ in 0..per {
+                    let mut n = model.clone();
+                    n.id = d.alloc_id();
+                    thread.push(d.insert(layer, usize::MAX, n).unwrap());
+                }
+                threads.push(thread);
+            }
+            d.text_threads = threads.clone();
+            Ok(threads)
+        })
+        .unwrap();
+    assert_eq!(s.doc().unwrap().doc.text_threads, threads);
+    (s, threads)
+}
+
+/// Select the first frame of each of `threads`.
+fn select_firsts(s: &mut Session, threads: &[Vec<NodeId>]) {
+    let ids: Vec<u64> = threads.iter().map(|t| t[0].0).collect();
+    s.execute("select.set", &json!({ "ids": ids })).unwrap();
+}
+
+/// Reset the count of [`Ids`] lookups, run `f`, and give its result with the lookups it made.
+fn looks<T>(f: impl FnOnce() -> T) -> (T, usize) {
+    ID_LOOKS.with(|c| c.set(0));
+    let out = f();
+    (out, ID_LOOKS.with(std::cell::Cell::get))
+}
+
+/// Whether Release Selection and Remove Threading are available is found in one pass over the
+/// threads' frames, however many frames are selected.
+#[test]
+fn thread_commands_are_offered_after_one_pass_over_the_threads() {
+    let (mut s, made) = many_threads(300, 3);
+    let (threads, loose) = made.split_at(150);
+    s.edit("Unthread", |d, _| {
+        d.text_threads = threads.to_vec();
+        Ok(())
+    })
+    .unwrap();
+    // 450 frames out of any thread, then the last frame of the last thread.
+    let mut ids: Vec<u64> = loose.iter().flatten().map(|id| id.0).collect();
+    ids.push(threads[149][2].0);
+    s.execute("select.set", &json!({ "ids": ids })).unwrap();
+    let (offered, n) = looks(|| has_thread_selection(&s));
+    assert!(offered.is_ok());
+    assert!(n <= 2 * (451 + 450), "{n} id lookups");
+    s.execute("select.set", &json!({ "ids": ids[..450] })).unwrap();
+    assert!(has_thread_selection(&s).is_err(), "frames out of any thread are no threaded text");
+    let rect = new_id(s.execute("shape.rectangle", &json!({"x": 400, "y": 200, "width": 20, "height": 20})).unwrap());
+    s.execute("select.set", &json!({"ids": [rect]})).unwrap();
+    assert!(has_thread_selection(&s).is_err(), "a rectangle is no threaded text");
+}
+
+/// The frames of the selected frames' threads are listed with one lookup per frame.
+#[test]
+fn the_frames_threaded_with_a_selection_are_listed_in_one_pass() {
+    let (s, threads) = many_threads(150, 3);
+    let firsts: Vec<NodeId> = threads.iter().map(|t| t[0]).collect();
+    let d = &s.doc().unwrap().doc;
+    let (all, n) = looks(|| with_threads(d, &firsts));
+    let mut want = firsts.clone();
+    want.extend(threads.iter().flat_map(|t| t[1..].iter().copied()));
+    assert_eq!(all, want);
+    assert!(n <= 4 * (150 + 450), "{n} id lookups");
+}
+
+/// The last frames of many threads copied out of them are found with a few lookups per frame and
+/// per object copied.
+#[test]
+fn the_last_frames_copied_out_of_many_threads_are_found_in_one_pass() {
+    let (s, threads) = many_threads(150, 3);
+    let d = &s.doc().unwrap().doc;
+    let lasts: Vec<std::sync::Arc<Node>> = threads.iter().map(|t| std::sync::Arc::new(d.node(t[2]).unwrap().clone())).collect();
+    let mut art = Node::group(NodeId(u64::MAX), lasts);
+    let before = art.clone();
+    let ((), n) = looks(|| keep_shown_text(d, &mut art));
+    assert!(n <= 4 * (151 + 450), "{n} id lookups");
+    assert_eq!(art, before, "each copied frame already shows all of its word");
+}
+
+/// Threading one frame of each of many threads merges them in one pass, in the order of the
+/// selection.
+#[test]
+fn creating_a_thread_from_many_threads_merges_them_in_one_pass() {
+    let (mut s, threads) = many_threads(150, 3);
+    select_firsts(&mut s, &threads);
+    let (made, n) = looks(|| s.execute("text.thread.create", &json!({})));
+    made.unwrap();
+    assert!(n <= 8 * (150 + 450), "{n} id lookups");
+    assert_eq!(s.doc().unwrap().doc.text_threads, vec![threads.concat()]);
+}
+
+/// Release Selection on one frame of each of many threads finds the selected frames with one
+/// lookup per frame.
+#[test]
+fn releasing_frames_of_many_threads_takes_one_pass() {
+    let (mut s, threads) = many_threads(150, 3);
+    select_firsts(&mut s, &threads);
+    let (released, n) = looks(|| s.execute("text.thread.releaseSelection", &json!({})));
+    released.unwrap();
+    assert!(n <= 2 * 450, "{n} id lookups");
+    let rest: Vec<Vec<NodeId>> = threads.iter().map(|t| t[1..].to_vec()).collect();
+    assert_eq!(s.doc().unwrap().doc.text_threads, rest);
+}
+
+/// Remove Threading on the last frame of each of many threads finds the selected frames with one
+/// lookup per frame.
+#[test]
+fn removing_the_threads_of_many_frames_takes_one_pass() {
+    let (mut s, threads) = many_threads(150, 3);
+    let lasts: Vec<u64> = threads.iter().map(|t| t[2].0).collect();
+    s.execute("select.set", &json!({ "ids": lasts })).unwrap();
+    let (removed, n) = looks(|| s.execute("text.thread.remove", &json!({})));
+    removed.unwrap();
+    assert!(n <= 2 * 450, "{n} id lookups");
+    assert!(s.doc().unwrap().doc.text_threads.is_empty());
+}
+
 /// The text that a thread's last frame has no room for is measured as the frame lays it out,
 /// without the first-line indent of the paragraph it continues: when the frame is outlined, the
 /// frame before it takes only that text.
diff --git a/crates/engine/src/cmd/typecmd.rs b/crates/engine/src/cmd/typecmd.rs
index e996591f91..94ed16ebd8 100644
--- a/crates/engine/src/cmd/typecmd.rs
+++ b/crates/engine/src/cmd/typecmd.rs
@@ -1225,8 +1225,8 @@ fn area_options(s: &mut Session, p: &Value) -> Result<Value> {
         .map(|(id, t)| merged(&t.area, t.dynamic_text).map(|o| (id, o)))
         .collect::<Result<_>>()?;
     // Dynamic Text's Block is refused for threaded frames, as `type.dynamicText` refuses it.
-    let frames: Vec<String> =
-        planned.iter().filter(|(id, (_, block))| *block && !super::threads::story_of(d, *id).is_empty()).map(|(id, _)| id.0.to_string()).collect();
+    let threads = super::threads::ThreadIndex::of(d);
+    let frames: Vec<String> = planned.iter().filter(|(id, (_, block))| *block && threads.threaded(*id)).map(|(id, _)| id.0.to_string()).collect();
     if !frames.is_empty() {
         let frames = frames.join(", ");
         return Err(bad(C, format!("area type in a thread cannot use Dynamic Text: {frames}")));
diff --git a/crates/engine/src/cmd/typecmd/area_tests.rs b/crates/engine/src/cmd/typecmd/area_tests.rs
index e71948086f..c68334e2c0 100644
--- a/crates/engine/src/cmd/typecmd/area_tests.rs
+++ b/crates/engine/src/cmd/typecmd/area_tests.rs
@@ -1663,6 +1663,108 @@ fn tate_chu_yoko_settings_are_character_attributes_saved_only_when_set() {
     assert_eq!(offsets(&s), before);
 }
 
+/// Warichu and Warichu Settings (Character panel menu, East Asian options): character attributes
+/// saved only when they differ from their defaults (off, 2 lines, no gap, 50%, Auto). Both
+/// commands set them in one undo step, a call that changes nothing records none, a bad value is
+/// refused naming the key before anything changes, the file and character styles keep them, and
+/// SVG and PDF write type with warichu as outlines.
+#[test]
+fn warichu_is_a_character_attribute_set_saved_and_exported() {
+    use vectorcraft_doc::WarichuAlign;
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+    let id = s.execute("text.create", &json!({"x": 10, "y": 50, "text": "ab cdef g"})).unwrap()["id"].as_u64().unwrap();
+    let runs = |s: &Session| match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
+        NodeKind::Text(t) => t.runs.clone(),
+        _ => panic!("text"),
+    };
+    let settings = |s: &Session| {
+        runs(s)
+            .iter()
+            .map(|r| (r.text.clone(), r.style.warichu, r.style.warichu_lines, r.style.warichu_gap, r.style.warichu_scale, r.style.warichu_align))
+            .collect::<Vec<_>>()
+    };
+    let saved = serde_json::to_value(&runs(&s)[0].style).unwrap();
+    assert!(["warichu", "warichuLines", "warichuGap", "warichuScale", "warichuAlign"].iter().all(|k| saved.get(*k).is_none()), "{saved}");
+    let plain_svg = vectorcraft_svg::export(&s.doc().unwrap().doc, &Default::default());
+    let plain_pdf = vectorcraft_pdf::export(&s.doc().unwrap().doc, &vectorcraft_pdf::PdfOptions::uncompressed()).unwrap();
+    let text_ops = |pdf: &[u8]| {
+        let s = String::from_utf8_lossy(pdf);
+        s.contains("Tj") || s.contains("TJ")
+    };
+    assert!(plain_svg.contains("<text") && text_ops(&plain_pdf));
+
+    // text.setFormat with the values the characters already have changes nothing and records no
+    // undo step.
+    s.execute("select.set", &json!({"ids": [id]})).unwrap();
+    let undo = s.doc().unwrap().history.undo.len();
+    s.execute("text.setFormat", &json!({"warichu": false, "warichuLines": 2, "warichuAlign": "auto"})).unwrap();
+    assert_eq!(s.doc().unwrap().history.undo.len(), undo);
+    s.execute("select.set", &json!({"ids": []})).unwrap();
+    let undo = s.doc().unwrap().history.undo.len();
+    let p = json!({"id": id, "start": 3, "end": 7, "warichu": true, "warichuLines": 3, "warichuGap": 2.5, "warichuScale": 40, "warichuAlign": "justifyAll"});
+    s.execute("text.setRangeStyle", &p).unwrap();
+    let want = vec![
+        ("ab ".to_string(), false, 2, 0.0, 50.0, WarichuAlign::Auto),
+        ("cdef".to_string(), true, 3, 2.5, 40.0, WarichuAlign::JustifyAll),
+        (" g".to_string(), false, 2, 0.0, 50.0, WarichuAlign::Auto),
+    ];
+    assert_eq!(settings(&s), want);
+    assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1, "one undo step");
+    let saved = serde_json::to_value(&runs(&s)[1].style).unwrap();
+    assert_eq!(
+        [&saved["warichu"], &saved["warichuLines"], &saved["warichuGap"], &saved["warichuScale"], &saved["warichuAlign"]],
+        [&json!(true), &json!(3), &json!(2.5), &json!(40.0), &json!("justifyAll")]
+    );
+    // Saved and reopened as they were.
+    let back = vectorcraft_format::load(&vectorcraft_format::save(&s.doc().unwrap().doc, false)).unwrap();
+    let NodeKind::Text(t) = &back.node(NodeId(id)).unwrap().kind else { panic!("text") };
+    assert_eq!(
+        t.runs.iter().map(|r| (r.style.warichu, r.style.warichu_lines, r.style.warichu_align)).collect::<Vec<_>>(),
+        [(false, 2, WarichuAlign::Auto), (true, 3, WarichuAlign::JustifyAll), (false, 2, WarichuAlign::Auto)]
+    );
+    // A character style captured from the characters carries them.
+    let attrs = super::super::textstyles::char_attrs(&runs(&s)[1].style);
+    assert_eq!(
+        (attrs["warichu"].clone(), attrs["warichuLines"].clone(), attrs["warichuAlign"].clone()),
+        (json!(true), json!(3), json!("justifyAll"))
+    );
+    // Exports draw the stacked lines as outlines.
+    let svg = vectorcraft_svg::export(&s.doc().unwrap().doc, &Default::default());
+    assert!(!svg.contains("<text"), "{svg}");
+    let pdf = vectorcraft_pdf::export(&s.doc().unwrap().doc, &vectorcraft_pdf::PdfOptions::uncompressed()).unwrap();
+    assert!(!text_ops(&pdf));
+
+    // Undo takes the whole change back.
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert!(settings(&s).iter().all(|r| !r.1 && r.2 == 2));
+    s.execute("edit.redo", &json!({})).unwrap();
+
+    // text.setFormat sets the selected objects' characters.
+    s.execute("select.set", &json!({"ids": [id]})).unwrap();
+    s.execute("text.setFormat", &json!({"warichuScale": 70})).unwrap();
+    assert!(settings(&s).iter().all(|r| r.4 == 70.0));
+
+    let before = settings(&s);
+    for (cmd, p, want) in [
+        ("text.setFormat", json!({"warichuLines": 7}), "`warichuLines` must be a whole number from 1 to 6"),
+        ("text.setFormat", json!({"warichuLines": 2.5}), "`warichuLines` must be a whole number from 1 to 6"),
+        ("text.setFormat", json!({"warichuScale": 5}), "`warichuScale` must be from 10 to 100"),
+        ("text.setFormat", json!({"warichuGap": -1}), "`warichuGap` must be from 0 to 100"),
+        ("text.setRangeStyle", json!({"id": id, "warichuGap": "2"}), "`warichuGap` must be a number"),
+        ("text.setRangeStyle", json!({"id": id, "warichu": "yes"}), "`warichu` must be true or false"),
+        (
+            "text.setRangeStyle",
+            json!({"id": id, "warichuAlign": "middle"}),
+            "`warichuAlign` must be one of \"auto\", \"left\", \"center\", \"right\", \"justifyLeft\", \"justifyCenter\", \"justifyRight\", \"justifyAll\"",
+        ),
+    ] {
+        let e = s.execute(cmd, &p).unwrap_err();
+        assert!(matches!(&e, EngineError::BadParams { msg, .. } if msg == want), "{cmd} {p}: {e}");
+    }
+    assert_eq!(settings(&s), before);
+}
+
 /// Insert Aki Left and Right (Character panel, East Asian options): character attributes in
 /// thousandths of an em, 0 by default and saved only when not 0. Both commands set either side
 /// alone, keeping the other side of every run, in one undo step; a value that is not a number or
diff --git a/crates/engine/src/cmd/typecmd/block.rs b/crates/engine/src/cmd/typecmd/block.rs
index c10abbc965..ef14a57558 100644
--- a/crates/engine/src/cmd/typecmd/block.rs
+++ b/crates/engine/src/cmd/typecmd/block.rs
@@ -220,6 +220,7 @@ pub(crate) fn block_fit(t: &mut TextObject) -> bool {
                 st.baseline_shift *= f;
                 st.tcy_up_down *= f;
                 st.tcy_left_right *= f;
+                st.warichu_gap *= f;
                 st.leading = Some((st.size + gap).max(min_leading));
                 if let Some(art) = &mut piece.inline {
                     art.baseline_shift *= f;
diff --git a/crates/engine/src/cmd/typemenu.rs b/crates/engine/src/cmd/typemenu.rs
index faada86d5f..87c16bb9b9 100644
--- a/crates/engine/src/cmd/typemenu.rs
+++ b/crates/engine/src/cmd/typemenu.rs
@@ -7,6 +7,7 @@ use vectorcraft_doc::{AreaFit, CharStyle, Document, Justify, LockedArtboards, No
 use vectorcraft_geom::{Affine, Rect, shapes};
 
 use super::object::choice;
+use super::threads::ThreadIndex;
 use super::typecmd::{area_text, block_gaps, needed_room, refresh_bounds};
 use super::{
     CommandSpec, EngineError, Result, Session, bad, checked_ids_param, cmd, find_command, has_clipboard, has_doc, has_selection, number_or,
@@ -556,7 +557,7 @@ fn path_center_refusal(d: &Document, ids: &[NodeId]) -> Option<String> {
         let open = open.join(", ");
         return Some(format!("type on an open or compound path cannot be centered on its top or bottom: {open}"));
     }
-    let frames = threaded_ids(d, ids);
+    let frames = threaded_ids(&ThreadIndex::of(d), ids);
     (!frames.is_empty()).then(|| format!("type on a path in a thread cannot be centered on its top or bottom: {frames}"))
 }
 
@@ -783,11 +784,6 @@ fn path_options(s: &mut Session, p: &Value) -> Result<Value> {
     options(s)
 }
 
-/// Whether type `id` is a frame of a thread.
-fn threaded(d: &Document, id: NodeId) -> bool {
-    !super::threads::story_of(d, id).is_empty()
-}
-
 /// Type on a path or area type: the type Dynamic Text works on.
 fn dynamic_type(n: Option<&Node>) -> Option<&TextObject> {
     path_text(n).or_else(|| area_text(n))
@@ -820,17 +816,18 @@ fn has_dynamic_type(s: &Session) -> std::result::Result<(), String> {
 /// path first; None when none is.
 fn threaded_refusal(d: &Document, ids: &[NodeId]) -> Option<String> {
     let (paths, areas): (Vec<NodeId>, Vec<NodeId>) = ids.iter().copied().partition(|id| path_text(d.node(*id)).is_some());
-    let frames = threaded_ids(d, &paths);
+    let threads = ThreadIndex::of(d);
+    let frames = threaded_ids(&threads, &paths);
     if !frames.is_empty() {
         return Some(format!("type on a path in a thread cannot use Dynamic Text: {frames}"));
     }
-    let frames = threaded_ids(d, &areas);
+    let frames = threaded_ids(&threads, &areas);
     (!frames.is_empty()).then(|| format!("area type in a thread cannot use Dynamic Text: {frames}"))
 }
 
-/// The ids among `ids` of frames of threads, as a list for a message; empty when there are none.
-fn threaded_ids(d: &Document, ids: &[NodeId]) -> String {
-    ids.iter().filter(|id| threaded(d, **id)).map(|id| id.0.to_string()).collect::<Vec<_>>().join(", ")
+/// The ids among `ids` of frames of `threads`, as a list for a message; empty when there are none.
+fn threaded_ids(threads: &ThreadIndex, ids: &[NodeId]) -> String {
+    ids.iter().filter(|id| threads.threaded(**id)).map(|id| id.0.to_string()).collect::<Vec<_>>().join(", ")
 }
 
 /// Type › Dynamic Text: set `on` (without it, the opposite of the first object's setting, or on
@@ -969,7 +966,7 @@ fn has_preset_type(s: &Session) -> std::result::Result<(), String> {
     if ids.is_empty() {
         return Err("select point type or type on a path".into());
     }
-    let frames = threaded_ids(d, &ids);
+    let frames = threaded_ids(&ThreadIndex::of(d), &ids);
     if !frames.is_empty() {
         return Err(format!("type on a path in a thread cannot use Dynamic Text: {frames}"));
     }
@@ -1108,7 +1105,7 @@ fn dynamic_text_preset(s: &mut Session, p: &Value) -> Result<Value> {
         if ids.is_empty() {
             return Err(bad(C, "select point type or type on a path"));
         }
-        let frames = threaded_ids(d, &ids);
+        let frames = threaded_ids(&ThreadIndex::of(d), &ids);
         if !frames.is_empty() {
             return Err(bad(C, format!("type on a path in a thread cannot use Dynamic Text: {frames}")));
         }
diff --git a/crates/engine/src/cmd/xform.rs b/crates/engine/src/cmd/xform.rs
index 1e01c8f62e..0fc5340e2f 100644
--- a/crates/engine/src/cmd/xform.rs
+++ b/crates/engine/src/cmd/xform.rs
@@ -21,7 +21,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Free Distort",
             [],
             None,
-            "{corners: [[x,y]×4] (TL, TR, BR, BL), from?: [x0,y0,x1,y1] (default: selection bounds), angle?: degrees (counter-clockwise; `from`, or the selection bounds, is then a box in the frame turned by it, as a rotated bounding box is; default 0), ids?} projective warp of anchors and handles; a linked opacity mask's art is warped with its object, an unlinked one stays",
+            "{corners: [[x,y]×4] (TL, TR, BR, BL), from?: [x0,y0,x1,y1] (default: selection bounds), angle?: degrees (counter-clockwise; `from`, or the selection bounds, is then a box in the frame turned by it, as a rotated bounding box is; default 0), ids?} projective warp of anchors and handles; a linked opacity mask's art is warped with its object, an unlinked one stays; each warped object's bounding box (the objects inside groups and the art of linked masks too) turns as the warp turns the art at its center (object.resetBoundingBox squares it again); corners where the box already stands change nothing and add no undo step",
             has_doc,
             distort
         ),
@@ -109,11 +109,18 @@ impl Projective {
 
 /// Warp `n`'s anchors and handles; gradients (pinned first if unplaced) follow the warp's affine
 /// approximation at their center. The art of a linked opacity mask is warped with the object it
-/// masks; an unlinked one stays where it is.
-fn warp_node(n: &mut Node, pr: &Projective) {
+/// masks; an unlinked one stays where it is. Each warped object's bounding-box angle follows the
+/// warp's affine approximation at that object's own center before the warp (as for the objects
+/// with no editable points); an object with no bounds keeps its angle, and a layer has none.
+/// Returns `n`'s geometric bounds before the warp ([`Node::geometric_bounds`]; none for a layer),
+/// gathered from its children's so that each subtree is measured once.
+fn warp_node(n: &mut Node, pr: &Projective) -> Option<Rect> {
     n.pin_gradients();
-    match &mut n.kind {
+    // The children before these are left out of a group's or compound path's bounds.
+    let skip = n.children().map_or(0, Vec::len) - n.editing_children().len();
+    let before = match &mut n.kind {
         NodeKind::Path { path, live, .. } => {
+            let b = path.bounds();
             *live = None;
             for sp in &mut path.subpaths {
                 for a in &mut sp.anchors {
@@ -122,24 +129,41 @@ fn warp_node(n: &mut Node, pr: &Projective) {
                     a.h_out = pr.apply(a.h_out);
                 }
             }
+            b
         }
-        NodeKind::Layer { children, .. } | NodeKind::Group { children, .. } | NodeKind::Compound { children, .. } => {
-            for c in children.iter_mut() {
-                warp_node(Arc::make_mut(c), pr);
-            }
+        NodeKind::Layer { children, .. } => {
+            warp_children(children, pr, |_| false);
+            None
         }
+        // A clip group is bounded by its clip path.
+        NodeKind::Group { children, clip: true } => warp_children(children, pr, |i| i == 0),
+        NodeKind::Group { children, .. } | NodeKind::Compound { children, .. } => warp_children(children, pr, |i| i >= skip),
         _ => {
             // No editable points: the affine approximation (which maps the gradients too).
-            if let Some(b) = n.geometric_bounds() {
+            let b = n.geometric_bounds();
+            if let Some(b) = b {
                 n.transform(pr.affine_near(b.center()), false);
             }
-            return;
+            return b;
         }
+    };
+    if let Some(b) = before {
+        n.bbox_angle = vectorcraft_doc::orient::transformed_angle(n.bbox_angle, pr.affine_near(b.center()));
     }
     if let Some(m) = n.extras_if_any().and_then(|x| x.mask.as_mut()).filter(|m| m.linked) {
         warp_node(Arc::make_mut(&mut m.art), pr);
     }
     n.appearance.warp_gradients(&|p| pr.affine_near(p));
+    before
+}
+
+/// Warps each of `children` and returns the union of the pre-warp bounds of those `counts` picks
+/// by index.
+fn warp_children(children: &mut [Arc<Node>], pr: &Projective, counts: impl Fn(usize) -> bool) -> Option<Rect> {
+    children.iter_mut().enumerate().fold(None, |acc, (i, c)| {
+        let b = warp_node(Arc::make_mut(c), pr);
+        if counts(i) { vectorcraft_geom::union_opt(acc, b) } else { acc }
+    })
 }
 
 fn distort(s: &mut Session, p: &Value) -> Result<Value> {
@@ -178,6 +202,11 @@ fn distort(s: &mut Session, p: &Value) -> Result<Value> {
     if !r.width().is_finite() || !r.height().is_finite() || r.width().abs() < 1e-9 || r.height().abs() < 1e-9 {
         return Err(bad(C, "cannot distort a zero-size or non-finite bounding box"));
     }
+    let ids_json = json!({ "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>() });
+    // Corners that stay where they are change nothing: no edit and no undo step.
+    if [tl, tr, br, bl] == src.corners() {
+        return Ok(ids_json);
+    }
     let pr = Projective::from_box(src, [tl, tr, br, bl]);
     s.edit("Free Distort", |d, _| {
         for id in &ids {
@@ -187,7 +216,7 @@ fn distort(s: &mut Session, p: &Value) -> Result<Value> {
         }
         Ok(())
     })?;
-    Ok(json!({ "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>() }))
+    Ok(ids_json)
 }
 
 // ---------- eyedropper ----------
diff --git a/crates/engine/src/doc_state.rs b/crates/engine/src/doc_state.rs
index 10d21266ba..ebd5e4120c 100644
--- a/crates/engine/src/doc_state.rs
+++ b/crates/engine/src/doc_state.rs
@@ -37,6 +37,9 @@ pub struct DocState {
     /// The objects Start Global Edit would take, highlighted before it starts
     /// ([`cmd::globaledit::similar`]), as of a revision. Not saved, not undoable.
     pub(crate) similar_outlines: cmd::globaledit::SimilarCache,
+    /// Whether Start Global Edit supports the one selected object
+    /// ([`cmd::globaledit::SupportCache`]), as of a revision. Not saved, not undoable.
+    pub(crate) global_edit_support: cmd::globaledit::SupportCache,
     /// What leaving symbol editing mode goes back to ([`cmd::symboledit`]).
     pub(crate) symbol_edit_return: cmd::symboledit::Return,
     pub interaction: Option<Interaction>,
@@ -311,6 +314,7 @@ impl DocState {
             isolation: None,
             global_edit: None,
             similar_outlines: Default::default(),
+            global_edit_support: Default::default(),
             symbol_edit_return: Default::default(),
             interaction: None,
             undo_group: None,
diff --git a/crates/engine/src/sanity.rs b/crates/engine/src/sanity.rs
index 22e0ce956f..f1b6fd55bb 100644
--- a/crates/engine/src/sanity.rs
+++ b/crates/engine/src/sanity.rs
@@ -54,7 +54,26 @@ fn rect_in_range(r: vectorcraft_geom::Rect) -> bool {
 }
 
 /// Do the objects `ids` have finite geometry within [`MAX_COORD`] (the ones not there pass)?
+///
+/// A path or compound path whose anchors and handles are all finite and inside the range by a
+/// margin passes without being measured: its curves stay inside their control points. Any other
+/// object, and a path with a point outside that margin, is measured.
 pub(crate) fn objects_in_range(d: &Document, ids: &[NodeId]) -> bool {
     let paths = d.index_paths(ids.iter().copied());
-    ids.iter().all(|id| paths.get(id).and_then(|p| d.node_at(p)).and_then(|n| n.geometric_bounds()).is_none_or(rect_in_range))
+    ids.iter().all(|id| paths.get(id).and_then(|p| d.node_at(p)).is_none_or(|n| points_in_range(n) || n.geometric_bounds().is_none_or(rect_in_range)))
+}
+
+/// Coordinates at most this far from 0 keep a curve's measured bounds within [`MAX_COORD`]
+/// whatever the rounding of its extrema.
+const POINTS_LIMIT: f64 = MAX_COORD * (1.0 - 1e-9);
+
+/// Whether every anchor and handle of path `n`, or of each path of compound path `n`, is finite and
+/// within [`POINTS_LIMIT`]. `false` for any other object.
+fn points_in_range(n: &vectorcraft_doc::Node) -> bool {
+    let near = |p: vectorcraft_geom::Point| p.x.is_finite() && p.y.is_finite() && p.x.abs() <= POINTS_LIMIT && p.y.abs() <= POINTS_LIMIT;
+    match &n.kind {
+        NodeKind::Path { path, .. } => path.subpaths.iter().flat_map(|s| &s.anchors).all(|a| near(a.p) && near(a.h_in) && near(a.h_out)),
+        NodeKind::Compound { .. } => n.editing_children().iter().all(|c| points_in_range(c)),
+        _ => false,
+    }
 }
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index c260b42d90..2f849901a4 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -7,6 +7,7 @@ use vectorcraft_tools::{PointerEvent, PointerKind, ToolKey};
 mod actionset;
 pub(super) mod adjust;
 mod ai_open_path;
+mod anchor_edit_work;
 mod appearance;
 mod areafit;
 mod arrowheads;
diff --git a/crates/engine/src/tests/anchor_edit_work.rs b/crates/engine/src/tests/anchor_edit_work.rs
new file mode 100644
index 0000000000..7ad50a871d
--- /dev/null
+++ b/crates/engine/src/tests/anchor_edit_work.rs
@@ -0,0 +1,111 @@
+//! An edit of one anchor of a long selected path does not measure the path's segments
+//! ([`vectorcraft_geom::path::measured_segments`]) to check that it stays within the canvas, and
+//! an edit that leaves the anchor as it was records no undo step.
+
+use std::collections::BTreeSet;
+use std::sync::Arc;
+
+use serde_json::{Value, json};
+use vectorcraft_doc::{Appearance, Document, Node, NodeId};
+use vectorcraft_geom::path::measured_segments;
+use vectorcraft_geom::{Anchor, PathData, Point, SubPath};
+
+use crate::*;
+
+/// Most segments one anchor edit may measure, however many anchors the path has.
+const MOST_MEASURED: u64 = 16;
+
+/// A session whose document holds one open zigzag path of `n` anchors, selected, with its anchor 5
+/// direct-selected.
+fn long_path(n: usize) -> (Session, NodeId) {
+    let mut d = Document::new(2000.0, 1000.0);
+    let anchors = (0..n).map(|i| Anchor::corner(Point::new(i as f64 * 0.1, if i % 2 == 0 { 100.0 } else { 110.0 }))).collect();
+    let id = d.alloc_id();
+    let node = Node::path(id, PathData::single(SubPath::new(anchors, false)), Appearance::default_art());
+    if let Some(ch) = Arc::make_mut(&mut d.layers[0]).children_mut() {
+        ch.push(Arc::new(node));
+    }
+    let mut s = Session::new();
+    s.add_document(d, None);
+    let st = s.doc_mut().unwrap();
+    st.selection.set([id]);
+    st.selection.anchors.insert(id, BTreeSet::from([(0, 5)]));
+    (s, id)
+}
+
+fn anchor(s: &Session, id: NodeId, ai: usize) -> Anchor {
+    s.doc().unwrap().doc.node(id).unwrap().path_data().unwrap().subpaths[0].anchors[ai]
+}
+
+fn undo_steps(s: &Session) -> usize {
+    s.doc().unwrap().history.undo.len()
+}
+
+/// Runs `cmd` with `p` and returns how many segments it measured.
+fn measured(s: &mut Session, cmd: &str, p: Value) -> u64 {
+    let before = measured_segments();
+    s.execute(cmd, &p).unwrap();
+    measured_segments() - before
+}
+
+#[test]
+fn one_anchor_edit_of_a_long_path_measures_few_segments() {
+    for n in [100, 10_000] {
+        let (mut s, id) = long_path(n);
+        let a = anchor(&s, id, 5);
+        let m = measured(&mut s, "path.moveAnchor", json!({"id": id.0, "anchor": 5, "x": 3, "y": 50}));
+        assert!(m <= MOST_MEASURED, "path.moveAnchor on {n} anchors measured {m} segments");
+        assert_eq!(anchor(&s, id, 5).p, Point::new(3.0, 50.0));
+        let m = measured(&mut s, "path.setHandle", json!({"id": id.0, "anchor": 5, "which": "out", "x": 4, "y": 40}));
+        assert!(m <= MOST_MEASURED, "path.setHandle on {n} anchors measured {m} segments");
+        assert_eq!(anchor(&s, id, 5).h_out, Point::new(4.0, 40.0));
+        let m = measured(&mut s, "path.moveAnchors", json!({"dx": 1, "dy": 0}));
+        assert!(m <= MOST_MEASURED, "path.moveAnchors on {n} anchors measured {m} segments");
+        let m = measured(&mut s, "object.nudge", json!({"dx": 1, "dy": 0}));
+        assert!(m <= MOST_MEASURED, "object.nudge on {n} anchors measured {m} segments");
+        assert_eq!(anchor(&s, id, 5).p, Point::new(5.0, 50.0));
+        // Only anchor 5 moved, and undoing the four edits gives it back.
+        assert_eq!(anchor(&s, id, 4), Anchor::corner(Point::new(4.0 * 0.1, 100.0)));
+        assert_eq!(anchor(&s, id, 6), Anchor::corner(Point::new(6.0 * 0.1, 100.0)));
+        for _ in 0..4 {
+            s.execute("edit.undo", &json!({})).unwrap();
+        }
+        assert_eq!(anchor(&s, id, 5), a);
+    }
+}
+
+/// A handle past the canvas is measured: the edit stands while the curve stays within the canvas,
+/// and is refused once the curve leaves it.
+#[test]
+fn a_handle_past_the_canvas_is_measured() {
+    let (mut s, id) = long_path(10_000);
+    // The curve from anchor 5 reaches 4/9 of the way to its outgoing handle.
+    let x = 2.0 * MAX_COORD;
+    s.execute("path.setHandle", &json!({"id": id.0, "anchor": 5, "which": "out", "x": x, "y": 110})).unwrap();
+    assert_eq!(anchor(&s, id, 5).h_out, Point::new(x, 110.0));
+    let before = s.doc().unwrap().doc.clone();
+    let undo = undo_steps(&s);
+    let x = 3.0 * MAX_COORD;
+    assert!(s.execute("path.setHandle", &json!({"id": id.0, "anchor": 5, "which": "out", "x": x, "y": 110})).is_err());
+    assert!(s.doc().unwrap().doc == before, "the refused edit changed the document");
+    assert_eq!(undo_steps(&s), undo);
+}
+
+/// `path.moveAnchor` to where the anchor is and `path.setHandle` to where the handle is change
+/// nothing and record no undo step.
+#[test]
+fn an_anchor_edit_that_changes_nothing_records_no_undo_step() {
+    let (mut s, id) = long_path(100);
+    let a = anchor(&s, id, 5);
+    s.execute("path.moveAnchor", &json!({"id": id.0, "anchor": 5, "x": a.p.x, "y": a.p.y})).unwrap();
+    assert_eq!(undo_steps(&s), 0, "path.moveAnchor recorded an undo step");
+    s.execute("path.setHandle", &json!({"id": id.0, "anchor": 5, "which": "out", "x": a.h_out.x, "y": a.h_out.y})).unwrap();
+    assert_eq!(undo_steps(&s), 0, "path.setHandle recorded an undo step");
+    assert_eq!(anchor(&s, id, 5), a);
+    // An anchor that is not there is still refused.
+    assert!(s.execute("path.moveAnchor", &json!({"id": id.0, "anchor": 100, "x": 0, "y": 0})).is_err());
+    assert!(s.execute("path.setHandle", &json!({"id": id.0, "anchor": 100, "which": "out", "x": 0, "y": 0})).is_err());
+    // A change still records one.
+    s.execute("path.moveAnchor", &json!({"id": id.0, "anchor": 5, "x": a.p.x + 1.0, "y": a.p.y})).unwrap();
+    assert_eq!(undo_steps(&s), 1);
+}
diff --git a/crates/engine/src/tests/bboxrotate.rs b/crates/engine/src/tests/bboxrotate.rs
index 8907b21cc0..aa1c14885c 100644
--- a/crates/engine/src/tests/bboxrotate.rs
+++ b/crates/engine/src/tests/bboxrotate.rs
@@ -4,7 +4,7 @@
 
 use serde_json::{Value, json};
 use vectorcraft_doc::{Node, OrientedBox};
-use vectorcraft_geom::{Point, Rect};
+use vectorcraft_geom::{Affine, Point, Rect};
 use vectorcraft_tools::bbox::Handle;
 use vectorcraft_tools::{Mods, PointerEvent, PointerKind};
 
@@ -190,6 +190,227 @@ fn free_transform_distort_starts_from_the_turned_box() {
     }
 }
 
+/// Where the line through `a` and `b` crosses the line through `c` and `d`.
+fn cross(a: Point, b: Point, c: Point, d: Point) -> Point {
+    let (r, q) = (b - a, d - c);
+    let t = ((c - a).x * q.y - (c - a).y * q.x) / (r.x * q.y - r.y * q.x);
+    a + r * t
+}
+
+/// The counter-clockwise angle of the direction from `from` to `to`.
+fn direction(from: Point, to: Point) -> f64 {
+    -(to.y - from.y).atan2(to.x - from.x).to_degrees()
+}
+
+fn near_deg(a: f64, b: f64) -> bool {
+    vectorcraft_geom::normalize_deg(a - b).abs() < 1e-6
+}
+
+fn json_points(pts: [Point; 4]) -> Value {
+    json!(pts.map(|p| [p.x, p.y]))
+}
+
+/// `pts` turned by `deg` (counter-clockwise) about `c`.
+fn turned(pts: [Point; 4], c: Point, deg: f64) -> [Point; 4] {
+    let a = Affine::translate(c.to_vec2()) * Affine::rotate(-deg.to_radians()) * Affine::translate(-c.to_vec2());
+    pts.map(|p| a * p)
+}
+
+/// A perspective quad for the 100 × 100 box at the origin: its top-right corner raised 20 pt.
+const RAISED: [(f64, f64); 4] = [(0.0, 0.0), (100.0, -20.0), (100.0, 100.0), (0.0, 100.0)];
+
+fn raised() -> [Point; 4] {
+    RAISED.map(|(x, y)| Point::new(x, y))
+}
+
+/// The angle a warp onto `quad` (from a box square to the page) turns an upright object's x axis
+/// to, where the object's center lands at `center`: every horizontal line of the box is drawn
+/// through the point where the lines of the quad's top and bottom sides cross.
+fn upright_angle_after(quad: [Point; 4], center: Point) -> f64 {
+    direction(cross(quad[0], quad[1], quad[3], quad[2]), center)
+}
+
+/// Where a warped rectangle's center lands: where the diagonals of its warped corners cross.
+fn warped_center(s: &Session, id: NodeId) -> Point {
+    let p = anchors(s, id);
+    assert_eq!(p.len(), 4, "{p:?}");
+    cross(p[0], p[2], p[1], p[3])
+}
+
+#[test]
+fn distort_turns_an_upright_box_with_the_warp_at_its_center() {
+    let mut s = session();
+    let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
+    sel(&mut s, &[a]);
+    let quad = raised();
+    s.execute("object.distort", &json!({ "corners": json_points(quad) })).unwrap();
+    // The top tilts up to the right: a small counter-clockwise angle (atan 0.1 for this quad).
+    let want = upright_angle_after(quad, cross(quad[0], quad[2], quad[1], quad[3]));
+    assert!(near(want, 0.1_f64.atan().to_degrees()), "{want}");
+    assert!(near(angle(&s, a), want), "{} vs {want}", angle(&s, a));
+    // The Selection and Free Transform tools' box stands at it.
+    assert!(near(selection_box(&s).angle, want), "{:?}", selection_box(&s));
+    // Reset Bounding Box squares it to the page and leaves the art.
+    let pts = anchors(&s, a);
+    assert_eq!(s.execute("object.resetBoundingBox", &json!({})).unwrap()["changed"], 1);
+    assert_eq!(angle(&s, a), 0.0);
+    assert_eq!(anchors(&s, a), pts);
+
+    // A warp that only stretches a turned object along its own axes keeps its angle exactly.
+    let mut s = session();
+    let t = turned_rect(&mut s);
+    let b = selection_box(&s);
+    let wide = OrientedBox { angle: b.angle, rect: Rect::new(b.rect.x0, b.rect.y0, b.rect.x1 + 50.0, b.rect.y1) };
+    let r = b.rect;
+    s.execute("object.distort", &json!({"corners": json_points(wide.corners()), "from": [r.x0, r.y0, r.x1, r.y1], "angle": b.angle})).unwrap();
+    assert_eq!(angle(&s, t), b.angle);
+    assert!(near(selection_box(&s).rect.width(), 150.0), "{:?}", selection_box(&s));
+}
+
+/// Every object's angle in `n`'s subtree, opacity mask art included, each with whether it is the
+/// art of an unlinked mask (or inside one).
+fn angles_with_links(n: &Node, unlinked: bool, out: &mut Vec<(f64, bool)>) {
+    out.push((n.bbox_angle, unlinked));
+    for c in n.children().into_iter().flatten() {
+        angles_with_links(c, unlinked, out);
+    }
+    if let Some(m) = &n.extras().mask {
+        angles_with_links(&m.art, unlinked || !m.linked, out);
+    }
+}
+
+fn group_angles(s: &Session, g: NodeId) -> Vec<(f64, bool)> {
+    let mut out = vec![];
+    angles_with_links(s.doc().unwrap().doc.node(g).unwrap(), false, &mut out);
+    out
+}
+
+fn selected(s: &Session) -> NodeId {
+    s.doc().unwrap().selection.objects[0]
+}
+
+#[test]
+fn distort_turns_each_member_and_linked_mask_by_its_own_warp() {
+    let mut s = session();
+    // A path turned 20° with a linked mask turned with it.
+    let a = rect(&mut s, 100.0, 100.0, 60.0, 40.0);
+    let am = rect(&mut s, 100.0, 100.0, 60.0, 40.0);
+    sel(&mut s, &[a, am]);
+    s.execute("object.rotate", &json!({"angle": 20})).unwrap();
+    s.execute("transparency.makeOpacityMask", &json!({})).unwrap();
+    // A path with an unlinked mask.
+    let u = rect(&mut s, 200.0, 100.0, 40.0, 40.0);
+    let um = rect(&mut s, 200.0, 100.0, 40.0, 40.0);
+    sel(&mut s, &[u, um]);
+    s.execute("transparency.makeOpacityMask", &json!({})).unwrap();
+    s.execute("transparency.unlinkOpacityMask", &json!({})).unwrap();
+    // A compound path turned 10°.
+    let c1 = rect(&mut s, 100.0, 200.0, 40.0, 40.0);
+    let c2 = rect(&mut s, 120.0, 220.0, 40.0, 40.0);
+    sel(&mut s, &[c1, c2]);
+    s.execute("object.compoundPath.make", &json!({})).unwrap();
+    let compound = selected(&s);
+    s.execute("object.rotate", &json!({"angle": 10})).unwrap();
+    // A clip group.
+    let k1 = rect(&mut s, 250.0, 200.0, 50.0, 50.0);
+    let k2 = rect(&mut s, 260.0, 210.0, 50.0, 50.0);
+    sel(&mut s, &[k1, k2]);
+    s.execute("object.clippingMask.make", &json!({})).unwrap();
+    let clip = selected(&s);
+    sel(&mut s, &[a, u, compound, clip]);
+    let g = id_of(&s.execute("object.group", &json!({})).unwrap());
+    let before = group_angles(&s, g);
+    assert!(before.len() >= 10 && before.iter().any(|(a, _)| near(*a, 20.0)) && before.iter().any(|(_, u)| *u), "{before:?}");
+    // A warp that turns the group 30° about its center turns every object 30° more, except the
+    // art of the unlinked mask, which stays.
+    let b = s.doc().unwrap().doc.bounds_of(&[g], false).unwrap();
+    let n = undo_len(&s);
+    s.execute("object.distort", &json!({ "corners": json_points(turned(OrientedBox::aligned(b).corners(), b.center(), 30.0)) })).unwrap();
+    assert_eq!(undo_len(&s), n + 1, "one step");
+    let after = group_angles(&s, g);
+    assert_eq!(after.len(), before.len());
+    for ((old, unlinked), (new, _)) in before.iter().zip(&after) {
+        if *unlinked {
+            assert_eq!(new, old, "{before:?} → {after:?}");
+        } else {
+            assert!(near_deg(*new, old + 30.0), "{before:?} → {after:?}");
+        }
+    }
+
+    // Under a perspective warp each object follows the warp at its own center: two members of a
+    // group, one above the other, tilt by different amounts, and the group by the warp at its own
+    // center.
+    let mut s = session();
+    let p = rect(&mut s, 0.0, 0.0, 100.0, 50.0);
+    let q = rect(&mut s, 0.0, 50.0, 100.0, 50.0);
+    sel(&mut s, &[p, q]);
+    let g = id_of(&s.execute("object.group", &json!({})).unwrap());
+    let quad = raised();
+    s.execute("object.distort", &json!({ "corners": json_points(quad) })).unwrap();
+    let (want_p, want_q) = (upright_angle_after(quad, warped_center(&s, p)), upright_angle_after(quad, warped_center(&s, q)));
+    assert!(near(angle(&s, p), want_p) && near(angle(&s, q), want_q), "{} {} vs {want_p} {want_q}", angle(&s, p), angle(&s, q));
+    assert!(want_p > want_q + 1.0, "{want_p} {want_q}");
+    let want_g = upright_angle_after(quad, cross(quad[0], quad[2], quad[1], quad[3]));
+    assert!(near(angle(&s, g), want_g), "{} vs {want_g}", angle(&s, g));
+}
+
+#[test]
+fn mirrored_and_collapsing_distorts_keep_valid_angles() {
+    let mut s = session();
+    let a = rect(&mut s, 0.0, 0.0, 100.0, 50.0);
+    sel(&mut s, &[a]);
+    s.execute("object.rotate", &json!({"angle": 30})).unwrap();
+    // Corners swapped left for right mirror the art: the box stands at the mirrored angle.
+    let b = s.doc().unwrap().doc.bounds_of(&[a], false).unwrap();
+    let [tl, tr, br, bl] = OrientedBox::aligned(b).corners();
+    s.execute("object.distort", &json!({ "corners": json_points([tr, tl, bl, br]) })).unwrap();
+    assert!(near(angle(&s, a), -30.0), "{}", angle(&s, a));
+    // A warp that collapses the art to a point leaves the angle as it was.
+    let n = undo_len(&s);
+    let c = b.center();
+    match s.execute("object.distort", &json!({ "corners": json_points([c; 4]) })) {
+        Ok(_) => assert!(near(angle(&s, a), -30.0), "{}", angle(&s, a)),
+        Err(_) => {
+            assert_eq!(undo_len(&s), n);
+            assert!(near(angle(&s, a), -30.0));
+        }
+    }
+}
+
+#[test]
+fn distort_angles_undo_redo_and_reopen_together() {
+    let mut s = session();
+    let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
+    sel(&mut s, &[a]);
+    let before = anchors(&s, a);
+    let n = undo_len(&s);
+    let b = Rect::new(0.0, 0.0, 100.0, 100.0);
+    s.execute("object.distort", &json!({ "corners": json_points(turned(OrientedBox::aligned(b).corners(), b.center(), 30.0)) })).unwrap();
+    assert_eq!(undo_len(&s), n + 1);
+    assert_eq!(s.doc().unwrap().history.undo.last().map(|e| e.label.as_str()), Some("Free Distort"));
+    assert!(near(angle(&s, a), 30.0), "{}", angle(&s, a));
+    let warped = anchors(&s, a);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!((anchors(&s, a), angle(&s, a)), (before, 0.0));
+    s.execute("edit.redo", &json!({})).unwrap();
+    assert_eq!(anchors(&s, a), warped);
+    assert!(near(angle(&s, a), 30.0));
+    // A native file keeps the angle.
+    let data = s.execute("document.save", &json!({})).unwrap()["dataBase64"].as_str().unwrap().to_string();
+    s.execute("document.open", &json!({"name": "warped.vectorcraft", "dataBase64": data})).unwrap();
+    assert!(near(angle(&s, a), 30.0));
+    sel(&mut s, &[a]);
+    let b = selection_box(&s);
+    assert!(near(b.angle, 30.0) && near(b.rect.width(), 100.0) && near(b.rect.height(), 100.0), "{b:?}");
+    // The next handle drag scales along the turned box: the Right handle 50 pt further out.
+    let right = b.to_doc() * Handle::Right.pos(b.rect);
+    let to = b.to_doc() * (Handle::Right.pos(b.rect) + vectorcraft_geom::Vec2::new(50.0, 0.0));
+    s.select_tool("selection", ViewInfo::default()).unwrap();
+    drag_with(&mut s, &[right, to, to], Mods::default());
+    let nb = selection_box(&s);
+    assert!(near(nb.angle, 30.0) && near(nb.rect.width(), 150.0) && near(nb.rect.height(), 100.0), "{nb:?}");
+}
+
 #[test]
 fn transform_panel_sizes_follow_the_turned_box() {
     let mut s = session();
diff --git a/crates/engine/src/tests/build.rs b/crates/engine/src/tests/build.rs
index 6eeace1073..cb61ac1b9e 100644
--- a/crates/engine/src/tests/build.rs
+++ b/crates/engine/src/tests/build.rs
@@ -3087,6 +3087,144 @@ fn live_paint_bucket_tool_fills_face() {
     assert_eq!(s.doc().unwrap().selection.objects, vec![f.id]);
 }
 
+/// `tool.setOption` refuses an invalid value for the Live Paint tools, naming its key, whether the
+/// tool is active or not and in the `key`/`value` and `values` forms: a switch that is not true or
+/// false, a color that is not an RGB color (an alpha part included), a width that is not a number
+/// and an option the tool does not have. Nothing is set, also from the valid values sent with it,
+/// and the saved settings stay as they were.
+#[test]
+fn live_paint_tool_options_refuse_invalid_values_and_change_nothing() {
+    let colors = [json!(3), json!("nope"), json!("#12345"), json!("#00ff0080"), json!("00ff0080"), json!("#0f08"), json!(null)];
+    let widths = [json!("wide"), json!(null), json!(true)];
+    let switches = [json!("true"), json!(null), json!(1)];
+    for (tool, keys) in
+        [("livePaintBucket", &["paintFills", "paintStrokes", "highlight"][..]), ("livePaintSelection", &["selectFills", "selectStrokes"][..])]
+    {
+        let mut bad: Vec<(&str, Value)> = keys.iter().flat_map(|k| switches.iter().map(move |v| (*k, v.clone()))).collect();
+        bad.extend(colors.iter().map(|v| ("color", v.clone())));
+        bad.extend(widths.iter().map(|v| ("width", v.clone())));
+        bad.push(("colour", json!("#00ff00")));
+        for active in [false, true] {
+            let mut s = session();
+            if active {
+                s.select_tool(tool, ViewInfo::default()).unwrap();
+            }
+            let (options, prefs) = (s.tool_options_of(tool), s.prefs.clone());
+            for (key, v) in &bad {
+                let mut values = serde_json::Map::new();
+                values.insert("width".into(), json!(9));
+                values.insert(key.to_string(), v.clone());
+                for p in [json!({"tool": tool, "values": values}), json!({"tool": tool, "key": key, "value": v})] {
+                    let e = s.set_tool_option_cmd(&p).unwrap_err();
+                    assert!(e.contains(&format!("`{key}`")), "{tool} {p}: {e}");
+                    assert_eq!((s.tool_options_of(tool), &s.prefs), (options.clone(), &prefs), "{tool} {p}");
+                }
+            }
+            // A `key` left without a `value` is an invalid value too.
+            assert!(s.set_tool_option_cmd(&json!({"tool": tool, "key": "color"})).is_err());
+            s.select_tool(tool, ViewInfo::default()).unwrap();
+            assert_eq!(s.tool_options_of(tool), options, "{tool}");
+        }
+    }
+}
+
+/// The Live Paint tools' options take each color form they took before, and a width out of range
+/// is clamped to 1–20 rather than refused; the values are saved with the preferences.
+#[test]
+fn live_paint_tool_options_take_rgb_colors_and_clamp_the_width() {
+    let mut s = session();
+    for tool in ["livePaintBucket", "livePaintSelection"] {
+        for (color, hex) in [("#00FF00", "#00ff00"), ("#0f0", "#00ff00"), ("0000ff", "#0000ff"), ("light blue", "#4f80ff"), ("white", "#ffffff")] {
+            let o = s.set_tool_option_cmd(&json!({"tool": tool, "key": "color", "value": color})).unwrap();
+            assert_eq!(o["color"], hex, "{tool} {color}");
+        }
+        for (width, set) in [(100.0, 20.0), (0.0, 1.0), (-3.0, 1.0), (7.5, 7.5)] {
+            let o = s.set_tool_option_cmd(&json!({"tool": tool, "values": {"width": width}})).unwrap();
+            assert_eq!(o["width"], set, "{tool} {width}");
+        }
+        assert_eq!(s.prefs.tool_settings[tool]["width"], 7.5);
+        assert_eq!(s.prefs.tool_settings[tool]["color"], "#ffffff");
+    }
+    let o = s.set_tool_option_cmd(&json!({"tool": "livePaintBucket", "values": {"paintFills": false, "highlight": false}})).unwrap();
+    assert_eq!((&o["paintFills"], &o["highlight"]), (&json!(false), &json!(false)));
+}
+
+/// Saved Live Paint settings that hold an invalid value still load: the tool keeps its default for
+/// that option and takes the valid ones.
+#[test]
+fn live_paint_tools_load_saved_settings_with_invalid_values() {
+    let mut s = session();
+    let saved = json!({"paintFills": "yes", "highlight": false, "width": "wide", "color": "nope", "paintStrokes": true});
+    s.prefs.tool_settings.insert("livePaintBucket".into(), saved.as_object().unwrap().clone());
+    s.select_tool("livePaintBucket", ViewInfo::default()).unwrap();
+    let o = s.tool_options_of("livePaintBucket");
+    assert_eq!(
+        (&o["paintFills"], &o["paintStrokes"], &o["highlight"], &o["width"], &o["color"]),
+        (&json!(true), &json!(true), &json!(false), &json!(4.0), &json!("#ff2a2a"))
+    );
+}
+
+/// `tool.setOption` refuses an invalid value for the Shape Builder, naming its key, whether the
+/// tool is active or not and in the `key`/`value` and `values` forms: a switch that is not true or
+/// false, a `pickColorFrom` or `selection` that is not one of its names, a `gapLength` that is not
+/// a number, a `highlightColor` that is not an RGB color (an alpha part included) and an option the
+/// tool does not have. Nothing is set, also from the valid values sent with it, and the saved
+/// settings stay as they were.
+#[test]
+fn shape_builder_tool_options_refuse_invalid_values_and_change_nothing() {
+    let tool = "shapeBuilder";
+    let switches = ["openFilledAsClosed", "cursorSwatchPreview", "highlightFill", "gapDetection", "clickStrokeSplitsPath", "highlightStroke"];
+    let mut bad: Vec<(&str, Value)> = switches.iter().flat_map(|k| [json!("true"), json!(null), json!(1)].map(move |v| (*k, v))).collect();
+    bad.extend([json!("Swatches"), json!(true), json!(null), json!("")].map(|v| ("pickColorFrom", v)));
+    bad.extend([json!("straight"), json!(1), json!(null)].map(|v| ("selection", v)));
+    bad.extend([json!("wide"), json!(null), json!(true)].map(|v| ("gapLength", v)));
+    let colors = [json!(3), json!("nope"), json!("#12345"), json!("#00ff0080"), json!("00ff0080"), json!("#0f08"), json!(null)];
+    bad.extend(colors.map(|v| ("highlightColor", v)));
+    bad.push(("color", json!("#00ff00")));
+    for active in [false, true] {
+        let mut s = session();
+        if active {
+            s.select_tool(tool, ViewInfo::default()).unwrap();
+        }
+        let (options, prefs) = (s.tool_options_of(tool), s.prefs.clone());
+        for (key, v) in &bad {
+            let mut values = serde_json::Map::new();
+            values.insert("gapLength".into(), json!(9));
+            values.insert(key.to_string(), v.clone());
+            for p in [json!({"tool": tool, "values": values}), json!({"tool": tool, "key": key, "value": v})] {
+                let e = s.set_tool_option_cmd(&p).unwrap_err();
+                assert!(e.contains(&format!("`{key}`")), "{p}: {e}");
+                assert_eq!((s.tool_options_of(tool), &s.prefs), (options.clone(), &prefs), "{p}");
+            }
+        }
+        s.select_tool(tool, ViewInfo::default()).unwrap();
+        assert_eq!(s.tool_options_of(tool), options);
+    }
+}
+
+/// The Shape Builder's options take each value they took before: the names of `pickColorFrom` and
+/// `selection`, each RGB color form, and a gap length out of range clamped rather than refused.
+#[test]
+fn shape_builder_tool_options_take_valid_values_and_clamp_the_gap() {
+    let mut s = session();
+    let tool = "shapeBuilder";
+    for (color, hex) in [("#00FF00", "#00ff00"), ("#0f0", "#00ff00"), ("0000ff", "#0000ff"), ("light blue", "#4f80ff"), ("white", "#ffffff")] {
+        let o = s.set_tool_option_cmd(&json!({"tool": tool, "key": "highlightColor", "value": color})).unwrap();
+        assert_eq!(o["highlightColor"], hex, "{color}");
+    }
+    for (gap, set) in [(1000.0, vectorcraft_tools::builder::SHAPE_BUILDER_MAX_GAP), (-3.0, 0.0), (7.5, 7.5)] {
+        let o = s.set_tool_option_cmd(&json!({"tool": tool, "values": {"gapLength": gap}})).unwrap();
+        assert_eq!(o["gapLength"], set, "{gap}");
+    }
+    let o = s
+        .set_tool_option_cmd(&json!({"tool": tool, "values": {"pickColorFrom": "swatches", "selection": "straightLine", "gapDetection": true}}))
+        .unwrap();
+    assert_eq!((&o["pickColorFrom"], &o["selection"], &o["gapDetection"]), (&json!("swatches"), &json!("straightLine"), &json!(true)));
+    let o = s.set_tool_option_cmd(&json!({"tool": tool, "values": {"pickColorFrom": "artwork", "selection": "freeform"}})).unwrap();
+    assert_eq!((&o["pickColorFrom"], &o["selection"]), (&json!("artwork"), &json!("freeform")));
+    assert_eq!(s.prefs.tool_settings[tool]["gapLength"], 7.5);
+}
+
 #[test]
 fn live_paint_bucket_alt_sample_paints_next_face_without_changing_selection() {
     let mut s = session();
@@ -4134,7 +4272,10 @@ fn image_trace_expand_by_color_groups_each_colors_paths() {
         sorted.sort();
         assert_eq!(sorted, ["#000000", "#c82832", "#f0f0dc"], "{method}");
         let n = node(&s, g);
-        assert_eq!(names(&n), order, "{method}");
+        // Overlapping fills the ring whole and draws the field inside it above the ring: that path starts a second
+        // group of the field's color, above the black one.
+        let want: Vec<String> = if method == "overlapping" { order.iter().chain(order.first()).cloned().collect() } else { order.clone() };
+        assert_eq!(names(&n), want, "{method}");
         // Each group holds its color's paths, and in turn they are the paths of the trace without
         // byColor, in their order.
         let groups = n.children().unwrap();
@@ -4148,8 +4289,8 @@ fn image_trace_expand_by_color_groups_each_colors_paths() {
         // Release to Layers: a sublayer for each color, in the same order.
         let r = s.execute("layer.releaseToLayers", &json!({"id": g.0})).unwrap();
         let subs = ids(&r);
-        assert_eq!(subs.len(), 3, "{method}");
-        for (sub, name) in subs.iter().zip(&order) {
+        assert_eq!(subs.len(), want.len(), "{method}");
+        for (sub, name) in subs.iter().zip(&want) {
             let l = node(&s, *sub);
             assert!(matches!(l.kind, NodeKind::Layer { .. }), "{method}");
             assert_eq!(names(&l), std::slice::from_ref(name), "{method}");
diff --git a/crates/engine/src/tests/draw2.rs b/crates/engine/src/tests/draw2.rs
index c957e81332..79dbd366f6 100644
--- a/crates/engine/src/tests/draw2.rs
+++ b/crates/engine/src/tests/draw2.rs
@@ -1367,6 +1367,32 @@ fn smooth_tool_reduces_jagged_path() {
     assert_eq!(p.subpaths[0].anchors[0].p, Point::new(100.0, 200.0));
 }
 
+/// The anchors a zigzag `amplitude` points high keeps after one `path.smoothRegion` drag along it
+/// at `fidelity`, with the path, the drag, its radius and the Fidelity all scaled by `scale`: the
+/// same drag on screen zoomed in 1 / `scale` times.
+fn smoothed_zigzag_anchors(amplitude: f64, fidelity: f64, scale: f64) -> usize {
+    let mut s = session();
+    let anchors: Vec<_> =
+        (0..=40).map(|i| json!({"x": (100.0 + i as f64 * 5.0) * scale, "y": (200.0 + if i % 2 == 0 { 0.0 } else { amplitude }) * scale})).collect();
+    let r = s.execute("path.create", &json!({"anchors": anchors})).unwrap();
+    let id = NodeId(r["id"].as_u64().unwrap());
+    let drag: Vec<_> = [(90.0, 200.0), (200.0, 200.0), (310.0, 200.0)].iter().map(|&(x, y)| json!([x * scale, y * scale])).collect();
+    s.execute("path.smoothRegion", &json!({"points": drag, "radius": 12.0 * scale, "fidelity": fidelity * scale})).unwrap();
+    path(&s, id).anchor_count()
+}
+
+/// The Smooth tool sends its Fidelity (screen pixels) in points at Fidelity / zoom, so
+/// `path.smoothRegion` refits at the tolerance it is sent from the lowest Fidelity at the highest
+/// zoom (0.05 px at 64000 %) to the highest at the lowest zoom (100 px at 3.13 %): a drag smooths
+/// as much on screen at any zoom.
+#[test]
+fn smooth_region_refits_at_the_tolerance_sent_at_any_zoom() {
+    for (amplitude, fidelity, scale) in [(1.5, 0.05, 1.0 / 640.0), (1.5, 0.05, 1.0 / 8.0), (5.0, 20.0, 1.0 / 0.0313), (5.0, 20.0, 4.0)] {
+        let want = smoothed_zigzag_anchors(amplitude, fidelity, 1.0);
+        assert_eq!(smoothed_zigzag_anchors(amplitude, fidelity, scale), want, "{amplitude} pt zigzag at {fidelity} px, zoom {}", 1.0 / scale);
+    }
+}
+
 /// A drag of the Smooth tool along a line jagged by up to 6 pt leaves no corner between a curve and
 /// a line: every anchor between the path's ends turns by at most 1°.
 #[test]
@@ -1606,6 +1632,83 @@ fn smoothing_a_whole_closed_path_smooths_a_bump_at_its_start() {
     assert!(start <= far + 0.5, "the bump at the start stays {start} pt high, the far one {far} pt");
 }
 
+/// A straight line along y = 200 from x = 100 to 400, one anchor every 5 pt, whose second and
+/// second-to-last anchors are 1.5 pt off the line: its first and last segments leave and arrive at
+/// 16.7° to it.
+fn smooth_jagged_ends(s: &mut Session) -> NodeId {
+    let anchors: Vec<_> = (0..=60).map(|i| json!({"x": 100.0 + 5.0 * f64::from(i), "y": if i == 1 || i == 59 { 201.5 } else { 200.0 }})).collect();
+    smooth_test_path(s, &anchors, false)
+}
+
+/// The degrees between the direction `sp` leaves its first anchor along (`at_end` false), or arrives
+/// at its last anchor along, and the x axis.
+fn smooth_end_angle(sp: &vectorcraft_geom::SubPath, at_end: bool) -> f64 {
+    let c = sp.segment(if at_end { sp.segment_count() - 1 } else { 0 });
+    let d = if at_end {
+        [c.p3 - c.p2, c.p3 - c.p1, c.p3 - c.p0].into_iter().find(|d| d.hypot() > 1e-9)
+    } else {
+        [c.p1 - c.p0, c.p2 - c.p0, c.p3 - c.p0].into_iter().find(|d| d.hypot() > 1e-9)
+    };
+    d.map_or(f64::NAN, |d| d.y.atan2(d.x).to_degrees().abs())
+}
+
+/// The largest turn, in degrees, at any anchor of `sp` (other than its ends) whose x is in `xs`.
+fn smooth_largest_turn(sp: &vectorcraft_geom::SubPath, xs: std::ops::Range<f64>) -> f64 {
+    let dir = |v: kurbo::Vec2, w: kurbo::Vec2, chord: kurbo::Vec2| [v, w, chord].into_iter().find(|d| d.hypot() > 1e-9).unwrap_or(chord);
+    (1..sp.segment_count())
+        .filter(|&i| xs.contains(&sp.anchors[i].p.x))
+        .map(|i| {
+            let (prev, next) = (sp.segment(i - 1), sp.segment(i));
+            let arrive = dir(prev.p3 - prev.p2, prev.p3 - prev.p1, prev.p3 - prev.p0);
+            let leave = dir(next.p1 - next.p0, next.p2 - next.p0, next.p3 - next.p0);
+            arrive.cross(leave).atan2(arrive.dot(leave)).abs().to_degrees()
+        })
+        .fold(0.0, f64::max)
+}
+
+/// A Smooth drag over the whole of an open path turns the curve at each end to follow the smoothed
+/// path rather than the jag of its first or last segment, and leaves both end points where they were.
+#[test]
+fn smoothing_an_open_path_turns_its_jagged_ends_with_the_path() {
+    let mut s = session();
+    let id = smooth_jagged_ends(&mut s);
+    let before = path(&s, id);
+    assert!(smooth_end_angle(&before.subpaths[0], false) > 16.0 && smooth_end_angle(&before.subpaths[0], true) > 16.0);
+    smooth_pass(&mut s, &smooth_drag_along(200.0, 90.0, 410.0));
+    let p = path(&s, id);
+    assert_ne!(p, before, "the path is smoothed");
+    let sp = &p.subpaths[0];
+    let (first, last) = (sp.anchors[0].p, sp.anchors[sp.anchors.len() - 1].p);
+    assert!(first == Point::new(100.0, 200.0) && last == Point::new(400.0, 200.0), "the ends stay: {first:?} {last:?}");
+    let (start, end) = (smooth_end_angle(sp, false), smooth_end_angle(sp, true));
+    assert!(start <= 5.0, "the path leaves its start at {start}° to the line");
+    assert!(end <= 5.0, "and arrives at its end at {end}°");
+    let off = smooth_test_samples(&p).iter().map(|q| (q.y - 200.0).abs()).fold(0.0, f64::max);
+    assert!(off <= 1.5, "the path stays within {off} pt of the line");
+}
+
+/// A Smooth drag that reaches only the start of an open path turns the curve there, and the rest of
+/// the path, its far end with its jag included, stays as it was, joining the refitted part without a
+/// corner.
+#[test]
+fn a_smooth_drag_turns_only_the_end_it_reaches() {
+    let mut s = session();
+    let id = smooth_jagged_ends(&mut s);
+    let before = path(&s, id);
+    smooth_pass(&mut s, &smooth_drag_along(200.0, 90.0, 200.0));
+    let p = path(&s, id);
+    assert_ne!(p, before, "the start is smoothed");
+    let sp = &p.subpaths[0];
+    assert_eq!(sp.anchors[0].p, Point::new(100.0, 200.0), "the start stays");
+    let start = smooth_end_angle(sp, false);
+    assert!(start <= 5.0, "the path leaves its start at {start}° to the line");
+    let kept = |sp: &vectorcraft_geom::SubPath| sp.anchors.iter().filter(|a| a.p.x >= 215.0).copied().collect::<Vec<_>>();
+    assert_eq!(kept(sp), kept(&before.subpaths[0]), "the anchors out of reach stay as they were");
+    assert!(smooth_end_angle(sp, true) > 16.0, "the far end keeps its jag");
+    let turn = smooth_largest_turn(sp, 101.0..300.0);
+    assert!(turn <= 1.0, "the refitted part joins the rest with a {turn}° turn");
+}
+
 /// `path.smoothRegion` along `drag` with the Smooth tool's reach and default Fidelity → the ids changed.
 fn smooth_pass_ids(s: &mut Session, drag: &[Point]) -> serde_json::Value {
     let pts: Vec<_> = drag.iter().map(|p| json!([p.x, p.y])).collect();
diff --git a/crates/engine/src/tests/dynamic_text.rs b/crates/engine/src/tests/dynamic_text.rs
index 8605a7e052..0bc13dba7d 100644
--- a/crates/engine/src/tests/dynamic_text.rs
+++ b/crates/engine/src/tests/dynamic_text.rs
@@ -456,3 +456,116 @@ fn first_text(s: &Session) -> NodeId {
     });
     found.unwrap()
 }
+
+/// Whether command `id` is enabled for `s`'s selection, with the reason when it is not.
+fn enabled(s: &Session, id: &str) -> std::result::Result<(), String> {
+    command_specs().iter().find(|c| c.id == id).map_or_else(|| Err(format!("no command {id}")), |c| (c.enabled)(s))
+}
+
+/// What `f` returned, and how many times it went through the document's text threads to tell
+/// which objects are frames of one.
+fn scans<T>(f: impl FnOnce() -> T) -> (T, usize) {
+    let before = crate::cmd::threads::thread_scans();
+    let out = f();
+    (out, crate::cmd::threads::thread_scans() - before)
+}
+
+/// Threads `a` with a new 100 pt square frame at (`x`, `y`); the thread's frames.
+fn thread_with_frame(s: &mut Session, a: NodeId, x: f64, y: f64) -> Vec<u64> {
+    let frame = s.execute("shape.rectangle", &json!({"x": x, "y": y, "width": 100, "height": 100})).unwrap()["id"].as_u64().unwrap();
+    s.execute("select.set", &json!({"ids": [a.0, frame]})).unwrap();
+    let r = s.execute("text.thread.create", &json!({})).unwrap();
+    r["ids"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect()
+}
+
+/// `ids` as a type command's refusal lists them.
+fn listed(ids: &[u64]) -> String {
+    ids.iter().map(u64::to_string).collect::<Vec<_>>().join(", ")
+}
+
+/// Dynamic Text, its presets, Center on Top and Bottom and Area Type Options look up the threads
+/// once for a whole selection, not once for each object, and refuse the same frames in the same
+/// order.
+#[test]
+fn type_commands_look_up_threads_once_for_the_whole_selection() {
+    const N: usize = 24;
+    let mut s = session();
+    let area = |s: &mut Session, i: usize| {
+        let x = 10.0 + 30.0 * i as f64;
+        let r = s.execute("text.create", &json!({"x": x, "y": 10, "text": format!("Area {i}"), "area": {"width": 25, "height": 40}})).unwrap();
+        NodeId(r["id"].as_u64().unwrap())
+    };
+    // Area type: every other one is the first frame of a thread of two.
+    let (mut areas, mut threaded) = (vec![], vec![]);
+    for i in 0..N {
+        let a = area(&mut s, i);
+        areas.push(a.0);
+        if i % 2 == 0 {
+            let frames = thread_with_frame(&mut s, a, 10.0 + 30.0 * i as f64, 500.0);
+            assert_eq!(frames.len(), 2, "{frames:?}");
+            areas.push(frames[1]);
+            threaded.extend(frames);
+        }
+    }
+    // The refusal lists the threaded frames in the order the objects are given.
+    areas.reverse();
+    let refused: Vec<u64> = areas.iter().copied().filter(|id| threaded.contains(id)).collect();
+    let before = undo_len(&s);
+    s.execute("select.set", &json!({ "ids": areas })).unwrap();
+    let why = format!("area type in a thread cannot use Dynamic Text: {}", listed(&refused));
+    let (e, n) = scans(|| enabled(&s, "type.dynamicText"));
+    assert_eq!((e, n), (Err(why.clone()), 1));
+    let (e, n) = scans(|| err(s.execute("type.dynamicText", &json!({"on": true, "ids": areas}))));
+    assert!(e.ends_with(&why) && n == 1, "{n}: {e}");
+    let (e, n) = scans(|| err(s.execute("text.areaOptions", &json!({"fit": "block", "ids": areas}))));
+    assert!(e.ends_with(&why) && n == 1, "{n}: {e}");
+    assert_eq!(undo_len(&s), before);
+
+    // Type on a path in a thread comes first, before the area type.
+    let path = on_line(&mut s, "Threaded path");
+    let path_frames = thread_with_frame(&mut s, path, 700.0, 500.0);
+    let mut mixed = areas.clone();
+    mixed.push(path.0);
+    s.execute("select.set", &json!({ "ids": mixed })).unwrap();
+    let why = format!("type on a path in a thread cannot use Dynamic Text: {}", path.0);
+    let (e, n) = scans(|| enabled(&s, "type.dynamicText"));
+    assert_eq!((e, n), (Err(why.clone()), 1));
+    let (e, n) = scans(|| err(s.execute("type.dynamicText", &json!({"on": true, "ids": mixed}))));
+    assert!(e.ends_with(&why) && n == 1, "{n}: {e}");
+
+    // Presets: point type beside type on a path in a thread.
+    let mut points: Vec<u64> = (0..N)
+        .map(|i| s.execute("text.create", &json!({"x": 10.0 + 30.0 * i as f64, "y": 300, "text": "P"})).unwrap()["id"].as_u64().unwrap())
+        .collect();
+    points.insert(N / 2, path.0);
+    s.execute("select.set", &json!({ "ids": points })).unwrap();
+    let (e, n) = scans(|| enabled(&s, "type.dynamicTextPreset"));
+    assert_eq!((e, n), (Err(why.clone()), 1));
+    let (e, n) = scans(|| err(s.execute("type.dynamicTextPreset", &json!({"preset": "arch", "ids": points}))));
+    assert!(e.ends_with(&why) && n == 1, "{n}: {e}");
+
+    // Center on Top and Bottom: type on closed paths, some of it in threads.
+    let mut circles = vec![];
+    let mut in_threads = vec![];
+    for i in 0..N {
+        let (x, y) = (60.0 + 30.0 * i as f64, 200.0);
+        let d = format!("M{} {y} A12 12 0 1 1 {} {y} A12 12 0 1 1 {} {y} Z", x - 12.0, x + 12.0, x - 12.0);
+        let pid = s.execute("path.create", &json!({ "d": d })).unwrap()["id"].as_u64().unwrap();
+        let r = s.execute("text.createInPath", &json!({"path": pid, "mode": "onPath", "text": "O", "size": 6, "at": [x - 12.0, y]})).unwrap();
+        let id = NodeId(r["id"].as_u64().unwrap());
+        if i % 3 == 0 {
+            thread_with_frame(&mut s, id, x, 650.0);
+            in_threads.push(id.0);
+        }
+        circles.push(id.0);
+    }
+    s.execute("select.set", &json!({ "ids": circles })).unwrap();
+    let why = format!("type on a path in a thread cannot be centered on its top or bottom: {}", listed(&in_threads));
+    for c in ["type.pathCenter.top", "type.pathCenter.bottom"] {
+        let (e, n) = scans(|| enabled(&s, c));
+        assert_eq!((e, n), (Err(why.clone()), 1), "{c}");
+        let (e, n) = scans(|| err(s.execute(c, &json!({ "ids": circles }))));
+        assert!(e.ends_with(&why) && n == 1, "{c} {n}: {e}");
+    }
+    assert_eq!(path_frames.len(), 2);
+}
diff --git a/crates/engine/src/tests/globaledit.rs b/crates/engine/src/tests/globaledit.rs
index ac5a494dc7..fa86248cdb 100644
--- a/crates/engine/src/tests/globaledit.rs
+++ b/crates/engine/src/tests/globaledit.rs
@@ -330,18 +330,103 @@ fn global_edit_needs_one_supported_object() {
     let e = s.execute("select.globalEdit", &json!({})).unwrap_err().to_string();
     assert!(e.contains("no similar objects") && e.contains("rotated"), "{e}");
     assert!(s.doc().unwrap().global_edit.is_none());
-    // A group holding type is refused, though another such group exists.
+    // A group holding type is not offered, though another such group exists.
     let group = |s: &mut Session, x: f64| {
         let p = rect(s, x, 100.0, 10.0, 10.0);
         let t = NodeId(s.execute("text.create", &json!({"x": x, "y": 150, "text": "Hi"})).unwrap()["id"].as_u64().unwrap());
         group_of(s, &[p, t])
     };
     let (g, _) = (group(&mut s, 600.0), group(&mut s, 700.0));
+    assert_not_offered(&mut s, g, "a group holding type");
+}
+
+fn enabled(s: &Session, id: &str) -> bool {
+    command_specs().iter().find(|c| c.id == id).is_some_and(|c| (c.enabled)(s).is_ok())
+}
+
+/// With `id` selected, Start Global Edit is disabled, and running it changes nothing.
+fn assert_not_offered(s: &mut Session, id: NodeId, what: &str) {
+    sel(s, &[id]);
+    assert!(!enabled(s, "select.globalEdit"), "{what}");
+    let r = s.execute("select.globalEdit", &json!({}));
+    assert!(matches!(&r, Err(EngineError::Disabled(_, why)) if why.contains("symbol instances and groups of them")), "{what}: {r:?}");
+    assert!(s.doc().unwrap().global_edit.is_none(), "{what}");
+}
+
+/// An embedded 4 × 4 image at `x`, in `parent` (the default layer when `None`) → its id. The
+/// selection stays as it is.
+fn image(s: &mut Session, x: f64, parent: Option<NodeId>) -> NodeId {
+    s.edit("Place", |d, _| {
+        let id = d.alloc_id();
+        let im = vectorcraft_doc::ImageObject {
+            key: "pic".into(),
+            width: 4,
+            height: 4,
+            xf: Affine::translate((x, 0.0)) * Affine::scale(10.0),
+            link: None,
+            placement: Default::default(),
+            pixels: None,
+        };
+        d.insert(parent.or(d.default_layer()), 0, Node::new(id, NodeKind::Image(Box::new(im))))?;
+        Ok(id)
+    })
+    .unwrap()
+}
+
+#[test]
+fn the_enabled_check_follows_edits_to_the_selected_group() {
+    let mut s = session();
+    let (g, _) = card(&mut s, 0.0, 1.0);
+    card(&mut s, 300.0, 1.0);
     sel(&mut s, &[g]);
-    // The menu only checks that it is a group; starting refuses its contents.
-    let e = s.execute("select.globalEdit", &json!({})).unwrap_err();
-    assert!(e.to_string().contains("symbol instances and groups of them"), "{e}");
-    assert!(s.doc().unwrap().global_edit.is_none());
+    assert!(enabled(&s, "select.globalEdit"));
+    // The answer is kept between frames, and an edit of the selected group changes it.
+    assert!(enabled(&s, "select.globalEdit"));
+    image(&mut s, 0.0, Some(g));
+    assert_eq!(s.doc().unwrap().selection.objects, [g]);
+    assert!(!enabled(&s, "select.globalEdit"), "an image put into the selected group");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().selection.objects, [g]);
+    assert!(enabled(&s, "select.globalEdit"), "after Undo");
+}
+
+#[test]
+fn start_global_edit_is_offered_only_for_a_group_of_supported_objects() {
+    let mut s = session();
+    // Groups holding an image, groups holding a group that holds type, and empty groups; two of
+    // each, so that each would have a group like it.
+    for x in [0.0, 300.0] {
+        let p = rect(&mut s, x, 100.0, 10.0, 10.0);
+        let i = image(&mut s, x, None);
+        let g = group_of(&mut s, &[p, i]);
+        assert_not_offered(&mut s, g, "a group holding an image");
+        let (p, q) = (rect(&mut s, x, 200.0, 10.0, 10.0), rect(&mut s, x + 20.0, 200.0, 10.0, 10.0));
+        let t = NodeId(s.execute("text.create", &json!({"x": x, "y": 250, "text": "Hi"})).unwrap()["id"].as_u64().unwrap());
+        let inner = group_of(&mut s, &[q, t]);
+        let g = group_of(&mut s, &[p, inner]);
+        assert_not_offered(&mut s, g, "a group holding a group that holds type");
+        let empty = s
+            .edit("Group", |d, _| {
+                let id = d.alloc_id();
+                d.insert(d.default_layer(), 0, Node::group(id, vec![]))?;
+                Ok(id)
+            })
+            .unwrap();
+        assert_not_offered(&mut s, empty, "an empty group");
+    }
+    // A group of supported objects is offered and starts; while on, Stop is offered whatever is
+    // selected.
+    let p = rect(&mut s, 600.0, 400.0, 10.0, 10.0);
+    let t = NodeId(s.execute("text.create", &json!({"x": 600, "y": 450, "text": "Hi"})).unwrap()["id"].as_u64().unwrap());
+    let typed = group_of(&mut s, &[p, t]);
+    let (g, _) = card(&mut s, 0.0, 1.0);
+    let (copy, _) = card(&mut s, 300.0, 1.0);
+    sel(&mut s, &[g]);
+    assert!(enabled(&s, "select.globalEdit"));
+    assert_eq!(start(&mut s, g, json!({})), [g, copy]);
+    sel(&mut s, &[typed]);
+    assert!(enabled(&s, "select.globalEdit"), "Stop");
+    assert_eq!(s.execute("select.globalEdit", &json!({})).unwrap()["active"], false);
 }
 
 #[test]
diff --git a/crates/engine/src/tests/livecorners.rs b/crates/engine/src/tests/livecorners.rs
index 888ce24dbd..190cd0d354 100644
--- a/crates/engine/src/tests/livecorners.rs
+++ b/crates/engine/src/tests/livecorners.rs
@@ -89,6 +89,43 @@ fn bad_corners_and_kinds_are_errors() {
     assert_eq!(corners(&s, id), ([0.0; 4], [CornerKind::Round; 4], 4), "nothing changed");
 }
 
+/// A side count that isn't a whole number from 3 to 1000, a negative radius and an unknown key
+/// (at the top level or in one of `items`) are errors naming the key; the shapes and the undo
+/// history stay as they were. A radius of 0 and the ends of the side range still work.
+#[test]
+fn bad_sides_radii_and_keys_are_errors() {
+    let (mut s, id) = session();
+    let poly = NodeId(s.execute("shape.polygon", &json!({"cx": 200, "cy": 200, "radius": 80, "sides": 6})).unwrap()["id"].as_u64().unwrap());
+    let state = |s: &Session| {
+        let st = s.doc().unwrap();
+        (corners(s, id), st.doc.node(poly).unwrap().clone(), st.history.undo.len())
+    };
+    let before = state(&s);
+    for (p, key) in [
+        (json!({"ids": [poly.0], "sides": 2.5}), "`sides` must be a whole number from 3 to 1000, not 2.5"),
+        (json!({"ids": [poly.0], "sides": -1}), "`sides` must be a whole number from 3 to 1000, not -1"),
+        (json!({"ids": [poly.0], "sides": 2}), "`sides` must be a whole number from 3 to 1000, not 2"),
+        (json!({"ids": [poly.0], "sides": 1001}), "`sides` must be a whole number from 3 to 1000, not 1001"),
+        (json!({"ids": [id.0, poly.0], "radius": -4}), "`radius` must be a radius of 0 or more, not -4"),
+        (json!({"items": [{"id": id.0, "corners": [0]}], "radius": -0.5}), "`radius` must be a radius of 0 or more, not -0.5"),
+        (json!({"id": id.0, "path": [[0, 0]], "radius": 5}), "unknown parameter `path`"),
+        (json!({"items": [{"id": id.0, "corner": [0]}], "radius": 5}), "unknown parameter `items[0].corner`; did you mean `items[0].corners`?"),
+    ] {
+        match s.execute("object.setLiveShape", &p) {
+            Err(EngineError::BadParams { cmd, msg }) => assert!(cmd == "object.setLiveShape" && msg.starts_with(key), "{p}: {msg}"),
+            other => panic!("{p}: {other:?}"),
+        }
+        assert_eq!(state(&s), before, "{p}");
+    }
+    run(&mut s, json!({"ids": [poly.0], "sides": 3}));
+    assert!(matches!(node_path(&s, poly).1, Some(LiveShape::Polygon { sides: 3, .. })));
+    run(&mut s, json!({"ids": [poly.0], "sides": 1000.0}));
+    assert!(matches!(node_path(&s, poly).1, Some(LiveShape::Polygon { sides: 1000, .. })));
+    run(&mut s, json!({"id": id.0, "radius": 6}));
+    run(&mut s, json!({"id": id.0, "radius": 0}));
+    assert_eq!(corners(&s, id).0, [0.0; 4]);
+}
+
 #[test]
 fn direct_selected_corners_round_alone_and_stay_selected() {
     let (mut s, id) = session();
diff --git a/crates/engine/src/tests/package.rs b/crates/engine/src/tests/package.rs
index 2e57ed048c..e61c4bb4a4 100644
--- a/crates/engine/src/tests/package.rs
+++ b/crates/engine/src/tests/package.rs
@@ -534,6 +534,16 @@ fn the_document_info_report_has_every_category() {
     let i = run(&mut s, "document.info", json!({"category": "linkedImages"}));
     assert_eq!((i["sections"].as_array().unwrap().len(), i["sections"][0]["id"].as_str()), (1, Some("linkedImages")));
     assert_eq!(i["sections"][0]["rows"].as_array().unwrap().len(), 2);
+    // `imageObjects` lists the linked images in the rows' order with the files they show, and the
+    // embedded one with no file.
+    let linked: Vec<Value> = i["imageObjects"].as_array().unwrap().iter().filter(|o| o["linked"] == true).cloned().collect();
+    for (o, r) in linked.iter().zip(i["sections"][0]["rows"].as_array().unwrap()) {
+        let shown = format!("{} × {} px — {}", o["width"], o["height"], o["file"].as_str().unwrap());
+        assert_eq!((&o["name"], shown.as_str()), (&r[0], r[1].as_str().unwrap()));
+    }
+    assert_eq!(linked.len(), 2);
+    let embedded: Vec<&Value> = i["imageObjects"].as_array().unwrap().iter().filter(|o| o["linked"] == false).collect();
+    assert_eq!((embedded.len(), &embedded[0]["file"], &embedded[0]["width"]), (1, &Value::Null, &json!(600)));
     let all = run(&mut s, "document.info", json!({}));
     assert_eq!(all["sections"].as_array().unwrap().len(), 13);
     let i = run(&mut s, "document.info", json!({"category": "brushes"}));
diff --git a/crates/engine/src/tests/panelcmds.rs b/crates/engine/src/tests/panelcmds.rs
index ac39de0646..8174cf36d1 100644
--- a/crates/engine/src/tests/panelcmds.rs
+++ b/crates/engine/src/tests/panelcmds.rs
@@ -1683,6 +1683,95 @@ fn delete_empty_artboards_deletes_those_with_no_art_in_one_step() {
     assert_eq!(s.doc().unwrap().doc.ruler_guides().len(), 3);
 }
 
+/// `n` artboards in a row, each with a guide, and a guide on no artboard; every guide is selected,
+/// and the key guide is the one on artboard `key`.
+fn artboards_with_selected_guides(n: usize, key: usize) -> Session {
+    let mut s = row_of_artboards(n);
+    s.edit("selection fixture", |d, sel| {
+        d.add_ruler_guide(&vectorcraft_doc::Guide::new(false, 75.0));
+        sel.guides = d.ruler_guides().iter().filter_map(|g| g.id).collect();
+        let on_key = d.artboards[key].id;
+        sel.key_guide = d.ruler_guides().iter().find(|g| g.artboard == Some(on_key)).and_then(|g| g.id);
+        Ok(())
+    })
+    .unwrap();
+    s
+}
+
+/// A document's artboards, ruler guides, selected guides and key guide.
+type BoardsAndGuides = (Vec<vectorcraft_doc::Artboard>, Vec<vectorcraft_doc::Guide>, Vec<NodeId>, Option<NodeId>);
+
+/// The artboards, guides, selected guides and key guide after deleting artboards `indices` of the
+/// open document one at a time, the last first. A clone shares the document's retired artboard id,
+/// so the clone retires none.
+fn deleted_one_at_a_time(s: &Session, indices: &[usize]) -> BoardsAndGuides {
+    let st = s.doc().unwrap();
+    let (mut d, mut sel) = ((*st.doc).clone(), st.selection.clone());
+    for &i in indices.iter().rev() {
+        let id = d.artboards.remove(i).id;
+        d.retain_guides(&mut sel, |g| g.artboard != Some(id));
+    }
+    let guides = d.ruler_guides();
+    (d.artboards, guides, sel.guides, sel.key_guide)
+}
+
+/// The same as [`deleted_one_at_a_time`] for the open document as it is.
+fn artboards_and_guides(s: &Session) -> BoardsAndGuides {
+    let st = s.doc().unwrap();
+    (st.doc.artboards.clone(), st.doc.ruler_guides(), st.selection.guides.clone(), st.selection.key_guide)
+}
+
+/// Delete Artboard with many artboards chosen walks the artboards once and the ruler guides once,
+/// and leaves the same artboards, guides and selected guides as deleting them one at a time, in
+/// one undo step.
+#[test]
+fn deleting_many_artboards_walks_the_artboards_and_guides_once() {
+    use crate::cmd::layer::ARTBOARD_PASSES;
+    let mut s = artboards_with_selected_guides(40, 7);
+    let indices: Vec<usize> = (0..40).filter(|i| i % 2 == 1 || *i == 38).collect();
+    let expected = deleted_one_at_a_time(&s, &indices);
+    let steps = s.doc().unwrap().history.undo.len();
+    ARTBOARD_PASSES.set(0);
+    s.execute("artboard.delete", &json!({ "indices": indices })).unwrap();
+    assert_eq!(ARTBOARD_PASSES.get(), 2, "one walk over the artboards and one over the guides");
+    let now = artboards_and_guides(&s);
+    assert_eq!(now, expected);
+    assert_eq!(now.0.len(), 19);
+    assert_eq!(now.1.len(), 20, "the kept artboards' guides and the guide on no artboard stay");
+    assert_eq!((now.2.len(), now.3), (20, None), "the deleted guides leave the selection, the key guide with them");
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(s.doc().unwrap().doc.artboards.len(), 40);
+    assert_eq!(s.doc().unwrap().doc.ruler_guides().len(), 41);
+}
+
+/// Delete Empty Artboards and Cut Artboard delete their artboards in the same single pass, with the
+/// same result as deleting them one at a time.
+#[test]
+fn delete_empty_and_cut_artboards_walk_the_artboards_and_guides_once() {
+    use crate::cmd::layer::ARTBOARD_PASSES;
+    let mut s = artboards_with_selected_guides(30, 0);
+    box_at(&mut s, 4010.0, 20.0);
+    let empty: Vec<usize> = (0..30).filter(|i| *i != 10).collect();
+    let expected = deleted_one_at_a_time(&s, &empty);
+    ARTBOARD_PASSES.set(0);
+    assert_eq!(s.execute("artboard.deleteEmpty", &json!({})).unwrap(), json!({ "deleted": empty }));
+    assert_eq!(ARTBOARD_PASSES.get(), 2);
+    assert_eq!(artboards_and_guides(&s), expected);
+    assert_eq!(artboard_names(&s), ["Artboard 11"]);
+
+    let mut s = artboards_with_selected_guides(30, 4);
+    let cut: Vec<usize> = (2..28).collect();
+    let expected = deleted_one_at_a_time(&s, &cut);
+    ARTBOARD_PASSES.set(0);
+    s.execute("artboard.cut", &json!({ "indices": cut, "art": false })).unwrap();
+    assert_eq!(ARTBOARD_PASSES.get(), 2);
+    assert_eq!(artboards_and_guides(&s), expected);
+    assert_eq!(s.doc().unwrap().doc.artboards.len(), 4);
+    assert!(s.execute("artboard.cut", &json!({ "indices": [0, 1, 2, 3], "art": false })).is_err(), "a document keeps one artboard");
+    assert_eq!(s.doc().unwrap().doc.artboards.len(), 4);
+}
+
 /// What counts as art: hidden and locked objects, an object straddling two artboards and one
 /// that only touches an artboard's edge; a group counts by its members, not by its box.
 #[test]
diff --git a/crates/engine/src/tests/params.rs b/crates/engine/src/tests/params.rs
index e72f607030..6fb8d30467 100644
--- a/crates/engine/src/tests/params.rs
+++ b/crates/engine/src/tests/params.rs
@@ -400,6 +400,43 @@ fn stroke_set_refuses_an_unknown_key() {
     }
 }
 
+/// `object.setLiveShape` names every key it reads, and each of its `items` takes `id` and
+/// `corners` alone: another key, at the top level, in an item or in a batch step, is refused
+/// instead of being ignored.
+#[test]
+fn set_live_shape_refuses_an_unknown_key() {
+    const ID: &str = "object.setLiveShape";
+    assert!(!UNCHECKED.contains(&ID));
+    let e = refusal(ID, json!({"id": 3, "path": [[0, 0], [1, 1]], "radius": 5}));
+    assert!(e.starts_with("unknown parameter `path`; the command takes: ") && e.contains("relativeRadii"), "{e}");
+    let e = refusal(ID, json!({"radiuss": 5}));
+    assert_eq!(e, "unknown parameter `radiuss`; did you mean `radius`?");
+    let e = refusal(ID, json!({"items": [{"id": 3, "corners": [0]}, {"id": 4, "corner": [0]}], "radius": 5}));
+    assert_eq!(e, "unknown parameter `items[1].corner`; did you mean `items[1].corners`?");
+    let e = refusal(ID, json!({"items": [{"id": 3, "radius": 5}]}));
+    assert_eq!(e, "unknown parameter `items[0].radius`; the command takes: items[0].id, items[0].corners");
+    let step = |params| json!({"commands": [{"command": "select.all", "params": {}}, {"command": ID, "params": params}]});
+    for (bad, key) in [(json!({"path": "x"}), "path"), (json!({"items": [{"id": 3, "kind": "chamfer"}]}), "items[0].kind")] {
+        match check_params("command.batch", &step(bad.clone())) {
+            Err(EngineError::BadParams { cmd, msg }) => {
+                assert!(cmd == ID && msg.starts_with(&format!("unknown parameter `{key}`")), "{bad}: {cmd} {msg}")
+            }
+            other => panic!("{bad}: {other:?}"),
+        }
+    }
+    for ok in [
+        json!({"items": [{"id": 3, "corners": [0, 2]}, {"id": 4}], "radius": 5}),
+        json!({"corners": [0], "kind": "chamfer", "radius": 2, "relativeRadii": false}),
+        json!({"id": 3, "radius": 5}),
+        json!({"ids": [3], "sides": 6, "polygonAngle": 15, "polygonRadius": 20, "sideLength": null, "makeSidesEqual": true}),
+        json!({"pieStart": 30, "pieEnd": 90, "invertPie": true}),
+        json!({"items": null}),
+    ] {
+        assert!(check_params(ID, &ok).is_ok(), "{ok}");
+        assert!(check_params("command.batch", &step(ok.clone())).is_ok(), "{ok}");
+    }
+}
+
 /// An object id given as something other than a whole number (`"5"`, `-1`) is refused as such,
 /// naming its key, not as a missing id; an id left out is still a missing one.
 #[test]
diff --git a/crates/engine/src/tests/pathops.rs b/crates/engine/src/tests/pathops.rs
index 1397357061..b587740744 100644
--- a/crates/engine/src/tests/pathops.rs
+++ b/crates/engine/src/tests/pathops.rs
@@ -441,6 +441,98 @@ fn offset_open_path_whose_ends_meet_grows_the_shape() {
     assert_eq!(path_of(&s, r[0]).0.subpaths.len(), 1);
 }
 
+/// The ids of the objects in the first layer, back to front.
+fn first_layer(s: &Session) -> Vec<NodeId> {
+    s.doc().unwrap().doc.layers[0].children().unwrap().iter().map(|n| n.id).collect()
+}
+
+/// Offset Path of several objects at once: each result goes directly above its object and takes
+/// the next ids in the objects' order, a group gives a group of its paths' offsets with their
+/// styles, a compound path gives a compound path, an inset that leaves nothing and type give
+/// nothing, and one undo gives the objects back.
+#[test]
+fn offset_path_of_several_objects_keeps_their_order() {
+    let mut s = session();
+    let a = rect(&mut s, 0.0, 0.0, 20.0, 20.0);
+    let b = rect(&mut s, 40.0, 0.0, 10.0, 10.0);
+    let c = rect(&mut s, 60.0, 0.0, 10.0, 10.0);
+    set_fill(&mut s, b, Color::rgb(1.0, 0.0, 0.0));
+    set_fill(&mut s, c, Color::rgb(0.0, 0.0, 1.0));
+    s.execute("select.set", &json!({"ids": [b.0, c.0]})).unwrap();
+    let g = NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap());
+    let tiny = rect(&mut s, 100.0, 0.0, 4.0, 4.0);
+    let outer = rect(&mut s, 200.0, 0.0, 40.0, 40.0);
+    let inner = rect(&mut s, 210.0, 10.0, 20.0, 20.0);
+    s.execute("select.set", &json!({"ids": [outer.0, inner.0]})).unwrap();
+    let cp = NodeId(s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap());
+    let t = NodeId(s.execute("text.create", &json!({"x": 300, "y": 10, "text": "Hi"})).unwrap()["id"].as_u64().unwrap());
+    let before = first_layer(&s);
+    assert_eq!(before, [a, g, tiny, cp, t]);
+    let first = s.doc().unwrap().doc.peek_next_id();
+    s.execute("select.set", &json!({"ids": [a.0, g.0, tiny.0, cp.0, t.0]})).unwrap();
+    let r = ids(&s.execute("object.path.offsetPath", &json!({"offset": -3, "joins": "miter"})).unwrap());
+    // a's offset, then b's and c's and their group, then the compound path and its two subpaths.
+    assert_eq!(r, [NodeId(first), NodeId(first + 3), NodeId(first + 4)]);
+    assert_eq!(first_layer(&s), [a, r[0], g, r[1], tiny, cp, r[2], t]);
+    assert_eq!(s.doc().unwrap().selection.objects, r);
+    assert!(close(bounds(&s, r[0]), Rect::new(3.0, 3.0, 17.0, 17.0), 1e-2), "{:?}", bounds(&s, r[0]));
+    let group = node(&s, r[1]);
+    assert!(matches!(group.kind, NodeKind::Group { .. }), "{:?}", group.kind);
+    let kids = group.children().unwrap();
+    assert_eq!(kids.iter().map(|k| k.id).collect::<Vec<_>>(), [NodeId(first + 1), NodeId(first + 2)]);
+    assert_eq!(kids[0].appearance.fill_paint(), Paint::solid(Color::rgb(1.0, 0.0, 0.0)));
+    assert_eq!(kids[1].appearance.fill_paint(), Paint::solid(Color::rgb(0.0, 0.0, 1.0)));
+    let rings = node(&s, r[2]);
+    assert!(matches!(rings.kind, NodeKind::Compound { .. }), "{:?}", rings.kind);
+    assert!(close(bounds(&s, r[2]), Rect::new(203.0, 3.0, 237.0, 37.0), 1e-2), "{:?}", bounds(&s, r[2]));
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(first_layer(&s), before);
+}
+
+/// Offset Path works out the offsets of several paths on more than one thread, and gives the
+/// results in the paths' order.
+#[test]
+fn offset_path_works_on_several_threads_in_order() {
+    let seen = std::sync::Mutex::new(vec![]);
+    let items: Vec<usize> = (0..8).collect();
+    let work = |i: &usize| {
+        if let Ok(mut seen) = seen.lock() {
+            seen.push(std::thread::current().id());
+        }
+        i * 2
+    };
+    let (out, used) = crate::cmd::pathops::ordered_map(&items, 4, work, |_| false);
+    assert_eq!(out, (0..8).map(|i| Some(i * 2)).collect::<Vec<_>>());
+    assert_eq!(used, 4);
+    let threads: std::collections::HashSet<_> = seen.into_inner().unwrap().into_iter().collect();
+    assert_eq!(threads.len(), 4);
+    // A count just past the threads still uses every thread.
+    let (out, used) = crate::cmd::pathops::ordered_map(&items[..5], 4, |i| i * 2, |_| false);
+    assert_eq!(out, (0..5).map(|i| Some(i * 2)).collect::<Vec<_>>());
+    assert_eq!(used, 4);
+    // One item, or one thread, is worked on here.
+    let (out, used) = crate::cmd::pathops::ordered_map(&items[..1], 4, |i| i * 2, |_| false);
+    assert_eq!((out, used), (vec![Some(0)], 1));
+    let (out, used) = crate::cmd::pathops::ordered_map(&items, 1, |i| i * 2, |_| false);
+    assert_eq!(used, 1);
+    assert_eq!(out.len(), 8);
+}
+
+/// Once a result stops the work (an offset that fails), the paths after it are left out, and every
+/// path before it has its result, so the first failure in the paths' order is the one reported.
+#[test]
+fn offset_path_stops_after_the_first_failure() {
+    let items: Vec<usize> = (0..8).collect();
+    let (out, _) = crate::cmd::pathops::ordered_map(&items, 1, |i| *i, |r| *r == 2 || *r == 5);
+    assert_eq!(out, [Some(0), Some(1), Some(2), None, None, None, None, None]);
+    for threads in [2, 4, 8] {
+        let (out, _) = crate::cmd::pathops::ordered_map(&items, threads, |i| *i, |r| *r == 2 || *r == 5);
+        assert_eq!(out[..3], [Some(0), Some(1), Some(2)], "{threads} threads");
+        let first = out.iter().position(|r| r.is_some_and(|r| r == 2 || r == 5));
+        assert_eq!(first, Some(2), "{threads} threads");
+    }
+}
+
 #[test]
 fn outline_stroke_of_line() {
     let mut s = session();
diff --git a/crates/engine/src/tests/pdfpresets.rs b/crates/engine/src/tests/pdfpresets.rs
index ecdf140c0e..7d765106aa 100644
--- a/crates/engine/src/tests/pdfpresets.rs
+++ b/crates/engine/src/tests/pdfpresets.rs
@@ -164,7 +164,13 @@ fn long_pages_in_points_round_trips_through_presets_and_reopens_at_full_size() {
     let v = s.execute("document.exportPdf", &json!({"preset": "Banner"})).unwrap();
     let bytes = pdf(&v);
     assert!(String::from_utf8_lossy(&bytes).contains("/UserUnit 1.969"));
-    assert!(warned(&v, "it is written with a UserUnit of 1.969, so apps that ignore UserUnit show it that many times smaller"), "{v}");
+    assert!(
+        warned(
+            &v,
+            "it is written with a UserUnit of 1.969, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points"
+        ),
+        "{v}"
+    );
     reopened(&bytes);
     for bad in [json!("yes"), json!(1)] {
         assert!(is_bad_params(s.execute("document.exportPdf", &json!({"longPagesInPoints": bad}))), "{bad}");
diff --git a/crates/engine/src/tests/recovery.rs b/crates/engine/src/tests/recovery.rs
index 976d217833..a51f73b222 100644
--- a/crates/engine/src/tests/recovery.rs
+++ b/crates/engine/src/tests/recovery.rs
@@ -396,6 +396,23 @@ fn an_app_that_leaves_has_its_copies_offered_at_once() {
     }
 }
 
+/// The folder copies go to: the `recoveryFolder` preference, trimmed, when it names one, else the
+/// folder the app sets; none with a store the host installed. The web build has no folders.
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn the_folder_in_use_is_the_preference_or_the_apps() {
+    let mut s = Session::new();
+    assert_eq!(cmd::recovery::folder(&s), None);
+    s.recovery.set_default_folder(Some("/app/recovery".into()));
+    assert_eq!(cmd::recovery::folder(&s), Some(("/app/recovery".into(), false)));
+    s.prefs.recovery_folder = " \t ".into();
+    assert_eq!(cmd::recovery::folder(&s), Some(("/app/recovery".into(), false)));
+    s.prefs.recovery_folder = "  /chosen/copies ".into();
+    assert_eq!(cmd::recovery::folder(&s), Some(("/chosen/copies".into(), true)));
+    s.recovery.set_store(Arc::new(MemoryStore::default()));
+    assert_eq!(cmd::recovery::folder(&s), None);
+}
+
 #[test]
 fn folder_areas_are_locked_by_running_apps() {
     let dir = std::env::temp_dir().join(format!("vc-recovery-locks-{}", std::process::id()));
diff --git a/crates/engine/src/tests/xform.rs b/crates/engine/src/tests/xform.rs
index 7de9793525..f507b765c6 100644
--- a/crates/engine/src/tests/xform.rs
+++ b/crates/engine/src/tests/xform.rs
@@ -571,6 +571,25 @@ fn distort_command_warps_the_linked_mask_of_a_path_in_a_group() {
     assert_eq!(a.extras().mask.as_ref().unwrap().art.path_data(), a.path_data(), "and so is its mask");
 }
 
+/// Corners where the box already stands change nothing: no undo step, the document as it was. A
+/// corner moved by a hundredth of a point is a warp.
+#[test]
+fn unchanged_distort_records_no_history() {
+    let mut s = session();
+    let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
+    s.execute("object.rotate", &json!({"angle": 30})).unwrap();
+    let b = s.doc().unwrap().doc.bounds_of(&[a], false).unwrap();
+    let doc = s.doc().unwrap().doc.clone();
+    let n = undo_len(&s);
+    let at = |x1: f64| json!([[b.x0, b.y0], [x1, b.y0], [b.x1, b.y1], [b.x0, b.y1]]);
+    assert_eq!(s.execute("object.distort", &json!({"corners": at(b.x1)})).unwrap()["ids"], json!([a.0]));
+    assert_eq!(undo_len(&s), n);
+    assert!(s.doc().unwrap().doc == doc, "the document is unchanged");
+    s.execute("object.distort", &json!({"corners": at(b.x1 + 0.01)})).unwrap();
+    assert_eq!(undo_len(&s), n + 1);
+    assert!(s.doc().unwrap().doc != doc);
+}
+
 #[test]
 fn distort_perspective_midpoint_is_projective() {
     // Distort a tiny probe at the centre of a 100×100 source box into a trapezoid: with a real
@@ -1239,7 +1258,7 @@ fn distort_reads_from_in_a_turned_frame_and_rejects_a_bad_angle() {
     }
     s.execute("object.distort", &json!({"corners": corners, "from": [-100, 0, 0, 100], "angle": 90, "ids": [a.0]})).unwrap();
     assert!(close(bounds(&s, a), original), "{:?}", bounds(&s, a));
-    assert_eq!(undo_len(&s), history + 1);
+    assert_eq!(undo_len(&s), history, "corners where the box stands change nothing");
     // Without `from`, the box is the objects' bounds in the turned frame: the same box here.
     s.execute("object.distort", &json!({"corners": corners, "angle": 90, "ids": [a.0]})).unwrap();
     assert!(close(bounds(&s, a), original), "{:?}", bounds(&s, a));
diff --git a/crates/engine/src/tooling.rs b/crates/engine/src/tooling.rs
index ae0c55ac76..4dedfe7b28 100644
--- a/crates/engine/src/tooling.rs
+++ b/crates/engine/src/tooling.rs
@@ -1311,14 +1311,12 @@ impl Session {
         {
             return Err(format!("unknown tool `{t}`"));
         }
-        // The active tool's merge being computed is applied with the options it was started with.
-        if tool.is_none_or(|t| t == self.tool.id()) {
-            self.finish_tool_edit_later().map_err(|e| e.to_string())?;
-        }
         let mut values = p.get("values").and_then(Value::as_object).cloned().unwrap_or_default();
         if let Some(k) = p.get("key").and_then(Value::as_str) {
             values.insert(k.to_string(), p.get("value").cloned().unwrap_or(Value::Null));
         }
+        // Every value is checked before any is set, so an invalid one changes nothing.
+        vectorcraft_tools::builder::check_builder_options(tool.unwrap_or(self.tool.id()), &values)?;
         // The Place queue is read later, by a click outside any automation scope: its files must
         // be readable now, under the roots of whoever sets it.
         if let Some(entries) = values.get("queue").and_then(|q| q.get("entries")).and_then(Value::as_array) {
@@ -1336,6 +1334,10 @@ impl Session {
                 return Err("Unknown dimension mode".into());
             }
         }
+        // The active tool's merge being computed is applied with the options it was started with.
+        if tool.is_none_or(|t| t == self.tool.id()) {
+            self.finish_tool_edit_later().map_err(|e| e.to_string())?;
+        }
         Ok(self.set_tool_options(tool, &values))
     }
 
diff --git a/crates/engine/tests/command_sweep.rs b/crates/engine/tests/command_sweep.rs
index d88d99665f..797ca39f52 100644
--- a/crates/engine/tests/command_sweep.rs
+++ b/crates/engine/tests/command_sweep.rs
@@ -849,6 +849,14 @@ fn structured_junk() {
         ("addon.pathtools.movePointsTogether", json!({"enabled": true})),
         ("addon.pathtools.slideAnchor", json!({"id": 2, "anchor": 1, "t": 0.5})),
         ("addon.pathtools.movePointsTogether", json!({"enabled": false})),
+        // Path Precision Tools: Trim at Crossings.
+        ("addon.pathtools.trim", json!({"at": [1e308, -1e308], "tolerance": 1e308})),
+        ("addon.pathtools.trim", json!({"at": ["x", null], "rect": [0, 0, f64::NAN, 1], "points": "all"})),
+        ("addon.pathtools.trim", json!({"rect": [-1e7, -1e7, 2e7, 2e7]})),
+        ("addon.pathtools.trim", json!({"rect": [0, 0, -1e308, 1e308]})),
+        ("addon.pathtools.trim", json!({"points": [[0, 0], [1e7, 1e7], [-1e7, 5], [0, 0]]})),
+        ("addon.pathtools.trim", json!({"points": [[0, 0], [1, "y"], null]})),
+        ("addon.pathtools.trim", json!({"at": [50, 50], "tolerance": 100})),
         // Arrange Tools add-on.
         ("addon.arrange.grid", json!({"columns": u64::MAX, "gapX": 1e6, "gapY": -1e6, "centerOnArtboard": true})),
         ("addon.arrange.grid", json!({"layout": "row", "gapX": f64::MAX, "columns": -1})),
@@ -901,6 +909,11 @@ fn structured_junk() {
         ("addon.cutting.weed", json!({"spacing": 1e-300, "box": "no", "direction": ["both"], "swatch": 5})),
         ("addon.cutting.weed", json!({"spacing": "1 mm", "box": false, "direction": "vertical", "swatch": "no such swatch"})),
         ("addon.cutting.weed", json!({"count": u64::MAX, "margin": "x", "gap": null, "weight": 0})),
+        ("addon.cutting.banner", json!({"hem": 1e5, "grommetInset": 1e5, "spacing": 1e-300, "diameter": 1000})),
+        ("addon.cutting.banner", json!({"hem": -1, "spacing": f64::MAX, "weight": 1e308, "top": "no", "allArtboards": 1})),
+        ("addon.cutting.banner", json!({"hem": 0, "grommetInset": 0, "spacing": 0.01, "allArtboards": true})),
+        ("addon.cutting.banner", json!({"spacing": "1 mm", "grommets": false, "swatch": 5, "left": null})),
+        ("addon.cutting.banner", json!({"top": false, "right": false, "bottom": false, "left": false, "allArtboards": false})),
         // Type Tools add-on.
         ("addon.type.textTweaker", json!({"attribute": "size", "from": 1296, "to": 0.1, "shape": "random", "seed": u64::MAX})),
         ("addon.type.textTweaker", json!({"attribute": "tracking", "from": f64::MAX, "to": -1e308, "shape": "spike"})),
diff --git a/crates/eps/src/ai_editing.rs b/crates/eps/src/ai_editing.rs
index cf068da1ef..0048cb945f 100644
--- a/crates/eps/src/ai_editing.rs
+++ b/crates/eps/src/ai_editing.rs
@@ -186,6 +186,7 @@
 //! The data streams hold the program compressed with Zstandard after `%AI24_ZStandard_Data`, with
 //! the version numbers of the newest files users sent ([`private_data`]).
 
+use std::collections::HashSet;
 use std::fmt::Write;
 use std::sync::Arc;
 
@@ -385,9 +386,15 @@ fn splice(text: &[u8], payloads: &[Vec<u8>]) -> Vec<u8> {
 }
 
 /// `doc` with its geometry effects and group paint baked ([`vectorcraft_effects::bake_document`]),
-/// in its symbols' art and its patterns' tile art too (which instances and pattern fills are
-/// written as); `None` when nothing changes.
+/// in its symbols' art, its patterns' tile art (which instances and pattern fills are written as)
+/// and its opacity masks' art too ([`baked_masks`]); `None` when nothing changes.
 fn baked(doc: &Document) -> Option<Document> {
+    let art = baked_art(doc);
+    baked_masks(art.as_ref().unwrap_or(doc)).or(art)
+}
+
+/// [`baked`] for the layers, symbols and patterns, leaving opacity masks' art as it is.
+fn baked_art(doc: &Document) -> Option<Document> {
     let baked = vectorcraft_effects::bake_document(doc);
     let d = baked.as_ref().unwrap_or(doc);
     let needs = vectorcraft_effects::needs_bake;
@@ -416,6 +423,100 @@ fn baked(doc: &Document) -> Option<Document> {
     Some(out)
 }
 
+/// `doc` with the art of the opacity masks in its layers', symbols' and patterns' art baked as
+/// [`baked_art`] bakes the layers. Each round bakes the art of the outermost masks whose art needs
+/// it, and the next round the masks inside that art, at most [`writer::MAX_NEST`] rounds (the
+/// writer leaves masks nested deeper out). Baked art keeps its id, by which the writer finds the
+/// art as it was before baking ([`writer::styled_objects`]). `None` when no mask's art needs baking.
+fn baked_masks(doc: &Document) -> Option<Document> {
+    let mut out: Option<Document> = None;
+    // The masks' art baked so far, by id: it isn't baked again.
+    let mut done = HashSet::new();
+    for _ in 0..writer::MAX_NEST {
+        let d = out.as_ref().unwrap_or(doc);
+        let roots = || d.layers.iter().chain(d.symbols.iter().map(|s| &s.art)).chain(d.patterns.iter().flat_map(|p| p.art.iter()));
+        let mut arts = vec![];
+        for n in roots() {
+            mask_arts(n, &done, &mut arts);
+        }
+        if arts.is_empty() {
+            break;
+        }
+        // Each art baked as a layer of a copy of the document, as [`baked_art`] bakes symbols.
+        let mut copy = d.clone();
+        copy.layers = arts.iter().map(|a| Arc::new(Node::group(vectorcraft_doc::NodeId(0), vec![a.clone()]))).collect();
+        let Some(mut next) = vectorcraft_effects::bake_document(&copy) else { break };
+        let layers = std::mem::replace(&mut next.layers, d.layers.clone());
+        let mut baked = layers.iter().map(|l| l.children().and_then(|c| c.first().cloned()));
+        for l in next.layers.iter_mut() {
+            if let Some(n) = with_baked_masks(l, &done, &mut baked) {
+                *l = n;
+            }
+        }
+        for s in next.symbols.iter_mut() {
+            if let Some(n) = with_baked_masks(&s.art, &done, &mut baked) {
+                s.art = n;
+            }
+        }
+        for p in next.patterns.iter_mut() {
+            for a in p.art.iter_mut() {
+                if let Some(n) = with_baked_masks(a, &done, &mut baked) {
+                    *a = n;
+                }
+            }
+        }
+        done.extend(arts.iter().map(|a| a.id));
+        out = Some(next);
+    }
+    out
+}
+
+/// Does [`baked_masks`] bake the art of mask `m` in this round?
+fn bakes_mask_art(m: &vectorcraft_doc::OpacityMask, done: &HashSet<vectorcraft_doc::NodeId>) -> bool {
+    !done.contains(&m.art.id) && vectorcraft_effects::needs_bake(&m.art)
+}
+
+/// The art of the opacity masks in `n` that [`baked_masks`] bakes in this round, in the order
+/// [`with_baked_masks`] puts them back: a mask's art before the object's members, and the masks
+/// inside art that isn't baked.
+fn mask_arts(n: &Node, done: &HashSet<vectorcraft_doc::NodeId>, out: &mut Vec<Arc<Node>>) {
+    if let Some(m) = n.extras().mask.as_ref() {
+        if bakes_mask_art(m, done) {
+            out.push(m.art.clone());
+        } else {
+            mask_arts(&m.art, done, out);
+        }
+    }
+    for c in n.children().into_iter().flatten() {
+        mask_arts(c, done, out);
+    }
+}
+
+/// `n` with the art of its opacity masks taken from `baked` in the order [`mask_arts`] lists it;
+/// `None` when nothing in it changes.
+fn with_baked_masks(n: &Arc<Node>, done: &HashSet<vectorcraft_doc::NodeId>, baked: &mut dyn Iterator<Item = Option<Arc<Node>>>) -> Option<Arc<Node>> {
+    let art =
+        n.extras().mask.as_ref().and_then(|m| if bakes_mask_art(m, done) { baked.next().flatten() } else { with_baked_masks(&m.art, done, baked) });
+    let members: Vec<Option<Arc<Node>>> = n.children().map(|c| c.iter().map(|c| with_baked_masks(c, done, baked)).collect()).unwrap_or_default();
+    if art.is_none() && members.iter().all(Option::is_none) {
+        return None;
+    }
+    let mut m = (**n).clone();
+    if let Some(a) = art
+        && let Some(mask) = m.extras_if_any().and_then(|e| e.mask.as_mut())
+    {
+        mask.art = a;
+    }
+    if let Some(children) = m.children_mut() {
+        for (c, new) in children.iter_mut().zip(members) {
+            if let Some(new) = new {
+                *c = new;
+            }
+        }
+    }
+    Some(Arc::new(m))
+}
+
 /// The editing data of `doc` as a `.ai` file's pages carry it: the program compressed with
 /// Zstandard after `%AI24_ZStandard_Data`, its header as the `AIMetaData`, and the version numbers
 /// that go with that form; and what it couldn't hold.
diff --git a/crates/eps/src/ai_editing/tests.rs b/crates/eps/src/ai_editing/tests.rs
index d998ff8e3d..7a15ff2563 100644
--- a/crates/eps/src/ai_editing/tests.rs
+++ b/crates/eps/src/ai_editing/tests.rs
@@ -6538,6 +6538,132 @@ fn effects_in_a_styled_objects_mask_are_warned_about() {
     assert!(shown(&out.program).contains("\n1 (Anon 1) XW\n"));
 }
 
+/// A 200 × 100 document of an image whose opacity mask doesn't clip, of the art `art` makes.
+fn masked_image(art: impl FnOnce(&mut Document) -> Node) -> Document {
+    let mut doc = Document::new(200.0, 100.0);
+    let layer = doc.layers[0].id;
+    let mut im = image_node(&mut doc, ImageBlob::png(rgb_png()), (3, 2), Affine::new([60.0, 0.0, 0.0, 40.0, 10.0, 10.0]), None);
+    let art = art(&mut doc);
+    im.extras_mut().mask = Some(OpacityMask { art: Arc::new(art), clip: false, invert: false, disabled: false, linked: true }.into());
+    doc.insert(Some(layer), usize::MAX, im).unwrap();
+    doc
+}
+
+/// The opacity mask art of the first image in `doc` that has one.
+fn image_mask_art(doc: &Document) -> Arc<Node> {
+    let mut art = None;
+    doc.walk(|n| {
+        if matches!(n.kind, NodeKind::Image(_))
+            && art.is_none()
+            && let Some(m) = n.extras().mask.as_ref()
+        {
+            art = Some(m.art.clone());
+        }
+    });
+    art.expect("an image with an opacity mask")
+}
+
+/// How many of the artboard's pixels `a` and `b` draw differently.
+fn pixels_apart(a: &Document, b: &Document) -> usize {
+    let (a, b) = (vectorcraft_testkit::raster::render_artboard(a), vectorcraft_testkit::raster::render_artboard(b));
+    assert_eq!((a.width, a.height), (b.width, b.height));
+    (0..a.height).flat_map(|y| (0..a.width).map(move |x| (x, y))).filter(|&(x, y)| a.pixel(x, y) != b.pixel(x, y)).count()
+}
+
+/// An opacity mask's art keeps its live effects as an art style: an image masked by a black path
+/// with Offset Path (hiding the image under it) reads back with the effect live on the mask's path,
+/// alone or as a member of a group of two, and draws as it did.
+#[test]
+fn a_masked_image_with_live_offset_path_round_trips() {
+    let offset = fx("path.offsetPath", serde_json::json!({"offset": 8.0, "joins": "miter", "miterLimit": 4.0}));
+    let black = solid(Color::rgb(0.0, 0.0, 0.0));
+    for members in [1, 2] {
+        let made = |effects: Vec<vectorcraft_doc::Effect>| {
+            masked_image(|doc| {
+                let grown = styled_rect(doc, "Grown", Rect::new(60.0, 30.0, 110.0, 70.0), black.clone(), Paint::None, effects);
+                if members == 1 {
+                    return grown;
+                }
+                let plain = square(doc, Rect::new(130.0, 30.0, 170.0, 70.0), Color::rgb(0.0, 0.0, 0.0));
+                group(doc, vec![grown, plain], false)
+            })
+        };
+        let doc = made(vec![offset.clone()]);
+        assert!(pixels_apart(&doc, &made(vec![])) > 0, "{members}: the effect draws nothing");
+        let out = export_ai_editing(&doc, &opts()).unwrap();
+        assert!(!out.warnings.iter().any(|w| w == writer::EFFECTS), "{members}: {:?}", out.warnings);
+        let back = read_back(&doc);
+        let art = image_mask_art(&back);
+        let grown = if members == 1 {
+            art.clone()
+        } else {
+            assert!(art.appearance.effects.is_empty(), "the group took the effect: {:?}", art.appearance.effects);
+            let children = art.children().expect("a group of the mask's art");
+            assert_eq!(children.len(), 2);
+            assert!(children[1].appearance.effects.is_empty());
+            children[0].clone()
+        };
+        assert!(matches!(grown.kind, NodeKind::Path { .. }), "{members}: {:?}", grown.kind);
+        let [e] = grown.appearance.effects.as_slice() else { panic!("{members}: {:?}", grown.appearance.effects) };
+        assert_eq!(e.id, "path.offsetPath");
+        assert_eq!(e.params.get("offset").and_then(serde_json::Value::as_f64), Some(8.0), "{:?}", e.params);
+        assert_eq!(pixels_apart(&doc, &back), 0, "{members}");
+    }
+}
+
+/// The art of a mask keeps Offset Path live when its root is hidden (the canvas draws it all the
+/// same) and when it is the art of a mask inside another mask's art (that clips).
+#[test]
+fn hidden_and_nested_mask_art_keep_live_offset_path() {
+    let offset = fx("path.offsetPath", serde_json::json!({"offset": 6.0}));
+    let grown = |doc: &mut Document, effects, gray: f32| {
+        styled_rect(doc, "Grown", Rect::new(60.0, 30.0, 110.0, 70.0), solid(Color::rgb(gray, gray, gray)), Paint::None, effects)
+    };
+    let hidden = |effects| {
+        masked_image(|doc| {
+            let mut art = grown(doc, effects, 0.0);
+            art.visible = false;
+            art
+        })
+    };
+    let nested = |effects| {
+        masked_image(|doc| {
+            let mut outer = square(doc, Rect::new(20.0, 15.0, 180.0, 85.0), Color::rgb(0.0, 0.0, 0.0));
+            let inner = grown(doc, effects, 1.0);
+            outer.extras_mut().mask = Some(OpacityMask { art: Arc::new(inner), clip: true, invert: false, disabled: false, linked: true }.into());
+            outer
+        })
+    };
+    for (case, made) in [("hidden", &hidden as &dyn Fn(Vec<vectorcraft_doc::Effect>) -> Document), ("nested", &nested)] {
+        let doc = made(vec![offset.clone()]);
+        assert!(pixels_apart(&doc, &made(vec![])) > 0, "{case}: the effect draws nothing");
+        let back = read_back(&doc);
+        let mut art = image_mask_art(&back);
+        if case == "nested" {
+            art = art.extras().mask.as_ref().expect("the mask inside the mask's art").art.clone();
+        }
+        let ids: Vec<&str> = art.appearance.effects.iter().map(|e| e.id.as_str()).collect();
+        assert_eq!(ids, ["path.offsetPath"], "{case}");
+        assert_eq!(pixels_apart(&doc, &back), 0, "{case}");
+    }
+}
+
+/// A geometry effect on an opacity mask's art that no art style holds (Roughen) is applied to the
+/// art written, so the mask reads back drawing what it drew, but for pixels on its edge that the
+/// written points' rounding moves.
+#[test]
+fn a_masks_art_with_an_effect_no_style_holds_is_written_as_it_draws() {
+    let rough = fx("distort.roughen", serde_json::json!({"size": 6.0, "relative": false, "points": "corner"}));
+    let black = solid(Color::rgb(0.0, 0.0, 0.0));
+    let rect = |doc: &mut Document, effects| styled_rect(doc, "Rough", Rect::new(60.0, 30.0, 140.0, 70.0), black.clone(), Paint::None, effects);
+    let doc = masked_image(|doc| rect(doc, vec![rough]));
+    assert!(pixels_apart(&doc, &masked_image(|doc| rect(doc, vec![]))) > 0, "the effect draws nothing");
+    let back = read_back(&doc);
+    assert!(image_mask_art(&back).appearance.effects.is_empty());
+    let apart = pixels_apart(&doc, &back);
+    assert!(apart <= 4, "{apart} pixels differ");
+}
+
 /// On a large canvas no art style is written (the reader scales the styles of a large canvas):
 /// objects with effects are written as their vector art with their geometry effects applied, with a
 /// warning.
@@ -7486,6 +7612,13 @@ fn a_link_to_a_twist_style_is_kept_where_the_reader_reads_it() {
         n.appearance = ap.into();
         n
     };
+    let frame = |doc: &mut Document, ap: Appearance| {
+        let outer = Node::path(doc.alloc_id(), square(), Appearance::default());
+        let inner = Node::path(doc.alloc_id(), shapes::rectangle(Rect::new(30.0, 20.0, 70.0, 50.0)), Appearance::default());
+        let mut n = Node::new(doc.alloc_id(), NodeKind::Compound { children: vec![Arc::new(outer), Arc::new(inner)], rule: FillRule::NonZero });
+        n.appearance = ap.into();
+        n
+    };
     // A group of a filled square and `second`.
     let group = |second: fn(&mut Document) -> Node| {
         move |doc: &mut Document, ap: Appearance| {
@@ -7510,7 +7643,12 @@ fn a_link_to_a_twist_style_is_kept_where_the_reader_reads_it() {
     for (what, doc, kept) in [
         ("a twisted curve", twisted(45.0, filled(), path(oval())), true),
         ("a curve twisted a quarter turn back", twisted(-90.0, filled(), path(oval())), true),
-        ("a square twisted three quarters of a turn", twisted(270.0, filled(), path(square())), true),
+        ("a square twisted half a turn", twisted(180.0, filled(), path(square())), true),
+        ("a square twisted half a turn back", twisted(-180.0, filled(), path(square())), true),
+        ("a square twisted three quarters of a turn", twisted(270.0, filled(), path(square())), false),
+        ("a square twisted three quarters of a turn back", twisted(-270.0, filled(), path(square())), false),
+        ("a straight compound path twisted half a turn", twisted(180.0, filled(), frame), true),
+        ("a straight compound path twisted a full turn", twisted(360.0, filled(), frame), false),
         ("a curve twisted past a quarter turn", twisted(120.0, filled(), path(oval())), false),
         ("a stroked curve", twisted(45.0, Appearance::basic(black_fill(), red.clone(), 2.0), path(oval())), false),
         ("a curved compound path", twisted(-60.0, filled(), ring), true),
@@ -7625,8 +7763,8 @@ fn a_style_that_isnt_written_defines_no_gradient() {
     assert!(p.contains("%%BeginSetup\n0 Bn\n"), "{p}");
 }
 
-/// An object in a plain group, a sublayer or a clipping group by a path keeps its style there. One
-/// in a symbol's art, in an opacity mask or in art cut to a clipping object other than a path is
+/// An object in a plain group, a sublayer, a clipping group by a path or an opacity mask keeps its
+/// style there. One in a symbol's art or in art cut to a clipping object other than a path is
 /// written as its drawn look, with a warning.
 #[test]
 fn where_a_styled_object_keeps_its_style() {
@@ -7683,8 +7821,17 @@ fn where_a_styled_object_keeps_its_style() {
     n.extras_mut().mask = Some(OpacityMask { art: Arc::new(art), clip: true, invert: false, disabled: false, linked: true }.into());
     put(&mut doc, n);
     let out = export_ai_editing(&doc, &opts()).unwrap();
-    assert!(out.warnings.iter().any(|w| w == writer::EFFECTS), "{:?}", out.warnings);
-    assert!(!shown(&out.program).contains("(Anon 1) XW"));
+    assert!(!out.warnings.iter().any(|w| w == writer::EFFECTS), "{:?}", out.warnings);
+    let back = read_back(&doc);
+    let mut art = None;
+    back.walk(|n| {
+        if let Some(m) = n.extras().mask.as_ref() {
+            art = Some(m.art.clone());
+        }
+    });
+    let art = art.expect("the opacity mask");
+    assert_eq!(art.name.as_deref(), Some("Inside"));
+    assert_eq!(art.appearance.effects.len(), 1);
     // In art cut to a clipping object other than a path: type.
     let mut doc = Document::new(200.0, 100.0);
     let t = vectorcraft_doc::TextObject::point(
diff --git a/crates/eps/src/ai_editing/writer.rs b/crates/eps/src/ai_editing/writer.rs
index 7db5d11896..ce937c9048 100644
--- a/crates/eps/src/ai_editing/writer.rs
+++ b/crates/eps/src/ai_editing/writer.rs
@@ -47,7 +47,7 @@ pub(super) use variables::{ACTIVE, BINDINGS, LIMITS, VALUES};
 /// How deep symbols, live objects and pattern tiles may nest in one another (deeper art is left
 /// out). Groups and layers need no limit of their own: a document is never deeper than
 /// [`vectorcraft_doc::MAX_DEPTH`].
-const MAX_NEST: u32 = 8;
+pub(super) const MAX_NEST: u32 = 8;
 
 pub(super) const TYPE: &str = "type in opacity masks, pattern tiles, symbols and art cut to a clipping object, mirrored type, area type and type on a path that is turned or unevenly scaled or whose frame or path has several parts, area type in an open frame, type on an open path whose ends meet, area type that flows around a text wrap, type of only white space, threads of type on a path, threads whose frames differ in orientation or hold a frame written as outlines, type of sizes past what the reader reads, stories past what the reader reads (1,048,576 bytes a story, 16,777,216 bytes in all, and the size of text document it reads), and type with inline graphics, ruby, gradient or pattern paint, or fills, strokes, effects or an opacity mask of the object's own, is written as its outlines in the editing data for other apps";
 pub(super) const PATTERNS: &str = "pattern fills whose tiles aren't a grid or whose art reaches past the tile, pattern fills in another pattern's tile or in a symbol, and pattern fills nested more than 8 deep are written as their tiles cut to the shape in the editing data for other apps";
@@ -200,6 +200,9 @@ pub(super) struct Writer<'a> {
     /// How many parts of the data written on `%_` lines (opacity masks' art, patterns' tiles) the
     /// art being written is in.
     hidden: u32,
+    /// The `hidden` and `nest` values at which the objects of the opacity mask's art being written
+    /// are written: objects there may be written with their art styles.
+    mask_level: Option<(u32, u32)>,
     /// The image just written was written as a placed file.
     placed: bool,
     /// The type just written was written as type, not as its outlines.
@@ -289,6 +292,7 @@ impl<'a> Writer<'a> {
             canvas_origin: origin,
             payloads: vec![],
             hidden: 0,
+            mask_level: None,
             placed: false,
             typed: false,
             bound: vec![],
@@ -613,10 +617,10 @@ impl<'a> Writer<'a> {
         if self.in_symbol {
             self.wrote_fixed |= symbols::redrawn(n);
         }
-        // On the layers, outside art cut to a clipping object: with its art style, when it has one.
+        // On the layers or in an opacity mask's art, outside art cut to a clipping object: with its
+        // art style, when it has one.
         if !self.in_look
-            && self.hidden == 0
-            && self.nest == 0
+            && ((self.hidden == 0 && self.nest == 0) || self.mask_level == Some((self.hidden, self.nest)))
             && self.clip.is_none()
             && !self.in_symbol
             && let Some(orig) = self.styled.get(&n.id).cloned()
@@ -843,21 +847,27 @@ impl<'a> Writer<'a> {
         };
         // A plain group of two or more objects, or of none, is the group the art is read into. A group
         // of one object is written as a group, because the reader makes one shown object the art.
+        // A group that may be written with its art style is written as one object.
         let plain = matches!(art.kind, NodeKind::Group { clip: false, .. })
             && Xy::of(art) == Xy::PLAIN
             && art.visible
             && !art.locked
             && art.name.as_deref().is_none_or(str::is_empty)
-            && art.extras().mask.is_none();
+            && art.extras().mask.is_none()
+            && !self.styled.contains_key(&art.id);
         let members = match art.children() {
             Some(c) if plain && c.len() != 1 => c.as_slice(),
             _ => std::slice::from_ref(art),
         };
         self.nest += 1;
         self.hidden += 1;
+        // The art's objects (not those inside its symbols, live objects or pattern tiles, which are
+        // deeper) may be written with their art styles.
+        let level = self.mask_level.replace((self.hidden, self.nest));
         for c in members {
             self.node(c);
         }
+        self.mask_level = level;
         self.hidden -= 1;
         self.nest -= 1;
         let lines = std::mem::replace(&mut self.body, outer);
diff --git a/crates/eps/src/ai_editing/writer/styles.rs b/crates/eps/src/ai_editing/writer/styles.rs
index fe3e68ce24..163d70381c 100644
--- a/crates/eps/src/ai_editing/writer/styles.rs
+++ b/crates/eps/src/ai_editing/writer/styles.rs
@@ -39,8 +39,9 @@ pub(in crate::ai_editing) fn style_links(doc: &Document) -> usize {
     doc.layers.iter().map(|l| count(l)).sum::<usize>() + doc.symbols.iter().map(|s| count(&s.art)).sum::<usize>()
 }
 
-/// The objects of `doc`'s layers that may be written with an art style ([`Writer::styled_object`]),
-/// by id: paths and compound paths with points and groups, with live effects, linked to a graphic
+/// The objects of `doc`'s layers and of their opacity masks' art that may be written with an art
+/// style ([`Writer::styled_object`]), by id (a mask's art root shown, as [`Writer::mask`] writes
+/// it): paths and compound paths with points and groups, with live effects, linked to a graphic
 /// style or (paths and compound paths) with a brush on a stroke, and embedded images with one Warp
 /// ([`warped_image`]), without Opacity & Mask Define
 /// Knockout Shape (the reader takes an object's transparency
@@ -52,6 +53,13 @@ pub(in crate::ai_editing) fn styled_objects(doc: &Document) -> HashMap<NodeId, A
             if candidate(n) {
                 out.insert(n.id, n.clone());
             }
+            if let Some(m) = n.extras().mask.as_ref() {
+                let mut art = m.art.clone();
+                if !art.visible {
+                    Arc::make_mut(&mut art).visible = true;
+                }
+                walk(std::slice::from_ref(&art), out);
+            }
             // A group's members are written with a style of their own only when the group is written
             // without one. Baking a container with effects of its own changes its members, which
             // keep their ids: they are written as baking left them.
diff --git a/crates/eps/src/ai_editing/writer/texts.rs b/crates/eps/src/ai_editing/writer/texts.rs
index b161ec636f..6bc3c63b09 100644
--- a/crates/eps/src/ai_editing/writer/texts.rs
+++ b/crates/eps/src/ai_editing/writer/texts.rs
@@ -208,6 +208,7 @@ pub(in crate::ai_editing) fn holds(n: &Node, t: &TextObject) -> bool {
     shape_ok
         && t.wrap.is_empty()
         && t.ruby.is_empty()
+        && !t.stacks_warichu()
         && t.runs.iter().any(|r| r.text.chars().any(|c| !c.is_whitespace()))
         && runs_held(t)
         && plain(n)
@@ -964,6 +965,7 @@ impl TextDoc {
                         && t.wrap.is_empty()
                         && plain(n)
                         && t.ruby.is_empty()
+                        && !t.stacks_warichu()
                         && runs_held(t)
                         && (story_scale(t) / scale - 1.0).abs() <= 1e-9
                         && within_reader(t, scale)
diff --git a/crates/eps/src/import/ai/read/ops.rs b/crates/eps/src/import/ai/read/ops.rs
index f79e7b9108..83d0f71d40 100644
--- a/crates/eps/src/import/ai/read/ops.rs
+++ b/crates/eps/src/import/ai/read/ops.rs
@@ -1107,11 +1107,17 @@ fn no_guides(n: &Node, depth: usize) -> bool {
 /// Twist keeps the file's drawn look.
 const MAX_TWIST: f64 = 90.0;
 
+/// The largest Twist angle, in degrees either way, read as a live effect on a path or compound path
+/// with straight segments: VectorCraft's own limit. One with a larger Twist keeps the file's drawn
+/// look.
+const MAX_STRAIGHT_TWIST: f64 = 180.0;
+
 /// Is `object` one that style `st`, whose effect moves the outline, is read on? It and everything
 /// in it [`moves_alike`], and the style paints no gradient. Twist is read only when nothing is
-/// stroked: on a path or compound path with straight segments at any angle, or up to [`MAX_TWIST`]
-/// degrees either way on another object with no guide in it. Transform that scales, turns or reflects
-/// is read only when nothing is stroked (its reference point lies on the bounds without strokes).
+/// stroked and its angle is a number: up to [`MAX_STRAIGHT_TWIST`] degrees either way on a path or
+/// compound path with straight segments, or up to [`MAX_TWIST`] degrees either way on another object
+/// with no guide in it. Transform that scales, turns or reflects is read only when nothing is stroked
+/// (its reference point lies on the bounds without strokes).
 fn moves_with(object: &Node, st: &crate::import::ai::style::ArtStyle) -> bool {
     use crate::import::ai::style::StyleItem;
     let stroked = st.items.iter().any(|i| matches!(i, StyleItem::Stroke { paint, .. } if !paint.is_none()))
@@ -1121,7 +1127,8 @@ fn moves_with(object: &Node, st: &crate::import::ai::style::ArtStyle) -> bool {
         && object.children().into_iter().flatten().all(|c| moves_alike(c, 1))
         && st.effects.iter().all(|e| match e.id.as_str() {
             "distort.twist" => {
-                !stroked && (straight(object) || (no_guides(object, 0) && e.params["angle"].as_f64().is_some_and(|a| a.abs() <= MAX_TWIST)))
+                let within = |limit: f64| e.params["angle"].as_f64().is_some_and(|a| a.abs() <= limit);
+                !stroked && if straight(object) { within(MAX_STRAIGHT_TWIST) } else { no_guides(object, 0) && within(MAX_TWIST) }
             }
             "distort.transform" => {
                 let p = &e.params;
diff --git a/crates/eps/src/import/ai/tests.rs b/crates/eps/src/import/ai/tests.rs
index f2a0a41ca7..23d2536adc 100644
--- a/crates/eps/src/import/ai/tests.rs
+++ b/crates/eps/src/import/ai/tests.rs
@@ -7159,7 +7159,6 @@ fn twist_is_read_on_curves_compound_paths_and_groups_with_nothing_stroked_up_to_
     let object = |hidden: &str| {
         format!("0 Ae\nu\n{RED}{}f\nU\n%_Bb\n%_{}0 BB\n1 (Bent) XW\n", rect_path(16.0, 16.0, 64.0, 54.0), hidden.replace('\n', "\n%_"))
     };
-    let square = object(&format!("{}f\n", rect_path(20.0, 20.0, 60.0, 50.0)));
     let oval = "20 35 m\n20 45 60 45 60 35 c\n60 25 20 25 20 35 c\n";
     let curved = object(&format!("{oval}f\n"));
     let ring = object(&format!("*u\n{oval}f\n30 35 m\n30 40 50 40 50 35 c\n50 30 30 30 30 35 c\nf\n*U\n"));
@@ -7184,7 +7183,6 @@ fn twist_is_read_on_curves_compound_paths_and_groups_with_nothing_stroked_up_to_
         ("a twisted group", read(&twist(90.0, None), &distort_group()), 2),
         ("a group with a hidden member", read(&twist(45.0, None), &hidden_member), 2),
         ("a curve twisted a quarter turn back", read(&twist(-90.0, BLUE_FILL), &curved), 0),
-        ("a square twisted three quarters of a turn, as before", read(&twist(270.0, BLUE_FILL), &square), 0),
         ("a straight compound path with a guide, as before", read(&twist(45.0, BLUE_FILL), &with_guide(&rect_path(20.0, 20.0, 60.0, 50.0))), 2),
     ] {
         assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{what}: {:?}", r.warnings);
@@ -7213,6 +7211,45 @@ fn twist_is_read_on_curves_compound_paths_and_groups_with_nothing_stroked_up_to_
     }
 }
 
+#[test]
+fn twist_is_read_on_straight_paths_and_compound_paths_up_to_half_a_turn() {
+    // GUARDS: a path or compound path with straight segments was read with a live Twist at any angle.
+    // The object, `hidden` painted with its style, under its drawn look.
+    let object = |hidden: &str| {
+        format!("0 Ae\nu\n{RED}{}f\nU\n%_Bb\n%_{}0 BB\n1 (Bent) XW\n", rect_path(16.0, 16.0, 64.0, 54.0), hidden.replace('\n', "\n%_"))
+    };
+    let square = object(&format!("{}f\n", rect_path(20.0, 20.0, 60.0, 50.0)));
+    let frame = object(&format!("*u\n{}f\n{}f\n*U\n", rect_path(20.0, 20.0, 60.0, 50.0), rect_path(30.0, 30.0, 50.0, 40.0)));
+    let twist = |angle: f64| distort_styles("Adobe Twirl", &format!("{angle} /Real (angle) ,\n"), BLUE_FILL);
+    let read = |angle: f64, art_: &str| read_ok(&format!("{}{}", twist(angle), layer(art_)));
+    for (what, r, members, angle) in [
+        ("a square twisted half a turn", read(180.0, &square), 0, 180.0),
+        ("a square twisted half a turn back", read(-180.0, &square), 0, -180.0),
+        ("a straight compound path twisted half a turn", read(180.0, &frame), 2, 180.0),
+    ] {
+        assert!(!r.warnings.iter().any(|w| w.contains("drawn look")), "{what}: {:?}", r.warnings);
+        let a = art(&r.doc);
+        assert_eq!(a.len(), 1, "{what}: {a:#?}");
+        assert_eq!(a[0].children().map_or(0, |c| c.len()), members, "{what}: the object, not its look: {a:#?}");
+        let [e] = a[0].appearance.effects.as_slice() else { panic!("{what}: {:?}", a[0].appearance) };
+        assert_eq!((e.id.as_str(), e.params["angle"].as_f64()), ("distort.twist", Some(angle)), "{what}");
+    }
+    for (what, r) in [
+        ("a square twisted just past half a turn", read(181.0, &square)),
+        ("a square twisted just past half a turn back", read(-181.0, &square)),
+        ("a square twisted three quarters of a turn", read(270.0, &square)),
+        ("a square twisted three quarters of a turn back", read(-270.0, &square)),
+        ("a square twisted two turns", read(720.0, &square)),
+        ("a square twisted ten turns", read(3600.0, &square)),
+        ("a straight compound path twisted a full turn", read(360.0, &frame)),
+    ] {
+        let a = art(&r.doc);
+        assert_eq!(a.len(), 1, "{what}: {a:#?}");
+        assert!(a[0].appearance.effects.is_empty(), "{what}: the drawn look: {a:#?}");
+        assert!(r.warnings.iter().any(|w| w.contains("drawn look")), "{what}: {:?}", r.warnings);
+    }
+}
+
 #[test]
 fn a_bare_comment_line_in_a_prolog_leaves_its_end_alone() {
     // GUARDS: a bare `%` line's empty marker matched the empty begin marker of a section that has none.
diff --git a/crates/eps/src/legacy_ai/encoding.rs b/crates/eps/src/legacy_ai/encoding.rs
index 3882e37fe1..7713028f81 100644
--- a/crates/eps/src/legacy_ai/encoding.rs
+++ b/crates/eps/src/legacy_ai/encoding.rs
@@ -98,13 +98,14 @@ pub(super) fn rotated(t: &TextObject) -> bool {
     })
 }
 
-/// Can 8-bit text hold type `t`: horizontal, without ruby (which a text object can't hold), its
-/// runs plain characters (no inline graphics) that 8-bit text can hold, filled and stroked with
-/// colours?
+/// Can 8-bit text hold type `t`: horizontal, without ruby or warichu (which a text object can't
+/// hold), its runs plain characters (no inline graphics) that 8-bit text can hold, filled and
+/// stroked with colours?
 pub(super) fn holds_as_text(t: &TextObject) -> bool {
     let solid = |p: &Paint| matches!(p, Paint::Solid { .. } | Paint::None);
     !t.vertical
         && t.ruby.is_empty()
+        && !t.stacks_warichu()
         && t.runs.iter().any(|r| !r.text.is_empty())
         && t.runs.iter().all(|r| {
             r.inline.is_none()
diff --git a/crates/geom/src/path.rs b/crates/geom/src/path.rs
index ac7dc63add..bef18334ae 100644
--- a/crates/geom/src/path.rs
+++ b/crates/geom/src/path.rs
@@ -248,6 +248,16 @@ fn anchors_within<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Vec<Anchor>,
     d.deserialize_seq(V)
 }
 
+thread_local! {
+    /// [`measured_segments`] of this thread.
+    static MEASURED_SEGMENTS: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
+}
+
+/// How many segments [`PathData::bounds`] has measured on this thread.
+pub fn measured_segments() -> u64 {
+    MEASURED_SEGMENTS.get()
+}
+
 /// An open or closed run of anchors.
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 pub struct SubPath {
@@ -568,6 +578,7 @@ impl PathData {
         }
         let mut bbox: Option<Rect> = None;
         for sp in &self.subpaths {
+            MEASURED_SEGMENTS.set(MEASURED_SEGMENTS.get().saturating_add(sp.segment_count() as u64));
             for i in 0..sp.segment_count() {
                 let c = sp.segment(i);
                 // `to_bezpath_into` writes a line where neither handle is out, else a cubic.
diff --git a/crates/mcp/src/tools/definitions.rs b/crates/mcp/src/tools/definitions.rs
index d4d69c945f..e583753e4d 100644
--- a/crates/mcp/src/tools/definitions.rs
+++ b/crates/mcp/src/tools/definitions.rs
@@ -511,7 +511,7 @@ pub fn tool_definitions() -> Vec<Value> {
             obj(
                 json!({
                     "ids": {"type": "array", "items": {"type": "integer"}},
-                    "offset": num("Gap between text and object (default 6 pt)"),
+                    "offset": num("Gap between text and object in pt, -1000 to 1000 (default 6 pt); a negative gap lets text that far into the object"),
                     "invert": {"type": "boolean"},
                     "release": {"type": "boolean"},
                 }),
diff --git a/crates/mcp/src/ui_catalog.rs b/crates/mcp/src/ui_catalog.rs
index dcde7c5076..037f8cd89b 100644
--- a/crates/mcp/src/ui_catalog.rs
+++ b/crates/mcp/src/ui_catalog.rs
@@ -925,7 +925,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "tool.options",
         "Tool Options…",
         "",
-        "{tool: id} what double-clicking a tool button opens: hand → fits the artboard in the window (view.fitArtboard), zoom → 100% (view.actualSize), rotate|scale|reflect|shear → that Object › Transform dialog (dialog `rotate`, `scale`, `reflect` or `shear`; error `nothing selected` without a selection), selection|directSelection|groupSelection → the Move dialog (dialog `move`; the same error), gradient|magicWand → the Gradient or Magic Wand panel (window.panel), artboard → Artboard Options of the active artboard (dialog `artboardOptions`, fields index, name, x, y, width, height, showCenterMark, showCrossHairs; OK runs artboard.setProps, and with other artboards selected with the Artboard tool a new width or height goes to each of them too, in its `artboards` list, each resized about the reference point the form used for that size, or about its top-left corner when the size was set in the fields directly), flare → Flare Tool Options (dialog `flareOptions`, fields diameter and pathLength (pt), opacity, brightness, growth, fuzziness, longest, rayFuzziness, largest (%), rays, rings, direction (°), raysOn, ringsOn; OK runs tool.setOption {tool: \"flare\", values}: the next flare dragged out uses them, and a Flare click's dialog, which also has x, y and preview (on initially), previews one there and accepts it as one Undo step; Cancel rolls back the preview), lineSegment|arc|rectangularGrid|polarGrid → that tool's Tool Options, its click dialog without x and y (dialog kind = the tool id, `__toolOptions: true`; lineSegment: length (pt), angle (°), fillLine; arc: lengthX, lengthY (pt), reference (0–8), arcType: open|closed, baseAlong: x|y, slope (−100…100), fillArc; rectangularGrid: width, height (pt, the Default Size), reference (0–8), rows, columns, rowSkew, columnSkew (%), frame, fill; polarGrid: the same with concentric, radial, concentricSkew, radialSkew and compound for rows, columns, the skews and frame; OK runs tool.setOption {tool, values} and draws nothing: the next drag uses them (Fill Line, the arc's type, base, slope and fill, the grids' dividers, skews and switches) and a click's dialog opens at them), columnGraph|stackedColumnGraph|barGraph|stackedBarGraph|lineGraph|areaGraph|scatterGraph|pieGraph|radarGraph → Graph Type for the selected graph (dialog `command` running graph.setType; an error without one), typeOnPath|verticalTypeOnPath → Type on a Path Options for the selected type on a path (dialog `command` running type.pathOptions; error `nothing selected` without a selection, and the command's error when no type on a path is selected),symbolSprayer|symbolShifter|symbolScruncher|symbolSizer|symbolSpinner|symbolStainer|symbolScreener|symbolStyler → Symbolism Tools Options (dialog `symbolismOptions`, fields tool, diameter (pt), intensity and density (1–10), shared by the eight tools; OK runs tool.setOption {tool, values}), blend → Blend Options, perspectiveGrid → Perspective Grid Options, eyedropper → Eyedropper Options (dialog `eyedropperOptions`, fields sampleSize, pickUp, apply; OK runs eyedropper.setOptions), printTiling → resets the print tiling (print.tiling.set {reset: true}), warp|twirl|pucker|bloat|scallop|crystallize|wrinkle → that tool's Tool Options (dialog `liquifyOptions`, fields tool, width, height, angle, intensity %, usePressure, detail, simplify, simplifyOn, rate, complexity, horizontal %, vertical %, affectAnchors, affectIn, affectOut, showBrush; OK runs tool.setOption {tool, values}), pencil|paintbrush|smooth|blobBrush|eraser → that tool's Tool Options (dialog `freehandOptions`, fields tool and the options the tool keeps: fidelity (px for pencil and paintbrush, the same at any zoom; pt for smooth and blobBrush), fill, keepSelected (on for pencil and paintbrush, off for blobBrush), mergeOnlySelection (off), closeWithin and editWithin (px, 0 is off), livePreview (pencil, on: off draws a thin line while the stroke is drawn, and the path's fill and stroke on release), size (pt), angle (°, −180–180; 0) and roundness (%, 1–100; 100) of the eraser's tip; OK runs tool.setOption {tool, values}), livePaintSelection → Live Paint Selection Tool Options (dialog `livePaintSelectionOptions`, fields selectFills and selectStrokes (both on), color (the highlight color, #rrggbb or a layer color's name; #ff2a2a), width (the highlight's width, 1–20 px; 4); OK runs tool.setOption {tool: \"livePaintSelection\", values}; a color with an alpha part (#rrggbbaa or #rgba) is an error and OK changes nothing), livePaintBucket → Live Paint Bucket Options (dialog `livePaintBucketOptions`, fields paintFills (on) and paintStrokes (off), highlight (on), color (the highlight color, #rrggbb or a layer color's name; #ff2a2a), width (the face highlight's width, 1–20 px; 4; an edge's highlight is half as wide); OK runs tool.setOption {tool: \"livePaintBucket\", values}; a color with an alpha part (#rrggbbaa or #rgba) is an error and OK changes nothing), shapeBuilder → Shape Builder Tool Options (dialog `shapeBuilderOptions`, fields gapDetection (off), gapLength (pt, 0–72; 3), openFilledAsClosed (on), clickStrokeSplitsPath (off), pickColorFrom: artwork|swatches (artwork), cursorSwatchPreview (off), selection: freeform|straightLine (freeform), highlightFill (on), highlightStroke (on), highlightColor (#rrggbb or a layer color's name; #ff4f4f); OK runs tool.setOption {tool: \"shapeBuilder\", values}; a highlightColor with an alpha part (#rrggbbaa or #rgba) is an error and OK changes nothing), objectsOnPath → Objects on Path Tool Options (dialog `objectsOnPathOptions`, fields pivot (0–8, row by row from the top left; 4, the center) and rotate (°, −360–360; 0); Reset puts 4 and 0 back; Save runs tool.setOption {tool: \"objectsOnPath\", values}: the objects attached next use them, groups attached before keep theirs)",
+        "{tool: id} what double-clicking a tool button opens: hand → fits the artboard in the window (view.fitArtboard), zoom → 100% (view.actualSize), rotate|scale|reflect|shear → that Object › Transform dialog (dialog `rotate`, `scale`, `reflect` or `shear`; error `nothing selected` without a selection), selection|directSelection|groupSelection → the Move dialog (dialog `move`; the same error), gradient|magicWand → the Gradient or Magic Wand panel (window.panel), artboard → Artboard Options of the active artboard (dialog `artboardOptions`, fields index, name, x, y, width, height, showCenterMark, showCrossHairs; OK runs artboard.setProps, and with other artboards selected with the Artboard tool a new width or height goes to each of them too, in its `artboards` list, each resized about the reference point the form used for that size, or about its top-left corner when the size was set in the fields directly), flare → Flare Tool Options (dialog `flareOptions`, fields diameter and pathLength (pt), opacity, brightness, growth, fuzziness, longest, rayFuzziness, largest (%), rays, rings, direction (°), raysOn, ringsOn; OK runs tool.setOption {tool: \"flare\", values}: the next flare dragged out uses them, and a Flare click's dialog, which also has x, y and preview (on initially), previews one there and accepts it as one Undo step; Cancel rolls back the preview), lineSegment|arc|rectangularGrid|polarGrid → that tool's Tool Options, its click dialog without x and y (dialog kind = the tool id, `__toolOptions: true`; lineSegment: length (pt), angle (°), fillLine; arc: lengthX, lengthY (pt), reference (0–8), arcType: open|closed, baseAlong: x|y, slope (−100…100), fillArc; rectangularGrid: width, height (pt, the Default Size), reference (0–8), rows, columns, rowSkew, columnSkew (%), frame, fill; polarGrid: the same with concentric, radial, concentricSkew, radialSkew and compound for rows, columns, the skews and frame; OK runs tool.setOption {tool, values} and draws nothing: the next drag uses them (Fill Line, the arc's type, base, slope and fill, the grids' dividers, skews and switches) and a click's dialog opens at them), columnGraph|stackedColumnGraph|barGraph|stackedBarGraph|lineGraph|areaGraph|scatterGraph|pieGraph|radarGraph → Graph Type for the selected graph (dialog `command` running graph.setType; an error without one), typeOnPath|verticalTypeOnPath → Type on a Path Options for the selected type on a path (dialog `command` running type.pathOptions; error `nothing selected` without a selection, and the command's error when no type on a path is selected),symbolSprayer|symbolShifter|symbolScruncher|symbolSizer|symbolSpinner|symbolStainer|symbolScreener|symbolStyler → Symbolism Tools Options (dialog `symbolismOptions`, fields tool, diameter (pt), intensity and density (1–10), shared by the eight tools; OK runs tool.setOption {tool, values}), blend → Blend Options, perspectiveGrid → Perspective Grid Options, eyedropper → Eyedropper Options (dialog `eyedropperOptions`, fields sampleSize, pickUp, apply; OK runs eyedropper.setOptions), printTiling → resets the print tiling (print.tiling.set {reset: true}), warp|twirl|pucker|bloat|scallop|crystallize|wrinkle → that tool's Tool Options (dialog `liquifyOptions`, fields tool, width, height, angle, intensity %, usePressure, detail, simplify, simplifyOn, rate, complexity, horizontal %, vertical %, affectAnchors, affectIn, affectOut, showBrush; OK runs tool.setOption {tool, values}), pencil|paintbrush|smooth|blobBrush|eraser → that tool's Tool Options (dialog `freehandOptions`, fields tool and the options the tool keeps: fidelity (px for pencil, paintbrush and smooth, the same at any zoom; pt for blobBrush), fill, keepSelected (on for pencil and paintbrush, off for blobBrush), mergeOnlySelection (off), closeWithin and editWithin (px, 0 is off), livePreview (pencil, on: off draws a thin line while the stroke is drawn, and the path's fill and stroke on release), size (pt), angle (°, −180–180; 0) and roundness (%, 1–100; 100) of the eraser's tip; OK runs tool.setOption {tool, values}), livePaintSelection → Live Paint Selection Tool Options (dialog `livePaintSelectionOptions`, fields selectFills and selectStrokes (both on), color (the highlight color, #rrggbb or a layer color's name; #ff2a2a), width (the highlight's width, 1–20 px; 4); OK runs tool.setOption {tool: \"livePaintSelection\", values}; a color with an alpha part (#rrggbbaa or #rgba) is an error and OK changes nothing), livePaintBucket → Live Paint Bucket Options (dialog `livePaintBucketOptions`, fields paintFills (on) and paintStrokes (off), highlight (on), color (the highlight color, #rrggbb or a layer color's name; #ff2a2a), width (the face highlight's width, 1–20 px; 4; an edge's highlight is half as wide); OK runs tool.setOption {tool: \"livePaintBucket\", values}; a color with an alpha part (#rrggbbaa or #rgba) is an error and OK changes nothing), shapeBuilder → Shape Builder Tool Options (dialog `shapeBuilderOptions`, fields gapDetection (off), gapLength (pt, 0–72; 3), openFilledAsClosed (on), clickStrokeSplitsPath (off), pickColorFrom: artwork|swatches (artwork), cursorSwatchPreview (off), selection: freeform|straightLine (freeform), highlightFill (on), highlightStroke (on), highlightColor (#rrggbb or a layer color's name; #ff4f4f); OK runs tool.setOption {tool: \"shapeBuilder\", values}; a highlightColor with an alpha part (#rrggbbaa or #rgba) is an error and OK changes nothing), objectsOnPath → Objects on Path Tool Options (dialog `objectsOnPathOptions`, fields pivot (0–8, row by row from the top left; 4, the center) and rotate (°, −360–360; 0); Reset puts 4 and 0 back; Save runs tool.setOption {tool: \"objectsOnPath\", values}: the objects attached next use them, groups attached before keep theirs)",
     ),
     (
         "ui.colorGuideOptions",
@@ -1296,6 +1296,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "",
         "{} open Tate-chu-yoko Settings (the Character panel menu's Tate-chu-yoko Settings…, with Show East Asian Options) on the characters the Character panel acts on, filled in with the values they share (dialog `tateChuYokoSettings`: tcyUpDown, tcyLeftRight (pt, -1296..1296)): OK runs text.setFormat (text.setRangeStyle while the Type tool edits text) with the values that changed, as one undo step; an error with no type selected",
     ),
+    (
+        "ui.warichuSettings",
+        "Warichu Settings…",
+        "",
+        "{} open Warichu Settings (the Character panel menu's Warichu Settings…, with Show East Asian Options) on the characters the Character panel acts on, filled in with the values they share (dialog `warichuSettings`: warichuLines 1..6, warichuGap (pt, 0..100), warichuScale (%, 10..100), warichuAlign): OK runs text.setFormat (text.setRangeStyle while the Type tool edits text) with the values that changed, as one undo step, and leaves Warichu itself as it is; an error with no type selected",
+    ),
     (
         "ui.colorGuideLimit",
         "Limit Color Guide to Library",
diff --git a/crates/pathops/src/addons/pathtools.rs b/crates/pathops/src/addons/pathtools.rs
index 1de342ffc8..a20a4a5b36 100644
--- a/crates/pathops/src/addons/pathtools.rs
+++ b/crates/pathops/src/addons/pathtools.rs
@@ -2,9 +2,9 @@
 //! rule, equalise handles, add evenly spaced anchors, close), what its live path effects add to them
 //! ([`add_anchors`], [`smooth_anchors`], [`split_at_anchors`]), the readouts the Measure & Inspect
 //! tool shows over a path, open paths lengthened or shortened at an end ([`extend`]), the places
-//! where paths cross ([`crossings`]), anchors slid along their path ([`slide`]), touching edges
-//! merged ([`shared_edge`]), paths divided into dashes ([`divide_dashes`]) and the Parametric Shape
-//! Tool's shapes ([`shapes`]).
+//! where paths cross ([`crossings`]), the stretches between them ([`spans`]), anchors slid along
+//! their path ([`slide`]), touching edges merged ([`shared_edge`]), paths divided into dashes
+//! ([`divide_dashes`]) and the Parametric Shape Tool's shapes ([`shapes`]).
 
 mod crossings;
 mod dashes;
@@ -14,19 +14,21 @@ mod shared_edge;
 mod slide;
 #[cfg(test)]
 mod tests;
+mod trim;
 
 use std::collections::BTreeSet;
 
 use kurbo::{CubicBez, ParamCurve, ParamCurveArclen, ParamCurveNearest, Point, Vec2};
 use vectorcraft_geom::{Anchor, AnchorKind, PathData, SubPath};
 
-pub use crossings::{MAX_CROSSING_SEGMENTS, crossings, insert_at};
+pub use crossings::{MAX_CROSSED_BY_SEGMENTS, MAX_CROSSING_SEGMENTS, Place, Work, crossings, crossings_on, crossings_on_within, insert_at};
 pub use dashes::{DashSpec, Piece, divide_dashes};
 pub use extend::{ExtendMode, extend_length_to, extend_open};
 pub use shared_edge::{
     COINCIDENCE, EndSide, Follow, MAX_COINCIDENCE, MergePlan, MergePreview, Stretch, apply_merge, ends_at, merge_preview, stretches_at,
 };
 pub use slide::{MAX_SLIDE, slide_anchor, slide_stops, slide_t_at};
+pub use trim::{Span, slice, span_at, spans, without_spans};
 
 use crate::fit::{end_tangent, start_tangent};
 
diff --git a/crates/pathops/src/addons/pathtools/crossings.rs b/crates/pathops/src/addons/pathtools/crossings.rs
index d216a2f4b3..c20e559d96 100644
--- a/crates/pathops/src/addons/pathtools/crossings.rs
+++ b/crates/pathops/src/addons/pathtools/crossings.rs
@@ -1,9 +1,10 @@
 //! Where paths cross: [`crossings`] finds the places, [`insert_at`] puts anchors there (which
-//! Split / Add Points at Crossings then keeps or cuts at).
+//! Split / Add Points at Crossings then keeps or cuts at), and [`crossings_on`] finds the places on
+//! one path (which Trim at Crossings removes stretches between).
 
 use std::collections::{BTreeMap, BTreeSet};
 
-use kurbo::{CubicBez, ParamCurve, ParamCurveNearest, Point, Rect};
+use kurbo::{CubicBez, ParamCurve, ParamCurveDeriv, ParamCurveNearest, Point, Rect};
 use vectorcraft_geom::{Anchor, AnchorKind, PathData, SubPath};
 
 /// Most segments [`crossings`] compares at once.
@@ -85,16 +86,82 @@ fn segment_crossings(a: &CubicBez, b: &CubicBez, budget: &mut usize) -> Option<V
     Some(found)
 }
 
-/// Do segments `i` and `j` of `sp` meet at an anchor they share?
-fn adjacent(sp: &SubPath, i: usize, j: usize) -> bool {
-    let n = sp.segment_count();
-    i.abs_diff(j) == 1 || (sp.closed && n > 1 && i.abs_diff(j) == n - 1)
+/// Where segment `c` crosses itself, as its two parameters in order: a cubic loops over itself at
+/// most once. `None` when it doesn't, or only at a cusp or an end.
+fn self_crossing(c: &CubicBez) -> Option<(f64, f64)> {
+    // In powers of t, c(t) = a t³ + b t² + k t + p0. Two parameters s and t meet where
+    // a (s² + st + t²) + b (s + t) + k = 0: with u = s + t and v = st, crossing that with `a` gives u,
+    // and dotting it with `a` gives v; s and t are the roots of z² - u z + v.
+    let (p0, p1, p2, p3) = (c.p0.to_vec2(), c.p1.to_vec2(), c.p2.to_vec2(), c.p3.to_vec2());
+    let a = p3 - p2 * 3.0 + p1 * 3.0 - p0;
+    let b = (p2 - p1 * 2.0 + p0) * 3.0;
+    let k = (p1 - p0) * 3.0;
+    let (ab, aa) = (a.cross(b), a.dot(a));
+    // A curve with no loop can leave these near zero, however long and thin a loop is: the checks
+    // at the end drop what that gives.
+    if ab == 0.0 || aa == 0.0 {
+        return None;
+    }
+    let u = -a.cross(k) / ab;
+    let v = u * u + (b * u + k).dot(a) / aa;
+    let disc = u * u - 4.0 * v;
+    if !disc.is_finite() || disc <= 1e-12 {
+        return None;
+    }
+    let (s, t) = ((u - disc.sqrt()) / 2.0, (u + disc.sqrt()) / 2.0);
+    let inside = |x: f64| END < x && x < 1.0 - END;
+    // The two places are one point, and the curve passes it in two directions (a straight curve
+    // that doubles back on itself meets itself along its length, not at a crossing).
+    let (ds, dt) = (c.deriv().eval(s).to_vec2(), c.deriv().eval(t).to_vec2());
+    let across = ds.cross(dt).abs() > 1e-15 * ds.hypot() * dt.hypot();
+    (inside(s) && inside(t) && across && c.eval(s).distance(c.eval(t)) < SAME).then_some((s, t))
 }
 
-/// Where `paths` cross one another (and, with `self_crossings`, where each crosses itself): for
-/// each path, the places on it, in order. Segments that meet at an anchor they share don't count as
-/// crossing there. `None` past [`MAX_CROSSING_SEGMENTS`] segments or when the curves are too tangled
-/// to sort out, or when a coordinate isn't finite.
+/// For each segment of `sp`, and one past the last, the first segment at or after it that has a
+/// length (the segment count when none has): segments with none lie at one point, between anchors
+/// that coincide.
+fn with_length_from(sp: &SubPath) -> Vec<usize> {
+    let n = sp.segment_count();
+    let mut out = vec![n; n + 1];
+    for i in (0..n).rev() {
+        let c = sp.segment(i);
+        let next = if control_box(&c).size().to_vec2().hypot() < SAME { out.get(i + 1).copied().unwrap_or(n) } else { i };
+        if let Some(o) = out.get_mut(i) {
+            *o = next;
+        }
+    }
+    out
+}
+
+/// The anchors segments `i` and `j` of `sp` share (`with_length` from [`with_length_from`]): none,
+/// one, or both ends for the two segments of a closed subpath of two. Segments with no length between
+/// them leave them meeting at that point.
+fn shared_anchors(sp: &SubPath, with_length: &[usize], i: usize, j: usize) -> Vec<Point> {
+    let (n, lo, hi) = (sp.segment_count(), i.min(j), i.max(j));
+    let from = |k: usize| with_length.get(k).copied().unwrap_or(n);
+    let mut out = vec![];
+    if hi > lo && from(lo + 1) >= hi {
+        out.extend([sp.segment(lo).p3, sp.segment(hi).p0]);
+    }
+    // Round the first anchor of a closed subpath.
+    if sp.closed && n > 1 && hi > lo && from(hi + 1) >= n && from(0) >= lo {
+        out.extend([sp.segment(hi).p3, sp.segment(lo).p0]);
+    }
+    out
+}
+
+/// Where segments `a` and `b` cross, without the places at the anchors in `shared`: two segments that
+/// meet at an anchor don't cross there, but they can cross again elsewhere.
+fn crossings_apart(a: &CubicBez, b: &CubicBez, shared: &[Point], budget: &mut usize) -> Option<Vec<(f64, f64)>> {
+    let mut found = segment_crossings(a, b, budget)?;
+    found.retain(|(ta, _)| !shared.iter().any(|p| a.eval(*ta).distance(*p) < SAME));
+    Some(found)
+}
+
+/// Where `paths` cross one another (and, with `self_crossings`, where each crosses itself, a segment
+/// that loops over itself included): for each path, the places on it, in order. Segments that meet
+/// at an anchor they share don't count as crossing there. `None` past [`MAX_CROSSING_SEGMENTS`]
+/// segments or when the curves are too tangled to sort out, or when a coordinate isn't finite.
 pub fn crossings(paths: &[&PathData], self_crossings: bool) -> Option<Vec<Vec<Place>>> {
     let mut segs: Vec<(usize, usize, usize, CubicBez, Rect)> = vec![];
     for (k, path) in paths.iter().enumerate() {
@@ -111,19 +178,22 @@ pub fn crossings(paths: &[&PathData], self_crossings: bool) -> Option<Vec<Vec<Pl
             }
         }
     }
+    let with_length: Vec<Vec<Vec<usize>>> = paths.iter().map(|p| p.subpaths.iter().map(with_length_from).collect()).collect();
     let mut out: Vec<Vec<Place>> = vec![vec![]; paths.len()];
     let mut budget = MAX_STEPS;
     for (i, (ka, sa, ia, ca, ra)) in segs.iter().enumerate() {
+        if self_crossings && let Some((s, t)) = self_crossing(ca) {
+            out.get_mut(*ka)?.extend([(*sa, *ia, s), (*sa, *ia, t)]);
+        }
         for (kb, sb, ib, cb, rb) in segs.iter().skip(i + 1) {
-            if ka == kb
-                && (!self_crossings || (sa == sb && paths.get(*ka).and_then(|p| p.subpaths.get(*sa)).is_some_and(|sp| adjacent(sp, *ia, *ib))))
-            {
+            if (ka == kb && !self_crossings) || !ra.inflate(SAME, SAME).overlaps(*rb) {
                 continue;
             }
-            if !ra.inflate(SAME, SAME).overlaps(*rb) {
-                continue;
-            }
-            for (ta, tb) in segment_crossings(ca, cb, &mut budget)? {
+            let shared = match (paths.get(*ka).and_then(|p| p.subpaths.get(*sa)), with_length.get(*ka).and_then(|w| w.get(*sa))) {
+                (Some(sp), Some(w)) if ka == kb && sa == sb => shared_anchors(sp, w, *ia, *ib),
+                _ => vec![],
+            };
+            for (ta, tb) in crossings_apart(ca, cb, &shared, &mut budget)? {
                 out.get_mut(*ka)?.push((*sa, *ia, ta));
                 out.get_mut(*kb)?.push((*sb, *ib, tb));
             }
@@ -136,6 +206,101 @@ pub fn crossings(paths: &[&PathData], self_crossings: bool) -> Option<Vec<Vec<Pl
     Some(out)
 }
 
+/// Most segments of other paths [`crossings_on`] compares one path with.
+pub const MAX_CROSSED_BY_SEGMENTS: usize = 200_000;
+/// Most pairs of segments [`crossings_on`] looks at.
+const MAX_PAIRS: usize = 60_000_000;
+
+/// The work [`crossings_on_within`] may still do: pairs of segments to look at and subdivision steps.
+/// One value shared by several calls bounds them all together.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Work {
+    pairs: usize,
+    steps: usize,
+}
+
+impl Default for Work {
+    /// The work one [`crossings_on`] call may do.
+    fn default() -> Self {
+        Self { pairs: MAX_PAIRS, steps: MAX_STEPS }
+    }
+}
+
+/// Where `others` cross `path`, and where `path` crosses itself (a segment that loops over itself
+/// included): the places on `path`, in order, within the work of [`Work::default`].
+pub fn crossings_on(path: &PathData, others: &[&PathData]) -> Option<Vec<Place>> {
+    crossings_on_within(path, others, &mut Work::default())
+}
+
+/// [`crossings_on`], drawing on `work`. Only the segments of `others` whose control boxes meet the
+/// box of `path` are compared with it, so the paths far from it cost one box test per segment.
+/// Segments of `path` that meet at an anchor they share don't count as crossing there, and a
+/// segment of `others` with a coordinate that isn't finite is left out. `None` when `path` has more
+/// than [`MAX_CROSSING_SEGMENTS`] segments or a coordinate that isn't finite, when more than
+/// [`MAX_CROSSED_BY_SEGMENTS`] segments of `others` lie in its box, when the pairs of segments to
+/// look at are more than `work` has left, or when the curves are too tangled to sort out in the
+/// steps it has left.
+pub fn crossings_on_within(path: &PathData, others: &[&PathData], work: &mut Work) -> Option<Vec<Place>> {
+    let mut own: Vec<(usize, usize, CubicBez, Rect)> = vec![];
+    for (si, sp) in path.subpaths.iter().enumerate() {
+        for s in 0..sp.segment_count() {
+            let c = sp.segment(s);
+            if ![c.p0, c.p1, c.p2, c.p3].iter().all(|p| p.x.is_finite() && p.y.is_finite()) {
+                return None;
+            }
+            own.push((si, s, c, control_box(&c)));
+            if own.len() > MAX_CROSSING_SEGMENTS {
+                return None;
+            }
+        }
+    }
+    let Some(reach) = own.iter().map(|o| o.3).reduce(|a, b| a.union(b)).map(|r| r.inflate(SAME, SAME)) else { return Some(vec![]) };
+    let mut near: Vec<(CubicBez, Rect)> = vec![];
+    for sp in others.iter().flat_map(|p| &p.subpaths) {
+        for s in 0..sp.segment_count() {
+            let c = sp.segment(s);
+            let r = control_box(&c);
+            if [c.p0, c.p1, c.p2, c.p3].iter().all(|p| p.x.is_finite() && p.y.is_finite()) && reach.overlaps(r) {
+                near.push((c, r));
+                if near.len() > MAX_CROSSED_BY_SEGMENTS {
+                    return None;
+                }
+            }
+        }
+    }
+    work.pairs = work.pairs.checked_sub(own.len().saturating_mul(near.len() + own.len() / 2))?;
+    let with_length: Vec<Vec<usize>> = path.subpaths.iter().map(with_length_from).collect();
+    let mut out: Vec<Place> = vec![];
+    let budget = &mut work.steps;
+    for (i, (sa, ia, ca, ra)) in own.iter().enumerate() {
+        let ra = ra.inflate(SAME, SAME);
+        if let Some((s, t)) = self_crossing(ca) {
+            out.extend([(*sa, *ia, s), (*sa, *ia, t)]);
+        }
+        for (cb, rb) in &near {
+            if ra.overlaps(*rb) {
+                out.extend(segment_crossings(ca, cb, budget)?.into_iter().map(|(ta, _)| (*sa, *ia, ta)));
+            }
+        }
+        for (sb, ib, cb, rb) in own.iter().skip(i + 1) {
+            if !ra.overlaps(*rb) {
+                continue;
+            }
+            let shared = match (path.subpaths.get(*sa), with_length.get(*sa)) {
+                (Some(sp), Some(w)) if sa == sb => shared_anchors(sp, w, *ia, *ib),
+                _ => vec![],
+            };
+            for (ta, tb) in crossings_apart(ca, cb, &shared, budget)? {
+                out.push((*sa, *ia, ta));
+                out.push((*sb, *ib, tb));
+            }
+        }
+    }
+    out.sort_by(|x, y| (x.0, x.1).cmp(&(y.0, y.1)).then(x.2.total_cmp(&y.2)));
+    out.dedup_by(|x, y| (x.0, x.1) == (y.0, y.1) && (x.2 - y.2).abs() < END);
+    Some(out)
+}
+
 /// `sp` with an anchor at each of `places` (segment, t), the shape unchanged → (the subpath, the
 /// indexes of the anchors at those places: the new ones, and existing ones where a place falls on
 /// an anchor). Places off the subpath are left out.
diff --git a/crates/pathops/src/addons/pathtools/tests.rs b/crates/pathops/src/addons/pathtools/tests.rs
index 121fe6653c..301da1a57c 100644
--- a/crates/pathops/src/addons/pathtools/tests.rs
+++ b/crates/pathops/src/addons/pathtools/tests.rs
@@ -434,3 +434,235 @@ fn splitting_reads_an_anchors_kind_from_its_handles() {
     assert_eq!(split_at_anchors(&sq, true, false).len(), 3);
     assert!(split_at_anchors(&sq, true, false).iter().all(|p| !p.closed));
 }
+
+#[test]
+fn crossings_on_finds_one_paths_places_among_many() {
+    // A horizontal line crossed by two uprights, with a self-crossing bow far away.
+    let across = PathData::single(line(&[(0.0, 50.0), (300.0, 50.0)], false));
+    let up1 = PathData::single(line(&[(100.0, 0.0), (100.0, 100.0)], false));
+    let up2 = PathData::single(line(&[(200.0, 0.0), (200.0, 100.0)], false));
+    let far = PathData::single(line(&[(1000.0, 0.0), (1100.0, 100.0), (1100.0, 0.0), (1000.0, 100.0)], false));
+    let places = crossings_on(&across, &[&up1, &up2, &far]).unwrap();
+    assert_eq!(places.len(), 2, "{places:?}");
+    let x = |p: &Place| across.subpaths[p.0].segment(p.1).eval(p.2).x;
+    assert!(near(x(&places[0]), 100.0, 1e-6) && near(x(&places[1]), 200.0, 1e-6));
+    // A path's crossings with itself count, once on each of the two segments.
+    let own = crossings_on(&far, &[&across]).unwrap();
+    assert_eq!(own.iter().map(|p| p.1).collect::<Vec<_>>(), [0, 2], "{own:?}");
+    // A path that ends on another marks the other there, and its own end.
+    let stub = PathData::single(line(&[(150.0, 50.0), (150.0, 90.0)], false));
+    assert_eq!(crossings_on(&across, &[&stub]).unwrap().len(), 1);
+    assert!(near(crossings_on(&stub, &[&across]).unwrap()[0].2, 0.0, 1e-6));
+    // Lines lying along each other don't cross, and a path with a coordinate that isn't finite is refused.
+    let along = PathData::single(line(&[(50.0, 50.0), (250.0, 50.0)], false));
+    assert!(crossings_on(&across, &[&along]).unwrap().is_empty());
+    let broken = PathData::single(line(&[(0.0, f64::NAN), (10.0, 10.0)], false));
+    assert!(crossings_on(&broken, &[&across]).is_none());
+    assert_eq!(crossings_on(&across, &[&broken, &up1]).unwrap().len(), 1, "a broken path beside it is left out");
+    assert!(crossings_on(&PathData::default(), &[&across]).unwrap().is_empty());
+}
+
+#[test]
+fn segments_that_share_an_anchor_still_cross_elsewhere() {
+    // A straight segment, then a curve from its end that swings back across it near x = 17.4.
+    let hook = SubPath::new(
+        vec![Anchor::corner(pt(0.0, 0.0)), Anchor { h_out: pt(-50.0, 50.0), ..Anchor::corner(pt(100.0, 0.0)) }, Anchor::corner(pt(50.0, -50.0))],
+        false,
+    );
+    let path = PathData::single(hook.clone());
+    let places = crossings_on(&path, &[]).unwrap();
+    assert_eq!(places.iter().map(|p| p.1).collect::<Vec<_>>(), [0, 1], "{places:?}");
+    let x = hook.segment(0).eval(places[0].2).x;
+    assert!(near(x, 17.4, 0.01), "{x}");
+    assert!(hook.segment(1).eval(places[1].2).distance(pt(x, 0.0)) < 1e-3);
+    // Split at Crossings finds it too, and neither counts the anchor the segments share.
+    assert_eq!(crossings(&[&path], true).unwrap()[0], places);
+    // The two segments of a closed subpath share both ends: a lens has no crossing.
+    let lens = SubPath::new(
+        vec![
+            Anchor { h_out: pt(30.0, -40.0), h_in: pt(30.0, 40.0), ..Anchor::corner(pt(0.0, 0.0)) },
+            Anchor { h_in: pt(70.0, -40.0), h_out: pt(70.0, 40.0), ..Anchor::corner(pt(100.0, 0.0)) },
+        ],
+        true,
+    );
+    assert!(crossings_on(&PathData::single(lens.clone()), &[]).unwrap().is_empty());
+    assert!(crossings(&[&PathData::single(lens)], true).unwrap()[0].is_empty());
+}
+
+#[test]
+fn segments_with_no_length_between_them_still_share_their_anchor() {
+    // An open path with its middle anchor doubled, and a closed one whose last anchor sits on its
+    // first: the segments either side of the one with no length meet there and don't cross.
+    let doubled = PathData::single(line(&[(0.0, 0.0), (100.0, 0.0), (100.0, 0.0), (100.0, 100.0)], false));
+    let ring = PathData::single(line(&[(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0), (0.0, 0.0)], true));
+    for p in [&doubled, &ring] {
+        assert!(crossings_on(p, &[]).unwrap().is_empty(), "{:?}", crossings_on(p, &[]));
+        assert!(crossings(&[p], true).unwrap()[0].is_empty(), "{:?}", crossings(&[p], true));
+    }
+    // A segment that crosses them elsewhere still does.
+    let bow = PathData::single(line(&[(0.0, 0.0), (100.0, 100.0), (100.0, 100.0), (100.0, 0.0), (0.0, 100.0)], false));
+    assert_eq!(crossings_on(&bow, &[]).unwrap().iter().map(|p| p.1).collect::<Vec<_>>(), [0, 3]);
+}
+
+#[test]
+fn one_work_budget_bounds_several_calls_together() {
+    // 1,000 segments in a straight row: 500,000 pairs a call, so 120 calls spend 60,000,000.
+    let row: Vec<(f64, f64)> = (0..=1000).map(|i| (i as f64, 0.0)).collect();
+    let path = PathData::single(line(&row, false));
+    let mut work = Work::default();
+    let calls = (0..200).take_while(|_| crossings_on_within(&path, &[], &mut work).is_some()).count();
+    assert_eq!(calls, 120);
+    assert!(crossings_on(&path, &[]).is_some(), "a call of its own has its own budget");
+}
+
+#[test]
+fn a_segment_that_loops_over_itself_crosses_itself() {
+    // One cubic that meets itself at t = 0.25 and t = 0.75.
+    let looped = PathData::single(SubPath::new(
+        vec![Anchor { h_out: pt(13.0 / 9.0, 1.0), ..Anchor::corner(pt(0.0, 0.0)) }, Anchor { h_in: pt(0.0, 1.0), ..Anchor::corner(pt(1.0, 0.0)) }],
+        false,
+    ));
+    let places = crossings_on(&looped, &[]).unwrap();
+    assert_eq!(places.len(), 2, "{places:?}");
+    assert!(near(places[0].2, 0.25, 1e-9) && near(places[1].2, 0.75, 1e-9), "{places:?}");
+    assert_eq!(crossings(&[&looped], true).unwrap()[0], places);
+    assert!(crossings(&[&looped], false).unwrap()[0].is_empty());
+    // Its two visits to that point divide it into three stretches, and the loop can go alone.
+    let sp = &looped.subpaths[0];
+    let three = spans(sp, &places.iter().map(|p| (p.1, p.2)).collect::<Vec<_>>());
+    assert_eq!(three.len(), 3, "{three:?}");
+    let left = without_spans(sp, &three, &[false, true, false]).unwrap();
+    assert_eq!(left.len(), 2);
+    let x = sp.segment(0).eval(0.25);
+    assert_eq!((left[0].anchors[0].p, left[1].anchors.last().unwrap().p), (pt(0.0, 0.0), pt(1.0, 0.0)));
+    assert!(left[0].anchors.last().unwrap().p.distance(x) < 1e-3 && left[1].anchors[0].p.distance(x) < 1e-3);
+    // The same loop squashed to a 10⁻¹² of its height.
+    let flat = PathData::single(SubPath::new(
+        vec![
+            Anchor { h_out: pt(13.0 / 9.0, 1e-12), ..Anchor::corner(pt(0.0, 0.0)) },
+            Anchor { h_in: pt(0.0, 1e-12), ..Anchor::corner(pt(1.0, 0.0)) },
+        ],
+        false,
+    ));
+    assert_eq!(crossings_on(&flat, &[]).unwrap().iter().map(|p| (p.2 * 4.0).round()).collect::<Vec<_>>(), [1.0, 3.0]);
+    // An arch, an S and a cusp don't cross themselves.
+    for (h1, h2) in [((0.0, 1.0), (1.0, 1.0)), ((0.3, 1.0), (0.7, -1.0)), ((1.0, 1.0), (0.0, 1.0))] {
+        let c = PathData::single(SubPath::new(
+            vec![Anchor { h_out: pt(h1.0, h1.1), ..Anchor::corner(pt(0.0, 0.0)) }, Anchor { h_in: pt(h2.0, h2.1), ..Anchor::corner(pt(1.0, 0.0)) }],
+            false,
+        ));
+        assert!(crossings_on(&c, &[]).unwrap().is_empty(), "{h1:?} {h2:?}");
+    }
+    // Nor does a straight curve that doubles back along itself, at a slant.
+    let back = PathData::single(SubPath::new(
+        vec![Anchor { h_out: pt(1.6, 1.2), ..Anchor::corner(pt(0.0, 0.0)) }, Anchor { h_in: pt(-0.8, -0.6), ..Anchor::corner(pt(0.8, 0.6)) }],
+        false,
+    ));
+    assert!(crossings_on(&back, &[]).unwrap().is_empty());
+}
+
+#[test]
+fn spans_divide_a_subpath_at_its_places() {
+    let open = line(&[(0.0, 0.0), (100.0, 0.0), (100.0, 100.0)], false);
+    assert_eq!(spans(&open, &[]), [(0.0, 2.0)]);
+    assert_eq!(spans(&open, &[(1, 0.5), (0, 0.25)]), [(0.0, 0.25), (0.25, 1.5), (1.5, 2.0)]);
+    // Places at an open end, off the subpath, or twice at one point, add no stretch.
+    assert_eq!(spans(&open, &[(0, 0.0), (1, 1.0), (7, 0.5), (0, 0.5), (0, 0.5 + 1e-9), (0, f64::NAN)]), [(0.0, 0.5), (0.5, 2.0)]);
+    // A place at an anchor is the same from either segment.
+    assert_eq!(spans(&open, &[(0, 1.0), (1, 0.0)]), [(0.0, 1.0), (1.0, 2.0)]);
+    let ring = line(&[(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)], true);
+    assert_eq!(spans(&ring, &[]), [(0.0, 4.0)]);
+    assert_eq!(spans(&ring, &[(1, 0.5)]), [(1.5, 5.5)], "one place: from it round to it again");
+    assert_eq!(spans(&ring, &[(3, 0.5), (0, 0.5)]), [(0.5, 3.5), (3.5, 4.5)]);
+    // The closing segment's end is the first anchor.
+    assert_eq!(spans(&ring, &[(3, 1.0), (0, 0.0), (2, 0.0)]), [(0.0, 2.0), (2.0, 4.0)]);
+    assert!(spans(&SubPath::new(vec![Anchor::corner(pt(1.0, 1.0))], false), &[(0, 0.5)]).is_empty());
+    // Which stretch a place is on: the one that starts there, the last one at an open end.
+    let three = spans(&open, &[(1, 0.5), (0, 0.25)]);
+    assert_eq!(span_at(&open, &three, 0, 0.1), Some(0));
+    assert_eq!(span_at(&open, &three, 0, 0.25), Some(1));
+    assert_eq!(span_at(&open, &three, 1, 1.0), Some(2));
+    assert_eq!(span_at(&open, &three, 0, f64::NAN), None);
+    let two = spans(&ring, &[(3, 0.5), (0, 0.5)]);
+    assert_eq!((span_at(&ring, &two, 0, 0.25), span_at(&ring, &two, 3, 0.75), span_at(&ring, &two, 2, 0.0)), (Some(1), Some(1), Some(0)));
+    // The closing segment's end is the first anchor: on the stretch that starts there, or runs through it.
+    let at_first = spans(&ring, &[(0, 0.0), (2, 0.0)]);
+    assert_eq!((span_at(&ring, &at_first, 3, 1.0), span_at(&ring, &at_first, 0, 0.0)), (Some(0), Some(0)));
+    assert_eq!((span_at(&ring, &two, 3, 1.0), span_at(&ring, &spans(&ring, &[]), 3, 1.0)), (Some(1), Some(0)));
+}
+
+#[test]
+fn a_subpath_without_some_stretches_keeps_the_rest_as_it_was() {
+    // An open line of three segments, crossed twice on its middle one: the middle stretch goes.
+    let open = line(&[(0.0, 0.0), (100.0, 0.0), (200.0, 0.0), (300.0, 0.0)], false);
+    let three = spans(&open, &[(1, 0.25), (1, 0.75)]);
+    let left = without_spans(&open, &three, &[false, true, false]).unwrap();
+    let xs = |sp: &SubPath| sp.anchors.iter().map(|a| a.p.x).collect::<Vec<_>>();
+    // A straight segment's parameter doesn't run evenly along it: the cuts are where it puts them.
+    let (q1, q3) = (open.segment(1).eval(0.25).x, open.segment(1).eval(0.75).x);
+    assert!(100.0 < q1 && q1 < q3 && q3 < 200.0);
+    assert_eq!(left.iter().map(xs).collect::<Vec<_>>(), [vec![0.0, 100.0, q1], vec![q3, 200.0, 300.0]]);
+    assert!(left.iter().all(|p| !p.closed && p.anchors.iter().all(|a| a.h_in == a.p && a.h_out == a.p)), "straight pieces have no handles");
+    // Nothing marked: unchanged. All marked: nothing left. An end stretch: one piece.
+    assert!(without_spans(&open, &three, &[false, false, false]).is_none());
+    assert!(without_spans(&open, &three, &[]).is_none());
+    assert_eq!(without_spans(&open, &three, &[true, true, true]), Some(vec![]));
+    assert_eq!(without_spans(&open, &three, &[true, false, false]).unwrap().iter().map(xs).collect::<Vec<_>>(), [vec![q1, 200.0, 300.0]]);
+    // Stretches left side by side stay one piece with no anchor where they meet.
+    let four = spans(&open, &[(0, 0.5), (1, 0.5), (2, 0.5)]);
+    assert_eq!(
+        without_spans(&open, &four, &[false, false, false, true]).unwrap().iter().map(xs).collect::<Vec<_>>(),
+        [vec![0.0, 100.0, 200.0, 250.0]]
+    );
+    // A closed square that loses a stretch opens, and its first anchor stays inside the piece.
+    let ring = line(&[(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)], true);
+    let two = spans(&ring, &[(1, 0.5), (2, 0.5)]);
+    let open_ring = without_spans(&ring, &two, &[true, false]).unwrap();
+    assert_eq!(open_ring.len(), 1);
+    let pts: Vec<Point> = open_ring[0].anchors.iter().map(|a| a.p).collect();
+    assert_eq!(pts, [pt(50.0, 100.0), pt(0.0, 100.0), pt(0.0, 0.0), pt(100.0, 0.0), pt(100.0, 50.0)]);
+    assert!(!open_ring[0].closed);
+    // The same when the removed stretch is the one through the first anchor.
+    let through = without_spans(&ring, &two, &[false, true]).unwrap();
+    assert_eq!(through[0].anchors.iter().map(|a| a.p).collect::<Vec<_>>(), [pt(100.0, 50.0), pt(100.0, 100.0), pt(50.0, 100.0)]);
+    // Three places: the two stretches left on both sides of the first anchor are one piece through it.
+    let three = spans(&ring, &[(0, 0.5), (1, 0.5), (2, 0.5)]);
+    assert_eq!(three, [(0.5, 1.5), (1.5, 2.5), (2.5, 4.5)]);
+    let around = without_spans(&ring, &three, &[false, true, false]).unwrap();
+    assert_eq!(around.len(), 1, "{around:?}");
+    let pts: Vec<Point> = around[0].anchors.iter().map(|a| a.p).collect();
+    assert_eq!(pts, [pt(50.0, 100.0), pt(0.0, 100.0), pt(0.0, 0.0), pt(100.0, 0.0), pt(100.0, 50.0)]);
+    // A closed subpath with one place loses all of itself.
+    assert_eq!(without_spans(&ring, &spans(&ring, &[(0, 0.5)]), &[true]), Some(vec![]));
+}
+
+#[test]
+fn a_slice_of_a_curve_keeps_its_shape_and_the_anchors_it_runs_through() {
+    let mut circle = line(&[(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)], true);
+    for i in 0..4 {
+        auto_smooth(&mut circle, i, SMOOTH_RATIO);
+    }
+    let piece = slice(&circle, (0.5, 2.5));
+    assert_eq!(piece.anchors.len(), 4);
+    assert!(!piece.closed);
+    // Its ends are corners with the handle off the piece retracted; the anchors between stay smooth, and
+    // the whole segment between them keeps its handles.
+    assert_eq!((piece.anchors[0].kind, piece.anchors[3].kind), (AnchorKind::Corner, AnchorKind::Corner));
+    assert_eq!((piece.anchors[0].h_in, piece.anchors[3].h_out), (piece.anchors[0].p, piece.anchors[3].p));
+    assert_eq!((piece.anchors[1].p, piece.anchors[2].p), (circle.anchors[1].p, circle.anchors[2].p));
+    assert_eq!((piece.anchors[1].h_out, piece.anchors[2].h_in), (circle.anchors[1].h_out, circle.anchors[2].h_in));
+    assert_eq!((piece.anchors[1].kind, piece.anchors[2].kind), (AnchorKind::Smooth, AnchorKind::Smooth));
+    // Every point of the piece is on the circle's outline.
+    for i in 0..piece.segment_count() {
+        for k in 0..=8 {
+            let p = piece.segment(i).eval(k as f64 / 8.0);
+            let d = PathData::single(circle.clone()).nearest(p).unwrap().4;
+            assert!(d < 1e-6, "{p:?} is {d} off");
+        }
+    }
+    assert!(near(length(&piece), length(&circle) / 2.0, 1e-3));
+    // No length, backwards or not finite: nothing.
+    assert!(slice(&circle, (1.0, 1.0)).anchors.is_empty());
+    assert!(slice(&circle, (2.0, 1.0)).anchors.is_empty());
+    assert!(slice(&circle, (f64::NAN, 1.0)).anchors.is_empty());
+}
diff --git a/crates/pathops/src/addons/pathtools/trim.rs b/crates/pathops/src/addons/pathtools/trim.rs
new file mode 100644
index 0000000000..618f8eb002
--- /dev/null
+++ b/crates/pathops/src/addons/pathtools/trim.rs
@@ -0,0 +1,153 @@
+//! The stretches of a subpath between the places it is crossed ([`spans`]), the stretch a place
+//! lies on ([`span_at`]), a stretch as a subpath of its own ([`slice`]) and the subpath with some
+//! of its stretches removed ([`without_spans`]).
+
+use kurbo::{ParamCurve, Point};
+use vectorcraft_geom::{Anchor, AnchorKind, SubPath};
+
+/// A parameter this close to a segment's end is its anchor.
+const END: f64 = 1e-6;
+/// Places closer than this (pt) are one.
+const SAME: f64 = 1e-3;
+
+/// A stretch of a subpath: where it starts and ends, each a segment's index plus the parameter on
+/// that segment. On a closed subpath the end is past the segment count where the stretch runs
+/// through the first anchor.
+pub type Span = (f64, f64);
+
+/// The point at position `u` (a segment's index plus the parameter on it) of `sp`, which has
+/// segments. A closed subpath's positions wrap round.
+fn point_at(sp: &SubPath, u: f64) -> Point {
+    let n = sp.segment_count();
+    let u = if sp.closed { u.rem_euclid(n as f64) } else { u.clamp(0.0, n as f64) };
+    let seg = (u.floor() as usize).min(n.saturating_sub(1));
+    sp.segment(seg).eval(u - seg as f64)
+}
+
+/// The stretches `places` (segment, t) divide `sp` into, in the subpath's order. An open subpath
+/// starts and ends a stretch at its ends; a closed one with no place is one stretch, the whole of
+/// it, and so is a closed one with one place, from that place round to it again. Places the subpath
+/// runs between without moving 0.001 pt away are one (a loop's two visits to a point are two), so
+/// are a place and an open end, and places off the subpath are left out.
+pub fn spans(sp: &SubPath, places: &[(usize, f64)]) -> Vec<Span> {
+    let n = sp.segment_count();
+    if n == 0 {
+        return vec![];
+    }
+    let nf = n as f64;
+    let mut at: Vec<f64> = places
+        .iter()
+        .filter(|(seg, t)| *seg < n && t.is_finite())
+        .map(|&(seg, t)| {
+            let t = if t <= END {
+                0.0
+            } else if t >= 1.0 - END {
+                1.0
+            } else {
+                t
+            };
+            let u = seg as f64 + t;
+            if sp.closed && u >= nf { u - nf } else { u }
+        })
+        .collect();
+    at.sort_by(f64::total_cmp);
+    // Two positions are one place when the subpath stays at the same point between them; a loop
+    // that comes back to a point visits it twice.
+    let same = |a: f64, b: f64| {
+        let p = point_at(sp, a);
+        (b - a).abs() < 1.0 && [0.25, 0.5, 0.75, 1.0].iter().all(|f| point_at(sp, a + (b - a) * f).distance(p) < SAME)
+    };
+    at.dedup_by(|later, earlier| same(*earlier, *later));
+    if !sp.closed {
+        at.retain(|u| !same(0.0, *u) && !same(*u, nf));
+        let bounds: Vec<f64> = std::iter::once(0.0).chain(at).chain([nf]).collect();
+        return bounds.windows(2).filter_map(|w| Some((*w.first()?, *w.get(1)?))).collect();
+    }
+    // The last place and the first meet round the first anchor.
+    while let (Some(&first), Some(&last)) = (at.first(), at.last())
+        && at.len() > 1
+        && same(last - nf, first)
+    {
+        at.pop();
+    }
+    let Some(&first) = at.first() else { return vec![(0.0, nf)] };
+    at.push(first + nf);
+    at.windows(2).filter_map(|w| Some((*w.first()?, *w.get(1)?))).collect()
+}
+
+/// Which of `stretches` of `sp` the place (`seg`, `t`) lies on. A place where two stretches meet
+/// is on the one that starts there.
+pub fn span_at(sp: &SubPath, stretches: &[Span], seg: usize, t: f64) -> Option<usize> {
+    let nf = sp.segment_count() as f64;
+    if !t.is_finite() {
+        return None;
+    }
+    let u = (seg as f64 + t.clamp(0.0, 1.0)).min(nf);
+    // On a closed subpath the closing segment's end is the first anchor.
+    let u = if sp.closed && u >= nf { u - nf } else { u };
+    let on = |&(from, to): &Span| (from <= u && u < to) || (sp.closed && from <= u + nf && u + nf < to);
+    stretches.iter().position(on).or_else(|| (!sp.closed && u >= nf).then(|| stretches.len().checked_sub(1)).flatten())
+}
+
+/// The stretch `(from, to)` of `sp` as an open subpath of its own: the anchors it runs through keep
+/// their kind and handles, and its ends are corners. Empty when the stretch has no length.
+pub fn slice(sp: &SubPath, (from, to): Span) -> SubPath {
+    let n = sp.segment_count();
+    let mut anchors: Vec<Anchor> = vec![];
+    if n == 0 || !(from.is_finite() && to.is_finite()) || from < 0.0 || to <= from {
+        return SubPath::new(anchors, false);
+    }
+    let to = to.min(from + n as f64);
+    let mut i = from.floor() as usize;
+    while (i as f64) < to {
+        let (t0, t1) = ((from - i as f64).max(0.0), (to - i as f64).min(1.0));
+        let seg = i % n;
+        i += 1;
+        if t1 <= t0 {
+            continue;
+        }
+        let whole = sp.segment(seg);
+        let c = if t0 <= 0.0 && t1 >= 1.0 { whole } else { whole.subsegment(t0..t1) };
+        let (h1, h2) = if sp.segment_is_line(seg) { (c.p0, c.p3) } else { (c.p1, c.p2) };
+        match anchors.last_mut() {
+            Some(a) => a.h_out = h1,
+            None => anchors.push(Anchor { p: c.p0, h_in: c.p0, h_out: h1, kind: AnchorKind::Corner }),
+        }
+        // An anchor the stretch runs through keeps its kind.
+        let through = t1 >= 1.0 && (i as f64) < to;
+        let kind = if through { sp.anchors.get((seg + 1) % sp.anchors.len()).map_or(AnchorKind::Corner, |a| a.kind) } else { AnchorKind::Corner };
+        anchors.push(Anchor { p: c.p3, h_in: h2, h_out: c.p3, kind });
+    }
+    SubPath::new(anchors, false)
+}
+
+/// `sp` without the stretches of `stretches` that `remove` marks: the pieces left, each an open
+/// subpath, in the subpath's order. Stretches left side by side stay one piece, so no anchor is
+/// added where a stretch that stays meets another. `None` when no stretch is marked, and no piece
+/// when all are.
+pub fn without_spans(sp: &SubPath, stretches: &[Span], remove: &[bool]) -> Option<Vec<SubPath>> {
+    let n = stretches.len();
+    let gone = |i: usize| remove.get(i).copied().unwrap_or(false);
+    let first_gone = (0..n).find(|&i| gone(i))?;
+    let nf = sp.segment_count() as f64;
+    // A closed subpath is walked from its first removed stretch, so the stretches left on both
+    // sides of its first anchor are one piece.
+    let start = if sp.closed { first_gone } else { 0 };
+    let mut out = vec![];
+    let mut run: Option<Span> = None;
+    for k in 0..n {
+        let i = (start + k) % n;
+        let Some(&(from, to)) = stretches.get(i).filter(|_| !gone(i)) else {
+            out.extend(run.take().map(|r| slice(sp, r)));
+            continue;
+        };
+        run = Some(match run {
+            // Past the first anchor of a closed subpath the positions start again.
+            Some((a, b)) => (a, if to < b { to + nf } else { to }),
+            None => (from, to),
+        });
+    }
+    out.extend(run.map(|r| slice(sp, r)));
+    out.retain(|p| p.anchors.len() >= 2);
+    Some(out)
+}
diff --git a/crates/pathops/src/edit.rs b/crates/pathops/src/edit.rs
index 960f4036d8..87b4cb000d 100644
--- a/crates/pathops/src/edit.rs
+++ b/crates/pathops/src/edit.rs
@@ -28,11 +28,26 @@ pub struct SimplifyOptions {
     /// keeps its shape. The limit is the same along the whole stretch, so where smoothing moves some of
     /// its points far, all of it is refitted within up to `tolerance`, as without this option.
     pub smooth_moved_only: bool,
+    /// With [`smooth`](Self::smooth), the curve at an open subpath's first anchor leaves it along the
+    /// direction of the smoothed path over the 3 spreads next to it rather than along its first
+    /// segment. The anchor stays where it is. A closed subpath has no such end, and [`simplify_part`]
+    /// ignores this.
+    pub free_start: bool,
+    /// [`free_start`](Self::free_start) for an open subpath's last anchor.
+    pub free_end: bool,
 }
 
 impl Default for SimplifyOptions {
     fn default() -> Self {
-        Self { tolerance: 0.5, corner_angle_deg: 30.0, straight_lines: false, smooth: 0.0, smooth_moved_only: false }
+        Self {
+            tolerance: 0.5,
+            corner_angle_deg: 30.0,
+            straight_lines: false,
+            smooth: 0.0,
+            smooth_moved_only: false,
+            free_start: false,
+            free_end: false,
+        }
     }
 }
 
@@ -107,6 +122,8 @@ fn simplify_subpath(sp: &SubPath, opts: &SimplifyOptions) -> Option<SubPath> {
     if n == 0 || sp.closed && n < 2 {
         return Some(sp.clone());
     }
+    let closed_opts = SimplifyOptions { free_start: false, free_end: false, ..*opts };
+    let opts = if sp.closed { &closed_opts } else { opts };
     if sp.closed {
         // Start the loop at its first corner, so no fit runs across one.
         let k = (0..n).find(|&i| turn_deg(&segs[(i + n - 1) % n], &segs[i]) > opts.corner_angle_deg).unwrap_or(0);
@@ -282,6 +299,12 @@ pub(crate) fn simplify_run_within(run: &[Seg], opts: &SimplifyOptions, mut budge
     cuts.insert(0, 0);
     cuts.push(run.len());
     let mut result: Vec<Seg> = Vec::new();
+    // Whether `part` starts where `run` does and whether it ends where `run` does, for the free ends.
+    let free = |part: &[(&Seg, usize)]| {
+        let starts = part.first().zip(run.first()).is_some_and(|((s, _), r)| std::ptr::eq(*s, r));
+        let ends = part.last().zip(run.last()).is_some_and(|((s, _), r)| std::ptr::eq(*s, r));
+        [opts.free_start && starts, opts.free_end && ends]
+    };
     for w in cuts.windows(2) {
         let piece = &run[w[0]..w[1]];
         let mut part: Vec<(&Seg, usize)> = Vec::new();
@@ -290,7 +313,7 @@ pub(crate) fn simplify_run_within(run: &[Seg], opts: &SimplifyOptions, mut budge
             let steps = sample_steps(&s.c, tol);
             if steps <= budget.min(MAX_SEGMENT_SAMPLES) && result.len() < MAX_RUN_RESULT {
                 if part_samples + steps > MAX_FIT_SAMPLES {
-                    refit_part(&part, opts, tol, None, &mut result);
+                    refit_part(&part, opts, tol, None, free(&part), &mut result);
                     part.clear();
                     part_samples = 0;
                 }
@@ -299,7 +322,7 @@ pub(crate) fn simplify_run_within(run: &[Seg], opts: &SimplifyOptions, mut budge
                 part.push((s, steps));
             } else {
                 part_samples = 0;
-                refit_part(&part, opts, tol, None, &mut result);
+                refit_part(&part, opts, tol, None, free(&part), &mut result);
                 part.clear();
                 if opts.straight_lines {
                     let room = MAX_RUN_RESULT.saturating_sub(result.len());
@@ -313,7 +336,7 @@ pub(crate) fn simplify_run_within(run: &[Seg], opts: &SimplifyOptions, mut budge
                 }
             }
         }
-        refit_part(&part, opts, tol, ends.filter(|_| part.len() == run.len()), &mut result);
+        refit_part(&part, opts, tol, ends.filter(|_| part.len() == run.len()), free(&part), &mut result);
     }
     result
 }
@@ -321,14 +344,18 @@ pub(crate) fn simplify_run_within(run: &[Seg], opts: &SimplifyOptions, mut budge
 /// Adds the refit of `part`, consecutive segments with no corner between them and the steps to
 /// sample each one with, to `result`. `ends`, given only when `part` is a whole closed loop, is the
 /// direction it leaves and arrives along; when the loop is smoothed, the smoothing runs across its
-/// start and the direction comes from the smoothed samples there.
-fn refit_part(part: &[(&Seg, usize)], opts: &SimplifyOptions, tol: f64, mut ends: Option<Vec2>, result: &mut Vec<Seg>) {
+/// start and the direction comes from the smoothed samples there. `free` says whether the start and
+/// the end of `part` are free ends of an open subpath: when it is smoothed, the refit leaves such a
+/// start and arrives at such an end along [`free_end_direction`], or along its first or last segment
+/// when that gives none or turns from the segment by 90° or more.
+fn refit_part(part: &[(&Seg, usize)], opts: &SimplifyOptions, tol: f64, mut ends: Option<Vec2>, free: [bool; 2], result: &mut Vec<Seg>) {
     let (Some((first, _)), Some((last, _))) = (part.first(), part.last()) else { return };
     let mut pts = Vec::new();
     for (k, (s, steps)) in part.iter().enumerate() {
         sample(&s.c, *steps, &mut pts, k == 0);
     }
     let mut tol = tol;
+    let (mut t0, mut t1) = (start_tangent(&first.c), end_tangent(&last.c));
     if opts.smooth > 0.0 {
         let smoothed = if ends.is_some() { smooth_loop_points(&pts, opts.smooth) } else { smooth_points(&pts, opts.smooth) };
         if ends.is_some()
@@ -336,6 +363,18 @@ fn refit_part(part: &[(&Seg, usize)], opts: &SimplifyOptions, tol: f64, mut ends
         {
             ends = unit(next - prev).or(ends);
         }
+        if ends.is_none() {
+            if free[0]
+                && let Some(d) = free_end_direction(&smoothed, opts.smooth, false).filter(|d| d.dot(t0) > 0.0)
+            {
+                t0 = d;
+            }
+            if free[1]
+                && let Some(d) = free_end_direction(&smoothed, opts.smooth, true).filter(|d| d.dot(t1) > 0.0)
+            {
+                t1 = d;
+            }
+        }
         if opts.smooth_moved_only {
             tol = tol.min((2.0 * smoothing_moved(&pts, &smoothed)).max(tol * SMOOTH_MOVED_FLOOR));
         }
@@ -351,7 +390,7 @@ fn refit_part(part: &[(&Seg, usize)], opts: &SimplifyOptions, tol: f64, mut ends
     // to 1.5% of `tol`: 3/4 of how far its handles may be from the line. The fitted curves join
     // smoothly, so a curve becomes a line only when the line keeps both of its joins smooth. The last
     // curve of a loop fitted across its start leaves along the loop's first segment.
-    let (t0, t1) = ends.map_or((start_tangent(&first.c), end_tangent(&last.c)), |d| (d, d));
+    let (t0, t1) = ends.map_or((t0, t1), |d| (d, d));
     let fitted = fit_cubics(&pts, t0, t1, tol * 0.98);
     let from = result.len();
     let mut arrive = t0;
@@ -451,6 +490,66 @@ fn smoothing_moved(pts: &[Point], smoothed: &[Point]) -> f64 {
         .fold(0.0, f64::max)
 }
 
+/// How far along the path, in spreads of the smoothing, [`free_end_direction`] looks from the end:
+/// as far as the Gaussian reaches. VectorCraft's own value.
+const FREE_END_SPREADS: f64 = 3.0;
+
+/// [`free_end_direction`] gives no direction when the path near the end spreads out from it more
+/// evenly than this: the ratio of the least to the most squared distance from a line through the end,
+/// over all such lines. VectorCraft's own value.
+const FREE_END_MAX_SPREAD: f64 = 1.0 / 3.0;
+
+/// The direction the samples `pts` of an open run leave their first point along, or with `at_end`
+/// arrive at their last point along: the direction of the line through that point that the path
+/// within [`FREE_END_SPREADS`] spreads `sigma` of it along its length, and at most half its length,
+/// lies closest to by the least sum of squared distances, pointing along the path. `None` when the
+/// path there has no length or is not finite, when its mean point is within a tenth of its length
+/// there of that point (it doubles back), or when it spreads from that point more evenly than
+/// [`FREE_END_MAX_SPREAD`].
+fn free_end_direction(pts: &[Point], sigma: f64, at_end: bool) -> Option<Vec2> {
+    let n = pts.len();
+    let total: f64 = pts.windows(2).map(|w| w[0].distance(w[1])).sum();
+    let reach = (FREE_END_SPREADS * sigma).min(total / 2.0);
+    if !(reach.is_finite() && reach > 0.0) {
+        return None;
+    }
+    let at = |i: usize| pts.get(if at_end { n - 1 - i } else { i }).copied();
+    let origin = at(0)?;
+    // The integrals along the path of v vᵀ and of v, for v from the end to each point.
+    let (mut sxx, mut sxy, mut syy, mut sum, mut along) = (0.0, 0.0, 0.0, Vec2::ZERO, 0.0);
+    let mut a = Vec2::ZERO;
+    for i in 1..n {
+        let Some(p) = at(i) else { break };
+        let mut b = p - origin;
+        let mut len = (b - a).hypot();
+        if along + len > reach {
+            b = a.lerp(b, (reach - along) / len);
+            len = reach - along;
+        }
+        sxx += len * (a.x * a.x + a.x * b.x + b.x * b.x) / 3.0;
+        syy += len * (a.y * a.y + a.y * b.y + b.y * b.y) / 3.0;
+        sxy += len * (2.0 * a.x * a.y + a.x * b.y + b.x * a.y + 2.0 * b.x * b.y) / 6.0;
+        sum += (a + b) * (len / 2.0);
+        along += len;
+        a = b;
+        if along >= reach {
+            break;
+        }
+    }
+    let (trace, apart) = (sxx + syy, (sxx - syy).hypot(2.0 * sxy));
+    // The two principal values are (trace ± apart) / 2.
+    if !(trace.is_finite() && apart.is_finite() && trace > 0.0) || trace - apart > FREE_END_MAX_SPREAD * (trace + apart) {
+        return None;
+    }
+    let mean = sum / along;
+    if !mean.hypot().is_finite() || mean.hypot() < 0.1 * along {
+        return None;
+    }
+    let d = Vec2::from_angle(0.5 * (2.0 * sxy).atan2(sxx - syy));
+    let d = if d.dot(mean) >= 0.0 { d } else { -d };
+    unit(if at_end { -d } else { d })
+}
+
 /// How many groups of samples a spread holds at most in [`smooth_points`]. Weighing them in groups
 /// leaves each smoothed point within a thousandth of a spread of the mean of its samples weighed one
 /// by one.
@@ -597,6 +696,7 @@ pub struct SimplifiedPart {
 /// `segments` is simplified whole, as [`simplify_with`] does. A run whose refit would have more
 /// segments than it had is left as it is (except with Convert to Straight Lines).
 pub fn simplify_part(path: &PathData, segments: &BTreeSet<(usize, usize)>, opts: &SimplifyOptions) -> SimplifiedPart {
+    let opts = &SimplifyOptions { free_start: false, free_end: false, ..*opts };
     let (mut runs, mut anchors) = (BTreeSet::new(), BTreeMap::new());
     let mut subpaths = Vec::with_capacity(path.subpaths.len());
     for (si, sp) in path.subpaths.iter().enumerate() {
@@ -784,6 +884,8 @@ pub fn smooth_options(path: &PathData, level: f64) -> SimplifyOptions {
         straight_lines: false,
         smooth: size * 0.05 * level / 100.0,
         smooth_moved_only: false,
+        free_start: false,
+        free_end: false,
     }
 }
 
diff --git a/crates/pathops/tests/it/ops.rs b/crates/pathops/tests/it/ops.rs
index 93f6d4c29c..0b5b0bbf25 100644
--- a/crates/pathops/tests/it/ops.rs
+++ b/crates/pathops/tests/it/ops.rs
@@ -488,6 +488,61 @@ fn simplify_keeps_the_join_at_the_start_of_a_smoothed_loop_smooth() {
     }
 }
 
+/// The degrees between the x axis and the direction `sp` leaves its first anchor along.
+fn start_angle(sp: &SubPath) -> f64 {
+    let c = sp.segment(0);
+    let d = [c.p1 - c.p0, c.p2 - c.p0, c.p3 - c.p0].into_iter().find(|d| d.hypot() > 1e-9).unwrap_or_default();
+    d.y.atan2(d.x).to_degrees()
+}
+
+/// With `free_start` and `free_end`, a smoothed open subpath leaves its first anchor and arrives at
+/// its last one along the smoothed path, not along a jagged first or last segment, and its end points
+/// stay. Only a flagged end turns, and a closed subpath, Object › Path › Smooth's selected segments
+/// (`simplify_part`) and a refit without smoothing give the same result with the flags as without.
+#[test]
+fn free_ends_turn_only_open_smoothed_ends() {
+    let pts: Vec<Point> = (0..=40).map(|i| Point::new(5.0 * f64::from(i), if i == 1 || i == 39 { 1.5 } else { 0.0 })).collect();
+    let path = PathData::single(SubPath::polyline(&pts, false));
+    let base = SimplifyOptions { tolerance: 2.5, corner_angle_deg: 179.0, smooth: 4.0, smooth_moved_only: true, ..Default::default() };
+    let both = SimplifyOptions { free_start: true, free_end: true, ..base };
+    let s = simplify_with(&path, &both);
+    let sp = &s.subpaths[0];
+    assert_eq!((sp.anchors[0].p, sp.anchors[sp.anchors.len() - 1].p), (pts[0], pts[40]), "{s:?}");
+    let mut back = sp.clone();
+    back.reverse();
+    assert!(start_angle(sp).abs() <= 5.0 && (start_angle(&back).abs() - 180.0).abs() <= 5.0, "{s:?}");
+    let start_only = simplify_with(&path, &SimplifyOptions { free_start: true, ..base });
+    let plain = simplify_with(&path, &base);
+    assert!(start_angle(&start_only.subpaths[0]).abs() <= 5.0, "{start_only:?}");
+    assert!(start_angle(&plain.subpaths[0]) > 16.0, "{plain:?}");
+    let (mut a, mut b) = (start_only.subpaths[0].clone(), plain.subpaths[0].clone());
+    a.reverse();
+    b.reverse();
+    assert!((start_angle(&a) - start_angle(&b)).abs() <= 1e-9, "the last anchor keeps its direction: {start_only:?}");
+    // Flags that must have no effect.
+    let ring = PathData::single(SubPath::polyline(&pts[..39], true));
+    assert_eq!(simplify_with(&ring, &both), simplify_with(&ring, &base));
+    let unsmoothed = SimplifyOptions { smooth: 0.0, ..base };
+    assert_eq!(simplify_with(&path, &SimplifyOptions { free_start: true, free_end: true, ..unsmoothed }), simplify_with(&path, &unsmoothed));
+    let picked: std::collections::BTreeSet<(usize, usize)> = (0..20).map(|i| (0, i)).collect();
+    assert_eq!(simplify_part(&path, &picked, &both).path, simplify_part(&path, &picked, &base).path);
+}
+
+/// A free end whose smoothed path turns back by more than 90° from its first segment keeps that
+/// segment's direction: a path that leaves its start along x for 2 pt, then turns by 170°.
+#[test]
+fn a_free_end_that_turns_back_keeps_its_first_direction() {
+    let back = kurbo::Vec2::from_angle(170f64.to_radians());
+    let mut pts = vec![Point::ORIGIN, Point::new(2.0, 0.0)];
+    pts.extend((1..=10).map(|i| Point::new(2.0, 0.0) + back * (3.0 * f64::from(i))));
+    let path = PathData::single(SubPath::polyline(&pts, false));
+    let opts =
+        SimplifyOptions { tolerance: 2.5, corner_angle_deg: 179.0, smooth: 4.0, smooth_moved_only: true, free_start: true, ..Default::default() };
+    let s = simplify_with(&path, &opts);
+    let angle = start_angle(&s.subpaths[0]);
+    assert!(angle.abs() <= 1.0, "the path leaves its start at {angle}°: {s:?}");
+}
+
 #[test]
 fn simplify_straight_lines_option() {
     let c = dense_circle(50.0, 200);
diff --git a/crates/pdf/src/export.rs b/crates/pdf/src/export.rs
index f4d65398e0..4ba4aa123d 100644
--- a/crates/pdf/src/export.rs
+++ b/crates/pdf/src/export.rs
@@ -60,6 +60,9 @@ pub(crate) struct Exporter<'a> {
     images: HashMap<String, Option<Image>>,
     /// `Some` while opacity mask art is written: whether an image in it was left out.
     image_left_out: Option<bool>,
+    /// While the pieces of a mesh-warped image are written: the size its pixels are resampled for
+    /// ([`Exporter::warp_image_size`]).
+    warp_size: Option<images::SharedSize>,
     /// The brush library, parsed when the first brushed stroke is written.
     brushes: Option<Vec<vectorcraft_brush::Brush>>,
     /// Whether the group being written is a knockout group (what its neutral children inherit).
diff --git a/crates/pdf/src/export/exporter.rs b/crates/pdf/src/export/exporter.rs
index ff94c6759f..22109b3e82 100644
--- a/crates/pdf/src/export/exporter.rs
+++ b/crates/pdf/src/export/exporter.rs
@@ -31,6 +31,7 @@ impl<'a> Exporter<'a> {
             warnings: vec![],
             images: HashMap::new(),
             image_left_out: None,
+            warp_size: None,
             brushes: None,
             knockout: doc.page_knockout,
             lab_spots: vec![],
diff --git a/crates/pdf/src/export/images.rs b/crates/pdf/src/export/images.rs
index c377b9f7e4..d0158d8cd2 100644
--- a/crates/pdf/src/export/images.rs
+++ b/crates/pdf/src/export/images.rs
@@ -1,5 +1,5 @@
 use super::exporter::{UNDECODED, UNWRITABLE_IMAGE, q, writable, xf};
-use super::{Arc, BlendMode, Color, Exporter, Image, NodeKind, Paint, Rect, Size, Surface, cmyk, krilla};
+use super::{Arc, BlendMode, Color, Exporter, Image, Node, NodeKind, Paint, Rect, Size, Surface, cmyk, krilla};
 use krilla::color::device_n::{Colorant, DeviceNSpace, Process};
 use krilla::image::{BitsPerComponent, CustomImage, ImageColorspace};
 
@@ -59,13 +59,17 @@ impl Exporter<'_> {
     /// the Output settings write them. The coverage is resampled as the Compression settings ask
     /// ([`crate::images::coverage_sized`]). `None` when the paint isn't a solid color, the image is
     /// missing or left out, its pixels can't be decoded, or its color channel exceeds
-    /// [`vectorcraft_doc::MAX_RASTER_ALLOC`]; image rejections are cached like [`Self::load_image`].
+    /// [`vectorcraft_doc::MAX_RASTER_ALLOC`]; cached by key and paint (and size when images are
+    /// resampled), image rejections too.
     /// With `interpolate` (and the export's own setting), viewers may smooth it.
     pub(super) fn colorized_image(&mut self, im: &vectorcraft_doc::ImageObject, paint: &Paint, interpolate: bool) -> Option<Image> {
         let Paint::Solid { color, swatch, tint } = paint else { return None };
-        let size = placed_size(im);
+        let size = self.image_size(im);
         let interpolate = interpolate && self.interpolate;
-        let mut cache = format!("{}\u{0}{paint:?}\u{0}{:.3}x{:.3}", im.key, size.0, size.1);
+        let mut cache = format!("{}\u{0}{paint:?}", im.key);
+        if self.downsampled() {
+            cache.push_str(&format!("\u{0}{:.3}x{:.3}", size.0, size.1));
+        }
         if !interpolate && self.interpolate {
             cache.push_str("\u{0}pixelated");
         }
@@ -124,9 +128,8 @@ impl Exporter<'_> {
     fn load_image(&mut self, im: &vectorcraft_doc::ImageObject, size: (f64, f64), interpolate: bool) -> Option<Image> {
         let key = im.key.as_str();
         let c = self.compression;
-        let sized = [c.color.downsample, c.gray.downsample, c.mono.downsample].iter().any(|d| *d != crate::Downsample::None);
         let interpolate = interpolate && self.interpolate;
-        let mut cache = if sized { format!("{key}\u{0}{:.3}x{:.3}", size.0, size.1) } else { key.to_string() };
+        let mut cache = if self.downsampled() { format!("{key}\u{0}{:.3}x{:.3}", size.0, size.1) } else { key.to_string() };
         if !interpolate && self.interpolate {
             cache.push_str("\u{0}pixelated");
         }
@@ -173,9 +176,12 @@ impl Exporter<'_> {
         if m.invert || !plain || (mi.xf, mi.width, mi.height) != (im.xf, im.width, im.height) {
             return None;
         }
-        let size = placed_size(im);
+        let size = self.image_size(im);
         let interpolate = interpolate && self.interpolate;
-        let mut cache = format!("{}\u{0}{}\u{0}{}\u{0}{:.3}x{:.3}", im.key, mi.key, m.clip, size.0, size.1);
+        let mut cache = format!("{}\u{0}{}\u{0}{}", im.key, mi.key, m.clip);
+        if self.downsampled() {
+            cache.push_str(&format!("\u{0}{:.3}x{:.3}", size.0, size.1));
+        }
         if !interpolate && self.interpolate {
             cache.push_str("\u{0}pixelated");
         }
@@ -206,7 +212,7 @@ impl Exporter<'_> {
             }
             return;
         }
-        let Some(img) = img.or_else(|| self.load_image(im, placed_size(im), !pixelated)) else {
+        let Some(img) = img.or_else(|| self.load_image(im, self.image_size(im), !pixelated)) else {
             self.image_left_out = self.image_left_out.map(|_| true);
             return;
         };
@@ -221,6 +227,56 @@ impl Exporter<'_> {
         s.draw_image(img, size);
         s.pop();
     }
+
+    /// Whether the Compression settings resample any kind of image.
+    fn downsampled(&self) -> bool {
+        let c = self.compression;
+        [c.color.downsample, c.gray.downsample, c.mono.downsample].iter().any(|d| *d != crate::Downsample::None)
+    }
+
+    /// The size image `im` is resampled for: [`Self::warp_image_size`]'s while the pieces of a
+    /// mesh-warped image of the same pixels are written, else the size it is placed at.
+    fn image_size(&self, im: &vectorcraft_doc::ImageObject) -> (f64, f64) {
+        match &self.warp_size {
+            Some(w) if (w.key.as_str(), w.width, w.height) == (im.key.as_str(), im.width, im.height) => w.size,
+            _ => placed_size(im),
+        }
+    }
+
+    /// When `children` are the pieces of a mesh-warped image ([`Node::warp_piece_image`]) and the
+    /// Compression settings resample images: the image they show, and the widest and highest any
+    /// piece places it, which every piece's image is resampled for, so that the pieces paint one
+    /// image. `None` for other children, pieces of different images, or a size that isn't finite
+    /// and positive.
+    pub(super) fn warp_image_size(&self, children: &[Arc<Node>]) -> Option<SharedSize> {
+        if !self.downsampled() {
+            return None;
+        }
+        let mut shared: Option<SharedSize> = None;
+        for c in children {
+            let n = c.warp_piece_image()?;
+            let NodeKind::Image(im) = &n.kind else { return None };
+            let im = self.doc.shown_image(n, im);
+            let (w, h) = placed_size(&im);
+            match &mut shared {
+                Some(s) if (s.key.as_str(), s.width, s.height) == (im.key.as_str(), im.width, im.height) => {
+                    s.size = (s.size.0.max(w), s.size.1.max(h));
+                }
+                Some(_) => return None,
+                None => shared = Some(SharedSize { key: im.key.clone(), width: im.width, height: im.height, size: (w, h) }),
+            }
+        }
+        shared.filter(|s| s.size.0.is_finite() && s.size.1.is_finite() && s.size.0 > 0.0 && s.size.1 > 0.0)
+    }
+}
+
+/// The size the pixels of image `key` (`width` × `height` pixels) are resampled for while the
+/// pieces of a mesh-warped image are written ([`Exporter::warp_image_size`]).
+pub(super) struct SharedSize {
+    key: String,
+    width: u32,
+    height: u32,
+    size: (f64, f64),
 }
 
 /// The size image `im` is placed at: its pixel grid's sides through its transform.
@@ -320,13 +376,48 @@ mod tests {
             let image =
                 ImageObject { key: key.into(), width: 1, height: 1, xf: Affine::IDENTITY, link: None, placement: Default::default(), pixels: None };
             assert!(exporter.colorized_image(&image, &paint, true).is_none(), "{key}");
-            let cache = format!("{key}\u{0}{paint:?}\u{0}1.000x1.000");
+            let cache = format!("{key}\u{0}{paint:?}");
             assert!(matches!(exporter.images.get(&cache), Some(None)), "rejection for {key} was not cached");
             assert!(exporter.colorized_image(&image, &paint, true).is_none(), "second call for {key}");
         }
         assert_eq!(exporter.images.len(), 3);
     }
 
+    /// Without downsampling, a colorized image and a CMYK image with a grid mask are made once for
+    /// every size they are placed at.
+    #[test]
+    fn colorized_and_grid_masked_images_are_made_once_for_every_size_without_downsampling() {
+        let gray = |pixels: Vec<u8>| {
+            let mut png = vec![];
+            image::GrayImage::from_raw(2, 2, pixels).unwrap().write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+            ImageBlob::png(png)
+        };
+        let mut doc = Document::new(100.0, 100.0);
+        doc.images.insert("pic".into(), gray(vec![0, 255, 128, 64]));
+        doc.images.insert("alpha".into(), gray(vec![255, 128, 0, 64]));
+        let inks = vectorcraft_doc::cmyk::Inks::new(2, 2, [0u8, 102, 255, 0].repeat(4)).unwrap();
+        doc.images.insert("inks".into(), ImageBlob::cmyk_tiff(&inks).unwrap());
+        let settings = crate::PdfSettings::default();
+        let mut exporter = Exporter::new(&doc, &settings);
+        let paint = Paint::solid(Color::rgb(1.0, 0.0, 0.0));
+        let image = |key: &str, scale: f64| ImageObject {
+            key: key.into(),
+            width: 2,
+            height: 2,
+            xf: Affine::scale(scale),
+            link: None,
+            placement: Default::default(),
+            pixels: None,
+        };
+        for scale in [10.0, 20.0] {
+            assert!(exporter.colorized_image(&image("pic", scale), &paint, true).is_some(), "colorized at {scale}");
+            let art = vectorcraft_doc::Node::new(doc.layers[0].id, vectorcraft_doc::NodeKind::Image(Box::new(image("alpha", scale))));
+            let mask = vectorcraft_doc::OpacityMask::new(art, true);
+            assert!(exporter.masked_image(&image("inks", scale), &mask, true).is_some(), "masked at {scale}");
+        }
+        assert_eq!(exporter.images.len(), 2, "{:?}", exporter.images.keys().collect::<Vec<_>>());
+    }
+
     #[test]
     fn tinted_color_rejects_oversized_and_overflowing_buffers() {
         let max = usize::try_from(vectorcraft_doc::MAX_RASTER_ALLOC).unwrap_or(usize::MAX);
diff --git a/crates/pdf/src/export/nodes.rs b/crates/pdf/src/export/nodes.rs
index bb73980177..8bafe017c6 100644
--- a/crates/pdf/src/export/nodes.rs
+++ b/crates/pdf/src/export/nodes.rs
@@ -100,6 +100,17 @@ impl Exporter<'_> {
         }
     }
 
+    /// [`Self::measured_children`] of a plain group or layer. When they are the pieces of a
+    /// mesh-warped image, every piece, on the page or not, takes part in the one size its pixels
+    /// are resampled for ([`Self::warp_image_size`]).
+    fn group_children(&mut self, s: &mut Surface, children: &[std::sync::Arc<Node>], page: Rect, measured: &[Measured]) {
+        let outer = self.warp_image_size(children).map(|w| self.warp_size.replace(w));
+        self.measured_children(s, children, page, measured);
+        if let Some(outer) = outer {
+            self.warp_size = outer;
+        }
+    }
+
     /// A luminosity mask that is 1 − the knockout shape of `c`, whose box is in `measured`: white,
     /// then black through an alpha mask of `c` (at full object opacity without its own mask, unless
     /// those define its shape).
@@ -268,7 +279,7 @@ impl Exporter<'_> {
         }
         match &n.kind {
             NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => {
-                self.measured_children(s, children, page, measured.map_or(&[], |m| m.members.as_slice()));
+                self.group_children(s, children, page, measured.map_or(&[], |m| m.members.as_slice()));
             }
             NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } => {
                 // The region every output clips to; nothing to clip by hides the clipped art. The
diff --git a/crates/pdf/src/export/text.rs b/crates/pdf/src/export/text.rs
index ea38fc3a1d..4b0b3a047a 100644
--- a/crates/pdf/src/export/text.rs
+++ b/crates/pdf/src/export/text.rs
@@ -38,8 +38,9 @@ impl Exporter<'_> {
         // stroke overprints.
         let text_space = xf(t.xf);
         // Ruby can't be real text in one run (it isn't characters of the base text): the type's
-        // characters go out as outlines where ruby is present, ruby included.
-        let plain = (!self.outline_text && t.ruby.is_empty()).then(|| t.plain_text());
+        // characters go out as outlines where ruby is present, ruby included. Warichu's stacked
+        // lines go out as outlines too.
+        let plain = (!self.outline_text && t.ruby.is_empty() && !t.stacks_warichu()).then(|| t.plain_text());
         let bars = vectorcraft_text::decorations(&layout, vectorcraft_text::FontDb::global(), t);
         for (i, run) in t.runs.iter().enumerate() {
             let mut bp = BezPath::new();
diff --git a/crates/pdf/src/tests/colorize.rs b/crates/pdf/src/tests/colorize.rs
index 60d7a9bd67..207c9fc595 100644
--- a/crates/pdf/src/tests/colorize.rs
+++ b/crates/pdf/src/tests/colorize.rs
@@ -133,6 +133,39 @@ fn colorized_images_are_downsampled() {
     assert!(text.contains("/Width 150") && !text.contains("/Width 600"), "resampled to 150 ppi");
 }
 
+/// The pieces of a colorized image under a mesh warp, placed at different widths, paint one
+/// colorized image and its one soft mask, with downsampling off and on.
+#[test]
+fn a_colorized_warped_image_is_written_once_for_all_its_pieces() {
+    for compression in [serde_json::json!({}), serde_json::json!({"gray": {"downsample": "bicubic", "ppi": 150}})] {
+        let mut d = Document::new(100.0, 100.0);
+        let gray = image::GrayImage::from_fn(600, 600, |x, y| image::Luma([((x + y) % 200) as u8]));
+        let mut png = vec![];
+        gray.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+        d.images.insert("pic".into(), ImageBlob::png(png));
+        let im = ImageObject {
+            key: "pic".into(),
+            width: 600,
+            height: 600,
+            xf: Affine::scale(72.0 / 600.0),
+            link: None,
+            placement: Default::default(),
+            pixels: None,
+        };
+        let mut n = Node::new(d.alloc_id(), NodeKind::Image(Box::new(im.clone())));
+        n.extras_mut().colorize = Some(Box::new(Paint::solid(Color::rgb(0.0, 0.0, 1.0))));
+        // 0.5 to 1.5 times as wide from left to right.
+        let stretch = |p: vectorcraft_geom::Point| vectorcraft_geom::Point::new(p.x * (0.5 + p.x / 144.0), p.y);
+        let warped = vectorcraft_doc::live::mesh_warp_image(&n, &im, &stretch, 4, false, false);
+        d.insert(d.default_layer(), 0, warped).unwrap();
+        let settings: PdfSettings = serde_json::from_value(serde_json::json!({ "compression": compression })).unwrap();
+        let out = export_with_report(&d, &PdfOptions { settings, ..Default::default() }).unwrap().bytes;
+        let found = images(&out);
+        assert_eq!(found.len(), 2, "{compression}: the colorized image and its soft mask, not {found:?}");
+        assert!(found.contains(&("DeviceRGB".into(), vec![], true)), "{compression}: {found:?}");
+    }
+}
+
 /// Printed separations keep a colorized image's pixels on every plate and separate its color:
 /// a spot-colorized image prints on its ink's plate only. An uncolorized image of the same pixels
 /// is separated as before.
diff --git a/crates/pdf/src/tests/compression.rs b/crates/pdf/src/tests/compression.rs
index 9e012e330a..c02f3f5e1c 100644
--- a/crates/pdf/src/tests/compression.rs
+++ b/crates/pdf/src/tests/compression.rs
@@ -5,10 +5,11 @@
 
 use std::io::Cursor;
 
+use craft_pdf::syntax::object::{Name, Object};
 use image::{DynamicImage, ImageFormat};
 use serde_json::{Value, json};
 use vectorcraft_doc::{Document, ImageBlob, ImageObject, Node, NodeKind};
-use vectorcraft_geom::Affine;
+use vectorcraft_geom::{Affine, Point};
 
 use crate::*;
 
@@ -72,6 +73,55 @@ fn images_above_the_threshold_are_resampled_to_the_target_resolution() {
     assert!(text.contains("/Width 100") && text.contains("/DeviceGray"), "grey at 100 ppi");
 }
 
+/// The width and height of each image XObject in `pdf`.
+fn image_sizes(pdf: &[u8]) -> Vec<(u32, u32)> {
+    let file = craft_pdf::syntax::Pdf::new(std::sync::Arc::new(pdf.to_vec())).unwrap();
+    file.objects()
+        .into_iter()
+        .filter_map(|o| match o {
+            Object::Stream(s) if s.dict().get::<Name<'_>>(b"Subtype").is_some_and(|n| n.as_ref() == b"Image") => {
+                Some((s.dict().get::<u32>(b"Width").unwrap_or(0), s.dict().get::<u32>(b"Height").unwrap_or(0)))
+            }
+            _ => None,
+        })
+        .collect()
+}
+
+/// A mesh warp that stretches the image across more toward its right side cuts it into pieces
+/// placed at different widths. With downsampling on, every piece paints one image, resampled for
+/// the widest piece; another placement of the image keeps its own resampling.
+#[test]
+fn a_warped_image_is_written_once_for_all_its_pieces() {
+    let compression = json!({"color": {"downsample": "bicubic", "ppi": 150, "abovePpi": 225}});
+    for masked in [false, true] {
+        let mut d = doc(encoded(colour(), ImageFormat::Png), "image/png");
+        let id = d.layers[0].children().unwrap()[0].id;
+        let n = d.node(id).unwrap().clone();
+        let NodeKind::Image(im) = &n.kind else { panic!("the image") };
+        // 0.5 to 1.5 times as wide from left to right, within the page.
+        let stretch = |p: Point| Point::new(p.x * (0.5 + p.x / 144.0), p.y);
+        *d.node_mut(id).unwrap() = vectorcraft_doc::live::mesh_warp_image(&n, im, &stretch, 4, false, masked);
+        let mut settings: PdfSettings = serde_json::from_value(json!({ "compression": compression })).unwrap();
+        settings.compression.compress_text = false;
+        let bytes = export_with_report(&d, &PdfOptions { settings: settings.clone(), ..Default::default() }).unwrap().bytes;
+        let sizes = image_sizes(&bytes);
+        assert_eq!(sizes.len(), 1, "masked {masked}: one image for 32 pieces, not {sizes:?}");
+        // One inch high (150 pixels at 150 ppi), and wider than one inch at its widest.
+        let (w, h) = sizes[0];
+        assert!(h == 150 && w > 150 && w < 600, "masked {masked}: {w} × {h}");
+        assert!(String::from_utf8_lossy(&bytes).matches(" Do").count() >= 32, "masked {masked}: every piece paints the image");
+
+        // The image placed again, two inches wide and high, is resampled for that placement.
+        let plain = Node::new(d.alloc_id(), NodeKind::Image(Box::new(ImageObject { xf: Affine::scale(144.0 / 600.0), ..(**im).clone() })));
+        let l = d.layers[0].id;
+        d.insert(Some(l), 1, plain).unwrap();
+        let bytes = export_with_report(&d, &PdfOptions { settings, ..Default::default() }).unwrap().bytes;
+        let mut sizes = image_sizes(&bytes);
+        sizes.sort_unstable();
+        assert_eq!(sizes, [(w, h), (300, 300)], "masked {masked}");
+    }
+}
+
 #[test]
 fn jpeg_zip_and_automatic_compression() {
     let png = doc(encoded(colour(), ImageFormat::Png), "image/png");
diff --git a/crates/render/src/tests/fontchange.rs b/crates/render/src/tests/fontchange.rs
index 0e7864b0b9..bedffb6b4b 100644
--- a/crates/render/src/tests/fontchange.rs
+++ b/crates/render/src/tests/fontchange.rs
@@ -210,6 +210,60 @@ fn a_documents_own_composite_font_draws_without_being_registered() {
     assert!(db.composite_font(NAME).is_none(), "given back after each render");
 }
 
+/// A placed document draws its type in its own definition of a composite font that the document
+/// placing it defines differently.
+#[test]
+fn a_placed_document_draws_its_own_definition_of_a_name_the_page_defines() {
+    use vectorcraft_doc::{CompositeFont, CompositePart, CompositeParts, ImageBlob, LinkInfo, PlacedDocument};
+    let _adding = adding_fonts();
+    const NAME: &str = "CF Placed Twice";
+    let definition = |roman: &str| {
+        let mut parts = CompositeParts::all(CompositePart::new("Source Sans 3", "Regular"));
+        parts.roman = CompositePart::new(roman, "Regular");
+        CompositeFont { name: NAME.into(), parts }
+    };
+    let typed = |family: &str| {
+        let mut d = Document::new(300.0, 150.0);
+        let style = CharStyle { size: 60.0, font_family: family.into(), ..Default::default() };
+        let n = Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(10.0, 100.0), "Hamburg", style))));
+        let l = d.layers[0].id;
+        let id = d.insert(Some(l), 0, n).unwrap();
+        (d, id)
+    };
+    let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
+    // A page placing `d` (drawn exactly), defining `fonts`.
+    let page = |d: &Document, id: NodeId, key: &str, fonts: Vec<CompositeFont>| {
+        let blob = ImageBlob::new("application/json", key.as_bytes().to_vec());
+        let p = PlacedDocument {
+            link: LinkInfo::new("/art/type.vectorcraft"),
+            key: key.into(),
+            bounding: false,
+            page_box: Default::default(),
+            width: 300.0,
+            height: 150.0,
+            xf: Affine::IDENTITY,
+            placement: Default::default(),
+        };
+        let art = d.node(id).unwrap().clone();
+        vectorcraft_doc::placed_document::prime(&p, blob.bytes.clone(), (d.clone(), art, Rect::new(0.0, 0.0, 300.0, 150.0)));
+        let mut page = Document::new(300.0, 150.0);
+        page.composite_fonts.extend(fonts);
+        page.images.insert(key.into(), blob);
+        let n = Node::new(page.alloc_id(), NodeKind::PlacedDocument(Box::new(p)));
+        let l = page.layers[0].id;
+        page.insert(Some(l), 0, n).unwrap();
+        Renderer::new().render(&page, 300, 150, Affine::IDENTITY, &opts).pixels
+    };
+    let (mut placed, id) = typed(NAME);
+    placed.composite_fonts.push(definition("JetBrains Mono"));
+    let (plain, plain_id) = typed("JetBrains Mono");
+    let (inter, inter_id) = typed("Inter");
+    let own = page(&placed, id, "fontchange-placed-twice", vec![definition("Inter")]);
+    assert!(own == page(&plain, plain_id, "fontchange-placed-twice-plain", vec![]), "drawn in the placed document's definition");
+    assert!(own != page(&inter, inter_id, "fontchange-placed-twice-inter", vec![]), "not in the page's");
+    assert!(vectorcraft_text::FontDb::global().composite_font(NAME).is_none());
+}
+
 /// Type at 80% opacity, in Multiply and with a drop shadow redraws in a font that becomes
 /// available: the glyph geometry kept for it is laid out again.
 #[test]
diff --git a/crates/svg/src/export/text.rs b/crates/svg/src/export/text.rs
index 27c317b607..2b9139f19b 100644
--- a/crates/svg/src/export/text.rs
+++ b/crates/svg/src/export/text.rs
@@ -82,7 +82,8 @@ impl Writer<'_> {
         let heights = vectorcraft_text::FontDb::global().font_heights_resolved(&resolved);
         let t = &*heights;
         let inline = t.runs.iter().any(|r| r.inline.is_some());
-        // Ruby is written as outlines with its base text: a reader's <text> can't place it. So are
+        // Ruby is written as outlines with its base text: a reader's <text> can't place it. So is
+        // type with warichu, whose stacked lines a reader's <text> can't place either. So are
         // small capitals, superscript and subscript and tab leaders, which SVG text doesn't draw (#3869),
         // and a glyph chosen for a character, which a reader's <text> draws with the default glyph. So
         // is type in one of the document's composite fonts, which a reader can't find by its name.
@@ -92,8 +93,12 @@ impl Writer<'_> {
                 || r.style.glyph_alternate.is_some()
                 || vectorcraft_doc::CompositeFont::named(&doc.composite_fonts, &r.style.font_family).is_some()
         }) || std::iter::once(&t.para).chain(&t.paras).any(|p| p.tabs.iter().any(|tab| !tab.leader.is_empty()));
-        let outlined =
-            self.opts.outline_text || t.vertical || !t.ruby.is_empty() || (inline && matches!(t.kind, TextKind::OnPath { .. })) || unwritable;
+        let outlined = self.opts.outline_text
+            || t.vertical
+            || !t.ruby.is_empty()
+            || t.stacks_warichu()
+            || (inline && matches!(t.kind, TextKind::OnPath { .. }))
+            || unwritable;
         let chars = |w: &mut Self, n: &Node| if outlined { w.text_outlines(n, t) } else { w.text(n, t) };
         let painted = n.appearance.items.iter().any(|i| i.visible() && !i.paint().is_none());
         // Live type with an inside or outside character stroke writes that stroke apart from the
diff --git a/crates/svg/src/import.rs b/crates/svg/src/import.rs
index 897f3fb5cf..087512bf90 100644
--- a/crates/svg/src/import.rs
+++ b/crates/svg/src/import.rs
@@ -20,7 +20,7 @@ use text::TextSlots;
 
 pub use depth::MAX_ELEMENT_DEPTH;
 pub(crate) use depth::xml_too_deep;
-pub use files::MAX_NESTED_SVG_IMAGES;
+pub use files::{MAX_NESTED_SVG_IMAGES, MAX_NESTED_SVG_READS, MAX_NESTED_SVG_TEXT};
 pub(crate) use fx::BLEND;
 
 /// Most objects an imported SVG may expand to: a guard against `<use>` and nested-image
diff --git a/crates/svg/src/import/files.rs b/crates/svg/src/import/files.rs
index 0472bc83e9..bab4246270 100644
--- a/crates/svg/src/import/files.rs
+++ b/crates/svg/src/import/files.rs
@@ -23,6 +23,13 @@ use crate::{ImportOptions, MAX_ELEMENT_DEPTH, MAX_SVGZ, SvgError};
 /// Most nested SVG images an imported SVG may decode (#3564).
 pub const MAX_NESTED_SVG_IMAGES: usize = 256;
 
+/// Most nested SVG images an imported SVG may read, decoded or not: each one read is checked and
+/// parsed, and an image that fails is read again wherever it is shown.
+pub const MAX_NESTED_SVG_READS: usize = 1024;
+
+/// Most bytes of nested SVG image text an imported SVG may read, decoded or not, all reads together.
+pub const MAX_NESTED_SVG_TEXT: u64 = 512 << 20;
+
 /// The files an SVG's images link to.
 #[derive(Default)]
 pub(in crate::import) struct Files {
@@ -48,6 +55,12 @@ pub(in crate::import) struct Files {
     svg_images: AtomicUsize,
     /// SVG images were left out for exceeding [`MAX_NESTED_SVG_IMAGES`].
     too_many_svg_images: AtomicBool,
+    /// How many nested SVG images were read so far, decoded or not.
+    svg_reads: AtomicUsize,
+    /// The bytes of text those reads took.
+    svg_text: AtomicU64,
+    /// SVG images were left out for exceeding [`MAX_NESTED_SVG_READS`] or [`MAX_NESTED_SVG_TEXT`].
+    too_much_svg_read: AtomicBool,
     /// The CMYK TIFF stored in place of a turned CMYK image, by the address of the PNG usvg got
     /// (kept here too, so the address stays its own).
     cmyk: Mutex<HashMap<usize, (Bytes, Bytes)>>,
@@ -253,6 +266,12 @@ impl Files {
         if self.too_many_svg_images.load(Ordering::Relaxed) {
             notes.push(format!("SVG images were left out: more than {MAX_NESTED_SVG_IMAGES} nested SVG images"));
         }
+        if self.too_much_svg_read.load(Ordering::Relaxed) {
+            notes.push(format!(
+                "SVG images were left out: nested SVG images, valid or not, are read at most {MAX_NESTED_SVG_READS} times and {} MB of text",
+                MAX_NESTED_SVG_TEXT >> 20
+            ));
+        }
         notes
     }
 
@@ -308,11 +327,33 @@ impl Files {
 
     /// The SVG image `text` as usvg reads it with `opts`. `None`, the image left out as one usvg
     /// can't read, when it isn't SVG or when its elements nest deeper than the SVGs around it
-    /// leave: usvg reads it while it reads them, on the same stack.
+    /// leave: usvg reads it while it reads them, on the same stack. Only a decoded image, with the
+    /// images decoded inside it, counts toward [`MAX_NESTED_SVG_IMAGES`]; every image read counts
+    /// toward [`MAX_NESTED_SVG_READS`] and [`MAX_NESTED_SVG_TEXT`].
     fn svg(&self, text: &str, opts: &usvg::Options) -> Option<ImageKind> {
-        if self.svg_images.fetch_add(1, Ordering::Relaxed) >= MAX_NESTED_SVG_IMAGES {
+        let decoded = self.svg_images.load(Ordering::Relaxed);
+        if decoded >= MAX_NESTED_SVG_IMAGES {
             return leave_out(&self.too_many_svg_images, true);
         }
+        let reads = self.svg_reads.load(Ordering::Relaxed);
+        let read = self.svg_text.load(Ordering::Relaxed).saturating_add(text.len() as u64);
+        if reads >= MAX_NESTED_SVG_READS || read > MAX_NESTED_SVG_TEXT {
+            return leave_out(&self.too_much_svg_read, true);
+        }
+        self.svg_reads.store(reads + 1, Ordering::Relaxed);
+        self.svg_text.store(read, Ordering::Relaxed);
+        // The image's place is taken while usvg reads it, so the images inside it get what is left.
+        // usvg reads them all on this thread, so no other read comes between these steps.
+        self.svg_images.store(decoded + 1, Ordering::Relaxed);
+        let tree = self.svg_tree(text, opts);
+        if tree.is_none() {
+            self.svg_images.store(decoded, Ordering::Relaxed);
+        }
+        tree
+    }
+
+    /// [`Files::svg`]'s image once it is counted.
+    fn svg_tree(&self, text: &str, opts: &usvg::Options) -> Option<ImageKind> {
         // Measured as the SVG holding it is (`import`): the text before the XML reader.
         let used = self.depth.load(Ordering::Relaxed);
         let left = MAX_ELEMENT_DEPTH.saturating_sub(used);
@@ -323,11 +364,12 @@ impl Files {
         let Some(height) = depth::height(&xml, left) else { return leave_out(&self.too_deep, true) };
         // usvg's parser would overflow on it, as on the SVG holding it (`import`).
         super::convolve_matrices_ok(&xml).ok()?;
-        self.note_text(text);
         self.depth.store(used + height, Ordering::Relaxed);
         let tree = usvg::Tree::from_data_nested(text.as_bytes(), opts);
         self.depth.store(used, Ordering::Relaxed);
-        tree.ok().map(ImageKind::SVG)
+        let tree = tree.ok()?;
+        self.note_text(text);
+        Some(ImageKind::SVG(tree))
     }
 }
 
@@ -587,4 +629,34 @@ mod tests {
         assert!(!read("2147483647"));
         assert!(read("1"));
     }
+
+    /// The nested SVG images read, decoded or not, take at most [`MAX_NESTED_SVG_TEXT`] bytes of
+    /// text together: an image whose text goes past it is left out and noted. A broken image's
+    /// text counts too, and its decoded place is given back.
+    #[test]
+    fn svg_images_share_the_text_cap() {
+        let svg = r#"<svg xmlns="http://www.w3.org/2000/svg" width="2" height="2"><rect width="1" height="1"/></svg>"#;
+        let broken = &svg[..20];
+        let files = Files::default();
+        let resolver = files.resolver(1);
+        let opts = usvg::Options::default();
+        let read =
+            |text: &str| matches!((resolver.resolve_data)("image/svg+xml", Arc::new(text.as_bytes().to_vec()), &opts), Some(ImageKind::SVG(_)));
+        assert!(!read(broken));
+        assert_eq!(files.svg_text.load(Ordering::Relaxed), broken.len() as u64);
+        assert_eq!((files.svg_reads.load(Ordering::Relaxed), files.svg_images.load(Ordering::Relaxed)), (1, 0));
+        files.svg_text.store(MAX_NESTED_SVG_TEXT - svg.len() as u64, Ordering::Relaxed);
+        assert!(read(svg));
+        assert_eq!((files.svg_reads.load(Ordering::Relaxed), files.svg_images.load(Ordering::Relaxed)), (2, 1));
+        assert!(files.left_out().is_empty());
+        assert!(!read(svg) && !read(broken));
+        assert_eq!(files.svg_text.load(Ordering::Relaxed), MAX_NESTED_SVG_TEXT, "past the cap, nothing is read");
+        assert_eq!(
+            files.left_out(),
+            [format!(
+                "SVG images were left out: nested SVG images, valid or not, are read at most {MAX_NESTED_SVG_READS} times and {} MB of text",
+                MAX_NESTED_SVG_TEXT >> 20
+            )]
+        );
+    }
 }
diff --git a/crates/svg/src/lib.rs b/crates/svg/src/lib.rs
index 7e5d220fbb..0c698eebc7 100644
--- a/crates/svg/src/lib.rs
+++ b/crates/svg/src/lib.rs
@@ -576,7 +576,7 @@ pub fn svg_filters(svg: &str, room: usize, taken: impl Fn(&str) -> bool) -> Resu
 }
 
 pub use glyph::glyph_art;
-pub use import::{MAX_ELEMENT_DEPTH, MAX_FOREIGN, MAX_FOREIGN_VALUE, MAX_NESTED_SVG_IMAGES, MAX_NODES};
+pub use import::{MAX_ELEMENT_DEPTH, MAX_FOREIGN, MAX_FOREIGN_VALUE, MAX_NESTED_SVG_IMAGES, MAX_NESTED_SVG_READS, MAX_NESTED_SVG_TEXT, MAX_NODES};
 
 /// Import an SVG document reading the files it links to as `opts` says, also returning warnings.
 pub fn import_with(svg: &str, opts: &ImportOptions) -> Result<(Document, Vec<String>), SvgError> {
diff --git a/crates/svg/tests/it/import_details.rs b/crates/svg/tests/it/import_details.rs
index d6983a1ce2..b043e4d985 100644
--- a/crates/svg/tests/it/import_details.rs
+++ b/crates/svg/tests/it/import_details.rs
@@ -6,7 +6,7 @@ use std::path::{Path, PathBuf};
 
 use vectorcraft_doc::{Document, ImageObject, LinkInfo, Node, NodeKind};
 use vectorcraft_geom::Rect;
-use vectorcraft_svg::{ImportOptions, MAX_NESTED_SVG_IMAGES, SvgError, import_with, import_with_report, import_within};
+use vectorcraft_svg::{ImportOptions, MAX_NESTED_SVG_IMAGES, MAX_NESTED_SVG_READS, SvgError, import_with, import_with_report, import_within};
 use vectorcraft_testkit::raster::{Image, assert_similar, render_artboard};
 
 fn svg(body: &str) -> String {
@@ -683,6 +683,87 @@ fn nested_svg_images_past_count_cap_are_left_out() {
     assert!(warnings.iter().any(|w| w.contains(&format!("more than {MAX_NESTED_SVG_IMAGES} nested SVG images"))));
 }
 
+/// Nested SVG images that can't be read: text that isn't XML, and an SVG without a size.
+const BROKEN_SVG_IMAGES: [&str; 2] =
+    [r#"<svg xmlns="http://www.w3.org/2000/svg" width="10"#, r#"<svg xmlns="http://www.w3.org/2000/svg" width="0" height="0"/>"#];
+const SMALL_SVG_IMAGE: &str = r#"<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"><rect width="5" height="5"/></svg>"#;
+
+/// `broken` images showing the broken SVG images in turn from data URLs, then `good` images
+/// showing a rectangle.
+fn broken_then_good(broken: usize, good: usize) -> String {
+    let broken: String = (0..broken).map(|i| image_of("image/svg+xml", BROKEN_SVG_IMAGES[i % 2])).collect();
+    format!(r#"<svg {SVG_NS} width="500" height="500">{broken}{}</svg>"#, image_of("image/svg+xml", SMALL_SVG_IMAGE).repeat(good))
+}
+
+/// Only nested SVG images that decode count toward `MAX_NESTED_SVG_IMAGES`: an image after that
+/// many broken ones, from data URLs or a linked file shown again and again, is imported, and the
+/// images past that many decoded ones are still left out.
+#[test]
+fn broken_nested_svg_images_do_not_use_up_the_image_allowance() {
+    let allowance = |w: &[String]| w.iter().any(|w| w.contains(&format!("more than {MAX_NESTED_SVG_IMAGES} nested SVG images")));
+    let (d, w) = import_with(&broken_then_good(MAX_NESTED_SVG_IMAGES + 10, 1), &ImportOptions::default()).unwrap();
+    assert_eq!(rects(&d), 1, "{w:?}");
+    assert!(!w.iter().any(|w| w.contains("left out")), "{w:?}");
+    let (d, w) = import_with(&broken_then_good(10, MAX_NESTED_SVG_IMAGES + 1), &ImportOptions::default()).unwrap();
+    assert_eq!(rects(&d), MAX_NESTED_SVG_IMAGES, "{w:?}");
+    assert!(allowance(&w), "{w:?}");
+
+    let dir = folder("brokensvgimages");
+    std::fs::write(dir.join("img").join("broken.svg"), BROKEN_SVG_IMAGES[0]).unwrap();
+    std::fs::write(dir.join("img").join("good.svg"), SMALL_SVG_IMAGE).unwrap();
+    let reads = std::sync::atomic::AtomicUsize::new(0);
+    let counted = |path: &str| {
+        reads.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        read(path)
+    };
+    let body = format!(
+        r#"{}<image href="img/good.svg" width="10" height="10"/>"#,
+        r#"<image href="img/broken.svg" width="10" height="10"/>"#.repeat(MAX_NESTED_SVG_IMAGES + 10)
+    );
+    let folder = dir.to_string_lossy();
+    let (d, w) = import_with(&svg(&body), &ImportOptions { folder: Some(&folder), read: Some(&counted) }).unwrap();
+    assert_eq!(rects(&d), 1, "{w:?}");
+    assert!(!w.iter().any(|w| w.contains("left out")), "{w:?}");
+    assert_eq!(reads.into_inner(), 2, "each file is read once");
+}
+
+/// Every nested SVG image read, decoded or not, counts toward `MAX_NESTED_SVG_READS`: past it,
+/// images are left out with a warning, also when `<use>` shows one broken linked file many times.
+#[test]
+fn nested_svg_images_are_read_at_most_max_nested_svg_reads_times() {
+    let past = |w: &[String]| w.iter().any(|w| w.contains(&format!("read at most {MAX_NESTED_SVG_READS} times")));
+    let (d, w) = import_with(&broken_then_good(MAX_NESTED_SVG_READS - 1, 1), &ImportOptions::default()).unwrap();
+    assert_eq!(rects(&d), 1, "{w:?}");
+    assert!(!past(&w), "{w:?}");
+    let (d, w) = import_with(&broken_then_good(MAX_NESTED_SVG_READS, 1), &ImportOptions::default()).unwrap();
+    assert_eq!(rects(&d), 0, "{w:?}");
+    assert!(past(&w), "{w:?}");
+    assert!(!w.iter().any(|w| w.contains(&format!("more than {MAX_NESTED_SVG_IMAGES} nested SVG images"))), "{w:?}");
+
+    let dir = folder("brokensvguses");
+    std::fs::write(dir.join("img").join("broken.svg"), BROKEN_SVG_IMAGES[0]).unwrap();
+    std::fs::write(dir.join("img").join("good.svg"), SMALL_SVG_IMAGE).unwrap();
+    let uses = r##"<use href="#broken"/>"##.repeat(2 * MAX_NESTED_SVG_READS);
+    let body = format!(
+        r#"<defs><g id="broken"><image href="img/broken.svg" width="10" height="10"/></g></defs>{uses}<image href="img/good.svg" width="10" height="10"/>"#
+    );
+    let (d, w) = open_in(&dir, &body);
+    assert_eq!(rects(&d), 0, "{w:?}");
+    assert!(past(&w), "{w:?}");
+}
+
+/// A nested SVG image that can't be read and is left out gives no warning about its text.
+#[test]
+fn broken_nested_svg_images_do_not_warn_about_their_text() {
+    let text = |svg: &str| {
+        let file = format!(r#"<svg {SVG_NS} width="50" height="50">{}</svg>"#, image_of("image/svg+xml", svg));
+        let (_, w) = import_with(&file, &ImportOptions::default()).unwrap();
+        w.iter().any(|w| w.contains("text inside an SVG image"))
+    };
+    assert!(!text(r#"<svg xmlns="http://www.w3.org/2000/svg" width="0" height="0"><text>Hi</text></svg>"#));
+    assert!(text(r#"<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"><text>Hi</text></svg>"#));
+}
+
 /// #3566: entity references in element content count toward the expansion limit, as in
 /// attributes. A 10 KB entity, a second entity that refers to it 250 times, and eight references
 /// to the second inside `<desc>` would expand to about 20 MB from a file of a few KB: the import
diff --git a/crates/text/src/fontdb.rs b/crates/text/src/fontdb.rs
index ace69a4148..f315f2bb69 100644
--- a/crates/text/src/fontdb.rs
+++ b/crates/text/src/fontdb.rs
@@ -116,10 +116,9 @@ pub struct FontDb {
     /// Faces instanced at the axis settings of type's Variable Font sliders ([`FontDb::instance`]).
     instances: Mutex<Instances>,
     /// Composite fonts (Type › Composite Fonts…) by lowercased name ([`FontDb::set_composite_font`]):
-    /// type naming one as its family is set in its parts' fonts.
+    /// type naming one as its family is set in its parts' fonts. A thread's guards can lend others
+    /// in their place ([`FontDb::lend_composite_fonts`]).
     composites: RwLock<HashMap<String, Arc<vectorcraft_doc::CompositeFont>>>,
-    /// The composite fonts [`FontDb::lend_composite_fonts`] put in, by lowercased name.
-    composite_loans: Mutex<HashMap<String, composite::CompositeLoan>>,
 }
 
 /// Where a database's system font scan looks: folders (read with their subfolders) and font files.
diff --git a/crates/text/src/fontdb/composite.rs b/crates/text/src/fontdb/composite.rs
index 0e1d9afa86..16e98038fa 100644
--- a/crates/text/src/fontdb/composite.rs
+++ b/crates/text/src/fontdb/composite.rs
@@ -2,6 +2,12 @@
 //! font menus and resolves to its base (Kanji) font, and layout sets each character of type in one
 //! in the font of the character's class ([`FontDb::composite_split`]).
 
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::hash::{DefaultHasher, Hash, Hasher};
+use std::marker::PhantomData;
+use std::sync::atomic::{AtomicU64, Ordering};
+
 use unicode_segmentation::UnicodeSegmentation;
 use vectorcraft_doc::{CharClass, CompositeFont, TextObject, TextRun};
 
@@ -11,6 +17,42 @@ use super::{Arc, FontDb, FontFace, FontMatch};
 /// A face [`FontDb::resolve`] found and how it matched.
 type Resolved = Option<(Arc<FontFace>, FontMatch)>;
 
+thread_local! {
+    /// The composite fonts the guards of this thread lend ([`FontDb::lend_composite_fonts`]), the
+    /// latest loan last.
+    static LENT: RefCell<Vec<Loan>> = const { RefCell::new(Vec::new()) };
+}
+
+/// The number of the next loan.
+static NEXT_LOAN: AtomicU64 = AtomicU64::new(1);
+
+/// The composite fonts one guard lends, on the thread that made it.
+struct Loan {
+    /// The lending database's [`FontDb::id`].
+    db: u64,
+    /// Tells this loan from the others.
+    number: u64,
+    /// The fonts, by lowercased name.
+    fonts: HashMap<String, Arc<CompositeFont>>,
+    /// The database's generation when they were lent, when each was then the font the database
+    /// holds by its name.
+    same_at: Option<u64>,
+    /// A number for the definitions lent: loans of the same definitions have the same one.
+    print: u64,
+}
+
+/// Feed composite font `f`'s name and parts to `h`.
+fn hash_font(f: &CompositeFont, h: &mut DefaultHasher) {
+    f.name.hash(h);
+    let p = &f.parts;
+    for part in [&p.kanji, &p.kana, &p.punctuation, &p.symbols, &p.roman, &p.numerals] {
+        (&part.font, &part.style, part.scale_at_center).hash(h);
+        for v in [part.size, part.baseline, part.h_scale, part.v_scale] {
+            v.to_bits().hash(h);
+        }
+    }
+}
+
 /// How a composite font draws some text ([`FontDb::composite_coverage`]).
 #[derive(Clone, Debug)]
 pub struct CompositeCoverage {
@@ -25,19 +67,13 @@ pub struct CompositeCoverage {
 impl FontDb {
     /// Make `font` available by its name, in place of a composite font of that name (any case).
     /// The font menus and anything else that lists fonts change only when the definition does.
-    /// Whether it did.
+    /// Whether it did. A font of that name a guard lends ([`FontDb::lend_composite_fonts`]) stays
+    /// in use on the guard's thread.
     pub fn set_composite_font(&self, font: &CompositeFont) -> bool {
         let key = font.name.to_lowercase();
         {
             let mut map = self.composites.write().unwrap_or_else(|e| e.into_inner());
             if map.get(&key).is_some_and(|f| **f == *font) {
-                // The same definition a guard lends: it stays when the guard drops.
-                let mut loans = self.composite_loans.lock().unwrap_or_else(|e| e.into_inner());
-                if let Some(loan) = loans.get_mut(&key)
-                    && map.get(&key).is_some_and(|have| Arc::ptr_eq(have, &loan.font))
-                {
-                    loan.adopted = true;
-                }
                 return false;
             }
             map.insert(key, Arc::new(font.clone()));
@@ -55,8 +91,16 @@ impl FontDb {
         removed
     }
 
-    /// The composite font named `name` (any case).
+    /// The composite font named `name` (any case): the one the latest guard of this thread that
+    /// lends that name lends ([`FontDb::lend_composite_fonts`]), else the one the database holds.
     pub fn composite_font(&self, name: &str) -> Option<Arc<CompositeFont>> {
+        if self.lends() {
+            let key = name.to_lowercase();
+            if let Some(f) = self.lent_font(&key) {
+                return Some(f);
+            }
+            return self.composites.read().unwrap_or_else(|e| e.into_inner()).get(&key).cloned();
+        }
         let map = self.composites.read().unwrap_or_else(|e| e.into_inner());
         if map.is_empty() {
             return None;
@@ -64,6 +108,39 @@ impl FontDb {
         map.get(&name.to_lowercase()).cloned()
     }
 
+    /// Whether a guard of this thread lends composite fonts of this database.
+    fn lends(&self) -> bool {
+        LENT.try_with(|l| l.borrow().iter().any(|loan| loan.db == self.id)).unwrap_or(false)
+    }
+
+    /// The composite font named `key` (lowercased) that the latest guard of this thread lending that
+    /// name lends.
+    fn lent_font(&self, key: &str) -> Option<Arc<CompositeFont>> {
+        LENT.try_with(|l| l.borrow().iter().rev().filter(|loan| loan.db == self.id).find_map(|loan| loan.fonts.get(key).cloned())).ok().flatten()
+    }
+
+    /// [`FontDb::generation`] on this thread, from the database's own generation `g`: `g` while each
+    /// font the guards of this thread lend is the one the database held by its name when it was lent
+    /// and the database has not changed since, else a number made from `g` and the definitions
+    /// lent, so what was laid out in one document's definitions is not taken for another's.
+    pub(super) fn lent_generation(&self, g: u64) -> u64 {
+        LENT.try_with(|l| {
+            let l = l.borrow();
+            let loans = l.iter().filter(|loan| loan.db == self.id);
+            if loans.clone().all(|loan| loan.same_at == Some(g)) {
+                return g;
+            }
+            let mut h = DefaultHasher::new();
+            g.hash(&mut h);
+            for loan in loans {
+                loan.print.hash(&mut h);
+            }
+            // The database's generations count up from 0 and never reach the top bit.
+            h.finish() | 1 << 63
+        })
+        .unwrap_or(g)
+    }
+
     /// The face composite font `name` sets character `c` in (its class's part's), and whether
     /// that part's font is missing. `None` when `name` is no composite font.
     pub fn composite_face(&self, name: &str, c: char) -> Option<(bool, u32)> {
@@ -168,48 +245,48 @@ impl FontDb {
         }
     }
 
-    /// Make each of the composite fonts `fonts` available while the returned guard lives, in place
-    /// of a composite font of the same name that the database holds. An app's session registers
-    /// the composite fonts of its front document; with the guard, a document exported without a
-    /// session, or one that is not in front, draws its type in its own. Dropping the guard puts
-    /// back the font each one replaced, or forgets it, unless another guard still lends the same
-    /// definition or a font of that name has been set since. While one guard lends a font, another
-    /// guard's different definition of that name is not lent.
+    /// Make each of the composite fonts `fonts` (a document's) available on this thread while the
+    /// returned guard lives, in place of a composite font of the same name that the database holds
+    /// or that an earlier guard of this thread lends. An app's session registers the composite fonts
+    /// of its front document; with the guard, a document exported without a session, one that is not
+    /// in front, or one placed in another document draws its type in its own, also while another
+    /// thread draws another document that defines the same name differently, or the session
+    /// registers another document's. Of fonts that share a name (in any case), the first is lent.
+    /// Other threads, and the fonts the database holds and lists, are left as they are. The guard
+    /// stays on its thread and ends its loan when it drops, also when the thread unwinds.
     pub fn lend_composite_fonts(&self, fonts: &[CompositeFont]) -> LentCompositeFonts<'_> {
-        let mut lent = Vec::new();
-        let mut changed = false;
         // A font a document can't use (its name an installed family's, or a value out of range)
         // is not lent: an app leaves it out when it opens the document.
         let usable: Vec<&CompositeFont> = fonts.iter().filter(|f| f.check().is_ok() && !self.has_installed_family(&f.name)).collect();
-        if !usable.is_empty() {
-            let mut map = self.composites.write().unwrap_or_else(|e| e.into_inner());
-            let mut loans = self.composite_loans.lock().unwrap_or_else(|e| e.into_inner());
+        if usable.is_empty() {
+            return LentCompositeFonts { number: None, thread: PhantomData };
+        }
+        let mut lent: HashMap<String, Arc<CompositeFont>> = HashMap::with_capacity(usable.len());
+        let mut h = DefaultHasher::new();
+        let mut same = true;
+        let generation = {
+            let map = self.composites.read().unwrap_or_else(|e| e.into_inner());
             for f in usable {
                 let key = f.name.to_lowercase();
-                // A loan still in force: lend the same definition again, and leave another as it is.
-                if let Some(loan) = loans.get_mut(&key)
-                    && map.get(&key).is_some_and(|have| Arc::ptr_eq(have, &loan.font))
-                {
-                    if *loan.font == *f {
-                        loan.guards += 1;
-                        lent.push((key, loan.font.clone()));
+                if lent.contains_key(&key) {
+                    continue;
+                }
+                hash_font(f, &mut h);
+                let font = match map.get(&key) {
+                    Some(have) if **have == *f => have.clone(),
+                    _ => {
+                        same = false;
+                        Arc::new(f.clone())
                     }
-                    continue;
-                }
-                if map.get(&key).is_some_and(|have| **have == *f) {
-                    continue;
-                }
-                let font = Arc::new((*f).clone());
-                let previous = map.insert(key.clone(), font.clone());
-                loans.insert(key.clone(), CompositeLoan { font: font.clone(), previous, guards: 1, adopted: false });
-                lent.push((key, font));
-                changed = true;
+                };
+                lent.insert(key, font);
             }
-        }
-        if changed {
-            self.changed();
-        }
-        LentCompositeFonts { db: self, lent }
+            self.generation.load(Ordering::Relaxed)
+        };
+        let number = NEXT_LOAN.fetch_add(1, Ordering::Relaxed);
+        let loan = Loan { db: self.id, number, fonts: lent, same_at: same.then_some(generation), print: h.finish() };
+        let pushed = LENT.try_with(|l| l.borrow_mut().push(loan)).is_ok();
+        LentCompositeFonts { number: pushed.then_some(number), thread: PhantomData }
     }
 
     /// The family and style composite font `f` sets characters of `class` in: its part's, or the
@@ -219,7 +296,7 @@ impl FontDb {
         if self.composite_font(&p.font).is_some() { (FALLBACK_FAMILY.to_string(), "Regular".to_string()) } else { (p.font.clone(), p.style.clone()) }
     }
 
-    /// The names of the composite fonts, sorted.
+    /// The names of the composite fonts the database holds (not those guards lend), sorted.
     pub fn composite_font_names(&self) -> Vec<String> {
         let mut v: Vec<String> = self.composites.read().unwrap_or_else(|e| e.into_inner()).values().map(|f| f.name.clone()).collect();
         v.sort_by_key(|n| n.to_lowercase());
@@ -241,7 +318,7 @@ impl FontDb {
     /// its first character. Also the index of the run of `t` each run came from. `None` when no run
     /// is set in a composite font.
     pub fn composite_split(&self, t: &TextObject) -> Option<(TextObject, Vec<usize>)> {
-        if self.composites.read().unwrap_or_else(|e| e.into_inner()).is_empty() {
+        if !self.lends() && self.composites.read().unwrap_or_else(|e| e.into_inner()).is_empty() {
             return None;
         }
         let fonts: Vec<Option<Arc<CompositeFont>>> =
@@ -299,59 +376,24 @@ impl FontDb {
     }
 }
 
-/// A composite font [`FontDb::lend_composite_fonts`] put in the database.
-pub(super) struct CompositeLoan {
-    /// The font lent.
-    font: Arc<CompositeFont>,
-    /// The font of that name it replaced, put back when the last guard lending it drops.
-    previous: Option<Arc<CompositeFont>>,
-    /// How many guards lend it.
-    guards: usize,
-    /// Whether [`FontDb::set_composite_font`] set the same definition while it was lent: the last
-    /// guard to drop then leaves it in place.
-    adopted: bool,
-}
-
-/// The composite fonts [`FontDb::lend_composite_fonts`] made available, given back when it drops.
+/// The composite fonts [`FontDb::lend_composite_fonts`] made available on its thread, until it
+/// drops. It is neither `Send` nor `Sync`: the loan belongs to the thread that made it.
 #[must_use = "the fonts are given back when the guard drops"]
 pub struct LentCompositeFonts<'a> {
-    db: &'a FontDb,
-    /// The lowercased names this guard lends, each with the font lent.
-    lent: Vec<(String, Arc<CompositeFont>)>,
+    /// The loan's number, when it lends any font.
+    number: Option<u64>,
+    thread: PhantomData<(&'a FontDb, *const ())>,
 }
 
 impl Drop for LentCompositeFonts<'_> {
     fn drop(&mut self) {
-        if self.lent.is_empty() {
-            return;
-        }
-        let mut changed = false;
-        {
-            let mut map = self.db.composites.write().unwrap_or_else(|e| e.into_inner());
-            let mut loans = self.db.composite_loans.lock().unwrap_or_else(|e| e.into_inner());
-            for (key, font) in &self.lent {
-                // A later loan of that name is another guard's.
-                let Some(loan) = loans.get_mut(key).filter(|l| Arc::ptr_eq(&l.font, font)) else { continue };
-                loan.guards -= 1;
-                if loan.guards > 0 {
-                    continue;
-                }
-                let previous = loan.previous.take();
-                let adopted = loan.adopted;
-                loans.remove(key);
-                // Given back unless a font of that name has been set (the same definition included)
-                // or removed since.
-                if !adopted && map.get(key).is_some_and(|have| Arc::ptr_eq(have, font)) {
-                    match previous {
-                        Some(p) => map.insert(key.clone(), p),
-                        None => map.remove(key),
-                    };
-                    changed = true;
-                }
+        let Some(number) = self.number else { return };
+        // Fails only while the thread's own storage is being destroyed, which drops the loans.
+        let _ = LENT.try_with(|l| {
+            let mut l = l.borrow_mut();
+            if let Some(at) = l.iter().rposition(|loan| loan.number == number) {
+                l.remove(at);
             }
-        }
-        if changed {
-            self.db.changed();
-        }
+        });
     }
 }
diff --git a/crates/text/src/fontdb/db.rs b/crates/text/src/fontdb/db.rs
index 0e28d57528..2fda0e79a1 100644
--- a/crates/text/src/fontdb/db.rs
+++ b/crates/text/src/fontdb/db.rs
@@ -74,7 +74,6 @@ impl FontDb {
             stamp: Mutex::new(None),
             instances: Mutex::new(Instances::default()),
             composites: RwLock::new(HashMap::new()),
-            composite_loans: Mutex::new(HashMap::new()),
         }
     }
 
@@ -127,9 +126,11 @@ impl FontDb {
     }
 
     /// A number that changes whenever the available fonts do (fonts added, system fonts
-    /// rescanned): lists built from [`FontDb::family_list`] are current while it doesn't.
+    /// rescanned): lists built from [`FontDb::family_list`] are current while it doesn't. While a
+    /// guard of this thread lends composite fonts other than the ones the database holds
+    /// ([`FontDb::lend_composite_fonts`]), it is a number of its own for those definitions.
     pub fn generation(&self) -> u64 {
-        self.generation.load(Ordering::Relaxed)
+        self.lent_generation(self.generation.load(Ordering::Relaxed))
     }
 
     /// A number no other database made in this process has: with [`FontDb::generation`], it tells
diff --git a/crates/text/src/harakat.rs b/crates/text/src/harakat.rs
index 783758cf82..4c75aa3dbc 100644
--- a/crates/text/src/harakat.rs
+++ b/crates/text/src/harakat.rs
@@ -75,6 +75,11 @@ pub(crate) fn paint_only(a: &CharStyle, b: &CharStyle) -> bool {
         tcy_up_down,
         tcy_left_right,
         standard_vertical_roman,
+        warichu,
+        warichu_lines,
+        warichu_gap,
+        warichu_scale,
+        warichu_align,
         digits,
         font_height_reference,
         no_break,
@@ -123,6 +128,11 @@ pub(crate) fn paint_only(a: &CharStyle, b: &CharStyle) -> bool {
         && tcy_up_down == &b.tcy_up_down
         && tcy_left_right == &b.tcy_left_right
         && standard_vertical_roman == &b.standard_vertical_roman
+        && warichu == &b.warichu
+        && warichu_lines == &b.warichu_lines
+        && warichu_gap == &b.warichu_gap
+        && warichu_scale == &b.warichu_scale
+        && warichu_align == &b.warichu_align
         && digits == &b.digits
         && font_height_reference == &b.font_height_reference
         && no_break == &b.no_break
diff --git a/crates/text/src/justify.rs b/crates/text/src/justify.rs
index 6be6a6ab4a..c2a076bce8 100644
--- a/crates/text/src/justify.rs
+++ b/crates/text/src/justify.rs
@@ -141,6 +141,11 @@ pub(crate) fn apply_desired(sg: &mut [SGlyph], j: &JustificationOptions, scale_g
             owner = None;
         }
         let (Some(g), Some(f)) = (sg.get_mut(k), flex.get_mut(k)) else { continue };
+        // A warichu block keeps the length its lines set and its glyphs their size, as an inline
+        // graphic does.
+        if g.wari.is_some() {
+            continue;
+        }
         if zero_width_space {
             if let Some(space) = space_gap {
                 g.adv += space * l_des;
diff --git a/crates/text/src/kashida.rs b/crates/text/src/kashida.rs
index 90f4efe277..c36eacbf2d 100644
--- a/crates/text/src/kashida.rs
+++ b/crates/text/src/kashida.rs
@@ -104,8 +104,8 @@ pub(crate) const MAX_TATWEELS: f64 = 64.0;
 /// The kashidas of the glyphs `line` (indices into `sg`, a paragraph's glyphs in logical order;
 /// `text` is the plain text) of a justified line with `room` points to fill: for each Arabic
 /// word with joined letters, at its last pair of them, the byte offset of the cluster after the kashida and
-/// the kashida's length, in text order. Words end at spaces, inline graphics, and characters other than letters
-/// and marks (punctuation, digits, symbols). Every kashida takes an equal share of `room`, up to
+/// the kashida's length, in text order. Words end at spaces, inline graphics, warichu blocks, and characters other
+/// than letters and marks (punctuation, digits, symbols). Every kashida takes an equal share of `room`, up to
 /// `kind`'s longest in ems of the letter after it (as wide as its horizontal scale draws it); a
 /// Stylistic kashida is a whole number of tatweels, at most [`MAX_TATWEELS`], and a word whose
 /// share is shorter than one tatweel gets none. A line of words without joined letters, or whose
@@ -124,7 +124,8 @@ pub(crate) fn plan(text: &str, sg: &[SGlyph], line: Range<usize>, kind: Kashida,
         let end = (j + 1..line.end).find(|&e| sg.get(e).is_none_or(|n| n.byte != g.byte)).unwrap_or(line.end);
         let first = text.get(g.byte..g.byte + g.len).and_then(|s| s.chars().next());
         let not_a_letter = first.is_some_and(|c| !c.is_alphabetic() && joining(c) != Joining::Transparent);
-        if g.is_space() || g.inline.is_some() || not_a_letter {
+        // A warichu block is set as one piece at the length its lines set: it ends a word too.
+        if g.is_space() || g.inline.is_some() || g.wari.is_some() || not_a_letter {
             picks.extend(word.take());
             prev = None;
         } else {
diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs
index fedd795d78..82a849a3dc 100644
--- a/crates/text/src/layout.rs
+++ b/crates/text/src/layout.rs
@@ -33,6 +33,7 @@ mod region;
 mod ruby;
 mod shaped;
 mod vertical;
+mod warichu;
 
 pub(crate) use bidi::{is_rtl, para_bidi, starts_bidi};
 use breaking::tab_advance;
@@ -41,6 +42,8 @@ use breaking::{break_line, candidates};
 pub use driver::{decorations, drawn, fit_first_line, fit_source_lines, layout, layout_with, scaled};
 #[cfg(test)]
 pub(crate) use driver::{fit_passes, layout_faces_per_call};
+#[cfg(test)]
+pub(crate) use on_path::{layout_trying_each_start, path_arrangements};
 use vertical::{TcyStyle, stands_upright, tate_chu_yoko, upright_cell, upright_centre, upright_extent, whole_character_widths};
 
 #[cfg(test)]
@@ -244,7 +247,9 @@ impl Ctx<'_> {
         if self.vertical {
             tate_chu_yoko(v, self.system_layout || !self.fractional_widths, |g| {
                 let st = style(g);
-                TcyStyle { size: st.size, marked: st.tate_chu_yoko, up: st.tcy_up_down, right: st.tcy_left_right }
+                // Type on a path sets warichu characters as they are, its digits included.
+                let warichu = st.warichu && !self.on_path;
+                TcyStyle { size: st.size, marked: st.tate_chu_yoko, up: st.tcy_up_down, right: st.tcy_left_right, warichu }
             });
             // An upright glyph advances down the column by its vertical advance (the font's vertical
             // metrics; without them at least one em, as CJK fonts' is), centred across it: a narrow
@@ -267,6 +272,12 @@ impl Ctx<'_> {
                 }
             }
         }
+        // Warichu: each stretch of marked characters stacked as one block inside its line, after
+        // tate-chu-yoko and the upright cells have set the glyphs' lengths along it. Type on a path
+        // sets them as they are.
+        if !self.on_path {
+            warichu::warichu(v, (self.vertical, self.system_layout || !self.fractional_widths), |g| warichu::WariStyle::of(style(g)));
+        }
         // System Layout or Fractional Widths off: whole-point advances, after tate-chu-yoko and the
         // upright cell have set the widths the line breaker will use. A zero advance stays zero.
         if self.system_layout || !self.fractional_widths {
@@ -291,7 +302,13 @@ impl Ctx<'_> {
     /// paragraph's embedding level.
     fn prepend_marker(&self, pr: &Range<usize>, para: &ParaStyle, text: Option<&str>, rtl: bool, sg: &mut Vec<SGlyph>) -> usize {
         let Some(text) = text.filter(|_| para.list.is_some() && !pr.is_empty()) else { return 0 };
-        let st = vectorcraft_doc::text::ParaList::marker_style(self.style_at(pr.start));
+        let first = self.style_at(pr.start);
+        let mut st = vectorcraft_doc::text::ParaList::marker_style(first);
+        // A paragraph that starts with warichu: the marker takes the size of the line, not the
+        // block's ([`warichu::warichu_sizes`] set the first character smaller).
+        if warichu::stacked(first, self.vertical) && !self.on_path {
+            st.size = warichu::WariStyle::of(first).parent_size();
+        }
         let run = self.runs.partition_point(|(r, _)| r.end <= pr.start);
         if !self.runs.get(run).is_some_and(|(r, _)| r.start <= pr.start && pr.start < r.end) {
             return 0;
@@ -322,12 +339,13 @@ impl Ctx<'_> {
         tab.aki_shift = 0.0;
         tab.aki = 0.0;
         tab.tcy = None;
+        tab.wari = None;
         tab.vpal = None;
         let left = para.laid_out_left_indent();
         let pen = left + para.first_line_indent + marker.iter().map(|g| g.adv).sum::<f64>();
         let to_indent = left - pen;
         let stop_before_indent = para.tabs.iter().any(|t| t.position > pen + EPS && t.position < left - EPS);
-        tab.adv = if to_indent > EPS && !stop_before_indent { to_indent } else { tab_advance(&para.tabs, 0.0, pen, sg).0 };
+        tab.adv = if to_indent > EPS && !stop_before_indent { to_indent } else { tab_advance(&para.tabs, 0.0, pen, sg.iter()).0 };
         if para.list.is_some_and(|l| l.align == ListAlign::Right) {
             marker.insert(0, tab);
         } else {
@@ -606,6 +624,8 @@ impl Ctx<'_> {
             },
             width,
             width_start,
+            warichu: g.wari.map(|w| w.start),
+            warichu_line: g.wari.map_or(0.0, |w| w.across),
         });
     }
 
@@ -640,6 +660,7 @@ impl Ctx<'_> {
         k.ch = kashida::TATWEEL;
         k.inline = None;
         k.tcy = None;
+        k.wari = None;
         // Base letter's run: `g` may be a mark (last in the shaping cluster) with mark paint.
         if let Some(run) = self.run_index_at(g.byte) {
             k.run = run;
@@ -705,6 +726,7 @@ mod emit_kashida_mark_last {
             xh: 20.0,
             ch: 'ب',
             tcy: None,
+            wari: None,
             inline: None,
             word_end: false,
             keeps_word: false,
@@ -770,6 +792,7 @@ mod emit_kashida_mark_last {
             xh: 20.0,
             ch: '\u{064E}',
             tcy: None,
+            wari: None,
             inline: None,
             word_end: false,
             keeps_word: false,
diff --git a/crates/text/src/layout/breaking.rs b/crates/text/src/layout/breaking.rs
index fd53a26428..671ebee7a1 100644
--- a/crates/text/src/layout/breaking.rs
+++ b/crates/text/src/layout/breaking.rs
@@ -20,7 +20,8 @@ pub(super) struct Metrics {
 
 impl Metrics {
     pub(super) fn of(g: &SGlyph) -> Self {
-        let em = g.face.units_per_em() * g.sy;
+        // A warichu glyph's em is the em of the line its block sits in.
+        let em = super::vertical::glyph_em(g);
         Self { asc: g.ascent, desc: g.descent, lead: g.leading, cap: g.cap, xh: g.xh, top: (g.face.ideographic_centre() + 0.5) * em }
     }
     pub(super) fn max(g: &[SGlyph]) -> Option<Self> {
@@ -203,11 +204,17 @@ impl Pen<'_> {
 
 /// Advance of a tab at pen position `x`: up to the next stop after it (explicit stops first, then
 /// every ½ inch), and the leader of that stop (default stops have none). Right, centre and decimal
-/// stops align the text that follows (`rest`, up to the next tab) on the stop.
-pub(super) fn tab_advance<'t>(tabs: &'t [vectorcraft_doc::TabStop], origin: f64, x: f64, rest: &[SGlyph]) -> (f64, &'t str) {
+/// stops align the text drawn after the tab (`rest`, in drawing order, up to the next tab) on the
+/// stop.
+pub(super) fn tab_advance<'t, 'g>(
+    tabs: &'t [vectorcraft_doc::TabStop],
+    origin: f64,
+    x: f64,
+    rest: impl IntoIterator<Item = &'g SGlyph>,
+) -> (f64, &'t str) {
     use vectorcraft_doc::TabAlign;
     let rel = x - origin;
-    let seg: Vec<&SGlyph> = rest.iter().take_while(|g| g.ch != '\t' && g.ch != '\u{2028}').collect();
+    let seg: Vec<&SGlyph> = rest.into_iter().take_while(|g| g.ch != '\t' && g.ch != '\u{2028}').collect();
     let width: f64 = seg.iter().map(|g| g.adv).sum();
     let target = |pos: f64, align: TabAlign, on: char| match align {
         TabAlign::Left => pos,
@@ -227,17 +234,28 @@ pub(super) fn tab_advance<'t>(tabs: &'t [vectorcraft_doc::TabStop], origin: f64,
     ((at - rel).max(0.0), leader)
 }
 
-/// The width of glyphs `from..to` of `sg` set on a line whose content starts `x_start` from the
-/// tab origin: tabs of the text take what [`tab_advance`] gives them, not the width of their
-/// glyph. The tab of a list marker (length 0) keeps its own width.
-pub(super) fn set_width(sg: &[SGlyph], from: usize, to: usize, tabs: &[vectorcraft_doc::TabStop], x_start: f64) -> f64 {
+/// The glyphs of `sg` drawn after position `k` of `drawn` (indices into `sg`, in drawing order).
+pub(super) fn drawn_after_tab<'g>(sg: &'g [SGlyph], drawn: &'g [usize], k: usize) -> impl Iterator<Item = &'g SGlyph> {
+    drawn.iter().skip(k + 1).filter_map(move |&j| sg.get(j))
+}
+
+/// The width of the glyphs of `sg` at `drawn` (indices into `sg`, in the order the line draws
+/// them) set on a line whose content starts `x_start` from the tab origin: tabs of the text take
+/// what [`tab_advance`] gives them from where the glyphs drawn before them end, aligning the glyphs
+/// drawn after them, not the width of their glyph. The tab of a list marker (length 0) keeps its
+/// own width.
+pub(super) fn drawn_width(sg: &[SGlyph], drawn: &[usize], tabs: &[vectorcraft_doc::TabStop], x_start: f64) -> f64 {
     let mut x = x_start;
-    for (j, g) in sg.iter().enumerate().take(to).skip(from) {
-        x += if g.ch == '\t' && g.len > 0 { tab_advance(tabs, 0.0, x, sg.get(j + 1..to).unwrap_or_default()).0 } else { g.adv };
+    for (k, g) in drawn.iter().enumerate().filter_map(|(k, &j)| sg.get(j).map(|g| (k, g))) {
+        x += if g.ch == '\t' && g.len > 0 { tab_advance(tabs, 0.0, x, drawn_after_tab(sg, drawn, k)).0 } else { g.adv };
     }
     x - x_start
 }
 
+/// Most breaks, or hyphenation points, [`break_line`] measures as drawn one by one from the latest
+/// back before bisecting the earlier ones.
+const MAX_DRAWN_CHECKS: usize = 256;
+
 /// Most copies of a leader drawn in one tab: a tiny type size and a far stop must not make
 /// millions of outlines.
 const MAX_LEADER_COPIES: f64 = 4096.0;
@@ -335,6 +353,12 @@ pub(super) fn word_width(g: &[SGlyph], i: usize, line_end: &[f64], kinsoku: Kins
 /// Margin Alignment or Roman Hanging Punctuation is on, and `vertical` in vertical type.
 /// `line_end[k]` is how much narrower a line ending with glyph `k` is set (Mojikumi); a cluster
 /// that fits only that narrower stays on the line when the line may end after it (empty: none).
+/// `fits`, for a line drawn in another order than its text's (right to left), is whether the line
+/// from `i` ending before glyph `end` (with a hyphen when `hyphenated`) fits `width` as it is drawn:
+/// once the line holds a tab, whose width depends on what is drawn before it, the line reads on
+/// while the least it can be drawn at fits `width`, then ends at the latest legal break where it
+/// fits as drawn (past [`MAX_DRAWN_CHECKS`] breaks back from the latest, the earlier ones without a
+/// hyphen are bisected); hyphenation points are measured the same way.
 #[allow(clippy::too_many_arguments)]
 pub(super) fn break_line(
     text: &str,
@@ -350,7 +374,29 @@ pub(super) fn break_line(
     hanging: bool,
     vertical: bool,
     line_end: &[f64],
+    fits: Option<&dyn Fn(usize, bool) -> bool>,
 ) -> (usize, bool) {
+    // The line ending at `chosen`, once it holds a tab, when it fits as drawn; otherwise the latest
+    // of the legal `breaks` before it that fits as drawn, measuring at most MAX_DRAWN_CHECKS of
+    // them from the latest back and bisecting the earlier ones without a hyphen; the first of them
+    // when none of those measured fits.
+    let settle = |tabbed: bool, chosen: (usize, bool), breaks: &[(usize, bool)]| -> (usize, bool) {
+        let Some(fits) = fits.filter(|_| tabbed) else { return chosen };
+        if fits(chosen.0, chosen.1) {
+            return chosen;
+        }
+        let earlier = breaks.get(breaks.partition_point(|b| b.0 <= i)..breaks.partition_point(|b| b.0 < chosen.0)).unwrap_or_default();
+        if let Some(&b) = earlier.iter().rev().take(MAX_DRAWN_CHECKS).find(|b| fits(b.0, b.1)) {
+            return b;
+        }
+        // Without a hyphen, a line that ends later is drawn no narrower, so those breaks bisect.
+        let rest = earlier.get(..earlier.len().saturating_sub(MAX_DRAWN_CHECKS)).unwrap_or_default();
+        let plain: Vec<&(usize, bool)> = rest.iter().filter(|b| !b.1).collect();
+        let fitting = plain.partition_point(|b| fits(b.0, b.1));
+        fitting.checked_sub(1).and_then(|k| plain.get(k).copied()).or(earlier.first()).copied().unwrap_or(chosen)
+    };
+    let mut breaks: Vec<(usize, bool)> = Vec::new();
+    let mut tabbed = false;
     if !width.is_finite() {
         if let Some(pos) = g[i..].iter().position(|gl| gl.ch == '\u{2028}') {
             return (i + pos + 1, false);
@@ -358,6 +404,27 @@ pub(super) fn break_line(
         return (g.len(), false);
     }
     let mut x = 0.0;
+    // The width of the line's glyphs other than its tabs, how far those with a negative advance step
+    // back in all, and how many tabs it holds.
+    let mut ink = 0.0;
+    let mut back = 0.0;
+    let mut tabs_read = 0usize;
+    // The `n`th of the stops a tab can go to, in order: the explicit stops, then every default
+    // stop after the last of them (0 when `n` is 0).
+    let mut explicit: Vec<f64> = if fits.is_some() { tabs.iter().map(|t| t.position).filter(|p| p.is_finite()).collect() } else { Vec::new() };
+    explicit.sort_by(f64::total_cmp);
+    explicit.dedup();
+    let last_explicit = tabs.iter().map(|t| t.position).fold(0.0, f64::max).max(0.0);
+    let nth_stop = |n: usize| -> f64 {
+        use vectorcraft_doc::text::DEFAULT_TAB_INTERVAL;
+        match n.checked_sub(1) {
+            None => 0.0,
+            Some(k) => explicit
+                .get(k)
+                .copied()
+                .unwrap_or_else(|| ((last_explicit / DEFAULT_TAB_INTERVAL).floor() + (n - explicit.len()) as f64) * DEFAULT_TAB_INTERVAL),
+        }
+    };
     let mut last_break: Option<(usize, bool)> = None;
     // A list marker (length 0) is a cluster of its own; the line holds it and at least the first
     // cluster after it.
@@ -384,19 +451,32 @@ pub(super) fn break_line(
             }
         }
         // A list marker's glyphs, its tab included, keep their own widths.
-        let cluster_width: f64 = if gl.ch == '\t' && gl.len > 0 {
+        let is_tab = gl.ch == '\t' && gl.len > 0;
+        let cluster_width: f64 = if is_tab {
+            tabbed = true;
+            tabs_read += 1;
             tab_advance(tabs, 0.0, x_start + x, g.get(cluster_end..).unwrap_or_default()).0
         } else {
             g[j..cluster_end].iter().map(|glyph| glyph.adv).sum()
         };
+        let cluster_ink = if is_tab { 0.0 } else { cluster_width };
+        let cluster_back: f64 = if is_tab { 0.0 } else { g[j..cluster_end].iter().map(|glyph| (-glyph.adv).max(0.0)).sum() };
         if gl.ch == '\u{2028}' {
-            return (cluster_end, false);
+            return settle(tabbed, (cluster_end, false), &breaks);
         }
         // Measured as the line is set when it ends with this cluster: only the cluster's last glyph
         // is narrowed, and only where the line may end.
         let end_credit =
             Some(line_end_credit(g, line_end, cluster_end)).filter(|&c| c > 0.0 && may_end_after(g, cluster_end, kinsoku)).unwrap_or(0.0);
-        if j > first && !gl.is_space() && x + cluster_width - end_credit > width + EPS {
+        // Once the line holds a tab and is measured as drawn, it reads on while the least it can be
+        // drawn at fits, and where it ends is settled then. That least is its glyphs other than the
+        // tabs and, while no glyph steps back, the stop its tabs reach: each tab then goes to a later
+        // stop than the one before and the text aligned on it ends at or past that stop, so the
+        // line's tabs, all before this cluster, reach at least the stop as many places along as
+        // there are tabs.
+        let stops_reached = if back + cluster_back > 0.0 { f64::NEG_INFINITY } else { nth_stop(tabs_read) - x_start };
+        let measured = if tabbed && fits.is_some() { (ink + cluster_ink).max(stops_reached) } else { x + cluster_width };
+        if j > first && !gl.is_space() && measured - end_credit > width + EPS {
             // It ends the line with the spaces after it.
             if burasagari != Burasagari::None && hangs(gl) && kinsoku_allows(g, cluster_end - 1, kinsoku) {
                 let mut end = cluster_end;
@@ -413,20 +493,23 @@ pub(super) fn break_line(
             break;
         }
         x += cluster_width;
+        ink += cluster_ink;
+        back += cluster_back;
         let last = &g[cluster_end - 1];
         if last.break_after() && last.len > 0 && kinsoku_allows(g, cluster_end - 1, kinsoku) && !splits_no_break(g, cluster_end) {
-            if last.is_soft_hyphen() {
-                if x + hyphen_glyph(last).adv <= width + EPS {
-                    last_break = Some((cluster_end, true));
+            // Once the line holds a tab, whether a break fits as drawn is settled when the line ends.
+            let hyphenated = last.is_soft_hyphen();
+            if !hyphenated || (tabbed && fits.is_some()) || x + hyphen_glyph(last).adv <= width + EPS {
+                last_break = Some((cluster_end, hyphenated));
+                if fits.is_some() {
+                    breaks.push((cluster_end, hyphenated));
                 }
-            } else {
-                last_break = Some((cluster_end, false));
             }
         }
         j = cluster_end;
     }
     if j >= g.len() {
-        return (g.len(), false);
+        return settle(tabbed, (g.len(), false), &breaks);
     }
     // Hyphenate the word that overflows. A list marker starting the line is not part of a word.
     let word_start = last_break.map_or(first, |b| b.0);
@@ -450,29 +533,39 @@ pub(super) fn break_line(
             .into_iter()
             .filter(|&k| k > 0 && kinsoku_allows(g, k - 1, kinsoku) && !splits_no_break(g, k))
             .collect();
-        for &k in pts.iter().rev() {
-            if k <= j && k > i {
-                let w = x_ws + g[word_start..k].iter().map(|g| g.adv).sum::<f64>() + hyphen_glyph(&g[k - 1]).adv;
-                if w <= width + EPS {
-                    return (k, true);
-                }
+        // The points the line may end at, the latest first. Measured as drawn, at most
+        // MAX_DRAWN_CHECKS of them are measured one by one, and the earlier ones are bisected:
+        // each ends with a hyphen, so a later one is drawn no narrower.
+        let points: Vec<usize> = pts.iter().rev().copied().filter(|&k| k <= j && k > i).collect();
+        let drawn = fits.filter(|_| tabbed);
+        for &k in points.iter().take(if drawn.is_some() { MAX_DRAWN_CHECKS } else { usize::MAX }) {
+            let w = x_ws + g[word_start..k].iter().map(|g| g.adv).sum::<f64>() + hyphen_glyph(&g[k - 1]).adv;
+            if drawn.map_or(w <= width + EPS, |fits| fits(k, true)) {
+                return (k, true);
+            }
+        }
+        if let Some(fits) = drawn {
+            let earlier: Vec<usize> = points.iter().skip(MAX_DRAWN_CHECKS).rev().copied().collect();
+            let fitting = earlier.partition_point(|&k| fits(k, true));
+            if let Some(&k) = fitting.checked_sub(1).and_then(|n| earlier.get(n)) {
+                return (k, true);
             }
         }
     }
     // Break candidates and greedy overflow are cluster boundaries; hyphenation also returns only
     // cluster starts, so the resulting end always keeps each source cluster together.
-    let (end, hy) = match last_break {
-        Some(b) if b.0 > i => b,
+    match last_break {
+        Some(b) if b.0 > i => settle(tabbed, b, &breaks),
         _ => (j, false),
-    };
-    (end, hy)
+    }
 }
 
 /// Can glyph `g` hang outside the line (burasagari)? An East Asian comma or full stop, full width
 /// (、。，．) or half width (､｡); not a closing bracket, nor Latin punctuation (Latin text keeps
-/// its line breaks and composer). Never an inline graphic (U+FFFC).
+/// its line breaks and composer). Never an inline graphic (U+FFFC), nor a character of a
+/// tate-chu-yoko or warichu block.
 pub(super) fn hangs(g: &SGlyph) -> bool {
-    g.inline.is_none() && matches!(g.ch, '、' | '。' | '，' | '．' | '､' | '｡') && g.tcy.is_none()
+    g.inline.is_none() && matches!(g.ch, '、' | '。' | '，' | '．' | '､' | '｡') && g.tcy.is_none() && g.wari.is_none()
 }
 
 /// Optical Margin Alignment: the share of glyph `g`'s advance that hangs outside the margin when
@@ -480,9 +573,10 @@ pub(super) fn hangs(g: &SGlyph) -> bool {
 /// asterisks, tildes, ellipses, en and em dashes, colons and semicolons hang by half (the amounts
 /// published for Roman Hanging Punctuation). A, V, W, Y, v, w and y hang by a tenth of their
 /// advance, VectorCraft's own amount for their slanted sides. Other characters, East Asian
-/// punctuation (which burasagari hangs) and inline graphics don't hang.
+/// punctuation (which burasagari hangs), inline graphics and the characters of a warichu block
+/// don't hang.
 pub(super) fn optical_share(g: &SGlyph) -> f64 {
-    if g.inline.is_some() || g.tcy.is_some() {
+    if g.inline.is_some() || g.tcy.is_some() || g.wari.is_some() {
         return 0.0;
     }
     match g.ch {
@@ -710,7 +804,7 @@ fn push_in(
 }
 
 /// May a push-in close the gap after glyph `a`? A gap between two characters, at least one of them
-/// CJK, outside a tate-chu-yoko block, a list marker and a shaped cluster, and not next to a space,
+/// CJK, outside a tate-chu-yoko or warichu block, a list marker and a shaped cluster, and not next to a space,
 /// a tab or an inline graphic before it, nor inside an inseparable pair that Bunri-Kinshi keeps
 /// together. Zero-width format controls take no gap: the gap is the one between the visible
 /// characters on either side, before `end`, as the layout justifies it.
@@ -724,7 +818,7 @@ fn closes(g: &[SGlyph], a: usize, end: usize) -> bool {
         && !p.is_space()
         && !n.is_space()
         && p.ch != '\t'
-        && !n.continues_tcy()
+        && !n.continues_block()
         && (is_cjk(p.ch) || is_cjk(n.ch))
 }
 
diff --git a/crates/text/src/layout/driver.rs b/crates/text/src/layout/driver.rs
index 68519f397b..9108cc171d 100644
--- a/crates/text/src/layout/driver.rs
+++ b/crates/text/src/layout/driver.rs
@@ -354,8 +354,8 @@ fn shrink_to_fit(db: &FontDb, t: &TextObject, shown: &TextObject, opts: &LayoutO
     Some(best.unwrap_or_else(|| at(lo)))
 }
 
-/// `t` with every run's size, explicit leading, baseline shift and tate-chu-yoko offsets scaled by `f`, inline art's own
-/// shift included (auto leading and the art's size follow the size; paragraph spacing stays).
+/// `t` with every run's size, explicit leading, baseline shift, tate-chu-yoko offsets and warichu Line Gap scaled by `f`,
+/// inline art's own shift included (auto leading and the art's size follow the size; paragraph spacing stays).
 /// Shrink Text to Fit lays `t` out as `scaled(t, f)`, where `f` is the layout's
 /// [`TextLayout::fit_scale`], so the result holds the styles the text is drawn in.
 pub fn scaled(t: &TextObject, f: f64) -> TextObject {
@@ -366,6 +366,7 @@ pub fn scaled(t: &TextObject, f: f64) -> TextObject {
         r.style.baseline_shift *= f;
         r.style.tcy_up_down *= f;
         r.style.tcy_left_right *= f;
+        r.style.warichu_gap *= f;
         if let Some(a) = &mut r.inline {
             a.baseline_shift *= f;
         }
@@ -414,10 +415,13 @@ pub(crate) fn layout_faces_per_call(db: &FontDb, t: &TextObject) -> TextLayout {
     l
 }
 
-/// One layout pass, without fitting. Runs set in a composite font are laid out as the runs of one
-/// class each that [`FontDb::composite_split`] makes of them; the glyphs, ruby and inline
-/// graphics still name the runs of `t`.
+/// One layout pass, without fitting. Warichu runs are set at their Warichu Settings Scale of
+/// their size ([`super::warichu::warichu_sizes`]). Runs set in a composite font are laid out as
+/// the runs of one class each that [`FontDb::composite_split`] makes of them; the glyphs, ruby and
+/// inline graphics still name the runs of `t`.
 fn layout_once(db: &FontDb, t: &TextObject, opts: &LayoutOptions) -> TextLayout {
+    let sized = super::warichu::warichu_sizes(t);
+    let t = &*sized;
     let Some((split, from)) = db.composite_split(t) else { return layout_runs(db, t, opts, None) };
     let mut l = layout_runs(db, &split, opts, Some(t));
     let original = |run: &mut usize| *run = from.get(*run).copied().unwrap_or(*run);
@@ -492,7 +496,9 @@ fn layout_runs(db: &FontDb, t: &TextObject, opts: &LayoutOptions, set: Option<&T
         TextKind::Point => {
             let first = cx.style_at(0);
             let centre = cx.face_at(0).map_or(EM_CENTER, |f| f.ideographic_centre());
-            Affine::translate((-centre * first.size, 0.0)) * QUARTER_TURN
+            // A warichu first character keeps the size of its line ([`super::warichu::warichu_sizes`]).
+            let size = if super::warichu::stacked(first, true) { super::warichu::WariStyle::of(first).parent_size() } else { first.size };
+            Affine::translate((-centre * size, 0.0)) * QUARTER_TURN
         }
         _ => QUARTER_TURN,
     };
diff --git a/crates/text/src/layout/flow.rs b/crates/text/src/layout/flow.rs
index 9e2362d9d1..1ee9a3fe50 100644
--- a/crates/text/src/layout/flow.rs
+++ b/crates/text/src/layout/flow.rs
@@ -1,7 +1,7 @@
 use super::bidi::{is_rtl, para_bidi_with, visual_order};
 use super::breaking::{
-    Metrics, PUSH_IN_SQUEEZE, Pen, break_line, candidates, hangs, leader_outline, optical_hangs, optical_hangs_rtl, optical_punct, optical_share,
-    roman_share, set_width, squeeze_em, tab_advance, word_width,
+    Metrics, PUSH_IN_SQUEEZE, Pen, break_line, candidates, drawn_after_tab, drawn_width, hangs, leader_outline, optical_hangs, optical_hangs_rtl,
+    optical_punct, optical_share, roman_share, squeeze_em, tab_advance, word_width,
 };
 use super::region::Region;
 use super::vertical::{
@@ -288,8 +288,10 @@ fn prepare_paragraph<'a, 'text>(
             wakan.splice(0..0, vec![0.0; marker]);
         }
     }
-    // …and Auto Leading: characters whose leading is Auto take this paragraph's share of their size.
-    let auto_leading = |style: &CharStyle| style.leading.unwrap_or_else(|| para.justification.auto_leading_for(style.size));
+    // …and Auto Leading: characters whose leading is Auto take this paragraph's share of their size
+    // (a warichu character, of the size of the line its block sits in).
+    let auto_leading =
+        |style: &CharStyle| style.leading.unwrap_or_else(|| para.justification.auto_leading_for(super::warichu::line_size(style, cx.vertical)));
     if para.justification.auto_leading != vectorcraft_doc::JustificationOptions::default().auto_leading {
         for glyph in sg.iter_mut().filter(|glyph| glyph.inline.is_none()) {
             glyph.leading = auto_leading(cx.style_at(glyph.byte));
@@ -342,6 +344,8 @@ fn prepare_paragraph<'a, 'text>(
 struct PlacementContext<'a> {
     para: &'a ParaStyle,
     pr: &'a Range<usize>,
+    /// [`ParagraphData::bidi`].
+    bidi: Option<&'a BidiInfo<'a>>,
     sg: &'a mut [SGlyph],
     /// [`ParagraphData::line_end`].
     line_end: &'a [f64],
@@ -376,6 +380,7 @@ fn place_flow_line(cx: &mut Ctx<'_>, pen: &mut Pen<'_>, context: &mut PlacementC
     let PlacementContext {
         para,
         pr,
+        bidi,
         sg,
         line_end,
         continued,
@@ -427,11 +432,32 @@ fn place_flow_line(cx: &mut Ctx<'_>, pen: &mut Pen<'_>, context: &mut PlacementC
         let (end, hyph, pushed_in) = match composed.as_ref().and_then(|lines| lines.get(*para_line)) {
             Some(&(end, hyph)) if end > *i => (end, hyph, false),
             _ if *i < n => {
+                let start = *i;
+                let glyphs: &[SGlyph] = sg;
+                // A horizontal line with right-to-left text is drawn in another order than its
+                // text's, and its tabs take their stops in the order they are drawn: whether the line
+                // ending before glyph `end` fits is measured as it is drawn ([`drawn_width`]).
+                let drawn_fits = |end: usize, hyphenated: bool| {
+                    let mut trimmed = end;
+                    while trimmed > start && glyphs.get(trimmed - 1).is_some_and(|g| g.is_space() || g.ch == '\u{2028}') {
+                        trimmed -= 1;
+                    }
+                    let bytes = glyphs.get(start).map_or(pr.start, |g| g.byte)..glyphs.get(end).map_or(pr.end, |g| g.byte);
+                    let drawn: Vec<usize> = visual_order(*bidi, pr.start, bytes, glyphs.get(start..end).unwrap_or_default())
+                        .into_iter()
+                        .map(|offset| start + offset)
+                        .filter(|&j| j < trimmed)
+                        .collect();
+                    let hyphen = if hyphenated { end.checked_sub(1).and_then(|k| glyphs.get(k)).map_or(0.0, |g| hyphen_glyph(g).adv) } else { 0.0 };
+                    let credit = trimmed.checked_sub(1).filter(|&k| k >= start).and_then(|k| line_end.get(k)).copied().unwrap_or(0.0);
+                    drawn_width(glyphs, &drawn, &para.tabs, ind_l) + hyphen - credit <= width + EPS
+                };
+                let fits: Option<&dyn Fn(usize, bool) -> bool> = (!cx.vertical && bidi.is_some_and(|b| b.has_rtl())).then_some(&drawn_fits);
                 let line = |ty| {
                     break_line(
                         cx.text,
-                        sg,
-                        *i,
+                        glyphs,
+                        start,
                         width,
                         &para.tabs,
                         ind_l,
@@ -442,6 +468,7 @@ fn place_flow_line(cx: &mut Ctx<'_>, pen: &mut Pen<'_>, context: &mut PlacementC
                         *hanging,
                         cx.vertical,
                         line_end,
+                        fits,
                     )
                 };
                 let (end, hyph) = line(para.kinsoku_type);
@@ -498,6 +525,14 @@ struct LineGeometry {
     last_of_para: bool,
 }
 
+impl LineGeometry {
+    /// The line's glyphs before its trailing spaces (indices into the paragraph's glyphs), in the
+    /// order they are drawn: the glyphs its tabs are measured over.
+    fn measured(&self) -> Vec<usize> {
+        self.order.iter().map(|&offset| self.index + offset).filter(|&j| j < self.trimmed).collect()
+    }
+}
+
 struct LineJustification {
     per_space: f64,
     per_gap: f64,
@@ -538,6 +573,7 @@ fn run_paragraph_lines(cx: &mut Ctx<'_>, pen: &mut Pen<'_>, t: &TextObject, mut
         let mut placement = PlacementContext {
             para: paragraph.para,
             pr: &paragraph.pr,
+            bidi: paragraph.bidi.as_ref(),
             sg: &mut paragraph.sg,
             line_end: &paragraph.line_end,
             continued: paragraph.continued,
@@ -609,10 +645,13 @@ fn prepare_line_geometry(cx: &Ctx<'_>, t: &TextObject, paragraph: &ParagraphData
         .checked_sub(1)
         .filter(|&k| k >= index && rules.trims_line_end())
         .map_or(0.0, |k| line_end_trim(sg, &paragraph.compressed, &paragraph.wakan, rules, k));
-    let measured_width = set_width(sg, index, trimmed, &para.tabs, position.ind_l) + hyphen.as_ref().map_or(0.0, |g| g.adv) - end_trim;
     let line_start = sg.get(index).map_or(paragraph.pr.start, |g| g.byte);
     let line_end = sg.get(position.end).map_or(paragraph.pr.end, |g| g.byte);
     let order = visual_order(paragraph.bidi.as_ref().filter(|_| !cx.vertical), paragraph.pr.start, line_start..line_end, &sg[index..position.end]);
+    // The line is as wide as it is drawn: its glyphs before its trailing spaces in drawing order,
+    // each tab up to its stop from where the glyphs drawn before it end.
+    let measured: Vec<usize> = order.iter().map(|&offset| index + offset).filter(|&j| j < trimmed).collect();
+    let measured_width = drawn_width(sg, &measured, &para.tabs, position.ind_l) + hyphen.as_ref().map_or(0.0, |g| g.adv) - end_trim;
     // The glyphs before `stop` in visual order, each with the advance it is set with. A list
     // marker does not hang: it is counted with no width.
     let visible = |stop: usize| -> (Vec<usize>, Vec<(&SGlyph, f64)>) {
@@ -776,12 +815,24 @@ fn gap_pair<'a>(glyph: usize, held: &[usize], after: &[Option<usize>], index: us
     visible_after(index, glyph, after, sg).and_then(|next| sg.get(next)).map(|b| (a, b))
 }
 
+// Are `a` and `b` glyphs of the same warichu block? Right to left, the bidi order can draw a
+// block's first glyph after the others, so the glyph drawn second need not continue the block.
+fn same_warichu_block(a: &SGlyph, b: &SGlyph) -> bool {
+    a.wari.zip(b.wari).is_some_and(|(first, second)| first.start == second.start)
+}
+
 // Japanese (and Chinese) lines are justified between their characters (JLREQ 3.8): the
-// gaps next to a CJK character, not inside a Latin word, a tate-chu-yoko block or a shaped
-// cluster.
-fn is_cjk_gap(glyph: usize, held: &[usize], after: &[Option<usize>], index: usize, sg: &[SGlyph]) -> bool {
+// gaps next to a CJK character, not inside a Latin word, a tate-chu-yoko or warichu block or a
+// shaped cluster.
+pub(super) fn is_cjk_gap(glyph: usize, held: &[usize], after: &[Option<usize>], index: usize, sg: &[SGlyph]) -> bool {
     gap_pair(glyph, held, after, index, sg).is_some_and(|(a, b)| {
-        a.byte != b.byte && !a.is_space() && !b.is_space() && !b.continues_tcy() && a.ch != '\t' && (is_cjk(a.ch) || is_cjk(b.ch))
+        a.byte != b.byte
+            && !a.is_space()
+            && !b.is_space()
+            && !b.continues_block()
+            && !same_warichu_block(a, b)
+            && a.ch != '\t'
+            && (is_cjk(a.ch) || is_cjk(b.ch))
     }) && !in_pair(glyph, index, after, sg)
 }
 
@@ -807,16 +858,16 @@ fn in_pair(glyph: usize, index: usize, after: &[Option<usize>], sg: &[SGlyph]) -
 }
 
 // Single Word Justification's Full Justify spreads a line's leftover room over the gaps between
-// its drawn glyphs: not after a held glyph, nor inside a tate-chu-yoko block (one cell), a shaped
-// cluster, whose glyphs (a letter and its combining marks, a conjunct and its matra) stay
+// its drawn glyphs: not after a held glyph, nor inside a tate-chu-yoko block (one cell) or a
+// warichu block (set as one piece), a shaped cluster, whose glyphs (a letter and its combining marks, a conjunct and its matra) stay
 // together, or an inseparable pair. On a line that ends in a drawn hyphen, the gap before the
 // hyphen counts too: it follows the line's last visible glyph.
-fn is_letter_gap(glyph: usize, held: &[usize], after: &[Option<usize>], index: usize, sg: &[SGlyph], hyphen: bool) -> bool {
+pub(super) fn is_letter_gap(glyph: usize, held: &[usize], after: &[Option<usize>], index: usize, sg: &[SGlyph], hyphen: bool) -> bool {
     if held.contains(&glyph) || sg.get(glyph).is_none_or(|a| is_format_control(a.ch)) || in_pair(glyph, index, after, sg) {
         return false;
     }
     match gap_pair(glyph, held, after, index, sg) {
-        Some((a, b)) => a.byte != b.byte && !b.continues_tcy(),
+        Some((a, b)) => a.byte != b.byte && !b.continues_block() && !same_warichu_block(a, b),
         None => hyphen,
     }
 }
@@ -847,15 +898,16 @@ fn is_tab_fixed(fixed: &[bool], index: usize, glyph: usize) -> bool {
 
 // The natural width of justified area type `line` with a tab, as [`emit_flow_line`] draws it from
 // the line's start: its glyphs in drawing order, each tab up to its stop from where the glyphs
-// drawn before it end, then the line's hyphen.
+// drawn before it end, aligning the glyphs drawn after it, then the line's hyphen.
 fn tabbed_natural_width(paragraph: &ParagraphData<'_, '_>, line: &LineGeometry, fixed: &[bool]) -> f64 {
     let sg = &paragraph.sg;
     let start = line.ax0 - line.opt_l;
     let mut x = start;
-    for &j in &line.drawn {
+    let measured = line.measured();
+    for (k, &j) in measured.iter().enumerate().filter(|&(_, &j)| j < line.body) {
         let Some(g) = sg.get(j) else { continue };
         x += if g.ch == '\t' && g.len > 0 && is_tab_fixed(fixed, line.index, j) {
-            tab_advance(&paragraph.para.tabs, line.position.x0, x + line.opt_l, sg.get(j + 1..line.trimmed).unwrap_or_default()).0
+            tab_advance(&paragraph.para.tabs, line.position.x0, x + line.opt_l, drawn_after_tab(sg, &measured, k)).0
         } else if j + 1 == line.trimmed {
             g.adv - line.end_trim
         } else {
@@ -1027,8 +1079,9 @@ fn justify_flow_line(cx: &Ctx<'_>, paragraph: &ParagraphData<'_, '_>, line: &Lin
     LineJustification { per_space, per_gap, per_cjk, squeeze, fit, start_x, after, kashidas, last_tab, trailing, fixed }
 }
 
-/// The advance and leader of tab `glyph_index` of `line`, at pen position `x`: up to its stop
-/// ([`tab_advance`], measured from `tab_origin` less `tab_shift`), or, for the last tab of
+/// The advance and leader of tab `glyph_index` of `line`, drawn at `order_index` of
+/// [`LineGeometry::order`], at pen position `x`: up to its stop ([`tab_advance`], measured from
+/// `tab_origin` less `tab_shift`, aligning the glyphs drawn after it), or, for the last tab of
 /// right-aligned area type ([`LineJustification::last_tab`]), up to where the rest of the line
 /// ends on the right edge. The tab after a list marker keeps the width `prepend_marker` gave it
 /// (`advance`).
@@ -1036,7 +1089,7 @@ fn tab_glyph<'p>(
     paragraph: &'p ParagraphData<'_, '_>,
     line: &LineGeometry,
     justification: &LineJustification,
-    glyph_index: usize,
+    (glyph_index, order_index): (usize, usize),
     x: f64,
     (tab_origin, tab_shift): (f64, f64),
     advance: f64,
@@ -1046,7 +1099,8 @@ fn tab_glyph<'p>(
     if !sg.get(glyph_index).is_some_and(|g| g.len > 0) {
         return (advance, "");
     }
-    let (advance, leader) = tab_advance(&paragraph.para.tabs, tab_origin, x - tab_shift, sg.get(glyph_index + 1..line.trimmed).unwrap_or_default());
+    let rest = line.order.iter().skip(order_index + 1).map(|&offset| line.index + offset).filter(|&j| j < line.trimmed).filter_map(|j| sg.get(j));
+    let (advance, leader) = tab_advance(&paragraph.para.tabs, tab_origin, x - tab_shift, rest);
     if justification.last_tab != Some(glyph_index) {
         return (advance, leader);
     }
@@ -1059,6 +1113,42 @@ fn tab_glyph<'p>(
     ((line.ax1 + line.opt_r - rest - x).max(0.0), leader)
 }
 
+/// Emit `glyph` of a line placed by `transform` at `origin` with `advance` along the line, its
+/// Insert Aki before it `aki` and the glyph scaling a justified line adds to it `scale`. A warichu
+/// glyph is drawn at its place in its block instead: the block starts where the first of its glyphs
+/// drawn on the line is placed (`blocks` holds the byte naming each block of the line and where it
+/// starts, kept when the bidi order draws another block's glyphs between two of its own), and the
+/// glyph sits on the baseline of its block line, measured from where Character Alignment sets the
+/// block on the line (`origin`), with its own advance for the caret, selection and hit testing.
+fn emit_line_glyph(
+    cx: &mut Ctx<'_>,
+    glyph: &SGlyph,
+    (transform, origin, advance): (Affine, Point, f64),
+    blocks: &mut Vec<(usize, f64)>,
+    line_index: usize,
+    (aki, scale): (f64, f64),
+) {
+    let Some(w) = glyph.wari else {
+        cx.emit(glyph, transform, origin, 0.0, advance, line_index);
+        // Its own width starts where the glyph is drawn, with the Aki kept at its width.
+        let own_shift = cx.own_width_shift(glyph, aki);
+        if let Some(out) = cx.out.glyphs.last_mut() {
+            out.scale = scale;
+            out.width_start += own_shift;
+        }
+        return;
+    };
+    let start = match blocks.iter().find(|(byte, _)| *byte == w.start) {
+        Some(&(_, at)) => at,
+        None => {
+            blocks.push((w.start, origin.x));
+            origin.x
+        }
+    };
+    let at = Point::new(start + w.along, origin.y + w.across);
+    cx.emit(glyph, Affine::translate(at.to_vec2()), at, 0.0, w.advance, line_index);
+}
+
 /// Lay out `line` of `paragraph` as `justification` aligns it: each glyph placed along the
 /// baseline (tabs as [`tab_glyph`] sets them), its hyphen, and the line's record, then the pen
 /// moved on past it.
@@ -1078,18 +1168,21 @@ fn emit_flow_line(cx: &mut Ctx<'_>, pen: &mut Pen<'_>, paragraph: &ParagraphData
     let line_em = sg.get(index..position.end).map_or(0.0, |glyphs| glyphs.iter().map(glyph_em).fold(0.0, f64::max));
     // Tab stops are measured from the frame's left edge (point type: the origin).
     let tab_origin = if paragraph.regions.is_some() { position.x0 } else { 0.0 };
-    // A line with tabs is measured as if it started at the left (see `set_width`), then
+    // A line with tabs is measured as if it started at the left (see `drawn_width`), then
     // aligned as a whole: its tabs stop where they were measured, however it is aligned.
     let tab_shift = start_x - if paragraph.regions.is_some() { ax0 } else { position.ind_l };
     // RTL's logical trailing spaces precede the visible content. Keep them outside
-    // the aligned content extent, just as LTR trailing spaces extend to its right.
-    let leading_space_width: f64 =
-        order.iter().take_while(|&&offset| index + offset >= trimmed).filter_map(|&offset| sg.get(index + offset)).map(|glyph| glyph.adv).sum();
+    // the aligned content extent, just as LTR trailing spaces extend to its right. A tab among
+    // them keeps its own width.
+    let leading = order.iter().take_while(|&&offset| index + offset >= trimmed).count();
+    let leading_space_width: f64 = order.iter().take(leading).filter_map(|&offset| sg.get(index + offset)).map(|glyph| glyph.adv).sum();
     let mut x = start_x - leading_space_width;
     let mut x_end = start_x;
     // The glyphs drawn for the list marker, and the index of its tab's glyph, when the line starts the paragraph.
     let mut marker_glyphs: Option<Range<usize>> = None;
     let mut marker_tab = 0;
+    // The warichu blocks drawn on the line: the byte that names each and where it starts.
+    let mut wari_blocks: Vec<(usize, f64)> = Vec::new();
     for (order_index, &offset) in order.iter().enumerate() {
         let glyph_index = index + offset;
         let Some(glyph) = sg.get(glyph_index) else { continue };
@@ -1100,8 +1193,8 @@ fn emit_flow_line(cx: &mut Ctx<'_>, pen: &mut Pen<'_>, paragraph: &ParagraphData
         // Glyph scaling a justified line adds to the glyph (1: none).
         let mut scale = 1.0;
         let mut leader = "";
-        if glyph.ch == '\t' {
-            (advance, leader) = tab_glyph(paragraph, line, justification, glyph_index, x, (tab_origin, tab_shift), advance);
+        if glyph.ch == '\t' && order_index >= leading {
+            (advance, leader) = tab_glyph(paragraph, line, justification, (glyph_index, order_index), x, (tab_origin, tab_shift), advance);
         } else if glyph_index < body && !is_tab_fixed(&justification.fixed, index, glyph_index) {
             let flex = flow_line_flex(glyph_index, &paragraph.flex, &line.held, &line.hung);
             if is_word_space(glyph) {
@@ -1141,13 +1234,8 @@ fn emit_flow_line(cx: &mut Ctx<'_>, pen: &mut Pen<'_>, paragraph: &ParagraphData
                 marker_tab = at;
             }
         }
-        cx.emit(glyph, transform, Point::new(x, y), 0.0, advance, line_index);
-        // Its own width starts where the glyph is drawn, with the Aki kept at its width.
-        let own_shift = cx.own_width_shift(glyph, aki);
-        if let Some(out) = cx.out.glyphs.last_mut() {
-            out.scale = paragraph.flex.get(glyph_index).map_or(1.0, |flex| flex.scale) * scale;
-            out.width_start += own_shift;
-        }
+        let glyph_scale = paragraph.flex.get(glyph_index).map_or(1.0, |flex| flex.scale) * scale;
+        emit_line_glyph(cx, glyph, (transform, Point::new(x, y), advance), &mut wari_blocks, line_index, (aki, glyph_scale));
         if !leader.is_empty() {
             // The leader belongs to the tab's glyph: the gap stays one character for the
             // caret, selection and hit testing.
diff --git a/crates/text/src/layout/on_path.rs b/crates/text/src/layout/on_path.rs
index de0272cb44..d119f5d780 100644
--- a/crates/text/src/layout/on_path.rs
+++ b/crates/text/src/layout/on_path.rs
@@ -7,6 +7,7 @@ use super::{
     SGlyph, Shape, TextObject, Vec2, style_metrics,
 };
 use crate::fontdb::PathAlignHeights;
+use unicode_bidi::{BidiClass, BidiInfo};
 
 /// The distance along type on a path each glyph takes: its advance measured `spacing` points above
 /// the path (Type on a Path Options › Spacing), so glyphs close up round the outside of a curve and
@@ -132,6 +133,253 @@ fn bend_outline(outline: &BezPath, pre: Affine, ap: &ArcPath, bend: &GlyphBend)
         .then_some(out)
 }
 
+/// Glyphs in a row, each taking its step: how far the row takes the line (`sum`), and how far past
+/// where its first glyph starts the farthest of their ends is (`far`).
+#[derive(Clone, Copy)]
+struct Reach {
+    sum: f64,
+    far: f64,
+}
+
+impl Reach {
+    /// No glyphs.
+    const NONE: Self = Self { sum: 0.0, far: f64::NEG_INFINITY };
+
+    /// One glyph.
+    fn step(step: f64) -> Self {
+        Self { sum: step, far: step }
+    }
+
+    /// The glyphs of `self` followed by those of `next`.
+    fn then(self, next: Self) -> Self {
+        Self { sum: self.sum + next.sum, far: self.far.max(self.sum + next.far) }
+    }
+}
+
+/// The reach of the glyphs at some of `n` positions in a row (a segment tree): a glyph is put at
+/// its position in O(log n), and the reach of the glyphs in a range of positions is found in O(log n).
+struct Reaches {
+    size: usize,
+    nodes: Vec<Reach>,
+}
+
+impl Reaches {
+    fn new(n: usize) -> Self {
+        let size = n.next_power_of_two();
+        Self { size, nodes: vec![Reach::NONE; 2 * size] }
+    }
+
+    fn node(&self, k: usize) -> Reach {
+        self.nodes.get(k).copied().unwrap_or(Reach::NONE)
+    }
+
+    /// Puts a glyph that takes `step` at position `at`.
+    fn put(&mut self, at: usize, step: f64) {
+        let mut k = self.size + at;
+        let Some(leaf) = self.nodes.get_mut(k) else { return };
+        *leaf = Reach::step(step);
+        while k > 1 {
+            k /= 2;
+            let joined = self.node(2 * k).then(self.node(2 * k + 1));
+            if let Some(node) = self.nodes.get_mut(k) {
+                *node = joined;
+            }
+        }
+    }
+
+    /// The reach of the glyphs put at positions `range`, in order.
+    fn of(&self, range: Range<usize>) -> Reach {
+        let (mut left, mut right) = (Reach::NONE, Reach::NONE);
+        let (mut a, mut b) = (range.start.min(self.size) + self.size, range.end.min(self.size) + self.size);
+        while a < b {
+            if a % 2 == 1 {
+                left = left.then(self.node(a));
+                a += 1;
+            }
+            if b % 2 == 1 {
+                b -= 1;
+                right = self.node(b).then(right);
+            }
+            (a, b) = (a / 2, b / 2);
+        }
+        left.then(right)
+    }
+}
+
+/// Whether a glyph whose character has bidi class `class` goes to its paragraph's level when the
+/// line ends with it and the characters after it like it (UAX #9 L1): whitespace and isolate
+/// controls, and the embedding controls and boundary neutrals, which `unicode_bidi` treats the same.
+fn trails(class: BidiClass) -> bool {
+    use unicode_bidi::BidiClass::{BN, FSI, LRE, LRI, LRO, PDF, PDI, RLE, RLI, RLO, WS};
+    matches!(class, WS | FSI | LRI | RLI | PDI | RLE | LRE | RLO | LRO | PDF | BN)
+}
+
+/// Measures every start of the text in reading order, shortest first, in O(n log n) for n glyphs:
+/// `visit(end, reach)` gets the byte each start ends at (a glyph's byte; the whole text is not
+/// visited) and the reach of its glyphs in its own visual order when each glyph `g` takes `step(g)`.
+///
+/// The visual order of a start of a paragraph keeps the order its glyphs have in the whole
+/// paragraph (UAX #9 L2 reorders by the levels between two glyphs only), except for the glyphs
+/// that L1 sets to the paragraph's level at the end of the start: those come after the rest in a
+/// left-to-right paragraph and before it, last first, in a right-to-left one. The glyphs are put at
+/// their positions in the whole text's visual order one start after another.
+fn each_start(shaped: &[(Range<usize>, Option<BidiInfo<'_>>, Vec<SGlyph>)], step: impl Fn(&SGlyph) -> f64, mut visit: impl FnMut(usize, Reach)) {
+    let total = shaped.iter().map(|(_, _, glyphs)| glyphs.len()).sum();
+    let mut reaches = Reaches::new(total);
+    let mut last_byte = None;
+    let mut para_at = 0;
+    for (pr, bidi, glyphs) in shaped {
+        // Where each glyph of the paragraph is in the whole text's visual order.
+        let mut at = vec![para_at; glyphs.len()];
+        for (v, i) in visual_order(bidi.as_ref(), pr.start, pr.clone(), glyphs).into_iter().enumerate() {
+            if let Some(p) = at.get_mut(i) {
+                *p = para_at + v;
+            }
+        }
+        let para_rtl = bidi.as_ref().and_then(|b| b.paragraphs.first()).map(|p| p.level.is_rtl());
+        // The glyphs at the end of the start so far that L1 sets to the paragraph's level, their
+        // reach in visual order, and the reach of the cluster being added to them.
+        let mut held: Vec<(usize, f64)> = Vec::new();
+        let (mut trailing, mut cluster) = (Reach::NONE, Reach::NONE);
+        let mut prev: Option<&SGlyph> = None;
+        for (g, &p) in glyphs.iter().zip(&at) {
+            // A cluster is a glyph and those after it at its byte (a list marker's apart).
+            let joins = prev.is_some_and(|q| q.byte == g.byte && (q.len == 0) == (g.len == 0));
+            if !joins {
+                trailing = match para_rtl {
+                    Some(true) => cluster.then(trailing),
+                    _ => trailing.then(cluster),
+                };
+                cluster = Reach::NONE;
+            }
+            if last_byte != Some(g.byte) {
+                // The start that ends before this glyph.
+                let reach = match para_rtl {
+                    _ if held.is_empty() => reaches.of(0..total),
+                    Some(true) => reaches.of(0..para_at).then(trailing).then(reaches.of(para_at..total)),
+                    _ => reaches.of(0..total).then(trailing),
+                };
+                visit(g.byte, reach);
+                last_byte = Some(g.byte);
+            }
+            let s = step(g);
+            // Every character of the glyph's cluster is one that trails.
+            let from = g.byte.saturating_sub(pr.start);
+            let classes = bidi.as_ref().and_then(|b| b.original_classes.get(from..from + g.len));
+            if para_rtl.is_some() && g.len > 0 && classes.is_some_and(|c| c.iter().copied().all(trails)) {
+                held.push((p, s));
+                cluster = cluster.then(Reach::step(s));
+            } else {
+                for (q, s) in held.drain(..) {
+                    reaches.put(q, s);
+                }
+                (trailing, cluster) = (Reach::NONE, Reach::NONE);
+                reaches.put(p, s);
+            }
+            prev = Some(g);
+        }
+        // The whole paragraph is in its own visual order.
+        for (q, s) in held.drain(..) {
+            reaches.put(q, s);
+        }
+        para_at += glyphs.len();
+    }
+}
+
+/// The end (a byte) of the longest start of the text, in reading order, whose glyphs fit when each
+/// takes its advance: `fits(w, far)` says whether glyphs in visual order that take `w` along the
+/// path, the farthest of their ends `far` past where the first starts, fit. `first` is the first
+/// glyph's byte, where nothing is laid out. A start can fit where a shorter one doesn't, after a
+/// glyph that takes the line back, so every start is measured ([`each_start`]).
+fn longest_fitting_start(shaped: &[(Range<usize>, Option<BidiInfo<'_>>, Vec<SGlyph>)], first: usize, fits: impl Fn(f64, f64) -> bool) -> usize {
+    let mut longest = first;
+    each_start(
+        shaped,
+        |g| g.adv,
+        |byte, reach| {
+            if fits(reach.sum, reach.far) {
+                longest = byte;
+            }
+        },
+    );
+    longest
+}
+
+/// The ends (bytes) of the starts of the text, in reading order, shortest first, that can fit on a
+/// path of length `len` with `spacing`: those whose glyphs, in their own visual order, reach at most
+/// `len` past where the first starts when each takes the least step it can. A glyph's step is at
+/// least a quarter of its advance with spacing, and its advance otherwise ([`path_steps`]); a line
+/// starts no earlier than its span with the hang at its start, and every glyph that fits ends within
+/// that span with both hangs, which is no longer than the path. The start before the first glyph,
+/// where nothing is laid out, is always one of them.
+fn starts_that_can_fit(shaped: &[(Range<usize>, Option<BidiInfo<'_>>, Vec<SGlyph>)], spacing: f64, len: f64) -> Vec<usize> {
+    let least = |g: &SGlyph| if spacing != 0.0 && g.adv > 1e-9 { g.adv * 0.25 } else { g.adv };
+    let mut starts = Vec::new();
+    each_start(shaped, least, |byte, reach| {
+        // A little room for sums added in another order than where the glyphs are placed.
+        if reach.far <= len + 1e-5 || reach.far.is_nan() {
+            starts.push(byte);
+        }
+    });
+    starts
+}
+
+/// The most starts of overflowing right-to-left type on a path that are arranged one by one, from
+/// the longest, when a glyph takes the line back ([`longest_start_tried`]).
+const PATH_START_TRIES: usize = 32;
+
+/// The longest of `starts` (ends of starts, shortest first, the first of which fits) for which
+/// `fits` holds, arranging at most `tries` of them one by one, from the longest. When none of those
+/// fits, a binary search among the rest finds one that fits with O(log n) more arrangements; as a
+/// longer start can fit where a shorter one doesn't, that one is not always the longest that fits.
+/// `None` when there are no starts.
+fn longest_start_tried(starts: &[usize], tries: usize, mut fits: impl FnMut(usize) -> bool) -> Option<usize> {
+    let rest = starts.len().saturating_sub(tries);
+    if let Some(&byte) = starts.get(rest..).unwrap_or_default().iter().rev().find(|&&byte| fits(byte)) {
+        return Some(byte);
+    }
+    // `starts[fit]` fits; `starts[over]` was tried or doesn't.
+    let (mut fit, mut over) = (0, rest);
+    while over > fit + 1 {
+        let mid = fit + (over - fit) / 2;
+        if starts.get(mid).is_some_and(|&byte| fits(byte)) {
+            fit = mid;
+        } else {
+            over = mid;
+        }
+    }
+    starts.get(fit).copied()
+}
+
+#[cfg(test)]
+thread_local! {
+    /// How many times type on a path arranged glyphs on its path on this thread ([`path_arrangements`]).
+    static ARRANGEMENTS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+/// How many times type on a path arranged glyphs on its path on this thread.
+#[cfg(test)]
+pub(crate) fn path_arrangements() -> usize {
+    ARRANGEMENTS.get()
+}
+
+#[cfg(test)]
+thread_local! {
+    /// Set while [`layout_trying_each_start`] lays text out.
+    static EACH_START: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
+}
+
+/// [`layout`](super::layout) arranging every start of overflowing right-to-left type on a path in
+/// turn, from the longest, until one fits: the reference the search for the longest start is
+/// compared with.
+#[cfg(test)]
+pub(crate) fn layout_trying_each_start(db: &crate::fontdb::FontDb, t: &TextObject) -> crate::TextLayout {
+    EACH_START.set(true);
+    let l = super::layout(db, t);
+    EACH_START.set(false);
+    l
+}
+
 /// Lay type on a path out along `path` (text space), between its brackets.
 pub(super) fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, path: &PathData) {
     cx.out.on_path = true;
@@ -247,29 +495,33 @@ pub(super) fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject,
         };
         (l, r, hung_r)
     };
+    // Where a line that takes `w` along the path starts, aligned in the span with the hangs.
+    let align = |w: f64, (l, r, _): (f64, f64, usize)| {
+        let (lo, room) = (s_start - l, avail + l + r);
+        match para.justify {
+            Justify::Auto if rtl => lo + (room - w).max(0.0),
+            Justify::Center | Justify::JustifyCenter => lo + ((room - w) * 0.5).max(0.0),
+            Justify::Right | Justify::JustifyRight => lo + (room - w).max(0.0),
+            _ => lo,
+        }
+    };
     // The glyphs `sg` arranged on the path: their steps, where the first starts, and the hangs.
     let arrange = |sg: &[SGlyph]| {
+        #[cfg(test)]
+        ARRANGEMENTS.set(ARRANGEMENTS.get() + 1);
         let mut steps = path_steps(&ap, sg, s_start, spacing);
-        let w: f64 = steps.iter().sum();
-        let place = |(l, r, _): (f64, f64, usize)| {
-            let (lo, room) = (s_start - l, avail + l + r);
-            match para.justify {
-                Justify::Auto if rtl => lo + (room - w).max(0.0),
-                Justify::Center | Justify::JustifyCenter => lo + ((room - w) * 0.5).max(0.0),
-                Justify::Right | Justify::JustifyRight => lo + (room - w).max(0.0),
-                _ => lo,
-            }
-        };
+        // Where the line starts when its glyphs take `steps`.
+        let place = |steps: &[f64], hung| align(steps.iter().sum(), hung);
         let mut hung = hangs(sg, &steps);
-        let mut s0 = place(hung);
+        let mut s0 = place(&steps, hung);
         if spacing != 0.0 && s0 != s_start {
             // Spaced from where the alignment puts them, the curve under them is another. That
-            // changes the hanging glyphs' steps, so the line is placed again from the new steps
-            // until it stays where it is (at most 8 times).
+            // changes the glyphs' steps, so what the line takes and what hangs, and the line is
+            // placed again from the new steps until it stays where it is (at most 8 times).
             steps = path_steps(&ap, sg, s0, spacing);
             for _ in 0..8 {
                 hung = hangs(sg, &steps);
-                let moved = place(hung);
+                let moved = place(&steps, hung);
                 if (moved - s0).abs() < 1e-9 {
                     break;
                 }
@@ -303,23 +555,47 @@ pub(super) fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject,
     // Right-to-left text that overflows keeps the start of its text, not what comes first in visual
     // order: the longest start, in reading order, whose glyphs fit in visual order is laid out.
     if shaped.iter().any(|(_, bidi, _)| bidi.is_some()) && fitting(&steps, s0, hung) < sg.len() {
-        let mut starts: Vec<usize> = shaped.iter().flat_map(|(_, _, glyphs)| glyphs.iter().map(|g| g.byte)).collect();
-        starts.dedup();
-        // The text before `starts[fit]` fits; before `starts[over]` (the whole text at the end) it
-        // doesn't.
-        let (mut fit, mut over) = (0, starts.len());
-        while over - fit > 1 {
-            let mid = (fit + over) / 2;
-            let sg = visual(starts.get(mid).copied().unwrap_or(text_len));
+        // Whether the text before byte `cut` fits, arranged as it would be laid out.
+        let fits_before = |cut: usize| {
+            let sg = visual(cut);
             let (steps, s0, hung) = arrange(&sg);
-            if fitting(&steps, s0, hung) == sg.len() {
-                fit = mid;
-            } else {
-                over = mid;
+            fitting(&steps, s0, hung) == sg.len()
+        };
+        // The byte at which each start of the text ends, in reading order.
+        let mut starts: Vec<usize> = shaped.iter().flat_map(|(_, _, glyphs)| glyphs).map(|g| g.byte).collect();
+        starts.dedup();
+        let first = starts.first().copied().unwrap_or(text_len);
+        // On one straight segment the path doesn't turn, so spacing changes no step.
+        let straight = matches!(path.to_bezpath().elements(), [PathEl::MoveTo(_), PathEl::LineTo(_)]);
+        #[cfg(test)]
+        let each_start = EACH_START.get();
+        #[cfg(not(test))]
+        let each_start = false;
+        fits = if each_start {
+            starts.iter().rev().copied().find(|&byte| fits_before(byte)).unwrap_or(first)
+        } else if (spacing == 0.0 || straight) && !hanging {
+            // Each glyph takes its advance wherever the line is placed.
+            longest_fitting_start(&shaped, first, |w, far| align(w, (0.0, 0.0, 0)) - s_start + far <= avail + 1e-6)
+        } else if sg.iter().all(|g| g.adv >= 0.0) {
+            // No glyph takes the line back: a start fits when a longer one does. The text before
+            // `starts[fit]` fits; before `starts[over]` (the whole text at the end) it doesn't.
+            let (mut fit, mut over) = (0, starts.len());
+            while over - fit > 1 {
+                let mid = (fit + over) / 2;
+                if fits_before(starts.get(mid).copied().unwrap_or(text_len)) {
+                    fit = mid;
+                } else {
+                    over = mid;
+                }
             }
-        }
+            starts.get(fit).copied().unwrap_or(text_len)
+        } else {
+            // A glyph that takes the line back can make a start fit where a shorter one doesn't:
+            // the starts that can fit the path however their glyphs are spaced are tried from the
+            // longest, at most `PATH_START_TRIES` of them before a binary search over the rest.
+            longest_start_tried(&starts_that_can_fit(&shaped, spacing, ap.len()), PATH_START_TRIES, &fits_before).unwrap_or(first)
+        };
         cx.out.overflow = true;
-        fits = starts.get(fit).copied().unwrap_or(text_len);
         sg = visual(fits);
         (steps, s0, hung) = arrange(&sg);
     }
@@ -432,3 +708,33 @@ pub(super) fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject,
         region: 0,
     });
 }
+
+#[cfg(test)]
+mod tests {
+    use super::longest_start_tried;
+
+    /// The longest start that fits is found among the ones tried; past the tries, a binary search
+    /// finds one that fits, with as many more tries as halvings of the rest.
+    #[test]
+    fn starts_are_tried_from_the_longest_then_searched() {
+        let starts: Vec<usize> = (0..1000).collect();
+        // Every start up to 600 fits, and so does 990.
+        let fits = |byte: usize| byte <= 600 || byte == 990;
+        let mut tried = 0;
+        let found = longest_start_tried(&starts, 32, |byte| {
+            tried += 1;
+            fits(byte)
+        });
+        assert_eq!((found, tried), (Some(990), 10));
+        tried = 0;
+        let found = longest_start_tried(&starts, 8, |byte| {
+            tried += 1;
+            fits(byte)
+        });
+        assert_eq!(found, Some(600));
+        assert!(tried <= 8 + 10, "{tried} tries");
+        // With fewer starts than tries, each is tried.
+        assert_eq!(longest_start_tried(&starts[..5], 32, |byte| byte == 0), Some(0));
+        assert_eq!(longest_start_tried(&[], 32, |_| true), None);
+    }
+}
diff --git a/crates/text/src/layout/region.rs b/crates/text/src/layout/region.rs
index d7293c1109..530dd2554c 100644
--- a/crates/text/src/layout/region.rs
+++ b/crates/text/src/layout/region.rs
@@ -166,20 +166,36 @@ fn subtract_intervals(a: &[(f64, f64)], b: &[(f64, f64)]) -> Vec<(f64, f64)> {
     out
 }
 
-/// `a` ∩ `b`.
+/// `a` ∩ `b` (both sorted left to right, each interval starting no earlier than the one before it
+/// ends, as [`union_intervals`] and [`band_intervals`] give them), left to right. It walks both
+/// lists once, stepping past whichever current interval ends first (both
+/// when they end together), so it looks at no more than `a.len() + b.len()` pairs.
 fn intersect_intervals(a: &[(f64, f64)], b: &[(f64, f64)]) -> Vec<(f64, f64)> {
     let mut out = vec![];
-    for &(s, e) in a {
-        for &(c, d) in b {
-            let (x, y) = (s.max(c), e.min(d));
-            if y > x {
-                out.push((x, y));
-            }
+    let (mut i, mut j) = (0, 0);
+    while let (Some(&(s, e)), Some(&(c, d))) = (a.get(i), b.get(j)) {
+        #[cfg(test)]
+        INTERSECT_PAIRS.set(INTERSECT_PAIRS.get() + 1);
+        let (x, y) = (s.max(c), e.min(d));
+        if y > x {
+            out.push((x, y));
+        }
+        // Ends that are equal, or not numbers, step past both, so the walk always ends.
+        match e.partial_cmp(&d) {
+            Some(std::cmp::Ordering::Less) => i += 1,
+            Some(std::cmp::Ordering::Greater) => j += 1,
+            _ => (i, j) = (i + 1, j + 1),
         }
     }
     out
 }
 
+#[cfg(test)]
+thread_local! {
+    /// How many pairs of intervals [`intersect_intervals`] looked at on this thread.
+    static INTERSECT_PAIRS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
 /// The most pairs of edges [`slant_boundaries`] compares for one band.
 const MAX_EDGE_PAIRS: usize = 1 << 14;
 
@@ -368,6 +384,80 @@ fn band_boundaries(polys: &[Vec<Point>], top: f64, bottom: f64) -> (Vec<(f64, f6
     (union_intervals(edges), paired)
 }
 
+/// The largest magnitude a text wrap offset may have (points), the bound the Text Wrap commands
+/// and `.ai` import keep too.
+const MAX_WRAP_OFFSET: f64 = 1000.0;
+
+/// A wrap object's offset as layout uses it: within [`MAX_WRAP_OFFSET`] either way, and 0 when it
+/// is not a number.
+fn wrap_offset(offset: f64) -> f64 {
+    if offset.is_nan() { 0.0 } else { offset.clamp(-MAX_WRAP_OFFSET, MAX_WRAP_OFFSET) }
+}
+
+/// The x at which some point of the band `top..bottom` (`top <= bottom`) is inside `polys`
+/// (even-odd) and farther than `d` (> 0) from every edge of it, holes included: the cover of the
+/// shape shrunk by `d`. The band is cut into pieces (at most [`INVERT_WRAP_PIECES`] even ones, and
+/// at every anchor's height and `d` above and below it when there are at most that many of those);
+/// in each piece, an x is left out when the shape is nowhere in the piece there, or when the whole
+/// piece there lies within `d` of one edge. A piece where several edges together cover it keeps
+/// its x, so the result can be wider than the shrunk shape, never narrower, and never wider than
+/// the shape's own cover of the band.
+fn eroded_cover(polys: &[Vec<Point>], top: f64, bottom: f64, d: f64) -> Vec<(f64, f64)> {
+    // A point `d` from an edge, up to rounding, counts as near it, so a band that only touches the
+    // shrunk shape is left whole.
+    let r = d * (1.0 + 1e-12);
+    let span = |p: &[Point]| p.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), q| (lo.min(q.y), hi.max(q.y)));
+    // The shrunk shape lies more than `d` below the shape's top and above its bottom, so a band
+    // outside that holds none of it; within it, only contours that come within `d` of the band
+    // count (the others neither cross it nor bound the shape near it).
+    let (lo, hi) = polys.iter().map(|p| span(p)).fold((f64::INFINITY, f64::NEG_INFINITY), |(a, b), (c, e)| (a.min(c), b.max(e)));
+    if bottom <= lo + r || top >= hi - r {
+        return vec![];
+    }
+    let near_band: Vec<Vec<Point>> = polys
+        .iter()
+        .filter(|p| {
+            let (lo, hi) = span(p);
+            hi >= top - r && lo <= bottom + r
+        })
+        .cloned()
+        .collect();
+    let polys = near_band.as_slice();
+    let pieces = ((bottom - top) * 4.0 / d).ceil().clamp(1.0, INVERT_WRAP_PIECES);
+    let mut cuts: Vec<f64> = (0..=pieces as usize).map(|k| top + (bottom - top) * k as f64 / pieces).collect();
+    if bottom > top {
+        let mut anchors: Vec<f64> = polys.iter().flatten().flat_map(|p| [p.y - d, p.y, p.y + d]).filter(|&y| y > top && y < bottom).collect();
+        anchors.sort_by(f64::total_cmp);
+        anchors.dedup();
+        if anchors.len() <= INVERT_WRAP_PIECES as usize {
+            cuts.extend(anchors);
+            cuts.sort_by(f64::total_cmp);
+            cuts.dedup();
+        }
+    }
+    let mut out = Vec::new();
+    // A band of no height keeps its two equal cuts: one piece of no height, measured at its y.
+    for w in cuts.windows(2) {
+        let (a, b) = (w[0], w[1]);
+        let cover = band_cover(polys, a, b, false);
+        if cover.is_empty() {
+            continue;
+        }
+        // The points closer than `d` to an edge make a convex shape, so a vertical line within
+        // the piece lies in it when both its ends do.
+        let near = polys.iter().flat_map(|p| {
+            (0..p.len()).filter_map(move |i| {
+                let (s, t) = (p[i], p[(i + 1) % p.len()]);
+                let (u, v) = (near_segment(s, t, a, r)?, near_segment(s, t, b, r)?);
+                let (x, y) = (u.0.max(v.0), u.1.min(v.1));
+                (y > x).then_some((x, y))
+            })
+        });
+        out.extend(subtract_intervals(&cover, &union_intervals(near.collect())));
+    }
+    union_intervals(out)
+}
+
 impl Region {
     pub(super) fn cells(path: &BezPath, opts: &LayoutOptions, wrap: &[vectorcraft_doc::WrapShape]) -> Vec<Region> {
         // A frame out of range has no cells, and a wrap shape out of range is left out.
@@ -376,7 +466,7 @@ impl Region {
         let polys: std::sync::Arc<[Vec<Point>]> = polys.into();
         let wraps: std::sync::Arc<[FlatWrap]> = wrap
             .iter()
-            .filter_map(|w| Some((polygons(&w.path.to_bezpath())?, w.wrap.offset.max(0.0), w.wrap.invert)))
+            .filter_map(|w| Some((polygons(&w.path.to_bezpath())?, wrap_offset(w.wrap.offset), w.wrap.invert)))
             .filter(|w| !w.0.is_empty())
             .collect();
         let bbox = path.bounding_box();
@@ -415,8 +505,10 @@ impl Region {
     }
 
     /// `iv` minus every x at which a wrap object lies somewhere in the band `top..bottom` (or the x
-    /// inside it over the whole band, for Invert Wrap). Offsets grow each wrap shape vertically
-    /// and horizontally. Along the line, the text also keeps the inset beside each wrap object
+    /// inside it over the whole band, for Invert Wrap). A positive offset grows each wrap shape
+    /// vertically and horizontally; a negative one shrinks it by that distance from its edges
+    /// (holes included), so text runs that far into the object, or stays that far inside it for
+    /// Invert Wrap. Along the line, the text also keeps the inset beside each wrap object
     /// (outside it, or inside it for Invert Wrap); above and below a wrap object only its offset
     /// applies.
     fn wrapped(&self, mut iv: Vec<(f64, f64)>, top: f64, bottom: f64) -> Vec<(f64, f64)> {
@@ -428,7 +520,17 @@ impl Region {
             }
             let grow = |v: Vec<(f64, f64)>| union_intervals(v.into_iter().map(|(a, b)| (a - off, b + off)).collect());
             let shrink = |v: Vec<(f64, f64)>| v.into_iter().map(|(a, b)| (a + inset, b - inset)).filter(|(a, b)| b > a).collect::<Vec<_>>();
-            iv = if *invert {
+            let pad = |v: Vec<(f64, f64)>| union_intervals(v.into_iter().map(|(a, b)| (a - inset, b + inset)).collect());
+            iv = if *off < 0.0 {
+                // Invert Wrap keeps the x at which the shape shrunk by the offset holds the whole
+                // band; otherwise the text leaves out the x at which the shrunk shape lies
+                // somewhere in the band.
+                if *invert {
+                    intersect_intervals(&iv, &shrink(band_inset_intervals(polys, top, bottom, -off)))
+                } else {
+                    subtract_intervals(&iv, &pad(eroded_cover(polys, top, bottom, -off)))
+                }
+            } else if *invert {
                 // The band is cut into pieces. Each height of a piece `y0..y1` is within the offset
                 // of some height from `y0` plus the offset to `y1` less the offset, so an x the
                 // shape holds at all of those heights is inside the grown shape over the piece. In
@@ -469,8 +571,7 @@ impl Region {
                 }
                 iv
             } else {
-                let w = grow(band_cover(polys, top - off, bottom + off, false));
-                subtract_intervals(&iv, &union_intervals(w.into_iter().map(|(a, b)| (a - inset, b + inset)).collect()))
+                subtract_intervals(&iv, &pad(grow(band_cover(polys, top - off, bottom + off, false))))
             };
         }
         iv
@@ -624,6 +725,94 @@ fn a_line_stays_clear_of_a_wrap_object_that_reaches_into_its_band() {
     assert_spans(&Region::cells(&frame, &LayoutOptions::default(), &[wrap])[0].spans(50.0, 50.0), &[(15.0, 45.0)]);
 }
 
+/// The spans of a 100 pt square frame over the band `top..bottom` with one wrap object through
+/// `contours` (even-odd).
+#[cfg(test)]
+fn wrap_spans(contours: &[&[(f64, f64)]], offset: f64, invert: bool, top: f64, bottom: f64) -> Vec<(f64, f64)> {
+    let frame = Rect::new(0.0, 0.0, 100.0, 100.0).to_path(0.1);
+    let wrap = vectorcraft_doc::WrapShape { path: PathData::from_bezpath(&closed(contours)), wrap: vectorcraft_doc::TextWrap { offset, invert } };
+    Region::cells(&frame, &LayoutOptions::default(), &[wrap])[0].spans(top, bottom)
+}
+
+/// A negative offset lets text run into a wrap object by that distance, across and along the
+/// line: beside a square, the line reaches 5 pt into it, and a line whose band reaches no more than
+/// 5 pt into its top or bottom runs across it.
+#[cfg(test)]
+#[test]
+fn negative_wrap_offset_insets_rectangle_on_both_axes() {
+    let square: &[(f64, f64)] = &[(40.0, 40.0), (60.0, 40.0), (60.0, 60.0), (40.0, 60.0)];
+    assert_spans(&wrap_spans(&[square], -5.0, false, 44.0, 50.0), &[(0.0, 45.0), (55.0, 100.0)]);
+    assert_spans(&wrap_spans(&[square], -5.0, false, 30.0, 45.0), &[(0.0, 100.0)]);
+    assert_spans(&wrap_spans(&[square], -5.0, false, 55.0, 70.0), &[(0.0, 100.0)]);
+    assert_spans(&wrap_spans(&[square], -5.0, false, 30.0, 46.0), &[(0.0, 45.0), (55.0, 100.0)]);
+    // The most an offset may take away is 1000 pt, and an offset that is not a number is 0.
+    assert_spans(&wrap_spans(&[square], f64::NEG_INFINITY, false, 44.0, 50.0), &[(0.0, 100.0)]);
+    assert_spans(&wrap_spans(&[square], f64::NAN, false, 44.0, 50.0), &[(0.0, 40.0), (60.0, 100.0)]);
+}
+
+/// A negative offset is measured from a sloped edge itself (10 pt across the edge of a triangle is
+/// 10√2 pt along the line), and from the edges of a hole too.
+#[cfg(test)]
+#[test]
+fn negative_wrap_offset_insets_sloped_shape_and_hole() {
+    let triangle: &[(f64, f64)] = &[(0.0, 0.0), (100.0, 100.0), (0.0, 100.0)];
+    assert_spans(&wrap_spans(&[triangle], -10.0, false, 40.0, 60.0), &[(0.0, 10.0), (60.0 - 10.0 * std::f64::consts::SQRT_2, 100.0)]);
+    let outer: &[(f64, f64)] = &[(20.0, 20.0), (80.0, 20.0), (80.0, 80.0), (20.0, 80.0)];
+    let hole: &[(f64, f64)] = &[(40.0, 40.0), (60.0, 40.0), (60.0, 60.0), (40.0, 60.0)];
+    assert_spans(&wrap_spans(&[outer, hole], -5.0, false, 48.0, 52.0), &[(0.0, 25.0), (35.0, 65.0), (75.0, 100.0)]);
+}
+
+/// With Invert Wrap, a negative offset keeps the text that far inside the object, along and across
+/// the line.
+#[cfg(test)]
+#[test]
+fn negative_invert_wrap_keeps_only_eroded_interior() {
+    let square: &[(f64, f64)] = &[(40.0, 40.0), (60.0, 40.0), (60.0, 60.0), (40.0, 60.0)];
+    assert_spans(&wrap_spans(&[square], -5.0, true, 46.0, 54.0), &[(45.0, 55.0)]);
+    assert!(wrap_spans(&[square], -5.0, true, 42.0, 48.0).is_empty());
+    let triangle: &[(f64, f64)] = &[(0.0, 0.0), (100.0, 100.0), (0.0, 100.0)];
+    assert_spans(&wrap_spans(&[triangle], -10.0, true, 40.0, 60.0), &[(10.0, 40.0 - 10.0 * std::f64::consts::SQRT_2)]);
+}
+
+/// A negative offset at least half as large as a wrap object is wide leaves nothing of it: text
+/// runs across it, and with Invert Wrap no text fits inside it.
+#[cfg(test)]
+#[test]
+fn negative_offset_erases_narrow_wrap_shape() {
+    let strip: &[(f64, f64)] = &[(40.0, 0.0), (48.0, 0.0), (48.0, 100.0), (40.0, 100.0)];
+    for offset in [-4.0, -5.0, -1000.0] {
+        assert_spans(&wrap_spans(&[strip], offset, false, 40.0, 60.0), &[(0.0, 100.0)]);
+        assert!(wrap_spans(&[strip], offset, true, 40.0, 60.0).is_empty(), "offset {offset}");
+    }
+    // A band of no height.
+    assert_spans(&wrap_spans(&[strip], -1.0, false, 50.0, 50.0), &[(0.0, 41.0), (47.0, 100.0)]);
+}
+
+/// A negative offset never keeps text farther from a wrap object than an offset of 0 does, on a
+/// shape whose edges meet at many angles.
+#[cfg(test)]
+#[test]
+fn negative_offset_never_wraps_more_than_no_offset() {
+    let star: Vec<(f64, f64)> = (0..40)
+        .map(|k| {
+            let (r, a) = (if k % 2 == 0 { 40.0 } else { 15.0 }, f64::from(k) * std::f64::consts::PI / 20.0);
+            (50.0 + r * a.cos(), 50.0 + r * a.sin())
+        })
+        .collect();
+    for (top, bottom) in [(10.0, 22.0), (44.0, 56.0), (30.0, 31.0), (70.0, 90.0)] {
+        for invert in [false, true] {
+            let zero = wrap_spans(&[star.as_slice()], 0.0, invert, top, bottom);
+            let neg = wrap_spans(&[star.as_slice()], -3.0, invert, top, bottom);
+            let width = |v: &[(f64, f64)]| v.iter().map(|(a, b)| b - a).sum::<f64>();
+            if invert {
+                assert!(width(&neg) <= width(&zero) + 1e-9, "{top}..{bottom}: {neg:?} {zero:?}");
+            } else {
+                assert!(width(&neg) >= width(&zero) - 1e-9, "{top}..{bottom}: {neg:?} {zero:?}");
+            }
+        }
+    }
+}
+
 /// A hole that starts and ends inside a line's band splits the line, and a band below the hole, or
 /// one that only touches it, keeps the whole width.
 #[cfg(test)]
@@ -792,6 +981,80 @@ fn an_inset_wider_than_a_shaped_frame_leaves_no_room() {
     }
 }
 
+/// `a` ∩ `b` by comparing every interval of `a` with every interval of `b`: the result
+/// [`intersect_intervals`] is checked against.
+#[cfg(test)]
+fn intersect_every_pair(a: &[(f64, f64)], b: &[(f64, f64)]) -> Vec<(f64, f64)> {
+    a.iter().flat_map(|&(s, e)| b.iter().map(move |&(c, d)| (s.max(c), e.min(d)))).filter(|(x, y)| y > x).collect()
+}
+
+/// The intersection of two lists of intervals, each sorted with no two overlapping, is the one
+/// every pair of their intervals gives, in the same order, left to right and of positive width, for
+/// every pair of such lists whose ends are among the points 0 to 6: empty lists, intervals that
+/// only touch (in one list or across the two), that end together, that hold one another and that
+/// overlap several others.
+#[cfg(test)]
+#[test]
+fn intervals_intersect_as_every_pair_of_them_does() {
+    // Every list is a shorter list with one more interval after its last.
+    let mut lists: Vec<Vec<(f64, f64)>> = vec![vec![]];
+    let mut k = 0;
+    while let Some(list) = lists.get(k).cloned() {
+        let from = list.last().map_or(0, |l: &(f64, f64)| l.1 as u8);
+        for s in from..6 {
+            for e in s + 1..=6 {
+                let mut next = list.clone();
+                next.push((f64::from(s), f64::from(e)));
+                lists.push(next);
+            }
+        }
+        k += 1;
+    }
+    assert_eq!(lists.len(), 233);
+    for a in &lists {
+        for b in &lists {
+            let got = intersect_intervals(a, b);
+            assert_eq!(got, intersect_every_pair(a, b), "{a:?} ∩ {b:?}");
+            assert!(got.iter().all(|(x, y)| y > x) && got.windows(2).all(|w| w[0].1 <= w[1].0), "{got:?}");
+        }
+    }
+}
+
+/// Intersecting two unions of 3,000 and 2,000 intervals that interleave looks at no more than
+/// 5,000 pairs of intervals, not every one of the 6,000,000 pairs.
+#[cfg(test)]
+#[test]
+fn intersecting_intervals_looks_at_each_interval_once() {
+    let a: Vec<(f64, f64)> = (0..3000).map(|i| f64::from(i) * 4.0).map(|x| (x, x + 3.0)).collect();
+    let b: Vec<(f64, f64)> = (0..2000).map(|i| f64::from(i) * 6.0).map(|x| (x + 1.0, x + 5.0)).collect();
+    INTERSECT_PAIRS.set(0);
+    let got = intersect_intervals(&a, &b);
+    assert!(INTERSECT_PAIRS.get() <= a.len() + b.len(), "{} pairs", INTERSECT_PAIRS.get());
+    assert_eq!(got, intersect_every_pair(&a, &b));
+    assert!(!got.is_empty());
+}
+
+/// A line in area type with an Invert Wrap comb of 500 teeth and an offset keeps a span inside
+/// each tooth, left to right, through every piece of its band, and intersecting the spans with each
+/// piece looks at each span once.
+#[cfg(test)]
+#[test]
+fn a_line_inside_an_invert_wrap_comb_keeps_a_span_in_each_tooth() {
+    let frame = Rect::new(0.0, 0.0, 1000.0, 100.0).to_path(0.1);
+    let teeth: Vec<Vec<(f64, f64)>> =
+        (0..500).map(|k| f64::from(k) * 2.0).map(|x| vec![(x, 0.0), (x + 1.0, 0.0), (x + 1.0, 100.0), (x, 100.0)]).collect();
+    let teeth: Vec<&[(f64, f64)]> = teeth.iter().map(Vec::as_slice).collect();
+    let path = PathData::from_bezpath(&closed(&teeth));
+    let wrap = vectorcraft_doc::WrapShape { path, wrap: vectorcraft_doc::TextWrap { offset: 0.25, invert: true } };
+    let cells = Region::cells(&frame, &LayoutOptions::default(), &[wrap]);
+    INTERSECT_PAIRS.set(0);
+    let got = cells[0].spans(40.0, 60.0);
+    let want: Vec<(f64, f64)> = (0..500).map(|k| f64::from(k) * 2.0).map(|x| ((x - 0.25).max(0.0), x + 1.25)).collect();
+    assert_spans(&got, &want);
+    // At most 64 pieces, each looking at no more than the spans so far and the tooth spans.
+    assert!(INTERSECT_PAIRS.get() <= 64 * (500 + 500), "{} pairs", INTERSECT_PAIRS.get());
+}
+
 /// Along the line, text keeps the inset beside a wrap object, around it and, with Invert Wrap,
 /// inside it.
 #[cfg(test)]
diff --git a/crates/text/src/layout/ruby.rs b/crates/text/src/layout/ruby.rs
index 34cb71f09a..9b8da39d80 100644
--- a/crates/text/src/layout/ruby.rs
+++ b/crates/text/src/layout/ruby.rs
@@ -377,5 +377,7 @@ fn ruby_glyph(g: &PositionedGlyph, m: Affine, run: usize, byte: usize, line: usi
         carets: Vec::new(),
         width: 0.0,
         width_start: 0.0,
+        warichu: None,
+        warichu_line: 0.0,
     }
 }
diff --git a/crates/text/src/layout/vertical.rs b/crates/text/src/layout/vertical.rs
index fc6b8f1f7e..30f12139a2 100644
--- a/crates/text/src/layout/vertical.rs
+++ b/crates/text/src/layout/vertical.rs
@@ -43,7 +43,8 @@ pub(super) fn whole_character_widths(glyphs: &mut [SGlyph]) {
 /// set in whole points ([`whole_character_widths`]).
 pub(super) fn tate_chu_yoko(g: &mut [SGlyph], whole: bool, style: impl Fn(&SGlyph) -> TcyStyle) {
     let manual: Vec<bool> = g.iter().map(|gl| gl.ch != '\u{2028}' && style(gl).marked).collect();
-    let digits: Vec<bool> = g.iter().map(|gl| gl.inline.is_none() && gl.ch.is_ascii_digit()).collect();
+    // Digits marked Warichu are stacked with their block, not set across the column.
+    let digits: Vec<bool> = g.iter().map(|gl| gl.inline.is_none() && gl.ch.is_ascii_digit() && !style(gl).warichu).collect();
     let mut i = 0;
     while i < g.len() {
         if manual.get(i).copied().unwrap_or(false) {
@@ -73,12 +74,14 @@ pub(super) fn tate_chu_yoko(g: &mut [SGlyph], whole: bool, style: impl Fn(&SGlyp
 }
 
 /// What [`tate_chu_yoko`] reads from a glyph's character style: its size, whether it is marked
-/// Tate-chu-yoko, and its Tate-chu-yoko Settings Up/Down and Left/Right in points.
+/// Tate-chu-yoko, its Tate-chu-yoko Settings Up/Down and Left/Right in points, and whether it is
+/// set as warichu (marked Warichu, and not on a path).
 pub(super) struct TcyStyle {
     pub size: f64,
     pub marked: bool,
     pub up: f64,
     pub right: f64,
+    pub warichu: bool,
 }
 
 /// Lay `g` across one em of the column, moved by `(up, right)` points. The first glyph takes the
@@ -116,10 +119,11 @@ fn place_tcy_block(g: &mut [SGlyph], em: f64, (up, right): (f64, f64), whole: bo
 }
 
 /// Half an em of `g`'s size when it is full-width Japanese punctuation of kind `kind` (its
-/// advance an em, give or take a tenth), the space that mojikumi can take off.
+/// advance an em, give or take a tenth), the space that mojikumi can take off. Not inside a
+/// tate-chu-yoko or warichu block, which is set as one piece.
 pub(super) fn punct_half(g: &SGlyph, kind: Punct) -> Option<f64> {
     // A glyph Proportional Metrics re-spaced has no empty half left to take off (#966).
-    if punct(g.ch)? != kind || g.tcy.is_some() || g.proportional {
+    if punct(g.ch)? != kind || g.tcy.is_some() || g.wari.is_some() || g.proportional {
         return None;
     }
     let em = g.face.units_per_em();
@@ -275,7 +279,7 @@ pub(super) fn space_japanese_and_latin(sg: &mut [SGlyph]) -> Vec<f64> {
     for j in 1..sg.len() {
         let (before, after) = sg.split_at_mut(j);
         let (Some(a), Some(b)) = (before.last_mut(), after.first()) else { continue };
-        if a.tcy.is_some() || b.tcy.is_some() {
+        if a.tcy.is_some() || b.tcy.is_some() || a.wari.is_some() || b.wari.is_some() {
             continue;
         }
         let japanese = if is_japanese_letter(a.ch) && is_latin_letter(b.ch) {
@@ -296,9 +300,9 @@ pub(super) fn space_japanese_and_latin(sg: &mut [SGlyph]) -> Vec<f64> {
     added
 }
 
-/// The size of `g`'s em, in points.
+/// The size of `g`'s em, in points. A warichu glyph has the em of the line its block sits in.
 pub(super) fn glyph_em(g: &SGlyph) -> f64 {
-    g.face.units_per_em() * g.sy
+    g.wari.map_or(g.face.units_per_em() * g.sy, |w| w.em)
 }
 
 /// How far up (line space) Character Alignment `a` moves glyph `g` on a line whose largest em is
diff --git a/crates/text/src/layout/warichu.rs b/crates/text/src/layout/warichu.rs
new file mode 100644
index 0000000000..dd816599c6
--- /dev/null
+++ b/crates/text/src/layout/warichu.rs
@@ -0,0 +1,313 @@
+use vectorcraft_doc::{CharStyle, TextKind, TextObject, WarichuAlign};
+
+use super::SGlyph;
+use crate::shape::Wari;
+
+/// What [`warichu`] reads from a glyph's character style ([`CharStyle::warichu`] and Warichu
+/// Settings): whether it is marked, its Lines, Line Gap (points) and Scale (percent), its
+/// Alignment, the size it is set at (already scaled by [`warichu_sizes`]) and whether its leading
+/// is Auto.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) struct WariStyle {
+    pub marked: bool,
+    pub lines: u8,
+    pub gap: f64,
+    pub scale: f64,
+    pub align: WarichuAlign,
+    pub size: f64,
+    pub auto_leading: bool,
+}
+
+impl WariStyle {
+    pub(super) fn of(st: &CharStyle) -> Self {
+        Self {
+            marked: st.warichu,
+            lines: st.warichu_lines,
+            gap: st.warichu_gap,
+            scale: st.warichu_scale,
+            align: st.warichu_align,
+            size: st.size,
+            auto_leading: st.leading.is_none(),
+        }
+    }
+    /// Do glyphs in styles `self` and `other` belong to one block: both marked, with the same
+    /// settings and size, and both with Auto leading or both without?
+    fn same_block(&self, other: &Self) -> bool {
+        self.marked
+            && other.marked
+            && self.lines == other.lines
+            && self.gap == other.gap
+            && self.scale == other.scale
+            && self.align == other.align
+            && self.size == other.size
+            && self.auto_leading == other.auto_leading
+    }
+}
+
+/// Warichu Settings Scale as a factor of the size, kept to the range Warichu Settings takes
+/// ([`vectorcraft_doc::text::WARICHU_SCALE`]); 50% when it is not a number.
+fn scale_factor(percent: f64) -> f64 {
+    let range = vectorcraft_doc::text::WARICHU_SCALE;
+    if percent.is_nan() { 0.5 } else { percent.clamp(*range.start(), *range.end()) / 100.0 }
+}
+
+/// Are characters in style `st` set as warichu (in `vertical` type or not)? In vertical type a
+/// character marked Tate-chu-yoko too is set across the column at its own size instead.
+pub(super) fn stacked(st: &CharStyle, vertical: bool) -> bool {
+    st.warichu && !(vertical && st.tate_chu_yoko)
+}
+
+/// `t` with each warichu run set at its Warichu Settings Scale of its size. An explicit leading
+/// stays in points, and [`place_block`] and the paragraph's Auto Leading give an Auto leading the
+/// run's own size ([`line_size`]), so that the block's line keeps its height. `t` itself when no
+/// run is marked, and for type on a path, which sets warichu characters at their own size.
+pub(super) fn warichu_sizes(t: &TextObject) -> std::borrow::Cow<'_, TextObject> {
+    let stacked = |st: &CharStyle| stacked(st, t.vertical);
+    if matches!(t.kind, TextKind::OnPath { .. }) || !t.runs.iter().any(|r| stacked(&r.style)) {
+        return std::borrow::Cow::Borrowed(t);
+    }
+    let mut out = t.clone();
+    for r in out.runs.iter_mut().filter(|r| stacked(&r.style)) {
+        r.style.size *= scale_factor(r.style.warichu_scale);
+    }
+    std::borrow::Cow::Owned(out)
+}
+
+/// The size of the line characters in style `st` sit in, from the styles [`warichu_sizes`] sets
+/// (in `vertical` type or not): a warichu character's size without its Warichu Settings Scale, any
+/// other character's own size. For flowed type, not type on a path.
+pub(super) fn line_size(st: &CharStyle, vertical: bool) -> f64 {
+    if stacked(st, vertical) { WariStyle::of(st).parent_size() } else { st.size }
+}
+
+impl WariStyle {
+    /// The size a warichu block's text has without its Warichu Settings Scale: the size of the
+    /// line it sits in.
+    pub(super) fn parent_size(&self) -> f64 {
+        self.size / scale_factor(self.scale)
+    }
+}
+
+/// Warichu: each stretch of marked glyphs `g` (shaped at their Warichu Settings Scale of their
+/// size, [`warichu_sizes`]) is set as one block of its Lines inside its line. The block takes the
+/// length of its longest line along the line and does not break across lines; its first glyph
+/// advances by that length and the others by none, as a tate-chu-yoko block's do, and every glyph
+/// keeps its place in the block ([`Wari`]). A stretch takes the settings of its first glyph, and a
+/// glyph with other settings, another size or the other kind of leading (Auto or a number) starts
+/// a new block. A tab, a forced line break and a tate-chu-yoko glyph are not part of a block and
+/// end it; digits marked Warichu are not set as automatic tate-chu-yoko. In horizontal type each
+/// line's characters are set in their bidi order, so right-to-left text reads from the right. The
+/// Insert Aki before the block's first character and after its last is space before and after the
+/// block.
+///
+/// The text is split between the lines where the line lengths come nearest an even share of the
+/// whole, at places where a line may break when there are enough of them (after a space or a CJK
+/// character), and between any two characters otherwise. A block has at most as many lines as
+/// characters. The lines are stacked one em of the warichu size apart plus the Line Gap, the stack
+/// centered across the line on the center of the line's ideographic em box (in vertical type, the
+/// column's center line), the first line above (in vertical type, to the right). Each line is set
+/// along the block by its Alignment; Auto sets the lines as Justify with Last Line Aligned Left
+/// does. These are VectorCraft's own rules for the parts public documentation does not describe.
+/// <https://helpx.adobe.com/illustrator/using/formatting-asian-characters.html>
+pub(super) fn warichu(g: &mut [SGlyph], (vertical, whole): (bool, bool), style: impl Fn(&SGlyph) -> WariStyle) {
+    let styles: Vec<WariStyle> = g.iter().map(&style).collect();
+    let member =
+        |i: usize| g.get(i).is_some_and(|gl| !matches!(gl.ch, '\u{2028}' | '\t') && gl.tcy.is_none()) && styles.get(i).is_some_and(|s| s.marked);
+    let members: Vec<bool> = (0..g.len()).map(member).collect();
+    let mut i = 0;
+    while i < g.len() {
+        let Some(first) = styles.get(i).copied().filter(|_| members.get(i).copied().unwrap_or(false)) else {
+            i += 1;
+            continue;
+        };
+        let mut end = i + 1;
+        while members.get(end).copied().unwrap_or(false) && styles.get(end).is_some_and(|s| first.same_block(s)) {
+            end += 1;
+        }
+        if let Some(block) = g.get_mut(i..end) {
+            place_block(block, &first, (vertical, whole));
+        }
+        i = end;
+    }
+}
+
+/// The clusters of `g` (glyphs of one character, by their byte), as glyph index ranges.
+fn clusters(g: &[SGlyph]) -> Vec<std::ops::Range<usize>> {
+    let mut out: Vec<std::ops::Range<usize>> = Vec::new();
+    for (i, gl) in g.iter().enumerate() {
+        match out.last_mut() {
+            Some(last) if i > 0 && g.get(i - 1).is_some_and(|p| p.byte == gl.byte && p.len > 0 && gl.len > 0) => last.end = i + 1,
+            _ => out.push(i..i + 1),
+        }
+    }
+    out
+}
+
+/// Where the block's text is split into `lines` lines: the cluster indices each later line starts
+/// at, nearest an even share of the whole length `total` (`ends` holds the length up to the end
+/// of each cluster), at places where a line may break when they give every line its share, and
+/// between any two characters otherwise.
+fn splits(g: &[SGlyph], clusters: &[std::ops::Range<usize>], ends: &[f64], lines: usize) -> Vec<usize> {
+    let count = clusters.len();
+    let may_break = |c: usize| clusters.get(c - 1).and_then(|r| g.get(r.end - 1)).is_some_and(SGlyph::break_after);
+    let preferred: Vec<usize> = (1..count).filter(|&c| may_break(c)).collect();
+    let out = nearest_splits(&preferred, ends, lines, count);
+    if out.len() + 1 >= lines { out } else { nearest_splits(&(1..count).collect::<Vec<_>>(), ends, lines, count) }
+}
+
+/// [`splits`] among the cluster indices `candidates` of a block of `count` clusters.
+fn nearest_splits(candidates: &[usize], ends: &[f64], lines: usize, count: usize) -> Vec<usize> {
+    let total = ends.last().copied().unwrap_or(0.0);
+    let mut out = Vec::with_capacity(lines.saturating_sub(1));
+    let mut previous = 0;
+    for k in 1..lines {
+        let target = total * k as f64 / lines as f64;
+        // Leave a cluster and a place to split for each line still to come.
+        let last = count.saturating_sub(lines - k);
+        let later = |c: usize| candidates.len() - candidates.partition_point(|&x| x <= c) >= lines - 1 - k;
+        let best = candidates.iter().copied().filter(|&c| c > previous && c <= last && later(c)).min_by(|&a, &b| {
+            (ends.get(a - 1).copied().unwrap_or(0.0) - target).abs().total_cmp(&(ends.get(b - 1).copied().unwrap_or(0.0) - target).abs())
+        });
+        let Some(c) = best else { break };
+        out.push(c);
+        previous = c;
+    }
+    out
+}
+
+/// Set one warichu block `g` in the settings `s` of its first glyph, in `vertical` type or not.
+/// With `whole` (System Layout on or Fractional Widths off) the block's length is a whole number
+/// of points, at least one, as each character's advance is ([`super::whole_character_widths`]).
+fn place_block(g: &mut [SGlyph], s: &WariStyle, (vertical, whole): (bool, bool)) {
+    let Some(first) = g.first() else { return };
+    let start = first.byte;
+    let ic = first.face.ideographic_centre();
+    // The block's tallest ascent and deepest descent: its glyphs may come from several faces (runs
+    // in other fonts, the classes of a composite font, a fallback face).
+    let ascent = g.iter().map(|gl| gl.ascent).fold(first.ascent, f64::max);
+    let descent = g.iter().map(|gl| gl.descent).fold(first.descent, f64::max);
+    let clusters = clusters(g);
+    // Each glyph's advance without its Insert Aki.
+    let own = |gl: &SGlyph| gl.adv - gl.aki;
+    let widths: Vec<f64> = clusters.iter().map(|r| g.get(r.clone()).map_or(0.0, |c| c.iter().map(own).sum())).collect();
+    let ends: Vec<f64> = widths
+        .iter()
+        .scan(0.0, |sum, w| {
+            *sum += w;
+            Some(*sum)
+        })
+        .collect();
+    let lines = usize::from(s.lines.clamp(*vectorcraft_doc::text::WARICHU_LINES.start(), *vectorcraft_doc::text::WARICHU_LINES.end()))
+        .min(clusters.len())
+        .max(1);
+    let mut starts = vec![0];
+    starts.extend(splits(g, &clusters, &ends, lines));
+    starts.push(clusters.len());
+    let rows: Vec<std::ops::Range<usize>> = starts.windows(2).filter_map(|w| Some(*w.first()?..*w.get(1)?)).filter(|r| !r.is_empty()).collect();
+    // Every character keeps its advance in the block, a space too, so each has its place for the
+    // caret and the selection.
+    let length = |r: &std::ops::Range<usize>| widths.get(r.clone()).map_or(0.0, |w| w.iter().sum::<f64>());
+    let block = rows.iter().map(length).fold(0.0, f64::max);
+    let block = if whole && block.is_finite() && block > 0.0 { block.round().max(1.0) } else { block };
+    let em = s.size;
+    let gap = if s.gap.is_finite() { s.gap.clamp(0.0, vectorcraft_doc::MAX_COORD) } else { 0.0 };
+    let count = rows.len();
+    let height = count as f64 * em + count.saturating_sub(1) as f64 * gap;
+    let top = -ic * s.parent_size() - height * 0.5;
+    // Every glyph's place: (along the block, across the line, its own advance).
+    let mut places = vec![(0.0, 0.0, 0.0); g.len()];
+    for (k, row) in rows.iter().enumerate() {
+        let baseline = top + k as f64 * (em + gap) + (ic + 0.5) * em;
+        let room = (block - length(row)).max(0.0);
+        let last = k + 1 == count;
+        let gaps = row.len().saturating_sub(1);
+        let align = match (s.align, last) {
+            (WarichuAlign::Auto | WarichuAlign::JustifyLeft, true) => WarichuAlign::Left,
+            (WarichuAlign::JustifyCenter, true) => WarichuAlign::Center,
+            (WarichuAlign::JustifyRight, true) => WarichuAlign::Right,
+            (WarichuAlign::Auto, false) => WarichuAlign::JustifyAll,
+            (a, _) => a,
+        };
+        let (mut pen, between) = match align {
+            WarichuAlign::Center => (room * 0.5, 0.0),
+            WarichuAlign::Right => (room, 0.0),
+            WarichuAlign::Left => (0.0, 0.0),
+            _ if gaps > 0 => (0.0, room / gaps as f64),
+            _ => (0.0, 0.0),
+        };
+        // The row's clusters in the order they are drawn: by their bidi levels in horizontal type
+        // (right-to-left text reads from the right), in reading order down a vertical column.
+        let order: Vec<usize> = if vertical {
+            row.clone().collect()
+        } else {
+            let levels: Vec<unicode_bidi::Level> =
+                row.clone().map(|c| clusters.get(c).and_then(|r| g.get(r.start)).map_or(unicode_bidi::Level::ltr(), |gl| gl.level)).collect();
+            unicode_bidi::BidiInfo::reorder_visual(&levels).into_iter().map(|i| row.start + i).collect()
+        };
+        for (n, &c) in order.iter().enumerate() {
+            let Some(range) = clusters.get(c) else { continue };
+            let mut inside = 0.0;
+            for i in range.clone() {
+                let adv = g.get(i).map_or(0.0, own);
+                if let Some(p) = places.get_mut(i) {
+                    *p = (pen + inside, baseline, adv);
+                }
+                inside += adv;
+            }
+            pen += widths.get(c).copied().unwrap_or(0.0) + if n + 1 < order.len() { between } else { 0.0 };
+        }
+    }
+    let r = scale_factor(s.scale);
+    let bottom = top + height;
+    // Insert Aki: the space before the block's first character and after its last, in reading
+    // order, is space before and after the block, on the sides the block's direction (its first
+    // character's) sets; inside the block it takes no part. A cluster holds the space on its left
+    // (above, in vertical type) in its glyphs' `aki_shift`, and the rest of the `aki` its last glyph
+    // carries on its right (below).
+    let sides = |r: Option<&std::ops::Range<usize>>| {
+        let Some(c) = r.and_then(|r| g.get(r.clone())) else { return (0.0, 0.0) };
+        let left = c.first().map_or(0.0, |gl| gl.aki_shift);
+        let right = c.iter().map(|gl| gl.aki).sum::<f64>() - left;
+        let rtl = !vertical && c.first().is_some_and(|gl| gl.level.is_rtl());
+        // (before, after) in reading order.
+        if rtl { (right, left) } else { (left, right) }
+    };
+    let (before, _) = sides(clusters.first());
+    let (_, after) = sides(clusters.last());
+    let finite = |v: f64| {
+        if !v.is_finite() {
+            0.0
+        } else if whole {
+            v.round().max(0.0)
+        } else {
+            v.max(0.0)
+        }
+    };
+    let (before, after) = (finite(before), finite(after));
+    let rtl = !vertical && g.first().is_some_and(|gl| gl.level.is_rtl());
+    let (inset, outset) = if rtl { (after, before) } else { (before, after) };
+    let length = inset + block + outset;
+    let glyphs = g.len();
+    for (i, (gl, (along, across, advance))) in g.iter_mut().zip(places).enumerate() {
+        let em = gl.face.units_per_em() * gl.sy / r;
+        gl.wari = Some(Wari { start, pen: if i == 0 { 0.0 } else { length }, along: inset + along, across, advance, em });
+        gl.adv = if i == 0 { length } else { 0.0 };
+        gl.tracking = 0.0;
+        gl.kern_shift -= gl.aki_shift;
+        gl.aki_shift = 0.0;
+        gl.aki = if i == 0 { inset + outset } else { 0.0 };
+        // No line breaks inside the block; the line may break before and after it.
+        if i + 1 < glyphs {
+            gl.keeps_next = true;
+        }
+        // The line keeps the height of the block's own size, and holds the whole stack.
+        gl.ascent = (ascent / r).max(-top);
+        gl.descent = (descent / r).max(bottom);
+        if s.auto_leading {
+            gl.leading /= r;
+        }
+        // The first baseline (Cap Height, x Height) measures the line's own size too.
+        gl.cap /= r;
+        gl.xh /= r;
+    }
+}
diff --git a/crates/text/src/layout/wrapping_tests.rs b/crates/text/src/layout/wrapping_tests.rs
index 9d54e6a1cc..eae22bab8a 100644
--- a/crates/text/src/layout/wrapping_tests.rs
+++ b/crates/text/src/layout/wrapping_tests.rs
@@ -33,6 +33,7 @@ fn synthetic_glyphs(specs: &[(usize, usize, f64, char)]) -> Vec<SGlyph> {
             xh: 4.0,
             ch,
             tcy: None,
+            wari: None,
             inline: None,
             word_end: false,
             keeps_word: false,
@@ -97,6 +98,7 @@ fn indic_hyphenation_reaches_both_composers_without_splitting_marks() {
             false,
             false,
             &[],
+            None,
         );
         assert_eq!((end, hyphen), (4, true), "{tag}");
         let params = Params { justify_last: false, ragged: true, tolerance: 1.0, uniform_from: 0, hyphen_limit: 0 };
@@ -169,7 +171,7 @@ fn greedy_wrap_keeps_an_oversized_first_cluster_and_its_source_range() {
     let glyphs = synthetic_glyphs(&[(0, 4, 2.0, 'ب'), (0, 4, 2.0, 'ب'), (4, 2, 1.0, 'ت')]);
 
     let (end, hyphenated) =
-        break_line(text, &glyphs, 0, 3.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, KinsokuShoriType::PushOutOnly, false, false, &[]);
+        break_line(text, &glyphs, 0, 3.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, KinsokuShoriType::PushOutOnly, false, false, &[], None);
 
     assert!(!hyphenated);
     assert_eq!(end, 2, "oversized base-plus-mark cluster must stay together");
@@ -183,12 +185,26 @@ fn greedy_wrap_keeps_an_oversized_cluster_after_a_line_start_atomic() {
     let glyphs = synthetic_glyphs(&[(0, 4, 1.0, 'ب'), (4, 4, 2.0, 'ت'), (4, 4, 2.0, 'ت'), (8, 2, 1.0, 'ث')]);
 
     let (first_end, _) =
-        break_line(text, &glyphs, 0, 3.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, KinsokuShoriType::PushOutOnly, false, false, &[]);
+        break_line(text, &glyphs, 0, 3.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, KinsokuShoriType::PushOutOnly, false, false, &[], None);
     assert_eq!(first_end, 1);
     assert_eq!(source_range(&glyphs, 0, first_end), 0..4);
 
-    let (second_end, hyphenated) =
-        break_line(text, &glyphs, first_end, 3.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, KinsokuShoriType::PushOutOnly, false, false, &[]);
+    let (second_end, hyphenated) = break_line(
+        text,
+        &glyphs,
+        first_end,
+        3.0,
+        &[],
+        0.0,
+        None,
+        Burasagari::None,
+        Kinsoku::Hard,
+        KinsokuShoriType::PushOutOnly,
+        false,
+        false,
+        &[],
+        None,
+    );
 
     assert!(!hyphenated);
     assert_eq!(second_end, 3, "oversized cluster at the next line start must stay together");
@@ -244,7 +260,7 @@ fn no_break_keeps_marked_characters_on_one_line() {
     let text = "A B";
     let plain = synthetic_glyphs(&[(0, 1, 10.0, 'A'), (1, 1, 4.0, ' '), (2, 1, 10.0, 'B')]);
     let (end, hyphen) =
-        break_line(text, &plain, 0, 16.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, KinsokuShoriType::PushOutOnly, false, false, &[]);
+        break_line(text, &plain, 0, 16.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, KinsokuShoriType::PushOutOnly, false, false, &[], None);
     assert!(!hyphen);
     assert_eq!(end, 2, "without the mark the line ends after the space");
 
@@ -253,7 +269,7 @@ fn no_break_keeps_marked_characters_on_one_line() {
         g.no_break = true;
     }
     let (end, hyphen) =
-        break_line(text, &marked, 0, 16.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, KinsokuShoriType::PushOutOnly, false, false, &[]);
+        break_line(text, &marked, 0, 16.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, KinsokuShoriType::PushOutOnly, false, false, &[], None);
     assert!(!hyphen);
     assert_eq!(end, 3, "the marked words stay together even though they are wider than the line");
 
@@ -263,10 +279,10 @@ fn no_break_keeps_marked_characters_on_one_line() {
     glyphs[2].no_break = true;
     glyphs[3].no_break = true;
     let (end, _) =
-        break_line(text, &glyphs, 0, 22.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, KinsokuShoriType::PushOutOnly, false, false, &[]);
+        break_line(text, &glyphs, 0, 22.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, KinsokuShoriType::PushOutOnly, false, false, &[], None);
     assert_eq!(end, 2, "the marked pair moves to the next line together");
     let (end, _) =
-        break_line(text, &glyphs, end, 15.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, KinsokuShoriType::PushOutOnly, false, false, &[]);
+        break_line(text, &glyphs, end, 15.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, KinsokuShoriType::PushOutOnly, false, false, &[], None);
     assert_eq!(end, 4, "on its own line the pair stays together even when it is wider than the line");
 
     let breaks = candidates(text, &glyphs, None, Kinsoku::None);
@@ -336,7 +352,7 @@ fn full_width(text: &str) -> Vec<SGlyph> {
 fn kinsoku_shori_type_pushes_a_closing_bracket_in_or_out() {
     use KinsokuShoriType::{PushInFirst, PushOutFirst, PushOutOnly};
     let hung = |text: &str, width: f64, kinsoku: Kinsoku, ty: KinsokuShoriType, hanging: bool| {
-        break_line(text, &full_width(text), 0, width, &[], 0.0, None, Burasagari::None, kinsoku, ty, hanging, false, &[]).0
+        break_line(text, &full_width(text), 0, width, &[], 0.0, None, Burasagari::None, kinsoku, ty, hanging, false, &[], None).0
     };
     let end = |text: &str, width: f64, kinsoku: Kinsoku, ty: KinsokuShoriType| hung(text, width, kinsoku, ty, false);
     let text = "一二三四五六七八九十一二三四五」六";
@@ -402,7 +418,7 @@ fn kinsoku_shori_type_counts_the_gaps_that_close() {
     let mut glyphs = full_width(mixed);
     glyphs[3].level = unicode_bidi::Level::rtl();
     let mixed_end =
-        |ty: KinsokuShoriType| break_line(mixed, &glyphs, 0, 150.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, ty, false, false, &[]).0;
+        |ty: KinsokuShoriType| break_line(mixed, &glyphs, 0, 150.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, ty, false, false, &[], None).0;
     assert_eq!(mixed_end(PushInFirst), 14, "right-to-left text on the line: 五 is pushed out with 」");
     assert_eq!(mixed_end(PushOutOnly), 14);
 
@@ -414,7 +430,7 @@ fn kinsoku_shori_type_counts_the_gaps_that_close() {
         g.sy *= 2.0;
     }
     let tall_end =
-        |ty: KinsokuShoriType| break_line(tall, &glyphs, 0, 50.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, ty, false, false, &[]).0;
+        |ty: KinsokuShoriType| break_line(tall, &glyphs, 0, 50.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, ty, false, false, &[], None).0;
     assert_eq!(tall_end(PushInFirst), 4, "Vertical Scale does not widen the gaps: 五 is pushed out with 」");
 
     // No gap closes inside a shaped cluster. 二 is two glyphs here, so the line has five gaps to
@@ -424,7 +440,7 @@ fn kinsoku_shori_type_counts_the_gaps_that_close() {
     let half = glyphs[1].clone();
     glyphs.insert(2, half);
     let split_end =
-        |width: f64| break_line(tall, &glyphs, 0, width, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, PushInFirst, false, false, &[]).0;
+        |width: f64| break_line(tall, &glyphs, 0, width, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, PushInFirst, false, false, &[], None).0;
     assert_eq!(split_end(54.0), 5, "五 is pushed out with 」");
     assert_eq!(split_end(55.0), 7, "five gaps close by 5 pt: 」 is pushed in");
 }
@@ -438,12 +454,198 @@ fn kinsoku_shori_type_counts_no_gap_at_a_format_control() {
     let mut glyphs = full_width(text);
     glyphs[2].adv = 0.0;
     let end = |width: f64| {
-        break_line(text, &glyphs, 0, width, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, KinsokuShoriType::PushInFirst, false, false, &[]).0
+        break_line(text, &glyphs, 0, width, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, KinsokuShoriType::PushInFirst, false, false, &[], None).0
     };
     assert_eq!(end(54.0), 5, "五 is pushed out with 」");
     assert_eq!(end(55.0), 7, "five gaps close by 5 pt: 」 is pushed in");
 }
 
+/// A line with a tab that does not fit as drawn ends at the latest break that does, even when an
+/// earlier break does not fit.
+#[test]
+fn a_tabbed_line_ends_at_the_latest_break_that_fits_as_drawn() {
+    let text = "a\tb c d e";
+    let specs: Vec<_> = text.char_indices().map(|(byte, ch)| (byte, ch.len_utf8(), 1.0, ch)).collect();
+    let glyphs = synthetic_glyphs(&specs);
+    // Breaks after the spaces end the line before glyphs 4, 6 and 8; the paragraph ends at 9.
+    let drawn_fits = |end: usize, _hyphenated: bool| end == 4 || end == 8;
+    let fits: Option<&dyn Fn(usize, bool) -> bool> = Some(&drawn_fits);
+    let ended =
+        break_line(text, &glyphs, 0, 100.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, KinsokuShoriType::PushOutOnly, false, false, &[], fits);
+    assert_eq!(ended, (8, false));
+}
+
+/// Past the breaks a tabbed line measures one by one, it ends at the latest break without a hyphen
+/// that fits as drawn, whatever the breaks with a hyphen between them measure.
+#[test]
+fn a_long_tabbed_line_ends_at_the_latest_plain_break_that_fits_as_drawn() {
+    // a (0), tab (1), then b, a soft hyphen, b and a space for each u: breaks before 4 + 4u (with a
+    // hyphen) and 6 + 4u.
+    let text = format!("a\t{}", "b\u{AD}b ".repeat(400));
+    let specs: Vec<_> = text.char_indices().map(|(byte, ch)| (byte, ch.len_utf8(), 1.0, ch)).collect();
+    let glyphs = synthetic_glyphs(&specs);
+    let drawn_fits = |end: usize, hyphenated: bool| !hyphenated && end <= 606;
+    let fits: Option<&dyn Fn(usize, bool) -> bool> = Some(&drawn_fits);
+    let ended =
+        break_line(&text, &glyphs, 0, 1e6, &[], 0.0, None, Burasagari::None, Kinsoku::None, KinsokuShoriType::PushOutOnly, false, false, &[], fits);
+    assert_eq!(ended, (606, false));
+}
+
+/// A line with a tab that overflows in the order of its text at many clusters stays whole when it
+/// fits as drawn.
+#[test]
+fn a_tabbed_line_that_fits_as_drawn_stays_whole_past_many_clusters() {
+    use vectorcraft_doc::{TabAlign, TabStop};
+    let text = format!("a\t{}", "b ".repeat(600));
+    let specs: Vec<_> = text.char_indices().map(|(byte, ch)| (byte, ch.len_utf8(), 0.1, ch)).collect();
+    let glyphs = synthetic_glyphs(&specs);
+    let tabs = [TabStop { position: 500.0, align: TabAlign::Left, leader: String::new(), align_on: '.' }];
+    // In the text's order the line is 500 pt and 120 pt of text wide; drawn, it fits.
+    let drawn_fits = |_end: usize, _hyphenated: bool| true;
+    let fits: Option<&dyn Fn(usize, bool) -> bool> = Some(&drawn_fits);
+    let ended = break_line(
+        &text,
+        &glyphs,
+        0,
+        600.0,
+        &tabs,
+        0.0,
+        None,
+        Burasagari::None,
+        Kinsoku::None,
+        KinsokuShoriType::PushOutOnly,
+        false,
+        false,
+        &[],
+        fits,
+    );
+    assert_eq!(ended, (glyphs.len(), false));
+}
+
+/// A line of tabs and glyphs without width stops reading once its tabs reach past the frame: the
+/// rest of the paragraph is not measured.
+#[test]
+fn a_tabbed_line_stops_reading_where_its_tabs_reach_past_the_frame() {
+    let text = format!("a{}", "\tx ".repeat(2000));
+    let specs: Vec<_> = text.char_indices().map(|(byte, ch)| (byte, ch.len_utf8(), if ch == 'a' { 1.0 } else { 0.0 }, ch)).collect();
+    let glyphs = synthetic_glyphs(&specs);
+    let furthest = std::cell::Cell::new(0);
+    let drawn_fits = |end: usize, _hyphenated: bool| {
+        furthest.set(furthest.get().max(end));
+        end <= 4
+    };
+    let fits: Option<&dyn Fn(usize, bool) -> bool> = Some(&drawn_fits);
+    let ended =
+        break_line(&text, &glyphs, 0, 100.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, KinsokuShoriType::PushOutOnly, false, false, &[], fits);
+    assert_eq!(ended, (4, false));
+    assert!(furthest.get() < 100, "measured up to glyph {}", furthest.get());
+}
+
+/// A tab to an explicit stop past the frame stops a line from reading on: the rest of the paragraph
+/// is not measured.
+#[test]
+fn a_tab_to_a_stop_past_the_frame_stops_the_line_reading() {
+    use vectorcraft_doc::{TabAlign, TabStop};
+    let text = format!("a b\t{}", "x ".repeat(2000));
+    let specs: Vec<_> = text.char_indices().map(|(byte, ch)| (byte, ch.len_utf8(), if ch == 'x' { 0.0 } else { 1.0 }, ch)).collect();
+    let glyphs = synthetic_glyphs(&specs);
+    let tabs = [TabStop { position: 500.0, align: TabAlign::Left, leader: String::new(), align_on: '.' }];
+    let furthest = std::cell::Cell::new(0);
+    let drawn_fits = |end: usize, _hyphenated: bool| {
+        furthest.set(furthest.get().max(end));
+        end <= 2
+    };
+    let fits: Option<&dyn Fn(usize, bool) -> bool> = Some(&drawn_fits);
+    let ended = break_line(
+        &text,
+        &glyphs,
+        0,
+        100.0,
+        &tabs,
+        0.0,
+        None,
+        Burasagari::None,
+        Kinsoku::None,
+        KinsokuShoriType::PushOutOnly,
+        false,
+        false,
+        &[],
+        fits,
+    );
+    assert_eq!(ended, (2, false));
+    assert!(furthest.get() < 100, "measured up to glyph {}", furthest.get());
+}
+
+/// A tabbed line that ends in a word with more hyphenation points than are measured one by one ends
+/// at the latest point that fits as drawn.
+#[test]
+fn a_tabbed_line_ends_at_the_latest_hyphenation_point_that_fits_as_drawn() {
+    let opts = HyphenationOptions { words_longer_than: 0, after_first: 1, before_last: 1, ..Default::default() };
+    // a (0), tab (1), then a word of 400 syllables of two glyphs from glyph 2: points before 4, 6, ...
+    let text = format!("a\t{}", "कि".repeat(400));
+    let specs: Vec<_> = text.char_indices().map(|(byte, ch)| (byte, ch.len_utf8(), 1.0, ch)).collect();
+    let mut glyphs = synthetic_glyphs(&specs);
+    for glyph in &mut glyphs {
+        glyph.hyphen_language = crate::hyphen::Language::from_tag(Some("hi"));
+        glyph.sx = 0.001;
+    }
+    let drawn_fits = |end: usize, _hyphenated: bool| end <= 50;
+    let fits: Option<&dyn Fn(usize, bool) -> bool> = Some(&drawn_fits);
+    let ended = break_line(
+        &text,
+        &glyphs,
+        0,
+        600.0,
+        &[],
+        0.0,
+        Some((&opts, 0.0)),
+        Burasagari::None,
+        Kinsoku::None,
+        KinsokuShoriType::PushOutOnly,
+        false,
+        false,
+        &[],
+        fits,
+    );
+    assert_eq!(ended, (50, true));
+}
+
+/// A glyph with a negative advance after a tab draws the line short of the tab's stop: a line that
+/// fits as drawn stays whole.
+#[test]
+fn a_negative_advance_after_a_tab_keeps_a_fitting_line_whole() {
+    let text = "a\tb";
+    let glyphs = synthetic_glyphs(&[(0, 1, 1.0, 'a'), (1, 1, 1.0, '\t'), (2, 1, -20.0, 'b')]);
+    let drawn_fits = |_end: usize, _hyphenated: bool| true;
+    let fits: Option<&dyn Fn(usize, bool) -> bool> = Some(&drawn_fits);
+    let ended =
+        break_line(text, &glyphs, 0, 30.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, KinsokuShoriType::PushOutOnly, false, false, &[], fits);
+    assert_eq!(ended, (3, false));
+    // Two right tabs can align on the same stop when the text after the second steps back: the
+    // second tab does not reach the next stop.
+    use vectorcraft_doc::{TabAlign, TabStop};
+    let text = "a\tb\tc";
+    let glyphs = synthetic_glyphs(&[(0, 1, 1.0, 'a'), (1, 1, 1.0, '\t'), (2, 1, 1.0, 'b'), (3, 1, 1.0, '\t'), (4, 1, -10.0, 'c')]);
+    let tabs = [100.0, 500.0].map(|position| TabStop { position, align: TabAlign::Right, leader: String::new(), align_on: '.' });
+    let ended = break_line(
+        text,
+        &glyphs,
+        0,
+        200.0,
+        &tabs,
+        0.0,
+        None,
+        Burasagari::None,
+        Kinsoku::None,
+        KinsokuShoriType::PushOutOnly,
+        false,
+        false,
+        &[],
+        fits,
+    );
+    assert_eq!(ended, (5, false));
+}
+
 /// Mojikumi: the greedy breaker measures a line as it is set, with its last character narrowed
 /// (`line_end`): 」 set half width ends a measure of three and a half characters. Only the last
 /// glyph of the last cluster counts, and only where the line may end.
@@ -455,7 +657,7 @@ fn greedy_wrap_counts_the_narrower_line_end() {
     let mut credit = vec![0.0; glyphs.len()];
     credit[3] = 5.0;
     let end = |glyphs: &[SGlyph], width: f64, burasagari: Burasagari, line_end: &[f64]| {
-        break_line(text, glyphs, 0, width, &[], 0.0, None, burasagari, Kinsoku::Hard, PushOutOnly, false, false, line_end).0
+        break_line(text, glyphs, 0, width, &[], 0.0, None, burasagari, Kinsoku::Hard, PushOutOnly, false, false, line_end, None).0
     };
     assert_eq!(end(&glyphs, 35.0, Burasagari::None, &credit), 4, "」 half width fits");
     assert_eq!(end(&glyphs, 35.0, Burasagari::None, &[]), 2, "」 full width does not: 三 goes with it");
@@ -471,7 +673,7 @@ fn greedy_wrap_counts_the_narrower_line_end() {
     let comma = "一二三、";
     let glyphs = full_width(comma);
     let end = |line_end: &[f64]| {
-        break_line(comma, &glyphs, 0, 25.0, &[], 0.0, None, Burasagari::Standard, Kinsoku::Hard, PushOutOnly, false, false, line_end).0
+        break_line(comma, &glyphs, 0, 25.0, &[], 0.0, None, Burasagari::Standard, Kinsoku::Hard, PushOutOnly, false, false, line_end, None).0
     };
     assert_eq!(end(&[0.0, 0.0, 5.0, 0.0]), 2);
 
@@ -480,7 +682,7 @@ fn greedy_wrap_counts_the_narrower_line_end() {
     let pushed = "一二三四」。六";
     let glyphs = full_width(pushed);
     let end = |ty: KinsokuShoriType, line_end: &[f64]| {
-        break_line(pushed, &glyphs, 0, 50.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, ty, false, false, line_end).0
+        break_line(pushed, &glyphs, 0, 50.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, ty, false, false, line_end, None).0
     };
     let stop = [0.0, 0.0, 0.0, 0.0, 0.0, 5.0, 0.0];
     assert_eq!(end(PushInFirst, &stop), 6, "。 is pushed in");
@@ -490,7 +692,7 @@ fn greedy_wrap_counts_the_narrower_line_end() {
     let pushed = format!("{}二」「四", "一".repeat(10));
     let glyphs = full_width(&pushed);
     let end = |line_end: &[f64]| {
-        break_line(&pushed, &glyphs, 0, 130.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, PushOutFirst, false, false, line_end).0
+        break_line(&pushed, &glyphs, 0, 130.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, PushOutFirst, false, false, line_end, None).0
     };
     let mut bracket = vec![0.0; glyphs.len()];
     bracket[11] = 5.0;
@@ -503,8 +705,9 @@ fn greedy_wrap_counts_the_narrower_line_end() {
     glyphs[2].adv = 5.0;
     let half = glyphs[2].clone();
     glyphs.insert(3, half);
-    let end =
-        |line_end: &[f64]| break_line(text, &glyphs, 0, 26.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, PushOutOnly, false, false, line_end).0;
+    let end = |line_end: &[f64]| {
+        break_line(text, &glyphs, 0, 26.0, &[], 0.0, None, Burasagari::None, Kinsoku::None, PushOutOnly, false, false, line_end, None).0
+    };
     assert_eq!(end(&[0.0, 0.0, 4.0, 0.0]), 2, "the cluster stays whole and goes to the next line");
     assert_eq!(end(&[0.0, 0.0, 0.0, 4.0]), 4, "its last glyph's credit keeps it on the line");
 }
@@ -784,8 +987,9 @@ fn korean(text: &str, anywhere: bool) -> Vec<SGlyph> {
 fn korean_words_break_at_spaces_unless_line_break_anywhere() {
     use KinsokuShoriType::PushOutOnly;
     let text = "가나다 라마바";
-    let greedy =
-        |g: &[SGlyph], width: f64| break_line(text, g, 0, width, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, PushOutOnly, false, false, &[]).0;
+    let greedy = |g: &[SGlyph], width: f64| {
+        break_line(text, g, 0, width, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, PushOutOnly, false, false, &[], None).0
+    };
     let ends = |g: &[SGlyph]| candidates(text, g, None, Kinsoku::Hard).iter().map(|b| b.end).collect::<Vec<_>>();
     // 50 pt holds "가나다 라" and not "가나다 라마".
     assert_eq!(greedy(&korean(text, false), 50.0), 4, "off: the line ends at the space");
@@ -804,7 +1008,7 @@ fn korean_words_break_at_spaces_unless_line_break_anywhere() {
     // A soft return still ends the line.
     let soft = "가나\u{2028}다라";
     assert_eq!(
-        break_line(soft, &korean(soft, false), 0, 100.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, PushOutOnly, false, false, &[]).0,
+        break_line(soft, &korean(soft, false), 0, 100.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, PushOutOnly, false, false, &[], None).0,
         3
     );
 }
@@ -825,7 +1029,8 @@ fn korean_words_keep_their_letters_and_break_after_punctuation() {
     for g in &mut glyphs[1..3] {
         g.no_break = true;
     }
-    let end = break_line(text, &glyphs, 0, 25.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, KinsokuShoriType::PushOutOnly, false, false, &[]).0;
+    let end =
+        break_line(text, &glyphs, 0, 25.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, KinsokuShoriType::PushOutOnly, false, false, &[], None).0;
     assert_eq!(end, 1, "No Break keeps 나다 together");
 }
 
@@ -852,6 +1057,7 @@ fn korean_words_take_no_hyphen() {
             false,
             false,
             &[],
+            None,
         );
         assert_eq!(line, (2, false));
         assert!(candidates(text, &glyphs, Some(&opts), Kinsoku::Hard).iter().all(|b| b.hyphen == 0.0));
@@ -897,8 +1103,9 @@ fn bunri_kinshi_keeps_jlreq_pairs_in_both_composers() {
     let marked = |text: &str| pairs(text, true).iter().filter(|g| g.keeps_next).count();
     assert_eq!((marked("……‥‥〳〵〴〵"), marked("—\u{2028}—"), marked("—〵"), marked("〵〳")), (4, 0, 0, 0));
     // 35 pt holds "あい—" and not "あい——".
-    let greedy =
-        |g: &[SGlyph], width: f64| break_line(text, g, 0, width, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, PushOutOnly, false, false, &[]).0;
+    let greedy = |g: &[SGlyph], width: f64| {
+        break_line(text, g, 0, width, &[], 0.0, None, Burasagari::None, Kinsoku::Hard, PushOutOnly, false, false, &[], None).0
+    };
     assert_eq!(greedy(&pairs(text, false), 35.0), 3, "off: the line ends between the dashes");
     assert_eq!(greedy(&pairs(text, true), 35.0), 2, "on: both dashes go to the next line");
     assert_eq!(breaking::word_width(&pairs("——あ", true), 0, &[], Kinsoku::Hard), 20.0);
@@ -916,7 +1123,7 @@ fn bunri_kinshi_keeps_jlreq_pairs_in_both_composers() {
 fn bunri_kinshi_progresses_with_an_overlong_pair_and_no_break() {
     use KinsokuShoriType::{PushInFirst, PushOutFirst, PushOutOnly};
     let line = |text: &str, g: &[SGlyph], i: usize, width: f64, kinsoku: Kinsoku, ty: KinsokuShoriType| {
-        break_line(text, g, i, width, &[], 0.0, None, Burasagari::None, kinsoku, ty, false, false, &[]).0
+        break_line(text, g, i, width, &[], 0.0, None, Burasagari::None, kinsoku, ty, false, false, &[], None).0
     };
     let text = "——あ";
     assert_eq!(line(text, &pairs(text, true), 0, 15.0, Kinsoku::Hard, PushOutOnly), 2, "the pair overflows the line whole");
@@ -951,3 +1158,26 @@ fn bunri_kinshi_progresses_with_an_overlong_pair_and_no_break() {
     assert_eq!(line(text, &pairs(text, false), 0, 46.5, Kinsoku::Hard, PushInFirst), 5);
     assert_eq!(line(text, &pairs(text, true), 0, 46.5, Kinsoku::Hard, PushInFirst), 3);
 }
+
+/// Justification adds no gap between two glyphs of one warichu block, whichever of them is drawn
+/// first: right to left, the block's first glyph (the one that starts it) is drawn after the
+/// others. Between glyphs of two blocks, the gap stays.
+#[test]
+fn justification_adds_no_gap_inside_a_warichu_block_drawn_right_to_left() {
+    let block = |g: &mut SGlyph, start: usize, pen: f64| {
+        g.wari = Some(crate::shape::Wari { start, pen, along: 0.0, across: 0.0, advance: g.adv, em: 10.0 });
+    };
+    // Glyph 1 is drawn first, then glyph 0, which starts the block.
+    let after = [None, Some(0)];
+    for (first, second) in [('א', 'ב'), ('漢', 'א')] {
+        let mut glyphs = synthetic_glyphs(&[(0, 2, 10.0, first), (2, 2, 0.0, second)]);
+        block(&mut glyphs[0], 0, 0.0);
+        block(&mut glyphs[1], 0, 10.0);
+        assert!(!flow::is_letter_gap(1, &[], &after, 0, &glyphs, false), "{first}{second}");
+        assert!(!flow::is_cjk_gap(1, &[], &after, 0, &glyphs), "{first}{second}");
+        // The same two glyphs as the first glyphs of two blocks.
+        block(&mut glyphs[1], 2, 0.0);
+        assert!(flow::is_letter_gap(1, &[], &after, 0, &glyphs, false), "{first}{second}");
+        assert_eq!(flow::is_cjk_gap(1, &[], &after, 0, &glyphs), first == '漢', "{first}{second}");
+    }
+}
diff --git a/crates/text/src/lib.rs b/crates/text/src/lib.rs
index 6586f3857a..2ff6b9ad5b 100644
--- a/crates/text/src/lib.rs
+++ b/crates/text/src/lib.rs
@@ -180,6 +180,14 @@ pub struct PositionedGlyph {
     /// path stands with its top toward the path's start, and its cell starts at its top: 0.12 em
     /// before the pen without the font's vertical metrics.
     pub width_start: f64,
+    /// A glyph of a warichu block: the byte offset of the block's first character, which names the
+    /// block. The block's lines share its line of text, so hit testing takes the block line nearest
+    /// the point before the nearest caret stop along it. `None` for any other glyph.
+    pub warichu: Option<usize>,
+    /// A glyph of a warichu block: the baseline of its block line across the line, from the
+    /// line's baseline before Character Alignment moves the glyph (y down). It names the block
+    /// line whatever the alignment of each character on it. 0 for any other glyph.
+    pub warichu_line: f64,
 }
 
 /// How a glyph on a path is bent along it: a point of its pen space (x along its advance from its
@@ -631,11 +639,18 @@ pub fn hit_byte(layout: &TextLayout, p: Point) -> usize {
     }) else {
         return 0;
     };
-    byte_in_line(layout, li, p.x)
+    byte_near(layout, li, p.x, Some(p.y))
 }
 
 /// Byte offset nearest to `x` on line `li`.
 pub fn byte_in_line(layout: &TextLayout, li: usize, x: f64) -> usize {
+    byte_near(layout, li, x, None)
+}
+
+/// Byte offset nearest to `x` on line `li`; with `y` (text space, as `x`), a warichu block's caret
+/// stops count only on the block line whose baseline is nearest `y`, since the block's lines share
+/// one line of text.
+fn byte_near(layout: &TextLayout, li: usize, x: f64, y: Option<f64>) -> usize {
     let Some(line) = layout.lines.get(li) else { return 0 };
     let glyphs = &layout.glyphs[line.glyph_start..line.glyph_end];
     // A cluster drawn with several adjacent glyphs (a Devanagari pre-base matra and its consonant,
@@ -653,11 +668,42 @@ pub fn byte_in_line(layout: &TextLayout, li: usize, x: f64) -> usize {
             _ => clusters.push((left, right, g)),
         }
     }
+    // Each warichu block's line whose baseline is nearest `y`: the block, the block line
+    // ([`PositionedGlyph::warichu_line`]) and its distance, sorted by block.
+    let mut rows: Vec<(usize, f64, f64)> = Vec::new();
+    if let Some(y) = y {
+        for (block, row, baseline) in warichu_rows(layout, line) {
+            let d = (baseline - y).abs();
+            match rows.last_mut() {
+                Some((b, best_row, best)) if *b == block => {
+                    if d < *best {
+                        (*best_row, *best) = (row, d);
+                    }
+                }
+                _ => rows.push((block, row, d)),
+            }
+        }
+    }
+    let on_row = |g: &PositionedGlyph| match (g.warichu, y) {
+        (Some(block), Some(_)) => {
+            rows.binary_search_by_key(&block, |r| r.0).ok().and_then(|k| rows.get(k)).is_none_or(|(_, row, _)| (g.warichu_line - row).abs() < 1e-9)
+        }
+        _ => true,
+    };
+    // A stop of the block line taken wins over a stop of the text around the block at the same
+    // place: at the block's start the text before it ends where both of its lines start.
     let nearest = clusters
         .iter()
-        .flat_map(|&(left, right, g)| g.stops_along(right - left).map(move |(b, d)| (if g.rtl { right - d } else { left + d }, b)))
-        .min_by(|a, b| (a.0 - x).abs().total_cmp(&(b.0 - x).abs()));
-    nearest.map_or(line.start, |(_, byte)| byte)
+        .filter(|(_, _, g)| on_row(g))
+        .flat_map(|&(left, right, g)| {
+            let row = y.is_some() && g.warichu.is_some();
+            g.stops_along(right - left).map(move |(b, d)| (if g.rtl { right - d } else { left + d }, b, row))
+        })
+        .min_by(|a, b| {
+            let (da, db) = ((a.0 - x).abs(), (b.0 - x).abs());
+            if a.2 != b.2 && (da - db).abs() <= 1e-9 { b.2.cmp(&a.2) } else { da.total_cmp(&db) }
+        });
+    nearest.map_or(line.start, |(_, byte, _)| byte)
 }
 
 /// Caret byte at the end of line `li`: a soft-wrapped line ends before its trailing space so the
@@ -711,6 +757,46 @@ pub fn caret_vertical(layout: &TextLayout, byte: usize, delta: i32, goal_x: f64)
     byte_in_line(layout, li as usize, goal_x)
 }
 
+/// The warichu blocks' lines on line `l`: one entry per block line, as the byte that names its
+/// block, its [`PositionedGlyph::warichu_line`] and its baseline across the line in text space,
+/// sorted by block and then from the top. Each block's lines are measured from where Character
+/// Alignment sets its characters on average, so the characters of a block line share one
+/// baseline whatever their own alignment.
+fn warichu_rows(layout: &TextLayout, l: &LineInfo) -> Vec<(usize, f64, f64)> {
+    let glyphs = layout.glyphs.get(l.glyph_start..l.glyph_end).unwrap_or_default();
+    // Where each block is set across the line: its characters' baselines less their block lines,
+    // summed, and how many there are.
+    let mut sets: Vec<(usize, f64, f64)> =
+        glyphs.iter().filter_map(|g| g.warichu.map(|block| (block, layout.logical_point(g.origin).y - g.warichu_line, 1.0))).collect();
+    sets.sort_by_key(|s| s.0);
+    sets.dedup_by(|next, kept| {
+        let same = next.0 == kept.0;
+        if same {
+            (kept.1, kept.2) = (kept.1 + next.1, kept.2 + next.2);
+        }
+        same
+    });
+    let mut rows: Vec<(usize, f64, f64)> = glyphs.iter().filter_map(|g| g.warichu.map(|block| (block, g.warichu_line, 0.0))).collect();
+    rows.sort_by(|x, y| x.0.cmp(&y.0).then(x.1.total_cmp(&y.1)));
+    rows.dedup_by(|x, y| x.0 == y.0 && (x.1 - y.1).abs() < 1e-9);
+    for row in &mut rows {
+        let set = sets.binary_search_by_key(&row.0, |s| s.0).ok().and_then(|k| sets.get(k)).map_or(0.0, |s| s.1 / s.2);
+        row.2 = set + row.1;
+    }
+    rows
+}
+
+/// A glyph of a warichu block line, for [`selection_quads`]: its block and block line, its extent
+/// along the line and its band across it (text space), and whether the selection covers it.
+struct BlockPiece {
+    row: (usize, usize),
+    x0: f64,
+    x1: f64,
+    top: f64,
+    bottom: f64,
+    selected: bool,
+}
+
 /// Highlight quads (text space, clockwise from top-left) covering the selected bytes `a..b`.
 pub fn selection_quads(layout: &TextLayout, a: usize, b: usize) -> Vec<[Point; 4]> {
     let (a, b) = (a.min(b), a.max(b));
@@ -729,6 +815,47 @@ pub fn selection_quads(layout: &TextLayout, a: usize, b: usize) -> Vec<[Point; 4
         let (f0, f1) = if g.rtl { (g.advance - fb, g.advance - fa) } else { (fa, fb) };
         (f0.min(f1), f0.max(f1))
     };
+    // A list marker's glyphs stand for no characters.
+    let selected = |i: usize, g: &PositionedGlyph| g.byte < b && g.byte + g.len > a && layout.marker_of(i).is_none();
+    let quad = |x0: f64, x1: f64, top: f64, bottom: f64| {
+        [Point::new(x0, top), Point::new(x1, top), Point::new(x1, bottom), Point::new(x0, bottom)].map(|q| layout.physical_point(q))
+    };
+    // The quads over the selected characters of the warichu blocks on line `l`. The block lines
+    // share the line of text: each takes the band out to halfway to the block lines next to it,
+    // and gets one quad over each run of selected characters drawn side by side on it, over the
+    // space a justified block line sets between them too.
+    let block_quads = |l: &LineInfo| {
+        let rows = warichu_rows(layout, l);
+        let mut pieces: Vec<BlockPiece> = Vec::new();
+        for (i, g) in layout.glyphs.iter().enumerate().take(l.glyph_end).skip(l.glyph_start) {
+            let Some(block) = g.warichu else { continue };
+            let lines = rows.get(rows.partition_point(|r| r.0 < block)..rows.partition_point(|r| r.0 <= block)).unwrap_or_default();
+            let row = lines.partition_point(|r| r.1 < g.warichu_line - 1e-9);
+            let Some(own) = lines.get(row).filter(|r| (r.1 - g.warichu_line).abs() < 1e-9) else { continue };
+            let top = row.checked_sub(1).and_then(|k| lines.get(k)).map_or(l.baseline - l.ascent, |above| (above.2 + own.2) * 0.5);
+            let bottom = lines.get(row + 1).map_or(l.baseline + l.descent, |below| (below.2 + own.2) * 0.5);
+            let x = layout.logical_point(g.origin).x;
+            let selected = selected(i, g);
+            let (f0, f1) = if selected { covered(g) } else { (0.0, g.advance) };
+            pieces.push(BlockPiece { row: (block, row), x0: x + f0, x1: x + f1, top, bottom, selected });
+        }
+        pieces.sort_by(|p, q| p.row.cmp(&q.row).then(p.x0.total_cmp(&q.x0)));
+        let mut quads = Vec::new();
+        let mut open: Option<BlockPiece> = None;
+        for piece in pieces {
+            match &mut open {
+                Some(run) if run.row == piece.row && piece.selected => run.x1 = run.x1.max(piece.x1),
+                _ => {
+                    quads.extend(open.take().map(|run| quad(run.x0, run.x1, run.top, run.bottom)));
+                    if piece.selected {
+                        open = Some(piece);
+                    }
+                }
+            }
+        }
+        quads.extend(open.map(|run| quad(run.x0, run.x1, run.top, run.bottom)));
+        quads
+    };
     if layout.on_path {
         // A list marker's glyphs stand for no characters.
         for g in layout.glyphs.iter().filter(|g| g.byte < b && g.byte + g.len > a && g.len > 0) {
@@ -742,22 +869,20 @@ pub fn selection_quads(layout: &TextLayout, a: usize, b: usize) -> Vec<[Point; 4
         return out;
     }
     if layout.glyphs.iter().any(|g| g.rtl) {
-        // A list marker's glyphs stand for no characters.
-        let glyphs = layout.glyphs.iter().enumerate().filter(|(i, g)| g.byte < b && g.byte + g.len > a && layout.marker_of(*i).is_none());
-        for (_, g) in glyphs {
+        // The last line whose warichu blocks were highlighted (glyphs come line by line).
+        let mut blocks_done = usize::MAX;
+        for (_, g) in layout.glyphs.iter().enumerate().filter(|(i, g)| selected(*i, g)) {
             let Some(l) = layout.lines.get(g.line) else { continue };
+            if g.warichu.is_some() {
+                if blocks_done != g.line {
+                    blocks_done = g.line;
+                    out.extend(block_quads(l));
+                }
+                continue;
+            }
             let p = layout.logical_point(g.origin);
             let (f0, f1) = covered(g);
-            let (x0, x1) = (p.x + f0, p.x + f1);
-            out.push(
-                [
-                    Point::new(x0, l.baseline - l.ascent),
-                    Point::new(x1, l.baseline - l.ascent),
-                    Point::new(x1, l.baseline + l.descent),
-                    Point::new(x0, l.baseline + l.descent),
-                ]
-                .map(|p| layout.physical_point(p)),
-            );
+            out.push(quad(p.x + f0, p.x + f1, l.baseline - l.ascent, l.baseline + l.descent));
         }
         return out;
     }
@@ -765,6 +890,25 @@ pub fn selection_quads(layout: &TextLayout, a: usize, b: usize) -> Vec<[Point; 4
         if l.start > b || l.end < a || (l.end == a && l.start < a && layout.lines.get(li + 1).is_some_and(|n| n.start == l.end)) {
             continue;
         }
+        // A line with selected characters of a warichu block: each selected glyph outside the
+        // blocks is highlighted across the line, and the blocks' characters on their own lines.
+        let line_glyphs = || layout.glyphs.iter().enumerate().take(l.glyph_end).skip(l.glyph_start).filter(|(i, g)| selected(*i, g));
+        if line_glyphs().any(|(_, g)| g.warichu.is_some()) {
+            let (t, bt) = (l.baseline - l.ascent, l.baseline + l.descent);
+            for (_, g) in line_glyphs().filter(|(_, g)| g.warichu.is_none()) {
+                let p = layout.logical_point(g.origin);
+                let (f0, f1) = covered(g);
+                out.push(quad(p.x + f0, p.x + f1, t, bt));
+            }
+            out.extend(block_quads(l));
+            if b > l.end {
+                // The selection continues past the line: include the line break / trailing space.
+                let glyphs = layout.glyphs.get(l.glyph_start..l.glyph_end).unwrap_or_default();
+                let last = glyphs.iter().map(|g| layout.logical_point(g.origin).x + g.advance).fold(l.x0, f64::max);
+                out.push(quad(last, last.max(l.x1) + (l.ascent + l.descent) * 0.25, t, bt));
+            }
+            continue;
+        }
         // A list marker before the line's first character is not part of the selection.
         let next = layout.markers.partition_point(|m| m.glyphs.start < l.glyph_start);
         let marked = layout.markers.get(next).is_some_and(|m| m.glyphs.start < l.glyph_end);
diff --git a/crates/text/src/shape.rs b/crates/text/src/shape.rs
index c8c460aa3b..ff79ce9a4c 100644
--- a/crates/text/src/shape.rs
+++ b/crates/text/src/shape.rs
@@ -66,6 +66,8 @@ pub(crate) struct SGlyph {
     pub ch: char,
     /// Vertical type: part of a tate-chu-yoko block (set across the column, upright).
     pub tcy: Option<Tcy>,
+    /// Part of a warichu block (stacked on several lines inside its line, see [`crate::layout`]).
+    pub wari: Option<Wari>,
     /// Japanese composition: the space taken off before the glyph (an opening bracket after
     /// another, see [`crate::layout`]); the glyph is drawn that much earlier on the line.
     pub lead: f64,
@@ -161,9 +163,32 @@ pub(crate) struct Tcy {
     pub right: f64,
 }
 
+/// A glyph's place in a warichu block: the block takes the length of its longest line along its
+/// line, and its glyphs are set on its lines inside that length. The block's first glyph
+/// advances by the whole length and the others by none, as a tate-chu-yoko block's do.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) struct Wari {
+    /// The byte of the block's first glyph, which names the block.
+    pub start: usize,
+    /// Laid-out distance from the block's start to this glyph's pen position (0 for the block's
+    /// first glyph, the block's length for the others).
+    pub pen: f64,
+    /// Where the glyph is drawn, from the block's start along the line.
+    pub along: f64,
+    /// Where the glyph is drawn across the line, from the line's baseline (y down): the
+    /// baseline of the block's line the glyph is on.
+    pub across: f64,
+    /// The glyph's own advance on its block line, in points.
+    pub advance: f64,
+    /// The em of the line the block sits in: the glyph's em without its Warichu Settings Scale.
+    pub em: f64,
+}
+
 impl SGlyph {
+    /// A space between words. Not a space inside a warichu block, which is set with its block and
+    /// takes no part in justifying or breaking its line.
     pub fn is_space(&self) -> bool {
-        self.inline.is_none() && matches!(self.ch, ' ' | '\t' | '\u{3000}' | '\u{2002}'..='\u{200B}')
+        self.inline.is_none() && self.wari.is_none() && matches!(self.ch, ' ' | '\t' | '\u{3000}' | '\u{2002}'..='\u{200B}')
     }
     /// A line may break after this glyph.
     pub fn break_after(&self) -> bool {
@@ -184,6 +209,12 @@ impl SGlyph {
     pub fn continues_tcy(&self) -> bool {
         self.tcy.is_some_and(|t| t.pen > 0.0)
     }
+    /// A tate-chu-yoko glyph after its block's first ([`Self::continues_tcy`]), or a warichu
+    /// glyph after its block's first: justification and Japanese composition add or take no
+    /// space before it, since its block is set as one piece.
+    pub fn continues_block(&self) -> bool {
+        self.continues_tcy() || self.wari.is_some_and(|w| w.pen > 0.0)
+    }
 }
 
 pub(crate) const SOFT_HYPHEN: char = '\u{00AD}';
@@ -940,7 +971,7 @@ fn source_run_at(runs: &[(Range<usize>, &CharStyle)], span: &Range<usize>, byte:
 /// Horizontal type does not read Standard Vertical Roman Alignment or the tate-chu-yoko offsets.
 /// The space before a line's first character ([`space_before`]) and Insert Aki ([`aki`]) come
 /// from the cluster's first character, so they do not split a ligature or a letter from its marks
-/// either.
+/// either. Warichu Settings count only on characters marked Warichu ([`warichu_alike`]).
 fn drawn_alike(a: &CharStyle, b: &CharStyle, vertical: bool) -> bool {
     // Exhaustive, like `shapes_alike`: compare borrowed fields without copying feature lists.
     let CharStyle {
@@ -985,6 +1016,12 @@ fn drawn_alike(a: &CharStyle, b: &CharStyle, vertical: bool) -> bool {
         tcy_up_down,
         tcy_left_right,
         standard_vertical_roman,
+        // Compared by `warichu_alike`.
+        warichu: _,
+        warichu_lines: _,
+        warichu_gap: _,
+        warichu_scale: _,
+        warichu_align: _,
         digits,
         font_height_reference,
         no_break,
@@ -1032,6 +1069,7 @@ fn drawn_alike(a: &CharStyle, b: &CharStyle, vertical: bool) -> bool {
         && kashidas == &b.kashidas
         && proportional_metrics == &b.proportional_metrics
         && tate_chu_yoko == &b.tate_chu_yoko
+        && warichu_alike(a, b)
         && digits == &b.digits
         && font_height_reference == &b.font_height_reference
         && no_break == &b.no_break
@@ -1039,6 +1077,18 @@ fn drawn_alike(a: &CharStyle, b: &CharStyle, vertical: bool) -> bool {
         && glyph_alternate == &b.glyph_alternate
 }
 
+/// Do characters in styles `a` and `b` set warichu alike: neither marked Warichu, whatever their
+/// Warichu Settings (which then take no part in setting them), or both marked with the same
+/// Warichu Settings?
+pub(crate) fn warichu_alike(a: &CharStyle, b: &CharStyle) -> bool {
+    a.warichu == b.warichu
+        && (!a.warichu
+            || (a.warichu_lines == b.warichu_lines
+                && a.warichu_gap == b.warichu_gap
+                && a.warichu_scale == b.warichu_scale
+                && a.warichu_align == b.warichu_align))
+}
+
 /// Do text runs in styles `a` and `b` shape alike, so that they are shaped as one piece of text?
 /// They do when they differ only in paint and stroke, underline and strikethrough, overprint, the
 /// character style's name, leading, baseline shift, rotation, Character Alignment, Character
@@ -1093,6 +1143,14 @@ fn shapes_alike(a: &CharStyle, b: &CharStyle) -> bool {
         tcy_up_down: _,
         tcy_left_right: _,
         standard_vertical_roman: _,
+        // A warichu block is shaped apart from the text around it and from a block with other
+        // settings: its characters are set at their own size and stacked by its settings
+        // ([`warichu_alike`]).
+        warichu: _,
+        warichu_lines: _,
+        warichu_gap: _,
+        warichu_scale: _,
+        warichu_align: _,
         digits,
         font_height_reference,
         no_break,
@@ -1100,6 +1158,7 @@ fn shapes_alike(a: &CharStyle, b: &CharStyle) -> bool {
         glyph_alternate,
     } = a;
     *font_family == b.font_family
+        && warichu_alike(a, b)
         && *font_style == b.font_style
         && *font_version == b.font_version
         && *font_axes == b.font_axes
@@ -1228,6 +1287,7 @@ fn inline_glyph(
         xh,
         ch: text.get(range.clone()).and_then(|s| s.chars().next()).unwrap_or(INLINE_CHAR),
         tcy: None,
+        wari: None,
         lead: 0.0,
         proportional: false,
         vpal: None,
@@ -1711,6 +1771,7 @@ fn shape_segment(text: &str, context: &Range<usize>, seg: &Segment, feats: &OtFe
             xh,
             ch,
             tcy: None,
+            wari: None,
             lead: 0.0,
             proportional: proportional.get(gi).copied().unwrap_or(false),
             vpal: vpal.get(gi).copied().flatten(),
diff --git a/crates/text/src/test_fonts.rs b/crates/text/src/test_fonts.rs
index 8c53e29a04..bdb818d3f3 100644
--- a/crates/text/src/test_fonts.rs
+++ b/crates/text/src/test_fonts.rs
@@ -702,6 +702,36 @@ pub fn lam_alef_font(feature: &[u8; 4]) -> Option<Vec<u8>> {
     Some(builder.build())
 }
 
+/// The family of [`tatweel_font`].
+pub const TATWEEL_FAMILY: &str = "Tatweeltest Sans";
+
+/// A test-only Arabic cmap over bundled Source Sans 3, without Arabic shaping: beh uses b, teh t,
+/// dal d, the tatweel the hyphen and the space the space, so that a justified line takes kashidas
+/// without an OS font. `None` when it can't be built.
+pub fn tatweel_font() -> Option<Vec<u8>> {
+    use write_fonts::tables::cmap::Cmap;
+
+    const BASE: &[u8] = include_bytes!("../../../assets/fonts/SourceSans3-Regular.ttf");
+    let font = skrifa::FontRef::new(BASE).ok()?;
+    let charmap = font.charmap();
+    let mapping = [(' ', ' '), ('\u{0628}', 'b'), ('\u{062A}', 't'), ('\u{062F}', 'd'), ('\u{0640}', '-')];
+    let mappings = mapping.into_iter().map(|(c, source)| Some((c, write_fonts::types::GlyphId::new(charmap.map(source)?.to_u32()))));
+    let cmap = Cmap::from_mappings(mappings.collect::<Option<Vec<_>>>()?).ok()?;
+    let full = format!("{TATWEEL_FAMILY} Regular");
+    let postscript = format!("{}-Regular", TATWEEL_FAMILY.replace(' ', ""));
+    let name = name_table(&[(1, TATWEEL_FAMILY), (2, "Regular"), (4, &full), (6, &postscript)])?;
+    let mut builder = FontBuilder::new();
+    builder.add_table(&cmap).ok()?;
+    builder.add_raw(Tag::new(b"name"), name);
+    for r in font.table_directory.table_records() {
+        let tag = Tag::new(&r.tag().to_be_bytes());
+        if !builder.contains(tag) {
+            builder.add_raw(tag, font.table_data(r.tag())?.as_bytes());
+        }
+    }
+    Some(builder.build())
+}
+
 /// The family of [`alternates_font`] with an `aalt` feature, and without one.
 pub fn alternates_family(aalt: bool) -> &'static str {
     if aalt { "Alttest Sans" } else { "Alttest Sans Noaalt" }
diff --git a/crates/text/src/tests.rs b/crates/text/src/tests.rs
index da3ade59b3..e7e4f33ff6 100644
--- a/crates/text/src/tests.rs
+++ b/crates/text/src/tests.rs
@@ -35,6 +35,7 @@ mod variable;
 mod versions;
 mod vertical;
 mod vietnamese;
+mod warichu;
 
 /// The bundled fonts only: what these tests measure doesn't change with the fonts installed.
 fn db() -> &'static FontDb {
@@ -834,6 +835,29 @@ fn on_path_circle_and_overflow() {
     assert!(l.overflow && l.glyphs.len() < t.plain_text().len());
 }
 
+/// Type on a curve with Spacing, aligned right or centered, is placed by what its glyphs take where
+/// it ends up, which differs from what they take at the start bracket: text that fits shows whole.
+#[test]
+fn on_path_aligned_spaced_text_that_fits_shows_whole() {
+    let circle = PathData::from_bezpath(&kurbo::Circle::new((0.0, 0.0), 200.0).to_path(0.1));
+    for text in ["Hi", "Around"] {
+        for justify in [Justify::Right, Justify::Center] {
+            for spacing in [20.0, -20.0] {
+                for (start, end) in [(0.0, Some(0.05)), (0.3, Some(0.4)), (0.0, None)] {
+                    let mut t = point(text, style(12.0));
+                    t.para.justify = justify;
+                    t.path_spacing = spacing;
+                    t.kind = TextKind::OnPath { path: circle.clone(), start, end };
+                    let l = layout(db(), &t);
+                    let case = format!("{text} {justify:?} {spacing} {start} {end:?}");
+                    assert!(!l.overflow, "{case}");
+                    assert_eq!(l.glyphs.len(), text.len(), "{case}");
+                }
+            }
+        }
+    }
+}
+
 #[test]
 fn fallback_font_per_character() {
     let primary = db().face("Source Sans 3", "Regular").unwrap();
diff --git a/crates/text/src/tests/bidi.rs b/crates/text/src/tests/bidi.rs
index 69f9bdb668..f02db481ab 100644
--- a/crates/text/src/tests/bidi.rs
+++ b/crates/text/src/tests/bidi.rs
@@ -168,6 +168,8 @@ fn lines_of_clusters(lines: &[&[(usize, usize, f64)]], rtl: bool) -> TextLayout
                 carets: Vec::new(),
                 width: advance,
                 width_start: 0.0,
+                warichu: None,
+                warichu_line: 0.0,
             });
             x += advance;
         }
@@ -696,3 +698,170 @@ fn mixed_type_on_a_path_hangs_its_final_period() {
     assert!(l.glyphs.iter().any(|g| g.byte == s.len() - 1), "the period shows");
     assert!(!l.overflow, "all of it fits");
 }
+
+/// `n` Hebrew letters on `path` from `start` to `end` (fractions of its length), one run each, the
+/// letter at `i` tracked so that it takes `steps[i % steps.len()]` points: what each takes with no
+/// tracking is measured first, and what each takes when tracked is checked.
+fn stepped_hebrew(db: &FontDb, n: usize, steps: &[f64], path: &BezPath, (start, end): (f64, Option<f64>)) -> TextObject {
+    let letters = ['א', 'ב', 'ג', 'ד'];
+    let style = CharStyle::default();
+    let mut t = TextObject::point(Point::ZERO, "", style.clone());
+    t.runs = (0..n).map(|i| TextRun { text: letters[i % letters.len()].to_string(), style: style.clone(), inline: None }).collect();
+    let long = kurbo::Line::new((0.0, 0.0), (100_000.0, 0.0)).to_path(0.1);
+    t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&long), start: 0.0, end: None };
+    let advances = |t: &TextObject| {
+        let l = layout(db, t);
+        assert!(!l.overflow);
+        let mut a: Vec<(usize, f64)> = l.glyphs.iter().map(|g| (g.byte, g.advance)).collect();
+        a.sort_by_key(|&(byte, _)| byte);
+        assert_eq!(a.len(), n, "one glyph per letter");
+        a.into_iter().map(|(_, adv)| adv).collect::<Vec<_>>()
+    };
+    let plain = advances(&t);
+    for (i, (run, adv)) in t.runs.iter_mut().zip(&plain).enumerate() {
+        run.style.tracking = (steps[i % steps.len()] - adv) / style.size * 1000.0;
+        assert!((-1000.0..=10000.0).contains(&run.style.tracking), "tracking {} is in the range commands allow", run.style.tracking);
+    }
+    for (i, adv) in advances(&t).into_iter().enumerate() {
+        assert!((adv - steps[i % steps.len()]).abs() < 1e-9, "letter {i} takes {adv}");
+    }
+    t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(path), start, end };
+    t
+}
+
+/// Right-to-left type on a path that overflows shows the longest start of its text whose glyphs
+/// fit, even where a shorter start doesn't fit: a letter tracked to take the line back (a negative
+/// step) lets a longer start fit than the one before it.
+#[test]
+fn overflowing_rtl_type_on_a_path_shows_the_longest_start_that_fits() {
+    use vectorcraft_doc::Justify;
+    let db = FontDb::with_font_dirs(vec![]);
+    // The span runs from x = 0 to x = 10, with path on both sides of it.
+    let line = kurbo::Line::new((-100.0, 0.0), (100.0, 0.0)).to_path(0.1);
+    let t = stepped_hebrew(&db, 4, &[6.0, 6.0, -3.0, 6.0], &line, (0.5, Some(0.55)));
+    // Letters 0 and 1 take 12 points, more than the span holds; letters 0 to 2 take 9 and fit:
+    // in visual order letter 2 (-3), then 1 and 0 (6 each). All four take 15.
+    for (justify, s0) in [(Justify::Right, 1.0), (Justify::Auto, 1.0), (Justify::Center, 0.5), (Justify::Left, 0.0)] {
+        let mut t = t.clone();
+        t.para.justify = justify;
+        let l = layout(&db, &t);
+        assert!(l.overflow, "{justify:?}");
+        assert_eq!(l.lines.first().map(|line| line.end), Some(6), "{justify:?}: the first three letters show");
+        assert_eq!(l.glyphs.len(), 3, "{justify:?}");
+        let x = |byte: usize| l.glyphs.iter().find(|g| g.byte == byte).map(|g| g.origin.x);
+        for (byte, at) in [(4, s0), (2, s0 - 3.0), (0, s0 + 3.0)] {
+            assert!(x(byte).is_some_and(|x| (x - at).abs() < 1e-6), "{justify:?}: letter at byte {byte} at {:?}, not {at}", x(byte));
+        }
+    }
+}
+
+/// The longest start that fits is the one found by arranging every start in turn, in mixed text
+/// whose letters take the line forward and back: with spaces and controls at the end of a start
+/// (UAX #9 L1), isolates, embeddings, several paragraphs and either base direction.
+#[test]
+fn the_longest_rtl_start_on_a_path_is_the_one_each_start_gives() {
+    use vectorcraft_doc::Justify;
+    let db = FontDb::with_font_dirs(vec![]);
+    let texts = [
+        "abc אבג de  שלום  ",
+        "שלום עולם, hello world 123 שלום  ",
+        "a \u{2067}אב \u{2069} cd אב  \u{2066}x ",
+        "אב גד\nef גה  \nשלום ab ",
+        "\u{202B}abc \u{202C} אב \u{200B} cd\u{0301} ",
+    ];
+    let tracking = [-900.0, 300.0, -400.0, 0.0, 800.0, -1000.0, 150.0];
+    let line = kurbo::Line::new((0.0, 0.0), (200.0, 0.0)).to_path(0.1);
+    let mut overflowed = 0;
+    for s in texts {
+        let style = CharStyle::default();
+        let mut t = TextObject::point(Point::ZERO, "", style.clone());
+        t.runs = s
+            .chars()
+            .enumerate()
+            .map(|(i, c)| TextRun { text: c.to_string(), style: CharStyle { tracking: tracking[i % tracking.len()], ..style.clone() }, inline: None })
+            .collect();
+        for direction in [None, Some(ParaDirection::RightToLeft), Some(ParaDirection::LeftToRight)] {
+            for justify in [Justify::Right, Justify::Center, Justify::Left, Justify::Auto] {
+                for end in (1..=25).map(|i| f64::from(i) * 0.02) {
+                    t.para.direction = direction;
+                    t.para.justify = justify;
+                    t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&line), start: 0.0, end: Some(end) };
+                    let (found, each) = (layout(&db, &t), crate::layout::layout_trying_each_start(&db, &t));
+                    let case = format!("{s:?} {direction:?} {justify:?} {end}");
+                    overflowed += usize::from(found.overflow);
+                    assert_eq!(found.overflow, each.overflow, "{case}");
+                    assert_eq!(found.lines.first().map(|l| l.end), each.lines.first().map(|l| l.end), "{case}");
+                    let placed = |l: &TextLayout| l.glyphs.iter().map(|g| (g.byte, g.origin.x)).collect::<Vec<_>>();
+                    assert_eq!(placed(&found), placed(&each), "{case}");
+                }
+            }
+        }
+    }
+    assert!(overflowed > 500, "{overflowed} of the layouts overflow");
+}
+
+/// Finding the longest start that fits in a long right-to-left text whose letters take the line
+/// back does not arrange the glyphs again for every start, nor for a search over them.
+#[test]
+fn the_longest_rtl_start_on_a_path_is_found_without_arranging_each_start() {
+    use vectorcraft_doc::Justify;
+    let db = FontDb::with_font_dirs(vec![]);
+    // Every 4 letters take 15 points, but 2 letters into a group the line is 3 points longer than
+    // after 3: with 940 points, 251 letters (939 points) fit and 250 (942) don't.
+    let line = kurbo::Line::new((0.0, 0.0), (940.0, 0.0)).to_path(0.1);
+    let t = stepped_hebrew(&db, 2000, &[6.0, 6.0, -3.0, 6.0], &line, (0.0, None));
+    let mut cases = Vec::new();
+    for justify in [Justify::Right, Justify::Center, Justify::Left] {
+        let mut t = t.clone();
+        t.para.justify = justify;
+        cases.push((format!("{justify:?}"), t.clone(), 2));
+        // Spacing on a straight path changes no step.
+        t.path_spacing = 5.0;
+        cases.push((format!("{justify:?} spaced"), t.clone(), 2));
+        // Hanging punctuation: starts are arranged one by one, from the longest that could fit.
+        t.path_spacing = 0.0;
+        t.para.roman_hanging = true;
+        cases.push((format!("{justify:?} hanging"), t, 3));
+    }
+    for (case, t, most) in cases {
+        let before = crate::layout::path_arrangements();
+        let l = layout(&db, &t);
+        let arrangements = crate::layout::path_arrangements() - before;
+        assert!(l.overflow, "{case}");
+        assert_eq!(l.lines.first().map(|line| line.end), Some(251 * 'א'.len_utf8()), "{case}: 251 letters show");
+        assert_eq!(l.glyphs.len(), 251, "{case}");
+        assert!(arrangements <= most, "{case}: {arrangements} arrangements");
+    }
+}
+
+/// Long right-to-left type on a curved, spaced path with hanging punctuation, whose letters take the
+/// line forward and back in turn, is arranged a bounded number of times however long the text is,
+/// and the start it shows fits.
+#[test]
+fn rtl_type_on_a_curve_whose_letters_take_the_line_back_is_arranged_a_bounded_number_of_times() {
+    use vectorcraft_doc::Justify;
+    let db = FontDb::with_font_dirs(vec![]);
+    let n = 600;
+    let circle = kurbo::Circle::new((0.0, 0.0), 200.0).to_path(0.1);
+    let t = stepped_hebrew(&db, n, &[6.0, -4.0], &circle, (0.0, Some(0.05)));
+    for justify in [Justify::Right, Justify::Left] {
+        for spacing in [20.0, -20.0] {
+            let mut t = t.clone();
+            t.para.justify = justify;
+            t.para.roman_hanging = true;
+            t.path_spacing = spacing;
+            let case = format!("{justify:?} spacing {spacing}");
+            let before = crate::layout::path_arrangements();
+            let l = layout(&db, &t);
+            let arrangements = crate::layout::path_arrangements() - before;
+            let end = l.lines.first().map_or(0, |line| line.end);
+            // The whole text, at most 32 starts one by one, a binary search over 600, and the start shown.
+            assert!(arrangements <= 44, "{case}: {arrangements} arrangements, overflow {}, end {end}", l.overflow);
+            assert!(l.overflow, "{case}");
+            assert!(end > 0, "{case}: some letters show");
+            assert_eq!(l.glyphs.len(), end / 'א'.len_utf8(), "{case}: every letter of the start shows");
+            let each = crate::layout::layout_trying_each_start(&db, &t);
+            assert!(end <= each.lines.first().map_or(0, |line| line.end), "{case}: no start longer than the longest that fits");
+        }
+    }
+}
diff --git a/crates/text/src/tests/composite.rs b/crates/text/src/tests/composite.rs
index 729afa0d5a..4158d89330 100644
--- a/crates/text/src/tests/composite.rs
+++ b/crates/text/src/tests/composite.rs
@@ -101,9 +101,9 @@ fn ruby_over_composite_type_is_set_in_its_own_parts() {
     assert!(rise > 8.0 && rise < 15.0, "the reading is {rise} pt above the base's baseline");
 }
 
-/// Lent composite fonts are available while a guard lends them: a second guard lends one again, a
-/// font of the same name the database holds is replaced and put back afterwards, and a font named
-/// like an installed family is not lent.
+/// Lent composite fonts are available while a guard lends them, in place of a font of the same name
+/// the database holds, which the database keeps. A font named like an installed family is not
+/// lent, and of two fonts of one name the first is.
 #[test]
 fn lent_composite_fonts_last_as_long_as_a_guard() {
     let db = FontDb::with_font_dirs(vec![]);
@@ -115,6 +115,7 @@ fn lent_composite_fonts_last_as_long_as_a_guard() {
     assert!(db.composite_font("lent").is_some());
     assert_eq!(db.composite_font("Held").unwrap().parts.roman.size, 75.0);
     assert!(db.composite_font("Inter").is_none());
+    assert_eq!(db.composite_font_names(), ["Held"], "the database's own fonts stay");
     let second = db.lend_composite_fonts(&fonts);
     drop(first);
     assert!(db.composite_font("Lent").is_some());
@@ -122,29 +123,97 @@ fn lent_composite_fonts_last_as_long_as_a_guard() {
     drop(second);
     assert!(db.composite_font("Lent").is_none());
     assert_eq!(db.composite_font("Held").unwrap().parts.roman.size, 50.0);
-    // A font set in its place while lent stays when the guard drops.
+    // A font set in the database while one of that name is lent doesn't change the one in use, and
+    // is used once the guard drops.
     let lent = db.lend_composite_fonts(&fonts[..1]);
     let mut replaced = mixed("Lent");
     replaced.parts.roman.size = 60.0;
     db.set_composite_font(&replaced);
+    assert_eq!(db.composite_font("Lent").unwrap().parts.roman.size, 50.0);
     drop(lent);
     assert_eq!(db.composite_font("Lent").unwrap().parts.roman.size, 60.0);
-    // So does the same definition set while lent, after every guard lending it drops.
-    assert!(db.remove_composite_font("Lent"));
-    let (one, two) = (db.lend_composite_fonts(&fonts[..1]), db.lend_composite_fonts(&fonts[..1]));
-    assert!(!db.set_composite_font(&fonts[0]));
-    drop(one);
-    drop(two);
-    assert!(db.composite_font("Lent").is_some());
-    // A guard whose font was removed doesn't give back a later guard's loan of that name.
-    assert!(db.remove_composite_font("Lent"));
-    let old = db.lend_composite_fonts(&fonts[..1]);
-    assert!(db.remove_composite_font("Lent"));
-    let new = db.lend_composite_fonts(&fonts[..1]);
-    drop(old);
-    assert!(db.composite_font("Lent").is_some());
-    drop(new);
-    assert!(db.composite_font("Lent").is_none());
+    let mut other = mixed("LENT");
+    other.parts.roman.size = 70.0;
+    let lent = db.lend_composite_fonts(&[mixed("Lent"), other]);
+    assert_eq!(db.composite_font("lent").unwrap().parts.roman.size, 50.0);
+    drop(lent);
+}
+
+/// A composite font `name` whose Roman part is set at `size` percent.
+fn roman_at(name: &str, size: f64) -> CompositeFont {
+    let mut f = mixed(name);
+    f.parts.roman.size = size;
+    f
+}
+
+/// The advance of `A` set at `size` points in `family`.
+fn advance(db: &FontDb, family: &str, size: f64) -> f64 {
+    layout(db, &TextObject::point(Point::ZERO, "A", style(family, size))).glyphs[0].advance
+}
+
+/// Two documents that define one name differently each lay out in their own definition, also when
+/// one's guard lends inside the other's (a document placed in another): the inner definition is
+/// used until its guard drops, then the outer one again, also after a panic inside the inner one.
+/// The generation tells the layouts apart, and lending changes nothing the database holds.
+#[test]
+fn nested_loans_of_one_name_use_each_documents_definition() {
+    let db = FontDb::with_font_dirs(vec![]);
+    let (a, b) = (roman_at("CF Shared", 50.0), roman_at("CF Shared", 75.0));
+    db.set_composite_font(&a);
+    let (half, three_quarters) = (advance(&db, "JetBrains Mono", 10.0), advance(&db, "JetBrains Mono", 15.0));
+    // Lending looks the name up among the installed families, which catalogs them the first time.
+    assert!(!db.has_installed_family("CF Shared"));
+    let plain = db.generation();
+    let outer = db.lend_composite_fonts(std::slice::from_ref(&a));
+    assert_eq!(db.generation(), plain, "the database's own definition");
+    assert!((advance(&db, "CF Shared", 20.0) - half).abs() < 1e-9);
+    {
+        let _inner = db.lend_composite_fonts(std::slice::from_ref(&b));
+        assert_eq!(db.composite_font("cf shared").unwrap().parts.roman.size, 75.0);
+        assert!((advance(&db, "CF Shared", 20.0) - three_quarters).abs() < 1e-9);
+        assert_ne!(db.generation(), plain, "another definition lays out under another generation");
+        let elsewhere =
+            std::thread::scope(|s| s.spawn(|| (db.generation(), db.composite_font("CF Shared").unwrap().parts.roman.size)).join().unwrap());
+        assert_eq!(elsewhere, (plain, 50.0), "other threads keep the database's");
+    }
+    assert!((advance(&db, "CF Shared", 20.0) - half).abs() < 1e-9);
+    assert_eq!(db.generation(), plain);
+    let caught = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        let _inner = db.lend_composite_fonts(std::slice::from_ref(&b));
+        panic!("a render that fails");
+    }));
+    assert!(caught.is_err());
+    assert_eq!(db.composite_font("CF Shared").unwrap().parts.roman.size, 50.0);
+    drop(outer);
+    let next = db.lend_composite_fonts(std::slice::from_ref(&b));
+    assert_eq!(db.composite_font("CF Shared").unwrap().parts.roman.size, 75.0);
+    drop(next);
+    assert_eq!(db.composite_font("CF Shared").unwrap().parts.roman.size, 50.0);
+    assert_eq!(db.generation(), plain);
+}
+
+/// Two threads that lend different definitions of one name at once each lay out in their own.
+#[test]
+fn threads_lending_one_name_at_once_use_their_own_definitions() {
+    let db = FontDb::with_font_dirs(vec![]);
+    let (half, three_quarters) = (advance(&db, "JetBrains Mono", 10.0), advance(&db, "JetBrains Mono", 15.0));
+    let (both_lent, both_read) = (std::sync::Barrier::new(2), std::sync::Barrier::new(2));
+    let lend = |size: f64| {
+        let _lent = db.lend_composite_fonts(&[roman_at("CF Threads", size)]);
+        both_lent.wait();
+        let read = (advance(&db, "CF Threads", 20.0), db.generation());
+        both_read.wait();
+        read
+    };
+    let ((a, ga), (b, gb)) = std::thread::scope(|s| {
+        let a = s.spawn(|| lend(50.0));
+        let b = s.spawn(|| lend(75.0));
+        (a.join().unwrap(), b.join().unwrap())
+    });
+    assert!((a - half).abs() < 1e-9, "{a} vs {half}");
+    assert!((b - three_quarters).abs() < 1e-9, "{b} vs {three_quarters}");
+    assert_ne!(ga, gb);
+    assert!(db.composite_font("CF Threads").is_none());
 }
 
 /// The fonts a composite font sets text in are those of the parts its characters fall in, and
diff --git a/crates/text/src/tests/harakat.rs b/crates/text/src/tests/harakat.rs
index b50b39da83..ea84bcf346 100644
--- a/crates/text/src/tests/harakat.rs
+++ b/crates/text/src/tests/harakat.rs
@@ -609,6 +609,8 @@ fn duplicate_authored_glyphs_keep_occurrence_order() {
         carets: Vec::new(),
         width: 0.0,
         width_start: 0.0,
+        warichu: None,
+        warichu_line: 0.0,
     };
     let before = TextLayout { glyphs: vec![glyph(0), glyph(1)], ..TextLayout::default() };
     assert_eq!(assert_kashida_ownership(&text, &before, &before, &red(), "duplicate glyphs", false), 0);
diff --git a/crates/text/src/tests/justify.rs b/crates/text/src/tests/justify.rs
index 8212a652e3..bc1e5b1b13 100644
--- a/crates/text/src/tests/justify.rs
+++ b/crates/text/src/tests/justify.rs
@@ -540,6 +540,134 @@ fn a_justified_right_to_left_line_with_a_tab_spans_its_measure() {
     assert!((l.lines[0].x1 - 300.0).abs() < 1e-6, "{}", l.lines[0].x1);
 }
 
+/// Right-to-left area type `text` in a frame `width` wide, aligned as `justify`, with tab stops at
+/// `stops` (position and alignment).
+fn rtl_tabbed(text: &str, width: f64, stops: &[(f64, TabAlign)], justify: Justify) -> TextLayout {
+    let mut t = area(text, width, justify, no_ranges());
+    t.para.tabs = stops.iter().map(|&(position, align)| TabStop { position, align, leader: String::new(), align_on: '.' }).collect();
+    layout(db(), &t)
+}
+
+/// Where the glyphs of line `k` that are not spaces start and end, as drawn.
+fn drawn_extent(l: &TextLayout, text: &str, k: usize) -> (f64, f64) {
+    let ink = l.glyphs.iter().filter(|g| g.line == k && !text[g.byte..].starts_with(' '));
+    ink.fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), g| (lo.min(g.origin.x), hi.max(g.origin.x + g.advance)))
+}
+
+/// A right-to-left line with a tab is measured as it is drawn: right aligned (and Auto, which
+/// aligns it right) it ends on the frame's right edge, and centered it leaves as much room at
+/// each side.
+#[test]
+fn a_right_to_left_line_with_a_tab_is_aligned_as_it_is_drawn() {
+    let text = "אב גד\tהו זח";
+    for justify in [Justify::Right, Justify::Auto, Justify::Center] {
+        let l = rtl_tabbed(text, 300.0, &[(150.0, TabAlign::Left)], justify);
+        assert_eq!(l.lines.len(), 1, "{justify:?}");
+        let (left, right) = drawn_extent(&l, text, 0);
+        if justify == Justify::Center {
+            assert!((left - (300.0 - right)).abs() < 1e-6, "{justify:?}: centered as drawn: {left} {right}");
+        } else {
+            assert!((right - 300.0).abs() < 1e-6, "{justify:?}: ends on the right edge: {right}");
+        }
+        assert!((l.lines[0].x1 - right).abs() < 1e-6, "{justify:?}: the line's record ends where it is drawn: {}", l.lines[0].x1);
+    }
+}
+
+/// Point type: a right-aligned right-to-left line with a tab ends at the origin as drawn.
+#[test]
+fn right_aligned_right_to_left_point_type_with_a_tab_ends_at_its_origin() {
+    let text = "אב גד\tהו זח";
+    let mut t = point(text, no_ranges());
+    t.para.justify = Justify::Right;
+    t.para.tabs = vec![TabStop { position: 150.0, align: TabAlign::Left, leader: String::new(), align_on: '.' }];
+    let l = layout(db(), &t);
+    let (_, right) = drawn_extent(&l, text, 0);
+    assert!(right.abs() < 1e-6, "ends at the origin: {right}");
+}
+
+/// A right-to-left line with a tab breaks where it fits as drawn: in a frame it fits only in the
+/// order of its text, it wraps, and every line stays inside the frame.
+#[test]
+fn a_right_to_left_line_with_a_tab_wraps_when_it_does_not_fit_as_drawn() {
+    // א (0), ב (2), space (4), ג (5), ד (7), tab (9), ה (10), ו (12), space (14), ז (15), ח (17).
+    let text = "אב גד\tהו זח";
+    let wide = rtl_tabbed(text, 1000.0, &[(150.0, TabAlign::Left)], Justify::Left);
+    let span = |from: usize, to: usize| -> f64 { wide.glyphs.iter().filter(|g| (from..to).contains(&g.byte)).map(|g| g.advance).sum() };
+    // Drawn, the text before the tab comes after it: the line is 150 pt and that text wide.
+    let (before, after) = (span(0, 9), span(10, 19));
+    assert!(before > after + 1.0, "the test needs the text before the tab wider: {before} {after}");
+    let width = 150.0 + (before + after) / 2.0;
+    let l = rtl_tabbed(text, width, &[(150.0, TabAlign::Left)], Justify::Right);
+    assert!(l.lines.len() >= 2, "wraps: {} line(s)", l.lines.len());
+    for k in 0..l.lines.len() {
+        let (left, right) = drawn_extent(&l, text, k);
+        assert!(left >= -1e-6 && right <= width + 1e-6, "line {k} stays in the frame: {left} {right} (frame {width})");
+    }
+}
+
+/// Right, center and decimal stops align the text drawn after the tab, which in a right-to-left
+/// line is the text before it.
+#[test]
+fn right_to_left_tab_stops_align_the_text_drawn_after_them() {
+    // מ (0), מ (2), tab (4), ו (5), ו (7): drawn, וו comes first and ממ after the tab.
+    let text = "ממ\tוו";
+    let mem = |l: &TextLayout| -> (f64, f64) {
+        l.glyphs
+            .iter()
+            .filter(|g| g.byte < 4)
+            .fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), g| (lo.min(g.origin.x), hi.max(g.origin.x + g.advance)))
+    };
+    let right = rtl_tabbed(text, 300.0, &[(150.0, TabAlign::Right)], Justify::Left);
+    assert!((mem(&right).1 - 150.0).abs() < 1e-6, "right stop: ends on the stop: {:?}", mem(&right));
+    let center = rtl_tabbed(text, 300.0, &[(150.0, TabAlign::Center)], Justify::Left);
+    let (lo, hi) = mem(&center);
+    assert!(((lo + hi) / 2.0 - 150.0).abs() < 1e-6, "center stop: centered on the stop: {lo} {hi}");
+    // 1 (0), . (1), 5 (2), tab (3), מ (4), מ (6): drawn, ממ comes first and 1.5 after the tab.
+    let decimal = rtl_tabbed("1.5\tממ", 300.0, &[(150.0, TabAlign::Decimal)], Justify::Left);
+    assert!((at(&decimal, 1).origin.x - 150.0).abs() < 1e-6, "decimal stop: the point on the stop: {}", at(&decimal, 1).origin.x);
+}
+
+/// Two tabs around a left-to-right run in a right-to-left line: each takes its stop in drawing
+/// order, and the right-aligned line ends on the right edge as drawn.
+#[test]
+fn a_right_to_left_line_with_two_tabs_and_a_latin_run_ends_on_the_right_edge() {
+    // מ (0), מ (2), tab (4), A B space C D (5..10), tab (10), ו (11), ו (13).
+    let text = "ממ\tAB CD\tוו";
+    let l = rtl_tabbed(text, 300.0, &[(80.0, TabAlign::Left), (160.0, TabAlign::Left)], Justify::Right);
+    assert_eq!(l.lines.len(), 1);
+    let (_, right) = drawn_extent(&l, text, 0);
+    assert!((right - 300.0).abs() < 1e-6, "ends on the right edge: {right}");
+    assert!(at(&l, 5).origin.x < at(&l, 6).origin.x, "the Latin run keeps its order");
+}
+
+/// A right-to-left line with a tab and more breaks than are measured as drawn stays one line when
+/// it fits the frame.
+#[test]
+fn a_long_right_to_left_line_with_a_tab_that_fits_stays_one_line() {
+    let text = format!("א\t{}", "ב ".repeat(400));
+    let l = rtl_tabbed(&text, 100_000.0, &[(150.0, TabAlign::Left)], Justify::Right);
+    assert_eq!(l.lines.len(), 1, "one line");
+}
+
+/// A right-to-left line with a tab and more breaks than are measured one by one still wraps when
+/// it fits only in the order of its text, and every line stays inside the frame.
+#[test]
+fn a_right_to_left_line_with_a_tab_and_many_breaks_wraps_when_it_does_not_fit_as_drawn() {
+    // אב גד, a tab, הו, 400 soft hyphens (each a break), a space and זח.
+    let text = format!("אב גד\tהו{} זח", "\u{AD}".repeat(400));
+    let wide = rtl_tabbed(&text, 10_000.0, &[(150.0, TabAlign::Left)], Justify::Left);
+    let span = |from: usize, to: usize| -> f64 { wide.glyphs.iter().filter(|g| (from..to).contains(&g.byte)).map(|g| g.advance).sum() };
+    let (before, after) = (span(0, 9), span(10, text.len()));
+    assert!(before > after + 1.0, "the test needs the text before the tab wider: {before} {after}");
+    let width = 150.0 + (before + after) / 2.0;
+    let l = rtl_tabbed(&text, width, &[(150.0, TabAlign::Left)], Justify::Right);
+    assert!(l.lines.len() >= 2, "wraps: {} line(s)", l.lines.len());
+    for k in 0..l.lines.len() {
+        let (left, right) = drawn_extent(&l, &text, k);
+        assert!(left >= -1e-6 && right <= width + 1e-6, "line {k} stays in the frame: {left} {right} (frame {width})");
+    }
+}
+
 /// Point type has no measure to fill: a justified line with a tab keeps its natural width.
 #[test]
 fn justified_point_type_with_a_tab_keeps_its_width() {
diff --git a/crates/text/src/tests/warichu.rs b/crates/text/src/tests/warichu.rs
new file mode 100644
index 0000000000..d68cb8fccc
--- /dev/null
+++ b/crates/text/src/tests/warichu.rs
@@ -0,0 +1,620 @@
+//! Warichu (Character panel menu › Warichu and Warichu Settings): marked characters set smaller
+//! and stacked on lines inside their line. Bundled fonts: in vertical type `§` stands upright like
+//! CJK.
+use super::{area, db, point, serif, style};
+use crate::*;
+use kurbo::Shape;
+use vectorcraft_doc::{CharStyle, Justify, TextKind, TextRun, WarichuAlign};
+use vectorcraft_geom::PathData;
+
+fn marked(size: f64) -> CharStyle {
+    CharStyle { warichu: true, ..style(size) }
+}
+
+/// "ab", then `inside` in `st`, then "z", as point type at the origin.
+fn with_block(inside: &str, st: CharStyle) -> TextObject {
+    let mut t = point("", style(20.0));
+    t.xf = Affine::IDENTITY;
+    t.runs = vec![TextRun::new("ab", style(20.0)), TextRun::new(inside, st), TextRun::new("z", style(20.0))];
+    t
+}
+
+fn ink(l: &TextLayout, i: usize) -> Rect {
+    l.glyphs[i].outline.bounding_box()
+}
+
+/// Two lines by default, at 50% of the size: the first two of four characters on a line above the
+/// other two, both lines starting where the block starts, and the text after the block starting
+/// where the longer line ends. The lines are one warichu em apart, and the stack is centered
+/// across the line on the line's ideographic em box.
+#[test]
+fn warichu_stacks_the_characters_on_two_lines_at_half_size() {
+    let l = layout(db(), &with_block("cdef", marked(20.0)));
+    let plain = layout(db(), &with_block("cdef", style(20.0)));
+    let (c, d, e, f, z) = (&l.glyphs[2], &l.glyphs[3], &l.glyphs[4], &l.glyphs[5], &l.glyphs[6]);
+    // Half size: half the ink height and half the advance of the same letter in the line.
+    let ratio = ink(&l, 2).height() / ink(&plain, 2).height();
+    assert!((ratio - 0.5).abs() < 1e-6, "{ratio}");
+    assert!((c.advance - plain.glyphs[2].advance * 0.5).abs() < 1e-6);
+    // Two lines: c and d on the first, e and f on the second, starting where the block starts.
+    assert!((c.origin.y - d.origin.y).abs() < 1e-9 && (e.origin.y - f.origin.y).abs() < 1e-9);
+    assert!((e.origin.y - c.origin.y - 10.0).abs() < 1e-6, "one em of 10 pt apart: {:?} {:?}", c.origin, e.origin);
+    assert!((c.origin.x - e.origin.x).abs() < 1e-9);
+    assert!((c.origin.x - plain.glyphs[2].origin.x).abs() < 1e-9, "the block starts where the text would");
+    // The block is as long as its longer line, and the text after it follows on.
+    let block = (c.advance + d.advance).max(e.advance + f.advance);
+    assert!((z.origin.x - c.origin.x - block).abs() < 1e-6, "{} {}", z.origin.x - c.origin.x, block);
+    assert!((z.origin.y - l.glyphs[0].origin.y).abs() < 1e-9, "the line's own baseline");
+    // Centered on the line's ideographic em box (0.12 em below the baseline to 0.88 em above it
+    // for a font without ideographs): the two 10 pt em boxes fill the 20 pt one, so the first
+    // line's baseline is 8.8 pt above the line's and the second's 1.2 pt below it.
+    let baseline = z.origin.y;
+    assert!((c.origin.y - (baseline - 8.8)).abs() < 1e-6, "{} {baseline}", c.origin.y);
+    assert!((e.origin.y - (baseline + 1.2)).abs() < 1e-6, "{} {baseline}", e.origin.y);
+    // Every glyph of the block is on the first line of the text.
+    assert!(l.glyphs.iter().all(|g| g.line == 0));
+}
+
+/// Warichu Settings: Lines sets how many lines the block is stacked on, Line Gap adds space
+/// between them, and Scale sets the size as a percentage.
+#[test]
+fn warichu_settings_set_the_lines_their_gap_and_the_scale() {
+    let st = CharStyle { warichu_lines: 3, warichu_gap: 4.0, warichu_scale: 30.0, ..marked(20.0) };
+    let l = layout(db(), &with_block("cdefgh", st));
+    let plain = layout(db(), &with_block("cdefgh", style(20.0)));
+    let ys: Vec<f64> = l.glyphs[2..8].iter().map(|g| g.origin.y).collect();
+    let mut lines = ys.clone();
+    lines.dedup_by(|a, b| (*a - *b).abs() < 1e-9);
+    assert_eq!(lines.len(), 3, "{ys:?}");
+    for pair in lines.windows(2) {
+        assert!((pair[1] - pair[0] - (6.0 + 4.0)).abs() < 1e-6, "an em of 6 pt plus the gap: {lines:?}");
+    }
+    let ratio = ink(&l, 2).height() / ink(&plain, 2).height();
+    assert!((ratio - 0.3).abs() < 1e-6, "{ratio}");
+    // One line: the characters keep to one smaller line centered on the line.
+    let one = layout(db(), &with_block("cd", CharStyle { warichu_lines: 1, ..marked(20.0) }));
+    assert!((one.glyphs[2].origin.y - one.glyphs[3].origin.y).abs() < 1e-9);
+    assert!(one.glyphs[3].origin.x > one.glyphs[2].origin.x);
+    // A block has no more lines than characters.
+    let two = layout(db(), &with_block("cd", CharStyle { warichu_lines: 6, ..marked(20.0) }));
+    assert!((two.glyphs[3].origin.y - two.glyphs[2].origin.y - 10.0).abs() < 1e-6);
+}
+
+/// Alignment: the shorter line is set at the start of the block, centered, at its end or spread
+/// to its length; Auto spreads every line but the last.
+#[test]
+fn warichu_alignment_sets_the_lines_along_the_block() {
+    // Where each line of a two-line block of four letters starts and ends along the block, and the
+    // block's length.
+    let at = |text: &str, align: WarichuAlign| {
+        let l = layout(db(), &with_block(text, CharStyle { warichu_align: align, ..marked(20.0) }));
+        let g = &l.glyphs[2..6];
+        let line = |a: &PositionedGlyph, b: &PositionedGlyph| (a.origin.x - g[0].origin.x, b.origin.x + b.advance - g[0].origin.x);
+        let block = l.glyphs[6].origin.x - g[0].origin.x;
+        (line(&g[0], &g[1]), line(&g[2], &g[3]), block)
+    };
+    // "mm" then "mi": the second, last line is shorter.
+    let (first, (start, end), block) = at("mmmi", WarichuAlign::Left);
+    assert!(first.0.abs() < 1e-9 && (first.1 - block).abs() < 1e-6, "the longer line fills the block");
+    assert!(start.abs() < 1e-9 && end < block - 1.0);
+    let (_, (start, end), block) = at("mmmi", WarichuAlign::Right);
+    assert!((end - block).abs() < 1e-6 && start > 1.0);
+    let (_, (start, end), block) = at("mmmi", WarichuAlign::Center);
+    assert!((start - (block - end)).abs() < 1e-6 && start > 0.5);
+    // The last line of a justified block: set left, centered or right, or spread with JustifyAll.
+    let (_, (start, _), _) = at("mmmi", WarichuAlign::JustifyLeft);
+    assert!(start.abs() < 1e-9);
+    let (_, (_, end), block) = at("mmmi", WarichuAlign::JustifyRight);
+    assert!((end - block).abs() < 1e-6);
+    let (_, (start, end), block) = at("mmmi", WarichuAlign::JustifyCenter);
+    assert!((start - (block - end)).abs() < 1e-6 && start > 0.5);
+    let (_, (start, end), block) = at("mmmi", WarichuAlign::JustifyAll);
+    assert!(start.abs() < 1e-9 && (end - block).abs() < 1e-6);
+    // "im" then "mm": the shorter first line is spread to the block's length by every justified
+    // alignment and by Auto, and not by Left.
+    for align in [WarichuAlign::Auto, WarichuAlign::JustifyLeft, WarichuAlign::JustifyCenter, WarichuAlign::JustifyRight, WarichuAlign::JustifyAll] {
+        let ((start, end), _, block) = at("immm", align);
+        assert!(start.abs() < 1e-9 && (end - block).abs() < 1e-6, "{align:?}: {start} {end} {block}");
+    }
+    let ((_, end), _, block) = at("immm", WarichuAlign::Left);
+    assert!(end < block - 1.0);
+    assert_eq!(at("mmmi", WarichuAlign::Auto), at("mmmi", WarichuAlign::JustifyLeft));
+}
+
+/// A warichu block stays whole on one line: area type breaks before or after it, never inside it,
+/// and a block longer than the line runs past its end.
+#[test]
+fn a_warichu_block_does_not_break_across_lines() {
+    let mut t = area("", style(20.0), Rect::new(0.0, 0.0, 60.0, 400.0), Justify::Left);
+    t.runs = vec![TextRun::new("ab ", style(20.0)), TextRun::new("cd efgh ijkl mnop qrst", marked(20.0)), TextRun::new(" z", style(20.0))];
+    let l = layout(db(), &t);
+    let block: Vec<usize> = l.glyphs.iter().filter(|g| (3..25).contains(&g.byte)).map(|g| g.line).collect();
+    assert!(!block.is_empty());
+    assert!(block.iter().all(|&line| line == block[0]), "{block:?}");
+    assert!(l.glyphs.iter().any(|g| g.line != block[0]), "the text around it breaks");
+}
+
+/// Vertical type: the lines of a block stand side by side across the column, the first to the
+/// right, each running down from where the block starts.
+#[test]
+fn vertical_warichu_sets_the_lines_side_by_side() {
+    let mut t = point("", style(20.0));
+    t.xf = Affine::IDENTITY;
+    t.vertical = true;
+    t.runs = vec![TextRun::new("§", style(20.0)), TextRun::new("§§§§", marked(20.0)), TextRun::new("§", style(20.0))];
+    let l = layout(db(), &t);
+    let (a, b, c) = (ink(&l, 1), ink(&l, 2), ink(&l, 3));
+    assert!((a.center().x - b.center().x).abs() < 1e-6, "one line down the column");
+    assert!(c.center().x < a.center().x - 5.0, "the second line is to the left: {a:?} {c:?}");
+    assert!((a.y0 - c.y0).abs() < 1e-6, "both lines start where the block starts");
+    // The column's center lies between the two lines, and the character after the block follows
+    // the longer line.
+    let column = ink(&l, 0).center().x;
+    assert!((((a.center().x + c.center().x) * 0.5) - column).abs() < 1.0, "{column} {a:?} {c:?}");
+    assert!(ink(&l, 5).y0 > b.y1, "{:?} {b:?}", ink(&l, 5));
+}
+
+/// Vertical point type that starts with warichu keeps its anchor on the column's center line, as
+/// the column has the size of its text.
+#[test]
+fn vertical_point_type_starting_with_warichu_keeps_its_anchor() {
+    let column = |runs: Vec<TextRun>| {
+        let mut t = point("", style(20.0));
+        t.xf = Affine::IDENTITY;
+        t.vertical = true;
+        t.runs = runs;
+        let l = layout(db(), &t);
+        ink(&l, l.glyphs.len() - 1).center().x
+    };
+    let plain = column(vec![TextRun::new("§", style(20.0))]);
+    let after = column(vec![TextRun::new("§§", marked(20.0)), TextRun::new("§", style(20.0))]);
+    assert!((plain - after).abs() < 1e-6, "{plain} {after}");
+}
+
+/// Every character of a block, a space at its end too, keeps its advance inside the block, and a
+/// block of spaces alone keeps their length.
+#[test]
+fn spaces_keep_their_advance_inside_a_block() {
+    for inside in ["cdef ", "  "] {
+        let l = layout(db(), &with_block(inside, marked(20.0)));
+        let n = inside.len();
+        let (start, end) = (l.glyphs[2].origin.x.min(l.glyphs[2 + n - 1].origin.x), l.glyphs[2 + n].origin.x);
+        assert!(end > start, "{inside:?}");
+        for g in &l.glyphs[2..2 + n] {
+            assert!(g.origin.x >= start - 1e-9 && g.origin.x + g.advance <= end + 1e-9, "{inside:?}: {:?} {} {start} {end}", g.origin, g.advance);
+        }
+    }
+}
+
+/// In vertical type, characters marked Tate-chu-yoko as well are set across the column at their
+/// own size, and digits marked Warichu are stacked rather than set across the column.
+#[test]
+fn vertical_tate_chu_yoko_wins_and_warichu_digits_stack() {
+    let column = |runs: Vec<TextRun>| {
+        let mut t = point("", style(20.0));
+        t.xf = Affine::IDENTITY;
+        t.vertical = true;
+        t.runs = runs;
+        layout(db(), &t)
+    };
+    let both = column(vec![TextRun::new("AB", CharStyle { tate_chu_yoko: true, ..marked(20.0) })]);
+    let tcy = column(vec![TextRun::new("AB", CharStyle { tate_chu_yoko: true, ..style(20.0) })]);
+    assert_eq!(ink(&both, 0), ink(&tcy, 0));
+    assert_eq!(ink(&both, 1), ink(&tcy, 1));
+    // "10" alone would stand across the column; marked Warichu its digits are stacked, the 1 to
+    // the right of the 0.
+    let digits = column(vec![TextRun::new("10", marked(20.0))]);
+    assert!(ink(&digits, 0).center().x > ink(&digits, 1).center().x + 2.0, "{:?} {:?}", ink(&digits, 0), ink(&digits, 1));
+    assert!((ink(&digits, 0).y0 - ink(&digits, 1).y0).abs() < 2.0, "both start where the block starts");
+}
+
+/// A line holding only a warichu block keeps the leading of the block's own size, with the default
+/// Auto Leading and with the paragraph's own.
+#[test]
+fn a_warichu_line_keeps_the_auto_leading_of_its_own_size() {
+    for auto in [120.0, 150.0] {
+        let gap = |first: CharStyle| {
+            let mut t = point("", style(20.0));
+            t.xf = Affine::IDENTITY;
+            t.para.justification.auto_leading = auto;
+            t.runs = vec![TextRun::new("cd", first), TextRun::new("\u{2028}z", style(20.0))];
+            let l = layout(db(), &t);
+            l.lines[1].baseline - l.lines[0].baseline
+        };
+        let (block, plain) = (gap(marked(20.0)), gap(style(20.0)));
+        assert!((block - plain).abs() < 1e-6, "{auto}%: {block} {plain}");
+    }
+}
+
+/// Area type that starts with warichu sets its first baseline as for text of the block's own size,
+/// whatever the First Baseline setting.
+#[test]
+fn the_first_baseline_measures_a_block_at_its_own_size() {
+    use vectorcraft_doc::FirstBaseline;
+    for first in [FirstBaseline::Ascent, FirstBaseline::CapHeight, FirstBaseline::XHeight, FirstBaseline::Leading] {
+        let baseline = |inside: CharStyle| {
+            let mut t = area("", style(20.0), Rect::new(0.0, 0.0, 300.0, 300.0), Justify::Left);
+            t.area.first_baseline = first;
+            t.runs = vec![TextRun::new("cd", inside)];
+            layout(db(), &t).lines[0].baseline
+        };
+        let (block, plain) = (baseline(marked(20.0)), baseline(style(20.0)));
+        assert!((block - plain).abs() < 1e-6 || block > plain, "{first:?}: {block} {plain}");
+        if first != FirstBaseline::Ascent {
+            assert!((block - plain).abs() < 1e-6, "{first:?}: {block} {plain}");
+        }
+    }
+}
+
+/// Mixed right-to-left and left-to-right text in a line of a block is set in its bidi order.
+#[test]
+fn a_warichu_line_sets_mixed_text_in_bidi_order() {
+    let l = layout(db(), &with_block("אב12", CharStyle { warichu_lines: 1, ..marked(20.0) }));
+    let at = |byte: usize| l.glyphs.iter().find(|g| g.byte == byte).unwrap().origin.x;
+    let (alef, bet, one, two) = (at(2), at(4), at(6), at(7));
+    assert!(one < two && two < bet && bet < alef, "{one} {two} {bet} {alef}");
+}
+
+/// Insert Aki before the block's first character and after its last is space before and after the
+/// block.
+#[test]
+fn insert_aki_spaces_the_block() {
+    let at = |aki: (f64, f64)| {
+        let mut t = with_block("cd", marked(20.0));
+        t.runs = vec![
+            TextRun::new("ab", style(20.0)),
+            TextRun::new("c", CharStyle { aki_left: aki.0, ..marked(20.0) }),
+            TextRun::new("d", CharStyle { aki_right: aki.1, ..marked(20.0) }),
+            TextRun::new("z", style(20.0)),
+        ];
+        let l = layout(db(), &t);
+        (l.glyphs[2].origin.x, l.glyphs[4].origin.x)
+    };
+    let (c, z) = at((0.0, 0.0));
+    let (c2, z2) = at((500.0, 250.0));
+    assert!((c2 - c - 5.0).abs() < 1e-6, "half an em of 10 pt before: {c} {c2}");
+    assert!((z2 - z - 7.5).abs() < 1e-6, "and a quarter after: {z} {z2}");
+    // Right to left, the space before the first character is on the block's right.
+    let rtl = |aki: f64| {
+        let mut t = with_block("", marked(20.0));
+        t.runs =
+            vec![TextRun::new("ab", style(20.0)), TextRun::new("אב", CharStyle { aki_left: aki, ..marked(20.0) }), TextRun::new("z", style(20.0))];
+        let l = layout(db(), &t);
+        let at = |byte: usize| l.glyphs.iter().find(|g| g.byte == byte).unwrap().origin.x;
+        (at(2).min(at(4)), at(6))
+    };
+    let ((left, z), (left2, z2)) = (rtl(0.0), rtl(500.0));
+    assert!((left2 - left).abs() < 1e-6 && z2 > z, "{left} {left2} {z} {z2}");
+}
+
+/// Type on a path sets warichu characters at their own size along the path, without stacking them.
+#[test]
+fn type_on_a_path_does_not_stack_warichu() {
+    let mut t = with_block("cdef", marked(20.0));
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&kurbo::Line::new((0.0, 0.0), (400.0, 0.0)).to_path(0.1)), start: 0.0, end: None };
+    let mut plain = with_block("cdef", style(20.0));
+    plain.kind = t.kind.clone();
+    let (l, p) = (layout(db(), &t), layout(db(), &plain));
+    // The block's characters are set where the same characters without the mark are (the pair
+    // spacing after the block may differ, since the block is shaped apart from the text after it).
+    let placed = |l: &TextLayout| l.glyphs[..6].iter().map(|g| g.origin).collect::<Vec<_>>();
+    assert_eq!(placed(&l), placed(&p));
+}
+
+/// A line may break between two blocks with different settings, and a block longer than its line
+/// stays whole.
+#[test]
+fn lines_break_between_blocks_and_a_long_block_stays_whole() {
+    let mut t = area("", style(20.0), Rect::new(0.0, 0.0, 30.0, 400.0), Justify::Left);
+    let other = CharStyle { warichu_lines: 3, ..marked(20.0) };
+    t.runs = vec![TextRun::new("mmmm", marked(20.0)), TextRun::new("mmmmmm", other), TextRun::new("mmmmmmmmmmmmmmmmmmmm", marked(20.0))];
+    let l = layout(db(), &t);
+    let lines = |r: std::ops::Range<usize>| l.glyphs.iter().filter(|g| r.contains(&g.byte)).map(|g| g.line).collect::<Vec<_>>();
+    let (a, b, c) = (lines(0..4), lines(4..10), lines(10..30));
+    assert!(a.iter().all(|&x| x == a[0]) && b.iter().all(|&x| x == b[0]) && c.iter().all(|&x| x == c[0]));
+    assert!(a[0] < b[0] && b[0] < c[0], "{a:?} {b:?} {c:?}");
+}
+
+/// Justification's Glyph Scaling leaves a block's glyphs at their size and places, as it leaves an
+/// inline graphic.
+#[test]
+fn glyph_scaling_leaves_a_warichu_block_as_it_is() {
+    let at = |scaling: [f64; 3]| {
+        let mut t = with_block("cdef", marked(20.0));
+        t.para.justification.glyph_scaling = scaling;
+        let l = layout(db(), &t);
+        let start = l.glyphs[2].origin.x;
+        (l.glyphs[2..6].iter().map(|g| (g.origin.x - start, g.origin.y, g.advance)).collect::<Vec<_>>(), ink(&l, 3).width())
+    };
+    let (plain, plain_ink) = at([100.0, 100.0, 100.0]);
+    let (scaled, scaled_ink) = at([120.0, 120.0, 120.0]);
+    assert_eq!(plain, scaled);
+    assert!((plain_ink - scaled_ink).abs() < 1e-9);
+}
+
+/// A block gets every line it asks for when its places to break are too few or too early: it is
+/// split between characters instead.
+#[test]
+fn a_block_gets_its_lines_when_places_to_break_run_short() {
+    let l = layout(db(), &with_block("a mmmmmmmm", CharStyle { warichu_lines: 3, ..marked(20.0) }));
+    let mut ys: Vec<f64> = l.glyphs[2..12].iter().map(|g| g.origin.y).collect();
+    ys.sort_by(f64::total_cmp);
+    ys.dedup_by(|a, b| (*a - *b).abs() < 1e-9);
+    assert_eq!(ys.len(), 3, "{ys:?}");
+}
+
+/// With System Layout on, the block takes a whole number of points, and the text after it starts
+/// where the block ends.
+#[test]
+fn system_layout_sets_the_block_in_whole_points() {
+    let mut t = with_block("cdef", marked(20.0));
+    t.system_layout = true;
+    let l = layout(db(), &t);
+    let (c, d, e, f, z) = (&l.glyphs[2], &l.glyphs[3], &l.glyphs[4], &l.glyphs[5], &l.glyphs[6]);
+    let length = z.origin.x - c.origin.x;
+    assert!((length - length.round()).abs() < 1e-9, "{length}");
+    let longer = (d.origin.x + d.advance).max(f.origin.x + f.advance) - c.origin.x.min(e.origin.x);
+    assert!((length - longer).abs() <= 0.5 + 1e-9, "{length} {longer}");
+}
+
+/// Character Alignment moves a block on a line of larger text as it moves text of the block's own
+/// size: the block counts as text of the size of the line it sits in.
+#[test]
+fn character_alignment_moves_a_block_as_text_of_its_own_size() {
+    let at = |align: vectorcraft_doc::CharAlign, inside: CharStyle| {
+        let mut t = point("", style(40.0));
+        t.xf = Affine::IDENTITY;
+        t.runs = vec![TextRun::new("ab", style(40.0)), TextRun::new("cd", CharStyle { char_align: align, ..inside })];
+        let l = layout(db(), &t);
+        // Where the third character sits across the line, from the line's baseline.
+        l.glyphs[2].origin.y - l.glyphs[0].origin.y
+    };
+    let plain = |a| at(a, style(20.0));
+    let block = |a| at(a, marked(20.0));
+    let roman = vectorcraft_doc::CharAlign::RomanBaseline;
+    for a in [vectorcraft_doc::CharAlign::EmBoxTop, vectorcraft_doc::CharAlign::EmBoxCenter, vectorcraft_doc::CharAlign::EmBoxBottom] {
+        let (moved, still) = (block(a) - block(roman), plain(a) - plain(roman));
+        assert!((moved - still).abs() < 1e-6, "{a:?}: {moved} {still}");
+    }
+}
+
+/// A tab ends a block: it keeps its tab stop, and the characters after it form a block of their own.
+#[test]
+fn a_tab_ends_a_warichu_block() {
+    let l = layout(db(), &with_block("cd\tef", marked(20.0)));
+    let (c, d, tab, e, f) = (&l.glyphs[2], &l.glyphs[3], &l.glyphs[4], &l.glyphs[5], &l.glyphs[6]);
+    assert!(d.origin.y > c.origin.y && (d.origin.x - c.origin.x).abs() < 1e-9, "c and d are one block");
+    assert!(f.origin.y > e.origin.y && (f.origin.x - e.origin.x).abs() < 1e-9, "e and f are another");
+    assert!((tab.origin.y - l.glyphs[0].origin.y).abs() < 1e-9 && tab.origin.x > c.origin.x);
+    assert!(e.origin.x >= tab.origin.x + tab.advance - 1e-6);
+}
+
+/// A right-to-left block reads from its right end: its first character is to the right of the
+/// second on the first line.
+#[test]
+fn a_right_to_left_warichu_block_reads_from_its_right_end() {
+    // Hebrew letters, two bytes each.
+    let l = layout(db(), &with_block("אבגד", marked(20.0)));
+    let at = |byte: usize| l.glyphs.iter().find(|g| g.byte == byte).unwrap();
+    let (c, d, e) = (at(2), at(4), at(6));
+    assert!((c.origin.y - d.origin.y).abs() < 1e-9 && e.origin.y > c.origin.y);
+    assert!(c.origin.x > d.origin.x, "{:?} {:?}", c.origin, d.origin);
+    assert!((c.origin.x - (d.origin.x + d.advance)).abs() < 1e-6, "c follows d to its right");
+}
+
+/// Shrink Text to Fit scales the Line Gap with the size, as it scales the baseline shift.
+#[test]
+fn shrink_text_to_fit_scales_the_warichu_line_gap() {
+    let st = CharStyle { warichu_gap: 10.0, ..marked(20.0) };
+    let t = with_block("cdef", st);
+    let s = scaled(&t, 0.5);
+    assert_eq!(s.runs[1].style.warichu_gap, 5.0);
+    let l = layout(db(), &s);
+    assert!((l.glyphs[4].origin.y - l.glyphs[2].origin.y - (5.0 + 5.0)).abs() < 1e-6);
+}
+
+/// Two blocks whose characters the bidi order draws in turn (Latin, then Hebrew in the first;
+/// Hebrew, then Latin in the second) each keep where they start: both lines of a block start there.
+#[test]
+fn blocks_the_bidi_order_interleaves_keep_their_places() {
+    let mut t = with_block("", marked(20.0));
+    t.runs = vec![
+        TextRun::new("ab", style(20.0)),
+        TextRun::new("cא", marked(20.0)),
+        TextRun::new("בd", CharStyle { warichu_lines: 3, ..marked(20.0) }),
+        TextRun::new("z", style(20.0)),
+    ];
+    let l = layout(db(), &t);
+    let at = |byte: usize| l.glyphs.iter().find(|g| g.byte == byte).unwrap().origin;
+    let (c, alef, bet, d, z) = (at(2), at(3), at(5), at(7), at(8));
+    assert!(alef.y > c.y && d.y > bet.y, "two lines each: {c:?} {alef:?} {bet:?} {d:?}");
+    assert!((alef.x - c.x).abs() < 1e-9, "the first block's lines start together: {c:?} {alef:?}");
+    assert!((d.x - bet.x).abs() < 1e-9, "the second block's lines start together: {bet:?} {d:?}");
+    assert!(c.x < bet.x && bet.x < z.x, "{c:?} {bet:?} {z:?}");
+}
+
+/// A click on a block's lower line goes to that line's characters, not to the character of the
+/// upper line at the same place along the block.
+#[test]
+fn a_click_on_a_block_line_goes_to_its_own_characters() {
+    let l = layout(db(), &with_block("cdef", marked(20.0)));
+    let (c, d, e, f) = (&l.glyphs[2], &l.glyphs[3], &l.glyphs[4], &l.glyphs[5]);
+    let near = |g: &PositionedGlyph, share: f64| Point::new(g.origin.x + g.advance * share, g.origin.y - 2.0);
+    assert_eq!(hit_byte(&l, near(e, 0.25)), 4);
+    assert_eq!(hit_byte(&l, near(f, 0.75)), 6);
+    assert_eq!(hit_byte(&l, near(c, 0.25)), 2);
+    assert_eq!(hit_byte(&l, near(d, 0.75)), 4);
+    // Without a point across the line, the nearest stop along it, as before.
+    assert_eq!(byte_in_line(&l, 0, l.glyphs[0].origin.x), 0);
+}
+
+/// Selecting characters of a block highlights each on its own line of the block: a character of
+/// the upper line does not highlight the lower one, and a selection that runs from the upper line
+/// to the lower one covers just the selected characters on each. A character with its own
+/// Character Alignment stays on its block line for the highlight and for a click.
+#[test]
+fn a_selection_in_a_block_highlights_its_own_block_line() {
+    let l = layout(db(), &with_block("cdef", marked(20.0)));
+    let (c, d, e) = (&l.glyphs[2], &l.glyphs[3], &l.glyphs[4]);
+    let middle = (c.origin.y + e.origin.y) * 0.5;
+    let extent = |quads: &[[Point; 4]]| {
+        let ys = quads.iter().flatten().map(|p| p.y);
+        let xs = quads.iter().flatten().map(|p| p.x);
+        (
+            xs.clone().fold(f64::INFINITY, f64::min),
+            xs.fold(f64::NEG_INFINITY, f64::max),
+            ys.clone().fold(f64::INFINITY, f64::min),
+            ys.fold(f64::NEG_INFINITY, f64::max),
+        )
+    };
+    // "c", on the upper line.
+    let (x0, x1, y0, y1) = extent(&selection_quads(&l, 2, 3));
+    assert!(y0 < c.origin.y && y1 <= middle + 1e-9, "{y0} {y1} {middle}");
+    assert!((x0 - c.origin.x).abs() < 1e-6 && (x1 - (c.origin.x + c.advance)).abs() < 1e-6, "{x0} {x1}");
+    // "e", on the lower line.
+    let (_, _, y0, y1) = extent(&selection_quads(&l, 4, 5));
+    assert!(y0 >= middle - 1e-9 && y1 > e.origin.y, "{y0} {y1} {middle}");
+    // "de": d on the upper line and e on the lower, nothing of c.
+    let quads = selection_quads(&l, 3, 5);
+    assert_eq!(quads.len(), 2, "{quads:?}");
+    let (x0, _, _, _) = extent(&quads[..1]);
+    assert!((x0 - d.origin.x).abs() < 1e-6, "{x0} {:?}", d.origin);
+    // A selection that runs on past the line's break covers the break after the line's text too.
+    let mut t = with_block("cdef", marked(20.0));
+    t.runs.push(TextRun::new("\u{2028}y", style(20.0)));
+    let l = layout(db(), &t);
+    let z = &l.glyphs[6];
+    let first: Vec<[Point; 4]> = selection_quads(&l, 2, 11).into_iter().filter(|q| q[0].y < l.lines[0].baseline).collect();
+    let (_, x1, _, _) = extent(&first);
+    assert!(x1 > z.origin.x + z.advance + 1.0, "{x1} {:?} {}", z.origin, z.advance);
+    // A character of the upper line with its own Character Alignment stays on that line: on a line
+    // of 40 pt text, where Character Alignment moves a block of 20 pt, "d" is set lower than "c".
+    let mut t = with_block("", marked(20.0));
+    t.runs = vec![
+        TextRun::new("ab", style(40.0)),
+        TextRun::new("c", marked(20.0)),
+        TextRun::new("d", CharStyle { char_align: vectorcraft_doc::CharAlign::EmBoxBottom, ..marked(20.0) }),
+        TextRun::new("ef", marked(20.0)),
+        TextRun::new("z", style(40.0)),
+    ];
+    let l = layout(db(), &t);
+    assert!((l.glyphs[3].origin.y - l.glyphs[2].origin.y).abs() > 0.5, "d is set lower: {:?} {:?}", l.glyphs[2].origin, l.glyphs[3].origin);
+    // "c" and "d" alone take the same band, and "cd" one highlight over both.
+    let band = |a: usize, b: usize| {
+        let (_, _, y0, y1) = extent(&selection_quads(&l, a, b));
+        (y0, y1)
+    };
+    let ((c0, c1), (d0, d1)) = (band(2, 3), band(3, 4));
+    assert!((c0 - d0).abs() < 1e-9 && (c1 - d1).abs() < 1e-9, "{c0} {c1} {d0} {d1}");
+    let quads = selection_quads(&l, 2, 4);
+    assert!(quads.len() == 1 && (quads[0][2].y - c1).abs() < 1e-9, "{quads:?} {c1}");
+    // The lower line's band starts where the upper line's ends.
+    let (e0, _) = band(4, 5);
+    assert!((e0 - c1).abs() < 1e-9, "{e0} {c1}");
+    // A click on the upper line at the end of "d" goes there too, though "d" is set lower than "c".
+    let (c, d) = (&l.glyphs[2], &l.glyphs[3]);
+    assert_eq!(hit_byte(&l, Point::new(d.origin.x + d.advance * 0.75, c.origin.y - 2.0)), 4);
+    // A justified block line's selected characters are highlighted as one piece, over the space
+    // between them too: "im" spread to the length of "mm".
+    let l = layout(db(), &with_block("immm", CharStyle { warichu_align: WarichuAlign::JustifyAll, ..marked(20.0) }));
+    let (i, m) = (&l.glyphs[2], &l.glyphs[3]);
+    assert!(m.origin.x > i.origin.x + i.advance + 1.0, "the line is spread: {:?} {} {:?}", i.origin, i.advance, m.origin);
+    let quads = selection_quads(&l, 2, 4);
+    let (x0, x1, _, _) = extent(&quads);
+    assert!(quads.len() == 1 && (x0 - i.origin.x).abs() < 1e-6 && (x1 - (m.origin.x + m.advance)).abs() < 1e-6, "{quads:?}");
+    // Characters selected together that the bidi order draws apart keep apart: "a" and "א" of
+    // "aאבb", drawn "aבאb", leave "ב" between them out.
+    let l = layout(db(), &with_block("aאבb", CharStyle { warichu_lines: 1, ..marked(20.0) }));
+    let bet = l.glyphs.iter().find(|g| g.byte == 5).map(|g| (l.logical_point(g.origin).x, g.advance)).unwrap();
+    let quads = selection_quads(&l, 2, 5);
+    assert_eq!(quads.len(), 2, "{quads:?}");
+    for q in &quads {
+        assert!(q[1].x <= bet.0 + 1e-6 || q[0].x >= bet.0 + bet.1 - 1e-6, "{q:?} {bet:?}");
+    }
+}
+
+/// Digits marked Warichu in vertical type on a path stand across the column as digits without the
+/// mark do: type on a path does not stack warichu.
+#[test]
+fn vertical_type_on_a_path_keeps_its_digits_across_the_column() {
+    let on_path = |st: CharStyle| {
+        let mut t = point("", style(20.0));
+        t.xf = Affine::IDENTITY;
+        t.vertical = true;
+        t.runs = vec![TextRun::new("12", st)];
+        t.kind = TextKind::OnPath { path: PathData::from_bezpath(&kurbo::Line::new((0.0, 0.0), (0.0, 400.0)).to_path(0.1)), start: 0.0, end: None };
+        let l = layout(db(), &t);
+        (ink(&l, 0), ink(&l, 1))
+    };
+    assert_eq!(on_path(marked(20.0)), on_path(style(20.0)));
+}
+
+/// A block whose characters come from fonts of different heights gives its line the tallest ascent
+/// and the deepest descent among them, whichever font comes first.
+#[test]
+fn a_block_of_several_fonts_keeps_the_tallest_of_them() {
+    let fonts = ["Source Sans 3", "Source Serif 4", "Inter", "JetBrains Mono"];
+    let st = |family: &str, warichu: bool| CharStyle { font_family: family.into(), warichu, ..style(20.0) };
+    let line = |runs: Vec<TextRun>| {
+        let mut t = point("", style(20.0));
+        t.xf = Affine::IDENTITY;
+        t.runs = runs;
+        let l = layout(db(), &t);
+        (l.lines[0].ascent, l.lines[0].descent)
+    };
+    let plain: Vec<(f64, f64)> = fonts.iter().map(|f| line(vec![TextRun::new("x", st(f, false))])).collect();
+    // The two fonts whose ascents differ most.
+    let mut pair = (0, 0);
+    for i in 0..fonts.len() {
+        for j in 0..fonts.len() {
+            if plain[i].0 - plain[j].0 > plain[pair.0].0 - plain[pair.1].0 {
+                pair = (i, j);
+            }
+        }
+    }
+    let (tall, short) = (fonts[pair.0], fonts[pair.1]);
+    assert!(plain[pair.0].0 - plain[pair.1].0 > 0.1, "the bundled fonts differ in height: {plain:?}");
+    let first_short = line(vec![TextRun::new("c", st(short, true)), TextRun::new("d", st(tall, true))]);
+    let first_tall = line(vec![TextRun::new("c", st(tall, true)), TextRun::new("d", st(short, true))]);
+    assert!((first_short.0 - first_tall.0).abs() < 1e-6 && (first_short.1 - first_tall.1).abs() < 1e-6, "{first_short:?} {first_tall:?}");
+    let deepest = plain[pair.0].1.max(plain[pair.1].1);
+    assert!(first_short.0 >= plain[pair.0].0 - 1e-6 && first_short.1 >= deepest - 1e-6, "{first_short:?} {plain:?}");
+}
+
+/// Warichu Settings on characters not marked Warichu leave their shaping alone: "fi" keeps its
+/// ligature when only the f has other settings.
+#[test]
+fn warichu_settings_without_the_mark_keep_a_ligature() {
+    let fi = |f: CharStyle| {
+        let mut t = point("", serif(20.0));
+        t.runs = vec![TextRun::new("f", f), TextRun::new("i", serif(20.0))];
+        layout(db(), &t)
+    };
+    let glyphs = |l: &TextLayout| l.glyphs.iter().map(|g| (g.gid, g.len)).collect::<Vec<_>>();
+    let plain = fi(serif(20.0));
+    assert!(plain.glyphs.iter().any(|g| g.len == 2), "the bundled serif joins f and i: {:?}", glyphs(&plain));
+    let settings = CharStyle { warichu_lines: 3, warichu_gap: 2.0, warichu_scale: 70.0, warichu_align: WarichuAlign::Center, ..serif(20.0) };
+    assert_eq!(glyphs(&fi(settings)), glyphs(&plain));
+}
+
+/// Insert Kashidas leaves a warichu block alone: a justified line lengthens its other Arabic words
+/// with kashidas, and the block keeps the length its lines set.
+#[test]
+fn kashidas_leave_a_warichu_block_alone() {
+    use crate::test_fonts::{TATWEEL_FAMILY, tatweel_font};
+    use vectorcraft_doc::text::Kashida;
+    let db = FontDb::with_font_dirs(vec![]);
+    db.add_font(tatweel_font().expect("the test font builds"));
+    let face = db.face(TATWEEL_FAMILY, "Regular").expect("the test face");
+    let arabic = |warichu: bool| CharStyle { font_family: TATWEEL_FAMILY.into(), warichu, ..style(20.0) };
+    let (before, block) = ("تبد تبد ", "بتب");
+    let mut t = area("", arabic(false), Rect::new(0.0, 0.0, 300.0, 400.0), Justify::JustifyAll);
+    t.para.kashida = Kashida::Medium;
+    t.runs = vec![TextRun::new(before, arabic(false)), TextRun::new(block, arabic(true)), TextRun::new(" تبد", arabic(false))];
+    let l = layout(&db, &t);
+    let tatweel = face.glyph_for('\u{0640}');
+    let kashidas: Vec<usize> = l.glyphs.iter().filter(|g| g.len == 0 && g.gid == tatweel).map(|g| g.byte).collect();
+    assert!(!kashidas.is_empty(), "the words around the block take kashidas");
+    let inside = before.len()..before.len() + block.len();
+    assert!(kashidas.iter().all(|b| !inside.contains(b)), "{kashidas:?} {inside:?}");
+}
diff --git a/crates/text/src/thread.rs b/crates/text/src/thread.rs
index ff22f3a5e8..609f155999 100644
--- a/crates/text/src/thread.rs
+++ b/crates/text/src/thread.rs
@@ -279,10 +279,13 @@ impl<'a> Rest<'a> {
 ///
 /// Type on a path is measured the same way when its line starts at the start bracket whatever text
 /// follows: no Dynamic Text, Optical Margin Alignment or Roman Hanging Punctuation, the first
-/// paragraph aligned Left, Justify Left or Auto, and no right-to-left text (`no_rtl`, and the first
-/// paragraph's direction not right to left) unless the type is vertical. Each glyph's step along the
-/// path then depends only on the glyphs before it, so when the first glyph that does not fit comes
-/// before the last paragraph break measured, the path holds the same bytes with the whole rest.
+/// paragraph aligned Left, Justify Left, Justify All or Auto, and no right-to-left text (`no_rtl`, and
+/// the first paragraph's direction not right to left) unless the type is vertical. Each glyph's step
+/// along the path then depends only on the glyphs before it, so when the first glyph that does not
+/// fit comes before the last paragraph break measured, the path holds the same bytes with the whole
+/// rest. A line aligned to the center or the right, or Auto right to left, starts where the width of
+/// all its glyphs puts it, and a glyph's advance can be negative (negative tracking), so a shorter
+/// text can start further along than the whole rest does; such type is measured with the whole rest.
 ///
 /// Other type, and a rest that ends first, is measured with the whole rest.
 fn fit_rest(db: &FontDb, probe: impl Fn(Vec<TextRun>) -> TextObject, frame: &TextObject, rest: Rest<'_>, mut want: usize, no_rtl: bool) -> usize {
@@ -313,7 +316,7 @@ fn path_starts_at_bracket(head: &TextObject, no_rtl: bool) -> bool {
     !head.dynamic_text
         && !head.optical_margin
         && !para.roman_hanging
-        && matches!(para.justify, Justify::Auto | Justify::Left | Justify::JustifyLeft)
+        && matches!(para.justify, Justify::Auto | Justify::Left | Justify::JustifyLeft | Justify::JustifyAll)
         && (head.vertical || (no_rtl && para.direction != Some(ParaDirection::RightToLeft)))
 }
 
diff --git a/crates/text/src/thread/tests.rs b/crates/text/src/thread/tests.rs
index 7554a808f9..0ac64f5d27 100644
--- a/crates/text/src/thread/tests.rs
+++ b/crates/text/src/thread/tests.rs
@@ -27,6 +27,13 @@ fn curved_path_frame() -> TextObject {
     t
 }
 
+/// Type on a closed path, a circle about 314 round.
+fn closed_path_frame() -> TextObject {
+    let mut t = path_frame(300.0);
+    t.kind = TextKind::OnPath { path: shapes::ellipse(Rect::new(0.0, 0.0, 100.0, 100.0)), start: 0.0, end: None };
+    t
+}
+
 /// Type on a path that overflows ends its line where its text stops fitting, as area type's
 /// last line does, so a story flows on from there through area type and type on a path alike.
 #[test]
@@ -724,7 +731,7 @@ fn frames_take_the_shares_the_whole_rest_gives_them() {
     ]
     .concat();
     type Edit = fn(&mut TextObject);
-    let edits: [(&str, Edit); 15] = [
+    let edits: [(&str, Edit); 18] = [
         ("path", |_| {}),
         ("path, Left", |t| t.para.justify = Justify::Left),
         ("path, Auto", |t| t.para.justify = Justify::Auto),
@@ -732,6 +739,20 @@ fn frames_take_the_shares_the_whole_rest_gives_them() {
         ("path, Center", |t| t.para.justify = Justify::Center),
         ("path, Right", |t| t.para.justify = Justify::Right),
         ("path, Justify All", |t| t.para.justify = Justify::JustifyAll),
+        ("path, Justify All, spacing", |t| {
+            t.para.justify = Justify::JustifyAll;
+            t.path_spacing = 8.0;
+        }),
+        ("path, Justify All, negative spacing", |t| {
+            t.para.justify = Justify::JustifyAll;
+            t.path_spacing = -8.0;
+        }),
+        ("closed path, Justify All", |t| {
+            t.para.justify = Justify::JustifyAll;
+            if let TextKind::OnPath { path, .. } = &mut t.kind {
+                *path = shapes::ellipse(Rect::new(0.0, 0.0, 100.0, 100.0));
+            }
+        }),
         ("path, spacing", |t| t.path_spacing = 8.0),
         ("path, Optical Margin Alignment", |t| t.optical_margin = true),
         ("path, Roman Hanging Punctuation", |t| t.para.roman_hanging = true),
@@ -757,6 +778,35 @@ fn frames_take_the_shares_the_whole_rest_gives_them() {
         // The story's last character does not hang, the last one measured does.
         took += same_as_whole_rest(db, &refs(&on), &story(&ends_unhung), &[], &format!("{case}, story ending in a letter"));
     }
+    // Glyphs whose advance is negative, and punctuation and quotes that end paragraphs, some of
+    // them alone after empty paragraphs.
+    let tight = CharStyle { tracking: -1200.0, ..Default::default() };
+    let text = paragraphs(120);
+    let mut negative: Vec<TextRun> =
+        text.split_inclusive(' ').enumerate().map(|(i, w)| TextRun::new(w, if i % 4 == 0 { tight.clone() } else { plain.clone() })).collect();
+    normalize(&mut negative);
+    let punctuated = (1..=150)
+        .map(|i| match i % 3 {
+            0 => ".".to_string(),
+            1 => format!("Item {i}: the \u{201c}fox.\u{201d}"),
+            _ => String::new(),
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    for justify in [Justify::Left, Justify::JustifyAll, Justify::Center, Justify::Right] {
+        let mut on = paths(|_| {});
+        on.push(closed_path_frame());
+        for t in &mut on {
+            t.para.justify = justify;
+        }
+        took += same_as_whole_rest(db, &refs(&on), &negative, &[], &format!("path, {justify:?}, negative tracking"));
+        took += same_as_whole_rest(db, &refs(&on), &story(&punctuated), &[], &format!("path, {justify:?}, punctuation at paragraph ends"));
+        let mut spaced = on.clone();
+        for t in &mut spaced {
+            t.path_spacing = -8.0;
+        }
+        took += same_as_whole_rest(db, &refs(&spaced), &negative, &[], &format!("path, {justify:?}, negative tracking and spacing"));
+    }
     let on = paths(|_| {});
     took += same_as_whole_rest(db, &refs(&on), &styled, &[], "path, style runs");
     took += same_as_whole_rest(db, &refs(&on), &story(&paragraphs(120)), &listed, "path, lists");
@@ -877,7 +927,7 @@ fn many_frames_measure_about_the_text_they_take() {
         }
         measures_about_the_text_taken(db, &shaped, &format!("{align:?}, ellipses"));
     }
-    for justify in [Justify::Left, Justify::JustifyLeft, Justify::Auto] {
+    for justify in [Justify::Left, Justify::JustifyLeft, Justify::JustifyAll, Justify::Auto] {
         let paths: Vec<TextObject> = (0..40)
             .map(|_| {
                 let mut t = path_frame(300.0);
@@ -887,6 +937,34 @@ fn many_frames_measure_about_the_text_they_take() {
             .collect();
         measures_about_the_text_taken(db, &paths, &format!("path, {justify:?}"));
     }
+    // Justify All on curved, bracketed and closed paths, and with Spacing.
+    type Make = fn() -> TextObject;
+    let kinds: [(&str, Make); 4] = [
+        ("curved", curved_path_frame),
+        ("bracketed", || {
+            let mut t = path_frame(300.0);
+            if let TextKind::OnPath { start, end, .. } = &mut t.kind {
+                (*start, *end) = (0.1, Some(0.8));
+            }
+            t
+        }),
+        ("closed", closed_path_frame),
+        ("spaced", || {
+            let mut t = curved_path_frame();
+            t.path_spacing = -20.0;
+            t
+        }),
+    ];
+    for (shape, make) in kinds {
+        let paths: Vec<TextObject> = (0..40)
+            .map(|_| {
+                let mut t = make();
+                t.para.justify = Justify::JustifyAll;
+                t
+            })
+            .collect();
+        measures_about_the_text_taken(db, &paths, &format!("{shape} path, Justify All"));
+    }
     let vertical: Vec<TextObject> = (0..40)
         .map(|_| {
             let mut t = path_frame(300.0);
diff --git a/crates/three-d/src/solid/build.rs b/crates/three-d/src/solid/build.rs
index 359192c7f8..6d21805e74 100644
--- a/crates/three-d/src/solid/build.rs
+++ b/crates/three-d/src/solid/build.rs
@@ -514,8 +514,9 @@ fn steps(o: &Extrude) -> Vec<Step> {
     } else {
         out.push(Step { inset: 0.0, t: 0.0, face: 1.0 });
     }
-    // Twist and taper bend the walls: cut them into slices.
-    let slices = if o.twist != 0.0 || o.taper != 1.0 { ((o.twist.abs() / 6.0).ceil() as usize).clamp(8, 64) } else { 1 };
+    // A twist bends the walls: cut them into slices. A taper alone keeps each wall flat (its edge
+    // only scales toward the center as it goes back), so it needs none.
+    let slices = if o.twist != 0.0 { ((o.twist.abs() / 6.0).ceil() as usize).clamp(8, 64) } else { 1 };
     let back_height = if bevel.is_some_and(|b| b.both_sides) { height } else { 0.0 };
     let (t0, t1) = (height / d, 1.0 - back_height / d);
     for k in 0..=slices {
diff --git a/crates/three-d/src/solid/tests.rs b/crates/three-d/src/solid/tests.rs
index 9929a52860..e89a29afea 100644
--- a/crates/three-d/src/solid/tests.rs
+++ b/crates/three-d/src/solid/tests.rs
@@ -154,6 +154,50 @@ fn taper_shrinks_the_back_and_twist_turns_it() {
     assert!(open.len() > 2 * 8, "{}", open.len());
 }
 
+/// A taper only scales each wall's far edge toward the center, so the wall stays one flat face;
+/// cut into slices, each joint between them showed a light tick. A twist bends the walls, which
+/// are still cut into slices.
+#[test]
+fn a_tapered_wall_is_one_flat_face_and_a_twisted_one_is_sliced() {
+    let (p, b) = shape(&square(0.0, 0.0, 100.0));
+    let v = View { rotation_x: -35.0, rotation_y: 25.0, ..front() };
+    // Every side facet, the ones turned away included.
+    let sides = |o: Extrude, v: View| -> Vec<Facet> {
+        extrude(&p, FillRule::NonZero, b, Extrude { hidden: true, ..o }, v).unwrap().into_iter().filter(|f| f.side).collect()
+    };
+    let o = Extrude { depth: 40.0, taper: 0.475, ..Extrude::default() };
+    let walls = sides(o, v);
+    assert_eq!(walls.len(), 4, "one face for each of a square's four walls");
+    for f in &walls {
+        let [ring] = &f.view[..] else { panic!("{} contours", f.view.len()) };
+        let n = super::build::newell(std::slice::from_ref(ring));
+        let len = n.0.hypot(n.1).hypot(n.2);
+        let off = |q: &V3| ((q.0 - ring[0].0) * n.0 + (q.1 - ring[0].1) * n.1 + (q.2 - ring[0].2) * n.2) / len;
+        assert!(ring.iter().all(|q| off(q).abs() < 1e-9), "a flat wall: {:?}", ring.iter().map(off).collect::<Vec<_>>());
+    }
+    // Beveled, in perspective or hollow, a taper adds no faces either.
+    let bevel = Bevel { width: 8.0, height: 8.0, ..Bevel::default() };
+    let perspective = View { perspective: 60.0, ..v };
+    for (o, v) in [
+        (Extrude { bevel: Some(bevel), ..o }, v),
+        (Extrude { bevel: Some(Bevel { both_sides: true, ..bevel }), ..o }, v),
+        (Extrude { bevel: Some(Bevel { inside: true, shape: BevelShape::Step, ..bevel }), ..o }, v),
+        (o, perspective),
+        (Extrude { cap: false, ..o }, perspective),
+    ] {
+        assert_eq!(sides(o, v).len(), sides(Extrude { taper: 1.0, ..o }, v).len(), "{o:?} {v:?}");
+    }
+    // A curved outline's walls take one band each too: a taper adds no faces to a circle's.
+    let (cp, cb) = shape(&circle(Point::new(50.0, 50.0), 50.0));
+    let round = |o: Extrude| extrude(&cp, FillRule::NonZero, cb, Extrude { hidden: true, ..o }, v).unwrap().into_iter().filter(|f| f.side).count();
+    assert_eq!(round(o), round(Extrude { taper: 1.0, ..o }), "a tapered circle's walls");
+    // A twist still cuts each wall into at least 8 slices, tapered or not.
+    for taper in [1.0, o.taper] {
+        let twisted = sides(Extrude { twist: 30.0, taper, ..o }, v).len();
+        assert!(twisted >= 4 * 8, "{twisted} faces for a twisted square's walls");
+    }
+}
+
 /// A flat facet carries its plane: the depth it gives at each corner of its drawing is the corner's
 /// view-space depth, with and without perspective. A piece of a twisted wall whose corners lie off
 /// one plane has none.
diff --git a/crates/tools/src/addons.rs b/crates/tools/src/addons.rs
index e88721b04e..c226a3c4d9 100644
--- a/crates/tools/src/addons.rs
+++ b/crates/tools/src/addons.rs
@@ -13,6 +13,7 @@ pub mod parametric_shape;
 pub mod shared_edge;
 pub mod slide_anchor;
 pub mod smart_pen;
+pub mod trim;
 
 use crate::{Tool, ToolInfo};
 
@@ -25,6 +26,7 @@ pub const PATH_TOOLS: &[ToolInfo] = &[
     ToolInfo { id: corner_tool::ID, label: "Corner Tool", shortcut: None, icon: "dc-rounded-rect" },
     ToolInfo { id: slide_anchor::ID, label: "Slide Anchor Along Path", shortcut: None, icon: "dc-anchor" },
     ToolInfo { id: shared_edge::ID, label: "Shared Edge Merge Tool", shortcut: None, icon: "dc-join" },
+    ToolInfo { id: trim::ID, label: "Trim at Crossings Tool", shortcut: None, icon: "dc-pf-trim" },
 ];
 
 /// Smart Pen's tool, a flyout group of its own.
@@ -60,6 +62,7 @@ pub fn create(id: &str) -> Option<Box<dyn Tool>> {
         shared_edge::ID => Box::new(shared_edge::SharedEdgeTool::default()),
         slide_anchor::ID => Box::new(slide_anchor::SlideAnchorTool::default()),
         smart_pen::ID => Box::new(smart_pen::SmartPenTool::default()),
+        trim::ID => Box::new(trim::TrimTool::default()),
         enclosing_lasso::ID => Box::new(enclosing_lasso::EnclosingLassoTool::default()),
         contour::ID => Box::new(contour::ContourTool::default()),
         box3d::ID => Box::new(box3d::Box3dTool::default()),
diff --git a/crates/tools/src/addons/trim.rs b/crates/tools/src/addons/trim.rs
new file mode 100644
index 0000000000..9eee5c436f
--- /dev/null
+++ b/crates/tools/src/addons/trim.rs
@@ -0,0 +1,236 @@
+//! Trim at Crossings Tool (Path Precision Tools): a click removes the stretch of the path under the
+//! pointer between the places where other paths, or the path itself, cross it; a drag draws a
+//! rectangle and removes every stretch it touches; an Alt-drag draws a freehand line and removes
+//! every stretch it crosses. Each runs `addon.pathtools.trim` on release, as one undo step, on
+//! every path that can be edited, selected or not. Escape during a drag removes nothing.
+
+use serde_json::json;
+use vectorcraft_geom::{Point, Rect};
+
+use crate::draw2::FEEDBACK;
+use crate::xform::polygon;
+use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};
+
+/// The tool's id.
+pub const ID: &str = "trimAtCrossings";
+/// How near the pointer a path counts as under it (screen pixels).
+pub const REACH: f64 = 4.0;
+/// A press that moves less than this many screen pixels is a click.
+const MIN_DRAG_PX: f64 = 3.0;
+/// The most points a freehand line keeps (one per screen pixel dragged). A longer one is dropped.
+pub(crate) const MAX_POINTS: usize = 65_536;
+/// The command the tool runs.
+const COMMAND: &str = "addon.pathtools.trim";
+
+#[derive(Default)]
+pub struct TrimTool {
+    /// Where the press started, while the button is down.
+    start: Option<Point>,
+    end: Point,
+    /// An Alt-drag's freehand line (empty for a rectangle).
+    line: Vec<Point>,
+    freehand: bool,
+    /// The pointer went `MIN_DRAG_PX` or more from the press: the gesture is a drag from then on.
+    moved: bool,
+}
+
+impl TrimTool {
+    fn reset(&mut self) {
+        self.start = None;
+        self.line.clear();
+        self.freehand = false;
+        self.moved = false;
+    }
+}
+
+impl Tool for TrimTool {
+    fn id(&self) -> &'static str {
+        ID
+    }
+
+    fn busy(&self) -> bool {
+        self.start.is_some()
+    }
+
+    fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
+        if !ev.pos.is_finite() {
+            if ev.kind == PointerKind::Up {
+                self.reset();
+            }
+            return vec![];
+        }
+        match ev.kind {
+            PointerKind::Down => {
+                self.start = Some(ev.pos);
+                self.end = ev.pos;
+                self.freehand = ev.mods.alt;
+                self.moved = false;
+                self.line = if self.freehand { vec![ev.pos] } else { vec![] };
+                vec![]
+            }
+            PointerKind::Drag if self.start.is_some() => {
+                self.end = ev.pos;
+                self.moved |= self.start.is_some_and(|start| start.distance(ev.pos) >= cx.tol(MIN_DRAG_PX));
+                if self.freehand && self.line.last().is_none_or(|p| p.distance(ev.pos) >= cx.tol(1.0)) {
+                    // A line cut short would cross other stretches than the one drawn: drop it.
+                    if self.line.len() >= MAX_POINTS {
+                        self.reset();
+                        return vec![];
+                    }
+                    self.line.push(ev.pos);
+                }
+                vec![]
+            }
+            PointerKind::Up => {
+                let Some(start) = self.start else { return vec![] };
+                let mut line = std::mem::take(&mut self.line);
+                let (freehand, moved) = (self.freehand, self.moved);
+                self.reset();
+                // A press that stayed near where it started is a click, even when a freehand line
+                // took a few points on the way. One that went farther stays a drag when it comes back.
+                if !moved && start.distance(ev.pos) < cx.tol(MIN_DRAG_PX) {
+                    return vec![Action::Exec(COMMAND.into(), json!({"at": [start.x, start.y], "tolerance": cx.tol(REACH).min(100.0)}))];
+                }
+                if !freehand {
+                    let r = Rect::from_points(start, ev.pos);
+                    return vec![Action::Exec(COMMAND.into(), json!({"rect": [r.x0, r.y0, r.width(), r.height()]}))];
+                }
+                if line.last().is_some_and(|p| *p != ev.pos) {
+                    line.push(ev.pos);
+                }
+                let points: Vec<_> = line.iter().map(|p| json!([p.x, p.y])).collect();
+                if points.len() < 2 { vec![] } else { vec![Action::Exec(COMMAND.into(), json!({ "points": points }))] }
+            }
+            _ => vec![],
+        }
+    }
+
+    fn key(&mut self, _cx: &ToolContext, key: ToolKey, _mods: Mods) -> Vec<Action> {
+        if key == ToolKey::Escape {
+            self.reset();
+        }
+        vec![]
+    }
+
+    fn claims_key(&self, _cx: &ToolContext, key: ToolKey) -> bool {
+        self.start.is_some() && key == ToolKey::Escape
+    }
+
+    fn overlays(&self, _cx: &ToolContext) -> Vec<Overlay> {
+        let Some(start) = self.start else { return vec![] };
+        if self.freehand {
+            return if self.line.len() < 2 {
+                vec![]
+            } else {
+                vec![Overlay::Path { path: polygon(&self.line, false), color: FEEDBACK, width: 1.0, dashed: false }]
+            };
+        }
+        if self.moved { vec![Overlay::Marquee(Rect::from_points(start, self.end))] } else { vec![] }
+    }
+
+    fn cursor(&self, _cx: &ToolContext, _p: Point, _mods: Mods) -> Cursor {
+        Cursor::Crosshair
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::testutil::*;
+    use vectorcraft_doc::Selection;
+
+    fn ev(kind: PointerKind, x: f64, y: f64) -> PointerEvent {
+        PointerEvent::new(kind, x, y)
+    }
+
+    #[test]
+    fn a_click_trims_at_the_point_with_nothing_selected() {
+        let (d, _) = doc_with_rect();
+        let (sel, p) = (Selection::default(), paint());
+        let mut cx = cx(&d, &sel, &p);
+        cx.zoom = 2.0;
+        let mut t = TrimTool::default();
+        assert!(t.pointer(&cx, &ev(PointerKind::Down, 100.0, 100.0)).is_empty());
+        assert!(t.busy() && t.overlays(&cx).is_empty());
+        let up = t.pointer(&cx, &ev(PointerKind::Up, 100.5, 100.0));
+        assert_eq!(up, vec![Action::Exec(COMMAND.into(), json!({"at": [100.0, 100.0], "tolerance": 2.0}))], "4 px at 200%");
+        assert!(!t.busy());
+        assert_eq!(t.cursor(&cx, Point::ZERO, Mods::default()), Cursor::Crosshair);
+    }
+
+    #[test]
+    fn a_drag_trims_what_its_rectangle_touches_and_escape_drops_it() {
+        let (d, _) = doc_with_rect();
+        let (sel, p) = (Selection::default(), paint());
+        let cx = cx(&d, &sel, &p);
+        let mut t = TrimTool::default();
+        t.pointer(&cx, &ev(PointerKind::Down, 160.0, 130.0));
+        assert!(t.pointer(&cx, &ev(PointerKind::Drag, 140.0, 90.0)).is_empty(), "nothing runs while dragging");
+        assert!(matches!(t.overlays(&cx).as_slice(), [Overlay::Marquee(r)] if *r == Rect::new(140.0, 90.0, 160.0, 130.0)));
+        let up = t.pointer(&cx, &ev(PointerKind::Up, 140.0, 90.0));
+        assert_eq!(up, vec![Action::Exec(COMMAND.into(), json!({"rect": [140.0, 90.0, 20.0, 40.0]}))]);
+        // Escape during a drag: nothing runs on release, and the key is the tool's only then.
+        assert!(!t.claims_key(&cx, ToolKey::Escape));
+        t.pointer(&cx, &ev(PointerKind::Down, 10.0, 10.0));
+        t.pointer(&cx, &ev(PointerKind::Drag, 60.0, 60.0));
+        assert!(t.claims_key(&cx, ToolKey::Escape));
+        assert!(t.key(&cx, ToolKey::Escape, Mods::default()).is_empty());
+        assert!(!t.busy() && t.overlays(&cx).is_empty());
+        assert!(t.pointer(&cx, &ev(PointerKind::Up, 60.0, 60.0)).is_empty());
+    }
+
+    #[test]
+    fn a_drag_that_comes_back_near_the_press_stays_a_rectangle() {
+        let (d, _) = doc_with_rect();
+        let (sel, p) = (Selection::default(), paint());
+        let cx = cx(&d, &sel, &p);
+        let mut t = TrimTool::default();
+        t.pointer(&cx, &ev(PointerKind::Down, 0.0, 0.0));
+        t.pointer(&cx, &ev(PointerKind::Drag, 20.0, 20.0));
+        t.pointer(&cx, &ev(PointerKind::Drag, 1.0, 1.0));
+        assert!(matches!(t.overlays(&cx).as_slice(), [Overlay::Marquee(r)] if *r == Rect::new(0.0, 0.0, 1.0, 1.0)));
+        let up = t.pointer(&cx, &ev(PointerKind::Up, 1.0, 1.0));
+        assert_eq!(up, vec![Action::Exec(COMMAND.into(), json!({"rect": [0.0, 0.0, 1.0, 1.0]}))]);
+        // A drag that stays within a pixel or two is still a click.
+        t.pointer(&cx, &ev(PointerKind::Down, 0.0, 0.0));
+        t.pointer(&cx, &ev(PointerKind::Drag, 2.0, 0.0));
+        let up = t.pointer(&cx, &ev(PointerKind::Up, 1.0, 1.0));
+        assert!(matches!(up.as_slice(), [Action::Exec(_, v)] if v.get("at").is_some()), "{up:?}");
+    }
+
+    #[test]
+    fn an_alt_drag_trims_what_its_line_crosses() {
+        let (d, _) = doc_with_rect();
+        let (sel, p) = (Selection::default(), paint());
+        let cx = cx(&d, &sel, &p);
+        let alt = Mods { alt: true, ..Mods::default() };
+        let mut t = TrimTool::default();
+        t.pointer(&cx, &ev(PointerKind::Down, 10.0, 10.0).with_mods(alt));
+        t.pointer(&cx, &ev(PointerKind::Drag, 10.2, 10.0).with_mods(alt));
+        t.pointer(&cx, &ev(PointerKind::Drag, 40.0, 30.0));
+        assert!(matches!(t.overlays(&cx).as_slice(), [Overlay::Path { .. }]));
+        // Alt at the press decides; points less than a pixel apart are one.
+        let up = t.pointer(&cx, &ev(PointerKind::Up, 80.0, 30.0));
+        assert_eq!(up, vec![Action::Exec(COMMAND.into(), json!({"points": [[10.0, 10.0], [40.0, 30.0], [80.0, 30.0]]}))]);
+        // An Alt-click is a click.
+        t.pointer(&cx, &ev(PointerKind::Down, 10.0, 10.0).with_mods(alt));
+        let up = t.pointer(&cx, &ev(PointerKind::Up, 10.0, 10.0).with_mods(alt));
+        assert!(matches!(up.as_slice(), [Action::Exec(_, v)] if v.get("at").is_some()), "{up:?}");
+        // So is one that moves a pixel or two, and one that goes away and comes back is a line.
+        t.pointer(&cx, &ev(PointerKind::Down, 10.0, 10.0).with_mods(alt));
+        t.pointer(&cx, &ev(PointerKind::Drag, 12.0, 10.0).with_mods(alt));
+        let up = t.pointer(&cx, &ev(PointerKind::Up, 12.0, 11.0).with_mods(alt));
+        assert_eq!(up, vec![Action::Exec(COMMAND.into(), json!({"at": [10.0, 10.0], "tolerance": 4.0}))]);
+        t.pointer(&cx, &ev(PointerKind::Down, 10.0, 10.0).with_mods(alt));
+        t.pointer(&cx, &ev(PointerKind::Drag, 40.0, 10.0).with_mods(alt));
+        let up = t.pointer(&cx, &ev(PointerKind::Up, 10.0, 11.0).with_mods(alt));
+        assert_eq!(up, vec![Action::Exec(COMMAND.into(), json!({"points": [[10.0, 10.0], [40.0, 10.0], [10.0, 11.0]]}))]);
+        // A line past the cap is dropped rather than cut short.
+        t.pointer(&cx, &ev(PointerKind::Down, 0.0, 0.0).with_mods(alt));
+        for i in 1..=MAX_POINTS {
+            t.pointer(&cx, &ev(PointerKind::Drag, i as f64 * 2.0, 0.0));
+        }
+        assert!(!t.busy());
+        assert!(t.pointer(&cx, &ev(PointerKind::Up, 0.0, 0.0)).is_empty());
+    }
+}
diff --git a/crates/tools/src/builder.rs b/crates/tools/src/builder.rs
index 1c5a895161..2190d34180 100644
--- a/crates/tools/src/builder.rs
+++ b/crates/tools/src/builder.rs
@@ -35,11 +35,11 @@ mod map;
 use cache::{BACKGROUND_SEGMENTS, CacheKey, RegionCache};
 #[cfg(test)]
 use live_paint::LpHover;
-use live_paint::lp_color;
 pub use live_paint::{
     LP_BUCKET_EDGE_FRACTION, LP_BUCKET_WIDTH, LP_BUCKET_WIDTH_RANGE, LP_FILL_CHUNK_POINTS, LP_SELECT_WIDTH, LP_SELECT_WIDTH_RANGE,
     LivePaintBucketTool, LivePaintSelectionTool,
 };
+use live_paint::{check_live_paint_options, lp_color, lp_rgb_color};
 pub use lookup::{
     EDGE_NAME, FACE_NAME, Face, LIVE_PAINT_NAME, LIVE_PAINT_PREFIX, SOURCES_NAME, builder_members, drawn_outlines, edge_near, edges, face_at, faces,
     is_live_paint, leaf_shapes, live_paint_at, live_paint_takes, node_outline, outline_snap, path_contains, shape_builder_shapes, shapes_for,
@@ -777,6 +777,39 @@ impl Tool for ShapeBuilderTool {
     }
 }
 
+/// Why `tool.setOption` cannot give the builder-family tool `tool` the options `values`, checked
+/// before any of them is set. For `shapeBuilder`: an option the tool does not have, a switch that
+/// is not true or false, a `pickColorFrom` other than `artwork` or `swatches`, a `selection` other
+/// than `freeform` or `straightLine`, a `highlightColor` that is not an RGB color without an alpha
+/// part and a `gapLength` that is not a finite number are errors. A finite gap length out of 0 to
+/// [`SHAPE_BUILDER_MAX_GAP`] is not an error: the tool clamps it. The Live Paint tools are checked
+/// by [`check_live_paint_options`]; Ok for every other tool. Saved settings go to the tools'
+/// `set_option` instead, which skips a value it cannot read.
+pub fn check_builder_options(tool: &str, values: &serde_json::Map<String, Value>) -> Result<(), String> {
+    if tool != "shapeBuilder" {
+        return check_live_paint_options(tool, values);
+    }
+    let one_of = |key: &str, v: &Value, names: &[&str]| {
+        (!v.as_str().is_some_and(|s| names.contains(&s))).then(|| format!("`{key}` must be one of {}", names.join(", ")))
+    };
+    for (key, v) in values {
+        let error = match key.as_str() {
+            "openFilledAsClosed" | "cursorSwatchPreview" | "highlightFill" | "gapDetection" | "clickStrokeSplitsPath" | "highlightStroke" => {
+                (!v.is_boolean()).then(|| format!("`{key}` must be true or false"))
+            }
+            "pickColorFrom" => one_of(key, v, &["artwork", "swatches"]),
+            "selection" => one_of(key, v, &["freeform", "straightLine"]),
+            "gapLength" => (!v.as_f64().is_some_and(f64::is_finite)).then(|| format!("`{key}` must be a number")),
+            "highlightColor" => (!lp_rgb_color(v)).then(|| format!("`{key}` must be a #rrggbb color or a layer color name")),
+            _ => Some(format!("unknown Shape Builder option `{key}`")),
+        };
+        if let Some(e) = error {
+            return Err(e);
+        }
+    }
+    Ok(())
+}
+
 /// Create a builder-family tool by id (None = not one of ours).
 pub fn create(id: &str) -> Option<Box<dyn Tool>> {
     Some(match id {
diff --git a/crates/tools/src/builder/live_paint.rs b/crates/tools/src/builder/live_paint.rs
index e2d6c9f77e..6b744e4435 100644
--- a/crates/tools/src/builder/live_paint.rs
+++ b/crates/tools/src/builder/live_paint.rs
@@ -594,6 +594,42 @@ pub(super) fn lp_color(v: &Value) -> Option<[u8; 3]> {
     Some([r, g, b])
 }
 
+/// Whether `v` is a highlight color [`lp_color`] reads without an alpha part: `#rrggbbaa` (with
+/// or without `#`) is not one.
+pub(super) fn lp_rgb_color(v: &Value) -> bool {
+    let Some(s) = v.as_str() else { return false };
+    let digits = s.trim().trim_start_matches('#');
+    let alpha = digits.len() == 8 && digits.chars().all(|c| c.is_ascii_hexdigit());
+    !alpha && lp_color(v).is_some()
+}
+
+/// Why `tool.setOption` cannot give the Live Paint tool `tool` (`livePaintBucket` or
+/// `livePaintSelection`) the options `values`, checked before any of them is set: an option the
+/// tool does not have, a switch that is not true or false, a `color` that is not an RGB color
+/// ([`lp_rgb_color`]) and a `width` that is not a finite number are errors. A finite width out of
+/// [`LP_BUCKET_WIDTH_RANGE`] or [`LP_SELECT_WIDTH_RANGE`] is not an error: the tool clamps it.
+/// Ok for every other tool. Saved settings go to the tools' `set_option` instead, which skips a
+/// value it cannot read.
+pub fn check_live_paint_options(tool: &str, values: &serde_json::Map<String, Value>) -> Result<(), String> {
+    let switches: &[&str] = match tool {
+        "livePaintBucket" => &["paintFills", "paintStrokes", "highlight"],
+        "livePaintSelection" => &["selectFills", "selectStrokes"],
+        _ => return Ok(()),
+    };
+    for (key, v) in values {
+        let error = match key.as_str() {
+            "color" => (!lp_rgb_color(v)).then(|| format!("`{key}` must be a #rrggbb color or a layer color name")),
+            "width" => (!v.as_f64().is_some_and(f64::is_finite)).then(|| format!("`{key}` must be a number")),
+            k if switches.contains(&k) => (!v.is_boolean()).then(|| format!("`{key}` must be true or false")),
+            _ => Some(format!("unknown Live Paint option `{key}`")),
+        };
+        if let Some(e) = error {
+            return Err(e);
+        }
+    }
+    Ok(())
+}
+
 impl Tool for LivePaintSelectionTool {
     fn id(&self) -> &'static str {
         "livePaintSelection"
diff --git a/crates/tools/src/draw2.rs b/crates/tools/src/draw2.rs
index f57936bd83..d85ff4fffa 100644
--- a/crates/tools/src/draw2.rs
+++ b/crates/tools/src/draw2.rs
@@ -39,9 +39,17 @@ pub const MIN_FIT_TOLERANCE: f64 = MIN_FIDELITY / 640.0;
 /// A change to either range changes this bound with it.
 pub const MAX_FIT_TOLERANCE: f64 = 100.0 / 0.0313;
 
-/// The lowest Fidelity (points) the Smooth tool takes.
+/// The lowest Fidelity (screen pixels) the Smooth tool takes.
 pub const SMOOTH_MIN_FIDELITY: f64 = 0.05;
 
+/// The finest tolerance (points) `path.smoothRegion` refits at: the Smooth tool's lowest Fidelity at
+/// the highest zoom (64000 %), whose screen pixels the tools send in points.
+pub const SMOOTH_MIN_TOLERANCE: f64 = SMOOTH_MIN_FIDELITY / 640.0;
+
+/// The coarsest tolerance (points) `path.smoothRegion` refits at: the highest Fidelity (100 screen
+/// pixels) at the lowest zoom (3.13 %).
+pub const SMOOTH_MAX_TOLERANCE: f64 = 100.0 / 0.0313;
+
 /// Whether segment `i` of `sp` is straight, so the Smooth tool leaves it as it is: its handles lie
 /// on the line through its ends, and the segment runs from one end to the other without turning back.
 pub fn segment_is_straight(sp: &SubPath, i: usize) -> bool {
diff --git a/crates/tools/src/draw2/gesture.rs b/crates/tools/src/draw2/gesture.rs
index f7b17d8907..9aed6f545b 100644
--- a/crates/tools/src/draw2/gesture.rs
+++ b/crates/tools/src/draw2/gesture.rs
@@ -23,6 +23,8 @@
 //! pointer, even if Alt is released during the drag. Shift on each drag or release constrains that
 //! line to 45° steps from the canvas axes.
 
+mod area;
+
 use std::cell::Cell;
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -31,9 +33,10 @@ use vectorcraft_doc::{NodeId, NodeKind};
 use vectorcraft_geom::{Affine, BezPath, FillRule, ParamCurve, PathData, PathSeg, Point, Rect, Vec2, shapes};
 use vectorcraft_pathops as po;
 
-use super::{FEEDBACK, blob_area, blob_tip, eraser_area, eraser_tip, points_json, polyline};
+use super::{FEEDBACK, blob_area, blob_tip, eraser_tip, points_json, polyline};
 use crate::guides::DrawSnap;
 use crate::{Action, Cursor, Mods, Overlay, PenPose, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};
+use area::{AreaKey, AreaPreview};
 
 /// How far from its drag the Smooth tool smooths, in screen pixels. Alt smoothing with the
 /// Pencil, Paintbrush or Blob Brush uses the same radius.
@@ -69,7 +72,7 @@ const BAND_WORK_PER_CALL: usize = 20_000;
 /// a fit's cost grows as its Fidelity shrinks (at 0.01 pt a long pen stroke lagged, #4565), and
 /// a preview within half a pixel of the stroke looks the same. The release fits it at its Fidelity.
 const PREVIEW_FIDELITY_PX: f64 = 0.5;
-/// The Smooth tool's Fidelity until Smooth Tool Options sets another.
+/// The Smooth tool's Fidelity (screen pixels) until Smooth Tool Options sets another.
 const SMOOTH_FIDELITY: f64 = 2.5;
 
 /// The `fidelity` (points) the Pencil and the Paintbrush send `path.freehand` for `px` screen pixels
@@ -104,8 +107,8 @@ pub struct GestureTool {
     /// Paths' distance in points); the stroke redraws the section it ends on (#2850).
     redraw: Option<(NodeId, f64)>,
     /// Fit tolerance (Pencil/Paintbrush/Smooth/Blob Brush "Fidelity"): in screen pixels for the
-    /// Pencil and the Paintbrush, so a stroke keeps as many points at any zoom (#5729), in points
-    /// for the others.
+    /// Pencil and the Paintbrush, so a stroke keeps as many points at any zoom (#5729), and for the
+    /// Smooth tool, so a drag smooths as much at any zoom; in points for the Blob Brush.
     pub fidelity: f64,
     /// Brush / eraser diameter in points (the Eraser's across its tip's long axis).
     pub size: f64,
@@ -136,8 +139,8 @@ pub struct GestureTool {
     /// preview shows the points joined by straight segments and the release fits them (Pencil
     /// only, on by default).
     pub live_fit: bool,
-    /// The Smooth tool's Fidelity, used when Alt switches the Pencil, Paintbrush or Blob Brush to Smooth.
-    /// The engine sets it from Smooth Tool Options (`smoothFidelity`).
+    /// The Smooth tool's Fidelity (screen pixels), used when Alt switches the Pencil, Paintbrush or
+    /// Blob Brush to Smooth. The engine sets it from Smooth Tool Options (`smoothFidelity`).
     smooth_fidelity: f64,
     /// Active drag is smoothing with the Pencil, Paintbrush or Blob Brush (Alt held).
     smoothing: bool,
@@ -166,6 +169,15 @@ pub struct GestureTool {
     /// Where the Blob Brush's or the Eraser's tip outline shows: the pointer over the canvas,
     /// unless Cmd/Ctrl lends a selection tool or Alt the Smooth tool.
     tip_at: Option<Point>,
+    /// A pen pressed less than fully at a point of the stroke whose pressure is kept.
+    light: bool,
+    /// The length of the stroke, in points.
+    length: f64,
+    /// The outline of the area a Blob Brush or Eraser drag covers, as far as it is built
+    /// ([`AreaPreview`]).
+    area: Cell<Option<AreaPreview>>,
+    /// The last [`Tool::overlays`] left part of that outline for later calls.
+    area_pending: Cell<bool>,
     /// The band the smoothing drag has shown so far ([`GestureTool::smooth_band`]).
     band: Cell<Option<SmoothBand>>,
     /// The band last shown does not cover the whole drag yet; the next call adds to it.
@@ -824,6 +836,10 @@ impl GestureTool {
             snap: DrawSnap::default(),
             pressed: Point::ZERO,
             tip_at: None,
+            light: false,
+            length: 0.0,
+            area: Cell::new(None),
+            area_pending: Cell::new(false),
             band: Cell::new(None),
             band_pending: Cell::new(false),
         }
@@ -871,9 +887,13 @@ impl GestureTool {
 
     /// Add a stroke sample, with the pen's pressure, tilt and rotation of the event `ev` there.
     fn push(&mut self, p: Point, ev: &PointerEvent) {
+        if let Some(last) = self.points.last() {
+            self.length += last.distance(p);
+        }
         self.points.push(p);
         if self.id == "paintbrush" || (self.varies_size() && self.size_pressure) {
             self.pressures.push(ev.pressure);
+            self.light |= ev.pressure < 1.0;
         }
         if self.id == "paintbrush" {
             self.poses.push(ev.pen.map(PenPose::sanitized));
@@ -961,6 +981,10 @@ impl GestureTool {
         self.poses.clear();
         self.previewed = 0;
         self.shift_line = None;
+        self.light = false;
+        self.length = 0.0;
+        self.area.set(None);
+        self.area_pending.set(false);
         self.band.set(None);
         self.band_pending.set(false);
     }
@@ -1022,7 +1046,7 @@ impl GestureTool {
     /// Pressure, when a pen pressed less than fully anywhere along it (a stroke without pressure
     /// keeps its Size).
     fn size_pressures(&self) -> Option<&[f32]> {
-        let pressed = self.pressures.len() == self.points.len() && self.pressures.iter().any(|p| *p < 1.0);
+        let pressed = self.pressures.len() == self.points.len() && self.light;
         (self.varies_size() && self.size_pressure && !self.smoothing && pressed).then_some(self.pressures.as_slice())
     }
 
@@ -1152,7 +1176,7 @@ impl GestureTool {
             if has_sel && pts.len() >= 2 {
                 return vec![Action::Exec(
                     "path.smoothRegion".into(),
-                    json!({"points": points_json(pts), "radius": radius, "fidelity": self.smooth_fidelity}),
+                    json!({"points": points_json(pts), "radius": radius, "fidelity": cx.tol(self.smooth_fidelity)}),
                 )];
             }
             return vec![];
@@ -1202,7 +1226,10 @@ impl GestureTool {
             )],
             "knife" if pts.len() >= 2 => vec![Action::Exec("path.knife".into(), json!({"points": points_json(pts)}))],
             "smooth" if has_sel && pts.len() >= 2 => {
-                vec![Action::Exec("path.smoothRegion".into(), json!({"points": points_json(pts), "radius": radius, "fidelity": self.fidelity}))]
+                vec![Action::Exec(
+                    "path.smoothRegion".into(),
+                    json!({"points": points_json(pts), "radius": radius, "fidelity": cx.tol(self.fidelity)}),
+                )]
             }
             "pathEraser" if has_sel => vec![Action::Exec("path.eraseSegments".into(), json!({"points": points_json(pts), "width": cx.tol(8.0)}))],
             "join" if pts.len() >= 2 => vec![Action::Exec("path.joinScrub".into(), json!({"points": points_json(pts), "tolerance": tol}))],
@@ -1388,10 +1415,10 @@ impl Tool for GestureTool {
     fn wants_samples(&self) -> bool {
         matches!(self.id, "pencil" | "paintbrush" | "blobBrush" | "eraser" | "knife" | "smooth" | "pathEraser")
     }
-    /// A smoothing drag's band outlined again after a zoom change reaches the whole drag over
-    /// several frames.
+    /// The outline of a long Blob Brush or Eraser drag, and a smoothing drag's band outlined again
+    /// after a zoom change, reach the whole drag over several frames.
     fn overlays_pending(&self) -> bool {
-        self.band_pending.get()
+        self.area_pending.get() || self.band_pending.get()
     }
     /// `[` and `]` are the Blob Brush's and the Eraser's: their size (#1661).
     fn claims_key(&self, _cx: &ToolContext, key: ToolKey) -> bool {
@@ -1443,6 +1470,7 @@ impl Tool for GestureTool {
         if began { stale.into_iter().chain([Action::Commit]).collect() } else { vec![] }
     }
     fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
+        self.area_pending.set(false);
         self.band_pending.set(false);
         let mut o = self.snap.guides().to_vec();
         // A path being drawn shows itself, except with the Pencil's Live preview off.
@@ -1467,24 +1495,24 @@ impl Tool for GestureTool {
         // A tip that is not round shows the outline of the area it covers, each step of the drag
         // as wide as the pen pressed there with Size set to Pressure. So does a round Blob Brush
         // tip: a line as wide as the brush would end square, where the stroke it adds is round at
-        // both ends (#4343).
+        // both ends (#4343). The outline is built a bounded amount per call ([`AreaPreview`]).
         if matches!(self.id, "eraser" | "blobBrush") && (self.roundness < 100.0 || self.id == "blobBrush") && !self.smoothing {
-            let area = |pts: &[Point], size| {
-                if self.id == "blobBrush" {
-                    blob_area(pts, size, self.angle, self.roundness)
-                } else {
-                    eraser_area(pts, size, self.angle, self.roundness)
-                }
+            let pressures = self.size_pressures();
+            let key = AreaKey {
+                blob: self.id == "blobBrush",
+                size: self.size,
+                variation: self.size_variation,
+                angle: self.angle,
+                roundness: self.roundness,
+                pressure: pressures.is_some(),
             };
-            if let Some(pressures) = self.size_pressures() {
-                for (seg, p) in self.points.windows(2).zip(pressures.windows(2)) {
-                    let pressure = f64::from(p[0] + p[1]) / 2.0;
-                    let size = super::pressure_size(self.size, self.size_variation, pressure);
-                    o.push(Overlay::Path { path: area(seg, size).to_bezpath(), color, width: 1.0, dashed: false });
-                }
-            } else {
-                o.push(Overlay::Path { path: area(&self.points, self.size).to_bezpath(), color, width: 1.0, dashed: false });
+            let mut area = self.area.take().filter(|a| a.fits(key, &self.points)).unwrap_or_else(|| AreaPreview::new(key, self.points[0]));
+            area.step(&self.points, pressures);
+            for path in area.paths(&self.points) {
+                o.push(Overlay::Path { path, color, width: 1.0, dashed: false });
             }
+            self.area_pending.set(area.pending(&self.points));
+            self.area.set(Some(area));
         } else if let Some(pressures) = self.size_pressures() {
             // With Size set to Pressure, each step of the drag shows as wide as the pen pressed there.
             for (seg, p) in self.points.windows(2).zip(pressures.windows(2)) {
@@ -1497,7 +1525,7 @@ impl Tool for GestureTool {
         }
         if cx.measurement_labels && self.id == "blobBrush" && !self.smoothing {
             let last = self.points[self.points.len() - 1];
-            let length = self.points.windows(2).map(|w| w[0].distance(w[1])).sum();
+            let length = self.length;
             o.push(Overlay::Measure { p: last + vectorcraft_geom::Vec2::new(cx.tol(12.0), cx.tol(12.0)), text: format!("L: {}", cx.len(length)) });
         }
         // Over the stroke's footprint, which reaches the tip's edge at the pointer.
diff --git a/crates/tools/src/draw2/gesture/area.rs b/crates/tools/src/draw2/gesture/area.rs
new file mode 100644
index 0000000000..0bc0f13f25
--- /dev/null
+++ b/crates/tools/src/draw2/gesture/area.rs
@@ -0,0 +1,645 @@
+//! The outline a Blob Brush or Eraser drag shows while it is dragged: the boundary of the area its
+//! tip covers, built a bounded amount at a time.
+//!
+//! The drag is cut into pieces of up to [`PIECE_SEGMENTS`] segments (one segment each when the
+//! Size varies with pressure). A call outlines again, in the space where the tip is round, only the
+//! pieces it added segments to. A piece's outline then loses the parts that lie inside the area
+//! of another piece, found through a grid of squares that lists the segments near each square, so
+//! the pieces show as one outline. One call takes at most [`POINTS_PER_CALL`] new points and does at most
+//! [`WORK_PER_CALL`] units of work, plus the one step it was in; what is left waits for the next
+//! call ([`AreaPreview::pending`]). Until then a piece shows the outline it last finished, and the
+//! points not yet taken show as a thin line. The settled pieces show as paths of up to
+//! [`BLOCK_PIECES`] pieces each, and a call joins again only the paths whose pieces changed, at
+//! most [`JOIN_PIECES_PER_CALL`] pieces' worth. The grid holds at most [`LISTINGS`] listings.
+
+use std::collections::{BTreeSet, HashMap};
+
+use vectorcraft_geom::{Affine, BezPath, Line, ParamCurve, PathData, PathEl, PathSeg, Point, SubPath};
+use vectorcraft_pathops as po;
+use vectorcraft_pathops::{Cap, Join};
+
+use super::super::{MIN_BRUSH_SIZE, blob_tip, eraser_tip, pressure_size};
+
+/// The most segments of a drag that one piece of its outline holds, when the Size does not vary
+/// with pressure (a piece then holds one segment).
+pub(super) const PIECE_SEGMENTS: usize = 32;
+/// The most points of a drag one call takes.
+pub(super) const POINTS_PER_CALL: usize = 256;
+/// The most work one call does: one unit for each square of the grid a segment is listed in, and
+/// for each segment of the drag a piece of an outline is checked against. A call stops before the
+/// next point or the next segment of an outline once it has done this much.
+pub(super) const WORK_PER_CALL: usize = 200_000;
+/// The most segments one square of the grid lists. A segment past them is not listed there, and
+/// the outlines inside its area there still show.
+const SQUARE_SEGMENTS: usize = 128;
+/// The most points, half a square apart, at which a segment of the drag is listed in the squares
+/// around them. A longer segment is kept in a short list of its own ([`WIDE_SEGMENTS`]).
+pub(super) const SEGMENT_SAMPLES: usize = 32;
+/// The most listings all squares of the grid hold together: past them a segment is listed in no
+/// square, and the outlines inside its area still show.
+pub(super) const LISTINGS: usize = 4_000_000;
+/// The most squares, along a side of an outline, whose segments the side is checked against; a
+/// longer side is checked against the squares at its ends.
+const SIDE_SQUARES: usize = 128;
+/// The most pieces one joined path of the outline holds.
+pub(super) const BLOCK_PIECES: usize = 64;
+/// The most pieces one call joins into those paths; the others show the path last joined.
+pub(super) const JOIN_PIECES_PER_CALL: usize = 2048;
+/// The most segments the list of long segments holds; the outlines inside the area of a long
+/// segment past them still show.
+const WIDE_SEGMENTS: usize = 256;
+/// The most points along a long segment at which the pieces near it are looked for.
+const WIDE_SAMPLES: usize = 128;
+/// The most points the thin line over the points not yet taken has.
+const GUIDE_POINTS: usize = 256;
+/// The most pieces a curve of an outline is checked in, each at its middle.
+const CURVE_PIECES: usize = 32;
+/// How far inside another piece's area, as a share of its radius, a piece of an outline must be
+/// to be left out: an outline along the edge of another area still shows.
+const INSIDE: f64 = 5e-3;
+
+/// What the outline depends on besides the drag's points: a change starts it again.
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub(super) struct AreaKey {
+    /// The Blob Brush's tip (else the Eraser's).
+    pub blob: bool,
+    pub size: f64,
+    pub variation: f64,
+    pub angle: f64,
+    pub roundness: f64,
+    /// Each segment is as wide as the pen pressed there.
+    pub pressure: bool,
+}
+
+/// The work of the last call.
+#[derive(Clone, Copy, Default, Debug)]
+pub(super) struct AreaWork {
+    /// Points taken.
+    pub points: usize,
+    /// Points of the drag outlined.
+    pub outlined: usize,
+    /// Units of work ([`WORK_PER_CALL`]).
+    pub work: usize,
+    /// Pieces joined into the paths shown ([`JOIN_PIECES_PER_CALL`]).
+    pub joined: usize,
+}
+
+/// The joined outline of up to [`BLOCK_PIECES`] settled pieces.
+#[derive(Default)]
+struct Block {
+    path: BezPath,
+    /// A piece in it changed since `path` was joined.
+    stale: bool,
+}
+
+/// A piece of the drag: segments `from..to` (segment `j` joins points `j` and `j + 1`).
+struct Piece {
+    from: usize,
+    to: usize,
+    /// Its outline where the tip is round, segment by segment: the segment, whether it starts a
+    /// contour and whether it ends a closed one.
+    outline: Vec<(PathSeg, bool, bool)>,
+    /// The part of its outline that shows, on the page.
+    shown: BezPath,
+}
+
+/// A piece whose outline is being checked, up to segment `at` of it.
+struct Check {
+    piece: usize,
+    at: usize,
+    out: BezPath,
+    pen: Option<Point>,
+    /// Every segment of the current contour shows whole.
+    whole: bool,
+}
+
+pub(super) struct AreaPreview {
+    key: AreaKey,
+    first: Point,
+    squash: Affine,
+    stretch: Affine,
+    /// The side of the grid's squares, where the tip is round.
+    side: f64,
+    /// The points taken, where the tip is round.
+    sq: Vec<Point>,
+    /// The last point taken, on the page.
+    last: Point,
+    /// The tip's radius along each segment, where the tip is round.
+    radius: Vec<f64>,
+    pieces: Vec<Piece>,
+    squares: HashMap<(i64, i64), Vec<u32>>,
+    /// How many listings the squares hold ([`LISTINGS`]).
+    listed: usize,
+    wide: Vec<usize>,
+    /// The pieces whose outline is to be checked again.
+    dirty: BTreeSet<usize>,
+    check: Option<Check>,
+    /// The outlines that show of every piece but a growing last one, joined [`BLOCK_PIECES`] at a
+    /// time.
+    blocks: Vec<Block>,
+    pub work: AreaWork,
+}
+
+impl AreaPreview {
+    /// The outline of a drag that starts at `first`.
+    pub(super) fn new(key: AreaKey, first: Point) -> Self {
+        let stretch = if key.blob { blob_tip(key.angle, key.roundness) } else { eraser_tip(key.angle, key.roundness) };
+        let widest = if key.pressure { pressure_size(key.size, key.variation, 1.0) } else { key.size };
+        Self {
+            key,
+            first,
+            squash: stretch.inverse(),
+            stretch,
+            side: widest.max(MIN_BRUSH_SIZE),
+            sq: vec![],
+            last: first,
+            radius: vec![],
+            pieces: vec![],
+            squares: HashMap::new(),
+            listed: 0,
+            wide: vec![],
+            dirty: BTreeSet::new(),
+            check: None,
+            blocks: vec![],
+            work: AreaWork::default(),
+        }
+    }
+
+    /// Is this the outline of the drag `pts` with `key`: the same start, and the points it took
+    /// still the drag's?
+    pub(super) fn fits(&self, key: AreaKey, pts: &[Point]) -> bool {
+        self.key == key
+            && pts.first() == Some(&self.first)
+            && self.sq.len() <= pts.len()
+            && self.sq.len().checked_sub(1).and_then(|i| pts.get(i)) == Some(&self.last)
+    }
+
+    /// Is part of the drag `pts` not shown yet as it should be?
+    pub(super) fn pending(&self, pts: &[Point]) -> bool {
+        self.sq.len() < pts.len() || !self.dirty.is_empty() || self.check.is_some() || self.blocks.iter().any(|b| b.stale)
+    }
+
+    /// How many listings the grid's squares hold.
+    #[cfg(test)]
+    pub(super) fn listed(&self) -> usize {
+        self.listed
+    }
+
+    /// Mark the joined path that holds settled piece `k` to be joined again.
+    fn mark(&mut self, k: usize) {
+        let b = k / BLOCK_PIECES;
+        if self.blocks.len() <= b {
+            self.blocks.resize_with(b + 1, Block::default);
+        }
+        self.blocks[b].stale = true;
+    }
+
+    /// Take the points of the drag `pts` added since the last call and check outlines, within this
+    /// call's limits. `pressures` holds the pen pressure at each point when the Size varies with it.
+    pub(super) fn step(&mut self, pts: &[Point], pressures: Option<&[f32]>) {
+        self.work = AreaWork::default();
+        let mut changed = BTreeSet::new();
+        while self.sq.len() < pts.len() && self.work.points < POINTS_PER_CALL && self.work.work < WORK_PER_CALL {
+            let i = self.sq.len();
+            self.sq.push(self.squash * pts[i]);
+            self.last = pts[i];
+            self.work.points += 1;
+            let Some(j) = i.checked_sub(1) else { continue };
+            let size = match pressures.filter(|_| self.key.pressure).and_then(|f| f.get(j..=i)) {
+                Some(f) => pressure_size(self.key.size, self.key.variation, f64::from(f[0] + f[1]) / 2.0),
+                None => self.key.size,
+            };
+            self.radius.push(size / 2.0);
+            if self.key.pressure || self.pieces.last().is_none_or(|p| p.to - p.from >= PIECE_SEGMENTS) {
+                self.pieces.push(Piece { from: j, to: j, outline: vec![], shown: BezPath::new() });
+            }
+            let k = self.pieces.len() - 1;
+            self.pieces[k].to = j + 1;
+            changed.insert(k);
+            self.list(j, k);
+        }
+        for k in changed {
+            self.outline_piece(k);
+        }
+        self.check_some();
+    }
+
+    /// The paths to show: the settled pieces' outlines, joined [`BLOCK_PIECES`] at a time, the
+    /// growing last piece's and a thin line over the points of `pts` not taken yet. The joined
+    /// paths with a changed piece are joined again, newest first, at most
+    /// [`JOIN_PIECES_PER_CALL`] pieces a call; the others show the path last joined.
+    pub(super) fn paths(&mut self, pts: &[Point]) -> Vec<BezPath> {
+        let settled = self.settled_count();
+        for b in (0..self.blocks.len()).rev() {
+            if self.work.joined >= JOIN_PIECES_PER_CALL {
+                break;
+            }
+            if !self.blocks[b].stale {
+                continue;
+            }
+            let pieces = self.pieces.get(b * BLOCK_PIECES..settled.min((b + 1) * BLOCK_PIECES)).unwrap_or_default();
+            let mut joined = BezPath::new();
+            for p in pieces {
+                joined.extend(p.shown.elements().iter().copied());
+            }
+            self.work.joined += pieces.len();
+            self.blocks[b] = Block { path: joined, stale: false };
+        }
+        let mut out: Vec<BezPath> = self.blocks.iter().filter(|b| !b.path.elements().is_empty()).map(|b| b.path.clone()).collect();
+        if let Some(p) = self.pieces.get(settled).filter(|p| !p.shown.elements().is_empty()) {
+            out.push(p.shown.clone());
+        }
+        if let Some(rest) = pts.get(self.sq.len()..).filter(|r| !r.is_empty()) {
+            let stride = rest.len().div_ceil(GUIDE_POINTS).max(1);
+            let mut guide = BezPath::new();
+            guide.move_to(self.last);
+            for p in rest.iter().skip(stride - 1).step_by(stride) {
+                guide.line_to(*p);
+            }
+            if let Some(&end) = rest.last().filter(|_| (rest.len() % stride) != 0) {
+                guide.line_to(end);
+            }
+            out.push(guide);
+        }
+        out
+    }
+
+    /// How many pieces no longer grow: all of them but a last one with room for more segments.
+    fn settled_count(&self) -> usize {
+        let growing = !self.key.pressure && self.pieces.last().is_some_and(|p| p.to - p.from < PIECE_SEGMENTS);
+        self.pieces.len() - usize::from(growing)
+    }
+
+    /// The piece that holds segment `j`.
+    fn piece_of(&self, j: usize) -> usize {
+        if self.key.pressure { j } else { j / PIECE_SEGMENTS }
+    }
+
+    /// The square of the grid that holds `p`; `None` far outside any document.
+    fn square(&self, p: Point) -> Option<(i64, i64)> {
+        let (x, y) = ((p.x / self.side).floor(), (p.y / self.side).floor());
+        (x.abs() < 1e15 && y.abs() < 1e15).then_some((x as i64, y as i64))
+    }
+
+    /// The squares around points half a square apart along the segment from `a` to `b`: every
+    /// square holding a point within half a square of it. `None` past `samples` points.
+    fn squares_along(&self, a: Point, b: Point, samples: usize) -> Option<Vec<(i64, i64)>> {
+        let n = (a.distance(b) / (0.5 * self.side)).ceil().max(1.0);
+        if !n.is_finite() || n > samples as f64 {
+            return None;
+        }
+        let mut keys = vec![];
+        for k in 0..=(n as usize) {
+            let (x, y) = self.square(a.lerp(b, k as f64 / n))?;
+            for dy in -1..=1 {
+                for dx in -1..=1 {
+                    keys.push((x + dx, y + dy));
+                }
+            }
+        }
+        keys.sort_unstable();
+        keys.dedup();
+        Some(keys)
+    }
+
+    /// List segment `j` of piece `k` in the squares its area reaches, and mark the other pieces
+    /// whose outline its area can reach to be checked again.
+    fn list(&mut self, j: usize, k: usize) {
+        let (a, b, r) = (self.sq[j], self.sq[j + 1], self.radius[j]);
+        let mut near = vec![];
+        match self.squares_along(a, b, SEGMENT_SAMPLES) {
+            Some(keys) => {
+                for key in keys {
+                    self.work.work += 1;
+                    if self.listed >= LISTINGS {
+                        near.extend(self.squares.get(&key).into_iter().flatten().map(|m| *m as usize));
+                        continue;
+                    }
+                    let listed = self.squares.entry(key).or_default();
+                    near.extend(listed.iter().map(|m| *m as usize));
+                    if listed.len() < SQUARE_SEGMENTS {
+                        listed.push(j as u32);
+                        self.listed += 1;
+                    }
+                }
+            }
+            None => {
+                // The pieces near points along it, at most WIDE_SAMPLES of them.
+                let n = (a.distance(b) / (0.5 * self.side)).ceil().clamp(1.0, WIDE_SAMPLES as f64);
+                for s in 0..=(n as usize) {
+                    let Some((x, y)) = self.square(a.lerp(b, s as f64 / n)) else { continue };
+                    for dy in -1..=1 {
+                        for dx in -1..=1 {
+                            self.work.work += 1;
+                            near.extend(self.squares.get(&(x + dx, y + dy)).into_iter().flatten().map(|m| *m as usize));
+                        }
+                    }
+                }
+                if self.wide.len() < WIDE_SEGMENTS {
+                    self.wide.push(j);
+                }
+            }
+        }
+        near.extend(self.wide.iter().copied().filter(|m| *m != j));
+        near.sort_unstable();
+        near.dedup();
+        for m in near {
+            self.work.work += 1;
+            let q = self.piece_of(m);
+            if q != k && !self.dirty.contains(&q) && segment_distance(a, b, self.sq[m], self.sq[m + 1]) < r + self.radius[m] {
+                self.dirty.insert(q);
+                if self.check.as_ref().is_some_and(|c| c.piece == q) {
+                    self.check = None;
+                }
+            }
+        }
+    }
+
+    /// Outline piece `k` again, and mark it to be checked.
+    fn outline_piece(&mut self, k: usize) {
+        let settled = self.settled_count();
+        let Some(p) = self.pieces.get(k) else { return };
+        let pts = &self.sq[p.from..=p.to];
+        let width = 2.0 * self.radius[p.from];
+        self.work.outlined += pts.len();
+        let area = po::outline_stroke(&PathData::single(SubPath::polyline(pts, false)), width, Cap::Round, Join::Round, 4.0).to_bezpath();
+        let outline = segments(&area);
+        let shown = self.stretch * area;
+        if let Some(p) = self.pieces.get_mut(k) {
+            p.outline = outline;
+            p.shown = shown;
+        }
+        if self.check.as_ref().is_some_and(|c| c.piece == k) {
+            self.check = None;
+        }
+        self.dirty.insert(k);
+        if k < settled {
+            self.mark(k);
+        }
+    }
+
+    /// Check the outlines of the pieces marked, newest first, one segment of an outline at a
+    /// time, until this call's work is done.
+    fn check_some(&mut self) {
+        while self.work.work < WORK_PER_CALL {
+            let mut c = match self.check.take() {
+                Some(c) => c,
+                None => match self.dirty.pop_last() {
+                    Some(piece) => Check { piece, at: 0, out: BezPath::new(), pen: None, whole: true },
+                    None => break,
+                },
+            };
+            let Some(p) = self.pieces.get(c.piece) else { continue };
+            let Some(&(seg, starts, closes)) = p.outline.get(c.at) else {
+                // The whole outline is checked.
+                let settled = self.settled_count();
+                let shown = self.stretch * std::mem::take(&mut c.out);
+                if let Some(p) = self.pieces.get_mut(c.piece) {
+                    p.shown = shown;
+                }
+                if c.piece < settled {
+                    self.mark(c.piece);
+                }
+                continue;
+            };
+            let own = p.from..p.to;
+            if starts {
+                c.pen = None;
+                c.whole = true;
+            }
+            let runs = self.visible(seg, own);
+            if !matches!(runs[..], [(a, b)] if a == 0.0 && b == 1.0) {
+                c.whole = false;
+            }
+            for (a, b) in runs {
+                push_seg(&mut c.out, &mut c.pen, if a == 0.0 && b == 1.0 { seg } else { seg.subsegment(a..b) });
+            }
+            if closes && c.whole {
+                c.out.close_path();
+                c.pen = None;
+            }
+            c.at += 1;
+            self.check = Some(c);
+        }
+    }
+
+    /// The segments of the drag, but `own`, whose area can hold a point of the squares `keys`.
+    fn candidates(&mut self, keys: impl IntoIterator<Item = (i64, i64)>, own: &std::ops::Range<usize>) -> Vec<usize> {
+        let mut out: Vec<usize> = self.wide.clone();
+        for key in keys {
+            out.extend(self.squares.get(&key).into_iter().flatten().map(|m| *m as usize));
+        }
+        self.work.work += out.len();
+        out.retain(|m| !own.contains(m));
+        out.sort_unstable();
+        out.dedup();
+        out
+    }
+
+    /// The stretches of `seg` (from and to, 0 at its start, 1 at its end) that lie inside no area
+    /// of a segment of the drag but `own`.
+    fn visible(&mut self, seg: PathSeg, own: std::ops::Range<usize>) -> Vec<(f64, f64)> {
+        let inside = |s: &Self, q: Point, m: usize| distance_to_segment(q, s.sq[m], s.sq[m + 1]) < s.radius[m] * (1.0 - INSIDE);
+        match seg {
+            PathSeg::Line(line) => {
+                let len = line.p0.distance(line.p1);
+                let n = (len / self.side).ceil().max(1.0);
+                let keys: Vec<(i64, i64)> = if !n.is_finite() || n > SIDE_SQUARES as f64 {
+                    // A very long side: the squares at its ends.
+                    [line.p0, line.p1].into_iter().filter_map(|p| self.square(p)).collect()
+                } else {
+                    let mut keys = vec![];
+                    for i in 0..(n as usize) {
+                        let (p, q) = (line.p0.lerp(line.p1, i as f64 / n), line.p0.lerp(line.p1, (i + 1) as f64 / n));
+                        let (Some(lo), Some(hi)) =
+                            (self.square(Point::new(p.x.min(q.x), p.y.min(q.y))), self.square(Point::new(p.x.max(q.x), p.y.max(q.y))))
+                        else {
+                            continue;
+                        };
+                        for y in lo.1..=hi.1 {
+                            for x in lo.0..=hi.0 {
+                                keys.push((x, y));
+                            }
+                        }
+                    }
+                    keys.sort_unstable();
+                    keys.dedup();
+                    keys
+                };
+                let near = self.candidates(keys, &own);
+                let spans = near.iter().filter_map(|&m| capsule_span(line, self.sq[m], self.sq[m + 1], self.radius[m] * (1.0 - INSIDE))).collect();
+                gaps(&merge_spans(spans))
+            }
+            _ => {
+                let reach: f64 = match seg {
+                    PathSeg::Quad(q) => q.p0.distance(q.p1) + q.p1.distance(q.p2),
+                    PathSeg::Cubic(c) => c.p0.distance(c.p1) + c.p1.distance(c.p2) + c.p2.distance(c.p3),
+                    PathSeg::Line(l) => l.p0.distance(l.p1),
+                };
+                let n = (reach / (0.025 * self.side)).ceil().clamp(1.0, CURVE_PIECES as f64) as usize;
+                let mut shows = vec![];
+                for i in 0..n {
+                    let mid = seg.eval((i as f64 + 0.5) / n as f64);
+                    let near = self.candidates(self.square(mid), &own);
+                    shows.push(!near.iter().any(|&m| inside(self, mid, m)));
+                }
+                let mut runs: Vec<(f64, f64)> = vec![];
+                for (i, show) in shows.into_iter().enumerate() {
+                    if !show {
+                        continue;
+                    }
+                    let (a, b) = (i as f64 / n as f64, (i + 1) as f64 / n as f64);
+                    match runs.last_mut() {
+                        Some(last) if last.1 == a => last.1 = b,
+                        _ => runs.push((a, b)),
+                    }
+                }
+                runs
+            }
+        }
+    }
+}
+
+/// The segments of `path`: each with whether it starts a contour and whether it ends a closed one.
+fn segments(path: &BezPath) -> Vec<(PathSeg, bool, bool)> {
+    let mut out: Vec<(PathSeg, bool, bool)> = vec![];
+    let (mut start, mut pen, mut first) = (Point::ZERO, Point::ZERO, true);
+    for el in path.elements() {
+        let seg = match *el {
+            PathEl::MoveTo(p) => {
+                (start, pen, first) = (p, p, true);
+                continue;
+            }
+            PathEl::LineTo(p) => PathSeg::Line(Line::new(pen, p)),
+            PathEl::QuadTo(p1, p2) => PathSeg::Quad(vectorcraft_geom::kurbo::QuadBez::new(pen, p1, p2)),
+            PathEl::CurveTo(p1, p2, p3) => PathSeg::Cubic(vectorcraft_geom::CubicBez::new(pen, p1, p2, p3)),
+            PathEl::ClosePath => {
+                if pen != start {
+                    out.push((PathSeg::Line(Line::new(pen, start)), first, false));
+                    first = false;
+                }
+                if !first && let Some(last) = out.last_mut() {
+                    last.2 = true;
+                }
+                pen = start;
+                first = true;
+                continue;
+            }
+        };
+        out.push((seg, first, false));
+        first = false;
+        pen = seg.end();
+    }
+    out
+}
+
+/// Add `seg` to `out`, starting a new subpath unless it starts at `pen`, where the last one ended.
+fn push_seg(out: &mut BezPath, pen: &mut Option<Point>, seg: PathSeg) {
+    let a = seg.start();
+    if *pen != Some(a) {
+        out.move_to(a);
+    }
+    match seg {
+        PathSeg::Line(l) => out.line_to(l.p1),
+        PathSeg::Quad(q) => out.quad_to(q.p1, q.p2),
+        PathSeg::Cubic(c) => out.curve_to(c.p1, c.p2, c.p3),
+    }
+    *pen = Some(seg.end());
+}
+
+/// How far `q` is from the segment from `a` to `b`.
+fn distance_to_segment(q: Point, a: Point, b: Point) -> f64 {
+    let d = b - a;
+    let t = if d.hypot2() > 0.0 { ((q - a).dot(d) / d.hypot2()).clamp(0.0, 1.0) } else { 0.0 };
+    q.distance(a + d * t)
+}
+
+/// How far the segment from `a` to `b` is from the segment from `c` to `d`.
+fn segment_distance(a: Point, b: Point, c: Point, d: Point) -> f64 {
+    let side = |p: Point, q: Point, s: Point| (q - p).cross(s - p);
+    if side(a, b, c) * side(a, b, d) < 0.0 && side(c, d, a) * side(c, d, b) < 0.0 {
+        return 0.0;
+    }
+    distance_to_segment(a, c, d).min(distance_to_segment(b, c, d)).min(distance_to_segment(c, a, b)).min(distance_to_segment(d, a, b))
+}
+
+/// The stretch of `line`, as from and to along it (0 at its start, 1 at its end, and beyond), that
+/// lies within `rad` of the segment from `a` to `b`; `None` when no point of the line does.
+fn capsule_span(line: Line, a: Point, b: Point, rad: f64) -> Option<(f64, f64)> {
+    let (p, d) = (line.p0, line.p1 - line.p0);
+    let dd = d.hypot2();
+    if dd <= 0.0 || rad.is_nan() || rad <= 0.0 {
+        return None;
+    }
+    let (mut lo, mut hi) = (f64::INFINITY, f64::NEG_INFINITY);
+    // The round ends.
+    for c in [a, b] {
+        let f = p - c;
+        let (half_b, k) = (d.dot(f), f.hypot2() - rad * rad);
+        let disc = half_b * half_b - dd * k;
+        if disc >= 0.0 {
+            let root = disc.sqrt();
+            lo = lo.min((-half_b - root) / dd);
+            hi = hi.max((-half_b + root) / dd);
+        }
+    }
+    // The part between them: along the segment from 0 to its length, and across it within `rad`.
+    let e = b - a;
+    let len = e.hypot();
+    if len > 0.0 {
+        let u = e / len;
+        let n = vectorcraft_geom::Vec2::new(-u.y, u.x);
+        let (mut s0, mut s1) = (f64::NEG_INFINITY, f64::INFINITY);
+        for (at, rate, min, max) in [((p - a).dot(u), d.dot(u), 0.0, len), ((p - a).dot(n), d.dot(n), -rad, rad)] {
+            if rate == 0.0 {
+                if at < min || at > max {
+                    s1 = f64::NEG_INFINITY;
+                }
+            } else {
+                let (x, y) = ((min - at) / rate, (max - at) / rate);
+                s0 = s0.max(x.min(y));
+                s1 = s1.min(x.max(y));
+            }
+        }
+        if s0 <= s1 {
+            lo = lo.min(s0);
+            hi = hi.max(s1);
+        }
+    }
+    (lo < hi).then_some((lo, hi))
+}
+
+/// `spans` sorted and joined where they overlap.
+fn merge_spans(mut spans: Vec<(f64, f64)>) -> Vec<(f64, f64)> {
+    spans.sort_by(|x, y| x.0.total_cmp(&y.0));
+    let mut out: Vec<(f64, f64)> = Vec::with_capacity(spans.len());
+    for (a, b) in spans {
+        match out.last_mut() {
+            Some(last) if a <= last.1 => last.1 = last.1.max(b),
+            _ => out.push((a, b)),
+        }
+    }
+    out
+}
+
+/// The stretches of 0 to 1 that none of `spans` (from [`merge_spans`]) holds.
+fn gaps(spans: &[(f64, f64)]) -> Vec<(f64, f64)> {
+    let mut out = vec![];
+    let mut at = 0.0;
+    for &(a, b) in spans {
+        if b <= at {
+            continue;
+        }
+        if a >= 1.0 {
+            break;
+        }
+        if a > at {
+            out.push((at, a));
+        }
+        at = b;
+    }
+    if at < 1.0 {
+        out.push((at, 1.0));
+    }
+    out
+}
diff --git a/crates/tools/src/draw2/gesture/tests.rs b/crates/tools/src/draw2/gesture/tests.rs
index 496ce396e2..4703305d85 100644
--- a/crates/tools/src/draw2/gesture/tests.rs
+++ b/crates/tools/src/draw2/gesture/tests.rs
@@ -585,7 +585,7 @@ fn blob_brush_alt_switches_to_the_smooth_tool() {
     let acts = drag_held(&mut t, &cx, &stroke, alt);
     assert!(acts[..acts.len() - 1].iter().all(|a| a.is_empty()), "{acts:?}");
     let v = smoothed(&acts).unwrap_or_else(|| panic!("{acts:?}"));
-    assert_eq!(v, json!({"points": [[50.0, 150.0], [150.0, 150.0], [250.0, 160.0]], "radius": cx.tol(12.0), "fidelity": SMOOTH_FIDELITY}));
+    assert_eq!(v, json!({"points": [[50.0, 150.0], [150.0, 150.0], [250.0, 160.0]], "radius": cx.tol(12.0), "fidelity": cx.tol(SMOOTH_FIDELITY)}));
     // Mid-drag the cursor stays the Smooth tool's when Alt is let go, and the line is thin with
     // no length label.
     t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 50.0, 150.0).with_mods(alt));
@@ -1499,6 +1499,37 @@ fn alt_smoothing_uses_the_smooth_tools_fidelity() {
     }
 }
 
+/// The Smooth tool's Fidelity is in screen pixels: the Smooth tool and an Alt smoothing drag with
+/// the Pencil, Paintbrush or Blob Brush send it in points at Fidelity / zoom, so a drag smooths as
+/// much on screen at any zoom.
+#[test]
+fn smooth_fidelity_is_in_screen_pixels_at_any_zoom() {
+    let (d, id) = doc_with_rect();
+    let mut s = Selection::default();
+    s.set([id]);
+    let p = paint();
+    let mut cx = cx(&d, &s, &p);
+    cx.smart_guides = false;
+    let pts = [(50.0, 150.0), (150.0, 150.0), (250.0, 160.0)];
+    let fidelity = |acts: &[Vec<Action>]| match acts.last().and_then(|a| a.first()) {
+        Some(Action::Exec(c, v)) if c == "path.smoothRegion" => v["fidelity"].as_f64().unwrap(),
+        a => panic!("expected path.smoothRegion, got: {a:?}"),
+    };
+    let alt = Mods { alt: true, ..Default::default() };
+    for zoom in [0.25, 1.0, 8.0] {
+        cx.zoom = zoom;
+        let mut t = GestureTool::new("smooth");
+        t.set_option("fidelity", &json!(4.0));
+        assert_eq!(fidelity(&drag(&mut t, &cx, &pts, Mods::default())), 4.0 / zoom, "smooth at {zoom}x");
+        for (id, alt_smooth) in [("pencil", true), ("blobBrush", false), ("paintbrush", false)] {
+            let mut t = GestureTool::new(id);
+            t.set_option("altSmooth", &json!(alt_smooth));
+            t.set_option("smoothFidelity", &json!(4.0));
+            assert_eq!(fidelity(&drag_held(&mut t, &cx, &pts, alt)), 4.0 / zoom, "{id} at {zoom}x");
+        }
+    }
+}
+
 /// Alt pressed after a Paintbrush stroke begins closes it, and an empty selection still draws.
 #[test]
 fn paintbrush_alt_after_press_closes_without_smoothing_and_empty_selection_draws() {
@@ -2171,6 +2202,254 @@ fn the_blob_brush_sends_its_tip_and_shows_the_area_it_covers() {
     assert!(vectorcraft_geom::Shape::bounding_box(path).height() < 0.1, "{o:?}");
 }
 
+/// A drag of `n` points (2 to 10 pt apart) that circles round and crosses itself many times,
+/// pressed at `pressure(i)` at point `i`, left down.
+fn long_area_drag(t: &mut GestureTool, cx: &ToolContext, n: usize, pressure: impl Fn(usize) -> f32) {
+    for i in 0..n {
+        let s = i as f64;
+        let r = 150.0 + 100.0 * (s * 0.0071).sin();
+        let (x, y) = (300.0 + r * (s * 0.04).cos(), 300.0 + r * (s * 0.04).sin());
+        let kind = if i == 0 { PointerKind::Down } else { PointerKind::Drag };
+        t.pointer(cx, &PointerEvent { pressure: pressure(i), ..PointerEvent::new(kind, x, y) });
+    }
+    assert_eq!(t.points.len(), n, "every point is a sample");
+}
+
+/// The work the last `overlays` did on the area's outline, and whether it left some for later.
+fn area_work(t: &GestureTool) -> (area::AreaWork, bool) {
+    let Some(a) = t.area.take() else { panic!("no outline") };
+    let w = (a.work, a.pending(&t.points));
+    t.area.set(Some(a));
+    assert_eq!(w.1, t.overlays_pending());
+    w
+}
+
+/// The most work one `overlays` call can do past [`area::WORK_PER_CALL`]: the one step it is in
+/// when it reaches it: a segment of the drag listed in, or checked near, up to 129 × 9 squares of
+/// up to 128 segments each, and those segments checked once each.
+const AREA_STEP: usize = 2 * (129 * 9 * 129 + 256);
+
+/// Call `overlays` until the outline covers the whole drag, checking each call's work; the
+/// number of calls it took.
+fn drain_area(t: &GestureTool, cx: &ToolContext) -> usize {
+    let mut calls = 0;
+    loop {
+        t.overlays(cx);
+        calls += 1;
+        let (w, pending) = area_work(t);
+        assert!(w.points <= area::POINTS_PER_CALL, "{w:?}");
+        assert!(w.outlined <= 2 * area::POINTS_PER_CALL + 2 * (area::PIECE_SEGMENTS + 1), "{w:?}");
+        assert!(w.work <= area::WORK_PER_CALL + AREA_STEP, "{w:?}");
+        assert!(w.joined <= area::JOIN_PIECES_PER_CALL + area::BLOCK_PIECES, "{w:?}");
+        if !pending {
+            return calls;
+        }
+        assert!(calls < 10_000, "the outline never covers the drag");
+    }
+}
+
+/// The Blob Brush's and the Eraser's outline of a long drag does a bounded amount of work per
+/// frame: each call takes at most `POINTS_PER_CALL` new points, outlines a bounded number of them
+/// and checks outlines for a bounded amount of work, leaving the rest for later calls
+/// (`overlays_pending`), which finish it with the pointer still. A call after that does nothing
+/// until the drag moves, and then only the new step's work. The release sends the whole stroke.
+#[test]
+fn the_blob_brush_and_the_eraser_outline_a_long_drag_a_bounded_amount_per_frame() {
+    let (d, _) = doc_with_rect();
+    let s = Selection::default();
+    let p = paint();
+    let cx = ToolContext { precise_cursors: true, ..cx(&d, &s, &p) };
+    for (id, angle, roundness, pressure) in [
+        ("blobBrush", 0.0, 100.0, false),
+        ("blobBrush", 30.0, 40.0, false),
+        ("eraser", -60.0, 30.0, false),
+        ("blobBrush", 0.0, 100.0, true),
+        ("eraser", 45.0, 50.0, true),
+    ] {
+        let mut t = GestureTool::new(id);
+        t.set_option("size", &json!(10));
+        t.set_option("angle", &json!(angle));
+        t.set_option("roundness", &json!(roundness));
+        if pressure {
+            t.set_option("sizeMode", &json!("pressure"));
+            t.set_option("sizeVariation", &json!(4));
+        }
+        long_area_drag(&mut t, &cx, 3000, |i| if pressure { 0.3 + 0.6 * ((i % 50) as f32 / 50.0) } else { 1.0 });
+        let calls = drain_area(&t, &cx);
+        assert!(calls > 1, "{id}: a 3,000-point drag takes several frames");
+        // Nothing new: nothing to do, at any zoom (the outline is in document space).
+        for zoom in [1.0, 4.0] {
+            t.overlays(&ToolContext { zoom, ..cx });
+            let (w, pending) = area_work(&t);
+            assert_eq!((w.points, w.outlined, w.work, w.joined, pending), (0, 0, 0, 0, false), "{id}");
+        }
+        // One step more: one point, its piece outlined again, and the outlines near it checked.
+        t.pointer(&cx, &PointerEvent { pressure: if pressure { 0.5 } else { 1.0 }, ..PointerEvent::new(PointerKind::Drag, 520.0, 300.0) });
+        t.overlays(&cx);
+        let (w, _) = area_work(&t);
+        assert_eq!(w.points, 1, "{id}");
+        assert!(w.outlined <= area::PIECE_SEGMENTS + 1, "{id}: {w:?}");
+        if pressure {
+            // 3,000 one-segment pieces: only the joined paths near the step are joined again.
+            assert!(w.joined <= 8 * area::BLOCK_PIECES, "{id}: {w:?}");
+        }
+        drain_area(&t, &cx);
+        let want = t.stroke_json();
+        let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 520.0, 300.0));
+        let Some(Action::Exec(_, v)) = acts.first() else { panic!("{acts:?}") };
+        assert_eq!(v["points"], want, "{id}: the release sends every point");
+        assert_eq!(v["points"].as_array().map(Vec::len), Some(3001), "{id}");
+        assert!(t.area.take().is_none() && !t.overlays_pending(), "{id}: the release drops the outline");
+    }
+}
+
+/// Every flattened point of the paths `o` (the outline shown).
+fn shown_points(o: &[Overlay]) -> Vec<(Point, Point)> {
+    let mut lines = vec![];
+    for o in o {
+        let Overlay::Path { path, .. } = o else { continue };
+        let mut pen = Point::ZERO;
+        let mut start = Point::ZERO;
+        vectorcraft_geom::kurbo::flatten(path.elements().iter().copied(), 0.01, |el| match el {
+            vectorcraft_geom::PathEl::MoveTo(p) => (pen, start) = (p, p),
+            vectorcraft_geom::PathEl::LineTo(p) => {
+                lines.push((pen, p));
+                pen = p;
+            }
+            vectorcraft_geom::PathEl::ClosePath => {
+                lines.push((pen, start));
+                pen = start;
+            }
+            _ => {}
+        });
+    }
+    lines
+}
+
+fn distance_to_line(q: Point, (a, b): (Point, Point)) -> f64 {
+    let d = b - a;
+    let t = if d.hypot2() > 0.0 { ((q - a).dot(d) / d.hypot2()).clamp(0.0, 1.0) } else { 0.0 };
+    q.distance(a + d * t)
+}
+
+/// Once a long drag's outline is finished it is the outline of the whole area its tip covers, as
+/// `blob_area` and `eraser_area` give it: no line inside the area (where pieces of the drag
+/// overlap or it crosses itself), and no gap along its edge.
+#[test]
+fn the_outline_of_a_long_drag_is_the_edge_of_the_whole_area() {
+    let (d, _) = doc_with_rect();
+    let s = Selection::default();
+    let p = paint();
+    let cx = ToolContext { precise_cursors: true, ..cx(&d, &s, &p) };
+    for (id, angle, roundness) in [("blobBrush", 0.0, 100.0), ("eraser", 30.0, 40.0)] {
+        let mut t = GestureTool::new(id);
+        t.set_option("size", &json!(12));
+        t.set_option("angle", &json!(angle));
+        t.set_option("roundness", &json!(roundness));
+        long_area_drag(&mut t, &cx, 700, |_| 1.0);
+        drain_area(&t, &cx);
+        let shown = shown_points(&t.overlays(&cx));
+        let tip = if id == "blobBrush" { blob_tip(angle, roundness) } else { eraser_tip(angle, roundness) };
+        let squash = tip.inverse();
+        let round: Vec<Point> = t.points.iter().map(|p| squash * *p).collect();
+        // Nothing shows inside the area: every point shown is about the tip's radius from the drag.
+        for &(a, _) in &shown {
+            let q = squash * a;
+            let inner = round.windows(2).map(|w| distance_to_line(q, (w[0], w[1]))).fold(f64::INFINITY, f64::min);
+            assert!(inner > 6.0 * 0.9, "{id}: a line {inner} from the drag, inside the area, at {a:?}");
+        }
+        // The whole edge shows.
+        let exact = if id == "blobBrush" {
+            super::super::blob_area(&t.points, 12.0, angle, roundness)
+        } else {
+            super::super::eraser_area(&t.points, 12.0, angle, roundness)
+        };
+        let edge = shown_points(&[Overlay::Path { path: exact.to_bezpath(), color: FEEDBACK, width: 1.0, dashed: false }]);
+        for &(a, _) in &edge {
+            let gap = shown.iter().map(|l| distance_to_line(a, *l)).fold(f64::INFINITY, f64::min);
+            assert!(gap < 0.6, "{id}: the edge at {a:?} is {gap} from the outline shown");
+        }
+    }
+}
+
+/// A drag with a very long step (a jump of 20,000 pt with a 1 pt tip) still finishes its outline
+/// a bounded amount at a time, and the outline reaches both ends of the jump.
+#[test]
+fn a_long_jump_in_a_blob_brush_drag_is_outlined_a_bounded_amount_at_a_time() {
+    let (d, _) = doc_with_rect();
+    let s = Selection::default();
+    let p = paint();
+    let cx = ToolContext { precise_cursors: true, ..cx(&d, &s, &p) };
+    let mut t = GestureTool::new("blobBrush");
+    t.set_option("size", &json!(1));
+    t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
+    for i in 1..400 {
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, f64::from(i) * 2.0, 0.0));
+    }
+    // Over and back across the first steps, then out 20,000 pt and back over the same line.
+    for x in [20_000.0, 400.0, 20_000.0, 10.0] {
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, x, 0.3));
+    }
+    drain_area(&t, &cx);
+    let o = t.overlays(&cx);
+    let b = o
+        .iter()
+        .filter_map(|o| if let Overlay::Path { path, .. } = o { Some(vectorcraft_geom::Shape::bounding_box(path)) } else { None })
+        .reduce(|a, b| a.union(b));
+    let Some(b) = b else { panic!("{o:?}") };
+    assert!((b.x0 + 0.5).abs() < 0.01 && (b.x1 - 20_000.5).abs() < 0.01, "{b:?}");
+}
+
+/// A drag of many long steps (60 times the tip's size) lists each step in a bounded number of the
+/// grid's squares, so the grid does not grow with the steps' length.
+#[test]
+fn long_steps_of_a_drag_are_listed_in_a_bounded_number_of_squares() {
+    let (d, _) = doc_with_rect();
+    let s = Selection::default();
+    let p = paint();
+    let cx = ToolContext { precise_cursors: true, ..cx(&d, &s, &p) };
+    let mut t = GestureTool::new("eraser");
+    t.set_option("size", &json!(1));
+    t.set_option("roundness", &json!(50));
+    t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
+    for i in 1..=2000 {
+        let x = if i % 2 == 0 { 0.0 } else { 60.0 };
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, x, f64::from(i) * 0.05));
+    }
+    assert_eq!(t.points.len(), 2001);
+    drain_area(&t, &cx);
+    let Some(a) = t.area.take() else { panic!("no outline") };
+    assert!(a.listed() <= 2000 * 3 * (32 + 1) && a.listed() <= area::LISTINGS, "{}", a.listed());
+}
+
+/// Escape, the release and leaving the tool drop the outline built so far; the next drag starts
+/// a new one, and its length label counts that drag alone.
+#[test]
+fn escape_and_leaving_the_tool_drop_the_drag_outline() {
+    let (d, _) = doc_with_rect();
+    let s = Selection::default();
+    let p = paint();
+    let cx = ToolContext { measurement_labels: true, ..cx(&d, &s, &p) };
+    for id in ["blobBrush", "eraser"] {
+        let mut t = GestureTool::new(id);
+        t.set_option("roundness", &json!(50));
+        long_area_drag(&mut t, &cx, 1000, |_| 1.0);
+        t.overlays(&cx);
+        assert!(t.overlays_pending(), "{id}: a 1,000-point drag takes more than one frame");
+        t.key(&cx, ToolKey::Escape, Mods::default());
+        assert!(t.area.take().is_none() && !t.overlays_pending(), "{id}: Escape drops it");
+        long_area_drag(&mut t, &cx, 1000, |_| 1.0);
+        t.overlays(&cx);
+        t.deactivate(&cx);
+        assert!(t.area.take().is_none() && !t.overlays_pending(), "{id}: leaving the tool drops it");
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 50.0, 150.0));
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0));
+        let o = t.overlays(&cx);
+        let want = format!("L: {}", cx.len(100.0));
+        assert_eq!(o.iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text == &want)), id == "blobBrush", "{id}: {o:?}");
+    }
+}
+
 /// #4977: the Blob Brush and the Eraser show their tip at the pointer before a press and while
 /// painting: its outline at its size, angle and roundness, a black line on a white halo, following
 /// `[` / `]` and Tool Options at once. It goes when the hover ends, with precise cursors (Caps
diff --git a/crates/tools/src/guides/targets.rs b/crates/tools/src/guides/targets.rs
index cb0fdfc1dc..fa31174afa 100644
--- a/crates/tools/src/guides/targets.rs
+++ b/crates/tools/src/guides/targets.rs
@@ -568,8 +568,10 @@ impl Targets {
     }
 
     /// View → Snap to Point: only these targets' anchors pull, and the ruler guides (shown and
-    /// unlocked, as the selection tools pick them) pull the pointer into line where they run.
-    pub(super) fn for_snap_to_point(self, cx: &ToolContext) -> Self {
+    /// unlocked, as the selection tools pick them) pull the pointer into line where they run. It
+    /// snaps without Smart Guides, so it draws none of their labels and lines.
+    pub(super) fn for_snap_to_point(mut self, cx: &ToolContext) -> Self {
+        self.style = GuideStyle { lines: false, labels: false, ..GuideStyle::of(cx) };
         self.anchors_only().with_rulers(cx)
     }
 
diff --git a/crates/tools/src/guides/tests.rs b/crates/tools/src/guides/tests.rs
index a4f3bc49fd..1b6ddbaa12 100644
--- a/crates/tools/src/guides/tests.rs
+++ b/crates/tools/src/guides/tests.rs
@@ -952,3 +952,26 @@ fn a_drawn_point_lands_on_a_corner_of_a_glyphs_bounds() {
         assert!((q - tr).cross(dir).abs() < 1e-6, "angle {angle}: {q:?} is off the right edge");
     }
 }
+
+/// With Smart Guides off, View → Snap to Point still pulls a drawn point onto an anchor, but
+/// draws no Smart Guides: no "anchor" label, no lines.
+#[test]
+fn snap_to_point_without_smart_guides_shows_no_guides() {
+    let (d, _) = doc_with_rect();
+    let (s, p) = (Selection::default(), paint());
+    // Within Snap to Point's 2 px of the anchor at (200, 200).
+    let at = Point::new(201.0, 199.0);
+    let off = ToolContext { smart_guides: false, snap_to_point: true, ..cx(&d, &s, &p) };
+    let mut snap = DrawSnap::default();
+    assert_eq!(snap.hover(&off, at, &[], None), Point::new(200.0, 200.0));
+    assert!(snap.guides().is_empty(), "{:?}", snap.guides());
+    assert_eq!(snap.press(&off, at, &[], None), Point::new(200.0, 200.0));
+    assert!(snap.guides().is_empty(), "{:?}", snap.guides());
+    // A dragged selection's grabbed point too.
+    let (q, ov) = Targets::snap_to_point(&off, &[]).unwrap().snap_point(at, 4.0);
+    assert_eq!((q, ov.len()), (Point::new(200.0, 200.0), 0), "{ov:?}");
+    // Smart Guides on: the same point says "anchor".
+    let mut snap = DrawSnap::default();
+    assert_eq!(snap.hover(&cx(&d, &s, &p), at, &[], None), Point::new(200.0, 200.0));
+    assert_eq!(labels(snap.guides()), ["anchor"]);
+}
diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs
index 17e6f038e9..d46a7fd972 100644
--- a/crates/tools/src/lib.rs
+++ b/crates/tools/src/lib.rs
@@ -136,9 +136,9 @@ pub trait Tool: Send {
     fn overlays(&self, _cx: &ToolContext) -> Vec<Overlay> {
         vec![]
     }
-    /// Did the last [`Tool::overlays`] leave part of its overlays for later calls (the band of a
-    /// long smoothing drag, outlined again after a zoom change)? The host then draws again on the
-    /// next frame, even when the pointer holds still.
+    /// Did the last [`Tool::overlays`] leave part of its overlays for later calls (the outline of a
+    /// long Blob Brush or Eraser drag, the band of a long smoothing drag outlined again after a
+    /// zoom change)? The host then draws again on the next frame, even when the pointer holds still.
     fn overlays_pending(&self) -> bool {
         false
     }
diff --git a/crates/trace/src/layers.rs b/crates/trace/src/layers.rs
index e1a0539a9d..04f687b46b 100644
--- a/crates/trace/src/layers.rs
+++ b/crates/trace/src/layers.rs
@@ -1,8 +1,11 @@
+use std::sync::atomic::{AtomicBool, AtomicU16, AtomicU64};
+use std::sync::{Arc, Mutex};
+
 use super::params::{Method, Mode, TraceParams};
 use super::pipeline::TracedPath;
 #[cfg(test)]
 use super::pipeline::{bw_tones, left_out};
-use super::raster::Raster;
+use super::raster::{Raster, TraceError};
 use super::{
     AtomicUsize, Crack, Loop, Ordering, PathData, Quantized, TRANSPARENT, TracedGradient, TracedShape, centerline, contour, fit, logo, shapes,
     trace_mask,
@@ -343,50 +346,256 @@ impl Layers<'_> {
     pub(crate) fn layer(&self, r: usize, ci: usize) -> Option<Vec<TracedPath>> {
         let params = self.params;
         let color = *self.q.palette.get(ci)?;
-        let overlapping = params.method == Method::Overlapping;
-        let (w, h) = (self.w, self.h);
         // Create Strokes: this colour's lines, left out of its areas.
         let (thin, lines) = if params.strokes {
             // The ink the lines are read against: the layer's colour; Black and White's own black.
             let ink = if params.mode == Mode::BlackAndWhite { [self.bw_tones[usize::from(ci == 1)]; 3] } else { color.map(f64::from) };
-            centerline::lines(self.traced, u16::try_from(ci).unwrap_or(TRANSPARENT), w, h, params.stroke_width, self.img, ink, &self.style)
+            centerline::lines(self.traced, u16::try_from(ci).unwrap_or(TRANSPARENT), self.w, self.h, params.stroke_width, self.img, ink, &self.style)
         } else {
             (vec![], vec![])
         };
+        let comps = self.contours(r, ci, &thin, None, &[])?;
+        self.fit_layer(ci, &comps, lines)
+    }
+
+    /// Whether pixel `(x, y)` is one that the layers trace: in the image, and neither transparent nor a color left out.
+    fn live(&self, x: usize, y: usize) -> bool {
+        x < self.w && self.traced.get(y * self.w + x).is_some_and(|&l| l != TRANSPARENT && !self.ignored(l))
+    }
+
+    /// The highest level of the area `a` whose mask holds every pixel along the inside of its edge (the image's
+    /// border, or the hole's outline), or 0 when a pixel there is not one the layers trace. That level's shape may
+    /// run around the whole edge and enclose the rest of the area, so [`Self::stacked`] finds its components (and those
+    /// of the levels above it) first.
+    fn rim_level(&self, a: &Area) -> usize {
+        // The lowest rank along the edge; `None` once a pixel there is not traced.
+        let mut lowest = Some(usize::MAX);
+        let mut see = |x: i32, y: i32| {
+            let rank = usize::try_from(x).ok().zip(usize::try_from(y).ok()).filter(|&(x, y)| self.live(x, y)).and_then(|(x, y)| {
+                let l = *self.traced.get(y * self.w + x)?;
+                self.rank.get(l as usize).copied()
+            });
+            lowest = lowest.zip(rank).map(|(a, b)| a.min(b));
+            lowest.is_some()
+        };
+        match &a.outline {
+            None => {
+                let (w, h) = (i32::try_from(self.w).unwrap_or(0), i32::try_from(self.h).unwrap_or(0));
+                // (Rows first, then the columns between them.)
+                let _ = (0..w).all(|x| see(x, 0) && see(x, h - 1)) && (1..h - 1).all(|y| see(0, y) && see(w - 1, y));
+            }
+            Some(l) => {
+                // A hole's outline has the shape's pixels on its right and the area's on its left (see `contour`).
+                let _ = l.pts.iter().zip(l.pts.iter().cycle().skip(1)).all(|(&(x0, y0), &(x1, y1))| {
+                    let (dx, dy) = ((x1 - x0).signum(), (y1 - y0).signum());
+                    // (Outlines run along pixel edges: never both ways at once.)
+                    if dx != 0 && dy != 0 {
+                        return false;
+                    }
+                    let mut p = (x0, y0);
+                    while p != (x1, y1) {
+                        let left = match (dx, dy) {
+                            (1, _) => (p.0, p.1 - 1),
+                            (_, 1) => (p.0, p.1),
+                            (-1, _) => (p.0 - 1, p.1),
+                            _ => (p.0 - 1, p.1 - 1),
+                        };
+                        if !see(left.0, left.1) {
+                            return false;
+                        }
+                        p = (p.0 + dx, p.1 + dy);
+                    }
+                    true
+                });
+            }
+        }
+        let Some(lowest) = lowest.filter(|&r| r != usize::MAX) else { return 0 };
+        a.levels.iter().rposition(|&(r, _)| r <= lowest).unwrap_or(0)
+    }
+
+    /// The components of layer `r`'s mask (palette entry `ci`), in image pixels: `thin` pixels (Create Strokes' lines)
+    /// are left out, and `within` an area, only that area's pixels are in it.
+    ///
+    /// The pixels inside `covered` (holes that higher levels fill, so that their shapes cover them) are left out too:
+    /// a component that reaches into one has it as a hole instead, which [`Self::fill_layer`] drops, and its other
+    /// loops are the same either way. A layer with no pixel of its own color left has nothing to trace.
+    fn contours(&self, r: usize, ci: usize, thin: &[bool], within: Option<&Area>, covered: &[&Loop]) -> Option<Vec<contour::Component>> {
+        let overlapping = self.params.method == Method::Overlapping;
+        let w = self.w;
         // The layer is traced within the box its pixels lie in, not the whole image.
         let part = |l: u16| if overlapping { self.rank.get(l as usize).is_some_and(|&lr| lr >= r) && !self.ignored(l) } else { l as usize == ci };
-        let (mut x0, mut y0, mut x1, mut y1) = (w, h, 0, 0);
+        let (mut x0, mut y0, mut x1, mut y1) = (w, self.h, 0, 0);
         for (l, b) in self.boxes.iter().enumerate() {
             if let Some(b) = b.filter(|_| part(l as u16)) {
                 (x0, y0, x1, y1) = (x0.min(b.0), y0.min(b.1), x1.max(b.2), y1.max(b.3));
             }
         }
+        if let Some(a) = within {
+            (x0, y0, x1, y1) = (x0.max(a.bx.0), y0.max(a.bx.1), x1.min(a.bx.2), y1.min(a.bx.3));
+        }
         if x0 >= x1 || y0 >= y1 {
             return Some(vec![]);
         }
         let (bw, bh) = (x1 - x0, y1 - y0);
-        let mut mask = Vec::with_capacity(bw * bh);
-        for y in y0..y1 {
-            let row = self.traced.get(y * w + x0..y * w + x1)?;
-            mask.extend(row.iter().enumerate().map(|(k, &l)| l != TRANSPARENT && !thin.get(y * w + x0 + k).copied().unwrap_or(false) && part(l)));
-        }
-        // Overlapping: a part of the mask with no pixel of this color holds only colors above it,
-        // whose own layers fill it, and is left out. The layer reaches under the colors above it
-        // only within the areas that hold its own color.
-        if overlapping {
-            let (comp, sizes) = contour::label(&mask, bw, bh);
-            let mut own = vec![false; sizes.len()];
-            for (k, &c) in comp.iter().enumerate() {
-                if self.q.labels.get((y0 + k / bw) * w + x0 + k % bw).is_some_and(|&l| l as usize == ci)
-                    && let Some(o) = own.get_mut(c as usize)
-                {
-                    *o = true;
+        // Each row's runs of pixels that may be in the mask: in the area, outside what is covered.
+        let mut mask = vec![false; bw * bh];
+        // (Whether any pixel of the layer's own color is in it: none, and the layer has nothing to trace.)
+        let (mut own_color, mut off_image) = (!overlapping, false);
+        row_runs(x0, x1, y0, bh, within.and_then(|a| a.outline.as_ref()), covered, |k, runs| {
+            let y = y0 + k;
+            for &(a, b) in runs {
+                let (Some(row), Some(out)) = (self.traced.get(y * w + a..y * w + b), mask.get_mut(k * bw + a - x0..k * bw + b - x0)) else {
+                    off_image = true;
+                    return;
+                };
+                for (j, (m, &l)) in out.iter_mut().zip(row).enumerate() {
+                    let i = y * w + a + j;
+                    *m = l != TRANSPARENT && !thin.get(i).copied().unwrap_or(false) && part(l);
+                    own_color |= *m && self.q.labels.get(i).is_some_and(|&l| l as usize == ci);
                 }
             }
-            for (m, &c) in mask.iter_mut().zip(&comp) {
-                *m = *m && own.get(c as usize).copied().unwrap_or(false);
+        });
+        if off_image {
+            return None;
+        }
+        if !own_color {
+            return Some(vec![]);
+        }
+        let mut comps = trace_mask(&mask, bw, bh);
+        drop(mask);
+        // Overlapping: a part of the mask with no pixel of this color holds only colors above it,
+        // whose own layers fill it, and is left out. The layer reaches under the colors above it
+        // only within the areas that hold its own color. (Leaving a component out changes no other
+        // component's loops: a walk turns by the pixels of its own component only.)
+        if overlapping {
+            let own = |x: usize, y: usize| self.q.labels.get((y0 + y) * w + x0 + x).is_some_and(|&l| l as usize == ci);
+            comps.retain(|c| !pixels_of(c, |x, y| !own(x, y)));
+        }
+        for comp in &mut comps {
+            for l in std::iter::once(&mut comp.outer).chain(&mut comp.holes) {
+                for p in &mut l.pts {
+                    *p = (p.0 + x0 as i32, p.1 + y0 as i32);
+                }
             }
         }
+        Some(comps)
+    }
+
+    /// The first pass of [`Self::stacked`] at level `level` of the area `a`: marks in `round.marks` the pixels inside
+    /// each hole of `comps` (that level's components) that its shape fills. A shape fills a hole of at least Noise
+    /// pixels when every pixel inside it is one the area traces (no transparent pixel, no color left out). Smaller
+    /// holes are filled with the shape's own color, as they always were. A hole inside an area that this level or a
+    /// higher one has already marked is passed over: every pixel in it is marked, and the component around it lies
+    /// inside that area, traced with it. Whether a hole holds a pixel that is not traced is read from `round.dead` a
+    /// run at a time, not a pixel at a time. Returns the holes marked.
+    fn mark_filled(&self, round: &Round, a: &Area, level: usize, comps: &[contour::Component]) -> Vec<Loop> {
+        let Some(mark) = u16::try_from(level + 1).ok().filter(|_| a.fill) else { return vec![] };
+        let min_hole = i64::from(self.params.noise.max(1));
+        let all_live = |hole: &Loop| {
+            let Some(dead) = round.dead else { return true };
+            runs_inside([hole], |y, a, b| {
+                #[cfg(test)]
+                round.live_reads.fetch_add(1, Ordering::Relaxed);
+                let row = y.saturating_mul(self.w);
+                !meets(dead, row.saturating_add(a), row.saturating_add(b))
+            })
+        };
+        let mut marked = vec![];
+        for hole in comps.iter().flat_map(|c| &c.holes) {
+            if self.params.noise > 0 && hole.area2.abs() / 2 < min_hole
+                || first_pixel(hole).and_then(|(x, y)| round.marks.get(y * self.w + x)).is_none_or(|m| m.load(Ordering::Relaxed) >= mark)
+                || !all_live(hole)
+            {
+                continue;
+            }
+            interior(hole, |x, y| {
+                if let Some(m) = round.marks.get(y * self.w + x) {
+                    m.fetch_max(mark, Ordering::Relaxed);
+                }
+                true
+            });
+            marked.push(hole.clone());
+        }
+        marked
+    }
+
+    /// The second pass of [`Self::stacked`] at level `level` (palette entry `ci`) of the area `a`, once every level of
+    /// the round has marked what it fills: the paths of `comps` (from the first pass), and the holes that the shapes
+    /// fill (see [`Self::inside`]).
+    ///
+    /// An area filled at a higher level is covered by that level's shape, which this one lies under: it is no hole
+    /// here, and a component whose own color lies only inside such areas is left out. A component inside an area filled
+    /// at any level is traced with that area. A hole this level fills is no hole. Every other hole stays.
+    ///
+    /// `covered`: whether a higher level of the area has filled a hole (without one, every component holds its own
+    /// color outside such areas, as `contours` keeps only those that hold it).
+    fn fill_layer(
+        &self,
+        round: &Round,
+        a: &Area,
+        level: usize,
+        ci: usize,
+        mut comps: Vec<contour::Component>,
+        covered: bool,
+    ) -> Option<(Vec<TracedPath>, Vec<Loop>)> {
+        let mark = u16::try_from(level + 1).unwrap_or(u16::MAX);
+        let marked = |(x, y): (usize, usize)| round.marks.get(y * self.w + x).map_or(0, |m| m.load(Ordering::Relaxed));
+        comps.retain(|comp| {
+            first_pixel(&comp.outer).is_some_and(|p| marked(p) == 0)
+                && !(covered && pixels_of(comp, |x, y| self.q.labels.get(y * self.w + x).is_none_or(|&l| l as usize != ci) || marked((x, y)) > mark))
+        });
+        let mut filled = vec![];
+        for comp in &mut comps {
+            for hole in std::mem::take(&mut comp.holes) {
+                match first_pixel(&hole).map(marked) {
+                    Some(m) if m > mark => {}
+                    Some(m) if m == mark && a.fill => filled.push(hole),
+                    _ => comp.holes.push(hole),
+                }
+            }
+            // The pixels the shape fills (the same whichever covered areas `contours` left out).
+            let area2 = comp.holes.iter().fold(comp.outer.area2, |a, h| a + h.area2);
+            comp.pixels = usize::try_from(area2 / 2).unwrap_or(0);
+        }
+        Some((self.fit_layer(ci, &comps, vec![])?, filled))
+    }
+
+    /// What [`Self::stacked`] draws inside the hole `hole` that a shape fills: an area of several colors, traced in the
+    /// next round, or the paths of an area of one color, traced here (as that round would trace it: its one level's
+    /// shape is the whole area, without holes). `None` once the anchors made pass the maximum.
+    fn inside(&self, hole: Loop) -> Option<Inside> {
+        let Some(area) = self.area_in(hole) else { return Some(Inside::Done(vec![])) };
+        let &[(_, ci)] = area.levels.as_slice() else { return Some(Inside::Next(area)) };
+        let comps = area.outline.as_ref().map(shapes_in_hole).unwrap_or_default();
+        Some(Inside::Done(self.fit_layer(ci, &comps, vec![])?))
+    }
+
+    /// The area inside the hole `hole`, with its box and the colors in it (`None` when it holds no pixel of a color).
+    fn area_in(&self, hole: Loop) -> Option<Area> {
+        let mut present = vec![false; self.q.palette.len()];
+        let (mut x0, mut y0, mut x1, mut y1) = (usize::MAX, usize::MAX, 0, 0);
+        runs_inside([&hole], |y, a, b| {
+            for &l in self.traced.get(y * self.w + a..y * self.w + b).unwrap_or_default() {
+                if let Some(p) = present.get_mut(l as usize) {
+                    *p = true;
+                }
+            }
+            (x0, y0, x1, y1) = (x0.min(a), y0.min(y), x1.max(b), y1.max(y + 1));
+            true
+        });
+        let mut levels: Vec<(usize, usize)> =
+            present.iter().enumerate().filter(|&(_, &p)| p).filter_map(|(ci, _)| Some((*self.rank.get(ci)?, ci))).collect();
+        levels.sort_unstable();
+        (x0 < x1 && !levels.is_empty()).then_some(Area { bx: (x0, y0, x1, y1), outline: Some(hole), levels, fill: true })
+    }
+
+    /// The paths of the components `comps` of palette entry `ci`'s layer, then of its `lines` (Create Strokes), or
+    /// `None` once the anchors made pass the maximum.
+    fn fit_layer(&self, ci: usize, comps: &[contour::Component], lines: Vec<centerline::Line>) -> Option<Vec<TracedPath>> {
+        let params = self.params;
+        let color = *self.q.palette.get(ci)?;
+        let overlapping = params.method == Method::Overlapping;
+        let (w, h) = (self.w, self.h);
         // Without Fills, areas are outlined with a 1 px stroke.
         let area_stroke = (params.strokes && !params.fills).then_some(1.0);
         let min_hole = params.noise.max(1) as i64;
@@ -401,15 +610,6 @@ impl Layers<'_> {
             paths.push(TracedPath { path, color, pixels, stroke, shape, gradient, square_caps });
             true
         };
-        let mut comps = trace_mask(&mask, bw, bh);
-        drop(mask);
-        for comp in &mut comps {
-            for l in std::iter::once(&mut comp.outer).chain(&mut comp.holes) {
-                for p in &mut l.pts {
-                    *p = (p.0 + x0 as i32, p.1 + y0 as i32);
-                }
-            }
-        }
         // One component's paths: a pure function of its loops and the shared read-only state, so components are fitted in
         // parallel and then added in order.
         let fit_comp = |comp: &contour::Component| -> Option<(PathData, Option<TracedShape>)> {
@@ -484,7 +684,7 @@ impl Layers<'_> {
         };
         // In chunks, so that the anchor budget still stops the work early: a hostile image is refused after fitting at most
         // the rest of one chunk, not after every component is fitted.
-        let accepted = fit_in_chunks(&comps, FIT_CHUNK, fit_comp, |comp, fitted| {
+        let accepted = fit_in_chunks(comps, FIT_CHUNK, fit_comp, |comp, fitted| {
             let Some((path, shape)) = fitted else { return true };
             add(path, comp.pixels, area_stroke, shape, false)
         });
@@ -498,6 +698,304 @@ impl Layers<'_> {
         }
         Some(paths)
     }
+
+    /// Overlapping with Fills (and without Create Strokes): the stacked layers of `layers` (`(rank, palette entry)`,
+    /// bottom up), with each shape filled whole. `largest` is the largest of the layers' boxes, in pixels.
+    ///
+    /// A layer's shape covers the colors above it in its area, so a part of other colors that it encloses is a hole in
+    /// it, and every layer whose shape encloses that part would otherwise have its own copy of the same outline.
+    /// Instead the shape fills the hole, and the area inside the hole is traced again in the next round, as the whole
+    /// image is, and drawn after everything around it. A hole stays where something inside it must stay unpainted (a
+    /// transparent pixel, a color left out).
+    ///
+    /// Each round takes two passes over its levels, each pass all levels in parallel. The first finds each level's
+    /// components and marks the pixels inside the holes it fills. The second leaves out what lies inside a marked area
+    /// (traced in the next round), treats an area filled at a higher level as covered (no hole, and no part of a lower
+    /// shape whose own color lies only inside it), and fits the rest. Every pixel inside a filled area is then fitted
+    /// in that area's round only. An area of one color is traced as soon as its hole is known (its one shape has no
+    /// holes), so only areas of several colors make another round. The levels that hold every pixel along an area's
+    /// edge go first in the first pass (see [`Self::rim_level`]).
+    ///
+    /// The pixels of nested areas are scanned once more in each round that holds them: past a budget of four times the
+    /// work of the first round (of a 256 × 256 image, at least), an area keeps its holes and ends its branch (an image
+    /// of thousands of nested rings). An area is charged its box times its levels only when it fits in what is left; an
+    /// area that does not fit is charged nothing.
+    ///
+    /// The marks take two bytes a pixel of the image. In an image with a transparent pixel or a color left out, the
+    /// runs of such pixels take up to four bytes a pixel more during the first round (eight bytes a run). Both count
+    /// against the half gigabyte that sets how many levels are traced at a time. The components kept for the second pass
+    /// take up to [`KEPT_BYTES`] more, outside that half gigabyte.
+    pub(crate) fn stacked(
+        &self,
+        layers: &[(usize, usize)],
+        largest: usize,
+        steps: &(dyn Fn(u64, u64) -> bool + Sync),
+    ) -> Result<Vec<TracedPath>, TraceError> {
+        let n = self.w * self.h;
+        let progress = Progress { steps, done: AtomicU64::new(0), total: 3 * layers.len().max(1) as u64 * STEP, stopped: AtomicBool::new(false) };
+        if !progress.add(0) {
+            return Err(TraceError::Cancelled);
+        }
+        let too_complex = || TraceError::TooComplex { max: self.max_anchors };
+        // Two bytes a pixel for the marks.
+        let marks: Vec<AtomicU16> = (0..n).map(|_| AtomicU16::new(0)).collect();
+        let untraced = |l: u16| l == TRANSPARENT || self.ignored(l);
+        // Eight bytes a run of untraced pixels, at most four a pixel (where every other pixel is one).
+        let mut dead = self.traced.iter().any(|&l| untraced(l)).then(|| dead_runs(self.traced, untraced));
+        let dead_bytes = dead.as_ref().map_or(0, |runs| runs.capacity().saturating_mul(size_of::<(u32, u32)>()));
+        #[cfg(test)]
+        let probe = PROBE.with(|p| {
+            let mut p = p.borrow_mut();
+            (p.live_reads, p.areas, p.dead_bytes) = (0, vec![], dead_bytes);
+            p.clone()
+        });
+        #[cfg(test)]
+        let (live_reads, mut decided) = (AtomicUsize::new(0), vec![]);
+        #[cfg(test)]
+        let mut round_number = 0usize;
+        let mut areas = vec![Area { bx: (0, 0, self.w, self.h), outline: None, levels: layers.to_vec(), fill: true }];
+        // The areas as a tree: each one's paths and the areas inside it.
+        let mut tree: Vec<(Vec<TracedPath>, Vec<usize>)> = vec![];
+        let mut nodes = vec![0usize];
+        tree.push((vec![], vec![]));
+        let mut budget = 4 * n.max(1 << 16) as u64 * layers.len().max(1) as u64;
+        #[cfg(test)]
+        if let Some(b) = probe.budget {
+            budget = b;
+        }
+        // What each round's levels may add to the progress, in units: the first round's levels a step each per pass,
+        // and every later round half of what is left.
+        let mut pot = layers.len() as u64 * STEP;
+        let mut first = true;
+        while !areas.is_empty() {
+            // The levels of every area, the highest first: a level's components are found after the levels above it
+            // have marked what they fill, where they could start first, and leave those areas out. The levels at and
+            // above an area's rim level (`rim_level`) go first of all, and the others start once they have marked: a
+            // shape that runs around the whole area (a frame) may enclose nearly all of it.
+            let rims: Vec<usize> = areas.iter().map(|a| self.rim_level(a)).collect();
+            let early = |&(k, i): &(usize, usize)| rims.get(k).is_some_and(|&r| r > 0 && i >= r);
+            let mut jobs: Vec<(usize, usize)> = areas.iter().enumerate().flat_map(|(k, a)| (0..a.levels.len()).map(move |i| (k, i))).collect();
+            jobs.sort_by_key(|job| (!early(job), std::cmp::Reverse(job.1), job.0));
+            let first_part = jobs.iter().take_while(|job| early(job)).count();
+            // The holes each level has marked, once it has.
+            let published: Mutex<Vec<Marked>> = Mutex::new(vec![]);
+            let per_job = if first {
+                STEP
+            } else {
+                let share = pot / 2;
+                pot -= share;
+                share / 2 / jobs.len().max(1) as u64
+            };
+            let round = Round {
+                marks: &marks,
+                dead: dead.as_deref().filter(|_| first),
+                #[cfg(test)]
+                live_reads: &live_reads,
+            };
+            #[cfg(test)]
+            {
+                round_number += 1;
+            }
+            // A level takes about ten bytes a pixel of its box while its components are found (as `pipeline` counts
+            // them): as many at a time as fit in half a gigabyte with the marks and the runs of untraced pixels.
+            let biggest =
+                jobs.iter().filter_map(|&(k, _)| areas.get(k)).map(|a| (a.bx.2 - a.bx.0) * (a.bx.3 - a.bx.1)).max().unwrap_or(1).min(largest).max(1);
+            let held = if first { dead_bytes } else { 0 };
+            let at_a_time = ((512usize << 20).saturating_sub(2 * n).saturating_sub(held) / (biggest * 10)).max(1);
+            // Threads cost time to start: one for each `PIXELS_PER_THREAD` pixels of the levels' boxes (the later rounds
+            // often hold hundreds of small areas).
+            let work = jobs.iter().filter_map(|&(k, _)| areas.get(k)).fold(0usize, |s, a| s.saturating_add((a.bx.2 - a.bx.0) * (a.bx.3 - a.bx.1)));
+            let at_a_time = at_a_time.min(work.div_ceil(PIXELS_PER_THREAD).max(1));
+            #[cfg(test)]
+            let at_a_time = if probe.one_level_at_a_time { 1 } else { at_a_time };
+            // The components found are kept for the second pass while they take at most `KEPT_BYTES`; past that, a
+            // level's are dropped and found again in the second pass.
+            let kept = AtomicUsize::new(0);
+            let find = |&(k, i): &(usize, usize)| {
+                let (a, &(r, ci)) = areas.get(k).and_then(|a| Some((a, a.levels.get(i)?)))?;
+                if progress.stopped.load(Ordering::Relaxed) {
+                    return None;
+                }
+                let above: Vec<Arc<Vec<Loop>>> =
+                    published.lock().map(|p| p.iter().filter(|e| e.0 == k && e.1 > i).map(|e| Arc::clone(&e.2)).collect()).unwrap_or_default();
+                let covered: Vec<&Loop> = above.iter().flat_map(|l| l.iter()).collect();
+                #[cfg(test)]
+                let covered = if probe.keep_covered { vec![] } else { covered };
+                let comps = self.contours(r, ci, &[], Some(a), &covered)?;
+                let marked = self.mark_filled(&round, a, i, &comps);
+                if !marked.is_empty()
+                    && let Ok(mut p) = published.lock()
+                {
+                    p.push((k, i, Arc::new(marked)));
+                }
+                progress.add(per_job);
+                let bytes = comps.iter().fold(0usize, |s, c| {
+                    std::iter::once(&c.outer).chain(&c.holes).fold(s.saturating_add(size_of::<contour::Component>()), |s, l| {
+                        s.saturating_add(size_of::<Loop>()).saturating_add(l.pts.len().saturating_mul(size_of::<(i32, i32)>()))
+                    })
+                });
+                let keep = kept.fetch_add(bytes, Ordering::Relaxed).saturating_add(bytes) <= KEPT_BYTES;
+                #[cfg(test)]
+                let keep = keep && !probe.keep_none;
+                Some(Mutex::new(keep.then_some(comps)))
+            };
+            let (early_jobs, later_jobs) = jobs.split_at(first_part);
+            let mut found = parallel_map_at_most(at_a_time, early_jobs, find);
+            found.extend(parallel_map_at_most(at_a_time, later_jobs, find));
+            if progress.stopped.load(Ordering::Relaxed) {
+                return Err(TraceError::Cancelled);
+            }
+            // (And one for each `POINTS_PER_THREAD` corners of the outlines to fit; as many as the first pass when a
+            // level's components are found again.)
+            let mut again = false;
+            let mut points = 0usize;
+            for c in found.iter().flatten() {
+                match c.lock().ok().as_deref() {
+                    Some(Some(comps)) => {
+                        points =
+                            comps.iter().flat_map(|c| std::iter::once(&c.outer).chain(&c.holes)).fold(points, |s, l| s.saturating_add(l.pts.len()));
+                    }
+                    _ => again = true,
+                }
+            }
+            let threads = points.div_ceil(POINTS_PER_THREAD).max(1);
+            let threads = if again { threads.min(at_a_time) } else { threads };
+            // The highest level of each area that has marked a hole (none: nothing in the area is covered).
+            let mut highest: Vec<Option<usize>> = vec![None; areas.len()];
+            if let Ok(p) = published.lock() {
+                for &(k, i, _) in p.iter() {
+                    if let Some(h) = highest.get_mut(k) {
+                        *h = Some(h.map_or(i, |h| h.max(i)));
+                    }
+                }
+            }
+            let items: Vec<_> = jobs.iter().zip(&found).collect();
+            let fitted = parallel_map_at_most(threads, &items, |&(&(k, i), comps)| {
+                let (a, &(r, ci)) = areas.get(k).and_then(|a| Some((a, a.levels.get(i)?)))?;
+                if progress.stopped.load(Ordering::Relaxed) {
+                    return None;
+                }
+                let comps = match comps.as_ref()?.lock().ok()?.take() {
+                    Some(comps) => comps,
+                    None => {
+                        // (Found again, leaving out every area the levels above have filled.)
+                        let above: Vec<Arc<Vec<Loop>>> = published
+                            .lock()
+                            .map(|p| p.iter().filter(|e| e.0 == k && e.1 > i).map(|e| Arc::clone(&e.2)).collect())
+                            .unwrap_or_default();
+                        self.contours(r, ci, &[], Some(a), &above.iter().flat_map(|l| l.iter()).collect::<Vec<_>>())?
+                    }
+                };
+                let covered = highest.get(k).copied().flatten().is_some_and(|h| h > i);
+                let out = self.fill_layer(&round, a, i, ci, comps, covered);
+                progress.add(per_job);
+                out
+            });
+            drop(found);
+            if progress.stopped.load(Ordering::Relaxed) {
+                return Err(TraceError::Cancelled);
+            }
+            drop(published);
+            // Each area's paths, its levels bottom up, and the holes filled in it.
+            let mut by_level = jobs.iter().zip(fitted).map(|(&job, out)| Some((job, out?))).collect::<Option<Vec<_>>>().ok_or_else(too_complex)?;
+            by_level.sort_by_key(|e| e.0);
+            // The marks of this round lie inside its areas' boxes.
+            for a in &areas {
+                for y in a.bx.1..a.bx.3 {
+                    for m in marks.get(y * self.w + a.bx.0..y * self.w + a.bx.2).unwrap_or_default() {
+                        m.store(0, Ordering::Relaxed);
+                    }
+                }
+            }
+            // What is drawn inside the holes the shapes fill, all levels' holes at once: the paths of an area of one
+            // color, or an area of the next round. (Threads by the pixels inside, by the corners of the outlines to fit,
+            // and by the number of holes.)
+            let mut holes: Vec<(usize, Loop)> = vec![];
+            for (n, (_, (_, filled))) in by_level.iter_mut().enumerate() {
+                holes.extend(std::mem::take(filled).into_iter().map(|l| (n, l)));
+            }
+            let pixels = holes.iter().fold(0usize, |s, (_, l)| s.saturating_add(usize::try_from(l.area2.unsigned_abs() / 2).unwrap_or(usize::MAX)));
+            let corners = holes.iter().fold(0usize, |s, (_, l)| s.saturating_add(l.pts.len()));
+            let threads = pixels.div_ceil(PIXELS_PER_THREAD).max(corners.div_ceil(POINTS_PER_THREAD)).max(holes.len().div_ceil(64)).max(1);
+            // (Once one is refused, past the anchors allowed, the rest are not fitted.)
+            let refused = AtomicBool::new(false);
+            let insides = parallel_map_at_most(threads, &holes, |(_, l)| {
+                if progress.stopped.load(Ordering::Relaxed) || refused.load(Ordering::Relaxed) {
+                    return None;
+                }
+                let inside = self.inside(l.clone());
+                if inside.is_none() {
+                    refused.store(true, Ordering::Relaxed);
+                }
+                inside
+            });
+            if progress.stopped.load(Ordering::Relaxed) {
+                return Err(TraceError::Cancelled);
+            }
+            if refused.load(Ordering::Relaxed) {
+                return Err(too_complex());
+            }
+            let mut by_job: Vec<Vec<Inside>> = (0..by_level.len()).map(|_| vec![]).collect();
+            for ((n, _), inside) in holes.into_iter().zip(insides) {
+                if let Some(v) = by_job.get_mut(n) {
+                    v.push(inside.ok_or_else(too_complex)?);
+                }
+            }
+            // Each area's paths, then what is drawn inside the holes its shapes fill.
+            let (mut next, mut next_nodes) = (vec![], vec![]);
+            for (((k, _), (paths, _)), inside) in by_level.into_iter().zip(by_job) {
+                let up = *nodes.get(k).ok_or_else(too_complex)?;
+                if let Some(t) = tree.get_mut(up) {
+                    t.0.extend(paths);
+                }
+                for item in inside {
+                    let node = tree.len();
+                    if let Some(t) = tree.get_mut(up) {
+                        t.1.push(node);
+                    }
+                    match item {
+                        Inside::Done(paths) => tree.push((paths, vec![])),
+                        Inside::Next(mut area) => {
+                            tree.push((vec![], vec![]));
+                            let cost = ((area.bx.2 - area.bx.0) * (area.bx.3 - area.bx.1)) as u64 * area.levels.len() as u64;
+                            // (An area past what is left keeps its holes and is charged nothing: a smaller one after
+                            // it may still fit.)
+                            area.fill = cost <= budget;
+                            if area.fill {
+                                budget -= cost;
+                            }
+                            #[cfg(test)]
+                            decided.push((round_number + 1, cost, area.fill));
+                            next.push(area);
+                            next_nodes.push(node);
+                        }
+                    }
+                }
+            }
+            (areas, nodes) = (next, next_nodes);
+            // (Only the first round reads the runs of untraced pixels.)
+            dead = None;
+            first = false;
+        }
+        // Each area's paths, then the areas inside it.
+        let mut out = vec![];
+        let mut stack = vec![0];
+        while let Some(k) = stack.pop() {
+            let Some((p, inner)) = tree.get_mut(k) else { continue };
+            out.append(p);
+            stack.extend(inner.iter().rev());
+        }
+        #[cfg(test)]
+        PROBE.with(|p| {
+            let mut p = p.borrow_mut();
+            p.live_reads = live_reads.load(Ordering::Relaxed);
+            p.areas = decided;
+        });
+        if !progress.add(progress.total) {
+            return Err(TraceError::Cancelled);
+        }
+        Ok(out)
+    }
 }
 
 /// Test probe: every crack between two labels of `img` quantised as `trace` does (no gradients),
@@ -542,6 +1040,297 @@ pub(crate) fn shift_probe(img: &Raster, params: &TraceParams) -> Vec<[f64; 4]> {
     out
 }
 
+/// Overlapping with Fills: a part of the image whose layers are traced together and stacked as the whole image's are
+/// (see [`Layers::stacked`]). The whole image is one; the area inside a hole that a shape fills is another, traced in
+/// the next round and drawn above the part it lies in.
+struct Area {
+    /// Its box in image pixels, `(x0, y0, x1, y1)`, the far sides excluded.
+    bx: (usize, usize, usize, usize),
+    /// The hole whose inside it is (the whole image has none).
+    outline: Option<Loop>,
+    /// The layers with pixels here, bottom up: `(rank, palette entry)`.
+    levels: Vec<(usize, usize)>,
+    /// Whether its shapes fill the holes they may fill (past the work budget, they keep them).
+    fill: bool,
+}
+
+/// What [`Layers::stacked`] draws above a shape inside a hole that the shape fills.
+enum Inside {
+    /// The paths of an area of one color, traced at once: it has no holes, and so nothing more inside it.
+    Done(Vec<TracedPath>),
+    /// An area of several colors, traced in the next round (its `fill` not set yet).
+    Next(Area),
+}
+
+/// The holes a level of [`Layers::stacked`] has marked: `(area, level, holes)`.
+type Marked = (usize, usize, Arc<Vec<Loop>>);
+
+/// One round of [`Layers::stacked`]: the areas traced at the same time. Areas of one round never share a pixel.
+struct Round<'a> {
+    /// For each pixel of the image, one more than the highest level of its area at which a shape fills a hole around
+    /// it; 0 where none does.
+    marks: &'a [AtomicU16],
+    /// In the first round, where a hole may hold a pixel that the layers do not trace (transparent, or a color left
+    /// out), the runs of such pixels (see [`dead_runs`]): an area is filled only where it holds none. `None` in later
+    /// rounds and in images without such pixels.
+    dead: Option<&'a [(u32, u32)]>,
+    /// Tests: the reads made to check a hole against `dead`.
+    #[cfg(test)]
+    live_reads: &'a AtomicUsize,
+}
+
+/// How far a stacked trace has got, for its `steps` callback: each level of the first round counts one step in each
+/// of the two passes, and the rounds after it share as many steps again as the first round has levels, each round
+/// half of what the rounds before it left (their number is not known in advance).
+struct Progress<'a> {
+    steps: &'a (dyn Fn(u64, u64) -> bool + Sync),
+    done: AtomicU64,
+    total: u64,
+    stopped: AtomicBool,
+}
+
+impl Progress<'_> {
+    /// Adds `n` units and says whether to go on.
+    fn add(&self, n: u64) -> bool {
+        let done = self.done.fetch_add(n, Ordering::Relaxed) + n;
+        if !(self.steps)(done.min(self.total), self.total) {
+            self.stopped.store(true, Ordering::Relaxed);
+        }
+        !self.stopped.load(Ordering::Relaxed)
+    }
+}
+
+/// One step of [`Progress`], in its own units (a level's step can then be split among the levels of later rounds).
+const STEP: u64 = 1 << 20;
+
+/// [`Layers::stacked`]: how many bytes of components found in the first pass of a round are kept for the second.
+const KEPT_BYTES: usize = 256 << 20;
+
+/// [`Layers::stacked`]: how many pixels of the levels' boxes, and how many corners of the outlines to fit, are worth a
+/// thread of their own.
+const PIXELS_PER_THREAD: usize = 1 << 16;
+const POINTS_PER_THREAD: usize = 1 << 6;
+
+/// Tests: switches and counts of [`Layers::stacked`], one set per test thread ([`PROBE`]). A trace reads the switches
+/// when it starts and writes the counts when it ends, so tests that run at the same time do not see each other's.
+#[cfg(test)]
+#[derive(Clone, Debug, Default)]
+pub(crate) struct Probe {
+    /// Keep the areas that higher levels have filled in a level's components (the result is the same either way).
+    pub(crate) keep_covered: bool,
+    /// Find one level's components at a time, so that every level leaves out all the areas the levels above it fill.
+    pub(crate) one_level_at_a_time: bool,
+    /// Drop every level's components after the first pass and find them again in the second (as past `KEPT_BYTES`).
+    pub(crate) keep_none: bool,
+    /// The work budget of nested areas, in place of the one the image gives.
+    pub(crate) budget: Option<u64>,
+    /// Counted: the reads the first round made to check that a hole holds only pixels the layers trace.
+    pub(crate) live_reads: usize,
+    /// Counted: the bytes the runs of untraced pixels take.
+    pub(crate) dead_bytes: usize,
+    /// Counted: each area of a later round, as `(round, cost, filled)`, in the order the budget was charged.
+    pub(crate) areas: Vec<(usize, u64, bool)>,
+}
+
+#[cfg(test)]
+thread_local! {
+    pub(crate) static PROBE: std::cell::RefCell<Probe> = std::cell::RefCell::new(Probe::default());
+}
+
+/// The runs of the pixels of `labels` for which `dead` holds, in order as `(i0, i1)` (indices into `labels`, so that a
+/// run goes on into the next row; one list for the image, whatever its height).
+fn dead_runs(labels: &[u16], dead: impl Fn(u16) -> bool) -> Vec<(u32, u32)> {
+    let mut runs: Vec<(u32, u32)> = vec![];
+    for (i, &l) in labels.iter().enumerate() {
+        let i = u32::try_from(i).unwrap_or(u32::MAX);
+        if !dead(l) {
+            continue;
+        }
+        match runs.last_mut() {
+            Some(r) if r.1 == i => r.1 = i.saturating_add(1),
+            _ => runs.push((i, i.saturating_add(1))),
+        }
+    }
+    runs
+}
+
+/// Whether any of the runs `runs` (left to right, apart) meets the pixels `a..b`.
+fn meets(runs: &[(u32, u32)], a: usize, b: usize) -> bool {
+    let (Ok(a), Ok(b)) = (u32::try_from(a), u32::try_from(b)) else { return true };
+    runs.get(runs.partition_point(|r| r.1 <= a)).is_some_and(|r| r.0 < b)
+}
+
+/// Calls `f(y, x0, x1)` with each run `x0..x1` of the pixels in row `y` inside the loops `loops` (along pixel edges;
+/// inside an odd number of them), row by row, until it answers false; whether it never did.
+fn runs_inside<'l>(loops: impl IntoIterator<Item = &'l Loop>, mut f: impl FnMut(usize, usize, usize) -> bool) -> bool {
+    // The loops' upright edges `(top, bottom, x)`, by their top. Going down the rows, the edges that pass the row are
+    // kept: the pixels between the first and the second are inside, and so on.
+    let mut edges: Vec<(i32, i32, i32)> = loops
+        .into_iter()
+        .flat_map(|l| l.pts.iter().zip(l.pts.iter().cycle().skip(1)))
+        .filter(|(a, b)| a.0 == b.0 && a.1 != b.1)
+        .map(|(a, b)| (a.1.min(b.1), a.1.max(b.1), a.0))
+        .collect();
+    edges.sort_unstable_by_key(|e| e.0);
+    let (Some(top), Some(bottom)) = (edges.first().map(|e| e.0), edges.iter().map(|e| e.1).max()) else { return true };
+    let (mut next, mut passing, mut xs) = (0, Vec::<(i32, i32)>::new(), Vec::<i32>::new());
+    for y in top..bottom {
+        while let Some(&(_, end, x)) = edges.get(next).filter(|e| e.0 <= y) {
+            passing.push((end, x));
+            next += 1;
+        }
+        passing.retain(|e| e.0 > y);
+        xs.clear();
+        xs.extend(passing.iter().map(|e| e.1));
+        xs.sort_unstable();
+        let Ok(row) = usize::try_from(y) else { continue };
+        for pair in xs.as_chunks::<2>().0 {
+            let (Ok(a), Ok(b)) = (usize::try_from(pair[0].max(0)), usize::try_from(pair[1].max(0))) else { continue };
+            if a < b && !f(row, a, b) {
+                return false;
+            }
+        }
+    }
+    true
+}
+
+/// Calls `f` with each pixel `(x, y)` inside the loops `loops` (see [`runs_inside`]), row by row, until it answers
+/// false; whether it never did. A component's outer loop and holes give its own pixels.
+fn pixels_inside<'l>(loops: impl IntoIterator<Item = &'l Loop>, mut f: impl FnMut(usize, usize) -> bool) -> bool {
+    runs_inside(loops, |y, a, b| (a..b).all(|x| f(x, y)))
+}
+
+/// Calls `f(k, runs)` with the runs of row `y0 + k`, for each `k` below `rows` in order, of the pixels inside `outline`
+/// (all of `x0..x1` without one) and inside none of `covered`, within `x0..x1`, left to right. Rows without such a
+/// pixel may be passed over. Only the covered loops' runs are held, not a list for every row.
+fn row_runs(x0: usize, x1: usize, y0: usize, rows: usize, outline: Option<&Loop>, covered: &[&Loop], mut f: impl FnMut(usize, &[(usize, usize)])) {
+    // The covered runs `(k, a, b)`, by row and then left to right.
+    let mut gone: Vec<(usize, usize, usize)> = vec![];
+    for l in covered {
+        runs_inside([*l], |y, a, b| {
+            if let Some(k) = y.checked_sub(y0).filter(|&k| k < rows) {
+                gone.push((k, a, b));
+            }
+            true
+        });
+    }
+    gone.sort_unstable();
+    let (mut next, mut left) = (0, vec![]);
+    // Row `k`'s runs `keep` less its covered runs.
+    let mut row = |k: usize, keep: &[(usize, usize)]| {
+        let from = next;
+        while gone.get(next).is_some_and(|e| e.0 <= k) {
+            next += 1;
+        }
+        let cut = gone.get(from..next).unwrap_or_default();
+        if cut.iter().all(|e| e.0 < k) {
+            f(k, keep);
+            return;
+        }
+        left.clear();
+        for &(a, b) in keep {
+            let mut x = a;
+            for &(_, ga, gb) in cut.iter().filter(|e| e.0 == k) {
+                if gb <= x || ga >= b {
+                    continue;
+                }
+                if ga > x {
+                    left.push((x, ga));
+                }
+                x = x.max(gb);
+            }
+            if x < b {
+                left.push((x, b));
+            }
+        }
+        f(k, &left);
+    };
+    match outline {
+        None => (0..rows).for_each(|k| row(k, &[(x0, x1)])),
+        Some(l) => {
+            // (`runs_inside` goes down the rows, each left to right.)
+            let (mut at, mut runs) = (None, vec![]);
+            runs_inside([l], |y, a, b| {
+                let Some(k) = y.checked_sub(y0).filter(|&k| k < rows) else { return true };
+                if at != Some(k) {
+                    if let Some(prev) = at {
+                        row(prev, &runs);
+                    }
+                    at = Some(k);
+                    runs.clear();
+                }
+                if a.max(x0) < b.min(x1) {
+                    runs.push((a.max(x0), b.min(x1)));
+                }
+                true
+            });
+            if let Some(prev) = at {
+                row(prev, &runs);
+            }
+        }
+    }
+}
+
+/// [`pixels_inside`] the loop `l`: for a hole, the pixels it encloses, those of what lies in it included.
+fn interior(l: &Loop, f: impl FnMut(usize, usize) -> bool) -> bool {
+    pixels_inside([l], f)
+}
+
+/// [`pixels_inside`] the component `c`: its own pixels.
+fn pixels_of(c: &contour::Component, f: impl FnMut(usize, usize) -> bool) -> bool {
+    pixels_inside(std::iter::once(&c.outer).chain(&c.holes), f)
+}
+
+/// The components that [`trace_mask`] finds in a mask of exactly the pixels inside the hole `hole`, without tracing
+/// one: the hole's outline walked the other way round, split where it touches itself (where two pixels inside it meet
+/// only at a corner, which are not connected), each part started at its top left corner and in the order of those
+/// corners, as `trace_mask` gives them.
+fn shapes_in_hole(hole: &Loop) -> Vec<contour::Component> {
+    let Some((&first, rest)) = hole.pts.split_first() else { return vec![] };
+    // The corners walked the other way, back to the first; a corner met again closes the part since its first visit.
+    let mut seen: std::collections::HashMap<(i32, i32), usize> = std::collections::HashMap::new();
+    let mut stack: Vec<(i32, i32)> = vec![];
+    let mut parts: Vec<Vec<(i32, i32)>> = vec![];
+    for p in std::iter::once(first).chain(rest.iter().rev().copied()).chain(std::iter::once(first)) {
+        if let Some(&at) = seen.get(&p) {
+            let part = stack.split_off(at + 1);
+            for q in &part {
+                seen.remove(q);
+            }
+            let start = stack.last().copied();
+            parts.push(start.into_iter().chain(part).collect());
+        } else {
+            seen.insert(p, stack.len());
+            stack.push(p);
+        }
+    }
+    let mut comps: Vec<contour::Component> = parts
+        .into_iter()
+        .filter(|pts| pts.len() >= 4)
+        .map(|mut pts| {
+            // From the top left corner (the walk turns right there).
+            if let Some(at) = pts.iter().enumerate().min_by_key(|(_, p)| (p.1, p.0)).map(|(i, _)| i) {
+                pts.rotate_left(at);
+            }
+            let area2 = pts
+                .iter()
+                .zip(pts.iter().cycle().skip(1))
+                .map(|(a, b)| i64::from(a.0) * i64::from(b.1) - i64::from(b.0) * i64::from(a.1))
+                .sum::<i64>();
+            let pixels = usize::try_from(area2 / 2).unwrap_or(0);
+            contour::Component { outer: Loop { pts, area2 }, holes: vec![], pixels }
+        })
+        .collect();
+    comps.sort_by_key(|c| c.outer.pts.first().map(|p| (p.1, p.0)));
+    comps
+}
+
+/// The pixel at the top left of the area a loop goes around: its topmost row's leftmost.
+fn first_pixel(l: &Loop) -> Option<(usize, usize)> {
+    let &(x, y) = l.pts.iter().min_by_key(|p| (p.1, p.0))?;
+    Some((usize::try_from(x).ok()?, usize::try_from(y).ok()?))
+}
+
 /// How many components of a layer are fitted at a time (see `fit_in_chunks`).
 const FIT_CHUNK: usize = 256;
 
@@ -825,4 +1614,134 @@ mod tests {
         assert_eq!(out, (1..=1000).collect::<Vec<_>>());
         assert!(fit_in_chunks(&[] as &[usize], 7, |&i| i, |_, _| false));
     }
+
+    /// Seeded 23 × 17 masks of several densities.
+    fn masks() -> impl Iterator<Item = (u32, Vec<bool>)> {
+        (0..200u32).map(|seed| {
+            let mask = (0..23 * 17)
+                .map(|i| ((i as u32).wrapping_mul(2_654_435_761) ^ seed.wrapping_mul(40_503)).wrapping_mul(2_246_822_519) >> 28 < (seed % 15) + 1)
+                .collect();
+            (seed, mask)
+        })
+    }
+
+    /// `interior` visits each pixel a loop encloses once, outer loops and holes alike, and stops when told to;
+    /// `pixels_of` visits a component's own pixels.
+    #[test]
+    fn interior_visits_each_enclosed_pixel_once() {
+        let (w, h) = (23, 17);
+        for (seed, mask) in masks() {
+            for comp in trace_mask(&mask, w, h) {
+                for l in std::iter::once(&comp.outer).chain(&comp.holes) {
+                    let mut seen = vec![false; w * h];
+                    let mut n = 0;
+                    assert!(interior(l, |x, y| {
+                        assert!(!std::mem::replace(&mut seen[y * w + x], true), "seed {seed}: ({x}, {y}) twice");
+                        n += 1;
+                        true
+                    }));
+                    assert_eq!(n, l.area2.abs() / 2, "seed {seed}");
+                }
+                let mut visits = 0;
+                assert!(!interior(&comp.outer, |_, _| {
+                    visits += 1;
+                    false
+                }));
+                assert_eq!(visits, 1);
+                let mut own = 0;
+                assert!(pixels_of(&comp, |x, y| {
+                    assert!(mask[y * w + x], "seed {seed}: ({x}, {y}) is not in the mask");
+                    own += 1;
+                    true
+                }));
+                assert_eq!(own, comp.pixels, "seed {seed}");
+            }
+        }
+    }
+
+    /// `shapes_in_hole` gives what `trace_mask` finds in a mask of the pixels inside a hole, holes that touch
+    /// themselves at a corner included.
+    #[test]
+    fn shapes_in_a_hole_are_those_traced() {
+        let (w, h) = (23, 17);
+        let (mut holes, mut touching) = (0, 0);
+        for (seed, mask) in masks() {
+            for hole in trace_mask(&mask, w, h).iter().flat_map(|c| &c.holes) {
+                let mut inside = vec![false; w * h];
+                interior(hole, |x, y| {
+                    inside[y * w + x] = true;
+                    true
+                });
+                assert_eq!(shapes_in_hole(hole), trace_mask(&inside, w, h), "seed {seed}: {hole:?}");
+                holes += 1;
+                let mut corners = hole.pts.clone();
+                corners.sort_unstable();
+                touching += usize::from(corners.windows(2).any(|p| p[0] == p[1]));
+            }
+        }
+        assert!(holes > 500 && touching > 20, "{holes} holes, {touching} touching themselves");
+    }
+
+    /// A component left out of the traced components (as `contours` leaves out those without the layer's own color)
+    /// gives the same loops as leaving its pixels out of the mask.
+    #[test]
+    fn leaving_a_component_out_keeps_the_other_loops() {
+        let (w, h) = (23, 17);
+        for (seed, mask) in masks() {
+            let (labels, _) = contour::label(&mask, w, h);
+            let rules: [fn(u32) -> bool; 2] = [|c| c % 2 == 0, |c| c % 3 != 1];
+            for keep in rules {
+                let fewer: Vec<bool> = mask.iter().zip(&labels).map(|(&m, &c)| m && keep(c)).collect();
+                let kept: Vec<contour::Component> =
+                    trace_mask(&mask, w, h).into_iter().enumerate().filter(|&(c, _)| keep(c as u32)).map(|(_, comp)| comp).collect();
+                assert_eq!(kept, trace_mask(&fewer, w, h), "seed {seed}");
+            }
+        }
+    }
+
+    /// `row_runs` gives the pixels inside an outline and inside none of the covered loops, clipped to the box.
+    #[test]
+    fn row_runs_keep_the_outline_less_what_is_covered() {
+        let (w, h) = (23, 17);
+        for (seed, mask) in masks() {
+            let comps = trace_mask(&mask, w, h);
+            let Some(outline) = comps.iter().max_by_key(|c| c.outer.area2).map(|c| &c.outer) else { continue };
+            let covered: Vec<&Loop> = comps.iter().flat_map(|c| &c.holes).collect();
+            let (x0, x1, y0, rows) = (2, 20, 1, 14);
+            for outline in [Some(outline), None] {
+                let mut want = vec![outline.is_none(); w * h];
+                if let Some(outline) = outline {
+                    interior(outline, |x, y| {
+                        want[y * w + x] = true;
+                        true
+                    });
+                }
+                for l in &covered {
+                    interior(l, |x, y| {
+                        want[y * w + x] = false;
+                        true
+                    });
+                }
+                let (mut got, mut last) = (vec![false; w * h], None);
+                row_runs(x0, x1, y0, rows, outline, &covered, |k, runs| {
+                    assert!(last.is_none_or(|l| l < k) && k < rows, "seed {seed}: row {k} after {last:?}");
+                    last = Some(k);
+                    for w2 in runs.windows(2) {
+                        assert!(w2[0].1 <= w2[1].0, "seed {seed}: {runs:?}");
+                    }
+                    for &(a, b) in runs {
+                        for x in a..b {
+                            got[(y0 + k) * w + x] = true;
+                        }
+                    }
+                });
+                for y in 0..h {
+                    for x in 0..w {
+                        let inside = (x0..x1).contains(&x) && (y0..y0 + rows).contains(&y);
+                        assert_eq!(got[y * w + x], want[y * w + x] && inside, "seed {seed}: ({x}, {y}), outline {}", outline.is_some());
+                    }
+                }
+            }
+        }
+    }
 }
diff --git a/crates/trace/src/lib.rs b/crates/trace/src/lib.rs
index 48baeccf83..c9e4289119 100644
--- a/crates/trace/src/lib.rs
+++ b/crates/trace/src/lib.rs
@@ -41,7 +41,10 @@
 //!
 //! Colour layers are traced either *abutting* (each colour's own area; shapes share edges) or
 //! *overlapping* (stacked: each layer also covers the layers above it within the areas that hold
-//! its own color, so no hairline gaps).
+//! its own color, so no hairline gaps). With Fills and without Create Strokes, an overlapping shape
+//! is filled whole: the area of other colors that it encloses is traced on its own and drawn above
+//! it, so each enclosed outline is fitted once. An area that holds a transparent pixel or a color
+//! left out stays a hole.
 #![forbid(unsafe_code)]
 
 mod centerline;
diff --git a/crates/trace/src/params.rs b/crates/trace/src/params.rs
index a6676cd696..9c430dd19d 100644
--- a/crates/trace/src/params.rs
+++ b/crates/trace/src/params.rs
@@ -24,7 +24,8 @@ pub enum Method {
     #[default]
     Abutting,
     /// Stacked: every layer extends under the layers above it, within the areas that hold its own
-    /// color.
+    /// color. With Fills (without Create Strokes) each shape is filled whole, and what it encloses
+    /// is stacked above it.
     Overlapping,
 }
 
diff --git a/crates/trace/src/pipeline.rs b/crates/trace/src/pipeline.rs
index aa5c7e25b7..2dd54af93b 100644
--- a/crates/trace/src/pipeline.rs
+++ b/crates/trace/src/pipeline.rs
@@ -167,7 +167,9 @@ pub fn trace_within(img: &Raster, params: &TraceParams, max_anchors: usize) -> R
 
 /// [`trace_within`], telling `steps` how far it has got: `steps(done, total)` after each stage
 /// that prepares the colour layers (`total` 0 while they aren't known yet) and after each colour
-/// layer, from whichever thread traced it. Once `steps` answers `false` the trace stops at the
+/// layer, from whichever thread traced it. Overlapping with Fills (without Create Strokes) counts
+/// in finer units instead: a share of `total` after each pass of each layer, in every round of
+/// enclosed areas (see `Layers::stacked`). Once `steps` answers `false` the trace stops at the
 /// next stage or layer with [`TraceError::Cancelled`].
 pub fn trace_watched(
     img: &Raster,
@@ -336,10 +338,23 @@ fn trace_paths(img: &Raster, params: &TraceParams, max_anchors: usize, steps: &(
     // A layer takes about ten bytes a pixel of its box while it is traced (its mask, the labels
     // of its components, the stack that fills them, its edges): as many layers at a time as fit
     // in half a gigabyte, so that a large image is not traced at the cost of gigabytes.
-    // (Overlapping labels a layer's mask once more before it is traced, with its labels and stack
-    // freed before the trace starts.)
     let largest = job.boxes.iter().flatten().map(|b| (b.2 - b.0) * (b.3 - b.1)).max().unwrap_or(1).max(1);
     let at_a_time = ((512 << 20) / (largest * 10)).max(1);
+    // Overlapping with Fills: each shape is filled whole, and what it encloses is traced again above it (see
+    // `Layers::stacked`). Lines (Create Strokes) and outlines (no Fills) are stacked as they always were.
+    if params.method == Method::Overlapping && params.fills && !params.strokes {
+        out.paths = job.stacked(&layers, largest, steps)?;
+        // The colors used, bottom layer first.
+        for &(_, ci) in &layers {
+            if let Some(&color) = q.palette.get(ci)
+                && !out.palette.contains(&color)
+                && out.paths.iter().any(|p| p.color == color)
+            {
+                out.palette.push(color);
+            }
+        }
+        return Ok(out);
+    }
     let total = layers.len() as u64;
     if !steps(0, total) {
         return Err(TraceError::Cancelled);
diff --git a/crates/trace/src/tests.rs b/crates/trace/src/tests.rs
index b244c3b79b..fbedb07e29 100644
--- a/crates/trace/src/tests.rs
+++ b/crates/trace/src/tests.rs
@@ -278,6 +278,365 @@ fn overlapping_layers_leave_out_areas_without_their_color() {
     }
 }
 
+/// Concentric discs about the middle of a `size` × `size` image: each `(radius, color)` paints the pixels whose
+/// centers lie within its radius, a smaller disc over a larger one; `ground` elsewhere.
+fn nested_discs(size: u32, ground: [u8; 4], discs: &[(f64, [u8; 4])]) -> Raster {
+    let c = f64::from(size) / 2.0;
+    Raster::from_fn(size, size, |x, y| {
+        let d = Point::new(f64::from(x) + 0.5, f64::from(y) + 0.5).distance(Point::new(c, c));
+        discs.iter().filter(|(r, _)| d <= *r).min_by(|a, b| a.0.total_cmp(&b.0)).map_or(ground, |(_, color)| *color)
+    })
+}
+
+/// The paths, drawn bottom first, paint every pixel center of `img` whose 3 × 3 neighborhood is one color with
+/// that color (within 3 levels), and leave those of the colors in `left_out` and the transparent ones unpainted.
+fn assert_draws(img: &Raster, res: &TraceResult, left_out: &[[u8; 3]]) {
+    use kurbo::Shape;
+    let paths: Vec<_> = res.paths.iter().map(|t| (t.color, t.path.to_bezpath())).collect();
+    let (w, h) = (img.width as usize, img.height as usize);
+    let px = |x: usize, y: usize| {
+        let k = (y * w + x) * 4;
+        [img.rgba[k], img.rgba[k + 1], img.rgba[k + 2], img.rgba[k + 3]]
+    };
+    for y in 1..h - 1 {
+        for x in 1..w - 1 {
+            let c = px(x, y);
+            if (0..9).any(|k| px(x + k % 3 - 1, y + k / 3 - 1) != c) {
+                continue;
+            }
+            let at = kurbo::Point::new(x as f64 + 0.5, y as f64 + 0.5);
+            let drawn = paths.iter().rev().find(|(_, b)| b.winding(at) != 0).map(|(color, _)| *color);
+            if c[3] == 0 || left_out.contains(&[c[0], c[1], c[2]]) {
+                assert_eq!(drawn, None, "at ({x}, {y})");
+            } else {
+                assert!(drawn.is_some_and(|d| (0..3).all(|k| d[k].abs_diff(c[k]) <= 3)), "at ({x}, {y}): drawn {drawn:?}, image {c:?}");
+            }
+        }
+    }
+}
+
+/// Overlapping fills each shape whole: a black ring around a white disc that holds a navy ring around a disc of the
+/// ground's tan, with a red dot in the middle, is traced as shapes with no holes, each drawn above the shape around
+/// it. Where something must stay unpainted (Ignore White), the hole stays.
+#[test]
+fn overlapping_fills_each_shape_whole_and_draws_what_it_encloses_above_it() {
+    let (tan, white, navy, red) = ([235, 225, 200, 255], [255, 255, 255, 255], [30, 40, 90, 255], [200, 40, 50, 255]);
+    let img = nested_discs(240, tan, &[(100.0, BLACK), (80.0, white), (55.0, navy), (40.0, tan), (12.0, red)]);
+    let params =
+        TraceParams { mode: Mode::Color, palette: Palette::Limited, colors: 5, noise: 2, method: Method::Overlapping, ..TraceParams::default() };
+    let res = trace(&img, &params);
+    assert_eq!(res.palette.len(), 5, "{:?}", res.palette);
+    for t in &res.paths {
+        assert_eq!(t.path.subpaths.len(), 1, "a {:?} path with holes", t.color);
+    }
+    assert_draws(&img, &res, &[]);
+    assert_eq!(trace(&img, &params), res, "tracing twice differs");
+    // Left out, white is not painted over: the shapes around it keep their holes.
+    let res = trace(&img, &TraceParams { ignore_white: true, ..params.clone() });
+    assert_draws(&img, &res, &[[255, 255, 255]]);
+    assert!(res.paths.iter().any(|t| t.path.subpaths.len() > 1));
+}
+
+/// How many outlines of [`ring_with_patches`]' white disc (without a frame) the paths of `res` hold, whichever path
+/// each is part of.
+fn disc_outlines(res: &TraceResult) -> usize {
+    res.paths
+        .iter()
+        .flat_map(|t| &t.path.subpaths)
+        .filter_map(|s| PathData::single(s.clone()).bounds())
+        .filter(|b| [(b.x0, 60.0), (b.y0, 60.0), (b.x1, 180.0), (b.y1, 180.0)].iter().all(|(v, want)| (v - want).abs() <= 1.5))
+        .count()
+}
+
+/// Overlapping: the outline of a white disc in a black ring is traced once, though four grays touch the ring and lie
+/// between white and black in the stack (each of their layers reaches under the ring and encloses the disc).
+#[test]
+fn overlapping_traces_an_enclosed_outline_once() {
+    let res = trace(&ring_with_patches(0), &patch_params());
+    assert_eq!(res.palette.len(), 7, "{:?}", res.palette);
+    assert_eq!(disc_outlines(&res), 1);
+    assert_draws(&ring_with_patches(0), &res, &[]);
+}
+
+/// Overlapping: a square of a color Keep Colors leaves out, or of transparent pixels, in a corner of the ground keeps
+/// its hole in the shapes around it, and the rest is filled whole as without it: the disc's outline is fitted once.
+#[test]
+fn overlapping_keeps_the_holes_around_colors_left_out_and_transparent_pixels() {
+    let with_square = |color: [u8; 4]| {
+        let img = ring_with_patches(0);
+        Raster::from_fn(240, 240, |x, y| {
+            if (10..40).contains(&x) && (10..40).contains(&y) {
+                return color;
+            }
+            let k = ((y * 240 + x) * 4) as usize;
+            [img.rgba[k], img.rgba[k + 1], img.rgba[k + 2], img.rgba[k + 3]]
+        })
+    };
+    let magenta = with_square([220, 40, 200, 255]);
+    let keep: Vec<String> = ["#ebe1c8", "#000000", "#ffffff", "#3c3c3c", "#646464", "#8c8c8c", "#b4b4b4"].map(String::from).to_vec();
+    let res = trace(&magenta, &TraceParams { colors: 8, keep_colors: keep, ..patch_params() });
+    assert!(res.keep_unmatched.is_empty(), "{:?}", res.keep_unmatched);
+    assert_eq!(res.palette.len(), 7, "{:?}", res.palette);
+    assert_draws(&magenta, &res, &[[220, 40, 200]]);
+    assert!(res.paths.iter().any(|t| t.path.subpaths.len() > 1), "no hole around the square");
+    assert_eq!(disc_outlines(&res), 1);
+    let clear = with_square([0, 0, 0, 0]);
+    let res = trace(&clear, &patch_params());
+    assert_draws(&clear, &res, &[]);
+    assert!(res.paths.iter().any(|t| t.path.subpaths.len() > 1), "no hole around the square");
+    assert_eq!(disc_outlines(&res), 1);
+}
+
+/// A white disc in a black ring on a tan ground, four grays straddling the ring's outer edge, inside a black frame
+/// `frame` pixels wide (none at 0): `240 + 2 * frame` pixels square.
+fn ring_with_patches(frame: u32) -> Raster {
+    let tan = [235, 225, 200, 255];
+    let grays = [60, 100, 140, 180];
+    Raster::from_fn(240 + 2 * frame, 240 + 2 * frame, |x, y| {
+        if x < frame || y < frame || x >= 240 + frame || y >= 240 + frame {
+            return BLACK;
+        }
+        let (dx, dy) = (f64::from(x - frame) + 0.5 - 120.0, f64::from(y - frame) + 0.5 - 120.0);
+        let d = dx.hypot(dy);
+        // A 30 px square straddling the ring's outer edge at each of four angles.
+        let patch = (0..4usize).find(|&k| {
+            let a = k as f64 * std::f64::consts::FRAC_PI_2;
+            (dx - 80.0 * a.cos()).abs() <= 15.0 && (dy - 80.0 * a.sin()).abs() <= 15.0
+        });
+        if d <= 60.0 {
+            WHITE
+        } else if d <= 72.0 {
+            BLACK
+        } else if let Some(k) = patch {
+            let v = grays[k];
+            [v, v, v, 255]
+        } else {
+            tan
+        }
+    })
+}
+
+fn patch_params() -> TraceParams {
+    TraceParams { mode: Mode::Color, palette: Palette::Limited, colors: 7, noise: 2, method: Method::Overlapping, ..TraceParams::default() }
+}
+
+/// Overlapping: a black frame on top of the stack encloses the whole picture, whose shapes are then traced once, in the
+/// area the frame fills: the layers below the frame do not trace them again, under it. The trace is the frame, filled
+/// whole, under the picture's own trace moved by the frame's width.
+#[test]
+fn overlapping_traces_what_a_frame_encloses_once() {
+    let alone = trace(&ring_with_patches(0), &patch_params());
+    let framed = trace(&ring_with_patches(12), &patch_params());
+    assert_draws(&ring_with_patches(12), &framed, &[]);
+    // The frame filled whole, under everything, then the picture.
+    assert_eq!(framed.paths.len(), alone.paths.len() + 1, "{:?}", framed.paths.iter().map(|t| t.color).collect::<Vec<_>>());
+    assert_eq!((framed.paths[0].color, framed.paths[0].path.subpaths.len()), ([0, 0, 0], 1));
+    let moved: Vec<_> = alone.paths.iter().map(|t| (t.color, t.path.anchor_count(), t.path.bounds().map(|b| (b.x0 + 12.0, b.y0 + 12.0)))).collect();
+    let inside: Vec<_> = framed.paths[1..].iter().map(|t| (t.color, t.path.anchor_count(), t.path.bounds().map(|b| (b.x0, b.y0)))).collect();
+    for (a, b) in moved.iter().zip(&inside) {
+        assert_eq!((a.0, a.1), (b.0, b.1));
+        let ((ax, ay), (bx, by)) = (a.2.unwrap(), b.2.unwrap());
+        assert!((ax - bx).abs() < 0.5 && (ay - by).abs() < 0.5, "{a:?} {b:?}");
+    }
+}
+
+/// Overlapping: in 37 nested rings, each area is traced once more for each one around it; past a budget of work the
+/// deeper areas keep their holes, and every ring is still drawn in its color.
+#[test]
+fn overlapping_keeps_the_holes_of_areas_nested_past_its_budget() {
+    let discs: Vec<(f64, [u8; 4])> = (0..37).map(|k| (148.0 - 4.0 * f64::from(k), if k % 2 == 0 { BLACK } else { WHITE })).collect();
+    let img = nested_discs(300, WHITE, &discs);
+    let params =
+        TraceParams { mode: Mode::Color, palette: Palette::Limited, colors: 2, noise: 0, method: Method::Overlapping, ..TraceParams::default() };
+    let res = trace(&img, &params);
+    assert!(res.paths.iter().any(|t| t.path.subpaths.len() > 1), "no area kept its holes");
+    assert!(res.paths.iter().take(4).all(|t| t.path.subpaths.len() == 1), "the outer areas kept their holes");
+    assert_draws(&img, &res, &[]);
+}
+
+/// `f` run with the stacked trace's switches `probe` on this thread, and the counts the last trace made.
+fn probed<R>(probe: layers::Probe, f: impl FnOnce() -> R) -> (R, layers::Probe) {
+    /// Puts the switches back, also when an assertion fails.
+    struct Restore;
+    impl Drop for Restore {
+        fn drop(&mut self) {
+            layers::PROBE.with(|p| *p.borrow_mut() = layers::Probe::default());
+        }
+    }
+    let _restore = Restore;
+    layers::PROBE.with(|p| *p.borrow_mut() = probe);
+    let out = f();
+    (out, layers::PROBE.with(|p| p.borrow().clone()))
+}
+
+/// Overlapping: in 37 nested rings around a transparent center, no ring's hole may be filled, and each hole is checked
+/// for pixels that are not traced by its rows, not by every pixel it encloses again for each ring around it.
+#[test]
+fn overlapping_checks_nested_holes_around_a_transparent_center_by_their_rows() {
+    let mut discs: Vec<(f64, [u8; 4])> = (0..37).map(|k| (148.0 - 4.0 * f64::from(k), if k % 2 == 0 { BLACK } else { WHITE })).collect();
+    discs.push((3.0, [0, 0, 0, 0]));
+    let img = nested_discs(300, WHITE, &discs);
+    let params =
+        TraceParams { mode: Mode::Color, palette: Palette::Limited, colors: 2, noise: 0, method: Method::Overlapping, ..TraceParams::default() };
+    let (res, probe) = probed(layers::Probe::default(), || trace(&img, &params));
+    assert_draws(&img, &res, &[]);
+    assert!(res.paths.iter().any(|t| t.path.subpaths.len() > 1), "no shape kept a hole around the transparent center");
+    // The rings' rows down to the center: under 37 × 300 reads. Read by the pixel, the holes took 205,241.
+    assert!(probe.live_reads > 0 && probe.live_reads < 37 * 300, "{} reads", probe.live_reads);
+}
+
+/// Overlapping: in a tall, narrow image that is transparent but for a black block with a white center, the runs of
+/// untraced pixels take a few bytes for the whole image, not a list for each row.
+#[test]
+fn overlapping_holds_the_untraced_pixels_of_a_tall_narrow_image_in_a_few_runs() {
+    let img = Raster::from_fn(3, 20_000, |x, y| match y {
+        100..110 if x == 1 && (104..106).contains(&y) => WHITE,
+        100..110 => BLACK,
+        _ => [0, 0, 0, 0],
+    });
+    let params =
+        TraceParams { mode: Mode::Color, palette: Palette::Limited, colors: 2, noise: 0, method: Method::Overlapping, ..TraceParams::default() };
+    let (res, probe) = probed(layers::Probe::default(), || trace(&img, &params));
+    assert_draws(&img, &res, &[]);
+    assert!(probe.dead_bytes > 0 && probe.dead_bytes <= 64, "{} bytes", probe.dead_bytes);
+}
+
+/// Overlapping: an enclosed area past what is left of the work budget keeps its holes and is charged nothing, so a
+/// smaller area after it in the same round is still filled.
+#[test]
+fn overlapping_charges_nothing_for_an_area_past_its_budget() {
+    let (red, navy) = ([200, 40, 50, 255], [30, 40, 90, 255]);
+    // A large black ring around a white field with a red and a navy disc, and a small one around a red disc, below it.
+    let img = Raster::from_fn(240, 240, |x, y| {
+        let ring = |x0: u32, x1: u32, t: u32| {
+            (x0..x1).contains(&x) && (x0..x1).contains(&y) && !((x0 + t..x1 - t).contains(&x) && (x0 + t..x1 - t).contains(&y))
+        };
+        let at = |cx: f64, cy: f64, r: f64| (f64::from(x) + 0.5 - cx).hypot(f64::from(y) + 0.5 - cy) <= r;
+        if ring(10, 130, 6) || ring(160, 210, 5) {
+            BLACK
+        } else if at(50.0, 60.0, 18.0) || at(185.0, 185.0, 9.0) {
+            red
+        } else if at(95.0, 90.0, 15.0) {
+            navy
+        } else {
+            WHITE
+        }
+    });
+    let params =
+        TraceParams { mode: Mode::Color, palette: Palette::Limited, colors: 4, noise: 0, method: Method::Overlapping, ..TraceParams::default() };
+    let (whole, probe) = probed(layers::Probe::default(), || trace(&img, &params));
+    assert_draws(&img, &whole, &[]);
+    assert!(probe.areas.iter().all(|a| a.2), "{:?}", probe.areas);
+    // An area `j` followed in its round by a smaller one `k`: a budget just short of `j` refuses `j`, and leaves `k` room.
+    let areas = &probe.areas;
+    let pair = (0..areas.len()).find_map(|j| (j + 1..areas.len()).find(|&k| areas[k].0 == areas[j].0 && areas[k].1 < areas[j].1).map(|k| (j, k)));
+    let Some((j, k)) = pair else { panic!("no smaller area after a larger one: {areas:?}") };
+    let budget = areas[..j].iter().map(|a| a.1).sum::<u64>() + areas[j].1 - 1;
+    let (res, probe) = probed(layers::Probe { budget: Some(budget), ..Default::default() }, || trace(&img, &params));
+    assert!(!probe.areas[j].2 && probe.areas[k].2, "{:?} with a budget of {budget}", probe.areas);
+    assert_draws(&img, &res, &[]);
+}
+
+/// Overlapping with Create Strokes, and without Fills: a layer still leaves out the parts of its mask without its own
+/// color (as with Fills), so a black bar on the light ground gets no blue path under it.
+#[test]
+fn overlapping_lines_and_outlines_leave_out_areas_without_their_color() {
+    let (light, blue) = ([240, 240, 220, 255], [40, 120, 240, 255]);
+    let img = Raster::from_fn(400, 400, |x, y| {
+        if (170..230).contains(&x) && (170..230).contains(&y) {
+            blue
+        } else if (50..350).contains(&x) && (300..340).contains(&y) {
+            BLACK
+        } else {
+            light
+        }
+    });
+    for fills in [false, true] {
+        let params = TraceParams {
+            mode: Mode::Color,
+            palette: Palette::Limited,
+            colors: 3,
+            method: Method::Overlapping,
+            strokes: true,
+            fills,
+            ..TraceParams::default()
+        };
+        let res = trace(&img, &params);
+        let blues: Vec<_> = res.paths.iter().filter(|p| p.color[0] < 100 && p.color[2] > 150).collect();
+        assert!(!blues.is_empty(), "fills {fills}: {:?}", res.palette);
+        for p in blues {
+            let b = p.path.bounds().unwrap();
+            assert!(b.x1 <= 50.0 || b.x0 >= 350.0 || b.y1 <= 300.0 || b.y0 >= 340.0, "fills {fills}: a blue path over the bar: {b:?}");
+        }
+    }
+}
+
+/// Overlapping: a level's components found with the areas that higher levels fill left out give the same trace as
+/// those found whole, and as those found again in the second pass (as past the memory kept for them), on a framed
+/// image of rings and scattered blobs of eight colors, whatever the Noise. Traced with several levels at a time, in
+/// whatever order the threads take them, it gives the same trace each time.
+#[test]
+fn overlapping_gives_the_same_trace_with_covered_areas_left_out() {
+    let colors: [[u8; 4]; 8] = [
+        [240, 235, 220, 255],
+        [200, 60, 50, 255],
+        [40, 90, 160, 255],
+        [230, 190, 60, 255],
+        [70, 140, 80, 255],
+        [120, 70, 140, 255],
+        [20, 20, 30, 255],
+        [250, 250, 250, 255],
+    ];
+    let img = Raster::from_fn(320, 320, |x, y| {
+        if x < 10 || y < 10 || x >= 310 || y >= 310 {
+            return colors[7];
+        }
+        let (fx, fy) = (f64::from(x) + 0.5, f64::from(y) + 0.5);
+        let ring = (fx - 160.0).hypot(fy - 160.0) / 18.0;
+        let cell = (x / 23 * 31 + y / 19 * 17) as usize;
+        let blob = (fx - f64::from(x / 23 * 23) - 11.5).hypot(fy - f64::from(y / 19 * 19) - 9.5) < 6.0;
+        colors[if blob { cell % 6 + 1 } else { ring as usize % 7 }]
+    });
+    for noise in [0, 4] {
+        let p = TraceParams { mode: Mode::Color, palette: Palette::Limited, colors: 8, noise, method: Method::Overlapping, ..TraceParams::default() };
+        let left_out = probed(layers::Probe { one_level_at_a_time: true, ..Default::default() }, || trace(&img, &p)).0;
+        let whole = probed(layers::Probe { one_level_at_a_time: true, keep_covered: true, ..Default::default() }, || trace(&img, &p)).0;
+        let again = probed(layers::Probe { keep_none: true, ..Default::default() }, || trace(&img, &p)).0;
+        assert!(left_out.palette.len() >= 6 && left_out.paths.len() > 20, "{} colors, {} paths", left_out.palette.len(), left_out.paths.len());
+        assert_eq!(left_out, whole, "noise {noise}");
+        assert_eq!(left_out, again, "noise {noise}: found again");
+        for run in 0..8 {
+            assert_eq!(left_out, trace(&img, &p), "noise {noise}: run {run} with several levels at a time");
+        }
+        assert_draws(&img, &left_out, &[]);
+    }
+}
+
+/// Overlapping with filled shapes: the trace counts its progress through the rounds of enclosed areas with the same
+/// total, and stops when told to there.
+#[test]
+fn overlapping_counts_its_enclosed_rounds_and_stops_in_them() {
+    let img = ring_with_patches(12);
+    let seen = std::sync::Mutex::new(vec![]);
+    let watched = trace_watched(&img, &patch_params(), usize::MAX, &|done, total| {
+        seen.lock().unwrap().push((done, total));
+        true
+    });
+    assert_eq!(watched.unwrap(), trace(&img, &patch_params()), "watching changes nothing");
+    let seen = seen.into_inner().unwrap();
+    let total = seen.last().unwrap().1;
+    assert!(seen.iter().filter(|s| s.1 > 0).all(|s| s.1 == total && s.0 <= total), "{seen:?}");
+    assert_eq!(seen.last().unwrap().0, total);
+    // After the first round's two passes (two thirds of the total), a step for each level of the area the frame fills
+    // (the picture's seven colors), in each pass.
+    let later = |done: u64| done * 3 > total * 2 && done < total;
+    assert!(seen.iter().filter(|s| later(s.0)).count() >= 14, "{seen:?}");
+    // Told to stop there.
+    let res = trace_watched(&img, &patch_params(), usize::MAX, &|done, _| !later(done));
+    assert!(matches!(res, Err(TraceError::Cancelled)), "{res:?}");
+    assert!(matches!(trace_watched(&img, &patch_params(), usize::MAX, &|done, _| done == 0), Err(TraceError::Cancelled)));
+}
+
 #[test]
 fn transparent_pixels_are_not_traced() {
     let img = Raster::from_fn(40, 40, |x, _| if x < 20 { [0, 0, 0, 0] } else { BLACK });
diff --git a/crates/ui-egui/src/addons/cutting.rs b/crates/ui-egui/src/addons/cutting.rs
index 1fbdcf88c2..15a6790872 100644
--- a/crates/ui-egui/src/addons/cutting.rs
+++ b/crates/ui-egui/src/addons/cutting.rs
@@ -2,6 +2,7 @@
 //! Bridges… opens the generic command dialog (`ui.paramDialog`, `dialogs::command`) on the options
 //! of `addon.cutting.bridges`. Weed Box and Lines… opens it on the options of `addon.cutting.weed`,
 //! with a Preview, and runs the command on OK. A Spacing above 0 is sent instead of the Count.
+//! Banner Hems and Grommets… opens it on the options of `addon.cutting.banner`, with a Preview.
 
 use serde_json::json;
 
@@ -15,6 +16,8 @@ pub const BRIDGE_DIRECTIONS: &[(&str, &str)] = &[("Vertical", "vertical"), ("Hor
 pub const WEED: &str = "addon.cutting.weed";
 /// Weed Box and Lines › Direction: what the command's `direction` takes, by name.
 pub const WEED_DIRECTIONS: &[(&str, &str)] = &[("Horizontal", "horizontal"), ("Vertical", "vertical"), ("Both", "both")];
+/// Banner Hems and Grommets' command.
+pub const BANNER: &str = "addon.cutting.banner";
 
 /// Object › Plug-ins › Cutting Tools.
 pub fn menu() -> Vec<Item> {
@@ -25,6 +28,14 @@ pub fn menu() -> Vec<Item> {
             WEED,
             json!({"margin": 9, "box": true, "direction": "both", "count": 1, "spacing": 0, "gap": 0, "weight": 0.3, "swatch": "[Registration]"}),
         ),
+        Item::Cmd(
+            "Banner Hems and Grommets…",
+            BANNER,
+            json!({
+                "hem": 72, "top": true, "right": true, "bottom": true, "left": true, "grommets": true, "spacing": 1728, "grommetInset": 36,
+                "diameter": 27, "weight": 0.3, "swatch": "[Registration]"
+            }),
+        ),
     ]
 }
 
diff --git a/crates/ui-egui/src/addons/cutting/tests.rs b/crates/ui-egui/src/addons/cutting/tests.rs
index 2e69eab904..99580b369c 100644
--- a/crates/ui-egui/src/addons/cutting/tests.rs
+++ b/crates/ui-egui/src/addons/cutting/tests.rs
@@ -143,3 +143,70 @@ fn weed_box_and_lines_previews_cancels_and_runs_on_ok() {
         app.run("edit.undo", json!({})).unwrap();
     }
 }
+
+/// Object › Plug-ins › Cutting Tools › Banner Hems and Grommets… opens the command dialog on its
+/// defaults with Preview off, previews the marks, takes them away on Cancel and keeps them as one
+/// step on OK. With nothing selected it marks the artboard.
+#[test]
+fn banner_hems_and_grommets_previews_cancels_and_runs_on_ok() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.run("file.new", json!({"width": 600, "height": 400})).unwrap();
+    app.run("select.none", json!({})).unwrap();
+    let steps = |app: &VectorcraftApp| app.session.doc().unwrap().history.undo.len();
+    let count = |app: &VectorcraftApp| app.session.doc().unwrap().doc.node_count();
+    let (start, n, nodes) = (app.session.doc().unwrap().doc.clone(), steps(&app), count(&app));
+    let open = |app: &mut VectorcraftApp| {
+        let entries = menus::menu_entries(app);
+        let item = entries.iter().find(|e| e.path == ["Object", "Plug-ins", "Cutting Tools"] && e.label == "Banner Hems and Grommets…").unwrap();
+        assert!(item.enabled);
+        let (cmd, p) = menus::click_target(&item.label, item.command.as_deref().unwrap(), &item.params);
+        menus::invoke(app, &cmd, p);
+    };
+
+    open(&mut app);
+    let d = app.ui.dialog.as_ref().expect("a dialog opens");
+    assert_eq!((d.str("__command"), d.str("__label")), (super::BANNER.to_string(), "Banner Hems and Grommets".to_string()));
+    assert_eq!((d.bool("grommets"), d.bool("top"), d.bool("preview")), (true, true, false));
+    let shown = painted_text(&mut app, |app, ui| crate::dialogs::show(app, ui.ctx()));
+    for s in [
+        "Banner Hems and Grommets",
+        "Hem",
+        "Top",
+        "Right",
+        "Bottom",
+        "Left",
+        "Grommets",
+        "Spacing",
+        "Grommet Inset",
+        "Diameter",
+        "Weight",
+        "Swatch",
+        "Preview",
+    ] {
+        assert!(shown.contains(s), "{s} in {shown}");
+    }
+    crate::i18n::set_current(crate::i18n::Lang::from_code("de").expect("de registered"));
+    let german = painted_text(&mut app, |app, ui| crate::dialogs::show(app, ui.ctx()));
+    crate::i18n::set_current(crate::i18n::Lang::EN);
+    for s in ["Bannersäume und Ösen", "Saum:", "Ösen:", "Randabstand der Ösen:", "Durchmesser:"] {
+        assert!(german.contains(s), "{s} in {german}");
+    }
+    assert_eq!(count(&app), nodes, "no preview without the checkbox");
+
+    // 600 × 400 pt with grommets at most 1728 pt apart: one at each corner. The group holds four
+    // hem lines and four grommets of three paths each.
+    let added = 1 + 4 + 4 * 4;
+    crate::dialogs::set_field(app.ui.dialog.as_mut().unwrap(), "preview".into(), json!(true));
+    painted_text(&mut app, |app, ui| crate::dialogs::show(app, ui.ctx()));
+    assert_eq!(count(&app), nodes + added, "previewed");
+    crate::dialogs::cancel(&mut app);
+    assert_eq!(app.session.doc().unwrap().doc, start, "Cancel takes the preview away");
+    assert_eq!(steps(&app), n, "and adds no undo step");
+
+    open(&mut app);
+    crate::dialogs::set_field(app.ui.dialog.as_mut().unwrap(), "spacing".into(), json!("100 pt"));
+    crate::dialogs::confirm(&mut app).unwrap();
+    assert_eq!(steps(&app), n + 1, "one undo step");
+    // 528 pt along the top and bottom need 6 gaps, 328 pt down the sides 4: 20 grommets.
+    assert_eq!(count(&app), nodes + 1 + 4 + 20 * 4);
+}
diff --git a/crates/ui-egui/src/addons/pathtools.rs b/crates/ui-egui/src/addons/pathtools.rs
index f59984ccdc..bfbcf0d5b3 100644
--- a/crates/ui-egui/src/addons/pathtools.rs
+++ b/crates/ui-egui/src/addons/pathtools.rs
@@ -15,7 +15,7 @@ pub mod shared_edge;
 use egui::Ui;
 use serde_json::{Map, Value, json};
 use vectorcraft_geom::Point;
-use vectorcraft_tools::addons::{anchor_eraser, extend_path, measure_inspect, parametric_shape, slide_anchor};
+use vectorcraft_tools::addons::{anchor_eraser, extend_path, measure_inspect, parametric_shape, slide_anchor, trim};
 
 use crate::VectorcraftApp;
 use crate::dialogs::DialogSpec;
@@ -60,6 +60,7 @@ pub fn menu() -> Vec<Item> {
         Item::Cmd("Set Corners…", set_corners::COMMAND, Value::Null),
         tool("Slide Anchor Along Path", slide_anchor::ID),
         Item::Cmd("Shared Edge Merge Tool", shared_edge::COMMAND, json!({})),
+        tool("Trim at Crossings Tool", trim::ID),
         Item::Sep,
         Item::Cmd("Anchor Inspector", "window.panel", json!({ "panel": ID })),
         Item::Cmd("Parametric Shape", "window.panel", json!({ "panel": shape::ID })),
diff --git a/crates/ui-egui/src/addons/pathtools/tests.rs b/crates/ui-egui/src/addons/pathtools/tests.rs
index 9ecf12062d..db4b39b6fc 100644
--- a/crates/ui-egui/src/addons/pathtools/tests.rs
+++ b/crates/ui-egui/src/addons/pathtools/tests.rs
@@ -22,6 +22,7 @@ fn the_plugins_submenu_selects_the_tools_and_opens_the_anchor_inspector() {
         ("Measure & Inspect Tool", "measureInspect"),
         ("Parametric Shape Tool", "parametricShape"),
         ("Slide Anchor Along Path", "slideAnchor"),
+        ("Trim at Crossings Tool", "trimAtCrossings"),
     ] {
         let e = under(label).expect(label);
         assert_eq!((e.command.as_deref(), &e.params), (Some("tool.select"), &json!({ "tool": tool })));
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index edafe2eb41..a947dde852 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -478,7 +478,7 @@ fn canvas_cursor(app: &mut VectorcraftApp, ui: &Ui, view_info: vectorcraft_engin
         return;
     }
     let m = ui.input(|i| i.modifiers);
-    let space = ui.input(|i| i.key_down(egui::Key::Space));
+    let space = drag::space_lends_view_tools(app, m, ui.input(|i| i.key_down(egui::Key::Space)));
     let drag = ui.data(|d| d.get_temp::<Drag>(drag_id()));
     let panning = matches!(drag, Some(Drag::Pan { .. }));
     let tool_holds = drag.is_some_and(drag::tool_holds);
diff --git a/crates/ui-egui/src/canvas/drag.rs b/crates/ui-egui/src/canvas/drag.rs
index 414746310f..cb01cf71d4 100644
--- a/crates/ui-egui/src/canvas/drag.rs
+++ b/crates/ui-egui/src/canvas/drag.rs
@@ -265,6 +265,12 @@ pub fn mods(m: egui::Modifiers, space: bool) -> Mods {
     Mods { shift: m.shift, alt: m.alt, cmd: m.command, ctrl: m.ctrl, space }
 }
 
+/// Whether Space, held with the modifiers `m`, lends the Hand, Rotate View or Zoom tool. While the
+/// Type tool edits text, Space types a space, and only Cmd+Space still lends the Zoom tool.
+pub(super) fn space_lends_view_tools(app: &VectorcraftApp, m: egui::Modifiers, space: bool) -> bool {
+    space && (m.command || !app.session.tool_wants_text())
+}
+
 /// Drop the tool press in progress, if any: nothing it began is kept, and the rest of the press
 /// does nothing ([`Drag::Gesture`]).
 pub(super) fn drop_press(app: &mut VectorcraftApp, ui: &Ui, view: vectorcraft_engine::ViewInfo) {
diff --git a/crates/ui-egui/src/canvas/input.rs b/crates/ui-egui/src/canvas/input.rs
index 879f86dd1e..4d121eb2a3 100644
--- a/crates/ui-egui/src/canvas/input.rs
+++ b/crates/ui-egui/src/canvas/input.rs
@@ -1,8 +1,8 @@
 use super::artboards::{artboard_name_at, begin_artboard_name_edit, name_press_id, select_named_artboard};
 use super::drag::{
     FrameMove, HoverContext, apply_requests, backquote_at_release, backquote_seen, dispatch, drag_art_out, drag_id, drag_layer_id, drag_pos_id,
-    drop_press, mods, move_pose, on_canvas, pen_pose, pen_pressure, tool_drag_doc_id, tool_drag_mods_changed, tool_drag_moved, tool_frame_moves,
-    tool_holds, tool_press_doc_id,
+    drop_press, mods, move_pose, on_canvas, pen_pose, pen_pressure, space_lends_view_tools, tool_drag_doc_id, tool_drag_mods_changed,
+    tool_drag_moved, tool_frame_moves, tool_holds, tool_press_doc_id,
 };
 use super::view::{
     HOLD_DELAY, HOLD_ZOOM, SCRUB_SLOP, SCRUB_ZOOM, WheelTurn, animated_zoom, pan_pixels, rotate_about, scroll_view, touch_gestures, trackpad_turn,
@@ -238,6 +238,7 @@ fn wheel_view(
             wheel(i, &app.session.prefs, wheel_zooms, animate, line, rect.height(), &mut turn),
         )
     });
+    let space = space_lends_view_tools(app, m, space);
     // A zoom glide still running when a modal dialog opens stops.
     if muted {
         turn.glide = 0.0;
@@ -298,7 +299,8 @@ fn begin_drag(app: &mut VectorcraftApp, ui: &Ui, f: &Pointing, p: Pos2) {
     let Pointing { resp, rect, m, space, xf, v, view, .. } = *f;
     let tool = app.session.tool_id();
     // Held, Space is the Hand tool for the moment, Space+Shift is the Rotate View tool and
-    // Cmd+Space is the Zoom tool (with Alt, zooming out), whatever the tool.
+    // Cmd+Space is the Zoom tool (with Alt, zooming out), whatever the tool. While the Type tool
+    // edits text, only Cmd+Space does ([`space_lends_view_tools`]).
     let zoom_mode = if space { m.command } else { tool == "zoom" };
     let rotate_mode = if space { m.shift && !m.command } else { tool == "rotateView" };
     let pan_mode = if space { !m.command && !m.shift } else { tool == "hand" };
diff --git a/crates/ui-egui/src/canvas/tests.rs b/crates/ui-egui/src/canvas/tests.rs
index 91c480e409..666a1c8a62 100644
--- a/crates/ui-egui/src/canvas/tests.rs
+++ b/crates/ui-egui/src/canvas/tests.rs
@@ -7366,6 +7366,48 @@ fn cmd_space_zooms_and_space_pans_whatever_the_tool() {
     assert!((after.center.x - (before.center.x - 30.0 / before.zoom)).abs() < 1e-6, "{before:?} → {after:?}");
 }
 
+/// While the Type tool edits text, Space types a space: held, it shows no hand and a drag with it
+/// does not pan the view. Cmd+Space still zooms.
+#[test]
+fn space_types_a_space_while_editing_text_and_does_not_pan() {
+    use egui::{CursorIcon, Event, Modifiers};
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.session.prefs.placeholder_text = false;
+    let ctx = egui::Context::default();
+    let id = start_typing(&mut app, &ctx);
+    let at = Xf::new(app.canvas_rect.unwrap(), app.view().unwrap()).to_screen(Point::new(100.0, 100.0));
+    let space = |pressed, modifiers| Event::Key { key: egui::Key::Space, physical_key: None, pressed, repeat: false, modifiers };
+    let button = |pos, pressed, modifiers| Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers };
+    // The cursor the canvas sets over a window without the focus, as in
+    // `the_rotate_cursor_shows_for_space_shift_and_the_rotate_view_tool`.
+    let shown = |app: &mut VectorcraftApp| {
+        let screen_rect = Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0)));
+        let mut out = ctx.run_ui(egui::RawInput { screen_rect, focused: false, ..Default::default() }, |ui| show(app, ui));
+        out.textures_delta.clear();
+        out.platform_output.cursor_icon
+    };
+    typing_frame(&mut app, &ctx, vec![Event::Text("a".into())]);
+    typing_frame(&mut app, &ctx, vec![Event::PointerMoved(at), space(true, Modifiers::NONE), Event::Text(" ".into())]);
+    assert_eq!(plain(&app, id), "a ", "Space types a space");
+    assert_ne!(shown(&mut app), CursorIcon::Grab, "held while editing, Space shows no hand");
+    let before = *app.view().unwrap();
+    typing_frame(&mut app, &ctx, vec![button(at, true, Modifiers::NONE)]);
+    typing_frame(&mut app, &ctx, vec![Event::PointerMoved(at + vec2(30.0, 0.0))]);
+    typing_frame(&mut app, &ctx, vec![button(at + vec2(30.0, 0.0), false, Modifiers::NONE)]);
+    let after = *app.view().unwrap();
+    assert_eq!((after.center, after.zoom, after.rotation), (before.center, before.zoom, before.rotation), "a drag with Space held does not pan");
+    assert!(app.session.tool_wants_text(), "editing goes on");
+    typing_frame(&mut app, &ctx, vec![space(false, Modifiers::NONE)]);
+    // Cmd+Space still lends the Zoom tool.
+    typing_frame(&mut app, &ctx, vec![Event::ModifiersChanged(Modifiers::COMMAND), space(true, Modifiers::COMMAND), Event::PointerMoved(at)]);
+    assert_eq!(shown(&mut app), CursorIcon::ZoomIn, "Cmd+Space shows the magnifier");
+    typing_frame(&mut app, &ctx, vec![button(at, true, Modifiers::COMMAND)]);
+    typing_frame(&mut app, &ctx, vec![button(at, false, Modifiers::COMMAND)]);
+    assert_eq!(app.view().unwrap().zoom, crate::state::next_zoom(before.zoom, true), "Cmd+Space click zooms in");
+    typing_frame(&mut app, &ctx, vec![space(false, Modifiers::COMMAND), Event::ModifiersChanged(Modifiers::NONE)]);
+    assert_eq!(plain(&app, id), "a ", "the text is as typed");
+}
+
 #[test]
 fn space_shift_drag_rotates_the_view_whatever_the_tool() {
     use egui::{Event, Modifiers};
diff --git a/crates/ui-egui/src/chrome/tests.rs b/crates/ui-egui/src/chrome/tests.rs
index 376450937c..052c7ec230 100644
--- a/crates/ui-egui/src/chrome/tests.rs
+++ b/crates/ui-egui/src/chrome/tests.rs
@@ -491,6 +491,32 @@ fn the_message_of_an_open_with_several_notes_lists_them_on_hover() {
     assert_eq!(hovered.iter().filter(|t| t.text.starts_with("Opened")).count(), 1, "no tooltip: {hovered:?}");
 }
 
+/// The message of an open that starts with a line about its linked files lists the open's notes on
+/// hover and for screen readers, in a wide and in a narrow window. A later message leaves the list
+/// out.
+#[test]
+fn combined_open_and_link_status_lists_notes_on_hover_and_for_accessibility() {
+    let (mut app, ctx) = status_readout_app();
+    ctx.enable_accesskit();
+    let notes = vec!["the file's layers weren't read".to_string(), "a brush wasn't read".to_string()];
+    let notice = crate::dialogs::missing_links::changed_on_disk_status(2);
+    let opened = crate::io::opened_with_notes(2, &notes[0]);
+    crate::io::show_opened(&mut app, Some(notice.clone()), notes);
+    assert!(app.ui.status.starts_with(&notice) && app.ui.status.ends_with(&opened), "{}", app.ui.status);
+    let full = format!("{}\n• the file's layers weren't read\n• a brush wasn't read", app.ui.status);
+    for width in [1400.0, 700.0] {
+        let (texts, nodes, hovered) = bar_hover(&mut app, &ctx, width, "2 linked", super::status_bar);
+        assert!(width > 700.0 || status_text(&texts, "2 linked").elided, "the narrow window cuts the message short");
+        assert!(nodes.iter().any(|n| n.value() == Some(full.as_str())), "screen readers receive the notes at {width}: {nodes:?}");
+        assert!(hovered.iter().any(|t| t.text == full), "the tooltip lists the notes at {width}: {hovered:?}");
+    }
+
+    app.ui.status = crate::dialogs::missing_links::changed_on_disk_status(1);
+    let (_, nodes, hovered) = bar_hover(&mut app, &ctx, 1400.0, "1 linked", super::status_bar);
+    assert!(!nodes.iter().any(|n| n.value().is_some_and(|v| v.contains("• "))), "{nodes:?}");
+    assert_eq!(hovered.iter().filter(|t| t.text.starts_with("1 linked")).count(), 1, "no tooltip: {hovered:?}");
+}
+
 /// The list has at most 30 notes, then how many more there are.
 #[test]
 fn the_hover_lists_thirty_notes_and_counts_the_rest() {
diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index 1f7f715fc4..2eea07b3ee 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -1236,7 +1236,8 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context, req: &ControlReques
 }
 
 /// Hides in `reply` the libraries hidden now and in `before`, and the paths outside the read root that
-/// `sent`, the request's params, holds ([`handle`]). The `path` and `files` entries of the reply's
+/// `sent`, the request's params, holds ([`handle`]), and the recovery folders outside the read root
+/// that are in use or that a failure message named. The `path` and `files` entries of the reply's
 /// `result`, at any depth, that name a file the request gave inside the write roots, the file it
 /// wrote, stay as given ([`written_paths`]).
 fn hide_in_reply(app: &VectorcraftApp, reply: &mut Value, sent: &Value, before: Hiding) {
@@ -1250,6 +1251,11 @@ fn hide_in_reply(app: &VectorcraftApp, reply: &mut Value, sent: &Value, before:
     hiding.merge(before);
     let mut paths = Vec::new();
     sent_paths(sent, &mut paths);
+    // The status text of a recovery copy that failed names the recovery folder it went to.
+    let current = vectorcraft_engine::cmd::recovery::folder(&app.session).map(|(f, _)| f);
+    for folder in app.recovery.named.iter().chain(current.as_ref()) {
+        collect_sent_paths(&json!(folder), true, &mut paths);
+    }
     hiding.set_hidden(paths, cfg!(windows));
     hide_library_ids(reply, &hiding);
     restore_written_paths(reply, kept);
diff --git a/crates/ui-egui/src/control/tests.rs b/crates/ui-egui/src/control/tests.rs
index ac8fbfa3eb..a0007d0676 100644
--- a/crates/ui-egui/src/control/tests.rs
+++ b/crates/ui-egui/src/control/tests.rs
@@ -415,6 +415,29 @@ fn a_hidden_library_at_the_top_of_the_file_system_keeps_its_shown_id() {
     assert_eq!(docking["result"]["flyout"], "library:swatches:loaded/b.svg", "{docking}");
 }
 
+/// `ui.inspect` shows a recovery folder outside the read root that the status text names (a failed
+/// recovery copy) by its folder name, also in the paths under it: the folder in use, and one a
+/// failure named before the preference moved on. A readable one stays.
+#[test]
+fn a_recovery_folder_outside_the_read_root_is_hidden_in_the_status() {
+    let mut app = VectorcraftApp::new(Session::new(), Services::default());
+    app.session.recovery.set_default_folder(Some("/outside/recovery".into()));
+    let root = crate::tests_folder::Folder::new("recovery-status");
+    let roots = vectorcraft_engine::file_access::AutomationRoots::new(&[root.as_path()], &[]).unwrap();
+    let inspect = |app: &mut VectorcraftApp, status: String| {
+        app.ui.status = status;
+        let reply = vectorcraft_engine::file_access::confine(roots.as_ref(), || input_request(app, "ui.inspect", json!({})));
+        reply["result"]["ui"]["status"].clone()
+    };
+    let status = "Couldn't save recovery data: /outside/recovery/a-1 is not a folder. Copies go to /outside/recovery".to_string();
+    assert_eq!(inspect(&mut app, status), "Couldn't save recovery data: recovery/a-1 is not a folder. Copies go to recovery");
+    let inside = root.as_path().join("copies").to_string_lossy().into_owned();
+    app.session.prefs.recovery_folder = inside.clone();
+    app.recovery.named = vec!["/outside/earlier".into()];
+    assert_eq!(inspect(&mut app, "Copies go to /outside/earlier".into()), "Copies go to earlier");
+    assert_eq!(inspect(&mut app, format!("Copies go to {inside}")), json!(format!("Copies go to {inside}")));
+}
+
 /// A path outside the read root that a request sent is shown by its file name in a reply that succeeded
 /// as in one that failed.
 #[test]
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index 1406d25530..552fbc0c06 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -143,6 +143,7 @@ pub mod trace_presets;
 pub(crate) mod transform;
 pub mod transform_each;
 pub mod variables;
+pub mod warichu;
 mod warp_effect;
 pub mod width_point;
 
@@ -367,6 +368,7 @@ registry! {
     Justification: [justification::KIND] => justification::SPEC,
     BulletsAndNumbering: [bullets_numbering::KIND] => bullets_numbering::SPEC,
     TateChuYokoSettings: [tate_chu_yoko::KIND] => tate_chu_yoko::SPEC,
+    WarichuSettings: [warichu::KIND] => warichu::SPEC,
     CompositeFonts: [composite_fonts::KIND] => composite_fonts::SPEC,
     SavePdf: [save_pdf::KIND] => save_pdf::SPEC,
     SvgOptions: [svg_options::KIND] => svg_options::SPEC,
diff --git a/crates/ui-egui/src/dialogs/command.rs b/crates/ui-egui/src/dialogs/command.rs
index 948b6f990f..cb23628a4c 100644
--- a/crates/ui-egui/src/dialogs/command.rs
+++ b/crates/ui-egui/src/dialogs/command.rs
@@ -65,7 +65,8 @@ pub(super) const SPEC: DialogSpec = DialogSpec {
 /// grid options lists one, and the radial and mirror pages do not. Type on a Path Options does
 /// too (#5360), as public tutorials of the dialog show, and Type Tools › Release Type on a Path
 /// works the same way (#5532), and so do Image Tools › Remove Background and Color Mask and
-/// Cutting Tools › Weed Box and Lines. (Cancel rolls a preview back whichever dialog started it.)
+/// Cutting Tools › Weed Box and Lines and Banner Hems and Grommets. (Cancel rolls a preview back
+/// whichever dialog started it.)
 fn previews(d: &Dialog) -> bool {
     match d.str("__command").as_str() {
         "object.repeat.options" => d.fields.contains_key("gridType"),
@@ -73,7 +74,8 @@ fn previews(d: &Dialog) -> bool {
         | crate::addons::typetools::RELEASE
         | crate::addons::image::REMOVE_BACKGROUND
         | crate::addons::image::COLOR_MASK
-        | crate::addons::cutting::WEED => true,
+        | crate::addons::cutting::WEED
+        | crate::addons::cutting::BANNER => true,
         _ => false,
     }
 }
@@ -120,6 +122,7 @@ fn lengths(command: &str) -> &'static [&'static str] {
         "shape.flare" => &["diameter", "pathLength"],
         "perspective.grid.set" => &["cell", "distance"],
         crate::addons::cutting::WEED => &["margin", "spacing", "gap", "weight"],
+        crate::addons::cutting::BANNER => &["hem", "spacing", "grommetInset", "diameter", "weight"],
         "object.repeat.options" => &["radius", "hSpacing", "vSpacing"],
         "text.areaOptions" => &["width", "height", "gutter", "rowGutter", "inset", "firstBaselineMin", "lineGap"],
         "type.pathOptions" => &["spacing"],
@@ -134,6 +137,9 @@ fn lengths(command: &str) -> &'static [&'static str] {
 fn order(command: &str) -> &'static [&'static str] {
     match command {
         crate::addons::cutting::WEED => &["margin", "box", "direction", "count", "spacing", "gap", "weight", "swatch"],
+        crate::addons::cutting::BANNER => {
+            &["hem", "top", "right", "bottom", "left", "grommets", "spacing", "grommetInset", "diameter", "weight", "swatch"]
+        }
         // The public Trap options' order.
         "object.pathfinder.trap" => &["thickness", "heightWidth", "tintReduction", "trapsWithProcessColor", "reverseTraps"],
         "addon.color.printFixes" => &["inkLimit", "excludePureBlack", "removeWhiteOverprint", "overprintBlack", "textOnly", "fill", "stroke"],
diff --git a/crates/ui-egui/src/dialogs/corners.rs b/crates/ui-egui/src/dialogs/corners.rs
index 939acd9c9e..e5300fe5e4 100644
--- a/crates/ui-egui/src/dialogs/corners.rs
+++ b/crates/ui-egui/src/dialogs/corners.rs
@@ -105,7 +105,7 @@ fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
                 d.fields.insert("radius".into(), json!(n));
             }
         } else {
-            form::length(ui, d, "radius", unit, 120.0);
+            form::length_within(ui, d, "radius", unit, 120.0, Some(0.0..=f64::INFINITY));
         }
         ui.end_row();
     });
diff --git a/crates/ui-egui/src/dialogs/find_links.rs b/crates/ui-egui/src/dialogs/find_links.rs
index 2e99f5e97e..3f9bd56c57 100644
--- a/crates/ui-egui/src/dialogs/find_links.rs
+++ b/crates/ui-egui/src/dialogs/find_links.rs
@@ -11,8 +11,9 @@
 //! in Folder… (`ui.findLinksInFolder`), they stay as they are.
 //!
 //! Fields: `document` (the document's uid), `missing` (`[{name, path, ids}]`), `modified` (the ids
-//! of the images whose file was modified, offered for update afterwards), `back` (the files left
-//! without a choice and those that fail to relink go back to dialog `missingLinks`), `state`
+//! of the images whose file was modified, offered for update afterwards), `notes` (from
+//! `missingLinks`: the open's notes, shown with the line about the modified files), `back` (the
+//! files left without a choice and those that fail to relink go back to dialog `missingLinks`), `state`
 //! (empty, `searching`, `done`, `stopped` or `failed`), `search` (the search's `id`), `folder`,
 //! `found` (`links.findFiles`'s `links`, with the files found), `searched`, `skipped`,
 //! `unreadable`, `stopped`, `error`, `picks` (the file chosen for each row of `missing`, or null),
@@ -66,6 +67,7 @@ fn dialog(app: &VectorcraftApp, missing: Vec<Value>, modified: Vec<Value>, back:
 /// Linked Files, searching `folder` for every file `d` still asks about.
 pub(super) fn from_missing_links(app: &mut VectorcraftApp, d: &mut Dialog, folder: &str) -> Result<(), String> {
     let mut find = dialog(app, rows(d, "missing"), rows(d, "modified"), true)?;
+    find.fields.insert("notes".into(), json!(super::missing_links::notes(d)));
     start_search(app, &mut find, folder)?;
     *d = find;
     Ok(())
@@ -386,7 +388,7 @@ fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
         None => {}
     }
     if d.bool("back") {
-        super::missing_links::ask_next(app, rest, rows(d, "modified"));
+        super::missing_links::ask_next(app, rest, rows(d, "modified"), super::missing_links::notes(d));
     }
     Ok(json!({ "relinked": relinked, "failed": failed }))
 }
diff --git a/crates/ui-egui/src/dialogs/find_links/tests.rs b/crates/ui-egui/src/dialogs/find_links/tests.rs
index 0b618c7e6f..1c79b48ce7 100644
--- a/crates/ui-egui/src/dialogs/find_links/tests.rs
+++ b/crates/ui-egui/src/dialogs/find_links/tests.rs
@@ -126,7 +126,8 @@ fn find_in_folder_relinks_the_missing_files_to_the_files_found() {
 }
 
 /// The files left without a file, or whose file fails to relink, go back to Linked File Not
-/// Found; the failure is named in the status line, and the other files still relink.
+/// Found, with the open's notes; the failure is named in the status line, and the other files
+/// still relink.
 #[test]
 fn files_not_relinked_go_back_to_linked_file_not_found() {
     let root = folder("back");
@@ -134,10 +135,13 @@ fn files_not_relinked_go_back_to_linked_file_not_found() {
     let bytes = opened_without(&mut app, &root, &["a.png", "b.png", "c.png"]);
     write(&at(&root, "found/a.png"), &bytes[0]);
     write(&at(&root, "found/b.png"), b"not an image");
-    app.ui.dialog.as_mut().unwrap().fields.insert("searchFolder".into(), json!(root.join("found")));
+    let missing_links = app.ui.dialog.as_mut().unwrap();
+    missing_links.fields.insert("notes".into(), json!(["a note"]));
+    missing_links.fields.insert("searchFolder".into(), json!(root.join("found")));
     super::super::confirm(&mut app).unwrap();
     searched(&mut app);
     let d = app.ui.dialog.as_ref().unwrap();
+    assert_eq!(d.fields["notes"], json!(["a note"]));
     // b.png's only file is chosen, c.png has none.
     assert_eq!((pick(d, "b.png"), pick(d, "c.png")), (&json!(at(&root, "found/b.png")), &Value::Null));
     assert!(frame(&mut app).contains("Not found"));
@@ -147,6 +151,7 @@ fn files_not_relinked_go_back_to_linked_file_not_found() {
     let names: Vec<&str> = d.fields["missing"].as_array().unwrap().iter().map(|r| r["name"].as_str().unwrap()).collect();
     assert_eq!((d.kind.as_str(), names.len()), (super::super::missing_links::KIND, 2));
     assert!(names.contains(&"b.png") && names.contains(&"c.png"), "{names:?}");
+    assert_eq!(d.fields["notes"], json!(["a note"]));
     super::super::cancel(&mut app);
     assert_eq!(app.run("links.check", json!({})).unwrap()["missing"], 2);
 }
diff --git a/crates/ui-egui/src/dialogs/freehand.rs b/crates/ui-egui/src/dialogs/freehand.rs
index c223c566fd..48f31731cc 100644
--- a/crates/ui-egui/src/dialogs/freehand.rs
+++ b/crates/ui-egui/src/dialogs/freehand.rs
@@ -3,7 +3,7 @@
 //! preferences. OK sets them with `tool.setOption {tool, values}`. The Pencil also has `liveFit`
 //! (Live curve fitting, on: its preview fits the stroke while it is drawn).
 //!
-//! Fields: `tool`; `fidelity` (screen pixels for the Pencil and Paintbrush, points for Smooth and
+//! Fields: `tool`; `fidelity` (screen pixels for the Pencil, Paintbrush and Smooth, points for the
 //! Blob Brush), `fill` (Pencil and
 //! Paintbrush), `keepSelected` (Pencil, Paintbrush and Blob Brush), `mergeOnlySelection` (Blob
 //! Brush), `closeWithin` and `editWithin` (screen pixels, 0 turns it off; Pencil and Paintbrush),
@@ -59,8 +59,8 @@ fn label_w(ui: &egui::Ui) -> f32 {
     CONTENT_W - FIELD_W - ui.spacing().item_spacing.x
 }
 
-/// The top of the Fidelity slider, in the tool's unit (screen pixels for the Pencil and
-/// Paintbrush, points for Smooth and Blob Brush); it starts at the lowest Fidelity the tool takes,
+/// The top of the Fidelity slider, in the tool's unit (screen pixels for the Pencil, Paintbrush
+/// and Smooth, points for the Blob Brush); it starts at the lowest Fidelity the tool takes,
 /// and the field takes up to 100.
 const FIDELITY_MAX: f64 = 20.0;
 
@@ -170,8 +170,9 @@ fn fidelity(ui: &mut egui::Ui, d: &mut Dialog) {
     let v = d.f64("fidelity", 1.5);
     let tool = d.str("tool");
     let rail = (vectorcraft_tools::draw2::min_fidelity(&tool), FIDELITY_MAX);
-    // The Pencil's and the Paintbrush's Fidelity is on screen, the same at any zoom (#5729).
-    let unit = if matches!(tool.as_str(), "pencil" | "paintbrush") { "px" } else { "pt" };
+    // The Pencil's, the Paintbrush's and the Smooth tool's Fidelity is on screen, the same at any
+    // zoom (#5729).
+    let unit = if matches!(tool.as_str(), "pencil" | "paintbrush" | "smooth") { "px" } else { "pt" };
     let rail_w = label_w(ui);
     let mut new = None;
     ui.label(egui::RichText::new(tl!("Fidelity:")).size(12.5).color(t.text));
diff --git a/crates/ui-egui/src/dialogs/missing_links.rs b/crates/ui-egui/src/dialogs/missing_links.rs
index 81a19912a5..70c2370f1b 100644
--- a/crates/ui-egui/src/dialogs/missing_links.rs
+++ b/crates/ui-egui/src/dialogs/missing_links.rs
@@ -8,8 +8,9 @@
 //! [`vectorcraft_engine::link_watch`]).
 //!
 //! Fields: `missing` (`[{name, path, ids}]`, the one asked about first), `modified` (the ids of
-//! images whose file was modified), `applyToAll`, `path` (the replacement file; picked when empty),
-//! `discard` (Ignore) and `searchFolder` (set it and confirm for Find in Folder… on that folder).
+//! images whose file was modified), `notes` (the open's notes, shown with the line about the
+//! modified files), `applyToAll`, `path` (the replacement file; picked when empty), `discard`
+//! (Ignore) and `searchFolder` (set it and confirm for Find in Folder… on that folder).
 
 use serde_json::{Value, json};
 
@@ -41,71 +42,94 @@ fn ids(rows: &[Value]) -> Vec<Value> {
 /// After a document opened (`document.open`'s result `r`): ask about its missing linked files,
 /// then about its modified ones, then about the fonts it opened without
 /// ([`super::missing_fonts`]). The web reads no linked files, so missing ones just show their
-/// previews there.
-pub fn after_open(app: &mut VectorcraftApp, r: &Value) {
+/// previews there. The status bar shows what it says about the linked files followed by the open's
+/// `notes` ([`crate::io::show_opened`]).
+pub fn after_open(app: &mut VectorcraftApp, r: &Value, notes: Vec<String>) {
+    after_open_for(app, r, notes, cfg!(target_arch = "wasm32"));
+}
+
+fn after_open_for(app: &mut VectorcraftApp, r: &Value, notes: Vec<String>, web: bool) {
     // The fonts' dialog waits for these questions (one dialog at a time).
     super::missing_fonts::after_open(app, r);
     let rows = |k: &str| r[k].as_array().cloned().unwrap_or_default();
     let (missing, modified) = (rows("missingLinks"), ids(&rows("modifiedLinks")));
-    if missing.is_empty() || cfg!(target_arch = "wasm32") {
-        if !missing.is_empty() {
-            app.status(crate::i18n::msg_n(
+    let notice = if missing.is_empty() || web {
+        let unreadable = (!missing.is_empty()).then(|| {
+            crate::i18n::msg_n(
                 missing.len() as u64,
                 "{n} linked file can't be read here: its preview shows",
                 "{n} linked files can't be read here: their previews show",
                 &[],
-            ));
-        }
-        ask_update(app, modified);
+            )
+        });
+        ask_update(app, modified).or(unreadable)
     } else {
-        open(app, missing, modified);
-    }
+        open(app, missing, modified, &notes);
+        None
+    };
+    crate::io::show_opened(app, notice, notes);
     super::settle(app);
 }
 
-fn open(app: &mut VectorcraftApp, missing: Vec<Value>, modified: Vec<Value>) {
-    app.ui.dialog = Some(Dialog::new(KIND, json!({ "missing": missing, "modified": modified, "applyToAll": false, "path": "" })));
+fn open(app: &mut VectorcraftApp, missing: Vec<Value>, modified: Vec<Value>, notes: &[String]) {
+    let fields = json!({ "missing": missing, "modified": modified, "notes": notes, "applyToAll": false, "path": "" });
+    app.ui.dialog = Some(Dialog::new(KIND, fields));
+}
+
+/// The open's notes a dialog `d` of the missing linked files keeps (field `notes`).
+pub(super) fn notes(d: &Dialog) -> Vec<String> {
+    let notes = d.fields.get("notes").and_then(Value::as_array).into_iter().flatten();
+    notes.filter_map(Value::as_str).map(str::to_string).collect()
 }
 
 /// Ask about the missing files `rest`, one at a time, then offer the modified ones `modified` for
-/// update.
-pub(super) fn ask_next(app: &mut VectorcraftApp, rest: Vec<Value>, modified: Vec<Value>) {
+/// update. A line about the modified files is followed by the open's `notes`
+/// ([`crate::io::show_opened`]).
+pub(super) fn ask_next(app: &mut VectorcraftApp, rest: Vec<Value>, modified: Vec<Value>, notes: Vec<String>) {
     if rest.is_empty() {
         app.ui.dialog = None;
-        ask_update(app, modified);
+        if let Some(notice) = ask_update(app, modified) {
+            crate::io::show_opened(app, Some(notice), notes);
+        }
     } else {
-        open(app, rest, modified);
+        open(app, rest, modified, &notes);
     }
 }
 
-/// With Update Links: Ask When Modified, offer to read the modified linked files `ids` again.
-fn ask_update(app: &mut VectorcraftApp, ids: Vec<Value>) {
+/// With Update Links: Ask When Modified, offer to read the modified linked files `ids` again;
+/// otherwise → the status bar's line for them ([`changed_on_disk_status`]).
+fn ask_update(app: &mut VectorcraftApp, ids: Vec<Value>) -> Option<String> {
     ask(
         app,
         ids,
         "{n} linked image changed since this document was saved. Show the new version?",
         "{n} linked images changed since this document was saved. Show the new versions?",
-    );
+    )
 }
 
 /// 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, "{n} linked image changed on disk. Show the new version?", "{n} linked images changed on disk. Show the new versions?");
+    let status =
+        ask(app, ids, "{n} linked image changed on disk. Show the new version?", "{n} linked images changed on disk. Show the new versions?");
+    if let Some(status) = status {
+        app.status(status);
+    }
 }
 
-/// Ask about the modified linked files `ids`; `one` and `other` are the English forms of the question.
-fn ask(app: &mut VectorcraftApp, ids: Vec<Value>, one: &str, other: &str) {
+/// Ask about the modified linked files `ids`; `one` and `other` are the English forms of the
+/// question. Without Update Links: Ask When Modified → the status bar's line for them instead.
+fn ask(app: &mut VectorcraftApp, ids: Vec<Value>, one: &str, other: &str) -> Option<String> {
     if ids.is_empty() {
-        return;
+        return None;
     }
     if app.session.prefs.update_links != "askWhenModified" {
-        app.status(changed_on_disk_status(ids.len()));
-        return;
+        return Some(changed_on_disk_status(ids.len()));
     }
     let detail = crate::i18n::tn(ids.len() as u64, one, other);
     super::confirm::ask(app, tl!("Update Modified Links"), &detail, "links.update", json!({ "ids": ids }));
+    None
 }
 
 /// The status bar's line for `n` linked images that changed on disk while Update Links doesn't ask.
@@ -208,7 +232,7 @@ fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
             rest.retain(|row| row["ids"].as_array().is_none_or(|ids| ids.iter().any(|id| !done.contains(id))));
         }
     }
-    ask_next(app, rest, modified);
+    ask_next(app, rest, modified, notes(d));
     Ok(out)
 }
 
@@ -303,6 +327,66 @@ mod tests {
         assert_eq!(question("cs", 5), "Od uložení dokumentu se změnilo 5 propojených obrázků. Zobrazit nové verze?");
     }
 
+    /// On the web, an open with two notes and two linked files it can't read: the status bar says
+    /// so about the files, then counts the notes, and keeps the notes for its hover. Without notes
+    /// the line about the files is shown alone.
+    #[test]
+    fn an_open_with_unreadable_links_keeps_import_notes_reachable() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+        let missing = json!([{ "name": "a.png", "path": "/gone/a.png", "ids": [1] }, { "name": "b.png", "path": "/gone/b.png", "ids": [2] }]);
+        let notes = vec!["a note".to_string(), "another note".to_string()];
+        let r = json!({ "missingLinks": missing, "warnings": notes });
+        after_open_for(&mut app, &r, notes.clone(), true);
+        let notice = "2 linked files can't be read here: their previews show";
+        assert_eq!(app.ui.status, crate::io::opened_after_notice(notice, 2, "a note"));
+        assert_eq!(app.ui.status_notes, Some((app.ui.status.clone(), notes)));
+        assert!(app.ui.dialog.is_none());
+        after_open_for(&mut app, &json!({ "missingLinks": missing }), vec![], true);
+        assert_eq!((app.ui.status.as_str(), &app.ui.status_notes), (notice, &None));
+    }
+
+    /// The line about modified linked files that follows the Linked File Not Found dialog keeps the
+    /// notes of that open, also when another message was shown meanwhile. An open without notes
+    /// shows the line alone, even while the status bar shows an earlier open's notes, and a later
+    /// line about files changed on disk while the document is open doesn't take them.
+    #[test]
+    fn modified_links_after_the_missing_ones_keep_the_open_notes() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+        app.session.prefs.update_links = "manually".into();
+        let notes = vec!["a note".to_string(), "another note".to_string()];
+        let links = json!({
+            "missingLinks": [{ "name": "a.png", "path": "/gone/a.png", "ids": [1] }],
+            "modifiedLinks": [{ "ids": [2] }],
+        });
+        let ignore = |app: &mut VectorcraftApp| {
+            app.ui.dialog.as_mut().unwrap().fields.insert("discard".into(), json!(true));
+            super::super::confirm(app).unwrap();
+            assert!(app.ui.dialog.is_none());
+        };
+        after_open_for(&mut app, &links, notes.clone(), false);
+        assert_eq!(app.ui.dialog.as_ref().map(|d| d.kind.as_str()), Some(KIND));
+        assert_eq!(app.ui.status, crate::io::opened_with_notes(2, "a note"));
+        app.status("Relinked 1 image");
+        ignore(&mut app);
+        assert_eq!(app.ui.status, crate::io::opened_after_notice(&changed_on_disk_status(1), 2, "a note"));
+        assert_eq!(app.ui.status_notes, Some((app.ui.status.clone(), notes.clone())));
+
+        crate::io::show_opened(&mut app, None, notes);
+        after_open_for(&mut app, &links, vec![], false);
+        ignore(&mut app);
+        assert_eq!((app.ui.status.clone(), &app.ui.status_notes), (changed_on_disk_status(1), &None));
+
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            crate::io::show_opened(&mut app, None, vec!["a note".to_string(), "another note".to_string()]);
+            ask_update_changed(&mut app, vec![json!(2)]);
+            assert_eq!(app.ui.status, changed_on_disk_status(1));
+            assert_ne!(app.ui.status_notes.as_ref().map(|(status, _)| status), Some(&app.ui.status));
+        }
+    }
+
     #[test]
     fn apply_to_all_replaces_the_others_from_the_same_folder() {
         let (mut app, dir, _) = opened_without_links("all");
diff --git a/crates/ui-egui/src/dialogs/save_pdf/tests.rs b/crates/ui-egui/src/dialogs/save_pdf/tests.rs
index fda9e78cc5..dbceed5881 100644
--- a/crates/ui-egui/src/dialogs/save_pdf/tests.rs
+++ b/crates/ui-egui/src/dialogs/save_pdf/tests.rs
@@ -244,8 +244,9 @@ fn summary_warnings_are_translated() {
 }
 
 /// The warnings and the error for a page longer than 14,400 pt are translated: a PDF 1.5 file
-/// written as PDF 1.6, a page with a `UserUnit`, a PDF/X-4 page in points, a refused PDF/X-1a
-/// file and a page too narrow for the `UserUnit` its long side needs.
+/// written as PDF 1.6, a page with a `UserUnit` with the option that writes it in points, a
+/// PDF/X-4 page in points, a refused PDF/X-1a file and a page too narrow for the `UserUnit` its
+/// long side needs.
 #[test]
 fn long_page_notes_are_translated() {
     let mut s = Session::new();
@@ -262,7 +263,14 @@ fn long_page_notes_are_translated() {
     let warnings = r["warnings"].as_array().unwrap().iter().filter_map(|w| w.as_str());
     notes.extend(warnings.filter(|w| w.contains("too long and narrow")).map(str::to_string));
     assert_eq!(notes.len(), 5, "{notes:?}");
-    let english = ["has no UserUnit, which", "apps that ignore UserUnit", "apps that keep to the limit", "real numbers up to", "too long and narrow"];
+    let english = [
+        "has no UserUnit, which",
+        "apps that ignore UserUnit",
+        "apps that keep to the limit",
+        "real numbers up to",
+        "too long and narrow",
+        "turn on",
+    ];
     for code in ["de", "fr", "ja", "zh-hans"] {
         let lang = crate::i18n::Lang::from_code(code).unwrap();
         for note in &notes {
diff --git a/crates/ui-egui/src/dialogs/tests.rs b/crates/ui-egui/src/dialogs/tests.rs
index 55cf45ce2f..3ce5455437 100644
--- a/crates/ui-egui/src/dialogs/tests.rs
+++ b/crates/ui-egui/src/dialogs/tests.rs
@@ -2290,7 +2290,13 @@ fn dialog_sliders_report_the_numbers_their_fields_show() {
     app.run("tool.options", json!({"tool": "smooth"})).unwrap();
     set(&mut app, "fidelity", json!(0.25));
     let shown = tree(|ui| show(&mut app, ui.ctx()));
-    assert_eq!(slider_value(&shown, "Fidelity:"), v(0.25, (0.05, 20.0), "0.25pt"));
+    assert_eq!(slider_value(&shown, "Fidelity:"), v(0.25, (0.05, 20.0), "0.25px"), "the Smooth tool's Fidelity is on screen (#4671)");
+    // The Blob Brush's Fidelity is in points.
+    app.ui.dialog = None;
+    app.run("tool.options", json!({"tool": "blobBrush"})).unwrap();
+    set(&mut app, "fidelity", json!(2.5));
+    let shown = tree(|ui| show(&mut app, ui.ctx()));
+    assert_eq!(slider_value(&shown, "Fidelity:"), v(2.5, (0.01, 20.0), "2.5pt"));
     app.ui.dialog = None;
     app.run("paint.setFill", json!({"color": "#ff8000"})).unwrap();
     app.run("ui.colorPicker", json!({})).unwrap();
diff --git a/crates/ui-egui/src/dialogs/warichu.rs b/crates/ui-egui/src/dialogs/warichu.rs
new file mode 100644
index 0000000000..156d10e596
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/warichu.rs
@@ -0,0 +1,305 @@
+//! Character panel menu › Warichu Settings… (or `ui.warichuSettings`): the Lines, Line Gap,
+//! Scale and Alignment of the characters the Character panel acts on, which set how a block of
+//! warichu characters is stacked inside its line. The dialog opens on the values the selected
+//! characters share (a blank field where they differ). OK runs `text.setFormat`
+//! (`text.setRangeStyle` while the Type tool edits text) with the values that changed, as one undo
+//! step; characters that differ keep a value left blank. It does not turn Warichu on or off.
+//!
+//! Fields: `warichuLines` (1..6), `warichuGap` (pt, 0..100), `warichuScale` (%, 10..100) and
+//! `warichuAlign`, as `text.setFormat` takes them, and `__initial` (the values it opened with).
+//!
+//! Behavior reference (public documentation):
+//! <https://helpx.adobe.com/illustrator/using/formatting-asian-characters.html>.
+
+use serde_json::{Map, Value, json};
+use vectorcraft_doc::WarichuAlign;
+use vectorcraft_doc::text::{MAX_WARICHU_GAP, WARICHU_LINES, WARICHU_SCALE};
+
+use super::swatch_options::{grid, label};
+use super::{DialogSpec, form};
+use crate::VectorcraftApp;
+use crate::state::Dialog;
+
+/// The dialog kind of Warichu Settings.
+pub const KIND: &str = "warichuSettings";
+
+/// The field holding the values the dialog opened with.
+const INITIAL: &str = "__initial";
+
+/// The fields, as `text.setFormat` names them.
+const KEYS: [&str; 4] = ["warichuLines", "warichuGap", "warichuScale", "warichuAlign"];
+
+/// The Alignment choices, by the value `text.setFormat` takes and their label.
+fn aligns() -> [(&'static str, &'static str); 8] {
+    WarichuAlign::ALL.map(|a| {
+        let label = match a {
+            WarichuAlign::Auto => tl!("Auto"),
+            WarichuAlign::Left => tl!("Align left"),
+            WarichuAlign::Center => tl!("Align center"),
+            WarichuAlign::Right => tl!("Align right"),
+            WarichuAlign::JustifyLeft => tl!("Justify with last line aligned left"),
+            WarichuAlign::JustifyCenter => tl!("Justify with last line aligned center"),
+            WarichuAlign::JustifyRight => tl!("Justify with last line aligned right"),
+            WarichuAlign::JustifyAll => tl!("Justify all lines"),
+        };
+        (a.id(), label)
+    })
+}
+
+pub(super) const SPEC: DialogSpec = DialogSpec {
+    heading: |_| tl!("Warichu Settings").into(),
+    body,
+    confirm,
+    min_width: 360.0,
+    // A value the characters don't share opens blank, without its field.
+    inputs: |_| &KEYS,
+    ..DialogSpec::FORM
+};
+
+/// Open Warichu Settings on the characters the Character panel acts on.
+pub fn open(app: &mut VectorcraftApp) -> Result<Value, String> {
+    crate::panels::character::text_style(app).ok_or("select some type first")?;
+    let shared = crate::panels::character::shared_warichu(app);
+    let mut values = Map::new();
+    if let Some(v) = shared.lines {
+        values.insert("warichuLines".into(), json!(v));
+    }
+    if let Some(v) = shared.gap {
+        values.insert("warichuGap".into(), json!(v));
+    }
+    if let Some(v) = shared.scale {
+        values.insert("warichuScale".into(), json!(v));
+    }
+    if let Some(v) = shared.align {
+        values.insert("warichuAlign".into(), json!(v.id()));
+    }
+    let mut fields = Value::Object(values.clone());
+    fields[INITIAL] = Value::Object(values);
+    app.ui.dialog = Some(Dialog::new(KIND, fields));
+    Ok(Value::Null)
+}
+
+fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
+    let unit = app.session.type_unit();
+    let lines = f64::from(*WARICHU_LINES.start())..=f64::from(*WARICHU_LINES.end());
+    grid(ui, |ui| {
+        label(ui, tl!("Lines:"));
+        let value = d.fields.get("warichuLines").and_then(Value::as_f64);
+        if let Some(n) = crate::widgets::range_field(ui, ("warichu", "warichuLines"), value, lines, "", 0, 60.0) {
+            d.fields.insert("warichuLines".into(), json!(n));
+        }
+        ui.end_row();
+        label(ui, tl!("Line Gap:"));
+        form::length_within(ui, d, "warichuGap", unit, 90.0, Some(0.0..=MAX_WARICHU_GAP));
+        ui.end_row();
+        label(ui, tl!("Scale:"));
+        let value = d.fields.get("warichuScale").and_then(Value::as_f64);
+        if let Some(n) = crate::widgets::range_field(ui, ("warichu", "warichuScale"), value, WARICHU_SCALE, "%", 1, 70.0) {
+            d.fields.insert("warichuScale".into(), json!(n));
+        }
+        ui.end_row();
+        label(ui, tl!("Alignment:"));
+        let current = d.str("warichuAlign");
+        let options = aligns();
+        let shown = options.iter().find(|(id, _)| *id == current).map_or("", |(_, l)| l);
+        let labels: Vec<&str> = options.iter().map(|(_, l)| *l).collect();
+        if let Some((id, _)) = crate::widgets::dropdown_names(ui, "warichuAlign", shown, &labels, 240.0).and_then(|i| options.get(i)) {
+            d.fields.insert("warichuAlign".into(), json!(id));
+        }
+        ui.end_row();
+    });
+    false
+}
+
+/// A number field's value: a number, or a string that reads as one (`"3"`, `"40%"`); `None` for a
+/// blank field. `Err` names the field when it holds anything else.
+fn number(d: &Dialog, key: &str, name: &str) -> Result<Option<f64>, String> {
+    let v = match d.fields.get(key) {
+        None | Some(Value::Null) => return Ok(None),
+        Some(Value::String(s)) if s.trim().is_empty() => return Ok(None),
+        Some(Value::Number(n)) => n.as_f64(),
+        Some(Value::String(s)) => s.trim().trim_end_matches('%').trim().parse::<f64>().ok(),
+        Some(_) => None,
+    };
+    v.filter(|v| v.is_finite()).map(Some).ok_or_else(|| format!("{name} must be a number"))
+}
+
+/// `text.setFormat` parameters: the fields that differ from the values the dialog opened with.
+/// Lines is rounded to a whole number and kept within 1..6, Line Gap is in points (a length typed
+/// with its unit, "1 mm", is converted) and kept within 0..100, and Scale is kept within 10..100.
+/// A blank field is left alone; a field that is not a number is an error. A number is compared
+/// with the value the dialog opened with before it is rounded or kept within its range, so OK
+/// leaves a value outside the range (Line Gap on a scaled object) as it is when it was not edited.
+fn params(d: &Dialog) -> Result<Map<String, Value>, String> {
+    let initial = d.fields.get(INITIAL).and_then(Value::as_object);
+    let unchanged = |key: &str, v: &Value| initial.and_then(|m| m.get(key)) == Some(v);
+    let opened_with = |key: &str, v: f64| initial.and_then(|m| m.get(key)).and_then(Value::as_f64) == Some(v);
+    let mut p = Map::new();
+    if let Some(n) = number(d, "warichuLines", "Lines")?.filter(|&n| !opened_with("warichuLines", n)) {
+        let n = n.round().clamp(f64::from(*WARICHU_LINES.start()), f64::from(*WARICHU_LINES.end()));
+        // Within 1..6 after the clamp, so the cast keeps the value.
+        let v = json!(n as u8);
+        if !unchanged("warichuLines", &v) {
+            p.insert("warichuLines".into(), v);
+        }
+    }
+    let gap = match d.fields.get("warichuGap") {
+        None | Some(Value::Null) => None,
+        Some(Value::String(s)) if s.trim().is_empty() => None,
+        Some(Value::Number(n)) => Some(n.as_f64().filter(|v| v.is_finite()).ok_or("Line Gap must be a number")?),
+        Some(Value::String(s)) => Some(vectorcraft_doc::Unit::Points.parse(s).filter(|v| v.is_finite()).ok_or("Line Gap must be a number")?),
+        Some(_) => return Err("Line Gap must be a number".into()),
+    };
+    if let Some(v) = gap.filter(|&v| !opened_with("warichuGap", v)).map(|v| v.clamp(0.0, MAX_WARICHU_GAP))
+        && !opened_with("warichuGap", v)
+    {
+        p.insert("warichuGap".into(), json!(v));
+    }
+    if let Some(n) = number(d, "warichuScale", "Scale")?.filter(|&n| !opened_with("warichuScale", n)) {
+        let v = n.clamp(*WARICHU_SCALE.start(), *WARICHU_SCALE.end());
+        if !opened_with("warichuScale", v) {
+            p.insert("warichuScale".into(), json!(v));
+        }
+    }
+    match d.fields.get("warichuAlign") {
+        None | Some(Value::Null) => {}
+        Some(Value::String(s)) if s.is_empty() => {}
+        Some(Value::String(s)) if WarichuAlign::from_id(s).is_some() => {
+            let v = json!(s);
+            if !unchanged("warichuAlign", &v) {
+                p.insert("warichuAlign".into(), v);
+            }
+        }
+        Some(_) => return Err("Alignment must be one of the choices".into()),
+    }
+    Ok(p)
+}
+
+fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
+    let p = params(d)?;
+    app.ui.dialog = None;
+    if p.is_empty() {
+        return Ok(Value::Null);
+    }
+    crate::panels::character::run_format(app, Value::Object(p))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use vectorcraft_engine::Session;
+    use vectorcraft_engine::doc::{NodeId, NodeKind};
+
+    /// A selected point type object with four characters.
+    fn app() -> (VectorcraftApp, u64) {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 400, "height": 400})).unwrap();
+        let id = app.run("text.create", json!({"x": 10, "y": 50, "text": "abcd"})).unwrap()["id"].as_u64().unwrap();
+        app.run("select.set", json!({"ids": [id]})).unwrap();
+        (app, id)
+    }
+
+    /// (warichu, Lines, Line Gap, Scale, Alignment) of each run.
+    fn settings(app: &VectorcraftApp, id: u64) -> Vec<(bool, u8, f64, f64, WarichuAlign)> {
+        match &app.session.active().unwrap().doc.node(NodeId(id)).unwrap().kind {
+            NodeKind::Text(t) => t
+                .runs
+                .iter()
+                .map(|r| (r.style.warichu, r.style.warichu_lines, r.style.warichu_gap, r.style.warichu_scale, r.style.warichu_align))
+                .collect(),
+            _ => panic!("not text"),
+        }
+    }
+
+    /// `ui.warichuSettings` opens on the characters' values; OK sets the changed ones in one undo
+    /// step without turning Warichu on, a length typed with its unit is converted to points, and
+    /// values past the ends are kept to them.
+    #[test]
+    fn warichu_settings_dialog_sets_lines_gap_scale_and_alignment() {
+        let (mut app, id) = app();
+        app.run("ui.warichuSettings", json!({})).unwrap();
+        let d = app.ui.dialog.clone().expect("Warichu Settings opened");
+        assert_eq!(d.kind, KIND);
+        assert_eq!((d.f64("warichuLines", 0.0), d.f64("warichuGap", -1.0), d.f64("warichuScale", 0.0)), (2.0, 0.0, 50.0));
+        assert_eq!(d.str("warichuAlign"), "auto");
+        let d = app.ui.dialog.as_mut().unwrap();
+        d.fields.insert("warichuLines".into(), json!(3));
+        d.fields.insert("warichuGap".into(), json!("0.5 in"));
+        d.fields.insert("warichuScale".into(), json!(400));
+        d.fields.insert("warichuAlign".into(), json!("center"));
+        let undo = app.session.active().unwrap().history.undo.len();
+        super::super::confirm(&mut app).unwrap();
+        assert!(app.ui.dialog.is_none());
+        assert_eq!(settings(&app, id), [(false, 3, 36.0, 100.0, WarichuAlign::Center)]);
+        assert_eq!(app.session.active().unwrap().history.undo.len(), undo + 1);
+        // It opens on the values set, and OK with nothing changed adds no undo step.
+        app.run("ui.warichuSettings", json!({})).unwrap();
+        let d = app.ui.dialog.clone().unwrap();
+        assert_eq!((d.f64("warichuLines", 0.0), d.f64("warichuGap", 0.0), d.f64("warichuScale", 0.0)), (3.0, 36.0, 100.0));
+        super::super::confirm(&mut app).unwrap();
+        assert_eq!(app.session.active().unwrap().history.undo.len(), undo + 1);
+        // With no type selected the dialog does not open.
+        app.run("select.set", json!({"ids": []})).unwrap();
+        assert!(app.run("ui.warichuSettings", json!({})).is_err());
+        assert!(app.ui.dialog.is_none());
+    }
+
+    /// A value it opened with outside its range (Line Gap of 200 pt on an object scaled by 2) is
+    /// left alone when OK is pressed without editing it; an edited one is kept within the range.
+    #[test]
+    fn warichu_settings_dialog_leaves_an_unedited_value_outside_its_range() {
+        let opened = json!({"warichuLines": 9, "warichuGap": 200.0, "warichuScale": 5.0});
+        let mut fields = opened.clone();
+        fields[INITIAL] = opened;
+        let mut d = Dialog::new(KIND, fields);
+        assert_eq!(params(&d), Ok(Map::new()));
+        d.fields.insert("warichuGap".into(), json!(150.0));
+        assert_eq!(params(&d).unwrap().get("warichuGap"), Some(&json!(MAX_WARICHU_GAP)));
+    }
+
+    /// Characters that differ open a blank field; OK leaves that value alone and sets the others.
+    #[test]
+    fn warichu_settings_dialog_leaves_mixed_values_blank() {
+        let (mut app, id) = app();
+        app.run("text.setRangeStyle", json!({"id": id, "start": 0, "end": 2, "warichuLines": 4})).unwrap();
+        app.run("ui.warichuSettings", json!({})).unwrap();
+        let d = app.ui.dialog.clone().unwrap();
+        assert!(!d.fields.contains_key("warichuLines"));
+        assert_eq!(d.f64("warichuScale", 0.0), 50.0);
+        app.ui.dialog.as_mut().unwrap().fields.insert("warichuScale".into(), json!(60));
+        super::super::confirm(&mut app).unwrap();
+        assert_eq!(settings(&app, id), [(false, 4, 0.0, 60.0, WarichuAlign::Auto), (false, 2, 0.0, 60.0, WarichuAlign::Auto)]);
+    }
+
+    /// OK with a value that is not a number returns an error naming the field, keeps the dialog
+    /// open and leaves the characters alone.
+    #[test]
+    fn warichu_settings_dialog_rejects_a_value_that_is_not_a_number() {
+        let (mut app, id) = app();
+        for (key, bad, message) in [
+            ("warichuLines", json!("two"), "Lines must be a number"),
+            ("warichuGap", json!("wide"), "Line Gap must be a number"),
+            ("warichuScale", json!(true), "Scale must be a number"),
+            ("warichuAlign", json!("sideways"), "Alignment must be one of the choices"),
+        ] {
+            app.run("ui.warichuSettings", json!({})).unwrap();
+            app.ui.dialog.as_mut().unwrap().fields.insert(key.into(), bad);
+            assert_eq!(super::super::confirm(&mut app), Err(message.to_string()));
+            assert!(app.ui.dialog.is_some());
+            assert_eq!(settings(&app, id), [(false, 2, 0.0, 50.0, WarichuAlign::Auto)]);
+            app.ui.dialog = None;
+        }
+    }
+
+    /// While the Type tool edits text, OK sets the selected characters.
+    #[test]
+    fn warichu_settings_dialog_sets_the_range_the_type_tool_selects() {
+        let (mut app, id) = app();
+        app.session.select_tool("type", Default::default()).unwrap();
+        app.session.set_tool_option("textSelection", &json!({"editing": id, "anchor": 0, "caret": 2}));
+        app.run("ui.warichuSettings", json!({})).unwrap();
+        app.ui.dialog.as_mut().unwrap().fields.insert("warichuAlign".into(), json!("justifyAll"));
+        assert!(super::super::confirm(&mut app).is_ok());
+        assert_eq!(settings(&app, id), [(false, 2, 0.0, 50.0, WarichuAlign::JustifyAll), (false, 2, 0.0, 50.0, WarichuAlign::Auto)]);
+    }
+}
diff --git a/crates/ui-egui/src/edit_toolbar/tests.rs b/crates/ui-egui/src/edit_toolbar/tests.rs
index cac6338418..c38cde007e 100644
--- a/crates/ui-egui/src/edit_toolbar/tests.rs
+++ b/crates/ui-egui/src/edit_toolbar/tests.rs
@@ -648,6 +648,7 @@ fn addon_tools_are_in_the_drawer_not_the_toolbars() {
             "cornerTool",
             "slideAnchor",
             "sharedEdge",
+            "trimAtCrossings",
             "smartPen",
             enclosing,
             contour,
@@ -663,7 +664,7 @@ fn addon_tools_are_in_the_drawer_not_the_toolbars() {
     let listed = |id: &str| {
         sections().iter().find(|(_, tools)| tools.iter().any(|t| t.id == id)).map(|(h, tools)| (*h, tools.iter().map(|t| t.id).collect::<Vec<_>>()))
     };
-    assert_eq!(listed("extendPath"), Some(("Path Precision Tools", addon[..7].to_vec())));
+    assert_eq!(listed("extendPath"), Some(("Path Precision Tools", addon[..8].to_vec())));
     assert_eq!(listed("smartPen"), Some(("Smart Pen", vec!["smartPen"])));
     assert_eq!(listed(enclosing), Some(("Enclosing Lasso", vec![enclosing])));
     assert_eq!(listed(contour), Some(("Contour", vec![contour])));
diff --git a/crates/ui-egui/src/font_menu.rs b/crates/ui-egui/src/font_menu.rs
index c7a74e3178..554eb9229f 100644
--- a/crates/ui-egui/src/font_menu.rs
+++ b/crates/ui-egui/src/font_menu.rs
@@ -1642,18 +1642,20 @@ pub(crate) fn render_sample_for_test(family: &str, text: &str, px: u32) -> Optio
 }
 
 /// Waits for the samples rendering on this thread's behalf and keeps them, so the next frame
-/// draws them.
+/// draws them. Returns `false` when no sample was rendering.
 #[cfg(all(test, not(target_arch = "wasm32")))]
-pub(crate) fn wait_for_samples(ctx: &egui::Context) {
+pub(crate) fn wait_for_samples(ctx: &egui::Context) -> bool {
     SAMPLES.with(|s| {
         let mut s = s.borrow_mut();
         let pending: Vec<_> = s.pending.drain().collect();
+        let waited = !pending.is_empty();
         for (key, rx) in pending {
             let tex =
                 rx.recv().ok().flatten().map(|img| ctx.load_texture(format!("font-sample-{}-{}", key.0, key.3), img, egui::TextureOptions::LINEAR));
             s.ready.insert(key, tex);
         }
-    });
+        waited
+    })
 }
 
 // ---------- applying a pick ----------
diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs
index a6bacfc1d7..9d15012784 100644
--- a/crates/ui-egui/src/i18n.rs
+++ b/crates/ui-egui/src/i18n.rs
@@ -688,7 +688,7 @@ fn message_at(lang: Lang, s: &str, depth: usize) -> String {
 
 /// Fill `{name}` placeholders in one pass: a value that holds `{name}` text stays as it is.
 /// Unknown placeholders are left as written. `{{` and `}}` are a literal `{` and `}`.
-fn fill_once(template: &str, args: &[(&str, &str)]) -> String {
+pub(crate) fn fill_once(template: &str, args: &[(&str, &str)]) -> String {
     let mut rest = template;
     let mut out = String::with_capacity(rest.len());
     while let Some(open) = rest.find(['{', '}']) {
diff --git a/crates/ui-egui/src/i18n/bg.tsv b/crates/ui-egui/src/i18n/bg.tsv
index 1b9eecde9e..4a79f37e72 100644
--- a/crates/ui-egui/src/i18n/bg.tsv
+++ b/crates/ui-egui/src/i18n/bg.tsv
@@ -2120,6 +2120,29 @@ font-technology	Variable	Променливи
 	Bristle Brush	Четка с косъм
 	Pattern Brush	Четка с мостра
 	missing from the Brushes panel	липсва в панела „Четки“
+	built in	вграден
+	embedding not allowed	вграждането не е разрешено
+	embedding for editing	вграждане за редактиране
+	embedding for preview and print	вграждане за преглед и печат
+	embedding allowed	вграждането е разрешено
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	заместен: показан с {family} {style} ({detail})
+	missing: shown in {family} {style}	липсва: показан с {family} {style}
+	missing	липсва
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Линеен градиент
+	Radial gradient	Радиален градиент
+	Conic gradient	Конусен градиент
+	Diamond gradient	Ромбовиден градиент
+	Freeform gradient	Градиент със свободна форма
+@plural	{n} instance|{n} instances	{n} екземпляр|{n} екземпляра
+@plural	{n} row|{n} rows	{n} ред|{n} реда
+@plural	{n} column|{n} columns	{n} колона|{n} колони
 	Select art to make a scatter, art or pattern brush.	Изберете графика, за да създадете разпръсната четка, артистична четка или четка с мостра.
 	Brush Art	Графика на четка
 	New Calligraphic Brush	Нова калиграфска четка
@@ -3552,6 +3575,11 @@ digits	Malayalam	Малаялам
 	Tate-chu-yoko	Тате-чу-йоко
 	Tate-chu-yoko Settings…	Настройки на Тате-чу-йоко…
 	Tate-chu-yoko Settings	Настройки на Тате-чу-йоко
+	Warichu	Варичу
+	Warichu Settings…	Настройки на Варичу…
+	Warichu Settings	Настройки на Варичу
+	Lines:	Редове:
+	Line Gap:	Разстояние между редовете:
 	Composite Fonts…	Съставни шрифтове…
 	Composite Fonts	Съставни шрифтове
 	Export Composite Fonts	Експортиране на съставни шрифтове
@@ -4142,6 +4170,10 @@ axis	Both	И двете
 @msg	Couldn't paste: the document it was pasted in was reverted	Неуспешно поставяне: документът, в който се поставяше, е върнат към запазеното
 @msg	Couldn't read {name}: {e}	Неуспешно четене на {name}: {e}
 @msg	Couldn't save recovery data: {e}	Неуспешно запазване на данните за възстановяване: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Неуспешно запазване на данните за възстановяване на {title}: {e}. Копията се записват в {folder}, папката за възстановяване по подразбиране; за да използвате друга папка, задайте Предпочитания → Работа с файлове → Възстановяване на данни → Папка (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Неуспешно запазване на данните за възстановяване на {title}: {e}. Копията се записват в {folder}, папката, зададена в Предпочитания; за да използвате друга папка, задайте Предпочитания → Работа с файлове → Възстановяване на данни → Папка (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Неуспешно запазване на данните за възстановяване: {e}. Копията се записват в {folder}, папката за възстановяване по подразбиране; за да използвате друга папка, задайте Предпочитания → Работа с файлове → Възстановяване на данни → Папка (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Неуспешно запазване на данните за възстановяване: {e}. Копията се записват в {folder}, папката, зададена в Предпочитания; за да използвате друга папка, задайте Предпочитания → Работа с файлове → Възстановяване на данни → Папка (recoveryFolder)
 @msg	Create Outlines: select text objects	Създаване на контури: изберете текстови обекти
 @msg	Create from Guides: the document has no artboard	Създаване от водачи: документът няма работна област
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Създаване от водачи: водачите правят повече от {MAX_PIECES} парчета
@@ -4751,6 +4783,7 @@ axis	Both	И двете
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Изхвърлен е {n} възстановен документ|Изхвърлени са {n} възстановени документа
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Възстановен е {n} документ: запазете го, за да го съхраните|Възстановени са {n} документа: запазете ги, за да ги съхраните
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Отворено с {n} бележка: {first}|Отворено с {n} бележки: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Отворено с {n} бележка: {first}|{notice}. Отворено с {n} бележки: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	{path} е запазен с {n} бележка: {first}|{path} е запазен с {n} бележки: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	Вградено е {n} изображение; {missing} липсват: първо ги свържете наново|Вградени са {n} изображения; {missing} липсват: първо ги свържете наново
 @msgplural	Embedded {n} image|Embedded {n} images	Вградено е {n} изображение|Вградени са {n} изображения
@@ -6308,6 +6341,8 @@ anchor	Points:	Точки:
 	Anchor Inspector	Инспектор на опорни точки
 	Add Points at Crossings	Добавяне на точки в пресичанията
 	Split at Crossings	Разделяне в пресичанията
+	Trim at Crossings Tool	Инструмент „Подрязване в пресичанията“
+	Trim at Crossings	Подрязване в пресичанията
 	Extend Path	Удължаване на път
 	Measure & Inspect	Измерване и проверка
 	Set Anchor	Задаване на опорна точка
@@ -6837,3 +6872,9 @@ breakText	Glyphs	Глифи
 	Box	Рамка
 	Swatch	Образец
 	Direction	Посока
+	Banner Hems and Grommets…	Подгъви и капси за банер…
+	Banner Hems and Grommets	Подгъви и капси за банер
+	Hem	Подгъв
+	Grommets	Капси
+	Grommet Inset	Отстъп на капсите от ръба
+	Diameter	Диаметър
diff --git a/crates/ui-egui/src/i18n/bs.tsv b/crates/ui-egui/src/i18n/bs.tsv
index cdd29cd330..5982685036 100644
--- a/crates/ui-egui/src/i18n/bs.tsv
+++ b/crates/ui-egui/src/i18n/bs.tsv
@@ -1607,6 +1607,11 @@ digits	Malayalam	Malajalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Postavke za Tate-chu-yoko…
 	Tate-chu-yoko Settings	Postavke za Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Postavke za Warichu…
+	Warichu Settings	Postavke za Warichu
+	Lines:	Redovi:
+	Line Gap:	Razmak između redova:
 	Composite Fonts…	Kompozitni fontovi…
 	Composite Fonts	Kompozitni fontovi
 	Export Composite Fonts	Izvezi kompozitne fontove
@@ -3351,6 +3356,29 @@ theme	Appearance	Izgled
 	Bristle Brush	Četkica s čekinjama
 	Pattern Brush	Četkica uzorka
 	missing from the Brushes panel	nedostaje u panelu Četkice
+	built in	ugrađen
+	embedding not allowed	ugrađivanje nije dozvoljeno
+	embedding for editing	ugrađivanje za uređivanje
+	embedding for preview and print	ugrađivanje za pregled i štampu
+	embedding allowed	ugrađivanje dozvoljeno
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	zamijenjen: prikazan fontom {family} {style} ({detail})
+	missing: shown in {family} {style}	nedostaje: prikazan fontom {family} {style}
+	missing	nedostaje
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Linearni gradijent
+	Radial gradient	Radijalni gradijent
+	Conic gradient	Konusni gradijent
+	Diamond gradient	Rombni gradijent
+	Freeform gradient	Gradijent slobodnog oblika
+@plural	{n} instance|{n} instances	{n} instanca|{n} instance|{n} instanci
+@plural	{n} row|{n} rows	{n} red|{n} reda|{n} redova
+@plural	{n} column|{n} columns	{n} kolona|{n} kolone|{n} kolona
 	Select art to make a scatter, art or pattern brush.	Odaberite crtež da napravite raspršenu, umjetničku četkicu ili četkicu uzorka.
 	Brush Art	Crtež četkice
 	New Symbol	Novi simbol
@@ -4506,6 +4534,10 @@ imageTrace	Outline	Obris
 @msg	Couldn't paste: the document it was pasted in was reverted	Nije moguće zalijepiti: dokument u koji se lijepilo je vraćen na sačuvano
 @msg	Couldn't read {name}: {e}	Nije moguće pročitati {name}: {e}
 @msg	Couldn't save recovery data: {e}	Nije moguće sačuvati podatke za oporavak: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Nije moguće sačuvati podatke za oporavak za {title}: {e}. Kopije se čuvaju u {folder}, zadanom folderu za oporavak; da biste koristili drugi folder, postavite Postavke → Rukovanje datotekama → Oporavak podataka → Folder (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Nije moguće sačuvati podatke za oporavak za {title}: {e}. Kopije se čuvaju u {folder}, folderu postavljenom u Postavkama; da biste koristili drugi folder, postavite Postavke → Rukovanje datotekama → Oporavak podataka → Folder (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Nije moguće sačuvati podatke za oporavak: {e}. Kopije se čuvaju u {folder}, zadanom folderu za oporavak; da biste koristili drugi folder, postavite Postavke → Rukovanje datotekama → Oporavak podataka → Folder (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Nije moguće sačuvati podatke za oporavak: {e}. Kopije se čuvaju u {folder}, folderu postavljenom u Postavkama; da biste koristili drugi folder, postavite Postavke → Rukovanje datotekama → Oporavak podataka → Folder (recoveryFolder)
 @msg	Create Outlines: select text objects	Kreiraj obrise: odaberite tekstualne objekte
 @msg	Create from Guides: the document has no artboard	Kreiraj iz vodilica: dokument nema radnu ploču
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Kreiraj iz vodilica: vodilice prave više od {MAX_PIECES} isječaka
@@ -5156,6 +5188,7 @@ imageTrace	Outline	Obris
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Odbačen {n} oporavljeni dokument|Odbačena {n} oporavljena dokumenta|Odbačeno {n} oporavljenih dokumenata
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Vraćen {n} oporavljeni dokument; sačuvajte ga da ga zadržite|Vraćena {n} oporavljena dokumenta; sačuvajte ih da ih zadržite|Vraćeno {n} oporavljenih dokumenata; sačuvajte ih da ih zadržite
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Otvoreno s {n} bilješkom: {first}|Otvoreno s {n} bilješke: {first}|Otvoreno s {n} bilješki: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Otvoreno s {n} bilješkom: {first}|{notice}. Otvoreno s {n} bilješke: {first}|{notice}. Otvoreno s {n} bilješki: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	Sačuvano {path} s {n} bilješkom: {first}|Sačuvano {path} s {n} bilješke: {first}|Sačuvano {path} s {n} bilješki: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	Ugrađena je {n} slika; nedostaje {missing}: prvo ih ponovo povežite|Ugrađene su {n} slike; nedostaje {missing}: prvo ih ponovo povežite|Ugrađeno je {n} slika; nedostaje {missing}: prvo ih ponovo povežite
 @msgplural	Embedded {n} image|Embedded {n} images	Ugrađena je {n} slika|Ugrađene su {n} slike|Ugrađeno je {n} slika
@@ -6359,6 +6392,8 @@ anchor	Points:	Tačke:
 	Anchor Inspector	Pregled sidara
 	Add Points at Crossings	Dodaj tačke na presjecima
 	Split at Crossings	Razdvoji na presjecima
+	Trim at Crossings Tool	Alat obreži na presjecima
+	Trim at Crossings	Obreži na presjecima
 	Extend Path	Produži putanju
 	Measure & Inspect	Mjeri i pregledaj
 	Set Anchor	Postavi sidro
@@ -6890,3 +6925,9 @@ shape	Open	Otvoren
 	Box	Okvir
 	Swatch	Uzorak boje
 	Direction	Smjer
+	Banner Hems and Grommets…	Porubi i ušice za baner…
+	Banner Hems and Grommets	Porubi i ušice za baner
+	Hem	Porub
+	Grommets	Ušice
+	Grommet Inset	Udaljenost ušica od ruba
+	Diameter	Prečnik
diff --git a/crates/ui-egui/src/i18n/ca.tsv b/crates/ui-egui/src/i18n/ca.tsv
index 6c3aa46c6d..9dfc5458b5 100644
--- a/crates/ui-egui/src/i18n/ca.tsv
+++ b/crates/ui-egui/src/i18n/ca.tsv
@@ -3115,6 +3115,29 @@ digits	Malayalam	Malaiàlam
 	Pattern Borders	Vores de motiu
 	Pattern Brush	Pinzell de motiu
 	missing from the Brushes panel	absent del tauler Pinzells
+	built in	integrat
+	embedding not allowed	incrustació no permesa
+	embedding for editing	incrustació per a l’edició
+	embedding for preview and print	incrustació per a la visualització i la impressió
+	embedding allowed	incrustació permesa
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	substituït: es mostra amb {family} {style} ({detail})
+	missing: shown in {family} {style}	absent: es mostra amb {family} {style}
+	missing	absent
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppp
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Degradat lineal
+	Radial gradient	Degradat radial
+	Conic gradient	Degradat cònic
+	Diamond gradient	Degradat de rombe
+	Freeform gradient	Degradat de forma lliure
+@plural	{n} instance|{n} instances	{n} instància|{n} instàncies
+@plural	{n} row|{n} rows	{n} fila|{n} files
+@plural	{n} column|{n} columns	{n} columna|{n} columnes
 	Pattern Brush Options	Opcions del pinzell de motiu
 	Pattern Editing	Edició de motius
 	Pattern Options	Opcions del motiu
@@ -4613,6 +4636,11 @@ digits	Malayalam	Malaiàlam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Configuració de Tate-chu-yoko…
 	Tate-chu-yoko Settings	Configuració de Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Configuració de Warichu…
+	Warichu Settings	Configuració de Warichu
+	Lines:	Línies:
+	Line Gap:	Separació entre línies:
 	Composite Fonts…	Tipus de lletra compostos…
 	Composite Fonts	Tipus de lletra compostos
 	Export Composite Fonts	Exporta tipus de lletra compostos
@@ -5255,6 +5283,9 @@ digits	Malayalam	Malaiàlam
 @msg	`{key}` must be [x, y, width, height]: four finite numbers, width and height not negative	`{key}` ha de ser [x, y, width, height]: quatre nombres finits, amb amplada i alçada no negatives
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` ha de ser `auto` o un codi d’idioma com `en` o `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}` ha de ser un color #rrggbb
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` ha de ser un color #rrggbb o el nom d’un color de capa
+@msg	unknown Live Paint option `{key}`	opció de pintura interactiva desconeguda `{key}`
+@msg	unknown Shape Builder option `{key}`	opció del constructor de formes desconeguda `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` ha de ser un color #rrggbb
 @msg	`{key}` must be a number	`{key}` ha de ser un nombre
 @msg	`{key}` must be a number not below 0	`{key}` ha de ser un nombre no inferior a 0
@@ -5555,6 +5586,10 @@ digits	Malayalam	Malaiàlam
 @msg	Couldn't place {name}: {e}	No s’ha pogut col·locar {name}: {e}
 @msg	Couldn't read {name}: {e}	No s’ha pogut llegir {name}: {e}
 @msg	Couldn't save recovery data: {e}	No s’han pogut desar les dades de recuperació: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	No s’han pogut desar les dades de recuperació de {title}: {e}. Les còpies es desen a {folder}, la carpeta de recuperació per defecte; per fer servir una altra carpeta, configureu Preferències → Gestió de fitxers → Recuperació de dades → Carpeta (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	No s’han pogut desar les dades de recuperació de {title}: {e}. Les còpies es desen a {folder}, la carpeta definida a Preferències; per fer servir una altra carpeta, configureu Preferències → Gestió de fitxers → Recuperació de dades → Carpeta (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	No s’han pogut desar les dades de recuperació: {e}. Les còpies es desen a {folder}, la carpeta de recuperació per defecte; per fer servir una altra carpeta, configureu Preferències → Gestió de fitxers → Recuperació de dades → Carpeta (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	No s’han pogut desar les dades de recuperació: {e}. Les còpies es desen a {folder}, la carpeta definida a Preferències; per fer servir una altra carpeta, configureu Preferències → Gestió de fitxers → Recuperació de dades → Carpeta (recoveryFolder)
 @msg	Create from Guides: the document has no artboard	Crea a partir de guies: el document no té cap tauler
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Crea a partir de guies: les guies fan més de {MAX_PIECES} talls
 @msg	Create from Selection: the selection has no area	Crea a partir de la selecció: la selecció no té àrea
@@ -5643,6 +5678,7 @@ digits	Malayalam	Malaiàlam
 @msg	invalid parameters for `{cmd}`: {msg}	paràmetres no vàlids per a `{cmd}`: {msg}
 @msg	invalid PDF setting: {0}	configuració del PDF no vàlida: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	la pàgina del tauler {n} fa {size}, més que el límit de pàgina del PDF de 14.400 pt (200 in): s’escriu amb un UserUnit de {unit}, de manera que les aplicacions que ignoren UserUnit la mostren tantes vegades més petita
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	la pàgina del tauler {n} fa {size}, més que el límit de pàgina del PDF de 14.400 pt (200 in): s’escriu amb un UserUnit de {unit}, de manera que les aplicacions que ignoren UserUnit la mostren tantes vegades més petita: activeu «Escriu les pàgines de més de 200 in a mida real, en punts»
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	la pàgina del tauler {n} fa {size}, més que el límit de pàgina del PDF de 14.400 pt (200 in): les pàgines {label} s’escriuen sense UserUnit, en punts, i les aplicacions que respecten el límit retallen la pàgina a 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	el PDF 1.5 no té UserUnit, que una pàgina de més de 14.400 pt (200 in) necessita per mantenir la mida: el fitxer s’escriu com a PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	el PDF 1.4 no té UserUnit, que una pàgina de més de 14.400 pt (200 in) necessita per quedar dins del límit de pàgina de 14.400 unitats del PDF/A-2: el fitxer s’escriu com a PDF 1.6
@@ -5926,6 +5962,7 @@ digits	Malayalam	Malaiàlam
 @msg	onto must name a panel floating in another group	onto ha de nomenar un panell que floti en un altre grup
 @msg	open a document with data sets	obre un document amb conjunts de dades
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	S’ha obert amb {n} nota: {first}|S’ha obert amb {n} notes: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. S’ha obert amb {n} nota: {first}|{notice}. S’ha obert amb {n} notes: {first}
 @msg	Opened {url}	Obert {url}
 @msg	Outline Stroke: no stroked paths selected	Contorneja el traç: no hi ha cap traçat amb traç seleccionat
 @msgplural	Packaged {n} file|Packaged {n} files	S’ha empaquetat {n} fitxer|S’han empaquetat {n} fitxers
@@ -6834,6 +6871,8 @@ anchor	Points:	Punts:
 	Anchor Inspector	Inspector de punts d’ancoratge
 	Add Points at Crossings	Afegeix punts als encreuaments
 	Split at Crossings	Divideix als encreuaments
+	Trim at Crossings Tool	Eina de retallar als encreuaments
+	Trim at Crossings	Retalla als encreuaments
 	Extend Path	Allarga el traçat
 	Measure & Inspect	Mesura i inspecciona
 	Set Anchor	Defineix el punt d’ancoratge
@@ -7424,3 +7463,9 @@ breakText	Glyphs	Glifs
 	Margin	Marge
 	Box	Caixa
 	Swatch	Mostra
+	Banner Hems and Grommets…	Vores i ullets de pancarta…
+	Banner Hems and Grommets	Vores i ullets de pancarta
+	Hem	Vora
+	Grommets	Ullets
+	Grommet Inset	Distància dels ullets a la vora
+	Diameter	Diàmetre
diff --git a/crates/ui-egui/src/i18n/cs.tsv b/crates/ui-egui/src/i18n/cs.tsv
index a80d4f6b2c..edaad350a0 100644
--- a/crates/ui-egui/src/i18n/cs.tsv
+++ b/crates/ui-egui/src/i18n/cs.tsv
@@ -1636,6 +1636,11 @@ digits	Malayalam	Malajálamské
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Nastavení Tate-chu-yoko…
 	Tate-chu-yoko Settings	Nastavení Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Nastavení Warichu…
+	Warichu Settings	Nastavení Warichu
+	Lines:	Řádky:
+	Line Gap:	Mezera mezi řádky:
 	Composite Fonts…	Složená písma…
 	Composite Fonts	Složená písma
 	Export Composite Fonts	Exportovat složená písma
@@ -3401,6 +3406,29 @@ theme	Appearance	Motiv
 	Bristle Brush	Štětinový štětec
 	Pattern Brush	Vzorkový štětec
 	missing from the Brushes panel	chybí v panelu Štětce
+	built in	vestavěné
+	embedding not allowed	vkládání není povoleno
+	embedding for editing	vkládání pro úpravy
+	embedding for preview and print	vkládání pro náhled a tisk
+	embedding allowed	vkládání povoleno
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	nahrazeno: zobrazeno písmem {family} {style} ({detail})
+	missing: shown in {family} {style}	chybí: zobrazeno písmem {family} {style}
+	missing	chybí
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} – {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Lineární přechod
+	Radial gradient	Kruhový přechod
+	Conic gradient	Kuželový přechod
+	Diamond gradient	Kosočtverečný přechod
+	Freeform gradient	Volný přechod
+@plural	{n} instance|{n} instances	{n} instance|{n} instance|{n} instancí
+@plural	{n} row|{n} rows	{n} řádek|{n} řádky|{n} řádků
+@plural	{n} column|{n} columns	{n} sloupec|{n} sloupce|{n} sloupců
 	Select art to make a scatter, art or pattern brush.	Vyberte kresbu, abyste mohli vytvořit rozptylový, obrazový nebo vzorkový štětec.
 	Brush Art	Kresba štětce
 	New Symbol	Nový symbol
@@ -4663,6 +4691,10 @@ imageTrace	Outline	Obrys
 @msg	Couldn't paste: the document it was pasted in was reverted	Nelze vložit: dokument, do kterého se vkládalo, byl vrácen k uložené verzi
 @msg	Couldn't read {name}: {e}	{name} nelze přečíst: {e}
 @msg	Couldn't save recovery data: {e}	Data pro obnovení nelze uložit: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Data pro obnovení dokumentu {title} nelze uložit: {e}. Kopie se ukládají do {folder}, výchozí složky pro obnovení; chcete-li použít jinou složku, nastavte Předvolby → Práce se soubory → Obnovení dat → Složka (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Data pro obnovení dokumentu {title} nelze uložit: {e}. Kopie se ukládají do {folder}, složky nastavené v Předvolbách; chcete-li použít jinou složku, nastavte Předvolby → Práce se soubory → Obnovení dat → Složka (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Data pro obnovení nelze uložit: {e}. Kopie se ukládají do {folder}, výchozí složky pro obnovení; chcete-li použít jinou složku, nastavte Předvolby → Práce se soubory → Obnovení dat → Složka (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Data pro obnovení nelze uložit: {e}. Kopie se ukládají do {folder}, složky nastavené v Předvolbách; chcete-li použít jinou složku, nastavte Předvolby → Práce se soubory → Obnovení dat → Složka (recoveryFolder)
 @msg	Create Outlines: select text objects	Převést na křivky: vyberte textové objekty
 @msg	Create from Guides: the document has no artboard	Vytvořit z vodítek: dokument nemá žádnou pracovní plochu
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Vytvořit z vodítek: vodítka vytvářejí více než {MAX_PIECES} řezů
@@ -4747,6 +4779,9 @@ imageTrace	Outline	Obrys
 @msg	`{keep}` is not a side of this axis	`{keep}` není strana této osy
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` musí být `auto` nebo kód jazyka, například `en` nebo `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}` musí být barva #rrggbb
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` musí být barva #rrggbb nebo název barvy vrstvy
+@msg	unknown Live Paint option `{key}`	neznámá možnost živé malby `{key}`
+@msg	unknown Shape Builder option `{key}`	neznámá možnost tvorby tvarů `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` musí být barva #rrggbb
 @msg	`{key}` must be a number	`{key}` musí být číslo
 @msg	`{key}` must be a number, not {v}	`{key}` musí být číslo, ne {v}
@@ -4906,6 +4941,7 @@ imageTrace	Outline	Obrys
 @msg	internal error: {msg} (please report this bug)	vnitřní chyba: {msg} (nahlaste prosím tuto chybu)
 @msg	invalid PDF setting: {0}	neplatné nastavení PDF: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	stránka pracovní plochy {n} má {size}, což přesahuje limit stránky PDF 14 400 pt (200 in): zapisuje se s UserUnit {unit}, takže aplikace, které UserUnit ignorují, ji zobrazí tolikrát menší
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	stránka pracovní plochy {n} má {size}, což přesahuje limit stránky PDF 14 400 pt (200 in): zapisuje se s UserUnit {unit}, takže aplikace, které UserUnit ignorují, ji zobrazí tolikrát menší: zapněte „Zapsat stránky delší než 200 in v plné velikosti v bodech“
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	stránka pracovní plochy {n} má {size}, což přesahuje limit stránky PDF 14 400 pt (200 in): stránky {label} se zapisují bez UserUnit, v bodech, a aplikace, které limit dodržují, stránku oříznou na 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 nemá UserUnit, který stránka delší než 14 400 pt (200 in) potřebuje, aby si zachovala velikost: soubor se zapíše jako PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 nemá UserUnit, který stránka delší než 14 400 pt (200 in) potřebuje, aby zůstala v limitu stránky PDF/A-2, 14 400 jednotek: soubor se zapíše jako PDF 1.6
@@ -5345,6 +5381,7 @@ imageTrace	Outline	Obrys
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Zahozen {n} obnovený dokument|Zahozeny {n} obnovené dokumenty|Zahozeno {n} obnovených dokumentů
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Obnoven {n} dokument; pokud ho chcete zachovat, uložte ho|Obnoveny {n} dokumenty; pokud je chcete zachovat, uložte je|Obnoveno {n} dokumentů; pokud je chcete zachovat, uložte je
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Otevřeno, {n} poznámka: {first}|Otevřeno, {n} poznámky: {first}|Otevřeno, {n} poznámek: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Otevřeno, {n} poznámka: {first}|{notice}. Otevřeno, {n} poznámky: {first}|{notice}. Otevřeno, {n} poznámek: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	Uloženo: {path}, {n} poznámka: {first}|Uloženo: {path}, {n} poznámky: {first}|Uloženo: {path}, {n} poznámek: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	Vložen {n} obrázek; chybí {missing}: nejprve je znovu propojte|Vloženy {n} obrázky; chybí {missing}: nejprve je znovu propojte|Vloženo {n} obrázků; chybí {missing}: nejprve je znovu propojte
 @msgplural	Embedded {n} image|Embedded {n} images	Vložen {n} obrázek|Vloženy {n} obrázky|Vloženo {n} obrázků
@@ -6865,6 +6902,8 @@ anchor	Points:	Body:
 	Anchor Inspector	Inspektor kotevních bodů
 	Add Points at Crossings	Přidat body v křížení
 	Split at Crossings	Rozdělit v křížení
+	Trim at Crossings Tool	Nástroj Zastřihnout v křížení
+	Trim at Crossings	Zastřihnout v křížení
 	Extend Path	Prodloužit cestu
 	Measure & Inspect	Měřit a zkoumat
 	Set Anchor	Nastavit kotevní bod
@@ -7443,3 +7482,9 @@ breakText	Glyphs	Glyfy
 	Margin	Okraj
 	Box	Rámeček
 	Swatch	Vzorek
+	Banner Hems and Grommets…	Lemy a průchodky banneru…
+	Banner Hems and Grommets	Lemy a průchodky banneru
+	Hem	Lem
+	Grommets	Průchodky
+	Grommet Inset	Odstup průchodek od okraje
+	Diameter	Průměr
diff --git a/crates/ui-egui/src/i18n/da.tsv b/crates/ui-egui/src/i18n/da.tsv
index 0035763d9e..10848dd3f7 100644
--- a/crates/ui-egui/src/i18n/da.tsv
+++ b/crates/ui-egui/src/i18n/da.tsv
@@ -1542,6 +1542,11 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Indstillinger for Tate-chu-yoko…
 	Tate-chu-yoko Settings	Indstillinger for Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Indstillinger for Warichu…
+	Warichu Settings	Indstillinger for Warichu
+	Lines:	Linjer:
+	Line Gap:	Linjeafstand:
 	Composite Fonts…	Sammensatte skrifttyper…
 	Composite Fonts	Sammensatte skrifttyper
 	Export Composite Fonts	Eksportér sammensatte skrifttyper
@@ -3134,6 +3139,29 @@ theme	Appearance	Udseende
 	Bristle Brush	Børstepensel
 	Pattern Brush	Mønsterpensel
 	missing from the Brushes panel	mangler i panelet Pensler
+	built in	indbygget
+	embedding not allowed	indlejring ikke tilladt
+	embedding for editing	indlejring til redigering
+	embedding for preview and print	indlejring til visning og udskrivning
+	embedding allowed	indlejring tilladt
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	erstattet: vist med {family} {style} ({detail})
+	missing: shown in {family} {style}	mangler: vist med {family} {style}
+	missing	mangler
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} – {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Lineær gradient
+	Radial gradient	Radial gradient
+	Conic gradient	Konisk gradient
+	Diamond gradient	Diamantgradient
+	Freeform gradient	Freeform-gradient
+@plural	{n} instance|{n} instances	{n} forekomst|{n} forekomster
+@plural	{n} row|{n} rows	{n} række|{n} rækker
+@plural	{n} column|{n} columns	{n} kolonne|{n} kolonner
 	Select art to make a scatter, art or pattern brush.	Markér grafik for at oprette en spredningspensel, grafikpensel eller mønsterpensel.
 	Brush Art	Penselgrafik
 	New Symbol	Nyt symbol
@@ -4258,6 +4286,10 @@ imageTrace	Outline	Kontur
 @msg	Couldn't paste: the document it was pasted in was reverted	Kunne ikke indsætte: dokumentet, der blev indsat i, blev gendannet
 @msg	Couldn't read {name}: {e}	Kunne ikke læse {name}: {e}
 @msg	Couldn't save recovery data: {e}	Kunne ikke gemme gendannelsesdata: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kunne ikke gemme gendannelsesdata for {title}: {e}. Kopierne gemmes i {folder}, standardmappen til gendannelse; angiv Præferencer → Filhåndtering → Datagendannelse → Mappe (recoveryFolder) for at bruge en anden mappe
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kunne ikke gemme gendannelsesdata for {title}: {e}. Kopierne gemmes i {folder}, mappen angivet i Præferencer; angiv Præferencer → Filhåndtering → Datagendannelse → Mappe (recoveryFolder) for at bruge en anden mappe
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kunne ikke gemme gendannelsesdata: {e}. Kopierne gemmes i {folder}, standardmappen til gendannelse; angiv Præferencer → Filhåndtering → Datagendannelse → Mappe (recoveryFolder) for at bruge en anden mappe
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kunne ikke gemme gendannelsesdata: {e}. Kopierne gemmes i {folder}, mappen angivet i Præferencer; angiv Præferencer → Filhåndtering → Datagendannelse → Mappe (recoveryFolder) for at bruge en anden mappe
 @msg	Create Outlines: select text objects	Opret konturer: markér tekstobjekter
 @msg	Create from Guides: the document has no artboard	Opret ud fra hjælpelinjer: dokumentet har ingen tegneflade
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Opret ud fra hjælpelinjer: hjælpelinjerne danner mere end {MAX_PIECES} udsnit
@@ -4838,6 +4870,7 @@ imageTrace	Outline	Kontur
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Kasserede {n} gendannet dokument|Kasserede {n} gendannede dokumenter
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Gendannede {n} dokument: gem det for at beholde det|Gendannede {n} dokumenter: gem dem for at beholde dem
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Åbnede med {n} note: {first}|Åbnede med {n} noter: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Åbnede med {n} note: {first}|{notice}. Åbnede med {n} noter: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	Gemte {path} med {n} note: {first}|Gemte {path} med {n} noter: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	Indlejrede {n} billede; {missing} mangler: link dem igen først|Indlejrede {n} billeder; {missing} mangler: link dem igen først
 @msgplural	Embedded {n} image|Embedded {n} images	Indlejrede {n} billede|Indlejrede {n} billeder
@@ -6324,6 +6357,8 @@ anchor	Points:	Punkter:
 	Anchor Inspector	Ankerpunktinspektør
 	Add Points at Crossings	Tilføj punkter ved krydsninger
 	Split at Crossings	Opdel ved krydsninger
+	Trim at Crossings Tool	Værktøj til trimning ved krydsninger
+	Trim at Crossings	Trim ved krydsninger
 	Extend Path	Forlæng sti
 	Measure & Inspect	Mål og undersøg
 	Set Anchor	Angiv ankerpunkt
@@ -6852,3 +6887,9 @@ breakText	Glyphs	Glyffer
 	Box	Ramme
 	Swatch	Farveprøve
 	Direction	Retning
+	Banner Hems and Grommets…	Bannersømme og maljer…
+	Banner Hems and Grommets	Bannersømme og maljer
+	Hem	Søm
+	Grommets	Maljer
+	Grommet Inset	Maljernes afstand fra kanten
+	Diameter	Diameter
diff --git a/crates/ui-egui/src/i18n/de.tsv b/crates/ui-egui/src/i18n/de.tsv
index 3dc6542d44..cd6a428631 100644
--- a/crates/ui-egui/src/i18n/de.tsv
+++ b/crates/ui-egui/src/i18n/de.tsv
@@ -2154,6 +2154,29 @@ file-filter	Templates	Vorlagen
 	Bristle Brush	Borstenpinsel
 	Pattern Brush	Musterpinsel
 	missing from the Brushes panel	fehlt im Bedienfeld „Pinsel“
+	built in	integriert
+	embedding not allowed	Einbetten nicht erlaubt
+	embedding for editing	Einbetten zum Bearbeiten
+	embedding for preview and print	Einbetten für Vorschau und Druck
+	embedding allowed	Einbetten erlaubt
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	ersetzt: angezeigt in {family} {style} ({detail})
+	missing: shown in {family} {style}	fehlt: angezeigt in {family} {style}
+	missing	fehlt
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} – {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Linearer Verlauf
+	Radial gradient	Radialer Verlauf
+	Conic gradient	Konischer Verlauf
+	Diamond gradient	Rautenverlauf
+	Freeform gradient	Freiformverlauf
+@plural	{n} instance|{n} instances	{n} Instanz|{n} Instanzen
+@plural	{n} row|{n} rows	{n} Zeile|{n} Zeilen
+@plural	{n} column|{n} columns	{n} Spalte|{n} Spalten
 	Select art to make a scatter, art or pattern brush.	Wählen Sie eine Grafik aus, um einen Spezial-, Bild- oder Musterpinsel zu erstellen.
 	Brush Art	Pinselgrafik
 	New Calligraphic Brush	Neuer Kalligrafiepinsel
@@ -3595,6 +3618,11 @@ effect	Points	Punkte
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Tate-chu-yoko-Einstellungen…
 	Tate-chu-yoko Settings	Tate-chu-yoko-Einstellungen
+	Warichu	Warichu
+	Warichu Settings…	Warichu-Einstellungen…
+	Warichu Settings	Warichu-Einstellungen
+	Lines:	Zeilen:
+	Line Gap:	Zeilenabstand:
 	Composite Fonts…	Zusammengesetzte Schriften…
 	Composite Fonts	Zusammengesetzte Schriften
 	Export Composite Fonts	Zusammengesetzte Schriften exportieren
@@ -4276,6 +4304,10 @@ theme	Appearance	Erscheinungsbild
 @msg	Couldn't paste: the document it was pasted in was reverted	Konnte nicht eingefügt werden: Das Dokument, in das eingefügt wurde, wurde auf die letzte Version zurückgesetzt
 @msg	Couldn't read {name}: {e}	{name} konnte nicht gelesen werden: {e}
 @msg	Couldn't save recovery data: {e}	Wiederherstellungsdaten konnten nicht gespeichert werden: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Wiederherstellungsdaten für {title} konnten nicht gespeichert werden: {e}. Kopien werden in {folder} gespeichert, dem Standardordner für die Wiederherstellung; um einen anderen Ordner zu verwenden, legen Sie Voreinstellungen → Dateihandhabung → Datenwiederherstellung → Ordner (recoveryFolder) fest
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Wiederherstellungsdaten für {title} konnten nicht gespeichert werden: {e}. Kopien werden in {folder} gespeichert, dem in den Voreinstellungen festgelegten Ordner; um einen anderen Ordner zu verwenden, legen Sie Voreinstellungen → Dateihandhabung → Datenwiederherstellung → Ordner (recoveryFolder) fest
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Wiederherstellungsdaten konnten nicht gespeichert werden: {e}. Kopien werden in {folder} gespeichert, dem Standardordner für die Wiederherstellung; um einen anderen Ordner zu verwenden, legen Sie Voreinstellungen → Dateihandhabung → Datenwiederherstellung → Ordner (recoveryFolder) fest
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Wiederherstellungsdaten konnten nicht gespeichert werden: {e}. Kopien werden in {folder} gespeichert, dem in den Voreinstellungen festgelegten Ordner; um einen anderen Ordner zu verwenden, legen Sie Voreinstellungen → Dateihandhabung → Datenwiederherstellung → Ordner (recoveryFolder) fest
 @msg	Create Outlines: select text objects	In Pfade umwandeln: Wählen Sie Textobjekte aus
 @msg	Create from Guides: the document has no artboard	Aus Hilfslinien erstellen: Das Dokument hat keine Zeichenfläche
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Aus Hilfslinien erstellen: Die Hilfslinien ergeben mehr als {MAX_PIECES} Slices
@@ -4361,6 +4393,9 @@ theme	Appearance	Erscheinungsbild
 @msg	`{keep}` is not a side of this axis	`{keep}` ist keine Seite dieser Achse
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` muss `auto` oder ein Sprachcode wie `en` oder `zh-hant` sein
 @msg	`{key}` must be a #rrggbb color	`{key}` muss eine Farbe der Form #rrggbb sein
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` muss eine Farbe der Form #rrggbb oder der Name einer Ebenenfarbe sein
+@msg	unknown Live Paint option `{key}`	unbekannte Option für Interaktiv malen `{key}`
+@msg	unknown Shape Builder option `{key}`	unbekannte Option für Formerstellung `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` muss eine Farbe der Form #rrggbb sein
 @msg	`{key}` must be a number	`{key}` muss eine Zahl sein
 @msg	`{key}` must be a number, not {v}	`{key}` muss eine Zahl sein, nicht {v}
@@ -4520,6 +4555,7 @@ theme	Appearance	Erscheinungsbild
 @msg	internal error: {msg} (please report this bug)	interner Fehler: {msg} (bitte melden Sie diesen Fehler)
 @msg	invalid PDF setting: {0}	ungültige PDF-Einstellung: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	die Seite der Zeichenfläche {n} ist {size} groß und damit länger als die PDF-Seitengrenze von 14.400 pt (200 in): sie wird mit einer UserUnit von {unit} geschrieben, daher zeigen Apps, die UserUnit ignorieren, sie entsprechend oft kleiner an
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	die Seite der Zeichenfläche {n} ist {size} groß und damit länger als die PDF-Seitengrenze von 14.400 pt (200 in): sie wird mit einer UserUnit von {unit} geschrieben, daher zeigen Apps, die UserUnit ignorieren, sie entsprechend oft kleiner an: „Seiten über 200 in in voller Größe in Punkt schreiben“ aktivieren
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	die Seite der Zeichenfläche {n} ist {size} groß und damit länger als die PDF-Seitengrenze von 14.400 pt (200 in): {label}-Seiten werden ohne UserUnit in Punkt geschrieben, und Apps, die die Grenze einhalten, schneiden die Seite auf 200 in ab
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 hat keine UserUnit, die eine Seite länger als 14.400 pt (200 in) braucht, um ihre Größe zu behalten: die Datei wird als PDF 1.6 geschrieben
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 hat keine UserUnit, die eine Seite länger als 14.400 pt (200 in) braucht, um innerhalb der PDF/A-2-Seitengrenze von 14.400 Einheiten zu bleiben: die Datei wird als PDF 1.6 geschrieben
@@ -4961,6 +4997,7 @@ theme	Appearance	Erscheinungsbild
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	{n} wiederhergestelltes Dokument verworfen|{n} wiederhergestellte Dokumente verworfen
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	{n} wiederhergestelltes Dokument geöffnet: Speichern Sie es, um es zu behalten|{n} wiederhergestellte Dokumente geöffnet: Speichern Sie sie, um sie zu behalten
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Mit {n} Hinweis geöffnet: {first}|Mit {n} Hinweisen geöffnet: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Mit {n} Hinweis geöffnet: {first}|{notice}. Mit {n} Hinweisen geöffnet: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	{path} mit {n} Hinweis gespeichert: {first}|{path} mit {n} Hinweisen gespeichert: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	{n} Bild eingebettet; {missing} fehlen: Verknüpfen Sie sie zuerst neu|{n} Bilder eingebettet; {missing} fehlen: Verknüpfen Sie sie zuerst neu
 @msgplural	Embedded {n} image|Embedded {n} images	{n} Bild eingebettet|{n} Bilder eingebettet
@@ -6457,6 +6494,8 @@ anchor	Points:	Punkte:
 	Anchor Inspector	Ankerpunkt-Inspektor
 	Add Points at Crossings	Punkte an Kreuzungen hinzufügen
 	Split at Crossings	An Kreuzungen teilen
+	Trim at Crossings Tool	An-Kreuzungen-kürzen-Werkzeug
+	Trim at Crossings	An Kreuzungen kürzen
 	Extend Path	Pfad verlängern
 	Measure & Inspect	Messen und prüfen
 	Set Anchor	Ankerpunkt festlegen
@@ -7039,3 +7078,9 @@ breakText	Glyphs	Glyphen
 	Margin	Rand
 	Box	Rahmen
 	Swatch	Farbfeld
+	Banner Hems and Grommets…	Bannersäume und Ösen…
+	Banner Hems and Grommets	Bannersäume und Ösen
+	Hem	Saum
+	Grommets	Ösen
+	Grommet Inset	Randabstand der Ösen
+	Diameter	Durchmesser
diff --git a/crates/ui-egui/src/i18n/el.tsv b/crates/ui-egui/src/i18n/el.tsv
index 95158fc54c..fc76658c72 100644
--- a/crates/ui-egui/src/i18n/el.tsv
+++ b/crates/ui-egui/src/i18n/el.tsv
@@ -1827,6 +1827,29 @@ font-technology	Variable	Μεταβλητές
 	Bristle Brush	Πινέλο με τρίχες
 	Pattern Brush	Πινέλο μοτίβου
 	missing from the Brushes panel	λείπει από τον πίνακα Πινέλα
+	built in	ενσωματωμένη
+	embedding not allowed	η ενσωμάτωση δεν επιτρέπεται
+	embedding for editing	ενσωμάτωση για επεξεργασία
+	embedding for preview and print	ενσωμάτωση για προεπισκόπηση και εκτύπωση
+	embedding allowed	η ενσωμάτωση επιτρέπεται
+	{file}; {embedding}	{file}· {embedding}
+	substituted: shown in {family} {style} ({detail})	αντικαταστάθηκε: εμφανίζεται με {family} {style} ({detail})
+	missing: shown in {family} {style}	λείπει: εμφανίζεται με {family} {style}
+	missing	λείπει
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Γραμμικό ντεγκραντέ
+	Radial gradient	Ακτινικό ντεγκραντέ
+	Conic gradient	Κωνικό ντεγκραντέ
+	Diamond gradient	Ρομβοειδές ντεγκραντέ
+	Freeform gradient	Ντεγκραντέ ελεύθερης μορφής
+@plural	{n} instance|{n} instances	{n} παρουσία|{n} παρουσίες
+@plural	{n} row|{n} rows	{n} γραμμή|{n} γραμμές
+@plural	{n} column|{n} columns	{n} στήλη|{n} στήλες
 	Select art to make a scatter, art or pattern brush.	Επιλέξτε σχέδιο για να δημιουργήσετε πινέλο διασποράς, σχεδίου ή μοτίβου.
 	Brush Art	Σχέδιο πινέλου
 	New Layer…	Νέο επίπεδο…
@@ -2428,6 +2451,10 @@ axis	Both	Και τα δύο
 @msg	Couldn't paste: the document it was pasted in was reverted	Δεν ήταν δυνατή η επικόλληση: το έγγραφο στο οποίο γινόταν η επικόλληση επανήλθε στην αποθηκευμένη έκδοση
 @msg	Couldn't read {name}: {e}	Δεν ήταν δυνατή η ανάγνωση του {name}: {e}
 @msg	Couldn't save recovery data: {e}	Δεν ήταν δυνατή η αποθήκευση δεδομένων ανάκτησης: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Δεν ήταν δυνατή η αποθήκευση δεδομένων ανάκτησης για το {title}: {e}. Τα αντίγραφα αποθηκεύονται στο {folder}, τον προεπιλεγμένο φάκελο ανάκτησης. Για να χρησιμοποιήσετε άλλο φάκελο, ορίστε Προτιμήσεις → Χειρισμός αρχείων → Ανάκτηση δεδομένων → Φάκελος (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Δεν ήταν δυνατή η αποθήκευση δεδομένων ανάκτησης για το {title}: {e}. Τα αντίγραφα αποθηκεύονται στο {folder}, τον φάκελο που ορίστηκε στις Προτιμήσεις. Για να χρησιμοποιήσετε άλλο φάκελο, ορίστε Προτιμήσεις → Χειρισμός αρχείων → Ανάκτηση δεδομένων → Φάκελος (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Δεν ήταν δυνατή η αποθήκευση δεδομένων ανάκτησης: {e}. Τα αντίγραφα αποθηκεύονται στο {folder}, τον προεπιλεγμένο φάκελο ανάκτησης. Για να χρησιμοποιήσετε άλλο φάκελο, ορίστε Προτιμήσεις → Χειρισμός αρχείων → Ανάκτηση δεδομένων → Φάκελος (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Δεν ήταν δυνατή η αποθήκευση δεδομένων ανάκτησης: {e}. Τα αντίγραφα αποθηκεύονται στο {folder}, τον φάκελο που ορίστηκε στις Προτιμήσεις. Για να χρησιμοποιήσετε άλλο φάκελο, ορίστε Προτιμήσεις → Χειρισμός αρχείων → Ανάκτηση δεδομένων → Φάκελος (recoveryFolder)
 @msg	Create Outlines: select text objects	Δημιουργία περιγραμμάτων: επιλέξτε αντικείμενα κειμένου
 @msg	Create from Guides: the document has no artboard	Δημιουργία από οδηγούς: το έγγραφο δεν έχει πίνακα σχεδίασης
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Δημιουργία από οδηγούς: οι οδηγοί σχηματίζουν περισσότερες από {MAX_PIECES} τομές
@@ -2513,6 +2540,9 @@ axis	Both	Και τα δύο
 @msg	`{keep}` is not a side of this axis	Το `{keep}` δεν είναι πλευρά αυτού του άξονα
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	Το `{key}` πρέπει να είναι `auto` ή κωδικός γλώσσας όπως `en` ή `zh-hant`
 @msg	`{key}` must be a #rrggbb color	Το `{key}` πρέπει να είναι χρώμα #rrggbb
+@msg	`{key}` must be a #rrggbb color or a layer color name	Το `{key}` πρέπει να είναι χρώμα #rrggbb ή όνομα χρώματος επιπέδου
+@msg	unknown Live Paint option `{key}`	άγνωστη επιλογή δυναμικής βαφής `{key}`
+@msg	unknown Shape Builder option `{key}`	άγνωστη επιλογή δημιουργίας σχημάτων `{key}`
 @msg	`{key}` must be a #rrggbb colour	Το `{key}` πρέπει να είναι χρώμα #rrggbb
 @msg	`{key}` must be a number	Το `{key}` πρέπει να είναι αριθμός
 @msg	`{key}` must be a number, not {v}	Το `{key}` πρέπει να είναι αριθμός, όχι {v}
@@ -4119,6 +4149,11 @@ digits	Malayalam	Μαλαγιάλαμ
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Ρυθμίσεις Tate-chu-yoko…
 	Tate-chu-yoko Settings	Ρυθμίσεις Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Ρυθμίσεις Warichu…
+	Warichu Settings	Ρυθμίσεις Warichu
+	Lines:	Γραμμές:
+	Line Gap:	Απόσταση γραμμών:
 	Composite Fonts…	Σύνθετες γραμματοσειρές…
 	Composite Fonts	Σύνθετες γραμματοσειρές
 	Export Composite Fonts	Εξαγωγή σύνθετων γραμματοσειρών
@@ -4553,6 +4588,7 @@ digits	Malayalam	Μαλαγιάλαμ
 @msg	internal error: {msg} (please report this bug)	εσωτερικό σφάλμα: {msg} (αναφέρετε το σφάλμα)
 @msg	invalid PDF setting: {0}	μη έγκυρη ρύθμιση PDF: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	η σελίδα του πίνακα σχεδίασης {n} είναι {size}, μεγαλύτερη από το όριο σελίδας PDF των 14.400 pt (200 in): γράφεται με UserUnit {unit}, οπότε οι εφαρμογές που αγνοούν το UserUnit την εμφανίζουν τόσες φορές μικρότερη
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	η σελίδα του πίνακα σχεδίασης {n} είναι {size}, μεγαλύτερη από το όριο σελίδας PDF των 14.400 pt (200 in): γράφεται με UserUnit {unit}, οπότε οι εφαρμογές που αγνοούν το UserUnit την εμφανίζουν τόσες φορές μικρότερη: ενεργοποιήστε την «Εγγραφή σελίδων μεγαλύτερων από 200 in σε πλήρες μέγεθος, σε στιγμές»
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	η σελίδα του πίνακα σχεδίασης {n} είναι {size}, μεγαλύτερη από το όριο σελίδας PDF των 14.400 pt (200 in): οι σελίδες {label} γράφονται χωρίς UserUnit, σε στιγμές, και οι εφαρμογές που τηρούν το όριο κόβουν τη σελίδα στις 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	το PDF 1.5 δεν έχει UserUnit, που χρειάζεται μια σελίδα μεγαλύτερη από 14.400 pt (200 in) για να κρατήσει το μέγεθός της: το αρχείο γράφεται ως PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	το PDF 1.4 δεν έχει UserUnit, που χρειάζεται μια σελίδα μεγαλύτερη από 14.400 pt (200 in) για να μείνει εντός του ορίου σελίδας του PDF/A-2, 14.400 μονάδων: το αρχείο γράφεται ως PDF 1.6
@@ -4986,6 +5022,7 @@ digits	Malayalam	Μαλαγιάλαμ
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Απορρίφθηκε {n} ανακτημένο έγγραφο|Απορρίφθηκαν {n} ανακτημένα έγγραφα
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Επαναφέρθηκε {n} ανακτημένο έγγραφο: αποθηκεύστε το για να διατηρηθεί|Επαναφέρθηκαν {n} ανακτημένα έγγραφα: αποθηκεύστε τα για να διατηρηθούν
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Άνοιξε με {n} σημείωση: {first}|Άνοιξε με {n} σημειώσεις: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Άνοιξε με {n} σημείωση: {first}|{notice}. Άνοιξε με {n} σημειώσεις: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	Αποθηκεύτηκε το {path} με {n} σημείωση: {first}|Αποθηκεύτηκε το {path} με {n} σημειώσεις: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	Ενσωματώθηκε {n} εικόνα· λείπουν {missing}: επανασυνδέστε τις πρώτα|Ενσωματώθηκαν {n} εικόνες· λείπουν {missing}: επανασυνδέστε τις πρώτα
 @msgplural	Embedded {n} image|Embedded {n} images	Ενσωματώθηκε {n} εικόνα|Ενσωματώθηκαν {n} εικόνες
@@ -6817,6 +6854,8 @@ anchor	Points:	Σημεία:
 	Anchor Inspector	Επιθεωρητής σημείων αγκύρωσης
 	Add Points at Crossings	Προσθήκη σημείων στις διασταυρώσεις
 	Split at Crossings	Διαχωρισμός στις διασταυρώσεις
+	Trim at Crossings Tool	Εργαλείο περικοπής στις διασταυρώσεις
+	Trim at Crossings	Περικοπή στις διασταυρώσεις
 	Extend Path	Επέκταση διαδρομής
 	Measure & Inspect	Μέτρηση και επιθεώρηση
 	Set Anchor	Ορισμός σημείου αγκύρωσης
@@ -7396,3 +7435,9 @@ breakText	Glyphs	Γλύφοι
 	Margin	Περιθώριο
 	Box	Πλαίσιο
 	Swatch	Δείγμα χρώματος
+	Banner Hems and Grommets…	Στριφώματα και τρουκς πανό…
+	Banner Hems and Grommets	Στριφώματα και τρουκς πανό
+	Hem	Στρίφωμα
+	Grommets	Τρουκς
+	Grommet Inset	Απόσταση τρουκς από την άκρη
+	Diameter	Διάμετρος
diff --git a/crates/ui-egui/src/i18n/es.tsv b/crates/ui-egui/src/i18n/es.tsv
index 7041dcacb3..c7c9c8bc1e 100644
--- a/crates/ui-egui/src/i18n/es.tsv
+++ b/crates/ui-egui/src/i18n/es.tsv
@@ -2192,6 +2192,29 @@ font-technology	Variable	Variables
 	Bristle Brush	Pincel de cerdas
 	Pattern Brush	Pincel de motivo
 	missing from the Brushes panel	falta en el panel Pinceles
+	built in	integrada
+	embedding not allowed	incrustación no permitida
+	embedding for editing	incrustación para edición
+	embedding for preview and print	incrustación para vista previa e impresión
+	embedding allowed	incrustación permitida
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	sustituida: se muestra con {family} {style} ({detail})
+	missing: shown in {family} {style}	falta: se muestra con {family} {style}
+	missing	falta
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppp
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Degradado lineal
+	Radial gradient	Degradado radial
+	Conic gradient	Degradado cónico
+	Diamond gradient	Degradado de rombo
+	Freeform gradient	Degradado libre
+@plural	{n} instance|{n} instances	{n} instancia|{n} instancias
+@plural	{n} row|{n} rows	{n} fila|{n} filas
+@plural	{n} column|{n} columns	{n} columna|{n} columnas
 	Select art to make a scatter, art or pattern brush.	Selecciona una ilustración para crear un pincel de dispersión, de arte o de motivo.
 	Brush Art	Ilustración del pincel
 	New Calligraphic Brush	Nuevo pincel caligráfico
@@ -3643,6 +3666,11 @@ digits	Malayalam	Malayálam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Ajustes de Tate-chu-yoko…
 	Tate-chu-yoko Settings	Ajustes de Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Ajustes de Warichu…
+	Warichu Settings	Ajustes de Warichu
+	Lines:	Líneas:
+	Line Gap:	Separación entre líneas:
 	Composite Fonts…	Fuentes compuestas…
 	Composite Fonts	Fuentes compuestas
 	Export Composite Fonts	Exportar fuentes compuestas
@@ -4353,6 +4381,10 @@ axis	Both	Ambos
 @msg	Couldn't paste: the document it was pasted in was reverted	No se pudo pegar: se revirtió el documento en el que se estaba pegando
 @msg	Couldn't read {name}: {e}	No se pudo leer {name}: {e}
 @msg	Couldn't save recovery data: {e}	No se pudieron guardar los datos de recuperación: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	No se pudieron guardar los datos de recuperación de {title}: {e}. Las copias se guardan en {folder}, la carpeta de recuperación predeterminada; para usar otra carpeta, configura Preferencias → Manejo de archivos → Recuperación de datos → Carpeta (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	No se pudieron guardar los datos de recuperación de {title}: {e}. Las copias se guardan en {folder}, la carpeta definida en Preferencias; para usar otra carpeta, configura Preferencias → Manejo de archivos → Recuperación de datos → Carpeta (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	No se pudieron guardar los datos de recuperación: {e}. Las copias se guardan en {folder}, la carpeta de recuperación predeterminada; para usar otra carpeta, configura Preferencias → Manejo de archivos → Recuperación de datos → Carpeta (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	No se pudieron guardar los datos de recuperación: {e}. Las copias se guardan en {folder}, la carpeta definida en Preferencias; para usar otra carpeta, configura Preferencias → Manejo de archivos → Recuperación de datos → Carpeta (recoveryFolder)
 @msg	Create Outlines: select text objects	Crear contornos: selecciona objetos de texto
 @msg	Create from Guides: the document has no artboard	Crear a partir de guías: el documento no tiene mesa de trabajo
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Crear a partir de guías: las guías forman más de {MAX_PIECES} sectores
@@ -4438,6 +4470,9 @@ axis	Both	Ambos
 @msg	`{keep}` is not a side of this axis	`{keep}` no es un lado de este eje
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` debe ser `auto` o un código de idioma como `en` o `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}` debe ser un color #rrggbb
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` debe ser un color #rrggbb o el nombre de un color de capa
+@msg	unknown Live Paint option `{key}`	opción de pintura interactiva desconocida `{key}`
+@msg	unknown Shape Builder option `{key}`	opción del generador de formas desconocida `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` debe ser un color #rrggbb
 @msg	`{key}` must be a number	`{key}` debe ser un número
 @msg	`{key}` must be a number, not {v}	`{key}` debe ser un número, no {v}
@@ -4597,6 +4632,7 @@ axis	Both	Ambos
 @msg	internal error: {msg} (please report this bug)	error interno: {msg} (por favor, informa de este error)
 @msg	invalid PDF setting: {0}	ajuste de PDF no válido: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	la página de la mesa de trabajo {n} mide {size}, más que el límite de página de PDF de 14.400 pt (200 in): se escribe con un UserUnit de {unit}, así que las aplicaciones que ignoran UserUnit la muestran ese número de veces más pequeña
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	la página de la mesa de trabajo {n} mide {size}, más que el límite de página de PDF de 14.400 pt (200 in): se escribe con un UserUnit de {unit}, así que las aplicaciones que ignoran UserUnit la muestran ese número de veces más pequeña: activa «Escribir las páginas de más de 200 in a tamaño real, en puntos»
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	la página de la mesa de trabajo {n} mide {size}, más que el límite de página de PDF de 14.400 pt (200 in): las páginas {label} se escriben sin UserUnit, en puntos, y las aplicaciones que respetan el límite recortan la página a 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 no tiene UserUnit, que una página de más de 14.400 pt (200 in) necesita para conservar su tamaño: el archivo se escribe como PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 no tiene UserUnit, que una página de más de 14.400 pt (200 in) necesita para no superar el límite de página de PDF/A-2, de 14.400 unidades: el archivo se escribe como PDF 1.6
@@ -5037,6 +5073,7 @@ axis	Both	Ambos
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Se descartó {n} documento recuperado|Se descartaron {n} documentos recuperados
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Se restauró {n} documento recuperado: guárdalo para conservarlo|Se restauraron {n} documentos recuperados: guárdalos para conservarlos
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Se abrió con {n} nota: {first}|Se abrió con {n} notas: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Se abrió con {n} nota: {first}|{notice}. Se abrió con {n} notas: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	Se guardó {path} con {n} nota: {first}|Se guardó {path} con {n} notas: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	Se incrustó {n} imagen; faltan {missing}: vuelve a vincularlas primero|Se incrustaron {n} imágenes; faltan {missing}: vuelve a vincularlas primero
 @msgplural	Embedded {n} image|Embedded {n} images	Se incrustó {n} imagen|Se incrustaron {n} imágenes
@@ -6808,6 +6845,8 @@ anchor	Points:	Puntos:
 	Anchor Inspector	Inspector de puntos de ancla
 	Add Points at Crossings	Agregar puntos en los cruces
 	Split at Crossings	Dividir en los cruces
+	Trim at Crossings Tool	Herramienta Recortar en los cruces
+	Trim at Crossings	Recortar en los cruces
 	Extend Path	Prolongar trazado
 	Measure & Inspect	Medir e inspeccionar
 	Set Anchor	Definir punto de ancla
@@ -7387,3 +7426,9 @@ breakText	Glyphs	Glifos
 	Margin	Margen
 	Box	Caja
 	Swatch	Muestra
+	Banner Hems and Grommets…	Dobladillos y ojales de pancarta…
+	Banner Hems and Grommets	Dobladillos y ojales de pancarta
+	Hem	Dobladillo
+	Grommets	Ojales
+	Grommet Inset	Distancia de los ojales al borde
+	Diameter	Diámetro
diff --git a/crates/ui-egui/src/i18n/fi.tsv b/crates/ui-egui/src/i18n/fi.tsv
index c5f1bd4d48..126e7854f9 100644
--- a/crates/ui-egui/src/i18n/fi.tsv
+++ b/crates/ui-egui/src/i18n/fi.tsv
@@ -1609,6 +1609,11 @@ digits	Malayalam	Malajalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Tate-chu-yoko-asetukset…
 	Tate-chu-yoko Settings	Tate-chu-yoko-asetukset
+	Warichu	Warichu
+	Warichu Settings…	Warichu-asetukset…
+	Warichu Settings	Warichu-asetukset
+	Lines:	Rivit:
+	Line Gap:	Riviväli:
 	Composite Fonts…	Yhdistelmäfontit…
 	Composite Fonts	Yhdistelmäfontit
 	Export Composite Fonts	Vie yhdistelmäfontit
@@ -3340,6 +3345,29 @@ theme	Appearance	Ulkoasu
 	Bristle Brush	Harjassivellin
 	Pattern Brush	Kuviosivellin
 	missing from the Brushes panel	puuttuu Siveltimet-paneelista
+	built in	sisäänrakennettu
+	embedding not allowed	upottaminen ei sallittu
+	embedding for editing	upottaminen muokkausta varten
+	embedding for preview and print	upottaminen esikatselua ja tulostusta varten
+	embedding allowed	upottaminen sallittu
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	korvattu: näytetään fontilla {family} {style} ({detail})
+	missing: shown in {family} {style}	puuttuu: näytetään fontilla {family} {style}
+	missing	puuttuu
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} – {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Lineaarinen liukuväri
+	Radial gradient	Säteittäinen liukuväri
+	Conic gradient	Kartiomainen liukuväri
+	Diamond gradient	Vinoneliöliukuväri
+	Freeform gradient	Vapaamuotoinen liukuväri
+@plural	{n} instance|{n} instances	{n} esiintymä|{n} esiintymää
+@plural	{n} row|{n} rows	{n} rivi|{n} riviä
+@plural	{n} column|{n} columns	{n} sarake|{n} saraketta
 	Select art to make a scatter, art or pattern brush.	Valitse kuvitus, jotta voit luoda sirote-, taide- tai kuviosiveltimen.
 	Brush Art	Siveltimen kuvitus
 	New Symbol	Uusi symboli
@@ -4577,6 +4605,10 @@ imageTrace	Outline	Ääriviiva
 @msg	Couldn't paste: the document it was pasted in was reverted	Liittäminen ei onnistunut: asiakirja, johon liitettiin, on palautettu tallennettuun versioon
 @msg	Couldn't read {name}: {e}	Tiedostoa {name} ei voitu lukea: {e}
 @msg	Couldn't save recovery data: {e}	Palautustietoja ei voitu tallentaa: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kohteen {title} palautustietoja ei voitu tallentaa: {e}. Kopiot tallennetaan kansioon {folder}, joka on oletusarvoinen palautuskansio; jos haluat käyttää toista kansiota, määritä Asetukset → Tiedostojen käsittely → Tietojen palautus → Kansio (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kohteen {title} palautustietoja ei voitu tallentaa: {e}. Kopiot tallennetaan kansioon {folder}, joka on määritetty Asetuksissa; jos haluat käyttää toista kansiota, määritä Asetukset → Tiedostojen käsittely → Tietojen palautus → Kansio (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Palautustietoja ei voitu tallentaa: {e}. Kopiot tallennetaan kansioon {folder}, joka on oletusarvoinen palautuskansio; jos haluat käyttää toista kansiota, määritä Asetukset → Tiedostojen käsittely → Tietojen palautus → Kansio (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Palautustietoja ei voitu tallentaa: {e}. Kopiot tallennetaan kansioon {folder}, joka on määritetty Asetuksissa; jos haluat käyttää toista kansiota, määritä Asetukset → Tiedostojen käsittely → Tietojen palautus → Kansio (recoveryFolder)
 @msg	Create Outlines: select text objects	Muunna ääriviivoiksi: valitse tekstiobjekteja
 @msg	Create from Guides: the document has no artboard	Luo apuviivoista: asiakirjassa ei ole piirtoalustaa
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Luo apuviivoista: apuviivat muodostavat yli {MAX_PIECES} viipaletta
@@ -4661,6 +4693,9 @@ imageTrace	Outline	Ääriviiva
 @msg	`{keep}` is not a side of this axis	`{keep}` ei ole tämän akselin puoli
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` on oltava `auto` tai kielikoodi, kuten `en` tai `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}` on oltava #rrggbb-väri
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` on oltava #rrggbb-väri tai tason värin nimi
+@msg	unknown Live Paint option `{key}`	tuntematon elävän maalauksen valinta `{key}`
+@msg	unknown Shape Builder option `{key}`	tuntematon muodonmuodostimen valinta `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` on oltava #rrggbb-väri
 @msg	`{key}` must be a number	`{key}` on oltava luku
 @msg	`{key}` must be a number, not {v}	`{key}` on oltava luku, ei {v}
@@ -4812,6 +4847,7 @@ imageTrace	Outline	Ääriviiva
 @msg	internal error: {msg} (please report this bug)	sisäinen virhe: {msg} (ilmoita tästä virheestä)
 @msg	invalid PDF setting: {0}	virheellinen PDF-asetus: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	piirtoalustan {n} sivu on {size}, pidempi kuin PDF:n 14 400 pt:n (200 in) sivuraja: se kirjoitetaan UserUnit-arvolla {unit}, joten UserUnitin ohittavat sovellukset näyttävät sen niin monta kertaa pienempänä
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	piirtoalustan {n} sivu on {size}, pidempi kuin PDF:n 14 400 pt:n (200 in) sivuraja: se kirjoitetaan UserUnit-arvolla {unit}, joten UserUnitin ohittavat sovellukset näyttävät sen niin monta kertaa pienempänä: ota käyttöön ”Kirjoita yli 200 in pitkät sivut täysikokoisina pisteinä”
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	piirtoalustan {n} sivu on {size}, pidempi kuin PDF:n 14 400 pt:n (200 in) sivuraja: {label}-sivut kirjoitetaan ilman UserUnitia, pisteinä, ja rajaa noudattavat sovellukset rajaavat sivun 200 in:iin
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5:ssä ei ole UserUnitia, jota yli 14 400 pt:n (200 in) sivu tarvitsee säilyttääkseen kokonsa: tiedosto kirjoitetaan PDF 1.6:na
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4:ssä ei ole UserUnitia, jota yli 14 400 pt:n (200 in) sivu tarvitsee pysyäkseen PDF/A-2:n 14 400 yksikön sivurajan sisällä: tiedosto kirjoitetaan PDF 1.6:na
@@ -5244,6 +5280,7 @@ imageTrace	Outline	Ääriviiva
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Hylättiin {n} palautettu asiakirja|Hylättiin {n} palautettua asiakirjaa
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Palautettiin {n} asiakirja: tallenna se säilyttääksesi sen|Palautettiin {n} asiakirjaa: tallenna ne säilyttääksesi ne
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Avattiin, {n} huomautus: {first}|Avattiin, {n} huomautusta: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Avattiin, {n} huomautus: {first}|{notice}. Avattiin, {n} huomautusta: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	Tallennettiin {path}, {n} huomautus: {first}|Tallennettiin {path}, {n} huomautusta: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	Upotettiin {n} kuva; {missing} puuttuu: linkitä ne ensin uudelleen|Upotettiin {n} kuvaa; {missing} puuttuu: linkitä ne ensin uudelleen
 @msgplural	Embedded {n} image|Embedded {n} images	Upotettiin {n} kuva|Upotettiin {n} kuvaa
@@ -6895,6 +6932,8 @@ anchor	Points:	Pisteet:
 	Anchor Inspector	Ankkuripisteiden tarkastelu
 	Add Points at Crossings	Lisää pisteet risteyskohtiin
 	Split at Crossings	Jaa risteyskohdista
+	Trim at Crossings Tool	Risteyskohdista katkaisun työkalu
+	Trim at Crossings	Katkaise risteyskohdista
 	Extend Path	Jatka polkua
 	Measure & Inspect	Mittaa ja tarkastele
 	Set Anchor	Aseta ankkuripiste
@@ -7478,3 +7517,9 @@ breakText	Glyphs	Merkit
 	Margin	Marginaali
 	Box	Kehys
 	Swatch	Värimalli
+	Banner Hems and Grommets…	Bannerin päärmeet ja purjerenkaat…
+	Banner Hems and Grommets	Bannerin päärmeet ja purjerenkaat
+	Hem	Päärme
+	Grommets	Purjerenkaat
+	Grommet Inset	Purjerenkaiden etäisyys reunasta
+	Diameter	Halkaisija
diff --git a/crates/ui-egui/src/i18n/fr.tsv b/crates/ui-egui/src/i18n/fr.tsv
index 4227df5602..3941bf0497 100644
--- a/crates/ui-egui/src/i18n/fr.tsv
+++ b/crates/ui-egui/src/i18n/fr.tsv
@@ -2184,6 +2184,29 @@ font-technology	Variable	Variables
 	Bristle Brush	Forme Soies
 	Pattern Brush	Forme de motif
 	missing from the Brushes panel	absente du panneau Formes
+	built in	intégrée
+	embedding not allowed	incorporation interdite
+	embedding for editing	incorporation pour la modification
+	embedding for preview and print	incorporation pour l’aperçu et l’impression
+	embedding allowed	incorporation autorisée
+	{file}; {embedding}	{file}, {embedding}
+	substituted: shown in {family} {style} ({detail})	remplacée, affichée en {family} {style} ({detail})
+	missing: shown in {family} {style}	absente, affichée en {family} {style}
+	missing	absente
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppp
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Dégradé linéaire
+	Radial gradient	Dégradé radial
+	Conic gradient	Dégradé conique
+	Diamond gradient	Dégradé en losange
+	Freeform gradient	Dégradé de forme libre
+@plural	{n} instance|{n} instances	{n} occurrence|{n} occurrences
+@plural	{n} row|{n} rows	{n} ligne|{n} lignes
+@plural	{n} column|{n} columns	{n} colonne|{n} colonnes
 	Select art to make a scatter, art or pattern brush.	Sélectionnez une illustration pour créer une forme diffuse, artistique ou de motif.
 	Brush Art	Illustration de la forme
 	New Calligraphic Brush	Nouvelle forme calligraphique
@@ -3635,6 +3658,11 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Paramètres Tate-chu-yoko…
 	Tate-chu-yoko Settings	Paramètres Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Paramètres Warichu…
+	Warichu Settings	Paramètres Warichu
+	Lines:	Lignes :
+	Line Gap:	Écart entre les lignes :
 	Composite Fonts…	Polices composites…
 	Composite Fonts	Polices composites
 	Export Composite Fonts	Exporter des polices composites
@@ -4342,6 +4370,10 @@ axis	Both	Les deux
 @msg	Couldn't paste: the document it was pasted in was reverted	Impossible de coller, car le document de destination a été rétabli à la version précédente
 @msg	Couldn't read {name}: {e}	Impossible de lire {name} : {e}
 @msg	Couldn't save recovery data: {e}	Impossible d’enregistrer les données de récupération : {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Impossible d’enregistrer les données de récupération de {title} : {e}. Les copies sont enregistrées dans {folder}, le dossier de récupération par défaut ; pour utiliser un autre dossier, définissez Préférences → Gestion des fichiers → Récupération des données → Dossier (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Impossible d’enregistrer les données de récupération de {title} : {e}. Les copies sont enregistrées dans {folder}, le dossier défini dans les Préférences ; pour utiliser un autre dossier, définissez Préférences → Gestion des fichiers → Récupération des données → Dossier (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Impossible d’enregistrer les données de récupération : {e}. Les copies sont enregistrées dans {folder}, le dossier de récupération par défaut ; pour utiliser un autre dossier, définissez Préférences → Gestion des fichiers → Récupération des données → Dossier (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Impossible d’enregistrer les données de récupération : {e}. Les copies sont enregistrées dans {folder}, le dossier défini dans les Préférences ; pour utiliser un autre dossier, définissez Préférences → Gestion des fichiers → Récupération des données → Dossier (recoveryFolder)
 @msg	Create Outlines: select text objects	Vectoriser : sélectionnez des objets texte
 @msg	Create from Guides: the document has no artboard	Créer d’après les repères : le document n’a pas de plan de travail
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Créer d’après les repères : les repères forment plus de {MAX_PIECES} tranches
@@ -4427,6 +4459,9 @@ axis	Both	Les deux
 @msg	`{keep}` is not a side of this axis	`{keep}` n’est pas un côté de cet axe
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` doit être `auto` ou un code de langue comme `en` ou `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}` doit être une couleur #rrggbb
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` doit être une couleur #rrggbb ou le nom d’une couleur de calque
+@msg	unknown Live Paint option `{key}`	option de peinture dynamique inconnue `{key}`
+@msg	unknown Shape Builder option `{key}`	option du concepteur de forme inconnue `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` doit être une couleur #rrggbb
 @msg	`{key}` must be a number	`{key}` doit être un nombre
 @msg	`{key}` must be a number, not {v}	`{key}` doit être un nombre, pas {v}
@@ -4585,6 +4620,7 @@ axis	Both	Les deux
 @msg	internal error in `{cmd}`: {msg} (the document was left as it was before; please report this bug)	erreur interne dans `{cmd}` : {msg} (le document est resté tel qu’il était ; veuillez signaler ce bogue)
 @msg	internal error: {msg} (please report this bug)	erreur interne : {msg} (veuillez signaler ce bogue)
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	la page du plan de travail {n} mesure {size}, plus que la limite de page PDF de 14 400 pt (200 in) : elle est écrite avec une UserUnit de {unit}, donc les applications qui ignorent UserUnit l’affichent autant de fois plus petite
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	la page du plan de travail {n} mesure {size}, plus que la limite de page PDF de 14 400 pt (200 in) : elle est écrite avec une UserUnit de {unit}, donc les applications qui ignorent UserUnit l’affichent autant de fois plus petite : activez « Écrire les pages de plus de 200 in en taille réelle, en points »
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	la page du plan de travail {n} mesure {size}, plus que la limite de page PDF de 14 400 pt (200 in) : les pages {label} sont écrites sans UserUnit, en points, et les applications qui respectent la limite coupent la page à 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 n’a pas d’UserUnit, dont une page de plus de 14 400 pt (200 in) a besoin pour garder sa taille : le fichier est écrit en PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 n’a pas d’UserUnit, dont une page de plus de 14 400 pt (200 in) a besoin pour rester dans la limite de page de PDF/A-2, 14 400 unités : le fichier est écrit en PDF 1.6
@@ -5024,6 +5060,7 @@ axis	Both	Les deux
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	{n} document récupéré supprimé|{n} documents récupérés supprimés
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	{n} document récupéré restauré : enregistrez-le pour le conserver|{n} documents récupérés restaurés : enregistrez-les pour les conserver
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Ouvert avec {n} remarque : {first}|Ouvert avec {n} remarques : {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Ouvert avec {n} remarque : {first}|{notice}. Ouvert avec {n} remarques : {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	{path} enregistré avec {n} remarque : {first}|{path} enregistré avec {n} remarques : {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	{n} image incorporée ; il en manque {missing} : rétablissez d’abord leurs liens|{n} images incorporées ; il en manque {missing} : rétablissez d’abord leurs liens
 @msgplural	Embedded {n} image|Embedded {n} images	{n} image incorporée|{n} images incorporées
@@ -6860,6 +6897,8 @@ anchor	Points:	Points :
 	Anchor Inspector	Inspecteur de points d’ancrage
 	Add Points at Crossings	Ajouter des points aux croisements
 	Split at Crossings	Scinder aux croisements
+	Trim at Crossings Tool	Outil Rogner aux croisements
+	Trim at Crossings	Rogner aux croisements
 	Extend Path	Prolonger le tracé
 	Measure & Inspect	Mesurer et inspecter
 	Set Anchor	Définir le point d’ancrage
@@ -7438,3 +7477,9 @@ breakText	Glyphs	Glyphes
 	Margin	Marge
 	Box	Cadre
 	Swatch	Nuance
+	Banner Hems and Grommets…	Ourlets et œillets de banderole…
+	Banner Hems and Grommets	Ourlets et œillets de banderole
+	Hem	Ourlet
+	Grommets	Œillets
+	Grommet Inset	Distance des œillets au bord
+	Diameter	Diamètre
diff --git a/crates/ui-egui/src/i18n/hi.tsv b/crates/ui-egui/src/i18n/hi.tsv
index 3b8986e5f1..bf2f223fc0 100644
--- a/crates/ui-egui/src/i18n/hi.tsv
+++ b/crates/ui-egui/src/i18n/hi.tsv
@@ -1243,7 +1243,7 @@ antiAlias	Sharp	शार्प
 	Delete the selected items and their artwork?	चुने गए आइटम और उनका आर्टवर्क हटाएँ?
 	Delete this layer and its artwork?	यह लेयर और इसका आर्टवर्क हटाएँ?
 	Delete “{name}”?	"{name}" को हटाएं?
-	Delete {kind} Style	Delete {kind} Style
+	Delete {kind} Style	{kind} स्टाइल हटाएँ
 	Delete Action Sets	एक्शन सेट हटाएं
 	Delete All	सभी हटाएँ
 	Delete All Slices	सभी स्लाइस हटाएँ
@@ -1271,7 +1271,7 @@ antiAlias	Sharp	शार्प
 	Delete Instances	इंस्टेंस हटाएँ
 	Delete Layer	लेयर हटाएँ
 	Delete Library	लाइब्रेरी हटाएँ
-	Delete Library Group	लाइब्रेरी समूह
+	Delete Library Group	लाइब्रेरी ग्रुप हटाएँ
 	Delete Library Item	लाइब्रेरी आइटम हटाएं
 	Delete Light	लाइट हटाएँ
 	Delete Mesh Point	मेश पॉइंट हटाएँ
@@ -1774,7 +1774,7 @@ antiAlias	Sharp	शार्प
 	Export Keyboard Shortcuts as Text…	कीबोर्ड शॉर्टकट टेक्स्ट के रूप में निर्यात करें…
 	Export Text…	टेक्स्ट निर्यात करें…
 	Export Layer	निर्यात लेयर
-	Export Library	लाइब्रेरी
+	Export Library	लाइब्रेरी एक्सपोर्ट करें
 	Export Library…	लाइब्रेरी निर्यात करें…
 	Export Option	निर्यात ऑप्शन
 	Export PDF	PDF निर्यात करें
@@ -1855,7 +1855,7 @@ antiAlias	Sharp	शार्प
 	Files of a PDF standard can't be password-protected.	एक PDF मानक की फ़ाइलें पासवर्ड की रक्षा नहीं की जा सकती है।
 	Files of this standard tag their colours with ICC profiles.	इस मानक की फ़ाइलें ICC प्रोफ़ाइल के साथ उनके रंगों को टैग करती हैं।
 	Fill	फ़िल
-	Fill (X), double-click for the Color Picker	रंग पिकर के लिए डबल क्लिक करें
+	Fill (X), double-click for the Color Picker	फ़िल (X), कलर पिकर के लिए डबल-क्लिक करें
 	Fill & Stroke	भरें और स्ट्रोक करें
 	Fill and Stroke	भरें और स्ट्रोक करें
 	Fill and Stroke Controls	भरण और स्ट्रोक नियंत्रण
@@ -1922,7 +1922,7 @@ antiAlias	Sharp	शार्प
 	Fix All	सभी को ठीक करें
 	Fix All Issues	सभी मुद्दों को ठीक करें
 	Fix Issues	मुद्दों को ठीक करें
-	Fix Selected	निर्धारित करना
+	Fix Selected	सिलेक्टेड को ठीक करें
 	Fixed	निश्चित
 	Flag…	झंडा…
 	Flare	फ्लेयर
@@ -2302,8 +2302,8 @@ antiAlias	Sharp	शार्प
 	If a drawing tablet's pen doesn't draw, choose an X11 (XWayland) option.	अगर ड्रॉइंग टैबलेट के पेन से ड्रॉ नहीं हो रहा, तो X11 (XWayland) ऑप्शन चुनें।
 	Ignore	अनदेखा करें
 	Ignore Artboards (all the art as one page)	आर्टबोर्ड्स नज़रअंदाज़ करें (सारा आर्टवर्क एक पेज पर)
-	Ignore Color	Ignore रंग
-	Ignore White	Ignore व्हाइट
+	Ignore Color	रंग अनदेखा करें
+	Ignore White	सफ़ेद अनदेखा करें
 	Image	इमेज
 	Image Info	इमेज जानकारी
 	Image Map:	इमेज मानचित्र:
@@ -2956,7 +2956,7 @@ antiAlias	Sharp	शार्प
 	Nesting too deep to follow	का पालन करने के लिए बहुत गहरी
 	Neutral Gradients	न्यूट्रल ग्रेडिएंट्स
 	New	नया
-	New {kind} Style…	नया {kind} Style…
+	New {kind} Style…	नई {kind} स्टाइल…
 	New Action	नया एक्शन
 	New Action…	नया एक्शन…
 	New Art Appearance	नई कला उपस्थिति
@@ -3134,8 +3134,8 @@ antiAlias	Sharp	शार्प
 	Odd Fields	विषम फ़ील्ड्स
 	Odd-Numbered Anchors	Odd-Numbered एंकर
 	Odia	ओडिया
-	of	of
-	of {count}	{count}
+	of	/
+	of {count}	/ {count}
 	of characters used	वर्णों का इस्तेमाल किया
 	Off	बंद
 	Off-Artboard Art	ऑफ आर्टबोर्ड आर्ट
@@ -3183,7 +3183,7 @@ antiAlias	Sharp	शार्प
 	Opacity:	ओपेसिटी:
 	Opacity: {value}	ओपेसिटी: {value}
 	Opacity: 50% Multiply	ओपेसिटी: 50% मल्टिप्लाई
-	Opacity: Default	Opacity: डिफ़ॉल्ट
+	Opacity: Default	ओपेसिटी: डिफ़ॉल्ट
 	Opaque	अपारदर्शी
 	Open	ओपन
 	Open a document to check it for issues.	इसे मुद्दों के लिए जांच करने के लिए एक डॉक्यूमेंट ओपन करें।
@@ -3397,6 +3397,29 @@ antiAlias	Sharp	शार्प
 	Pattern Borders	पैटर्न सीमा
 	Pattern Brush	पैटर्न ब्रश
 	missing from the Brushes panel	ब्रश पैनल में अनुपलब्ध
+	built in	अंतर्निहित
+	embedding not allowed	एम्बेडिंग की अनुमति नहीं
+	embedding for editing	संपादन के लिए एम्बेडिंग
+	embedding for preview and print	पूर्वावलोकन और प्रिंट के लिए एम्बेडिंग
+	embedding allowed	एम्बेडिंग की अनुमति है
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	प्रतिस्थापित: {family} {style} में दिखाया गया ({detail})
+	missing: shown in {family} {style}	अनुपलब्ध: {family} {style} में दिखाया गया
+	missing	अनुपलब्ध
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	लीनियर ग्रेडिएंट
+	Radial gradient	रेडियल ग्रेडिएंट
+	Conic gradient	कोनिक ग्रेडिएंट
+	Diamond gradient	डायमंड ग्रेडिएंट
+	Freeform gradient	फ्रीफॉर्म ग्रेडिएंट
+@plural	{n} instance|{n} instances	{n} इंस्टेंस|{n} इंस्टेंस
+@plural	{n} row|{n} rows	{n} पंक्ति|{n} पंक्तियाँ
+@plural	{n} column|{n} columns	{n} कॉलम|{n} कॉलम
 	Pattern Brush Options	पैटर्न ब्रश ऑप्शन्स
 	Pattern Editing	पैटर्न संपादन
 	Pattern Options	पैटर्न ऑप्शन्स
@@ -3600,8 +3623,8 @@ antiAlias	Sharp	शार्प
 	Preserve Text Editability	टेक्स्ट संपादन क्षमता को संरक्षित करना
 	Preserve Tints	टिंट्स बनाए रखें
 	Preserve:	बनाए रखें:
-	Preset {}	Preset {}
-	Preset {number}	Preset {number}
+	Preset {}	प्रीसेट {}
+	Preset {number}	प्रीसेट {number}
 	PRESET DETAILS	प्रीसेट विवरण
 	Preset Name	प्रीसेट का नाम
 	Preset name:	प्रीसेट का नाम:
@@ -3797,9 +3820,9 @@ antiAlias	Sharp	शार्प
 	Rectangular Grid Tool	आयताकार ग्रिड टूल
 	Rectangular Grid Tool Options	आयताकार ग्रिड टूल ऑप्शन्स
 	Red	लाल
-	Redefine {kind} Style	Redefine {kind} स्टाइल
+	Redefine {kind} Style	{kind} स्टाइल फिर से डिफ़ाइन करें
 	Redefine {name}	{name} फिर से डिफ़ाइन करें
-	Redefine Character Style	रेडफाइन कैरेक्टर स्टाइल
+	Redefine Character Style	कैरेक्टर स्टाइल फिर से डिफ़ाइन करें
 	Redefine Graphic Style	ग्राफ़िक स्टाइल फिर से डिफ़ाइन करें
 	Redefine Graphic Style “{name}”	ग्राफ़िक स्टाइल “{name}” फिर से डिफ़ाइन करें
 	Redefine Paragraph Style	पैराग्राफ़ स्टाइल फिर से डिफ़ाइन करें
@@ -4167,7 +4190,7 @@ antiAlias	Sharp	शार्प
 	Save Document	डॉक्यूमेंट सेव करें
 	Save Document Info…	डॉक्यूमेंट जानकारी सेव करें…
 	Save each artboard to a separate file	प्रत्येक आर्टबोर्ड को एक अलग फ़ाइल में सेव करें
-	Save Export Preset	सेविंग प्रीसेट
+	Save Export Preset	एक्सपोर्ट प्रीसेट सेव करें
 	Save for Office Documents	कार्यालय डॉक्यूमेंट्स के लिए सेव करें
 	Save for Office Documents…	कार्यालय डॉक्यूमेंट्स के लिए सेव करें…
 	Save for Web	वेब के लिए सेव करें
@@ -4464,7 +4487,7 @@ antiAlias	Sharp	शार्प
 	Shadow Intensity	शैडो तीव्रता
 	Shadows and Glows	छाया और चमक
 	Game HUD	गेम HUD
-	Health Fill	स्वास्थ्य
+	Health Fill	हेल्थ फ़िल
 	Mana Glow	माना
 	Damage Flash	क्षति
 	Quest Outline	क्वेस्ट
@@ -4527,7 +4550,7 @@ antiAlias	Sharp	शार्प
 	Shortcuts	शॉर्टकट्स
 	Shorter Than Length	लंबाई से कम
 	Show	दिखाएँ
-	Show {kind} Brushes	शो {kind} ब्रश
+	Show {kind} Brushes	{kind} ब्रश दिखाएँ
 	Show Active Plane Widget	सक्रिय प्लेन विजेट दिखाएं
 	Show All	सभी दिखाएँ
 	Show All Hidden Attributes	सभी छिपे हुए गुण दिखाएँ
@@ -4771,6 +4794,8 @@ antiAlias	Sharp	शार्प
 	Split at Anchors	एंकर पर विभाजित
 	Split at Anchors…	एंकर पर विभाजित…
 	Split at Crossings	क्रॉसिंग में विभाजित
+	Trim at Crossings Tool	क्रॉसिंग पर ट्रिम टूल
+	Trim at Crossings	क्रॉसिंग पर ट्रिम करें
 	Split at Cursor	कर्सर में विभाजित
 	Split Complementary	स्प्लिट कॉम्प्लेमेंटरी
 	Split Freeform Line	स्प्लिट फ्रीफॉर्म लाइन
@@ -4866,7 +4891,7 @@ antiAlias	Sharp	शार्प
 	Strikethrough	स्ट्राइकथ्रू
 	String not closed	स्ट्रिंग बंद नहीं
 	Stroke	स्ट्रोक
-	Stroke (X), double-click for the Color Picker	स्ट्रोक (एक्स), रंग पिकर के लिए डबल क्लिक करें
+	Stroke (X), double-click for the Color Picker	स्ट्रोक (X), कलर पिकर के लिए डबल-क्लिक करें
 	Stroke Color	स्ट्रोक रंग
 	Stroke Direction	स्ट्रोक दिशा
 	Stroke Gradient	स्ट्रोक ग्रेडिएंट
@@ -4995,6 +5020,11 @@ antiAlias	Sharp	शार्प
 	Target:	लक्ष्य:
 	Tate-chu-yoko	ताते-चू-योको
 	Tate-chu-yoko Settings	ताते-चू-योको सेटिंग्स
+	Warichu	वारिचू
+	Warichu Settings…	वारिचू सेटिंग्स…
+	Warichu Settings	वारिचू सेटिंग्स
+	Lines:	पंक्तियाँ:
+	Line Gap:	पंक्ति गैप:
 	Tate-chu-yoko Settings…	ताते-चू-योको सेटिंग्स…
 	Composite Fonts…	कंपोज़िट फ़ॉन्ट…
 	Composite Fonts	कंपोज़िट फ़ॉन्ट
@@ -5173,8 +5203,8 @@ antiAlias	Sharp	शार्प
 	Transform	रूपांतरण करें
 	Transform Again	फिर से बदलना
 	Transform Both	दोनों को बदलना
-	Transform Each	प्रत्येक को बदलना
-	Transform Each…	प्रत्येक ट्रांसफॉर्मर…
+	Transform Each	प्रत्येक को ट्रांसफ़ॉर्म करें
+	Transform Each…	प्रत्येक को ट्रांसफ़ॉर्म करें…
 	Transform in Perspective	पर्सपेक्टिव में रूपांतरण
 	Transform Object Only	केवल ऑब्जेक्ट को ट्रांसफॉर्म करें
 	Transform Objects	ऑब्जेक्ट को रूपांतरित करें
@@ -5357,7 +5387,7 @@ antiAlias	Sharp	शार्प
 	User Graphic Style Library 9	उपयोगकर्ता ग्राफिक स्टाइल लाइब्रेरी 9
 	User Interface	उपयोगकर्ता इंटरफ़ेस
 	User Library	उपयोगकर्ता लाइब्रेरी
-	User Preset	उपयोगकर्ता Preset
+	User Preset	उपयोगकर्ता प्रीसेट
 	User Swatch Library 1	यूज़र स्वॉच लाइब्रेरी 1
 	User Swatch Library 10	यूज़र स्वॉच लाइब्रेरी 10
 	User Swatch Library 2	यूज़र स्वॉच लाइब्रेरी 2
@@ -5739,7 +5769,7 @@ antiAlias	Sharp	शार्प
 @msg	{_1} is {_2} bytes (limit {_3})	{_1} {_2} बाइट्स का है (सीमा {_3})
 @msg	{_1} is a live effect (Effect › Plug-ins)	{_1} एक लाइव इफ़ेक्ट (इफ़ेक्टी> प्लग-इन) है।
 @msg	{_1} is already used by {_2}	{_1} का उपयोग पहले से ही {_2} द्वारा किया जाता है
-@msg	{_1} is an exporter (File › Export › Export As…)	{_1} एक निर्यातक (फ़ाइल> निर्यात › निर्यात As...) है।
+@msg	{_1} is an exporter (File › Export › Export As…)	{_1} एक एक्सपोर्टर है (फ़ाइल › एक्सपोर्ट › इस रूप में एक्सपोर्ट करें…)
 @msg	{_1} is not a file	{_1} एक फ़ाइल नहीं है
 @msg	{_1} is reserved by the system	{_1} सिस्टम द्वारा आरक्षित है
 @msg	{_1} isn't a path	{_1} एक पाथ नहीं है
@@ -5792,8 +5822,8 @@ antiAlias	Sharp	शार्प
 @msg	{key} must be 0–{MAX_ADD_AROUND} pt	{key} होना चाहिए 0-{MAX_ADD_AROUND} pt
 @msg	{key} must be a finite coordinate	{key} एक परिमित निर्देशांक होना चाहिए
 @msg	{key} must be a percentage {min}..100	{key} को {min}..100 के बीच प्रतिशत होना चाहिए
-@msg	{key} must be a positive number, not {n}	{key} एक सकारात्मक संख्या होना चाहिए, नहीं {n}
-@msg	{key} must be a positive number, not {v}	{key} एक सकारात्मक संख्या होना चाहिए, नहीं {v}
+@msg	{key} must be a positive number, not {n}	{key} एक धनात्मक संख्या होनी चाहिए, {n} नहीं
+@msg	{key} must be a positive number, not {v}	{key} एक धनात्मक संख्या होनी चाहिए, {v} नहीं
 @msg	{key} must be an array of non-negative integer object ids	{key} को गैर-नकारात्मक पूर्णांक ऑब्जेक्ट ids की एक सरणी होना चाहिए
 @msg	{key} must be one of {_1}	{key} {_1} में से एक होना चाहिए
 @msg	{key} must be Unix seconds (an integer) or null	{key} को यूनिक्स सेकंड (एक पूर्णांक) या null होना चाहिए
@@ -5807,7 +5837,7 @@ antiAlias	Sharp	शार्प
 @msg	{label} can't build a solid from an image: trace it first with Object › Image Trace › Make.	{label} इमेज से ठोस नहीं बना सकता: पहले ऑब्जेक्ट › इमेज ट्रेस › बनाएँ से उसे ट्रेस करें।
 @msg	{label} keeps 1 of the document's {n} artboards: the file reopens with one. Turn on Preserve Editing Capabilities to keep them all.	{label} डॉक्यूमेंट के {n} आर्टबोर्ड में से 1 रखता है: फ़ाइल एक आर्टबोर्ड के साथ फिर से खुलती है। सभी आर्टबोर्ड रखने के लिए संपादन क्षमताओं को संरक्षित करना विकल्प चालू करें।
 @msg	{label} must be a number	{label} एक नंबर होना चाहिए
-@msg	{label} must be a number above 0 and at most {max}	{label} 0 से ऊपर और सबसे {max} पर होना चाहिए
+@msg	{label} must be a number above 0 and at most {max}	{label} 0 से बड़ी और अधिकतम {max} संख्या होनी चाहिए
 @msg	{label} must be at most {max} characters	{label} में अधिकतम {max} वर्ण होने चाहिए
 @msg	{label} must be one character	{label} एक वर्ण होना चाहिए
 @msg	at most {max} tab stops	अधिकतम {max} टैब स्टॉप
@@ -5816,7 +5846,7 @@ antiAlias	Sharp	शार्प
 @msg	{label} must be a number from {min} to {max}	{label} को {min} से {max} तक एक नंबर होना चाहिए
 @msg	{label} must be a whole number from {min} to {max}	{label} को {min} से {max} तक एक पूर्ण संख्या होना चाहिए
 @msg	{label} must be a number from 1 to 10000	{label} को 1 से 10000 तक एक नंबर होना चाहिए
-@msg	{label} must be a number of at least 0.1	{label} को कम से कम 0.1 होना चाहिए।
+@msg	{label} must be a number of at least 0.1	{label} कम से कम 0.1 की संख्या होनी चाहिए
 @msg	{label} produced an empty result	{label} ने खाली परिणाम का उत्पादन किया
 @msg	{LABEL} produced an empty result	{LABEL} ने खाली परिणाम का उत्पादन किया
 @msg	{label} requires a shape with at least two anchors	{label} को कम से कम दो एंकरों के साथ एक आकार की आवश्यकता होती है
@@ -5829,7 +5859,7 @@ antiAlias	Sharp	शार्प
 @msg	{name} must be {lo}–{hi}{unit} (got {v})	{name} को {lo}-{hi}{unit} ({v}) होना चाहिए।
 @msg	{name}: {e}	{name}: {e}
 @msg	{name}: CRC mismatch	{name}: CRC mismatch
-@msg	{name}: CRC or size mismatch	{name}: CRC or size mismatch
+@msg	{name}: CRC or size mismatch	{name}: CRC या आकार मेल नहीं खाता
 @msg	{name}: no local header	{name}: कोई स्थानीय हैडर नहीं
 @msg	{name}: no such recovery entry	{name}: ऐसी कोई वसूली प्रविष्टि नहीं
 @msg	{name}: only this Affinity file's embedded preview could be read; use File › Open to see it with its warning, or export SVG or PDF from Affinity before placing	{name}: इस Affinity फ़ाइल का केवल एम्बेडेड प्रीव्यू पढ़ा जा सका; इसे इसकी चेतावनी के साथ देखने के लिए फ़ाइल › ओपन का उपयोग करें, या प्लेस करने से पहले Affinity से SVG या PDF निर्यात करें
@@ -5901,6 +5931,9 @@ antiAlias	Sharp	शार्प
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` को `auto` या `en` या `zh-hant` जैसे भाषा कोड होना चाहिए।
 @msg	`{key}` must be 0..{max}	`{key}` होना चाहिए 0.{max}
 @msg	`{key}` must be a #rrggbb color	`{key}` एक #rrggbb रंग होना चाहिए
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` एक #rrggbb रंग या लेयर रंग का नाम होना चाहिए
+@msg	unknown Live Paint option `{key}`	अज्ञात लाइव पेंट ऑप्शन `{key}`
+@msg	unknown Shape Builder option `{key}`	अज्ञात शेप बिल्डर ऑप्शन `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` एक #rrggbb रंग होना चाहिए
 @msg	`{key}` must be a non-negative integer	`{key}` को एक गैर-नकारात्मक पूर्णांक होना चाहिए
 @msg	`{key}` must be a number	`{key}` एक संख्या होना चाहिए
@@ -5981,16 +6014,16 @@ antiAlias	Sharp	शार्प
 @msg	`anchors` must be an array of [subpath, anchor] pairs	`anchors` को [subpath, एंकर] जोड़े की एक सारणी होना चाहिए
 @msg	`anchors` must list anchor indices (0, 1, 2…), not {k}	`anchors` में एंकर इंडेक्स (0, 1, 2…) की सूची होनी चाहिए, {k} नहीं
 @msg	`anchors` must list anchor indices (0, 1, 2…), not {v}	`anchors` में एंकर इंडेक्स (0, 1, 2…) की सूची होनी चाहिए, {v} नहीं
-@msg	`antiAlias` must be "none", "sharp", "crisp" or "strong"	`antiAlias` होना चाहिए "none", "sharp", "crisp" या "strong"
+@msg	`antiAlias` must be "none", "sharp", "crisp" or "strong"	`antiAlias` "none", "sharp", "crisp" या "strong" होना चाहिए
 @msg	`artboards` must be a list of artboard indices	`artboards` को आर्टबोर्ड इंडेक्स की सूची होना चाहिए
 @msg	`artboards`: all or a range such as 1, 3-5, not {v}	`artboards`: all या 1, 3-5 जैसी सीमा दें, {v} नहीं
 @msg	`aspect` must be a number (%)	`aspect` को संख्या (%) होना चाहिए
 @msg	`asset` is the asset id (see assets.list)	`asset` परिसंपत्ति आईडी है (assets.list देखें)
 @msg	`at` must be [x, y]	`at` होना चाहिए [x, y]
-@msg	`at` must be a byte offset	`at` to be a byte ऑफसेट
+@msg	`at` must be a byte offset	`at` बाइट ऑफ़सेट होना चाहिए
 @msg	`autoLeading` must be a number	`autoLeading` को संख्या होना चाहिए
 @msg	`background` must be "", "matte" or #rrggbb	`background` होना चाहिए "", "matte" या #rrggbb
-@msg	`burasagari` must be "none", "standard" or "forced"	`burasagari` होना चाहिए "none", "standard" या "forced"
+@msg	`burasagari` must be "none", "standard" or "forced"	`burasagari` "none", "standard" या "forced" होना चाहिए
 @msg	`by` must be lines, paragraphs, words or glyphs, not {other}	`by` होना चाहिए लाइनों, पैराग्राफ, शब्द या glyphs, नहीं {other}
 @msg	`center` must be [x, y]	`center` होना चाहिए [x, y]
 @msg	`charAlign` must be "romanBaseline", "emBoxTop", "emBoxCenter", "emBoxBottom", "icfTop" or "icfBottom"	`charAlign` को "romanBaseline", "emBoxTop", "emBoxCenter", "emBoxBottom", "icfTop" या "icfBottom" होना चाहिए
@@ -6031,15 +6064,15 @@ antiAlias	Sharp	शार्प
 @msg	`digits` must be one of {_1}	`digits` को {_1} में से एक होना चाहिए
 @msg	`dimImages` is a percentage or false	`dimImages` एक प्रतिशत या false है
 @msg	`direction` must be "auto", "leftToRight" or "rightToLeft"	`direction` को "auto", "leftToRight" या "rightToLeft" होना चाहिए
-@msg	`dither` applies to gradient fills (paint.setFill)	`dither` gradient fills (paint.setFill) पर लागू होता है
+@msg	`dither` applies to gradient fills (paint.setFill)	`dither` ग्रेडिएंट फ़िल पर लागू होता है (paint.setFill)
 @msg	`dither` applies to gradient fills (stroke: false)	`dither` ग्रेडिएंट फ़िल (stroke: false) पर लागू होता है
 @msg	`dither` must be true or false	`dither` को true या false होना चाहिए
 @msg	`documentData` is {size} bytes (limit {MAX_DOCUMENT_DATA})	`documentData` {size} bytes (limit {MAX_DOCUMENT_DATA}) है।
 @msg	`each` is the value one design stands for, more than 0	`each` एक डिज़ाइन का मान है, जो 0 से अधिक होना चाहिए
 @msg	`end` must be "start" or "end"	`end` को "start" या "end" होना चाहिए।
 @msg	`ends` applies to joining exactly two paths	`ends` ठीक दो पाथ को जोड़ने पर लागू होता है
-@msg	`event` must be one of {_1}	`event` is one of the {_1}
-@msg	`every` must be "all", "odd" or "even", not {v}	`every` होना चाहिए "all", "odd" या "even", नहीं {v}
+@msg	`event` must be one of {_1}	`event` {_1} में से एक होना चाहिए
+@msg	`every` must be "all", "odd" or "even", not {v}	`every` "all", "odd" या "even" होना चाहिए, {v} नहीं
 @msg	`expand` must be true or false	`expand` को true या false होना चाहिए
 @msg	`exportPreset` is the name of a preset of document.exportPresets.list	`exportPreset`, document.exportPresets.list के किसी प्रीसेट का नाम है
 @msg	`files` must be 1 to 1000 paths of font files the last text.findFontFiles search found	`files` में पिछली text.findFontFiles सर्च में मिली फ़ॉन्ट फ़ाइलों के 1 से 1000 पाथ होने चाहिए
@@ -6143,11 +6176,11 @@ antiAlias	Sharp	शार्प
 @msg	`preset` must be a string	`preset` एक स्ट्रिंग होना चाहिए
 @msg	`radius` must be from 0 to 1000000 pt	`radius` 0 से 1000000 pt से होना चाहिए
 @msg	`ratio` must be from 0.1 to 0.5	`ratio` को 0.1 से 0.5 तक होना चाहिए
-@msg	`rect` must be [x, y, width, height] with a positive size	`rect` होना चाहिए [x, y, चौड़ाई, ऊंचाई] एक सकारात्मक आकार के साथ
+@msg	`rect` must be [x, y, width, height] with a positive size	`rect` धनात्मक आकार वाला [x, y, width, height] होना चाहिए
 @msg	`relation` must be overlap, inside or outside	`relation` को ओवरलैप, अंदर या बाहर होना चाहिए
 @msg	`reversed` must be true or false	`reversed` को true या false होना चाहिए
 @msg	`rotate` must be a finite number	`rotate` एक परिमित संख्या होना चाहिए
-@msg	`rule` must be nonZero or evenOdd	`rule` होना चाहिए nonZero or evenOdd होना चाहिए
+@msg	`rule` must be nonZero or evenOdd	`rule` nonZero या evenOdd होना चाहिए
 @msg	`sampleSize` must be 1, 3 or 5	`sampleSize` होना चाहिए 1, 3 या 5
 @msg	`scale` must be a number in (0, 100]	`scale` को (0, 100] के बीच की संख्या होना चाहिए
 @msg	`scope` must be "selection" or "document", not {other}	`scope` को "selection" या "document" होना चाहिए, न कि {other}
@@ -6162,7 +6195,7 @@ antiAlias	Sharp	शार्प
 @msg	`size` is a percentage of the base text's size, 1 to 100	`size` आधार टेक्स्ट के आकार का एक प्रतिशत है, 1 से 100
 @msg	`source` and `target` are the same object	`source` और `target` एक ही ऑब्जेक्ट है
 @msg	`source` must be `folder` or `datasets`	`source` होना चाहिए `folder` या `datasets` होना चाहिए
-@msg	`spacing` must be a number	`spacing` होना चाहिए
+@msg	`spacing` must be a number	`spacing` एक संख्या होनी चाहिए
 @msg	`spacing` must be a number of points, 0 or more, or "auto"	`spacing` पॉइंट में 0 या उससे बड़ी संख्या, या "auto" होनी चाहिए
 @msg	`start` must be a finite number	`start` को परिमित संख्या होना चाहिए
 @msg	`starts` must be an array of anchor indices (or nulls)	`starts` को एंकर इंडेक्स (या null) की ऐरे होना चाहिए
@@ -6205,7 +6238,7 @@ antiAlias	Sharp	शार्प
 @msg	`with` moves points, not a handle	`with` पॉइंट मूव करता है, हैंडल नहीं
 @msg	`with` must be a list of at most 10000 spine point indexes	`with` में अधिकतम 10000 स्पाइन पॉइंट इंडेक्स की लिस्ट होनी चाहिए
 @msg	a {_1} series can't go in a {_2} graph	एक {_1} श्रृंखला एक {_2} ग्राफ में नहीं जा सकती
-@msg	a {width}×{height} screenshot's byte count overflows	A {width}×{height} स्क्रीनशॉट की बाइट गिनती ओवरफ्लो
+@msg	a {width}×{height} screenshot's byte count overflows	{width}×{height} स्क्रीनशॉट की बाइट संख्या सीमा से बाहर है
 @msg	a batch preview cannot switch documents	एक बैच प्रीव्यू डॉक्यूमेंट्स को स्विच नहीं कर सकता
 @msg	a bitmap is empty	एक बिटमैप खाली है
 @msg	a bitmap is too large to read	बिटमैप पढ़ने के लिए बहुत बड़ा है
@@ -6233,7 +6266,7 @@ antiAlias	Sharp	शार्प
 @msg	a feConvolveMatrix filter's order is {x}×{y}, which overflows the kernel-size multiply usvg makes	एक feConvolveMatrix फिल्टर का आदेश {x} ×{y} है, जो कर्नेल-आकार की बहुप्लाई usvg को ओवरफ्लो करता है।
 @msg	a freeform gradient keeps at least one point	फ़्रीफ़ॉर्म ग्रेडिएंट में कम से कम एक पॉइंट रहता है
 @msg	a gradient needs at least two stops	कम से कम दो स्टॉप की आवश्यकता होती है
-@msg	a gradient preset is already called {n}	gradient preset पहले से ही कहा जाता है {n}
+@msg	a gradient preset is already called {n}	{n} नाम का ग्रेडिएंट प्रीसेट पहले से मौजूद है
 @msg	a graph has at most {_1} series, so it transposes with at most that many categories	एक ग्राफ में सबसे {_1} श्रृंखला है, इसलिए यह उस कई श्रेणियों के साथ ट्रांसपोजित होता है।
 @msg	a graph's records don't end where they should: its art was read as it is	एक ग्राफ का रिकॉर्ड अंत नहीं है जहां उन्हें होना चाहिए: इसकी कला को पढ़ा गया क्योंकि यह है
 @msg	a graphic style named `{to}` already exists	`{to}` नामक एक ग्राफिक स्टाइल पहले से मौजूद है
@@ -6259,7 +6292,7 @@ antiAlias	Sharp	शार्प
 @msg	a page is missing	एक पेज गायब हो रहा है
 @msg	a page object is used by something else	एक पृष्ठ ऑब्जेक्ट का उपयोग किसी अन्य चीज़ के द्वारा किया जाता है
 @msg	a page out of range	श्रेणी से बाहर एक पृष्ठ
-@msg	a page thumbnail must be RGB pixels, 1 to {THUMBNAIL_SIZE} a side (got {w} × {h})	एक पृष्ठ थंबनेल RGB पिक्सल होना चाहिए, 1 to {THUMBNAIL_SIZE} a side (not {w} × {h})
+@msg	a page thumbnail must be RGB pixels, 1 to {THUMBNAIL_SIZE} a side (got {w} × {h})	पेज थंबनेल RGB पिक्सल का होना चाहिए, हर तरफ़ 1 से {THUMBNAIL_SIZE} (मिला {w} × {h})
 @msg	a page tree kid isn't a reference	एक पृष्ठ पेड़ बच्चा एक संदर्भ नहीं है
 @msg	a page tree node has no kids	पृष्ठ पेड़ नोड में कोई बच्चे नहीं है
 @msg	a page's placement is not finite	एक पृष्ठ का प्लेसमेंट परिमित नहीं है
@@ -6270,14 +6303,14 @@ antiAlias	Sharp	शार्प
 @msg	a pattern named `{n}` exists	`{n}` नामक एक पैटर्न मौजूद है
 @msg	a PDF presets file with over {_1} presets	{_1} प्रीसेट के साथ एक PDF प्रीसेट फ़ाइल
 @msg	a plug-in with id {_1} is already installed	आईडी {_1} के साथ एक प्लग-इन पहले से ही स्थापित है
-@msg	a PostScript error ({name} in `{op}`; {meaning})	एक पोस्टस्क्रिप्ट त्रुटि ({name} in `{op}`; {meaning})
-@msg	a PostScript error ({name} in `{op}`; {meaning}), in {procs}	PostScript त्रुटि ({name} in `{op}`; {meaning}), {procs}
+@msg	a PostScript error ({name} in `{op}`; {meaning})	पोस्टस्क्रिप्ट त्रुटि (`{op}` में {name}; {meaning})
+@msg	a PostScript error ({name} in `{op}`; {meaning}), in {procs}	पोस्टस्क्रिप्ट त्रुटि (`{op}` में {name}; {meaning}), {procs} में
 @msg	a PostScript error ({name} in `{op}`: {at}; {meaning})	PostScript त्रुटि (`{op}` में {name}: {at}; {meaning})
 @msg	a PostScript error ({name} in `{op}`: {at}; {meaning}), in {procs}	PostScript त्रुटि (`{op}` में {name}: {at}; {meaning}), {procs} में
-@msg	a PostScript error ({name} in `{op}`: {at})	एक पोस्टस्क्रिप्ट त्रुटि ({name} in `{op}`: {at})
-@msg	a PostScript error ({name} in `{op}`: {at}), in {procs}	एक पोस्टस्क्रिप्ट त्रुटि ({name} in `{op}`: {at}), {procs}
-@msg	a PostScript error ({name} in `{op}`)	पोस्टस्क्रिप्ट त्रुटि ({name} in `{op}`)
-@msg	a PostScript error ({name} in `{op}`), in {procs}	PostScript त्रुटि ({name} in `{op}`), {procs}
+@msg	a PostScript error ({name} in `{op}`: {at})	पोस्टस्क्रिप्ट त्रुटि (`{op}` में {name}: {at})
+@msg	a PostScript error ({name} in `{op}`: {at}), in {procs}	पोस्टस्क्रिप्ट त्रुटि (`{op}` में {name}: {at}), {procs} में
+@msg	a PostScript error ({name} in `{op}`)	पोस्टस्क्रिप्ट त्रुटि (`{op}` में {name})
+@msg	a PostScript error ({name} in `{op}`), in {procs}	पोस्टस्क्रिप्ट त्रुटि (`{op}` में {name}), {procs} में
 @msg	a PostScript error ({name}; {meaning})	PostScript त्रुटि ({name}; {meaning})
 @msg	a PostScript error ({name})	पोस्टस्क्रिप्ट त्रुटि ({name})
 @msg	a preset named `{_1}` exists	`{_1}` नामक एक प्रीसेट मौजूद है
@@ -6293,7 +6326,7 @@ antiAlias	Sharp	शार्प
 @msg	a start must be an anchor index ≥ 0 or null	प्रारंभ में एक एंकर इंडेक्स होना चाहिए ≥ 0 या null
 @msg	a stream runs past the end	एक स्ट्रीम अंत तक चलता है
 @msg	a stream's length is wrong	धारा की लंबाई गलत है
-@msg	a stream's length isn't a number	एक धारा की लंबाई नहीं है
+@msg	a stream's length isn't a number	स्ट्रीम की लंबाई कोई संख्या नहीं है
 @msg	a style named `{name}` already exists	`{name}` नामक एक स्टाइल पहले से मौजूद है
 @msg	a style named `{to}` already exists	`{to}` नामक एक स्टाइल पहले से मौजूद है
 @msg	a swatch needs a colour, gradient or pattern	स्वॉच को रंग, ग्रेडिएंट या पैटर्न चाहिए
@@ -6318,7 +6351,7 @@ antiAlias	Sharp	शार्प
 @msg	aiVersion 7 writes legacy .ai files, not .ait templates	aiVersion 7 विरासत .ai फ़ाइलों को लिखते हैं, .ait टेम्पलेट नहीं
 @msg	All colors are within the CMYK gamut	सभी रंग CMYK गामट के भीतर हैं
 @msg	already editing a pattern	पहले से ही एक पैटर्न संपादन
-@msg	already editing an opacity mask	पहले से ही एक opacity मास्क संपादित करें
+@msg	already editing an opacity mask	ओपेसिटी मास्क पहले से संपादित किया जा रहा है
 @msg	already editing another object's opacity mask	पहले से ही किसी अन्य ऑब्जेक्ट के अपारदर्शिता मास्क को संपादित करना
 @msg	already in pattern editing mode	पहले से ही पैटर्न संपादन मोड में
 @msg	an action in the action set file has more than 10,000 steps	एक्शन सेट फ़ाइल में एक कार्रवाई 10,000 से अधिक कदम है
@@ -6338,7 +6371,7 @@ antiAlias	Sharp	शार्प
 @msg	an image VectorCraft can't read was left out	एक इमेज VectorCraft पढ़ा नहीं जा सकता था
 @msg	an image whose data is cut short was left out	जिस इमेज का डेटा छोटा है उसे छोड़ दिया गया था
 @msg	an index must be a whole number	एक सूचकांक होना चाहिए पूरी संख्या
-@msg	an inline graphic has no glyphs	एक इनलाइन ग्राफ़िक में कोई glyph नहीं है
+@msg	an inline graphic has no glyphs	इनलाइन ग्राफ़िक में कोई ग्लिफ़ नहीं है
 @msg	an invisible text form can't be read	एक अदृश्य टेक्स्ट फॉर्म नहीं पढ़ा जा सकता है
 @msg	an object can't be read	किसी ऑब्जेक्ट को पढ़ा नहीं जा सकता
 @msg	an object in perspective would leave the edited grid	पर्सपेक्टिव में एक ऑब्जेक्ट संपादित ग्रिड छोड़ देगी
@@ -6352,37 +6385,37 @@ antiAlias	Sharp	शार्प
 @msg	anchor `{key}` must be [x, y]	एंकर `{key}` होना चाहिए [x, y]
 @msg	anchor `{key}` must be a number	एंकर `{key}` को एक नंबर होना चाहिए
 @msg	anchor `smooth` must be true or false	एंकर का `smooth` true या false होना चाहिए
-@msg	anchor must name a registered panel	anchor: एंकर को एक पंजीकृत पैनल का नाम देना चाहिए
+@msg	anchor must name a registered panel	anchor किसी पंजीकृत पैनल का नाम होना चाहिए
 @msg	angle and roundness must be finite	कोण और गोलाई परिमित होना चाहिए
-@msg	angles must be a list as long as pins (degrees or null)	angles: कोण एक सूची होना चाहिए जब तक पिन (डिग्री या null)
+@msg	angles must be a list as long as pins (degrees or null)	angles पिन जितनी लंबी सूची होनी चाहिए (डिग्री या null)
 @msg	Angles require two straight segments	कोणों को दो सीधे खंडों की आवश्यकता होती है
 @msg	antiAlias `{id}`: none, art or type	antiAlias `{id}`: none, art या type
 @msg	appearance must be flat|center|edge	appearance को flat|center|edge होना चाहिए
 @msg	apply is "fill" or "stroke", not `{other}`	apply "fill" या "stroke" है, नहीं `{other}`
-@msg	area must be a closed polygon of 3 to 100000 [x, y] points	area: क्षेत्र 3 से 100000 [x, y] पॉइंट का एक बंद बहुभुज होना चाहिए
+@msg	area must be a closed polygon of 3 to 100000 [x, y] points	area 3 से 100000 [x, y] पॉइंट का एक बंद बहुभुज होना चाहिए
 @msg	area type {_1} is named twice	एरिया टाइप {_1} का नाम दो बार दिया गया है
 @msg	area type in frames too short for a line of the font it shows in got taller frames ({_1}): their type wouldn't show otherwise	अपने फ़ॉन्ट की एक लाइन के लिए बहुत छोटे फ़्रेम वाले एरिया टाइप को लंबे फ़्रेम दिए गए ({_1}): वरना उनका टाइप नहीं दिखता
 @msg	area type needs a path that encloses an area	एरिया टाइप को ऐसा पाथ चाहिए जो किसी क्षेत्र को घेरता हो
-@msg	arrowAlign must be extend|tip, got {o}	arrowAlign होना चाहिए thetip, get {o}
+@msg	arrowAlign must be extend|tip, got {o}	arrowAlign को extend|tip होना चाहिए, {o} मिला
 @msg	arrowScale must be [start, end]	arrowScale होना चाहिए [शुरू, अंत]
 @msg	artboard {0} does not exist	आर्टबोर्ड {0} मौजूद नहीं है
 @msg	artboard {i} doesn't print	आर्टबोर्ड {i} प्रिंट नहीं करता है
-@msg	artboard is a 0-based index	artboard: आर्टबोर्ड एक 0-आधारित इंडेक्स है
-@msg	artboard must be a 0-based index	artboard: आर्टबोर्ड एक 0-आधारित इंडेक्स होना चाहिए
+@msg	artboard is a 0-based index	artboard 0 से शुरू होने वाला इंडेक्स है
+@msg	artboard must be a 0-based index	artboard 0 से शुरू होने वाला इंडेक्स होना चाहिए
 @msg	artboardLayout must be {layout?, columns?, spacing?, rightToLeft?}	artboardLayout को {layout?, columns?, spacing?, rightToLeft?} होना चाहिए
 @msg	artboardLayout.columns must be 1 or more	artboardLayout.columns को 1 या अधिक होना चाहिए
 @msg	artboardLayout.layout must be gridByRow, gridByColumn, row or column	artboardLayout.layout को gridByRow, gridByColumn, row या column होना चाहिए
 @msg	artboardLayout.rightToLeft must be true or false	artboardLayout.rightToLeft को true या false होना चाहिए
 @msg	artboardLayout.spacing must be 0–{MAX_SPACING} pt	artboardLayout.spacing को 0–{MAX_SPACING} pt होना चाहिए
-@msg	artboards must be a non-empty list	artboards: आर्टबोर्ड एक गैर-खाली सूची होना चाहिए
-@msg	artboards must be a number	artboards: आर्टबोर्ड एक नंबर होना चाहिए
+@msg	artboards must be a non-empty list	artboards एक गैर-खाली सूची होनी चाहिए
+@msg	artboards must be a number	artboards एक संख्या होनी चाहिए
 @msg	asset `{_1}` has no art to export	संपत्ति `{_1}` को निर्यात करने के लिए कोई कला नहीं है
 @msg	at most {MAX_KEYWORDS} keywords	सबसे अधिक {MAX_KEYWORDS} कीवर्ड
 @msg	at most {MAX_MATCHES} matches are kept	अधिकांश {MAX_MATCHES} मैचों को रखा जाता है
 @msg	at most {MAX_POINTS} points	{MAX_POINTS} पॉइंट पर
 @msg	at most {MAX_QUEUE} files	सबसे अधिक {MAX_QUEUE} फ़ाइलों में
 @msg	at most {MAX_UNGROUPED} parameters outside groups: give the others a `group`	समूहों के बाहर अधिकतम {MAX_UNGROUPED} पैरामीटर: बाकी को एक `group` दें
-@msg	at must be [x, y]	at: [x, y] होना चाहिए
+@msg	at must be [x, y]	at [x, y] होना चाहिए
 @msg	at this scale the drawing is {w} × {h} pt, more than the canvas holds: choose a smaller scale or fit it to the artboard	इस पैमाने पर ड्राइंग {w} × {h} pt है, कैनवास से अधिक रखती है: एक छोटे पैमाने सिलेक्ट करें या इसे आर्टबोर्ड पर फिट करें
 @msg	at/rect lie outside the canvas	कैनवास के बाहर / सही झूठ
 @msg	attribute must be size|leading|tracking|kerning|baselineShift	attribute को size|leading|tracking|kerning|baselineShift होना चाहिए
@@ -6401,8 +6434,8 @@ antiAlias	Sharp	शार्प
 @msg	automation path rejected: path is empty	स्वचालन पाथ खारिज: पाथ खाली है
 @msg	automation path rejected: reserved device names are not allowed: {path}	स्वचालन पाथ खारिज कर दिया: आरक्षित उपकरण नामों की अनुमति नहीं है: {path}
 @msg	automation path rejected: the folder's name isn't valid text	स्वचालन पाथ खारिज: फ़ोल्डर का नाम वैध टेक्स्ट नहीं है
-@msg	axis must be "vertical", "horizontal" or an angle in degrees, not `{given}`	axis: अक्ष को "vertical", "horizontal" या डिग्री में एक कोण होना चाहिए, नहीं `{given}``
-@msg	axis must be "vertical", "horizontal" or an angle in degrees, not `{v}`	axis: अक्ष को "vertical", "horizontal" या डिग्री में एक कोण होना चाहिए, नहीं `{v}`
+@msg	axis must be "vertical", "horizontal" or an angle in degrees, not `{given}`	axis "vertical", "horizontal" या डिग्री में कोण होना चाहिए, `{given}` नहीं
+@msg	axis must be "vertical", "horizontal" or an angle in degrees, not `{v}`	axis "vertical", "horizontal" या डिग्री में कोण होना चाहिए, `{v}` नहीं
 @msg	background {other}: transparent, white, black or a colour such as "#ff8800"	पृष्ठभूमि {other}: पारदर्शी, सफेद, काला या एक रंग जैसे "#ff8800"
 @msg	backgroundContents must be transparent or white	backgroundContents को transparent या white होना चाहिए
 @msg	bad {k} colour	बुरा {k} रंग
@@ -6438,22 +6471,22 @@ antiAlias	Sharp	शार्प
 @msg	bad stream length	खराब धारा की लंबाई
 @msg	bad trailer	बुरा ट्रेलर
 @msg	bad trailer size	बुरा ट्रेलर आकार
-@msg	balance must be between 0 and 100	balance: 0 से 100 के बीच संतुलन होना चाहिए
+@msg	balance must be between 0 and 100	balance 0 से 100 के बीच होना चाहिए
 @msg	batch step {_1} (`{id}`) failed: {e}	बैच चरण {_1} (`{id}`) विफल: {e}
 @msg	Batch: {count} processed	बैच: {count} संसाधित
 @msg	Batch: {count} processed, {failed} failed	बैच: {count} संसाधित, {failed} विफल
 @msg	batches cannot nest	बैच घोंसला नहीं कर सकते
-@msg	before must name a panel	before: पहले एक पैनल का नाम देना चाहिए
+@msg	before must name a panel	before में किसी पैनल का नाम होना चाहिए
 @msg	below and above must name a panel floating in another group	नीचे और ऊपर एक पैनल दूसरे समूह में चल रहा है नाम होना चाहिए
 @msg	bind something to a variable first	पहले किसी ऑब्जेक्ट को वेरिएबल से बाँधें
-@msg	bleed must be 0–{MAX_BLEED} pt: a number, [top, bottom, left, right] or {{top, bottom, left, right}}	bleed होना चाहिए 0-{MAX_BLEED} pt: a number, [top, bottom, left, right] or {{top, bottom, left, right}}
+@msg	bleed must be 0–{MAX_BLEED} pt: a number, [top, bottom, left, right] or {{top, bottom, left, right}}	bleed 0–{MAX_BLEED} pt होना चाहिए: एक संख्या, [top, bottom, left, right] या {{top, bottom, left, right}}
 @msg	Blend colors: select at least three objects with filled colours	मिश्रित रंग: भरे हुए रंगों के साथ कम से कम तीन ऑब्जेक्ट चुनें
 @msg	BMP files are RGB or grayscale: colorModel rgb or gray	BMP फ़ाइलें RGB या ग्रेस्केल होती हैं: colorModel को rgb या gray रखें
 @msg	brightness must be dark|mediumDark|mediumLight|light	brightness को dark|mediumDark|mediumLight|light होना चाहिए
-@msg	brush must be a name or null	brush: ब्रश एक नाम या null होना चाहिए
+@msg	brush must be a name or null	brush एक नाम या null होना चाहिए
 @msg	brushes move only within their type	ब्रश केवल उनके प्रकार के भीतर ही चलते हैं
 @msg	brushes VectorCraft can't read yet were left out of the Brushes panel ({_1})	ब्रश VectorCraft को अभी तक नहीं पढ़ा जा सकता है ब्रश पैनल ({_1}) से बाहर छोड़ दिया गया था।
-@msg	by must be a number	by: द्वारा एक नंबर होना चाहिए
+@msg	by must be a number	by एक संख्या होनी चाहिए
 @msg	can't add page thumbnails: {why}	पेज थंबनेल नहीं जोड़ा जा सकता: {why}
 @msg	can't add the editing data for other apps: {why}	अन्य ऐप्स के लिए संपादन डेटा नहीं जोड़ सकते: {why}
 @msg	can't edit the written PDF: {why}	लिखित PDF संपादित नहीं कर सकता: {why}
@@ -6464,7 +6497,7 @@ antiAlias	Sharp	शार्प
 @msg	can't open `{_1}`: {_2}	`{_1}` नहीं खोल सकते: {_2}
 @msg	can't open `{_1}`: {e}	`{_1}` नहीं खोल सकते: {e}
 @msg	can't open `{name}`: not a format VectorCraft reads (see document.formats)	`{name}` ओपन नहीं कर सकते: VectorCraft इस फ़ॉर्मैट को पढ़ नहीं सकता (document.formats देखें)
-@msg	can't parse shortcut `{c}`	नहीं कर सकते हैं a shortcut `{c}`
+@msg	can't parse shortcut `{c}`	शॉर्टकट `{c}` पार्स नहीं किया जा सका
 @msg	can't parse shortcut `{s}` for `{k}`	`{k}` के लिए शॉर्टकट `{s}` को पार नहीं कर सकता
 @msg	can't place `{name}`: not a format VectorCraft reads (see document.formats)	`{name}` प्लेस नहीं कर सकते: VectorCraft इस फ़ॉर्मैट को पढ़ नहीं सकता (document.formats देखें)
 @msg	can't read back the written PDF: {e}	लिखित PDF को वापस नहीं पढ़ सकते: {e}
@@ -6484,7 +6517,7 @@ antiAlias	Sharp	शार्प
 @msg	cannot split an open path at its end point	अपने अंतिम बिंदु पर एक खुले रास्ते को विभाजित नहीं कर सकता है
 @msg	case must be upper|lower|title|sentence	case को upper|lower|title|sentence होना चाहिए
 @msg	category `{c}`: one of {_1}	श्रेणी `{c}`: {_1} में से एक
-@msg	center must be [x, y]	center: केंद्र होना चाहिए [x, y]
+@msg	center must be [x, y]	center [x, y] होना चाहिए
 @msg	check a layer to export	निर्यात करने के लिए एक लेयर की जांच करें
 @msg	check an artboard to export	निर्यात करने के लिए एक आर्टबोर्ड की जांच करें
 @msg	check an asset to export	निर्यात करने के लिए एक परिसंपत्ति की जांच करें
@@ -6508,8 +6541,8 @@ antiAlias	Sharp	शार्प
 @msg	clip must be true or false	clip को true या false होना चाहिए
 @msg	clipboard is empty	क्लिपबोर्ड खाली है
 @msg	clippingMask must be true or false	clippingMask को true या false होना चाहिए
-@msg	closed must be a boolean	closed: बंद होना चाहिए एक boolean
-@msg	closing needs three anchors	closing: बंद करने की जरूरत है तीन एंकर
+@msg	closed must be a boolean	closed एक boolean होना चाहिए
+@msg	closing needs three anchors	बंद करने के लिए तीन एंकर चाहिए
 @msg	collapsed must be true or false	collapsed को true या false होना चाहिए
 @msg	color.profile: no RGB or CMYK profile is called “{profile}”	color.profile: "{profile}" नाम की कोई RGB या CMYK प्रोफ़ाइल नहीं है
 @msg	colorMode must be rgb or cmyk, not `{m}`	colorMode को rgb या cmyk होना चाहिए, `{m}` नहीं
@@ -6529,16 +6562,16 @@ antiAlias	Sharp	शार्प
 @msg	Combine Slices: the slices have no bounds	स्लाइस को मिलाएं: स्लाइस में कोई सीमा नहीं है
 @msg	command `{0}` is not available right now: {1}	आदेश `{0}` अभी उपलब्ध नहीं है: {1}
 @msg	command `{id}` is not available right now	आदेश `{id}` अभी उपलब्ध नहीं है
-@msg	command must be a shape.* command	command: आदेश एक आकार होना चाहिए।* आदेश
+@msg	command must be a shape.* command	command कोई shape.* कमांड होना चाहिए
 @msg	commands[{i}]: missing `command`	आदेश [{i}]: लापता `command`
-@msg	composer must be "singleLine" or "everyLine"	composer: संगीतकार "singleLine" या "everyLine" होना चाहिए।
+@msg	composer must be "singleLine" or "everyLine"	composer "singleLine" या "everyLine" होना चाहिए
 @msg	compound {_1} must contain exactly one open path to join	जोड़ने के लिए कंपाउंड {_1} में ठीक एक खुला पाथ होना चाहिए
 @msg	compound paths can only contain paths	यौगिक पाथ में केवल पाथ हो सकते हैं
 @msg	compound shapes take paths, compound paths, groups, compound shapes, type, blends and envelopes	कंपाउंड शेप पाथ, कंपाउंड पाथ, समूह, कंपाउंड शेप, टाइप, ब्लेंड और एन्वेलप लेते हैं
 @msg	compressed (RLE) bitmaps can't be read yet	संकुचित (RLE) bitmaps अभी तक पढ़ा नहीं जा सकता है
 @msg	connect end must be "start" or "end"	कनेक्ट अंत "start" या "end" होना चाहिए
-@msg	connect needs a path other than the one extended	connect: कनेक्ट एक विस्तारित के अलावा एक पाथ की जरूरत है
-@msg	connect needs id	connect: कनेक्ट करने की जरूरत आईडी
+@msg	connect needs a path other than the one extended	connect के लिए बढ़ाए गए पाथ के अलावा कोई दूसरा पाथ चाहिए
+@msg	connect needs id	connect के लिए id चाहिए
 @msg	connect path has no open end	कनेक्ट पाथ का कोई खुला अंत नहीं है
 @msg	Contour: select paths or shapes	कंटूर: पाथ या आकृतियों सिलेक्ट करें
 @msg	Contour: the Offset Path effect is not available	Contour: ऑफसेट पाथ इफ़ेक्ट उपलब्ध नहीं है
@@ -6651,8 +6684,8 @@ antiAlias	Sharp	शार्प
 @msg	there is no script engine named {name}	{name} नाम का कोई स्क्रिप्ट इंजन नहीं है
 @msg	Running a script	स्क्रिप्ट चल रही है
 @msg	Copied the script report	Copied स्क्रिप्ट रिपोर्ट
-@msg	copy needs path: the file to copy into the document's folder	copy: प्रतिलिपि की जरूरत है पाथ: फ़ाइल को डॉक्यूमेंट के फ़ोल्डर में कॉपी करने के लिए
-@msg	copy takes images only: relink placed documents where their files are	copy: प्रतिलिपि केवल इमेज को लेती है: डॉक्यूमेंट्स को फिर से लिंक करें जहां उनकी फ़ाइलें हैं
+@msg	copy needs path: the file to copy into the document's folder	copy के लिए path चाहिए: डॉक्यूमेंट के फ़ोल्डर में कॉपी करने वाली फ़ाइल
+@msg	copy takes images only: relink placed documents where their files are	copy केवल इमेज लेता है: प्लेस किए गए डॉक्यूमेंट्स को वहीं फिर से लिंक करें जहाँ उनकी फ़ाइलें हैं
 @msg	copying a file isn't available on the web	एक फ़ाइल की प्रतिलिपि वेब पर उपलब्ध नहीं है
 @msg	copyrightStatus must be unknown, copyrighted or publicDomain	copyrightStatus को unknown, copyrighted या publicDomain होना चाहिए
 @msg	copyrightUrl must be a URL (no spaces, at most 2048 characters)	copyrightUrl को URL होना चाहिए (स्पेस नहीं, अधिकतम 2048 अक्षर)
@@ -6660,7 +6693,7 @@ antiAlias	Sharp	शार्प
 @msg	corners must be 4 [x, y] points (TL, TR, BR, BL)	corners में 4 [x, y] पॉइंट (TL, TR, BR, BL) होने चाहिए
 @msg	could not decode image: {0}	इमेज को डीकोड नहीं कर सकता: {0}
 @msg	Couldn't copy to the system clipboard: {e}	सिस्टम क्लिपबोर्ड को कॉपी नहीं कर सका: {e}
-@msg	Couldn't open {name}: {e}	नहीं खोल सकता {name}: {e}
+@msg	Couldn't open {name}: {e}	{name} ओपन नहीं हो सका: {e}
 @msg	Couldn't paste from the clipboard: {e}	क्लिपबोर्ड से पेस्ट नहीं कर सका: {e}
 @msg	Couldn't paste: the document it was pasted in was closed	पेस्ट नहीं कर सका: इसमें चिपकाए गए डॉक्यूमेंट को बंद कर दिया गया था
 @msg	Couldn't place {name}: {e}	नहीं रह सकता {name}: {e}
@@ -6671,11 +6704,15 @@ antiAlias	Sharp	शार्प
 @msg	Couldn't paste: the document it was pasted in was reverted	पेस्ट नहीं कर सका: जिस डॉक्यूमेंट में पेस्ट किया जा रहा था, उसे मूल स्थिति में लाया गया
 @msg	Couldn't read {name}: {e}	नहीं पढ़ सकता {name}: {e}
 @msg	Couldn't save recovery data: {e}	रिकवरी डेटा सेव नहीं किया जा सका: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	{title} का रिकवरी डेटा सेव नहीं किया जा सका: {e}। प्रतिलिपियाँ {folder} में जाती हैं, जो डिफ़ॉल्ट रिकवरी फ़ोल्डर है; कोई दूसरा फ़ोल्डर इस्तेमाल करने के लिए प्रेफ़रेंसेज़ → फ़ाइल हैंडलिंग → डेटा रिकवरी → फ़ोल्डर (recoveryFolder) सेट करें
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	{title} का रिकवरी डेटा सेव नहीं किया जा सका: {e}। प्रतिलिपियाँ {folder} में जाती हैं, जो प्रेफ़रेंसेज़ में सेट किया गया फ़ोल्डर है; कोई दूसरा फ़ोल्डर इस्तेमाल करने के लिए प्रेफ़रेंसेज़ → फ़ाइल हैंडलिंग → डेटा रिकवरी → फ़ोल्डर (recoveryFolder) सेट करें
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	रिकवरी डेटा सेव नहीं किया जा सका: {e}। प्रतिलिपियाँ {folder} में जाती हैं, जो डिफ़ॉल्ट रिकवरी फ़ोल्डर है; कोई दूसरा फ़ोल्डर इस्तेमाल करने के लिए प्रेफ़रेंसेज़ → फ़ाइल हैंडलिंग → डेटा रिकवरी → फ़ोल्डर (recoveryFolder) सेट करें
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	रिकवरी डेटा सेव नहीं किया जा सका: {e}। प्रतिलिपियाँ {folder} में जाती हैं, जो प्रेफ़रेंसेज़ में सेट किया गया फ़ोल्डर है; कोई दूसरा फ़ोल्डर इस्तेमाल करने के लिए प्रेफ़रेंसेज़ → फ़ाइल हैंडलिंग → डेटा रिकवरी → फ़ोल्डर (recoveryFolder) सेट करें
 @msg	counterPer `{c}`: item or file	counterPer `{c}`: item या file
 @msg	Create from Guides: the document has no artboard	गाइड से बनाएँ: डॉक्यूमेंट में कोई आर्टबोर्ड नहीं है
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	गाइड से बनाएँ: गाइड {MAX_PIECES} स्लाइस से अधिक बनाते हैं
 @msg	Create from Selection: the selection has no area	सिलेक्शन से बनाएँ: सिलेक्शन में कोई क्षेत्र नहीं है
-@msg	Create needs fills, strokes or both	जरूरतों को पूरा करने, स्ट्रोक या दोनों की जरूरत है
+@msg	Create needs fills, strokes or both	बनाने के लिए फ़िल, स्ट्रोक या दोनों चाहिए
 @msg	Create Outlines: select text objects	आउटलाइन बनाएं: टेक्स्ट ऑब्जेक्ट चुनें
 @msg	crop `{_1}`: only PDF pages have art, trim, bleed and media boxes; use "crop" or "bounding"	क्रॉप `{_1}`: केवल PDF पेजों में आर्ट, ट्रिम, ब्लीड और मीडिया बॉक्स होते हैं; "crop" या "bounding" का उपयोग करें
 @msg	crop rectangle doesn't overlap the image	क्रॉप आयत इमेज को ओवरलैप नहीं करता
@@ -6691,9 +6728,9 @@ antiAlias	Sharp	शार्प
 @msg	damaged	क्षतिग्रस्त
 @msg	damaged compressed data: {e}	क्षतिग्रस्त संकुचित डेटा: {e}
 @msg	dash lengths must be numbers, got {v}	डैश की लंबाई नंबर होना चाहिए, {v} होना चाहिए
-@msg	dash must be a list of lengths or null, got {v}	dash: डैश लंबाई या null की एक सूची होना चाहिए, {v} मिला
+@msg	dash must be a list of lengths or null, got {v}	dash लंबाइयों की सूची या null होना चाहिए, {v} मिला
 @msg	data key `{k}`: letters, digits, -, _ and . (not name or vc-…)	डेटा कुंजी `{k}`: अक्षर, अंक, -, _ और (नाम या vc-...)
-@msg	data must be an object of key: value, not {v}	data: डेटा कुंजी का एक ऑब्जेक्ट होना चाहिए: मान, नहीं {v}
+@msg	data must be an object of key: value, not {v}	data, key: value वाला ऑब्जेक्ट होना चाहिए, {v} नहीं
 @msg	Data Recovery can't keep copies in {path}: {e}	डेटा रिकवरी {path} में प्रतियां नहीं रख सकती: {e}
 @msg	Data Recovery has nowhere to keep copies: set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	डेटा रिकवरी की प्रतिलिपियाँ रखने के लिए कहीं नहीं है: निर्धारित प्राथमिकता → फ़ाइल हैंडलिंग → डेटा रिकवरी → फ़ोल्डर (recoveryFolder)
 @msg	data set `{name}` holds a control character, which a variable library can't hold	डेटा सेट `{name}` में एक कंट्रोल कैरेक्टर है, जिसे वेरिएबल लाइब्रेरी में नहीं रखा जा सकता
@@ -6701,23 +6738,23 @@ antiAlias	Sharp	शार्प
 @msg	data set `{name}` holds two values for `{var}`	डेटा सेट `{name}` में `{var}` के लिए दो मान हैं।
 @msg	data set `{name}` is declared twice	डेटा सेट `{name}` को दो बार घोषित किया गया है
 @msg	data set `{name}` starts or ends with white space, which a variable library can't hold	डेटा सेट `{name}` की शुरुआत या अंत में व्हाइटस्पेस है, जिसे वेरिएबल लाइब्रेरी में नहीं रखा जा सकता
-@msg	data takes at most {MAX_DATA} keys at once	data: डेटा एक बार में सबसे {MAX_DATA} कुंजी लेता है
+@msg	data takes at most {MAX_DATA} keys at once	data एक बार में अधिकतम {MAX_DATA} कुंजियाँ लेता है
 @msg	data the program reads is damaged or cut short, or the program asks for a position in a file that has none	प्रोग्राम पढ़ने वाले डेटा को क्षतिग्रस्त या छोटा काट दिया जाता है, या प्रोग्राम एक फ़ाइल में एक स्थिति के लिए पूछता है जिसमें कोई नहीं है।
 @msg	dataset `{name}` already exists	डेटासेट `{name}` पहले से मौजूद है
 @msg	dataset `{to}` already exists	डेटासेट `{to}` पहले से मौजूद है
 @msg	date `{d}`: YYYY-MM-DD	दिनांक `{d}`: YYYYY-MM-DD
-@msg	decimals must be {_1}–{_2} (got {_3})	decimals: दशमलव होना चाहिए {_1}-{_2} ({_3})
+@msg	decimals must be {_1}–{_2} (got {_3})	decimals {_1}–{_2} होना चाहिए (मिला {_3})
 @msg	decoded data is too large	डीकोडेड डेटा बहुत बड़ा है
 @msg	define a variable first	पहले एक वेरिएबल परिभाषित करें
 @msg	detect must be true or false	detect को true या false होना चाहिए
-@msg	Dimension is locked or hidden	आयाम बंद या छिपा हुआ है
+@msg	Dimension is locked or hidden	आयाम लॉक या छिपा हुआ है
 @msg	Dimension mode does not match its source	आयाम मोड अपने स्रोत से मेल नहीं खाता है
 @msg	Dimension point is outside the canvas	आयाम बिंदु कैनवास के बाहर है
 @msg	Dimension size is outside its supported range	आयाम आकार अपनी समर्थित सीमा से बाहर है
 @msg	direct-select anchor points of a path	एक पाथ के प्रत्यक्ष सिलेक्शन एंकर अंक
 @msg	direct-select anchor points to cut at (not the end points of open paths)	डायरेक्ट-सिलेक्शन एंकर पॉइंट्स को कट करने के लिए ( ओपन पाथ के अंतिम बिंदु नहीं)
 @msg	direct-select the anchor points to remove	हटाने के लिए एंकर पॉइंट्स सिलेक्ट करें
-@msg	distance must be > 0	distance: दूरी होना चाहिए > 0
+@msg	distance must be > 0	distance > 0 होना चाहिए
 @msg	divide into 1 to {MAX_PIECES} slices	1 से {MAX_PIECES} स्लाइस में विभाजित करें
 @msg	Divide Objects Below: select a path	नीचे दिए गए ऑब्जेक्ट्स को विभाजित करें: एक पाथ चुनें
 @msg	Divide Objects Below: select exactly one path	नीचे दिए गए ऑब्जेक्ट्स को विभाजित करें: बिल्कुल एक पाथ चुनें
@@ -6728,12 +6765,12 @@ antiAlias	Sharp	शार्प
 @msg	dx and dy must be numbers	डीएक्स और डीआई होना चाहिए
 @msg	DXF {field} `{s}`: {allowed}	DXF {field} `{s}`: {allowed}
 @msg	dxf fitTo must be [width, height], positive	dxf fitTo को धनात्मक [width, height] होना चाहिए
-@msg	dxf must be an object of DXF import options	dxf: DXF को DXF आयात ऑप्शन्स का एक ऑब्जेक्ट होना चाहिए
+@msg	dxf must be an object of DXF import options	dxf DXF आयात ऑप्शन्स का एक ऑब्जेक्ट होना चाहिए
 @msg	DXF options: {e}	DXF ऑप्शन्स: {e}
-@msg	dxf scale must be a positive number up to {_1}, not {s}	Dxf स्केल को {_1} तक सकारात्मक संख्या होना चाहिए, न कि {s}
-@msg	DXF scale must be a positive number up to {_1}, not {scale}	DXF स्केल को {_1} तक सकारात्मक संख्या होना चाहिए, न कि {scale}
+@msg	dxf scale must be a positive number up to {_1}, not {s}	dxf स्केल {_1} तक की धनात्मक संख्या होनी चाहिए, न कि {s}
+@msg	DXF scale must be a positive number up to {_1}, not {scale}	DXF स्केल {_1} तक की धनात्मक संख्या होनी चाहिए, न कि {scale}
 @msg	dxf unit `{u}`: a unit such as mm, cm, in or pt	dxf इकाई `{u}`: एक इकाई जैसे mm, cm, in या pt
-@msg	dxf: {e}	Dxf: {e}
+@msg	dxf: {e}	dxf: {e}
 @msg	each format is an object {format, scale?, suffix?}	हर फ़ॉर्मैट एक ऑब्जेक्ट {format, scale?, suffix?} है
 @msg	each item needs an id	प्रत्येक आइटम को एक आईडी की आवश्यकता होती है
 @msg	each match needs `kind`	प्रत्येक मैच की जरूरत है `kind`
@@ -6745,7 +6782,7 @@ antiAlias	Sharp	शार्प
 @msg	each stop needs a position	प्रत्येक स्टॉप को स्थिति की आवश्यकता होती है
 @msg	each subpath needs an anchors array	प्रत्येक उपपाथ को एक एंकर सरणी की आवश्यकता होती है
 @msg	easingType must be easeIn, easeOut, easeInOut or easeOutIn	easingType को easeIn, easeOut, easeInOut या easeOutIn होना चाहिए
-@msg	Edit Original opens image and document files only; “{name}” is not one	मूल रूप से केवल इमेज और डॉक्यूमेंट फ़ाइलों को खोलता है; "{name}" एक नहीं है
+@msg	Edit Original opens image and document files only; “{name}” is not one	मूल एडिट करें केवल इमेज और डॉक्यूमेंट फ़ाइलें ओपन करता है; "{name}" इनमें से नहीं है
 @msg	editingData must be true or false	editingData को true या false होना चाहिए
 @msg	editingData must be true, false or "always"	editingData को true, false या "always" होना चाहिए
 @msg	edits overlap	ओवरलैप संपादित करें
@@ -6755,10 +6792,10 @@ antiAlias	Sharp	शार्प
 @msg	empty cutter	खाली कटर
 @msg	empty header in column {_1}	कॉलम में खाली हैडर {_1}
 @msg	empty path	खाली पाथ
-@msg	encoding `{_1}`: utf8 or utf16	एन्कोडिंग `{_1}`: utf8 or utf16
-@msg	ends must be two of "first" and "last"	ends: समाप्त होता है दो "first" और "last" होना चाहिए।
+@msg	encoding `{_1}`: utf8 or utf16	एन्कोडिंग `{_1}`: utf8 या utf16
+@msg	ends must be two of "first" and "last"	ends में "first" और "last" में से दो मान होने चाहिए
 @msg	EPS {field} `{s}`: {allowed}	EPS {field} `{s}`: {allowed}
-@msg	EPS flattener: {e}	ईपीएस flattener: {e}
+@msg	EPS flattener: {e}	EPS फ़्लैटनर: {e}
 @msg	EPS options: {e}	ईपीएस ऑप्शन्स: {e}
 @msg	EPS Save writes all artwork: use document.export for selected-only EPS	EPS सेव पूरा आर्टवर्क लिखता है: केवल सिलेक्ट किए आर्टवर्क के EPS के लिए document.export उपयोग करें
 @msg	every numbered name for {name} is taken in the document's folder	{name} के लिए हर नंबर का नाम डॉक्यूमेंट के फ़ोल्डर में लिया जाता है
@@ -6784,16 +6821,16 @@ antiAlias	Sharp	शार्प
 @msg	Exporting {_1}	निर्यात {_1}
 @msg	exportText must be editable or appearance	exportText को editable या appearance होना चाहिए
 @msg	exportType must be movieClip or graphic, not `{s}`	exportType को movieClip या graphic होना चाहिए, `{s}` नहीं
-@msg	extend needs id	extend: विस्तार की जरूरत है आईडी
+@msg	extend needs id	extend के लिए id चाहिए
 @msg	extension {e} is listed twice	एक्सटेंशन {e} को दो बार सूचीबद्ध किया गया है
 @msg	extension {e}: use 1-16 lower-case letters and digits, without the dot	एक्सटेंशन {e}: डॉट के बिना, 1-16 लोअर-केस अक्षरों और अंकों का उपयोग करें
-@msg	featureChanges lists at most {MAX_FEATURE_CHANGES} tags	featureChanges list at most {MAX_FEATURE_CHANGES} टैग
+@msg	featureChanges lists at most {MAX_FEATURE_CHANGES} tags	featureChanges में अधिकतम {MAX_FEATURE_CHANGES} टैग होते हैं
 @msg	featureChanges must be a list of tags	featureChanges को टैग की सूची होना चाहिए
 @msg	features lists at most {max} tags	अधिकांश {max} टैग पर सूची
-@msg	features must be a list of tags	features: विशेषताएं टैग की एक सूची होना चाहिए
-@msg	fidelity must be 0..100	fidelity: निष्ठा 0..100 होना चाहिए
+@msg	features must be a list of tags	features टैग की एक सूची होनी चाहिए
+@msg	fidelity must be 0..100	fidelity 0..100 होना चाहिए
 @msg	file version {0} is newer than this VectorCraft supports ({VERSION})	फ़ाइल संस्करण {0} इस वेक्टर क्रेफ्ट समर्थन ({VERSION}) की तुलना में नया है।
-@msg	files must be {name, dataBase64}	files: फ़ाइलों को {name, dataBase64} होना चाहिए
+@msg	files must be {name, dataBase64}	files {name, dataBase64} होना चाहिए
 @msg	finish editing the pattern first	पहले पैटर्न को संपादित करना
 @msg	First measured segment no longer exists	पहले मापा खंड अब मौजूद नहीं है
 @msg	fit must be none|autoHeight|shrinkText|block, got {id}	fit को none|autoHeight|shrinkText|block होना चाहिए, {id} मिला
@@ -6801,7 +6838,7 @@ antiAlias	Sharp	शार्प
 @msg	Flat Logo traced the image at {_1} × {_2} pixels, averaged down from {_3} × {_4}.	फ्लैट लोगो ने {_1} × {_2} पिक्सेल पर इमेज का पता लगाया, जो {_3} × {_4} से नीचे है।
 @msg	Flatten Transparency: {e}	Flatten transparency: {e}
 @msg	Flatten Transparency: select objects to flatten	Flatten Transparency: ऑब्जेक्ट्स को सपाट करने के लिए चुनें
-@msg	flattener: {e}	Flattener: {e}
+@msg	flattener: {e}	फ़्लैटनर: {e}
 @msg	flattenerPreset `{name}`: high, medium, low or a saved one (see flattener.presets.list)	flattenerPreset `{name}`: high, medium, low या सेव किया हुआ प्रीसेट (flattener.presets.list देखें)
 @msg	flipProfile must be along|across, got {o}	flipProfile को along|across होना चाहिए, {o} मिला
 @msg	folders `{f}`: none, rows, format, item or itemFormat	folders `{f}`: none, rows, format, item या itemFormat
@@ -6810,42 +6847,42 @@ antiAlias	Sharp	शार्प
 @msg	font family `{family}` is not available	फ़ॉन्ट परिवार `{family}` उपलब्ध नहीं है
 @msg	font family `{tf}` is not available	फ़ॉन्ट परिवार `{tf}` उपलब्ध नहीं है
 @msg	fonts not copied: {fonts}	फ़ॉन्ट कॉपी नहीं हुए: {fonts}
-@msg	format `{f}`: pdf or postscript	फ़ॉर्मैट `{f}`: pdf or postscript
+@msg	format `{f}`: pdf or postscript	फ़ॉर्मैट `{f}`: pdf या postscript
 @msg	format `{f}`: text or json	फ़ॉर्मैट `{f}`: टेक्स्ट या json
 @msg	format is `{format}`	फ़ॉर्मैट `{format}` है
-@msg	formats must be an array of rows, not {v}	formats: फ़ॉर्मैट पंक्तियों की एक सरणी होना चाहिए, न कि {v}
+@msg	formats must be an array of rows, not {v}	formats पंक्तियों की ऐरे होनी चाहिए, {v} नहीं
 @msg	freeform line {i} must be an array of point indices	फ्रीफॉर्म लाइन {i} को पॉइंट इंडेक्स की एक सरणी होना चाहिए
 @msg	freeform point {i} needs `at` [x, y] and a valid `color`	फ्रीफॉर्म पॉइंट {i} को `at` [x, y] और एक वैध `color` की आवश्यकता होती है
-@msg	frequency must be between 1 and 300 lines per inch	frequency: आवृत्ति प्रति इंच 1 और 300 लाइनों के बीच होना चाहिए
+@msg	frequency must be between 1 and 300 lines per inch	frequency प्रति इंच 1 से 300 लाइनों के बीच होनी चाहिए
 @msg	from and to must be finite	से और होना चाहिए करने के लिए
-@msg	from must be [x0, y0, x1, y1]	from: से होना चाहिए [x0, y0, x1, y1]
-@msg	give {key, value} or {values}	{key, value} or {values}
-@msg	give `{a}` and `{b}`	देना `{a}` and `{b}`
+@msg	from must be [x0, y0, x1, y1]	from [x0, y0, x1, y1] होना चाहिए
+@msg	give {key, value} or {values}	{key, value} या {values} दें
+@msg	give `{a}` and `{b}`	`{a}` और `{b}` दें
 @msg	give `anchor`, the index of the anchor to slide	खिसकाने वाले एंकर का इंडेक्स `anchor` दें
 @msg	give `before` or `after`, not both	`before` या `after` दें, दोनों नहीं
-@msg	give `char` or `text`	देना `char` or `text`
+@msg	give `char` or `text`	`char` या `text` दें
 @msg	give `colors`, or `color` and `rule`	देना `colors`, या `color` और `rule`
 @msg	give `event`, such as onclick	देना `event`, जैसे onclick
 @msg	give `file`, the JavaScript file's path or URL	देना `file`, जावास्क्रिप्ट फ़ाइल का पाथ या यूआरएल
-@msg	give `fill` and/or `stroke`	`fill` और/or`stroke`
+@msg	give `fill` and/or `stroke`	`fill` और/या `stroke` दें
 @msg	give `fill`, `stroke` or both	`fill`, `stroke` या दोनों
 @msg	give `folder`	देना `folder`
 @msg	give `fonts`, or open a document	देना `fonts`, या एक डॉक्यूमेंट ओपन करें
 @msg	give `from` or `indices`, not both	`from` या `indices` दें, दोनों नहीं
 @msg	give `id` (no text is being edited)	देना `id` (कोई टेक्स्ट संपादित नहीं किया जा रहा है)
 @msg	give `id` and `anchors`, or `items`, not both	देना `id` और `anchors`, या `items`, दोनों नहीं
-@msg	give `id` or `guide`, not both	देना `id` or `guide`, दोनों नहीं
-@msg	give `inkLimit`, `removeWhiteOverprint` or `overprintBlack`	देना `inkLimit`, `removeWhiteOverprint` or `overprintBlack`
+@msg	give `id` or `guide`, not both	`id` या `guide` दें, दोनों नहीं
+@msg	give `inkLimit`, `removeWhiteOverprint` or `overprintBlack`	`inkLimit`, `removeWhiteOverprint` या `overprintBlack` दें
 @msg	give `length` or `to`	`length` या `to` देना
 @msg	give `matches`: [{kind, name, target}]	`matches`: [{kind, name, target}]
 @msg	give `name` (or edit a pattern)	`name` (या एक पैटर्न संपादित करें)
 @msg	give `name` or `names`	`name` या `names` दें
-@msg	give `path` (a .wasm file) or `dataBase64` (the module)	`path` (a .wasm file) या `dataBase64` (module)
+@msg	give `path` (a .wasm file) or `dataBase64` (the module)	`path` (.wasm फ़ाइल) या `dataBase64` (मॉड्यूल) दें
 @msg	give `path`, `data` or `dataBase64`	देना `path`, `data` या `dataBase64`
 @msg	give `path`, `data`, `dataBase64` or `csv`	देना `path`, `data`, `dataBase64` या `csv`
 @msg	give `path`, `xml` or `dataBase64`	देना `path`, `xml` या `dataBase64`
 @msg	give `script`, the JavaScript the event runs ("" removes the event)	देना `script`, जावास्क्रिप्ट घटना रन (""" घटना को हटा देता है)
-@msg	give `text` (the reading) or `remove`	`text` (remove`) या `remove`
+@msg	give `text` (the reading) or `remove`	`text` (रीडिंग) या `remove` दें
 @msg	give `width` or `height`	`width` या `height` दें
 @msg	give `x` and `y` (and a `tolerance` of 0 or more)	`x` और `y` दें (और 0 या अधिक `tolerance`)
 @msg	give a fraction `t` from 0 to 1	0 से 1 तक एक अंश `t` देना
@@ -6875,7 +6912,7 @@ antiAlias	Sharp	शार्प
 @msg	give formats or a preset, not both	फ़ॉर्मैट या एक पूर्व निर्धारित देना, दोनों ही नहीं
 @msg	give horizontal or vertical	क्षैतिज या ऊर्ध्वाधर देना
 @msg	give newName or delete	newName या delete दें
-@msg	give offset or by	ऑफसेट देना या by
+@msg	give offset or by	offset या by दें
 @msg	give one of `to`, `rect` or `at`	`to`, `rect` या `at` में से एक देना
 @msg	give one of assets, layers, selection or fullDocument	assets, layers, selection या fullDocument में से एक दें
 @msg	give only one of onto, above, below, icon and a column place	केवल ऊपर, नीचे, आइकन और एक स्तंभ स्थान देने के लिए
@@ -6905,17 +6942,17 @@ antiAlias	Sharp	शार्प
 @msg	glyph {_1} is not drawn for {ch} with the character's style (such as All Caps, Small Caps or a numeral system)	Glyph {_1} चरित्र की स्टाइल (जैसे सभी कैप्स, छोटे कैप्स या एक संख्यात्मक प्रणाली) के साथ {ch} के लिए तैयार नहीं है।
 @msg	glyph {g} is not an alternate of {ch} in {_1} {_2}	Glyph {g} {_1} {_2} में {ch} का एक वैकल्पिक नहीं है।
 @msg	gradient “{name}” isn't defined in the file: a plain colour stands in for it	ग्रेडिएंट "{name}" को फ़ाइल में परिभाषित नहीं किया गया है: इसके लिए एक सादे रंग खड़ा है
-@msg	gradient must be "objects" or "mesh"	gradient: ग्रेडिएंट "objects" या "mesh" होना चाहिए
+@msg	gradient must be "objects" or "mesh"	gradient "objects" या "mesh" होना चाहिए
 @msg	graphs come in as plain art, without their data or settings	ग्राफ़ अपने डेटा या सेटिंग्स के बिना सादे कला के रूप में आते हैं
-@msg	grays must be "profile" or "black", not `{g}`	grays: ग्रे "profile" या "black" होना चाहिए, नहीं `{g}`
+@msg	grays must be "profile" or "black", not `{g}`	grays "profile" या "black" होना चाहिए, `{g}` नहीं
 @msg	gridColors must be a preset name or two colours	gridColors को प्रीसेट नाम या दो रंग होना चाहिए
 @msg	gridSize must be small, medium or large	gridSize को small, medium या large होना चाहिए
-@msg	group must be the id of a Shaper Group	group: समूह को एक शेपर ग्रुप का आईडी होना चाहिए
+@msg	group must be the id of a Shaper Group	group किसी शेपर ग्रुप की id होनी चाहिए
 @msg	group must be true or false	group को true या false होना चाहिए
 @msg	guide {g} is not selected	गाइड {g} नहीं चुना गया है
 @msg	guides are locked	गाइड लॉक कर रहे हैं
 @msg	handle must be 0..3	handle को 0..3 होना चाहिए
-@msg	handle must be in or out	handle: संभालना चाहिए या बाहर होना चाहिए
+@msg	handle must be in or out	handle in या out होना चाहिए
 @msg	heightWidth must be from 1 to 1000 %	heightWidth को 1 से 1000 % होना चाहिए
 @msg	hiddenObjects {v}: "layer" (the default), "omit" or "visible"	hiddenObjects {v}: "layer" (डिफ़ॉल्ट), "omit" या "visible"
 @msg	highlight a layer to merge into	में विलय करने के लिए एक लेयर को हाइलाइट करें
@@ -6927,7 +6964,7 @@ antiAlias	Sharp	शार्प
 @msg	icon only docks a panel in the icon column, with no anchor	आइकन केवल आइकन कॉलम में एक पैनल को डॉक करता है, जिसमें कोई एंकर नहीं होता है
 @msg	id {value} is a layer, not an object	Id {value} एक लेयर है, कोई ऑब्जेक्ट नहीं है
 @msg	id {value} is a layer, not an object; move layers with layer.move	id {value} एक लेयर है, ऑब्जेक्ट नहीं; लेयर्स को layer.move से स्थानांतरित करें
-@msg	id must be a dimension id	id: आईडी एक आयाम आईडी होना चाहिए
+@msg	id must be a dimension id	id किसी आयाम की id होनी चाहिए
 @msg	Identify Objects By is XML ID: the name must be a valid XML ID (start with a letter, underscore or colon; no spaces)	ऑब्जेक्ट्स को XML ID से पहचानें: नाम एक वैध XML ID होना चाहिए (एक पत्र, अंडरस्कोर या कॉलोन के साथ शुरू; कोई स्थान नहीं)
 @msg	ids must contain 1–10000 object ids	ids में 1–10000 ऑब्जेक्ट ids होना चाहिए
 @msg	image '{key}' has no pixels and was left out	इमेज '{key}' में कोई पिक्सेल नहीं है और इसे छोड़ दिया गया था
@@ -6945,25 +6982,25 @@ antiAlias	Sharp	शार्प
 @msg	Imported {what}: {_1}	आयात {what}: {_1}
 @msg	Imported library {name}	आयातित लाइब्रेरी {name}
 @msg	included must be true or false	included को true या false होना चाहिए
-@msg	index must be ≥ 0	index: सूचकांक होना चाहिए ≥ 0
-@msg	index must be a number or first, previous, next or last	index को एक नंबर या first, previous, next या last होना चाहिए
-@msg	index must be a number or first, previous, next or last, not `{other}`	index को एक नंबर या first, previous, next या last होना चाहिए, `{other}` नहीं
+@msg	index must be ≥ 0	index ≥ 0 होना चाहिए
+@msg	index must be a number or first, previous, next or last	index कोई संख्या या first, previous, next या last होना चाहिए
+@msg	index must be a number or first, previous, next or last, not `{other}`	index कोई संख्या या first, previous, next या last होना चाहिए, `{other}` नहीं
 @msg	index out of range	रेंज से बाहर सूचकांक
 @msg	Installed plug-in {_1}	स्थापित प्लग-इन {_1}
 @msg	installing from a path is not available on the web; pass the module as `dataBase64`	एक पाथ से स्थापित वेब पर उपलब्ध नहीं है; मॉड्यूल को `dataBase64`` के रूप में पास करें
-@msg	instances must be 1..1000	instances: उदाहरण 1..1000
+@msg	instances must be 1..1000	instances 1..1000 होना चाहिए
 @msg	instruction budget	निर्देश बजट
-@msg	internal error in `{cmd}`: {msg} (the document was left as it was before; please report this bug)	`{cmd}` में आंतरिक त्रुटि: {msg} (लेखन पहले ही छोड़ दिया गया था); कृपया इस बग की रिपोर्ट करें)
+@msg	internal error in `{cmd}`: {msg} (the document was left as it was before; please report this bug)	`{cmd}` में आंतरिक त्रुटि: {msg} (डॉक्यूमेंट पहले जैसा ही छोड़ दिया गया; कृपया इस बग की रिपोर्ट करें)
 @msg	internal error: {msg} (please report this bug)	आंतरिक त्रुटि: {msg} (कृपया इस बग की रिपोर्ट करें)
 @msg	Internal error: {msg} (please report this bug)	आंतरिक त्रुटि: {msg} (कृपया इस बग की रिपोर्ट करें)
 @msg	invalid `color`	अमान्य `color`
 @msg	invalid anchor index {v}: expected a non-negative integer	अमान्य एंकर इंडेक्स {v}: एक गैर-नकारात्मक पूर्णांक की उम्मीद
 @msg	invalid anchor reference {v}: expected [subpath, anchor]	अमान्य एंकर संदर्भ {v}: उम्मीद [subpath, एंकर]
-@msg	invalid angle	अमानवीय कोण
+@msg	invalid angle	अमान्य कोण
 @msg	invalid brush: {e}	अमान्य ब्रश: {e}
 @msg	invalid color	अमान्य रंग
 @msg	invalid colour {c}	अमान्य रंग {c}
-@msg	invalid delta	अवैध डेल्टा
+@msg	invalid delta	अमान्य डेल्टा
 @msg	Invalid dimension distance	अमान्य आयाम दूरी
 @msg	Invalid dimension font name	अमान्य आयाम फ़ॉन्ट नाम
 @msg	Invalid dimension offset	अमान्य आयाम ऑफसेट
@@ -6977,16 +7014,17 @@ antiAlias	Sharp	शार्प
 @msg	invalid parameter name {k}	अमान्य पैरामीटर नाम {k}
 @msg	invalid parameters for `{cmd}`: {msg}	`{cmd}` के लिए अमान्य पैरामीटर: {msg}
 @msg	invalid pattern tile choice	अमान्य पैटर्न टाइल ऑप्शन
-@msg	invalid PDF setting: {0}	Invalid PDF सेटिंग: {0}
+@msg	invalid PDF setting: {0}	अमान्य PDF सेटिंग: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	आर्टबोर्ड {n} का पेज {size} है, जो PDF की 14,400 pt (200 in) की पेज सीमा से लंबा है: इसे {unit} के UserUnit के साथ लिखा जाता है, इसलिए UserUnit को अनदेखा करने वाले ऐप इसे उतने गुना छोटा दिखाते हैं
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	आर्टबोर्ड {n} का पेज {size} है, जो PDF की 14,400 pt (200 in) की पेज सीमा से लंबा है: इसे {unit} के UserUnit के साथ लिखा जाता है, इसलिए UserUnit को अनदेखा करने वाले ऐप इसे उतने गुना छोटा दिखाते हैं: "200 in से लंबे पेज पूरे आकार में, पॉइंट में लिखें" चालू करें
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	आर्टबोर्ड {n} का पेज {size} है, जो PDF की 14,400 pt (200 in) की पेज सीमा से लंबा है: {label} पेज बिना UserUnit के, पॉइंट में लिखे जाते हैं, और सीमा मानने वाले ऐप पेज को 200 in पर काट देते हैं
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 में UserUnit नहीं है, जिसकी 14,400 pt (200 in) से लंबे पेज को अपना आकार बनाए रखने के लिए ज़रूरत होती है: फ़ाइल PDF 1.6 के रूप में लिखी जाती है
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 में UserUnit नहीं है, जिसकी 14,400 pt (200 in) से लंबे पेज को PDF/A-2 की 14,400 इकाइयों की पेज सीमा के भीतर रहने के लिए ज़रूरत होती है: फ़ाइल PDF 1.6 के रूप में लिखी जाती है
 @msg	the page of artboard {n} is {size}, too long and narrow for PDF's page sides of 3 to 14,400 units: it is written with a UserUnit of {unit}, which keeps the short side at 3 units or more, and apps that keep to the limit cut the long side to 14,400 units	आर्टबोर्ड {n} का पेज {size} है, जो PDF की 3 से 14,400 इकाई की पेज भुजाओं के लिए बहुत लंबा और संकरा है: इसे {unit} की UserUnit के साथ लिखा जाता है, जो छोटी भुजा को 3 इकाई या अधिक पर रखती है, और सीमा का पालन करने वाले ऐप लंबी भुजा को 14,400 इकाई पर काट देते हैं
 @msg	{label} files hold real numbers up to {max}, and the page of artboard {n}, {side} pt long, needs larger ones: choose PDF 1.6 or later without a PDF/X standard, or a smaller artboard	{label} फ़ाइलें {max} तक की वास्तविक संख्याएँ रखती हैं, और आर्टबोर्ड {n} का {side} pt लंबा पेज इससे बड़ी संख्याएँ माँगता है: बिना PDF/X मानक के PDF 1.6 या बाद का चुनें, या छोटा आर्टबोर्ड
-@msg	invalid point	अमानवीय बिंदु
-@msg	Invalid point	अमानवीय बिंदु
-@msg	Invalid real scale	अमानवीय वास्तविक पैमाने
+@msg	invalid point	अमान्य बिंदु
+@msg	Invalid point	अमान्य बिंदु
+@msg	Invalid real scale	अमान्य वास्तविक स्केल
 @msg	invalid restored panel group	अमान्य बहाल पैनल समूह
 @msg	invalid size	अमान्य आकार
 @msg	invalid stroke widths	अमान्य स्ट्रोक चौड़ाई
@@ -7014,8 +7052,8 @@ antiAlias	Sharp	शार्प
 @msg	its editing data doesn't say where its artboard is	इसके संपादन डेटा का कहना नहीं है कि इसका आर्टबोर्ड कहां है?
 @msg	its editing data has no layers	इसके संपादन डेटा में कोई लेयरें नहीं हैं
 @msg	its editing data is damaged	इसके संपादन डेटा क्षतिग्रस्त हो जाता है
-@msg	its editing data is for a {w} × {h} pt page, not the file's {pw} × {ph} pt page	इसके संपादन डेटा एक {w} × {h} pt page के लिए है, फ़ाइल का {pw} × {ph} pt page
-@msg	its editing data is for a {w} × {h} pt page, the file's {pw} × {ph} pt page at {scale}	इसके संपादन डेटा एक {w} × {h} pt page के लिए है, फ़ाइल का {pw} × {ph} pt page {scale} पर
+@msg	its editing data is for a {w} × {h} pt page, not the file's {pw} × {ph} pt page	इसका संपादन डेटा {w} × {h} pt के पेज के लिए है, फ़ाइल के {pw} × {ph} pt के पेज के लिए नहीं
+@msg	its editing data is for a {w} × {h} pt page, the file's {pw} × {ph} pt page at {scale}	इसका संपादन डेटा {w} × {h} pt के पेज के लिए है; फ़ाइल का पेज {scale} पर {pw} × {ph} pt है
 @msg	its editing data is for a different page	इसके संपादन डेटा एक अलग पृष्ठ के लिए है
 @msg	its layers use {_1}, which aren't read yet	इसकी लेयरें {_1} का उपयोग करती हैं, जो अभी तक पढ़ा नहीं जाता है
 @msg	its metadata has no description	इसके मेटाडाटा में कोई विवरण नहीं है
@@ -7032,26 +7070,26 @@ antiAlias	Sharp	शार्प
 @msg	join two different paths	दो अलग पाथ जोड़ें
 @msg	Join: a subpath went missing	जोड़ते समय एक सबपाथ नहीं मिला
 @msg	justify must be auto|left|center|right|justifyAll	justify को auto|left|center|right|justifyAll होना चाहिए
-@msg	kbps must be a positive number, not {kbps}	kbps एक सकारात्मक संख्या होना चाहिए, नहीं {kbps}
+@msg	kbps must be a positive number, not {kbps}	kbps एक धनात्मक संख्या होनी चाहिए, {kbps} नहीं
 @msg	kerning must be a number, "auto", or "optical"	kerning एक संख्या, "auto", या "optical" होना चाहिए
-@msg	keywords must be a list of words or a comma-separated string	keywords: कीवर्ड शब्दों की एक सूची होना चाहिए या एक अल्पसंख्यक स्ट्रिंग होना चाहिए
-@msg	keywords must be at most {MAX_KEYWORD} characters, without control characters	keywords: कीवर्ड नियंत्रण वर्णों के बिना, अधिकांश {MAX_KEYWORD} वर्णों पर होना चाहिए
+@msg	keywords must be a list of words or a comma-separated string	keywords शब्दों की सूची या कॉमा से अलग की गई स्ट्रिंग होनी चाहिए
+@msg	keywords must be at most {MAX_KEYWORD} characters, without control characters	keywords अधिकतम {MAX_KEYWORD} वर्णों के होने चाहिए, कंट्रोल वर्णों के बिना
 @msg	kind must be 1, 2 or 3, or give a preset `name` (see perspective.presets.list)	kind 1, 2 या 3 होना चाहिए, या प्रीसेट `name` दें (perspective.presets.list देखें)
 @msg	kind must be graphic, fillColor, strokeColor, fillGradient, strokeGradient, fillPattern, strokePattern, charStyle or paraStyle	kind को graphic, fillColor, strokeColor, fillGradient, strokeGradient, fillPattern, strokePattern, charStyle या paraStyle होना चाहिए
-@msg	knockout must be "on", "off", "neutral" or a bool, not {v}	knockout: नॉकआउट को "on", "off", "neutral" या एक बोल, न {v} होना चाहिए
-@msg	lang must be one of {_1}	lang: लैंग को {_1} में से एक होना चाहिए
+@msg	knockout must be "on", "off", "neutral" or a bool, not {v}	knockout "on", "off", "neutral" या bool होना चाहिए, {v} नहीं
+@msg	lang must be one of {_1}	lang {_1} में से एक होना चाहिए
 @msg	larger than 256 MB	256 MB से अधिक
 @msg	layer `{name}` has no art to export	लेयर `{name}` को निर्यात करने के लिए कोई कला नहीं है
-@msg	layer must name a layer or sublayer	layer: लेयर को एक लेयर या सबलेयर नाम देना चाहिए
+@msg	layer must name a layer or sublayer	layer में किसी लेयर या सबलेयर का नाम होना चाहिए
 @msg	layers can't be intertwined: select the objects in them	लेयर्स में हस्तक्षेप नहीं किया जा सकता है: उनमें ऑब्जेक्ट्स सिलेक्ट करें
 @msg	layers can't be wrap objects	लेयर्स को लपेटा नहीं जा सकता
 @msg	layers go only at the top level or in layers, objects in layers and groups	लेयरें केवल शीर्ष स्तर पर या लेयर्स में, लेयर्स और समूहों में ऑब्जेक्टएं
 @msg	layers must be true or false	layers को true या false होना चाहिए
 @msg	layout must be gridByRow, gridByColumn, row or column	layout को gridByRow, gridByColumn, row या column होना चाहिए
-@msg	leading must be a number or "auto"	leading: अग्रणी एक नंबर या "auto" होना चाहिए
+@msg	leading must be a number or "auto"	leading कोई संख्या या "auto" होना चाहिए
 @msg	left/right must be non-negative widths	बाएं / दाएं गैर-नकारात्मक चौड़ाई होना चाहिए
 @msg	level `{t}`: 2 or 3	स्तर `{t}`: 2 या 3
-@msg	library panel `{given}` isn't missing its library	लाइब्रेरी पैनल `{given}` अपने लाइब्रेरी को याद नहीं कर रहा है
+@msg	library panel `{given}` isn't missing its library	लाइब्रेरी पैनल `{given}` की लाइब्रेरी गुम नहीं है
 @msg	library panel `{given}` isn't open	लाइब्रेरी पैनल `{given}` खुला नहीं है
 @msg	line {line}: more than {MAX_CSV_COLS} columns	लाइन {line}: {MAX_CSV_COLS} कॉलम से अधिक
 @msg	line {line}: unclosed quote	लाइन {line}: unclosed उद्धरण
@@ -7076,7 +7114,7 @@ antiAlias	Sharp	शार्प
 @msg	manifest: {e}	प्रकटन: {e}
 @msg	margin: a {m} pt margin leaves no imageable area on the paper	मार्जिन: एक {m} pt मार्जिन कागज पर कोई इमेजेबल क्षेत्र नहीं छोड़ता है
 @msg	mask art ends outside a mask dictionary	मास्क कला एक मास्क शब्दकोश के बाहर समाप्त होता है
-@msg	matrix must be finite and invertible, depth finite	matrix: मैट्रिक्स को परिमित और उलटा, गहराई परिमित होना चाहिए
+@msg	matrix must be finite and invertible, depth finite	matrix परिमित और व्युत्क्रमणीय होनी चाहिए, और depth परिमित
 @msg	matte: {e}	मैट: {e}
 @msg	Measured anchor no longer exists	मापने वाला एंकर अब मौजूद नहीं है
 @msg	Invalid measured point	मापा गया बिंदु अमान्य है
@@ -7098,13 +7136,13 @@ antiAlias	Sharp	शार्प
 @msg	missing `family`	`family` अनुपस्थित है
 @msg	missing `find`	लापता `find`
 @msg	missing `folder`	लापता `folder`
-@msg	missing `gid` (a glyph id, or null for the default glyph)	लापता `gid` (a glyph id, या डिफ़ॉल्ट glyph के लिए null)
+@msg	missing `gid` (a glyph id, or null for the default glyph)	लापता `gid` (ग्लिफ़ id, या डिफ़ॉल्ट ग्लिफ़ के लिए null)
 @msg	missing `group`	लापता `group`
 @msg	missing `id`	लापता `id`
 @msg	missing `id` (see plugin.list)	अनुपलब्ध `id` (plugin.list देखें)
 @msg	missing `id`: give one, or select one type object	लापता `id`: एक दें, या एक टाइप ऑब्जेक्ट सिलेक्ट करें
-@msg	missing `index` (a point index, or null to clear)	लापता `index` (a बिंदु सूचकांक, या स्पष्ट करने के लिए null)
-@msg	missing `index` (a stop index, or null to clear)	लापता `index` (a स्टॉप इंडेक्स, या स्पष्ट करने के लिए null)
+@msg	missing `index` (a point index, or null to clear)	लापता `index` (बिंदु इंडेक्स, या हटाने के लिए null)
+@msg	missing `index` (a stop index, or null to clear)	लापता `index` (स्टॉप इंडेक्स, या हटाने के लिए null)
 @msg	missing `index` (an item index or null)	लापता `index` (एक आइटम सूचकांक या null)
 @msg	missing `item`	लापता `item`
 @msg	missing `kind`	लापता `kind`
@@ -7116,7 +7154,7 @@ antiAlias	Sharp	शार्प
 @msg	missing `map` (rows [{from, to}] or {current})	लापता `map` (rows [{from, to}] या {current})
 @msg	missing `matrix` [a,b,c,d,e,f]	लापता `matrix` [a,b,c,d,e,f]
 @msg	missing `name`	लापता `name`
-@msg	missing `name` (see gradient.presets.list)	लापता `name` (view gradient.presets.list)
+@msg	missing `name` (see gradient.presets.list)	लापता `name` (gradient.presets.list देखें)
 @msg	missing `offset` (a distance in points)	लापता `offset` (बिंदुओं में एक दूरी)
 @msg	missing `path`	लापता `path`
 @msg	missing `path` (a path object id)	लापता `path` (एक पाथ ऑब्जेक्ट आईडी)
@@ -7127,7 +7165,7 @@ antiAlias	Sharp	शार्प
 @msg	missing `target` id	लापता `target` id
 @msg	missing `text`	लापता `text`
 @msg	missing `to`	`to` अनुपस्थित है
-@msg	missing `to` (an index)	लापता `to` (an index)
+@msg	missing `to` (an index)	लापता `to` (एक इंडेक्स)
 @msg	missing `to`: a non-negative integer	`to` अनुपस्थित है: एक गैर-ऋणात्मक पूर्णांक चाहिए
 @msg	missing `tool`	लापता `tool`
 @msg	missing `type`	लापता `type`
@@ -7164,11 +7202,11 @@ antiAlias	Sharp	शार्प
 @msg	missing stops	लापता ठहराव
 @msg	missing subpaths	लापता subpaths
 @msg	missing target	लापता लक्ष्य
-@msg	missing to	याद करना
-@msg	missing x, y	लापता xy
+@msg	missing to	लापता to
+@msg	missing x, y	लापता x, y
 @msg	mode is set, add or toggle, not `{other}`	mode set, add या toggle है, `{other}` नहीं
-@msg	mode must be "cmyk" or "rgb"	mode: मोड "cmyk" या "rgb" होना चाहिए
-@msg	mode must be area|onPath, got {o}	mode: मोड होना चाहिए क्षेत्रफल (onPath), {o} मिला
+@msg	mode must be "cmyk" or "rgb"	mode "cmyk" या "rgb" होना चाहिए
+@msg	mode must be area|onPath, got {o}	mode को area|onPath होना चाहिए, {o} मिला
 @msg	module is {_1} bytes (limit {_2})	मॉड्यूल {_1} बाइट्स का है (सीमा {_2})
 @msg	more than {MAX_BATCH_FILES} data sets	{MAX_BATCH_FILES} डेटा सेट से अधिक
 @msg	more than {MAX_BATCH_FILES} files	{MAX_BATCH_FILES} फ़ाइलों से अधिक
@@ -7181,22 +7219,22 @@ antiAlias	Sharp	शार्प
 @msg	more than 256 commands	256 से अधिक कमांड
 @msg	more than one action is named “{_1}”	एक से अधिक कार्रवाई का नाम "{_1}" रखा गया है।
 @msg	Move Panel to New Window is not available: floating panels stay in the main window	नई विंडो में पैनल को स्थानांतरित करना उपलब्ध नहीं है: अस्थायी पैनल मुख्य विंडो में रहते हैं
-@msg	move requires a destination panel	move: एक गंतव्य पैनल की आवश्यकता होती है
-@msg	move requires an existing destination panel	move: चाल एक मौजूदा गंतव्य पैनल की आवश्यकता है
+@msg	move requires a destination panel	move के लिए गंतव्य पैनल चाहिए
+@msg	move requires an existing destination panel	move के लिए मौजूदा गंतव्य पैनल चाहिए
 @msg	moved must be [[x,y]…]	moved को [[x,y]…] होना चाहिए
 @msg	Multichannel PSD files can't be read: save it in RGB, CMYK or Grayscale mode	मल्टीचैनल PSD फ़ाइलों को पढ़ा नहीं जा सकता: इसे RGB, CMYK या ग्रेस्केल मोड में सेव करें
 @msg	name (a toolbar's name) is required	नाम (एक टूलबार का नाम) की आवश्यकता होती है
 @msg	name (a toolbar's name) must be a string	नाम (एक टूलबार का नाम) एक स्ट्रिंग होना चाहिए
 @msg	name is empty	नाम खाली है
-@msg	name must be a toolbar's name	name: नाम एक टूलबार का नाम होना चाहिए
+@msg	name must be a toolbar's name	name किसी टूलबार का नाम होना चाहिए
 @msg	name the file	फ़ाइल नाम
 @msg	names is empty	names खाली है
-@msg	names must be an array of symbol names	names: नाम सिंबल नामों की एक सरणी होना चाहिए
+@msg	names must be an array of symbol names	names सिंबल नामों की एक सरणी होनी चाहिए
 @msg	need `anchor` or `segment` + `t`	की जरूरत `anchor` या `segment` + `t`
 @msg	need at least one anchor	कम से कम एक एंकर की जरूरत है
 @msg	need at least one point	कम से कम एक बिंदु की जरूरत है
 @msg	need at least two points	कम से कम दो बिंदुओं की आवश्यकता
-@msg	needs points	जरूरत अंक
+@msg	needs points	पॉइंट्स चाहिए
 @msg	New Window isn't available yet: a document opens in one window	नई विंडो अभी तक उपलब्ध नहीं है: एक डॉक्यूमेंट एक विंडो में खुलता है
 @msg	nineSlice must be true or false	nineSlice को true या false होना चाहिए
 @msg	nineSliceGuides must be [left, top, right, bottom], each -16..16, with left + right < 1 and top + bottom < 1	nineSliceGuides को [left, top, right, bottom] होना चाहिए, हर मान -16..16, और left + right < 1 तथा top + bottom < 1
@@ -7272,7 +7310,7 @@ antiAlias	Sharp	शार्प
 @msg	no formats to export	निर्यात करने के लिए कोई फ़ॉर्मैट नहीं
 @msg	no free data set file name in destination folder	गंतव्य फ़ोल्डर में कोई मुफ्त डेटा सेट फ़ाइल नाम नहीं
 @msg	no free recovery area	कोई मुफ्त वसूली क्षेत्र
-@msg	no gradient preset `{name}` (see gradient.presets.list)	कोई gradient preset `{name}` (view gradient.presets.list)
+@msg	no gradient preset `{name}` (see gradient.presets.list)	`{name}` नाम का कोई ग्रेडिएंट प्रीसेट नहीं (gradient.presets.list देखें)
 @msg	no gradient stop or freeform point is selected	कोई क्रमिक स्टॉप या फ्रीफॉर्म पॉइंट नहीं चुना जाता है
 @msg	no gradient swatch `{name}`	कोई ग्रेडिएंट स्वॉच `{name}` नहीं
 @msg	no graphic style `{n}`	कोई ग्राफिक स्टाइल `{n}`
@@ -7281,7 +7319,7 @@ antiAlias	Sharp	शार्प
 @msg	no graphic style library `{key}` (see graphicStyle.libraries)	कोई ग्राफिक स्टाइल लाइब्रेरी `{key}` (graphicStyle.libraries देखें)
 @msg	no guide {i}	कोई गाइड {i}
 @msg	no guide selected	कोई गाइड सिलेक्टेड नहीं
-@msg	no guide selected (or give an index)	कोई गाइड नहीं चुना गया (या एक सूचकांक देना)
+@msg	no guide selected (or give an index)	कोई गाइड सिलेक्ट नहीं है (या index दें)
 @msg	no history to clear	स्पष्ट करने के लिए कोई इतिहास नहीं
 @msg	no history state {v}	कोई हिस्ट्री स्थिति {v} नहीं
 @msg	no images in the folder	फ़ोल्डर में कोई इमेज नहीं
@@ -7322,7 +7360,7 @@ antiAlias	Sharp	शार्प
 @msg	no plug-in {id} is installed	कोई प्लग-इन {id} स्थापित नहीं है
 @msg	no PNG encoder	नहीं पीएनजी एनकोडर
 @msg	no point {i} (the gradient has {_1})	कोई बिंदु {i} (ग्रेडेंट {_1} है)
-@msg	no point selected (give `index`)	कोई बिंदु नहीं चुना गया (give `index`)
+@msg	no point selected (give `index`)	कोई बिंदु सिलेक्ट नहीं है (`index` दें)
 @msg	no preset called `{from}` (see file.newPresets)	`{from}` नामक कोई प्रीसेट नहीं ( file.newPresets देखें)
 @msg	no preset called `{name}` (see file.newPresets)	`{name}` नामक कोई पूर्व निर्धारित नहीं है (file.newPresets देखें)
 @msg	no preset editor	कोई पूर्व निर्धारित संपादक
@@ -7332,7 +7370,7 @@ antiAlias	Sharp	शार्प
 @msg	no print preset named `{base}`	`{base}` नामक कोई प्रिंट प्रीसेट नहीं है
 @msg	no print preset named `{n}`	`{n}` नामक कोई प्रिंट प्रीसेट नहीं है
 @msg	no print preset named `{name}`	कोई प्रिंट प्रीसेट जिसका नाम `{name}` है
-@msg	no print preset named `{name}` (presets: {_1})	`{name}` नामक कोई प्रिंट प्रीसेट नहीं (presets: {_1})
+@msg	no print preset named `{name}` (presets: {_1})	`{name}` नाम का कोई प्रिंट प्रीसेट नहीं (प्रीसेट: {_1})
 @msg	no print service	कोई प्रिंट सेवा नहीं
 @msg	no profile named `{name}`	`{name}` नामक कोई प्रोफ़ाइल नहीं
 @msg	no readable files in the folder	फ़ोल्डर में कोई पठनीय फ़ाइल नहीं
@@ -7396,7 +7434,7 @@ antiAlias	Sharp	शार्प
 @msg	no such rows	ऐसी कोई पंक्ति नहीं
 @msg	no such saved selection	ऐसा कोई सेव किया गया सिलेक्शन नहीं
 @msg	no such segment	ऐसा कोई खंड नहीं
-@msg	no such spine point	ऐसी कोई रीढ़ की हड्डी नहीं
+@msg	no such spine point	ऐसा कोई स्पाइन बिंदु नहीं
 @msg	no such spine segment	ऐसा कोई खंड नहीं
 @msg	no such subpath	ऐसा कोई उप-पाथ नहीं
 @msg	no such user library	ऐसी कोई उपयोगकर्ता लाइब्रेरी नहीं
@@ -7419,12 +7457,12 @@ antiAlias	Sharp	शार्प
 @msg	no symbol library `{key}` (see symbol.libraries)	`{key}` सिंबल लाइब्रेरी नहीं है (symbol.libraries देखें)
 @msg	no symbol named `{n}`	`{n}` नाम का कोई सिंबल नहीं
 @msg	no symbol named `{name}`	`{name}` नाम का कोई सिंबल नहीं
-@msg	no target object has an opacity mask: select one or give `id`	कोई लक्ष्य ऑब्जेक्ट एक opacity मास्क नहीं है: एक सिलेक्ट करें या `id` देना
+@msg	no target object has an opacity mask: select one or give `id`	किसी लक्ष्य ऑब्जेक्ट में ओपेसिटी मास्क नहीं है: एक सिलेक्ट करें या `id` दें
 @msg	no text objects selected	कोई टेक्स्ट ऑब्जेक्ट नहीं चुना गया
 @msg	no threaded text selected	कोई थ्रेडेड टेक्स्ट नहीं चुना गया
 @msg	no toolbar named `{_1}`	`{_1}` नाम का कोई टूलबार नहीं
 @msg	no toolbar named `{name}`	कोई टूलबार जिसका नाम `{name}` है
-@msg	no tracing preset `{preset}` (see imageTrace.presets)	कोई अनुरेखण पूर्व निर्धारित `{preset}` (imageTrace.presets देखें)
+@msg	no tracing preset `{preset}` (see imageTrace.presets)	`{preset}` नाम का कोई ट्रेसिंग प्रीसेट नहीं (imageTrace.presets देखें)
 @msg	no user library folder here	यहां कोई उपयोगकर्ता लाइब्रेरी फ़ोल्डर नहीं
 @msg	no user library folder here (save with a path, or without one to get the data)	यहाँ कोई यूज़र लाइब्रेरी फ़ोल्डर नहीं है (पाथ के साथ सेव करें, या डेटा पाने के लिए बिना पाथ के)
 @msg	no user workspace `{from}`	कोई उपयोगकर्ता वर्कस्पेस `{from}`
@@ -7445,19 +7483,19 @@ antiAlias	Sharp	शार्प
 @msg	not a closed path	एक बंद पाथ नहीं
 @msg	not a DXF drawing	नहीं एक DXF ड्राइंग
 @msg	not a file	फ़ाइल नहीं
-@msg	not a flattener presets file (format `{_1}`)	नहीं एक flattener presets फ़ाइल (format `{_1}`)
-@msg	not a flattener presets file: {e}	नहीं एक flattener presets फ़ाइल: {e}
+@msg	not a flattener presets file (format `{_1}`)	यह फ़्लैटनर प्रीसेट फ़ाइल नहीं है (फ़ॉर्मैट `{_1}`)
+@msg	not a flattener presets file: {e}	यह फ़्लैटनर प्रीसेट फ़ाइल नहीं है: {e}
 @msg	not a font file	एक फ़ॉन्ट फ़ाइल नहीं
 @msg	not a gradient mesh or mesh envelope	एक ग्रेडिएंट जाल या जाल लिफाफे नहीं
-@msg	not a graphic style library (format `{_1}`)	नहीं एक ग्राफिक स्टाइल लाइब्रेरी (format `{_1}`)
+@msg	not a graphic style library (format `{_1}`)	यह ग्राफ़िक स्टाइल लाइब्रेरी नहीं है (फ़ॉर्मैट `{_1}`)
 @msg	not a layer or group	एक लेयर या समूह नहीं
 @msg	not a library file: {e}	एक लाइब्रेरी फ़ाइल नहीं: {e}
 @msg	not a mesh envelope point	एक जाल लिफाफा बिंदु नहीं
-@msg	not a PDF presets file (format `{_1}`)	नहीं एक PDF प्रीसेट फ़ाइल (format `{_1}`)
-@msg	not a PDF presets file: {e}	PDF Presets फ़ाइल नहीं: {e}
-@msg	not a perspective grid presets file (format `{_1}`)	नहीं एक पर्सपेक्टिव ग्रिड presets फ़ाइल (format `{_1}`)
+@msg	not a PDF presets file (format `{_1}`)	यह PDF प्रीसेट फ़ाइल नहीं है (फ़ॉर्मैट `{_1}`)
+@msg	not a PDF presets file: {e}	यह PDF प्रीसेट फ़ाइल नहीं है: {e}
+@msg	not a perspective grid presets file (format `{_1}`)	यह पर्सपेक्टिव ग्रिड प्रीसेट फ़ाइल नहीं है (फ़ॉर्मैट `{_1}`)
 @msg	not a perspective grid presets file: {e}	एक पर्सपेक्टिव ग्रिड प्रीसेट फ़ाइल नहीं: {e}
-@msg	not a print presets file (format `{_1}`)	कोई प्रिंट प्रीसेट फ़ाइल नहीं (format `{_1}`)
+@msg	not a print presets file (format `{_1}`)	यह प्रिंट प्रीसेट फ़ाइल नहीं है (फ़ॉर्मैट `{_1}`)
 @msg	not a print presets file: {e}	एक प्रिंट प्रीसेट फ़ाइल नहीं: {e}
 @msg	not a PSD file	PSD फ़ाइल नहीं
 @msg	not a shortcut set: the text doesn't start with a slash name and an opening brace	एक शॉर्टकट सेट नहीं: टेक्स्ट एक स्लैश नाम और एक उद्घाटन ब्रेस के साथ शुरू नहीं होता है
@@ -7479,12 +7517,12 @@ antiAlias	Sharp	शार्प
 @msg	not an HP-GL file	HP-GL फ़ाइल नहीं है
 @msg	not a PICT file	PICT फ़ाइल नहीं है
 @msg	`pens` must be an array of 1 to 255 #rrggbb colors	`pens` को 1 से 255 #rrggbb रंगों की ऐरे होना चाहिए
-@msg	not an export presets file (format `{_1}`)	नहीं निर्यात presets फ़ाइल (format `{_1}`)
+@msg	not an export presets file (format `{_1}`)	यह एक्सपोर्ट प्रीसेट फ़ाइल नहीं है (फ़ॉर्मैट `{_1}`)
 @msg	not an export presets file: {e}	एक निर्यात प्रीसेट फ़ाइल नहीं: {e}
 @msg	not an image VectorCraft reads (see document.formats)	यह ऐसी इमेज नहीं है जिसे VectorCraft पढ़ सके (document.formats देखें)
 @msg	not an RTF file: it doesn't start with {\\rtf	RTF फ़ाइल नहीं: यह {\rtf के साथ शुरू नहीं होता है
 @msg	not area type (text in a frame) outside perspective	पर्सपेक्टिव के बाहर का एरिया टाइप (फ़्रेम में टेक्स्ट) नहीं है
-@msg	not editing an opacity mask	एक opacity मास्क संपादित न करें
+@msg	not editing an opacity mask	ओपेसिटी मास्क संपादित नहीं किया जा रहा है
 @msg	not found	नहीं मिला
 @msg	not in pattern editing mode	पैटर्न संपादन मोड में नहीं
 @msg	not JSON: {e}	JSON नहीं है: {e}
@@ -7533,11 +7571,11 @@ antiAlias	Sharp	शार्प
 @msg	object {id} is not a selected top-level object	ऑब्जेक्ट {id} एक सिलेक्टेड शीर्ष स्तर की ऑब्जेक्ट नहीं है
 @msg	object has no weighted stroke	ऑब्जेक्ट में कोई भारित स्ट्रोक नहीं है
 @msg	object ids are non-negative integers, not {v}	ऑब्जेक्ट ids गैर-नकारात्मक पूर्णांक हैं, न कि {v}
-@msg	object is not a path	object: ऑब्जेक्ट एक पाथ नहीं है
+@msg	object is not a path	object एक पाथ नहीं है
 @msg	object transparency cannot be sampled onto highlighted characters; disable Transparency in Eyedropper Options or select the whole object	ऑब्जेक्ट पारदर्शिता को हाइलाइट किए गए पात्रों पर नमूने नहीं दिए जा सकते हैं; आइड्रॉपर ऑप्शन्स में पारदर्शिता को अक्षम करें या पूरे ऑब्जेक्ट सिलेक्ट करें
 @msg	objects can't be nested more than 32 deep	ऑब्जेक्ट्स को 32 से अधिक गहराई तक घोंसला नहीं किया जा सकता है
 @msg	objects inside a blend, envelope, repeat or Intertwine group can't be attached to a path	एक मिश्रण, लिफ़ाफ़ाफ़ा, दोहराने या अंतर्जातीय समूह के अंदर ऑब्जेक्ट्स को एक पाथ से जोड़ा नहीं जा सकता है
-@msg	objects must be none, move or copy	objects: ऑब्जेक्टएं कोई नहीं, चाल या प्रतिलिपि होना चाहिए
+@msg	objects must be none, move or copy	objects none, move या copy होना चाहिए
 @msg	warped text objects that came in as drawn art, not as editable type: {_1}	मोड़े गए टेक्स्ट ऑब्जेक्ट जो संपादन योग्य टेक्स्ट के बजाय कला के रूप में आए: {_1}
 @msg	objects that drew differently from the file's own page came in as its art: {_1}	उन ऑब्जेक्ट्स को जो फ़ाइल के स्वयं के पृष्ठ से अलग-अलग तरीके से आकर्षित होते हैं, उनकी कला के रूप में आया: {_1}
 @msg	objects were left out	ऑब्जेक्ट्स को छोड़ दिया गया था
@@ -7558,17 +7596,17 @@ antiAlias	Sharp	शार्प
 @msg	only solid-colour swatches can be spot colours	केवल ठोस रंग वाले स्वॉच स्पॉट रंग हो सकते हैं
 @msg	only this Affinity file's embedded preview could be read; use File › Open to see it with its warning	केवल इस Affinity फ़ाइल के एम्बेडेड प्रीव्यू को पढ़ा जा सकता है; फ़ाइल का उपयोग करें > इसे अपनी चेतावनी के साथ देखने के लिए ओपन करें
 @msg	only this Affinity file's embedded preview could be read: use File › Open to see it with its warning, or export SVG or PDF from Affinity first	केवल इस Affinity फ़ाइल के एम्बेडेड प्रीव्यू को पढ़ा जा सकता है: फ़ाइल का उपयोग करें > इसे अपनी चेतावनी के साथ देखने के लिए ओपन करें, या पहले Affinity से SVG या PDF निर्यात करें
-@msg	onto must name a floating panel	onto: पर एक फ्लोटिंग पैनल का नाम होना चाहिए
-@msg	onto must name a panel floating in another group	onto: किसी अन्य समूह में फ्लोटिंग पैनल का नाम होना चाहिए
+@msg	onto must name a floating panel	onto में किसी फ़्लोटिंग पैनल का नाम होना चाहिए
+@msg	onto must name a panel floating in another group	onto में किसी दूसरे ग्रुप में फ़्लोट कर रहे पैनल का नाम होना चाहिए
 @msg	onto, above, below, icon and a column place belong to window.panel.float and window.panel.dock	onto, above, below, icon और column स्थान window.panel.float और window.panel.dock के लिए हैं
 @msg	onto, above, below, icon and a column place take no anchor, side, zone or before	ऊपर, नीचे, आइकन और एक स्तंभ स्थान पर कोई एंकर, साइड, जोन या पहले नहीं होता है
 @msg	onto, above, below, icon and a column place take no x, y, width or height	ऊपर, नीचे, आइकन और एक स्तंभ स्थान पर कोई एक्स, वाई, चौड़ाई या ऊंचाई नहीं होती है
 @msg	open a document to look for its linked files	अपनी लिंक्ड फ़ाइलों को देखने के लिए एक डॉक्यूमेंट ओपन करें
 @msg	open a document with data sets	डेटा सेट के साथ एक डॉक्यूमेंट ओपन करें
 @msg	Opened {url}	{url} ओपन किया गया
-@msg	options must be an object (see file.formatOptions)	options: ऑप्शन्स एक ऑब्जेक्ट होना चाहिए (file.formatOptions देखें)
+@msg	options must be an object (see file.formatOptions)	options एक ऑब्जेक्ट होना चाहिए (file.formatOptions देखें)
 @msg	order must be leftToRight or rightToLeft	order को leftToRight या rightToLeft होना चाहिए
-@msg	orientation must be portrait or landscape, not `{o}`	orientation: अभिविन्यास चित्र या परिदृश्य होना चाहिए, नहीं `{o}`
+@msg	orientation must be portrait or landscape, not `{o}`	orientation portrait या landscape होना चाहिए, `{o}` नहीं
 @msg	others must be true or false	others को true या false होना चाहिए
 @msg	Outline Stroke: no stroked paths selected	आउटलाइन स्ट्रोक: सिलेक्टेड कोई स्ट्रोक पाथ नहीं
 @msg	outlineText {v}: true or false	outlineText {v}: true या false
@@ -7596,49 +7634,49 @@ antiAlias	Sharp	शार्प
 @msg	page art is missing image data for {key}	पृष्ठ कला {key} के लिए इमेज डेटा लापता है
 @msg	page art is missing pattern {name}	पृष्ठ कला लापता पैटर्न {name} है
 @msg	page art is missing swatch {name}	पेज आर्टवर्क में स्वॉच {name} नहीं है
-@msg	page must be a whole number from 1	page: पृष्ठ 1 से एक पूरी संख्या होना चाहिए
+@msg	page must be a whole number from 1	page 1 या उससे बड़ी पूर्ण संख्या होनी चाहिए
 @msg	page size {w} × {h}	{w} × {h}
 @msg	page thumbnail: {e}	पेज थंबनेल: {e}
-@msg	pages must be a range such as "2-3" or a page number, not {v}	pages: पृष्ठों को "2-3" या एक पृष्ठ संख्या के रूप में एक श्रेणी होना चाहिए, नहीं {v}
+@msg	pages must be a range such as "2-3" or a page number, not {v}	pages "2-3" जैसी रेंज या पेज संख्या होनी चाहिए, {v} नहीं
 @msg	pages: {e}	पेज: {e}
 @msg	panel group is empty	पैनल समूह खाली है
-@msg	panel is not in a dock group	panel: पैनल एक डॉक समूह में नहीं है
-@msg	panel must name a registered panel	panel: पैनल का नाम एक पंजीकृत पैनल होना चाहिए
+@msg	panel is not in a dock group	panel किसी डॉक समूह में नहीं है
+@msg	panel must name a registered panel	panel किसी पंजीकृत पैनल का नाम होना चाहिए
 @msg	panel position must be finite	पैनल की स्थिति परिमित होना चाहिए
 @msg	parameter `{k}`: {what}	पैरामीटर `{k}`: {what}
 @msg	parameter `{name}`: {what}	पैरामीटर `{name}`: {what}
-@msg	parameters must be an object	parameters: पैरामीटर एक ऑब्जेक्ट होना चाहिए
-@msg	params must be an object	params: परम एक ऑब्जेक्ट होना चाहिए
+@msg	parameters must be an object	parameters एक ऑब्जेक्ट होना चाहिए
+@msg	params must be an object	params एक ऑब्जेक्ट होना चाहिए
 @msg	part of the program isn't valid PostScript text	कार्यक्रम का हिस्सा मान्य नहीं है PostScript टेक्स्ट
 @msg	pass newName, registration, exportType, nineSlice and/or type	newName, registration, exportType, nineSlice और/या type दें
 @msg	passwords can have up to {MAX_PASSWORD} bytes	पासवर्ड {MAX_PASSWORD} बाइट्स तक हो सकता है
 @msg	paste unavailable	पेस्ट करें अनुपलब्ध
 @msg	Pasting	चिपकाना
 @msg	path has no open end	पाथ का कोई खुला अंत नहीं है
-@msg	path is already closed	path: पाथ पहले से ही बंद हो गया है
-@msg	path must be a list of child indices	path: बच्चे के सूचकांक की सूची होना चाहिए
+@msg	path is already closed	path पहले से बंद है
+@msg	path must be a list of child indices	path चाइल्ड इंडेक्स की सूची होनी चाहिए
 @msg	paths contain invalid coordinates	पाथ में अमान्य निर्देशांक होते हैं
-@msg	paths must be strings	paths: पाथ स्ट्रिंग होना चाहिए
+@msg	paths must be strings	paths स्ट्रिंग होने चाहिए
 @msg	paths: give at least one file	पाथ: कम से कम एक फ़ाइल दें
 @msg	pattern missing	पैटर्न लापता
 @msg	patterns nested too deeply are filled with mid-grey	पैटर्न घोंसला बहुत गहराई से मध्य ग्रे से भर रहे हैं
 @msg	PCX files with {bits}-bit pixels in {planes} planes can't be read	पीसीएक्स फ़ाइलों के साथ {bits}-बिट पिक्सल {planes} विमानों में पढ़ा नहीं जा सकता है
 @msg	PDF content is incomplete or exceeds the reader's limits; no document was imported	PDF सामग्री अधूरे है या टेक्स्टक की सीमाओं से अधिक है; कोई डॉक्यूमेंट आयात नहीं किया गया था
-@msg	PDF flattener: {e}	PDF flattener: {e}
+@msg	PDF flattener: {e}	PDF फ़्लैटनर: {e}
 @msg	PDF options: {e}	PDF ऑप्शन्स: {e}
 @msg	PDF security settings are not an object	PDF सुरक्षा सेटिंग्स एक ऑब्जेक्ट नहीं हैं
 @msg	PDF settings are not an object	PDF सेटिंग्स एक ऑब्जेक्ट नहीं हैं
 @msg	PDF writer error: {0}	PDF लेखक त्रुटि: {0}
 @msg	pdfCompatible: false needs every artboard to keep the editable artwork	pdfCompatible: false में एडिट करने योग्य आर्टवर्क रखने के लिए सभी आर्टबोर्ड चाहिए
 @msg	pdfs `{m}`: single or multiple	pdfs `{m}`: एकल या एकाधिक
-@msg	percent must be above 0 and at most 6400, not {p}	percent: प्रतिशत 0 से अधिक होना चाहिए और अधिक 6400 पर, नहीं {p}
+@msg	percent must be above 0 and at most 6400, not {p}	percent 0 से बड़ा और अधिकतम 6400 होना चाहिए, {p} नहीं
 @msg	Persistent libraries not found: {files}	Persistent लाइब्रेरीों नहीं मिला: {files}
 @msg	pick a colour, gradient or pattern to save as a swatch	स्वॉच के रूप में सेव करने के लिए रंग, ग्रेडिएंट या पैटर्न चुनें
 @msg	pickColorFrom is "artwork" or "swatches", not {v}	pickColorFrom को "artwork" या "swatches" होना चाहिए, {v} नहीं
 @msg	pins and moved must be non-empty lists of the same length	पिन और ले जाने के लिए समान लंबाई की गैर-खाली सूची होनी चाहिए
-@msg	pins must be [[x,y]…]	pins: पिन होना चाहिए [[x,y]...]
-@msg	pins must be finite	pins: पिन परिमित होना चाहिए
-@msg	place is above, below or inside, not `{other}`	place: स्थान ऊपर, नीचे या अंदर है, नहीं `{other}`
+@msg	pins must be [[x,y]…]	pins [[x,y]…] होना चाहिए
+@msg	pins must be finite	pins परिमित होने चाहिए
+@msg	place is above, below or inside, not `{other}`	place above, below या inside होता है, `{other}` नहीं
 @msg	Placing {_1}	पतंग {_1}
 @msg	plane must be left, right or ground	plane को left, right या ground होना चाहिए
 @msg	plane must be left|right|ground	plane को left|right|ground होना चाहिए
@@ -7653,24 +7691,24 @@ antiAlias	Sharp	शार्प
 @msg	plug-in trapped: {0}	प्लग-इन में ट्रैप हुआ: {0}
 @msg	Plug-ins can't be loaded from {path}: {e}	प्लग-इन {path} से लोड नहीं किया जा सकता: {e}
 @msg	point is outside the mesh	बिंदु मेश के बाहर है
-@msg	points must be [t, left, right] with non-negative widths	points: गैर-नकारात्मक चौड़ाई के साथ अंक [t, left, right] होना चाहिए
-@msg	points must be a non-empty [[x,y,pressure?]…] list	points: अंक एक गैर-खाली होना चाहिए [[x,y, दबाव?]...] सूची
-@msg	points must be a non-empty list of finite [x,y]	points: अंक परिमित की एक गैर-खाली सूची होना चाहिए [x,y]
-@msg	points must be an array or null	points: अंक एक सारणी या null होना चाहिए
-@msg	points must be finite	points: अंक परिमित होना चाहिए
-@msg	points must be finite [x,y] pairs	points: अंक परिमित होना चाहिए [x,y] जोड़े
+@msg	points must be [t, left, right] with non-negative widths	points गैर-ऋणात्मक चौड़ाई वाले [t, left, right] होने चाहिए
+@msg	points must be a non-empty [[x,y,pressure?]…] list	points गैर-खाली [[x,y,pressure?]…] सूची होनी चाहिए
+@msg	points must be a non-empty list of finite [x,y]	points परिमित [x,y] की गैर-खाली सूची होनी चाहिए
+@msg	points must be an array or null	points ऐरे या null होना चाहिए
+@msg	points must be finite	points परिमित होने चाहिए
+@msg	points must be finite [x,y] pairs	points परिमित [x,y] जोड़े होने चाहिए
 @msg	points must contain 1–4096 coordinates	points में 1–4096 निर्देशांक होने चाहिए
-@msg	position must be normal, superscript or subscript	position: स्थिति सामान्य, सुपरस्क्रिप्ट या सबस्क्रिप्ट होना चाहिए
+@msg	position must be normal, superscript or subscript	position normal, superscript या subscript होना चाहिए
 @msg	position must be topLeft, topRight, bottomLeft or bottomRight	position को topLeft, topRight, bottomLeft या bottomRight होना चाहिए
-@msg	positions must be between 0 and 100000 pt	positions: 0 और 100000 pt के बीच होना चाहिए
-@msg	ppi must be a positive number, not {ppi}	ppi एक सकारात्मक संख्या होना चाहिए, नहीं {ppi}
-@msg	ppi must be between 1 and 2400	ppi: पीपीआई 1 और 2400 के बीच होना चाहिए
-@msg	precision must be from 0.001 to 10 pt	precision: परिशुद्धता 0.001 से 10 pt तक होना चाहिए
+@msg	positions must be between 0 and 100000 pt	positions 0 और 100000 pt के बीच होनी चाहिए
+@msg	ppi must be a positive number, not {ppi}	ppi एक धनात्मक संख्या होनी चाहिए, {ppi} नहीं
+@msg	ppi must be between 1 and 2400	ppi 1 और 2400 के बीच होना चाहिए
+@msg	precision must be from 0.001 to 10 pt	precision 0.001 से 10 pt तक होनी चाहिए
 @msg	preserve `{v}` is not transforms|bounds|fileDimensions|fit|fill	preserve `{v}`, transforms|bounds|fileDimensions|fit|fill में से नहीं है
 @msg	preserveShape must be clippingMask|transparency	preserveShape को clippingMask|transparency होना चाहिए
 @msg	preset `{id}`: mobile or density	प्रीसेट `{id}`: मोबाइल या घनत्व
 @msg	preset must be standard, diffuse, topLeft or right	preset को standard, diffuse, topLeft या right होना चाहिए
-@msg	preset must be the name of a print preset	preset: प्रीसेट एक प्रिंट प्रीसेट का नाम होना चाहिए
+@msg	preset must be the name of a print preset	preset किसी प्रिंट प्रीसेट का नाम होना चाहिए
 @msg	Preview in Browser needs the desktop app (the web downloads files instead)	ब्राउज़र में प्रीव्यू डेस्कटॉप ऐप (वेब डाउनलोड फ़ाइलों के बजाय) की जरूरत है
 @msg	previewMode must be default, pixel or overprint	previewMode को default, pixel या overprint होना चाहिए
 @msg	Print Ink Fixes works on CMYK documents: choose File › Document Color Mode › CMYK Color first	प्रिंट इंक फिक्स CMYK डॉक्यूमेंट्स पर काम करता है: फ़ाइल चुनें › डॉक्यूमेंट रंग मोड › CMYK कलर फर्स्ट
@@ -7686,16 +7724,16 @@ antiAlias	Sharp	शार्प
 @msg	range `{s}`: `{part}` runs backwards	रेंज `{s}`: `{part}` पीछे चल रहा है
 @msg	range `{s}`: `{t}` is not a number from 1 to {count}	सीमा `{s}`: `{t}` 1 से {count} के बीच की संख्या नहीं है
 @msg	rasterEffectsPpi must be 1–2400 (72 screen, 150 medium, 300 high)	rasterEffectsPpi को 1–2400 होना चाहिए (72 स्क्रीन, 150 मध्यम, 300 उच्च)
-@msg	rating must be a whole number from 0 to {MAX_RATING}	rating: रेटिंग 0 से {MAX_RATING} तक पूरी संख्या होना चाहिए
+@msg	rating must be a whole number from 0 to {MAX_RATING}	rating 0 से {MAX_RATING} तक की पूर्ण संख्या होनी चाहिए
 @msg	Recolor Artwork is no longer open	Recolor Artwork अब खुला नहीं है
 @msg	recovery copy `{file}`: {e}	वसूली प्रतिलिपि `{file}`: {e}
 @msg	rect and {k} contradict each other: give the area or the artboards	सही और {k} एक दूसरे के विपरीत: क्षेत्र या आर्टबोर्ड देना
 @msg	rect applies to raster formats, not {_1}	सही रेस्टर फ़ॉर्मैट्स पर लागू होता है, न कि {_1}
 @msg	rect is [x, y, width, height] in points	rect पॉइंट में [x, y, width, height] है
-@msg	rect must be [x, y, width, height]	rect: [x, y, चौड़ाई, ऊंचाई] होना चाहिए
-@msg	rect must be [x, y, width, height] with a positive width and height	rect: सही होना चाहिए [x, y, चौड़ाई, ऊंचाई] सकारात्मक चौड़ाई और ऊंचाई के साथ
-@msg	rect needs finite numbers and a positive width and height	rect: सही की जरूरत परिमित संख्या और सकारात्मक चौड़ाई और ऊंचाई
-@msg	redraw needs id	redraw: ई.डी. की आवश्यकता
+@msg	rect must be [x, y, width, height]	rect [x, y, width, height] होना चाहिए
+@msg	rect must be [x, y, width, height] with a positive width and height	rect धनात्मक चौड़ाई और ऊँचाई वाला [x, y, width, height] होना चाहिए
+@msg	rect needs finite numbers and a positive width and height	rect में परिमित संख्याएँ और धनात्मक चौड़ाई और ऊँचाई चाहिए
+@msg	redraw needs id	redraw के लिए id चाहिए
 @msg	redraw within must be a finite distance of 0 or more	भीतर वापस लेना 0 या उससे अधिक की एक सीमित दूरी होना चाहिए
 @msg	registration must be 0..8	registration को 0..8 होना चाहिए
 @msg	Rejoin Path Pieces: too many paths to rejoin at once	पाथ के हिस्से फिर से जोड़ें: एक बार में फिर से जोड़ने के लिए बहुत अधिक पाथ हैं
@@ -7704,17 +7742,17 @@ antiAlias	Sharp	शार्प
 @msg	Release: no layer to put the rectangle in	रिलीज: आयत को डालने के लिए कोई लेयर नहीं
 @msg	Reload the page to go on (changes not saved yet may be lost).	जारी रखने के लिए पेज फिर से लोड करें (जो बदलाव अभी सेव नहीं हुए, वे खो सकते हैं)।
 @msg	replace keeps the replaced object's place and transform: drop template, at and rect	प्रतिस्थापित ऑब्जेक्ट के स्थान को बनाए रखता है और बदल देता है: ड्रॉप टेम्पलेट, पर और आयतन
-@msg	Replace Spine: select a blend and a path	Spine: एक मिश्रण और एक पाथ चुनें
+@msg	Replace Spine: select a blend and a path	स्पाइन रिप्लेस करें: एक ब्लेंड और एक पाथ सिलेक्ट करें
 @msg	replace: select the one object to replace	प्रतिस्थापित करने के लिए एक ऑब्जेक्ट सिलेक्ट करें
 @msg	replace: the object to replace was changed or deleted	प्रतिस्थापित करने के लिए ऑब्जेक्ट को बदल दिया गया था या हटा दिया गया
 @msg	the document it was prepared for is no longer active	जिस डॉक्यूमेंट के लिए इसे तैयार किया गया था, वह अब सक्रिय नहीं है
 @msg	Reset {_1}	रीसेट करें {_1}
-@msg	resolution must be a number or screen|medium|high	resolution: रिज़ॉल्यूशन एक नंबर या स्क्रीन होना चाहिए
-@msg	resolution must be between 1 and 2400 ppi	resolution: रिज़ॉल्यूशन 1 और 2400 ppi के बीच होना चाहिए
-@msg	resolutions must be between 1 and 2400 ppi	resolutions: रिज़ॉल्यूशन 1 और 2400 ppi के बीच होना चाहिए
+@msg	resolution must be a number or screen|medium|high	resolution कोई संख्या या screen|medium|high होना चाहिए
+@msg	resolution must be between 1 and 2400 ppi	resolution 1 और 2400 ppi के बीच होना चाहिए
+@msg	resolutions must be between 1 and 2400 ppi	resolutions 1 और 2400 ppi के बीच होने चाहिए
 @msg	result would exceed the canvas (coordinates out of range)	परिणाम कैनवास से अधिक होगा (श्रेणी से बाहर समन्वय)
-@msg	rotation must be a number of degrees	rotation: रोटेशन डिग्री की एक संख्या होना चाहिए
-@msg	rotation must be finite	rotation: रोटेशन को परिमित होना चाहिए
+@msg	rotation must be a number of degrees	rotation डिग्री में एक संख्या होनी चाहिए
+@msg	rotation must be finite	rotation परिमित होना चाहिए
 @msg	rows and cols must be 1..50	पंक्तियां और कॉल 1..50 होना चाहिए
 @msg	rows and columns must be 1..500	rows और columns को 1..500 होना चाहिए
 @msg	rows of objects whose appearances differ can't be reordered together	उन ऑब्जेक्ट्स की पंक्तियाँ जिनकी उपस्थिति भिन्न होती हैं, उन्हें एक साथ फिर से व्यवस्थित नहीं किया जा सकता है
@@ -7723,7 +7761,7 @@ antiAlias	Sharp	शार्प
 @msg	save the document first: copy puts the file in its folder	पहले डॉक्यूमेंट को सेव करना: प्रतिलिपि फ़ाइल को अपने फ़ोल्डर में डालती है
 @msg	save the document first: Package collects a saved document	पहले डॉक्यूमेंट को सेव करना: पैकेज एक सेव किए गए डॉक्यूमेंट एकत्र करता है
 @msg	Save writes {_1}, not {_2}: use document.export for other formats	सेव {_1} लिखता है, {_2} नहीं: दूसरे फ़ॉर्मैट के लिए document.export उपयोग करें
-@msg	Save writes {_1}, not {_2}: use file.saveAsTemplate to write it	सेव करें {_1}, not {_2}: use file.saveAsTemplate to write it
+@msg	Save writes {_1}, not {_2}: use file.saveAsTemplate to write it	सेव {_1} लिखता है, {_2} नहीं: इसे लिखने के लिए file.saveAsTemplate का उपयोग करें
 @msg	Save writes one artboard: name one, or export several with document.export	सेव एक आर्टबोर्ड लिखता है: एक का नाम दें या कई आर्टबोर्ड document.export से एक्सपोर्ट करें
 @msg	Saved {n} files beside {path}	{path} के पास {n} फ़ाइलें सेव की गईं
 @msg	Saved {path}	सेव्ड {path}
@@ -7736,18 +7774,18 @@ antiAlias	Sharp	शार्प
 @msg	Saving {_1}	बचत {_1}
 @msg	Saving recovery data for {_1}	{_1} के लिए रिकवरी डेटा सेव करना
 @msg	scale `{s}`: a factor such as 2x, a width (100w), a height (100h) or a resolution (72ppi)	पैमाने `{s}`: एक कारक जैसे 2x, चौड़ाई (100w), ऊंचाई (100h) या एक रिज़ॉल्यूशन (72ppi)
-@msg	scale must be a number above 0, at most 64	scale: पैमाने 0 से अधिक होना चाहिए, अधिकांश 64 में
-@msg	scale must be a number from {_1} to {_2}, not {_3}	scale: स्केल {_1} से {_2} के लिए एक नंबर होना चाहिए, नहीं {_3}
-@msg	scale must be a number from {_1} to {_2}, not {s}	scale: स्केल {_1} से {_2} के लिए एक नंबर होना चाहिए, नहीं {s}
+@msg	scale must be a number above 0, at most 64	scale 0 से बड़ी और अधिकतम 64 संख्या होनी चाहिए
+@msg	scale must be a number from {_1} to {_2}, not {_3}	scale {_1} से {_2} तक की संख्या होनी चाहिए, {_3} नहीं
+@msg	scale must be a number from {_1} to {_2}, not {s}	scale {_1} से {_2} तक की संख्या होनी चाहिए, {s} नहीं
 @msg	Scale must be drawing:real, for example 1:10	स्केल ड्राइंग होना चाहिए:वास्तविक, उदाहरण के लिए 1:10
-@msg	scale must be non-zero	scale: स्केल होना चाहिए गैर-zero
+@msg	scale must be non-zero	scale शून्य नहीं होना चाहिए
 @msg	Scale ratio must be between 1:1000000 and 1000000:1	स्केल अनुपात 1:1000000 और 1000000:1 के बीच होना चाहिए
 @msg	Scale Text Attributes: selected type has no scale to bake	स्केल टेक्स्ट एट्रिब्यूट्स: सिलेक्टेड टाइप में बेक करने के लिए कोई स्केल नहीं है
-@msg	scope must be selection or all (got {other})	scope: गुंजाइश का सिलेक्शन होना चाहिए या सभी ({other}) होना चाहिए।
+@msg	scope must be selection or all (got {other})	scope selection या all होना चाहिए (मिला {other})
 @msg	scribble is too long	स्क्रिबल बहुत लंबा है
 @msg	searching a folder isn't available on the web	एक फ़ोल्डर खोज वेब पर उपलब्ध नहीं है
 @msg	Second measured segment no longer exists	दूसरा मापा खंड अब मौजूद नहीं है
-@msg	seconds must be a whole number from 1 to 60	seconds: सेकंड 1 से 60 तक पूरी संख्या होना चाहिए
+@msg	seconds must be a whole number from 1 to 60	seconds 1 से 60 तक की पूर्ण संख्या होनी चाहिए
 @msg	segment does not exist	खंड मौजूद नहीं है
 @msg	select (or target) objects whose appearance isn't basic	सिलेक्शन (या लक्ष्य) ऑब्जेक्ट जिनकी उपस्थिति बुनियादी नहीं है
 @msg	select a blend	मिश्रण सिलेक्ट करें
@@ -7868,9 +7906,9 @@ antiAlias	Sharp	शार्प
 @msg	select type on a path	एक पाथ पर टाइप करें
 @msg	selection `{m}`: one or each	सिलेक्शन `{m}`: एक या प्रत्येक
 @msg	selection has no bounds	सिलेक्शन की कोई सीमा नहीं है
-@msg	Sent to {_1}	Sent to {_1}
+@msg	Sent to {_1}	{_1} को भेजा गया
 @msg	settings is an object of document.exportForScreens params	settings, document.exportForScreens पैरामीटर का ऑब्जेक्ट है
-@msg	settings must be an object	settings: सेटिंग्स एक ऑब्जेक्ट होना चाहिए
+@msg	settings must be an object	settings एक ऑब्जेक्ट होना चाहिए
 @msg	shadings of an unknown type were left out	अज्ञात प्रकार के छायांकन को छोड़ दिया गया था
 @msg	shadings of more than 4096 patches or triangles were left out	4096 से अधिक पैच या त्रिकोणों के छायांकन को छोड़ दिया गया था
 @msg	shadings whose functions are of an unknown type are filled with their middle colour	छायांकन जिसका कार्य अज्ञात प्रकार के होते हैं, उनके मध्य रंग से भरे होते हैं
@@ -7879,33 +7917,33 @@ antiAlias	Sharp	शार्प
 @msg	Shaper needs 1–64 source paths	शेपर के लिए 1–64 स्रोत पाथ चाहिए
 @msg	shortcut for `{k}` must be a string	`{k}` के लिए शॉर्टकट एक स्ट्रिंग होना चाहिए
 @msg	show `{show}`: all, missing, modified or embedded	`{show}``: सभी, लापता, संशोधित या एम्बेडेड
-@msg	Show All Hidden Attributes: nothing is hidden	Show all Hidden Attributes: कुछ भी छिपा नहीं है
+@msg	Show All Hidden Attributes: nothing is hidden	सभी छिपे हुए गुण दिखाएँ: कुछ भी छिपा नहीं है
 @msg	show must be true or false	show को true या false होना चाहिए
 @msg	Simplify Anchors: the paths have too many anchors to simplify at once	एंकर को सरलीकृत करें: पाथ में एक बार में सरल बनाने के लिए कई एंकर हैं
-@msg	size must be "small", "medium", "large" or a number of points over 0 up to {_1}	size: आकार "small", "medium", "large" या पॉइंट में 0 से अधिक और {_1} तक की संख्या होना चाहिए
-@msg	size must be positive	size: आकार सकारात्मक होना चाहिए
+@msg	size must be "small", "medium", "large" or a number of points over 0 up to {_1}	size "small", "medium", "large" या पॉइंट में 0 से अधिक और {_1} तक की संख्या होना चाहिए
+@msg	size must be positive	size धनात्मक होना चाहिए
 @msg	sizeMode is "fixed" or "pressure", not {other}	sizeMode को "fixed" या "pressure" होना चाहिए, {other} नहीं
 @msg	sizeMode is "fixed" or "pressure", not `{other}`	sizeMode को "fixed" या "pressure" होना चाहिए, `{other}` नहीं
 @msg	sizeVariation must be 0 or more	sizeVariation को 0 या अधिक होना चाहिए
 @msg	smallCaps must be true or false	smallCaps को true या false होना चाहिए
-@msg	some text is hidden or locked, so its font wasn't replaced	कुछ टेक्स्ट छिपा हुआ है या बंद कर दिया गया है, इसलिए इसका फ़ॉन्ट प्रतिस्थापित नहीं किया गया था
+@msg	some text is hidden or locked, so its font wasn't replaced	कुछ टेक्स्ट छिपा या लॉक है, इसलिए उसका फ़ॉन्ट बदला नहीं गया
 @msg	sort `{x}`: name, kind or status	sort `{x}`: name, kind या status होना चाहिए
-@msg	source must be the id of a Shaper Group's original shape	source: स्रोत एक शेपर ग्रुप के मूल आकार का आईडी होना चाहिए
+@msg	source must be the id of a Shaper Group's original shape	source किसी शेपर ग्रुप के मूल आकार का id होना चाहिए
 @msg	source paths are too large for Shaper	स्रोत पाथ शेपर के लिए बहुत बड़े हैं
-@msg	span must be "object" or "selection", got {v}	span: स्पैन को "object" या "selection" होना चाहिए, {v} मिला
+@msg	span must be "object" or "selection", got {v}	span "object" या "selection" होना चाहिए, {v} मिला
 @msg	span: "selection" places a `gradient`, not a swatch	span: "selection" एक `gradient` रखता है, स्वॉच नहीं
 @msg	span: "selection" places a gradient: give `gradient`	span: "selection" ग्रेडिएंट रखता है: `gradient` दें
 @msg	span: "selection" places a linear, radial, conic or diamond gradient, not a freeform one	span: "selection" एक रैखिक, रेडियल, शंक्वाकार या डायमंड ग्रेडिएंट रखता है, फ्रीफॉर्म ग्रेडिएंट नहीं
 @msg	span: "selection" places the gradient itself: leave out `start` and `end` (they already place it in document coordinates)	span: "selection" खुद ग्रेडिएंट रखता है: `start` और `end` न दें (वे उसे डॉक्यूमेंट निर्देशांकों पर रख देते हैं)
-@msg	speed must be accelerated, step or pause	speed: गति को तेज, कदम या रोकें होना चाहिए
+@msg	speed must be accelerated, step or pause	speed accelerated, step या pause होना चाहिए
 @msg	Split Into Grid: select paths large enough for the grid	स्प्लिट इनो ग्रिड: ग्रिड के लिए काफी बड़े पाथ सिलेक्ट करें
 @msg	spot, mode and group apply to solid colours only	स्पॉट, मोड और समूह केवल ठोस रंगों पर लागू होते हैं
 @msg	status `{s}`: linked, embedded, missing or modified	स्थिति `{s}`: लिंक्ड, एम्बेडेड, लापता या संशोधित
-@msg	steps must be 1..{MAX_STEPS}	steps: चरण 1 होना चाहिए।{MAX_STEPS}
+@msg	steps must be 1..{MAX_STEPS}	steps 1..{MAX_STEPS} होना चाहिए
 @msg	steps must be 1..1000	steps को 1..1000 होना चाहिए
 @msg	stop {i} needs `offset`	स्टॉप {i} को `offset` की जरूरत है
 @msg	stop {i} needs a valid `color`	स्टॉप {i} को वैध `color` की आवश्यकता है
-@msg	stop {i}: `{k}` must be a number	'{i}': `{k}` होना चाहिए
+@msg	stop {i}: `{k}` must be a number	स्टॉप {i}: `{k}` एक संख्या होनी चाहिए
 @msg	stop {i}: `plates` must be four numbers from 0 to 1 (C, M, Y, K)	स्टॉप {i}: `plates` में 0 से 1 के बीच चार संख्याएँ होनी चाहिए (C, M, Y, K)
 @msg	stop editing the opacity mask first	पहली बार अपारदर्शिता मास्क संपादित करना बंद करो
 @msg	stopped before the archive was finished	संग्रह समाप्त होने से पहले बंद कर दिया गया
@@ -7922,7 +7960,7 @@ antiAlias	Sharp	शार्प
 @msg	Targa files are RGB: colorModel rgb	Targa फ़ाइलें RGB हैं: colorModel rgb
 @msg	text must be {characterSet?, platform?, removeLineReturns?, removeParagraphReturns?, replaceSpaces?}	text को {characterSet?, platform?, removeLineReturns?, removeParagraphReturns?, replaceSpaces?} होना चाहिए
 @msg	Text options: {e}	टेक्स्ट ऑप्शन्स: {e}
-@msg	text transform is collapsed or unrepresentable	टेक्स्ट रूपांतरण पतन या प्रतिनिधित्व करने योग्य है
+@msg	text transform is collapsed or unrepresentable	टेक्स्ट ट्रांसफ़ॉर्म सिमटा हुआ है या उसे दर्शाया नहीं जा सकता
 @msg	Text Wrap: select a wrap object	टेक्स्ट लपेटें: एक रैप ऑब्जेक्ट चुनें
 @msg	text.{key} `{v}`: use "{_1}" or "{_2}"	Text.{key} `{v}`: "{_1}" या "{_2}" का उपयोग करें।
 @msg	text.replaceSpaces must be a whole number from 2 to 100	text.replaceSpaces को 2 से 100 के बीच पूर्णांक होना चाहिए
@@ -8015,7 +8053,7 @@ antiAlias	Sharp	शार्प
 @msg	the art on them differs from the page's in {_1}% of it	उनमें से कला पृष्ठ के {_1}% में भिन्न होती है।
 @msg	the art on them differs from the page's in {_1}% of it: they come from its editing data all the same	उनमें से कला पृष्ठ के {_1}% में भिन्न होती है: वे इसके संपादन डेटा से आते हैं।
 @msg	the artboard is locked	आर्टबोर्ड को लॉक किया जाता है
-@msg	the artboard to fit must be a positive size up to {_1} pt	फिट करने के लिए आर्टबोर्ड {_1} pt तक सकारात्मक आकार होना चाहिए
+@msg	the artboard to fit must be a positive size up to {_1} pt	फिट करने के लिए आर्टबोर्ड का आकार {_1} pt तक धनात्मक होना चाहिए
 @msg	the artboards don't fit on the canvas: fewer artboards, less spacing or a smaller size	आर्टबोर्ड कैनवास पर फिट नहीं हैं: कम आर्टबोर्ड, कम रिक्ति या छोटे आकार
 @msg	the background worker stopped	पृष्ठभूमि कार्यकर्ता बंद कर दिया
 @msg	the blend has no spine	मिश्रण में कोई रीढ़ नहीं है
@@ -8067,7 +8105,7 @@ antiAlias	Sharp	शार्प
 @msg	the file was updated or encrypted already	फ़ाइल को पहले से ही अद्यतन या एन्क्रिप्ट किया गया था
 @msg	the file's layers weren't read ({_1}): it comes in as its page, in one layer	फ़ाइल की लेयरें नहीं पढ़ी गईं ({_1}): यह अपने पृष्ठ के रूप में आता है, एक लेयर में
 @msg	the file's layers weren't read from its editing data ({_1}): they come from its PDF part	फ़ाइल की लेयर्स को इसके संपादन डेटा ({_1}) से नहीं पढ़ा गया था: वे अपने PDF भाग से आते हैं
-@msg	the file's preview header points outside the file	फ़ाइल के प्रीव्यू शीर्षलेख फ़ाइल के बाहर अंक
+@msg	the file's preview header points outside the file	फ़ाइल का प्रीव्यू हेडर फ़ाइल के बाहर की जगह बताता है
 @msg	the file's variable bindings weren't all read (bindings skipped: {_1}): those objects aren't bound to their variables	फ़ाइल की कुछ वेरिएबल बाइंडिंग नहीं पढ़ी गईं (छोड़ी गई बाइंडिंग: {_1}): वे ऑब्जेक्ट अपने वेरिएबल्स से नहीं बँधे हैं
 @msg	the file's variable library couldn't be read: the Variables panel doesn't list it	फ़ाइल की वेरिएबल लाइब्रेरी पढ़ी नहीं जा सकी: वेरिएबल्स पैनल उसे सूचीबद्ध नहीं करता
 @msg	the file's variable library was partly read (entries skipped: {_1}): the Variables panel lists the rest	फ़ाइल की वेरिएबल लाइब्रेरी आंशिक रूप से पढ़ी गई (छोड़ी गई प्रविष्टियाँ: {_1}): वेरिएबल्स पैनल शेष प्रविष्टियाँ दिखाता है
@@ -8109,7 +8147,7 @@ antiAlias	Sharp	शार्प
 @msg	the job would print more than {_1} pages	नौकरी {_1} पृष्ठों से अधिक प्रिंट करेगी
 @msg	the job would print more than {MAX_PAGES} pages	इस जॉब में {MAX_PAGES} से अधिक पेज प्रिंट होंगे
 @msg	the JPEG 2000 file can't be read	JPEG 2000 फ़ाइल पढ़ा नहीं जा सकता
-@msg	the JPEG 2000 file has an unsupported color space or JPX content	JPEG 2000 फ़ाइल में एक unसमर्थित रंग स्थान या JPX सामग्री है
+@msg	the JPEG 2000 file has an unsupported color space or JPX content	JPEG 2000 फ़ाइल में असमर्थित कलर स्पेस या JPX सामग्री है
 @msg	The last start of VectorCraft ended on {name} before its window appeared, so it started on {summary}. To try that graphics processor again, change Preferences › Performance › Graphics Processor or start with WGPU_BACKEND set	वेक्टर क्रेफ्ट की अंतिम शुरुआत अपनी विंडो दिखाई देने से पहले {name} पर समाप्त हुई, इसलिए यह {summary} पर शुरू हुआ। उस ग्राफिक्स प्रोसेसर को फिर से आज़माने के लिए, वरीयताओं को बदलें › प्रदर्शन › ग्राफिक्स प्रोसेसर या WGPU_BACKEND सेट के साथ शुरू होता है।
 @msg	The last start of VectorCraft ended while it listed the graphics processors, so it started on {summary} with OpenGL alone. To try the other graphics backends again, change Preferences › Performance › Graphics Processor or start with WGPU_BACKEND set	जब यह ग्राफिक्स प्रोसेसर को सूचीबद्ध करता है, तो यह केवल ओपनजीएल के साथ {summary} पर शुरू हुआ। फिर से अन्य ग्राफिक्स बैकेंड की कोशिश करने के लिए, वरीयताओं को बदलें › प्रदर्शन › ग्राफिक्स प्रोसेसर या WGPU_BACKEND सेट के साथ शुरू होता है।
 @msg	the layer has no objects to clip by	लेयर में क्लिप करने के लिए कोई ऑब्जेक्ट नहीं है
@@ -8184,7 +8222,7 @@ antiAlias	Sharp	शार्प
 @msg	the program asks for a resource that isn't defined	कार्यक्रम एक संसाधन के लिए पूछता है जिसे परिभाषित नहीं किया गया है
 @msg	the program ends a dictionary it didn't begin	कार्यक्रम एक शब्दकोश को समाप्त करता है यह शुरू नहीं हुआ था
 @msg	the program goes past one of the reader's limits	कार्यक्रम रीडर की सीमाओं में से एक के पास जाता है
-@msg	the program opens a file, which the reader can't do	कार्यक्रम एक फ़ाइल खोलता है, जिसे टेक्स्टक नहीं कर सकता
+@msg	the program opens a file, which the reader can't do	प्रोग्राम एक फ़ाइल ओपन करता है, जो रीडर नहीं कर सकता
 @msg	the program restores a saved state that was already restored	प्रोग्राम एक सेव की गई स्थिति को फिर से बहाल करता है, जो पहले ही बहाल हो चुकी थी
 @msg	the program runs too long	कार्यक्रम बहुत लंबे समय तक चलता है
 @msg	the program runs, deletes or renames a file, which the reader can't do	कार्यक्रम एक फ़ाइल को चलाता है, हटाता है या उसका नाम बदलता है, जिसे टेक्स्टक नहीं कर सकता
@@ -8259,12 +8297,12 @@ antiAlias	Sharp	शार्प
 @msg	the variable library's document type declaration holds something other than entities of plain text	वेरिएबल लाइब्रेरी के डॉक्यूमेंट प्रकार की घोषणा सादे टेक्स्ट की संस्थाओं के अलावा कुछ अन्य रखती है
 @msg	the variable library's entities expand to more than {MAX_LIBRARY_BYTES} bytes	वेरिएबल लाइब्रेरी की संस्थाएं {MAX_LIBRARY_BYTES} बाइट्स से अधिक विस्तार करती हैं
 @msg	the window has no dock	विंडो में कोई डॉक नहीं है
-@msg	the window's {what} ({points} points × {scale} DPI) cannot size a screenshot	विंडो का {what} ({points} अंक × {scale} डीपीआई) एक स्क्रीनशॉट का आकार नहीं दे सकता
+@msg	the window's {what} ({points} points × {scale} DPI) cannot size a screenshot	विंडो का {what} ({points} पॉइंट × {scale} DPI) एक स्क्रीनशॉट का आकार नहीं दे सकता
 @msg	the WMF header is damaged	WMF हेडर क्षतिग्रस्त है
 @msg	the Word document has more than {_1} MB of formatting properties, too many to place	वर्ड डॉक्यूमेंट में स्वरूपण प्रॉपर्टीज़ के {_1} MB से अधिक है, कई जगहों पर
 @msg	the Word document has more than {MAX_PAGES} pages of properties, too many to place	Word डॉक्यूमेंट में गुणों के {MAX_PAGES} से अधिक पेज हैं, रखने के लिए बहुत अधिक
 @msg	the Word document has more than {MAX_RUNS} runs of character or paragraph properties, too many to place	वर्ड डॉक्यूमेंट में {MAX_RUNS} से अधिक अक्षर या पैराग्राफ प्रॉपर्टीज़ होते हैं, बहुत से जगह होते हैं।
-@msg	the Word document has too much text or formatting to place as type (at most {MAX_PARAGRAPHS} paragraphs, {MAX_RUNS} runs and {_1} MB of text)	वर्ड डॉक्यूमेंट में टाइप के रूप में बहुत अधिक टेक्स्ट या स्वरूपण होता है (अधिकांश {MAX_PARAGRAPHS} पैराग्राफ, {MAX_RUNS} रन और {_1} MB of text)
+@msg	the Word document has too much text or formatting to place as type (at most {MAX_PARAGRAPHS} paragraphs, {MAX_RUNS} runs and {_1} MB of text)	वर्ड डॉक्यूमेंट में टाइप के रूप में रखने के लिए बहुत अधिक टेक्स्ट या फ़ॉर्मैटिंग है (अधिकतम {MAX_PARAGRAPHS} पैराग्राफ़, {MAX_RUNS} रन और {_1} MB टेक्स्ट)
 @msg	the Word document has too much text to place as type (at most {_1} MB)	वर्ड डॉक्यूमेंट में टाइप के रूप में बहुत अधिक टेक्स्ट होता है (अधिकांश {_1} MB)
 @msg	the Word document is encrypted or protected with a password; save it without one to place it	वर्ड डॉक्यूमेंट को एन्क्रिप्ट किया गया है या पासवर्ड के साथ संरक्षित किया गया है; इसे बिना किसी स्थान के सेव करें
 @msg	the Word document is too large to place (its {name} stream holds more than {_1} MB)	वर्ड डॉक्यूमेंट बहुत बड़ा होता है (यह {name} स्ट्रीम {_1} MB से अधिक रखता है)
@@ -8277,22 +8315,22 @@ antiAlias	Sharp	शार्प
 @msg	there are no colour swatches to draw	ड्रॉ करने के लिए कोई रंग स्वॉच नहीं है
 @msg	there are no objects to release	जारी करने के लिए कोई ऑब्जेक्ट नहीं है
 @msg	there are no printer settings to open here	यहां ओपन करने के लिए कोई प्रिंटर सेटिंग नहीं है
-@msg	there is already a design named `{name}`	there: पहले से ही `{name}` नामक एक डिज़ाइन है।
-@msg	there is already a design named `{to}`	there: पहले से ही `{to}` नामक एक डिजाइन है
-@msg	there is already a toolbar named `{name}`	there: पहले से ही `{name}` नामक एक टूलबार है।
-@msg	there is already a toolbar named `{to}`	there: पहले से ही `{to}` नामक एक टूलबार है।
+@msg	there is already a design named `{name}`	`{name}` नाम का डिज़ाइन पहले से मौजूद है
+@msg	there is already a design named `{to}`	`{to}` नाम का डिज़ाइन पहले से मौजूद है
+@msg	there is already a toolbar named `{name}`	`{name}` नाम का टूलबार पहले से मौजूद है
+@msg	there is already a toolbar named `{to}`	`{to}` नाम का टूलबार पहले से मौजूद है
 @msg	there is no clock here	यहाँ कोई घड़ी नहीं है
 @msg	there is no clock here: give `time` (Unix seconds)	यहाँ घड़ी नहीं है: `time` दें (Unix सेकंड)
 @msg	there is no library: create one first	वहाँ कोई लाइब्रेरी नहीं है: पहले एक बनाना
 @msg	these paths are too degenerate for Shaper	इन पाथ को शेपर के लिए बहुत अलग किया जाता है
-@msg	thickness must be from 0.01 to 5000 pt	thickness: मोटाई 0.01 से 5000 तक होना चाहिए
+@msg	thickness must be from 0.01 to 5000 pt	thickness 0.01 से 5000 pt तक होनी चाहिए
 @msg	this file was saved without PDF compatibility, and its editing data can't be read ({why})	यह फ़ाइल PDF संगतता के बिना सेव की गई थी, और इसका एडिटिंग डेटा पढ़ा नहीं जा सकता ({why})
 @msg	this file's PostScript couldn't be read ({why}): {what}	इस फ़ाइल के पोस्टस्क्रिप्ट को पढ़ा नहीं जा सकता ({why}): {what}
 @msg	this format holds one artboard: export several as PDF or with document.exportForScreens	इस फ़ॉर्मैट में एक आर्टबोर्ड रहता है: कई आर्टबोर्ड PDF में या document.exportForScreens से एक्सपोर्ट करें
-@msg	this is a DWG drawing, which can't be read: save it from the CAD app as an ASCII DXF and open that	this: यह एक डीडब्ल्यूजी ड्राइंग है, जिसे पढ़ा नहीं जा सकता है: इसे सीएडी ऐप से ASCII DXF के रूप में सेव करें और इसे ओपन करें कि
+@msg	this is a DWG drawing, which can't be read: save it from the CAD app as an ASCII DXF and open that	यह एक DWG ड्रॉइंग है, जिसे पढ़ा नहीं जा सकता: इसे CAD ऐप से ASCII DXF के रूप में सेव करें और वह फ़ाइल ओपन करें
 @msg	this is a PostScript file (an .ai saved in an older format or without PDF compatibility, or an EPS file), not a PDF: File › Open and File › Place read it as EPS	यह एक PostScript फ़ाइल है (पुराने फ़ॉर्मैट में या PDF संगतता के बिना सेव की गई .ai, या EPS फ़ाइल), PDF नहीं: फ़ाइल › ओपन और फ़ाइल › प्लेस इसे EPS के रूप में पढ़ते हैं
 @msg	this is a PostScript file (an .ai saved in an older format or without PDF compatibility, or an EPS file), which can't be opened yet: save it as PDF, PDF-compatible .ai or SVG	यह एक PostScript फ़ाइल है (पुराने फ़ॉर्मैट में या PDF संगतता के बिना सेव की गई .ai, या EPS फ़ाइल), जिसे अभी ओपन नहीं किया जा सकता: इसे PDF, PDF-संगत .ai या SVG के रूप में सेव करें
-@msg	this is not a PostScript file	this: यह पोस्टस्क्रिप्ट फ़ाइल नहीं है
+@msg	this is not a PostScript file	यह पोस्टस्क्रिप्ट फ़ाइल नहीं है
 @msg	this isn't a flat-colour logo ({_1}% of its solid areas match a few flat colours), so Flat Logo mode would turn its gradients into patches: use Color mode instead	यह एक फ्लैट रंग का लोगो नहीं है ({_1}% अपने ठोस क्षेत्रों में कुछ फ्लैट रंगों से मेल खाता है), इसलिए फ्लैट लोगो मोड अपने ग्रेडिएंट को पैच में बदल देगा: इसके बजाय कलर मोड का उपयोग करें
 @msg	this kind of brush has no options dialog yet	इस तरह के ब्रश में अभी तक कोई ऑप्शन्स संवाद नहीं है
 @msg	this PostScript file can't be read ({why}): save it as PDF or SVG in the app that made it	इस पोस्टस्क्रिप्ट फ़ाइल को पढ़ा नहीं जा सकता ({why}): इसे उस ऐप में PDF या SVG के रूप में सेव करें जिसने इसे बनाया
@@ -8308,13 +8346,13 @@ antiAlias	Sharp	शार्प
 @msg	tintReduction must be from 0 to 100 %	tintReduction 0 से 100 % तक होना चाहिए
 @msg	title can't be empty	title खाली नहीं हो सकता
 @msg	to (the new name) is required	(नया नाम) के लिए आवश्यक है
-@msg	to must be fill or stroke	to: होना चाहिए भरने या स्ट्रोक होना चाहिए
-@msg	to must be smooth or corner	to: होना चाहिए चिकनी या कोने होना
+@msg	to must be fill or stroke	to को fill या stroke होना चाहिए
+@msg	to must be smooth or corner	to को smooth या corner होना चाहिए
 @msg	too large for a zip archive: package to a folder	एक ज़िप संग्रह के लिए बहुत बड़ा: एक फ़ोल्डर में पैकेज
 @msg	too many `points` (at most 100000)	बहुत सारे `points` (अधिकांश 100000 पर)
 @msg	Too many breaks to remove at once	एक बार में हटाने के लिए बहुत सारे ब्रेक
 @msg	too many changed shortcuts	बहुत से बदलाव किए गए शॉर्टकट
-@msg	too many characters: at most {MAX_CHARS}	बहुत सारे अक्षर: at most {MAX_CHARS}
+@msg	too many characters: at most {MAX_CHARS}	बहुत अधिक अक्षर: अधिकतम {MAX_CHARS}
 @msg	too many dots for this size: lower the frequency	इस आकार के लिए बहुत सारे डॉट्स: आवृत्ति को कम करें
 @msg	too many filters over one file	एक फ़ाइल पर बहुत सारे फिल्टर
 @msg	too many library panels were opened in this session	इस सत्र में कई लाइब्रेरी पैनल ओपन किए गए थे।
@@ -8336,7 +8374,7 @@ antiAlias	Sharp	शार्प
 @msg	two saved selections would be named `{_1}`	दो सेव किए गए सिलेक्शन का नाम `{_1}` होगा
 @msg	type dimension cannot be represented with this text transform	इस टेक्स्ट को बदलने के साथ टाइप आयाम का प्रतिनिधित्व नहीं किया जा सकता है
 @msg	type dimension must be finite	टाइप का आयाम परिमित होना चाहिए
-@msg	type must be static or dynamic, not {v}	type: प्रकार स्थिर या गतिशील होना चाहिए, न कि {v}
+@msg	type must be static or dynamic, not {v}	type static या dynamic होना चाहिए, {v} नहीं
 @msg	type objects can't be isolated	टाइप ऑब्जेक्ट्स को आइसोलेट नहीं किया जा सकता
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	टेक्स्ट ऑब्जेक्ट के भीतर लेखन दिशा बदलने वाला टेक्स्ट अपने पहले वर्ण की दिशा में खुलता है
 @msg	type used as a mask in linked areas, wraparound text or a compound path doesn't clip	लिंक्ड एरिया, रैपअराउंड टेक्स्ट या कंपाउंड पाथ में मास्क के रूप में इस्तेमाल किया गया टाइप क्लिप नहीं करता
@@ -8344,15 +8382,15 @@ antiAlias	Sharp	शार्प
 @msg	unexpected host trap	होस्ट में अप्रत्याशित ट्रैप
 @msg	unexpected resources	अप्रत्याशित संसाधन
 @msg	unknown {k} key `{key}` (size, position)	अज्ञात {k} कुंजी `{key}` (आकार, स्थिति)
-@msg	unknown {key} `{v}` (none, short or full)	अज्ञात {key} `{v}` (one, short or full)
+@msg	unknown {key} `{v}` (none, short or full)	अज्ञात {key} `{v}` (none, short या full)
 @msg	unknown {key} profile `{n}`	अज्ञात {key} प्रोफ़ाइल `{n}`
-@msg	unknown align `{other}`	अज्ञात `{other}`
+@msg	unknown align `{other}`	अज्ञात संरेखण `{other}`
 @msg	unknown alignToPath `{a}`	अज्ञात alignToPath `{a}`
 @msg	unknown arrowhead {v}	अज्ञात arrowhead {v}
 @msg	unknown artboardLayout key `{k}` (layout, columns, spacing, rightToLeft)	अज्ञात artboardLayout कुंजी `{k}` (layout, columns, spacing, rightToLeft)
 @msg	unknown attribute `{attribute}`	अज्ञात विशेषता `{attribute}`
 @msg	unknown attribute `{k}`	अज्ञात विशेषता `{k}`
-@msg	unknown axis `{other}` (vertical|horizontal|free)	अज्ञात धुरी `{other}` (vertical Chhorizontal Chlorfree)
+@msg	unknown axis `{other}` (vertical|horizontal|free)	अज्ञात अक्ष `{other}` (vertical|horizontal|free)
 @msg	unknown blend mode {b}	अज्ञात मिश्रण मोड {b}
 @msg	unknown blend mode `{b}`	अज्ञात मिश्रण मोड `{b}`
 @msg	unknown brush type `{o}`	अज्ञात ब्रश प्रकार `{o}`
@@ -8394,8 +8432,8 @@ antiAlias	Sharp	शार्प
 @msg	unknown mode {m}	अज्ञात मोड {m}
 @msg	unknown mode `{o}`	अज्ञात मोड `{o}`
 @msg	unknown mode `{other}` (gray, rgb, hsb, lab, cmyk or web)	अज्ञात मोड `{other}` (ग्रे, RGB, hsb, लैब, cmyk या वेब)
-@msg	unknown mode `{other}` (mono|cmyk)	अज्ञात मोड `{other}` (mono trumcmyk)
-@msg	unknown mode `{other}` (rgb|cmyk|gray|global)	अज्ञात मोड `{other}` (rgb trumcmyk Chgray Chlobal)
+@msg	unknown mode `{other}` (mono|cmyk)	अज्ञात मोड `{other}` (mono|cmyk)
+@msg	unknown mode `{other}` (rgb|cmyk|gray|global)	अज्ञात मोड `{other}` (rgb|cmyk|gray|global)
 @msg	unknown mode `{other}` (set, add, subtract)	अज्ञात मोड `{other}` (सेट, ऐड, घटाना)
 @msg	unknown model `{other}`	अज्ञात मॉडल `{other}`
 @msg	unknown model `{other}` (keep, new or document)	अज्ञात मॉडल `{other}` (keep, नया या डॉक्यूमेंट)
@@ -8420,9 +8458,9 @@ antiAlias	Sharp	शार्प
 @msg	`{path}` must be {expected}, not {got}	`{path}` {expected} होना चाहिए, {got} नहीं
 @msg	`{path}` is nested too deeply	`{path}` बहुत गहराई तक नेस्ट किया गया है
 @msg	unknown PDF preset `{name}` (presets: {_1})	अज्ञात PDF प्रीसेट `{name}` (presets: {_1})
-@msg	unknown pieLegend `{v}` (none, standard or wedges)	अज्ञात pieLegend `{v}` (one, मानक या wedges)
+@msg	unknown pieLegend `{v}` (none, standard or wedges)	अज्ञात pieLegend `{v}` (none, standard या wedges)
 @msg	unknown piePosition `{v}` (even, ratio or stacked)	अज्ञात piePosition `{v}` (यहां तक कि अनुपात या स्टैक्ड)
-@msg	unknown pieSort `{v}` (none, all or first)	अज्ञात pieSort `{v}` (one, all या पहले)
+@msg	unknown pieSort `{v}` (none, all or first)	अज्ञात pieSort `{v}` (none, all या first)
 @msg	unknown plate `{n}`	अज्ञात प्लेट `{n}`
 @msg	unknown preference `{k}`	अज्ञात वरीयता `{k}`
 @msg	unknown preference `{key}`	अज्ञात वरीयता `{key}`
@@ -8443,19 +8481,19 @@ antiAlias	Sharp	शार्प
 @msg	unknown preset (one of {_1})	अज्ञात प्रीसेट ({_1} में से एक)
 @msg	unknown preset `{name}` (high, medium, low or a saved one: see flattener.presets.list)	अज्ञात प्रीसेट `{name}` (high, medium, low या कोई सेव किया गया प्रीसेट: flattener.presets.list देखें)
 @msg	unknown preset `{name}` (see flattener.presets.list)	अज्ञात प्रीसेट `{name}` (देखें flattener.presets.list)
-@msg	unknown preset `{name}` (see webExport.presets.list)	अज्ञात प्रीसेट `{name}` (see webExport.presets.list)
+@msg	unknown preset `{name}` (see webExport.presets.list)	अज्ञात प्रीसेट `{name}` (webExport.presets.list देखें)
 @msg	unknown preset `{name}`: not a built-in or saved preset (see imageTrace.presets)	अज्ञात प्रीसेट `{name}`: एक अंतर्निहित या सेव किए गए प्रीसेट नहीं (imageTrace.presets देखें)
-@msg	unknown profile {id} (see stroke.widthProfile.list)	अज्ञात प्रोफ़ाइल {id} (view stroke.widthProfile.list)
+@msg	unknown profile {id} (see stroke.widthProfile.list)	अज्ञात प्रोफ़ाइल {id} (stroke.widthProfile.list देखें)
 @msg	unknown proof target `{t}`	अज्ञात प्रमाण लक्ष्य `{t}`
 @msg	unknown quotes key `{k}` (double, single)	अज्ञात उद्धरण कुंजी `{k}` (डबल, सिंगल)
 @msg	unknown resolution `{v}`	अज्ञात रिज़ॉल्यूशन `{v}`
 @msg	unknown rule `{r}` (see color.harmony)	अज्ञात नियम `{r}` (देखें color.harmony)
 @msg	unknown rule `{rule}` ({_1})	अज्ञात नियम `{rule}` ({_1})
 @msg	unknown setting `{k}`	अज्ञात सेटिंग `{k}`
-@msg	unknown shape `{v}` (circle|ellipse|square|diamond|line)	अज्ञात आकार `{v}` (circle Chellipsesquareddiamond filline)
-@msg	unknown side `{other}` (left|right|top|bottom)	अज्ञात पक्ष `{other}` (left |right |topbottom)
-@msg	unknown snap option `{key}` (use {options})	अज्ञात स्नैप ऑप्शन्स `{key}` (Us {options})
-@msg	unknown spacing `{o}` (smooth|steps|distance)	अज्ञात रिक्ति `{o}` (स्मोथ ट्रूस्टेप |distance)
+@msg	unknown shape `{v}` (circle|ellipse|square|diamond|line)	अज्ञात आकार `{v}` (circle|ellipse|square|diamond|line)
+@msg	unknown side `{other}` (left|right|top|bottom)	अज्ञात पक्ष `{other}` (left|right|top|bottom)
+@msg	unknown snap option `{key}` (use {options})	अज्ञात स्नैप ऑप्शन `{key}` ({options} का उपयोग करें)
+@msg	unknown spacing `{o}` (smooth|steps|distance)	अज्ञात स्पेसिंग `{o}` (smooth|steps|distance)
 @msg	unknown tileType `{t}` ({_1})	अज्ञात tileType `{t}` ({_1})
 @msg	unknown tool `{t}`	अज्ञात टूल `{t}`
 @msg	unknown tool `{tool}`	अज्ञात टूल `{tool}`
@@ -8494,11 +8532,11 @@ antiAlias	Sharp	शार्प
 @msg	version {0} files can't be compressed: only version {COMPRESSED_SINCE} and later open compressed files	संस्करण {0} की फ़ाइलें संपीड़ित नहीं हो सकतीं: केवल संस्करण {COMPRESSED_SINCE} और बाद के संस्करण संपीड़ित फ़ाइलें खोलते हैं
 @msg	videoRulerPixelAspectRatio must be a number from 0.1 to 10	videoRulerPixelAspectRatio को 0.1 से 10 के बीच संख्या होना चाहिए
 @msg	view is required	view आवश्यक है
-@msg	view must be one of {_1}	view: राय होना चाहिए {_1}
+@msg	view must be one of {_1}	view {_1} में से एक होना चाहिए
 @msg	warpStyle can only edit an applied Warp effect	warpStyle केवल लागू वार्प इफ़ेक्ट एडिट कर सकता है
 @msg	width and height are at least 1 pixel	चौड़ाई और ऊंचाई कम से कम 1 पिक्सेल हैं
 @msg	width factors must be finite	चौड़ाई कारकों को परिमित होना चाहिए
-@msg	width must be positive	width: चौड़ाई सकारात्मक होना चाहिए
+@msg	width must be positive	width धनात्मक होनी चाहिए
 @msg	width out of range	सीमा से बाहर चौड़ाई
 @msg	width/height must be > 0	चौड़ाई / ऊंचाई होना चाहिए > 0
 @msg	width and height must be more than 0 and at most {limit}	चौड़ाई और ऊंचाई 0 से अधिक और अधिकतम {limit} होनी चाहिए
@@ -8517,10 +8555,10 @@ antiAlias	Sharp	शार्प
 @msg	a layer of the PSD file is too large to read	PSD फ़ाइल की एक लेयर पढ़ने के लिए बहुत बड़ी है
 @msg	the PSD file's layers take more memory to read than allowed	PSD फ़ाइल की लेयर पढ़ने के लिए अनुमति से अधिक मेमोरी चाहिए
 @msg	the layers can't be read ({e}): the file opened as its merged image	लेयर पढ़ी नहीं जा सकतीं ({e}): फ़ाइल अपनी मर्ज की गई इमेज के रूप में खुली
-@msg	zone must be a string	zone: क्षेत्र एक स्ट्रिंग होना चाहिए
+@msg	zone must be a string	zone एक स्ट्रिंग होनी चाहिए
 @msg	zone must be tab, center, left, right, top or bottom	zone को tab, center, left, right, top या bottom होना चाहिए
-@msg	zone needs an anchor: dock beside a panel with anchor, or in a new dock column with side (Start or End)	zone: जोन को एक एंकर की आवश्यकता होती है: एंकर के साथ एक पैनल के बगल में, या साइड (स्टार्ट या एंड) के साथ एक नए डॉक कॉलम में
-@msg	zoom must be positive	zoom: ज़ूम सकारात्मक होना चाहिए
+@msg	zone needs an anchor: dock beside a panel with anchor, or in a new dock column with side (Start or End)	zone के लिए एंकर चाहिए: anchor देकर किसी पैनल के पास डॉक करें, या side (Start या End) देकर नए डॉक कॉलम में
+@msg	zoom must be positive	zoom धनात्मक होना चाहिए
 @msgplural	({n} linked file not found)|({n} linked files not found)	({n} लिंक्ड फ़ाइल नहीं मिली)|({n} लिंक्ड फ़ाइलें नहीं मिलीं)
 @msgplural	{n} color is out of the CMYK gamut|{n} colors are out of the CMYK gamut	{n} रंग CMYK गैमट से बाहर है|{n} रंग CMYK गैमट से बाहर हैं
 @msgplural	{n} font file is now in {folder}; {failed} couldn't be added: {reason}|{n} font files are now in {folder}; {failed} couldn't be added: {reason}	{n} फ़ॉन्ट फ़ाइल अब {folder} में है; {failed} जोड़ी नहीं जा सकीं: {reason}|{n} फ़ॉन्ट फ़ाइलें अब {folder} में हैं; {failed} जोड़ी नहीं जा सकीं: {reason}
@@ -8548,6 +8586,7 @@ antiAlias	Sharp	शार्प
 @msg	the document sets a bleed that this PDF/X file leaves out: turn on Use document bleed settings	डॉक्यूमेंट एक ब्लीड सेट करता है जिसे यह PDF/X फ़ाइल छोड़ देती है: "डॉक्यूमेंट की ब्लीड सेटिंग्स उपयोग करें" चालू करें
 @msgplural	Exported {what} with {n} note: {first}|Exported {what} with {n} notes: {first}	{what} एक्सपोर्ट हुआ, {n} नोट के साथ: {first}|{what} एक्सपोर्ट हुआ, {n} नोट्स के साथ: {first}
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	{n} नोट के साथ खुला: {first}|{n} नोट्स के साथ खुला: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}। {n} नोट के साथ खुला: {first}|{notice}। {n} नोट्स के साथ खुला: {first}
 @msgplural	Packaged {n} file ({note}) in {folder}|Packaged {n} files ({note}) in {folder}	{folder} में {n} फ़ाइल ({note}) पैकेज हुई|{folder} में {n} फ़ाइलें ({note}) पैकेज हुईं
 @msgplural	Packaged {n} file {note}|Packaged {n} files {note}	{n} फ़ाइल पैकेज हुई {note}|{n} फ़ाइलें पैकेज हुईं {note}
 @msgplural	Packaged {n} file in {folder}|Packaged {n} files in {folder}	{folder} में {n} फ़ाइल पैकेज हुई|{folder} में {n} फ़ाइलें पैकेज हुईं
@@ -8835,3 +8874,9 @@ theme	Appearance	अपीयरेंस
 	Margin	मार्जिन
 	Box	बॉक्स
 	Swatch	स्वॉच
+	Banner Hems and Grommets…	बैनर हेम और आईलेट…
+	Banner Hems and Grommets	बैनर हेम और आईलेट
+	Hem	हेम
+	Grommets	आईलेट
+	Grommet Inset	किनारे से आईलेट की दूरी
+	Diameter	व्यास
diff --git a/crates/ui-egui/src/i18n/hu.tsv b/crates/ui-egui/src/i18n/hu.tsv
index cea96d098d..969b923a1c 100644
--- a/crates/ui-egui/src/i18n/hu.tsv
+++ b/crates/ui-egui/src/i18n/hu.tsv
@@ -3009,6 +3009,29 @@ file-filter	Templates	Sablonok
 	Pattern	Mintázat
 	Pattern Brush	Mintázatecset
 	missing from the Brushes panel	hiányzik az Ecsetek panelről
+	built in	beépített
+	embedding not allowed	beágyazás nem engedélyezett
+	embedding for editing	beágyazás szerkesztéshez
+	embedding for preview and print	beágyazás előnézethez és nyomtatáshoz
+	embedding allowed	beágyazás engedélyezett
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	helyettesítve: megjelenítés ezzel: {family} {style} ({detail})
+	missing: shown in {family} {style}	hiányzik: megjelenítés ezzel: {family} {style}
+	missing	hiányzik
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} – {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Lineáris színátmenet
+	Radial gradient	Körkörös színátmenet
+	Conic gradient	Kúpos színátmenet
+	Diamond gradient	Rombusz színátmenet
+	Freeform gradient	Szabad formájú színátmenet
+@plural	{n} instance|{n} instances	{n} példány
+@plural	{n} row|{n} rows	{n} sor
+@plural	{n} column|{n} columns	{n} oszlop
 	Pattern Brush Options	Mintázatecset beállításai
 	Pattern Editing	Mintázatszerkesztés
 	Pattern Options	Mintázat beállításai
@@ -4310,6 +4333,11 @@ mark-style	Japanese	Japán
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Tate-chu-yoko beállításai…
 	Tate-chu-yoko Settings	Tate-chu-yoko beállításai
+	Warichu	Warichu
+	Warichu Settings…	Warichu beállításai…
+	Warichu Settings	Warichu beállításai
+	Lines:	Sorok:
+	Line Gap:	Sorköz:
 	Composite Fonts…	Összetett betűtípusok…
 	Composite Fonts	Összetett betűtípusok
 	Export Composite Fonts	Összetett betűtípusok exportálása
@@ -4867,6 +4895,9 @@ imageTrace	Outline	Körvonal
 @msg	`{keep}` is not a side of this axis	`{keep}` nem ennek a tengelynek az oldala
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}`: `auto` vagy nyelvkód kell, például `en` vagy `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}`: #rrggbb szín kell
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}`: #rrggbb szín vagy rétegszín neve kell
+@msg	unknown Live Paint option `{key}`	ismeretlen élő festés beállítás: `{key}`
+@msg	unknown Shape Builder option `{key}`	ismeretlen alakzatépítő beállítás: `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}`: #rrggbb szín kell
 @msg	`{key}` must be a number	`{key}`: szám kell
 @msg	`{key}` must be a number, not {v}	`{key}`: szám kell, ez nem az: {v}
@@ -5162,6 +5193,10 @@ imageTrace	Outline	Körvonal
 @msg	Couldn't place {name}: {e}	Nem sikerült elhelyezni: {name}: {e}
 @msg	Couldn't read {name}: {e}	Nem sikerült beolvasni: {name}: {e}
 @msg	Couldn't save recovery data: {e}	Nem sikerült menteni a helyreállítási adatokat: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Nem sikerült menteni a(z) {title} helyreállítási adatait: {e}. A másolatok helye: {folder}, az alapértelmezett helyreállítási mappa; másik mappa használatához állítsd be a Beállítások → Fájlkezelés → Adat-helyreállítás → Mappa értéket (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Nem sikerült menteni a(z) {title} helyreállítási adatait: {e}. A másolatok helye: {folder}, a Beállításokban megadott mappa; másik mappa használatához állítsd be a Beállítások → Fájlkezelés → Adat-helyreállítás → Mappa értéket (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Nem sikerült menteni a helyreállítási adatokat: {e}. A másolatok helye: {folder}, az alapértelmezett helyreállítási mappa; másik mappa használatához állítsd be a Beállítások → Fájlkezelés → Adat-helyreállítás → Mappa értéket (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Nem sikerült menteni a helyreállítási adatokat: {e}. A másolatok helye: {folder}, a Beállításokban megadott mappa; másik mappa használatához állítsd be a Beállítások → Fájlkezelés → Adat-helyreállítás → Mappa értéket (recoveryFolder)
 @msg	Create from Guides: the document has no artboard	Létrehozás segédvonalakból: a dokumentumban nincs rajztábla
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Létrehozás segédvonalakból: a segédvonalak túl sok szeletet adnak (legfeljebb {MAX_PIECES})
 @msg	Create from Selection: the selection has no area	Létrehozás a kijelölésből: a kijelölésnek nincs területe
@@ -5238,6 +5273,7 @@ imageTrace	Outline	Körvonal
 @msg	invalid parameters for `{cmd}`: {msg}	érvénytelen paraméterek (`{cmd}`): {msg}
 @msg	invalid PDF setting: {0}	érvénytelen PDF-beállítás: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	a(z) {n}. rajztábla oldala {size}, hosszabb a PDF 14 400 pt-os (200 in) oldalkorlátjánál: {unit} UserUnit értékkel íródik, így a UserUnit-ot figyelmen kívül hagyó alkalmazások ennyiszer kisebbnek mutatják
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	a(z) {n}. rajztábla oldala {size}, hosszabb a PDF 14 400 pt-os (200 in) oldalkorlátjánál: {unit} UserUnit értékkel íródik, így a UserUnit-ot figyelmen kívül hagyó alkalmazások ennyiszer kisebbnek mutatják: kapcsolja be a „200 in-nél hosszabb oldalak írása teljes méretben, pontban” beállítást
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	a(z) {n}. rajztábla oldala {size}, hosszabb a PDF 14 400 pt-os (200 in) oldalkorlátjánál: a(z) {label} oldalak UserUnit nélkül, pontokban íródnak, és a korlátot betartó alkalmazások 200 in-re vágják az oldalt
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	a PDF 1.5-ben nincs UserUnit, amelyre egy 14 400 pt-nál (200 in) hosszabb oldalnak szüksége van a mérete megtartásához: a fájl PDF 1.6-ként íródik
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	a PDF 1.4-ben nincs UserUnit, amelyre egy 14 400 pt-nál (200 in) hosszabb oldalnak szüksége van, hogy a PDF/A-2 14 400 egységes oldalkorlátján belül maradjon: a fájl PDF 1.6-ként íródik
@@ -5479,6 +5515,7 @@ imageTrace	Outline	Körvonal
 @msg	onto must name a floating panel	az onto egy lebegő panelt kell megnevezzen
 @msg	onto must name a panel floating in another group	az onto egy másik csoportban lebegő panelt kell megnevezzen
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Megnyitva; megjegyzések: {n}, az első: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Megnyitva; megjegyzések: {n}, az első: {first}
 @msg	Opened {url}	Megnyitva: {url}
 @msg	Outline Stroke: no stroked paths selected	Körvonal útvonallá alakítása: nincs kijelölt körvonalas útvonal
 @msgplural	Packaged {n} file ({note}) in {folder}|Packaged {n} files ({note}) in {folder}	Becsomagolt fájlok: {n}, mappa: {folder} ({note})
@@ -6848,6 +6885,8 @@ anchor	Points:	Pontok:
 	Anchor Inspector	Horgonypont-vizsgáló
 	Add Points at Crossings	Pontok hozzáadása a kereszteződésekben
 	Split at Crossings	Felosztás a kereszteződésekben
+	Trim at Crossings Tool	Levágás a kereszteződésekben eszköz
+	Trim at Crossings	Levágás a kereszteződésekben
 	Extend Path	Útvonal meghosszabbítása
 	Measure & Inspect	Mérés és vizsgálat
 	Set Anchor	Horgonypont beállítása
@@ -7427,3 +7466,9 @@ breakText	Glyphs	Glifák
 	Margin	Margó
 	Box	Keret
 	Swatch	Színminta
+	Banner Hems and Grommets…	Molinó szegései és ringlijei…
+	Banner Hems and Grommets	Molinó szegései és ringlijei
+	Hem	Szegés
+	Grommets	Ringlik
+	Grommet Inset	Ringlik távolsága a széltől
+	Diameter	Átmérő
diff --git a/crates/ui-egui/src/i18n/id.tsv b/crates/ui-egui/src/i18n/id.tsv
index 3593cedb9c..55cff9798e 100644
--- a/crates/ui-egui/src/i18n/id.tsv
+++ b/crates/ui-egui/src/i18n/id.tsv
@@ -1542,6 +1542,11 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Pengaturan Tate-chu-yoko…
 	Tate-chu-yoko Settings	Pengaturan Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Pengaturan Warichu…
+	Warichu Settings	Pengaturan Warichu
+	Lines:	Baris:
+	Line Gap:	Celah Baris:
 	Composite Fonts…	Font komposit…
 	Composite Fonts	Font komposit
 	Export Composite Fonts	Ekspor font komposit
@@ -3134,6 +3139,29 @@ theme	Appearance	Tampilan
 	Bristle Brush	Kuas bristle
 	Pattern Brush	Kuas pola
 	missing from the Brushes panel	tidak ada di panel Kuas
+	built in	bawaan
+	embedding not allowed	penyematan tidak diizinkan
+	embedding for editing	penyematan untuk pengeditan
+	embedding for preview and print	penyematan untuk pratinjau dan cetak
+	embedding allowed	penyematan diizinkan
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	diganti: ditampilkan dengan {family} {style} ({detail})
+	missing: shown in {family} {style}	tidak ada: ditampilkan dengan {family} {style}
+	missing	tidak ada
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Gradien linear
+	Radial gradient	Gradien radial
+	Conic gradient	Gradien kerucut
+	Diamond gradient	Gradien wajik
+	Freeform gradient	Gradien bentuk bebas
+@plural	{n} instance|{n} instances	{n} instans
+@plural	{n} row|{n} rows	{n} baris
+@plural	{n} column|{n} columns	{n} kolom
 	Select art to make a scatter, art or pattern brush.	Pilih karya seni untuk membuat kuas sebar, seni, atau pola.
 	Brush Art	Karya seni kuas
 	New Symbol	Simbol baru
@@ -4258,6 +4286,10 @@ imageTrace	Outline	Kontur
 @msg	Couldn't paste: the document it was pasted in was reverted	Tidak dapat menempel: dokumen tempatnya ditempel sudah dikembalikan
 @msg	Couldn't read {name}: {e}	Tidak dapat membaca {name}: {e}
 @msg	Couldn't save recovery data: {e}	Tidak dapat menyimpan data pemulihan: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Tidak dapat menyimpan data pemulihan untuk {title}: {e}. Salinan disimpan di {folder}, folder pemulihan bawaan; untuk memakai folder lain, atur Preferensi → Penanganan File → Pemulihan Data → Folder (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Tidak dapat menyimpan data pemulihan untuk {title}: {e}. Salinan disimpan di {folder}, folder yang diatur di Preferensi; untuk memakai folder lain, atur Preferensi → Penanganan File → Pemulihan Data → Folder (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Tidak dapat menyimpan data pemulihan: {e}. Salinan disimpan di {folder}, folder pemulihan bawaan; untuk memakai folder lain, atur Preferensi → Penanganan File → Pemulihan Data → Folder (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Tidak dapat menyimpan data pemulihan: {e}. Salinan disimpan di {folder}, folder yang diatur di Preferensi; untuk memakai folder lain, atur Preferensi → Penanganan File → Pemulihan Data → Folder (recoveryFolder)
 @msg	Create Outlines: select text objects	Buat kontur: pilih objek teks
 @msg	Create from Guides: the document has no artboard	Buat dari panduan: dokumen tidak memiliki artboard
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Buat dari panduan: panduan menghasilkan lebih dari {MAX_PIECES} irisan
@@ -4838,6 +4870,7 @@ imageTrace	Outline	Kontur
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	{n} dokumen hasil pemulihan dibuang
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	{n} dokumen hasil pemulihan dipulihkan: simpan agar tidak hilang
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Dibuka dengan {n} catatan: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Dibuka dengan {n} catatan: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	{path} disimpan dengan {n} catatan: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	{n} gambar tersemat; {missing} hilang: tautkan ulang dulu
 @msgplural	Embedded {n} image|Embedded {n} images	{n} gambar tersemat
@@ -6324,6 +6357,8 @@ anchor	Points:	Titik:
 	Anchor Inspector	Pemeriksa titik jangkar
 	Add Points at Crossings	Tambahkan titik di persilangan
 	Split at Crossings	Pisahkan di persilangan
+	Trim at Crossings Tool	Alat pangkas di persilangan
+	Trim at Crossings	Pangkas di persilangan
 	Extend Path	Perpanjang jalur
 	Measure & Inspect	Ukur dan periksa
 	Set Anchor	Atur titik jangkar
@@ -6852,3 +6887,9 @@ breakText	Glyphs	Glif
 	Box	Kotak
 	Swatch	Sampel warna
 	Direction	Arah
+	Banner Hems and Grommets…	Lipatan dan Mata Ayam Spanduk…
+	Banner Hems and Grommets	Lipatan dan Mata Ayam Spanduk
+	Hem	Lipatan
+	Grommets	Mata ayam
+	Grommet Inset	Jarak mata ayam dari tepi
+	Diameter	Diameter
diff --git a/crates/ui-egui/src/i18n/it.tsv b/crates/ui-egui/src/i18n/it.tsv
index 61ad0afce3..ea10433ebd 100644
--- a/crates/ui-egui/src/i18n/it.tsv
+++ b/crates/ui-egui/src/i18n/it.tsv
@@ -2230,6 +2230,29 @@ file-filter	Templates	Modelli
 	Bristle Brush	Pennello a setole
 	Pattern Brush	Pennello motivo
 	missing from the Brushes panel	mancante nel pannello Pennelli
+	built in	integrato
+	embedding not allowed	incorporamento non consentito
+	embedding for editing	incorporamento per la modifica
+	embedding for preview and print	incorporamento per anteprima e stampa
+	embedding allowed	incorporamento consentito
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	sostituito: mostrato con {family} {style} ({detail})
+	missing: shown in {family} {style}	mancante: mostrato con {family} {style}
+	missing	mancante
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Sfumatura lineare
+	Radial gradient	Sfumatura radiale
+	Conic gradient	Sfumatura conica
+	Diamond gradient	Sfumatura a rombo
+	Freeform gradient	Sfumatura libera
+@plural	{n} instance|{n} instances	{n} istanza|{n} istanze
+@plural	{n} row|{n} rows	{n} riga|{n} righe
+@plural	{n} column|{n} columns	{n} colonna|{n} colonne
 	Select art to make a scatter, art or pattern brush.	Seleziona la grafica per creare un pennello a dispersione, artistico o motivo.
 	Brush Art	Grafica del pennello
 	New Calligraphic Brush	Nuovo pennello calligrafico
@@ -3689,6 +3712,11 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Impostazioni Tate-chu-yoko…
 	Tate-chu-yoko Settings	Impostazioni Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Impostazioni Warichu…
+	Warichu Settings	Impostazioni Warichu
+	Lines:	Righe:
+	Line Gap:	Distanza tra le righe:
 	Composite Fonts…	Font compositi…
 	Composite Fonts	Font compositi
 	Export Composite Fonts	Esporta font compositi
@@ -4405,6 +4433,10 @@ axis	Both	Entrambi
 @msg	Couldn't paste: the document it was pasted in was reverted	Impossibile incollare: il documento in cui si incollava è stato ripristinato
 @msg	Couldn't read {name}: {e}	Impossibile leggere {name}: {e}
 @msg	Couldn't save recovery data: {e}	Impossibile salvare i dati di recupero: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Impossibile salvare i dati di recupero di {title}: {e}. Le copie vanno in {folder}, la cartella di recupero predefinita; per usare un’altra cartella, imposta Preferenze → Gestione file → Recupero dati → Cartella (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Impossibile salvare i dati di recupero di {title}: {e}. Le copie vanno in {folder}, la cartella impostata nelle Preferenze; per usare un’altra cartella, imposta Preferenze → Gestione file → Recupero dati → Cartella (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Impossibile salvare i dati di recupero: {e}. Le copie vanno in {folder}, la cartella di recupero predefinita; per usare un’altra cartella, imposta Preferenze → Gestione file → Recupero dati → Cartella (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Impossibile salvare i dati di recupero: {e}. Le copie vanno in {folder}, la cartella impostata nelle Preferenze; per usare un’altra cartella, imposta Preferenze → Gestione file → Recupero dati → Cartella (recoveryFolder)
 @msg	Create Outlines: select text objects	Crea contorni: seleziona oggetti di testo
 @msg	Create from Guides: the document has no artboard	Crea da guide: il documento non ha una tavola da disegno
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Crea da guide: le guide generano più di {MAX_PIECES} sezioni
@@ -4490,6 +4522,9 @@ axis	Both	Entrambi
 @msg	`{keep}` is not a side of this axis	`{keep}` non è un lato di questo asse
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` deve essere `auto` o un codice lingua come `en` o `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}` deve essere un colore #rrggbb
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` deve essere un colore #rrggbb o il nome di un colore del livello
+@msg	unknown Live Paint option `{key}`	opzione di pittura dinamica sconosciuta `{key}`
+@msg	unknown Shape Builder option `{key}`	opzione del generatore forme sconosciuta `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` deve essere un colore #rrggbb
 @msg	`{key}` must be a number	`{key}` deve essere un numero
 @msg	`{key}` must be a number, not {v}	`{key}` deve essere un numero, non {v}
@@ -4649,6 +4684,7 @@ axis	Both	Entrambi
 @msg	internal error: {msg} (please report this bug)	errore interno: {msg} (segnala questo bug)
 @msg	invalid PDF setting: {0}	impostazione PDF non valida: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	la pagina della tavola da disegno {n} misura {size}, più del limite di pagina PDF di 14.400 pt (200 in): viene scritta con una UserUnit di {unit}, quindi le app che ignorano UserUnit la mostrano altrettante volte più piccola
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	la pagina della tavola da disegno {n} misura {size}, più del limite di pagina PDF di 14.400 pt (200 in): viene scritta con una UserUnit di {unit}, quindi le app che ignorano UserUnit la mostrano altrettante volte più piccola: attiva «Scrivi le pagine più lunghe di 200 in a grandezza reale, in punti»
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	la pagina della tavola da disegno {n} misura {size}, più del limite di pagina PDF di 14.400 pt (200 in): le pagine {label} vengono scritte senza UserUnit, in punti, e le app che rispettano il limite tagliano la pagina a 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 non ha UserUnit, che serve a una pagina più lunga di 14.400 pt (200 in) per mantenere le sue dimensioni: il file viene scritto come PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 non ha UserUnit, che serve a una pagina più lunga di 14.400 pt (200 in) per restare entro il limite di pagina di PDF/A-2, di 14.400 unità: il file viene scritto come PDF 1.6
@@ -5089,6 +5125,7 @@ axis	Both	Entrambi
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Scartato {n} documento recuperato|Scartati {n} documenti recuperati
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Ripristinato {n} documento recuperato. Salvalo per conservarlo|Ripristinati {n} documenti recuperati. Salvali per conservarli
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Aperto con {n} nota: {first}|Aperto con {n} note: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Aperto con {n} nota: {first}|{notice}. Aperto con {n} note: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	Salvato {path} con {n} nota: {first}|Salvato {path} con {n} note: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	Incorporata {n} immagine; mancanti: {missing} (ricollegale prima)|Incorporate {n} immagini; mancanti: {missing} (ricollegale prima)
 @msgplural	Embedded {n} image|Embedded {n} images	Incorporata {n} immagine|Incorporate {n} immagini
@@ -6491,6 +6528,8 @@ anchor	Points:	Punti:
 	Anchor Inspector	Ispettore punti di ancoraggio
 	Add Points at Crossings	Aggiungi punti agli incroci
 	Split at Crossings	Dividi agli incroci
+	Trim at Crossings Tool	Strumento Rifila agli incroci
+	Trim at Crossings	Rifila agli incroci
 	Extend Path	Estendi tracciato
 	Measure & Inspect	Misura e ispeziona
 	Set Anchor	Imposta punto di ancoraggio
@@ -7073,3 +7112,9 @@ breakText	Glyphs	Glifi
 	Margin	Margine
 	Box	Riquadro
 	Swatch	Campione
+	Banner Hems and Grommets…	Orli e occhielli per striscioni…
+	Banner Hems and Grommets	Orli e occhielli per striscioni
+	Hem	Orlo
+	Grommets	Occhielli
+	Grommet Inset	Distanza degli occhielli dal bordo
+	Diameter	Diametro
diff --git a/crates/ui-egui/src/i18n/ja.tsv b/crates/ui-egui/src/i18n/ja.tsv
index e624f78e06..ca80ba3a83 100644
--- a/crates/ui-egui/src/i18n/ja.tsv
+++ b/crates/ui-egui/src/i18n/ja.tsv
@@ -2439,6 +2439,29 @@ antiAlias	Sharp	シャープ
 	Bristle Brush	剛毛ブラシ
 	Pattern Brush	パターンブラシ
 	missing from the Brushes panel	ブラシパネルにありません
+	built in	内蔵
+	embedding not allowed	埋め込み不可
+	embedding for editing	編集用に埋め込み可
+	embedding for preview and print	プレビューと印刷用に埋め込み可
+	embedding allowed	埋め込み可
+	{file}; {embedding}	{file}、{embedding}
+	substituted: shown in {family} {style} ({detail})	代替: {family} {style} で表示 ({detail})
+	missing: shown in {family} {style}	見つかりません: {family} {style} で表示
+	missing	見つかりません
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}、{instances}
+	{kind}, {rows} × {cols}	{kind}、{rows} × {cols}
+	{grid}, {instances}	{grid}、{instances}
+	Linear gradient	線形グラデーション
+	Radial gradient	円形グラデーション
+	Conic gradient	円錐グラデーション
+	Diamond gradient	ひし形グラデーション
+	Freeform gradient	フリーグラデーション
+@plural	{n} instance|{n} instances	インスタンス {n} 個
+@plural	{n} row|{n} rows	{n} 行
+@plural	{n} column|{n} columns	{n} 列
 	Select art to make a scatter, art or pattern brush.	散布ブラシ、アートブラシ、パターンブラシを作成するには、アートを選択します。
 	Brush Art	ブラシのアート
 	New Calligraphic Brush	新規絵筆ブラシ
@@ -4018,6 +4041,11 @@ file-filter	Templates	テンプレート
 	Tate-chu-yoko	縦中横
 	Tate-chu-yoko Settings…	縦中横の設定…
 	Tate-chu-yoko Settings	縦中横の設定
+	Warichu	割注
+	Warichu Settings…	割注の設定…
+	Warichu Settings	割注の設定
+	Lines:	行数:
+	Line Gap:	行間:
 	Composite Fonts…	合成フォント…
 	Composite Fonts	合成フォント
 	Export Composite Fonts	合成フォントを書き出し
@@ -4597,6 +4625,9 @@ swatch	Bright Violet	ビビッドバイオレット
 @msg	installing from a path is not available on the web; pass the module as `dataBase64`	Web 版ではファイルパスからはインストールできないため、モジュールは `dataBase64` で渡してください
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` は `auto` か、`en` や `zh-hant` などの言語コードにしてください
 @msg	`{key}` must be a #rrggbb color	`{key}` は #rrggbb 形式のカラーにしてください
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` は #rrggbb 形式のカラーかレイヤーカラー名にしてください
+@msg	unknown Live Paint option `{key}`	不明なライブペイントオプション `{key}`
+@msg	unknown Shape Builder option `{key}`	不明なシェイプ形成ツールオプション `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` は #rrggbb 形式のカラーにしてください
 @msg	`{key}` must be a string	`{key}` は文字列にしてください
 @msg	`{key}` must be a profile name or null	`{key}` はプロファイル名または null にしてください
@@ -4804,6 +4835,7 @@ swatch	Bright Violet	ビビッドバイオレット
 @msg	cannot read PDF: {0}	PDF を読み込めません: {0}
 @msg	invalid PDF setting: {0}	PDF の設定が正しくありません: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	アートボード {n} のページは {size} で、PDF のページ上限 14,400 pt (200 in) を超えています: UserUnit {unit} で書き出されるため、UserUnit を無視するアプリではその倍率だけ小さく表示されます
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	アートボード {n} のページは {size} で、PDF のページ上限 14,400 pt (200 in) を超えています: UserUnit {unit} で書き出されるため、UserUnit を無視するアプリではその倍率だけ小さく表示されます: 「200 in より長いページを実寸のポイントで書き出す」をオンにしてください
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	アートボード {n} のページは {size} で、PDF のページ上限 14,400 pt (200 in) を超えています: {label} のページは UserUnit なしでポイント単位で書き出され、上限を守るアプリではページが 200 in で切り取られます
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 には、14,400 pt (200 in) を超えるページがサイズを保つために必要な UserUnit がありません: ファイルは PDF 1.6 として書き出されます
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 には、14,400 pt (200 in) を超えるページが PDF/A-2 のページ上限 14,400 単位に収まるために必要な UserUnit がありません: ファイルは PDF 1.6 として書き出されます
@@ -5202,10 +5234,15 @@ swatch	Bright Violet	ビビッドバイオレット
 @msg	the print job has no data	プリントジョブにデータがありません
 @msg	there are no printer settings to open here	この環境では開けるプリンター設定がありません
 @msg	Couldn't save recovery data: {e}	復帰用データを保存できませんでした: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	{title} の復帰用データを保存できませんでした: {e}。コピーの保存先は {folder} (デフォルトの復帰用フォルダー) です。別のフォルダーを使うには、「環境設定 → ファイル管理 → データ復帰 → フォルダー」 (recoveryFolder) を設定してください
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	{title} の復帰用データを保存できませんでした: {e}。コピーの保存先は {folder} (環境設定で指定したフォルダー) です。別のフォルダーを使うには、「環境設定 → ファイル管理 → データ復帰 → フォルダー」 (recoveryFolder) を設定してください
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	復帰用データを保存できませんでした: {e}。コピーの保存先は {folder} (デフォルトの復帰用フォルダー) です。別のフォルダーを使うには、「環境設定 → ファイル管理 → データ復帰 → フォルダー」 (recoveryFolder) を設定してください
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	復帰用データを保存できませんでした: {e}。コピーの保存先は {folder} (環境設定で指定したフォルダー) です。別のフォルダーを使うには、「環境設定 → ファイル管理 → データ復帰 → フォルダー」 (recoveryFolder) を設定してください
 @msg	Saved recovery data for {title}	{title} の復帰用データを保存しました
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	復帰用データのドキュメントを {n} 件破棄しました
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	復帰用データからドキュメントを {n} 件復元しました: 残すには保存してください
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	ドキュメントを開きました (注意 {n} 件): {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}。ドキュメントを開きました (注意 {n} 件): {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	{path} を保存しましたが、注意事項が {n} 件あります: {first}
 @msg	Saving recovery data for {_1}	{_1} の復帰用データを保存中
 @msg	This shortcut file is in a form VectorCraft can't read.	このショートカットファイルは VectorCraft で読み込めない形式です。
@@ -6557,6 +6594,8 @@ anchor	Points:	ポイント:
 	Anchor Inspector	アンカーポイントインスペクター
 	Add Points at Crossings	交差点にポイントを追加
 	Split at Crossings	交差点で分割
+	Trim at Crossings Tool	交差点でトリムツール
+	Trim at Crossings	交差点でトリム
 	Extend Path	パスを延長
 	Measure & Inspect	計測・検査
 	Set Anchor	アンカーポイントを設定
@@ -7139,3 +7178,9 @@ breakText	Glyphs	字形
 	Margin	マージン
 	Box	枠
 	Swatch	スウォッチ
+	Banner Hems and Grommets…	バナーの折り返しとハトメ…
+	Banner Hems and Grommets	バナーの折り返しとハトメ
+	Hem	折り返し
+	Grommets	ハトメ
+	Grommet Inset	端からハトメまでの距離
+	Diameter	直径
diff --git a/crates/ui-egui/src/i18n/ka.tsv b/crates/ui-egui/src/i18n/ka.tsv
index 237b034f61..0778b2e405 100644
--- a/crates/ui-egui/src/i18n/ka.tsv
+++ b/crates/ui-egui/src/i18n/ka.tsv
@@ -1480,6 +1480,11 @@ digits	Malayalam	მალაიალამური
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Tate-chu-yoko პარამეტრები…
 	Tate-chu-yoko Settings	Tate-chu-yoko პარამეტრები
+	Warichu	Warichu
+	Warichu Settings…	Warichu პარამეტრები…
+	Warichu Settings	Warichu პარამეტრები
+	Lines:	სტრიქონები:
+	Line Gap:	სტრიქონებს შორის ღრეჩო:
 	Composite Fonts…	კომპოზიტური შრიფტები…
 	Composite Fonts	კომპოზიტური შრიფტები
 	Export Composite Fonts	კომპოზიტური შრიფტების ექსპორტი
@@ -2977,6 +2982,29 @@ theme	Appearance	იერსახე
 	Bristle Brush	ჯაგრის ფუნჯი
 	Pattern Brush	პატერნის ფუნჯი
 	missing from the Brushes panel	ფუნჯების პანელში არ არის
+	built in	ჩაშენებული
+	embedding not allowed	ჩაშენება არ არის დაშვებული
+	embedding for editing	ჩაშენება რედაქტირებისთვის
+	embedding for preview and print	ჩაშენება გადახედვისა და ბეჭდვისთვის
+	embedding allowed	ჩაშენება დაშვებულია
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	ჩანაცვლებულია: ნაჩვენებია შრიფტით {family} {style} ({detail})
+	missing: shown in {family} {style}	აკლია: ნაჩვენებია შრიფტით {family} {style}
+	missing	აკლია
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	წრფივი გრადიენტი
+	Radial gradient	რადიალური გრადიენტი
+	Conic gradient	კონუსური გრადიენტი
+	Diamond gradient	რომბისებრი გრადიენტი
+	Freeform gradient	თავისუფალი ფორმის გრადიენტი
+@plural	{n} instance|{n} instances	{n} ეგზემპლარი
+@plural	{n} row|{n} rows	{n} მწკრივი
+@plural	{n} column|{n} columns	{n} სვეტი
 	Select art to make a scatter, art or pattern brush.	მონიშნეთ ნახატი გაფანტვის, მხატვრული ან პატერნის ფუნჯის შესაქმნელად.
 	Brush Art	ფუნჯის ნახატი
 	New Symbol	ახალი სიმბოლო
@@ -4057,6 +4085,10 @@ font-technology	Variable	ცვლადი
 @msg	Couldn't paste: the document it was pasted in was reverted	ჩასმა ვერ მოხერხდა: დოკუმენტი, რომელშიც ის ჩაისმებოდა, წინა ვერსიაზე დაბრუნდა
 @msg	Couldn't read {name}: {e}	{name} ვერ წაიკითხა: {e}
 @msg	Couldn't save recovery data: {e}	აღდგენის მონაცემები ვერ შეინახა: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	დოკუმენტის {title} აღდგენის მონაცემები ვერ შეინახა: {e}. ასლები ინახება საქაღალდეში {folder}, რომელიც აღდგენის ნაგულისხმევი საქაღალდეა; სხვა საქაღალდის გამოსაყენებლად მიუთითეთ პარამეტრები → ფაილების დამუშავება → მონაცემთა აღდგენა → საქაღალდე (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	დოკუმენტის {title} აღდგენის მონაცემები ვერ შეინახა: {e}. ასლები ინახება საქაღალდეში {folder}, რომელიც პარამეტრებშია მითითებული; სხვა საქაღალდის გამოსაყენებლად მიუთითეთ პარამეტრები → ფაილების დამუშავება → მონაცემთა აღდგენა → საქაღალდე (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	აღდგენის მონაცემები ვერ შეინახა: {e}. ასლები ინახება საქაღალდეში {folder}, რომელიც აღდგენის ნაგულისხმევი საქაღალდეა; სხვა საქაღალდის გამოსაყენებლად მიუთითეთ პარამეტრები → ფაილების დამუშავება → მონაცემთა აღდგენა → საქაღალდე (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	აღდგენის მონაცემები ვერ შეინახა: {e}. ასლები ინახება საქაღალდეში {folder}, რომელიც პარამეტრებშია მითითებული; სხვა საქაღალდის გამოსაყენებლად მიუთითეთ პარამეტრები → ფაილების დამუშავება → მონაცემთა აღდგენა → საქაღალდე (recoveryFolder)
 @msg	Create Outlines: select text objects	კონტურების შექმნა: მონიშნეთ ტექსტური ობიექტები
 @msg	Create from Guides: the document has no artboard	დამხმარე ხაზებიდან შექმნა: დოკუმენტს სამუშაო დაფა არ აქვს
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	დამხმარე ხაზებიდან შექმნა: დამხმარე ხაზები {MAX_PIECES}-ზე მეტ ნაჭერს ქმნის
@@ -4282,6 +4314,7 @@ font-technology	Variable	ცვლადი
 @msg	internal error: {msg} (please report this bug)	შიდა შეცდომა: {msg} (გთხოვთ, შეგვატყობინოთ ამ ხარვეზის შესახებ)
 @msg	invalid PDF setting: {0}	PDF-ის არასწორი პარამეტრი: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	სამუშაო დაფა {n}-ის გვერდი არის {size}, რაც აღემატება PDF-ის გვერდის ლიმიტს 14 400 pt (200 in): ის იწერება UserUnit {unit}-ით, ამიტომ აპები, რომლებიც UserUnit-ს უგულებელყოფენ, მას ამდენჯერ პატარას აჩვენებენ
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	სამუშაო დაფა {n}-ის გვერდი არის {size}, რაც აღემატება PDF-ის გვერდის ლიმიტს 14 400 pt (200 in): ის იწერება UserUnit {unit}-ით, ამიტომ აპები, რომლებიც UserUnit-ს უგულებელყოფენ, მას ამდენჯერ პატარას აჩვენებენ: ჩართეთ „200 in-ზე გრძელი გვერდების სრული ზომით, პუნქტებში ჩაწერა“
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	სამუშაო დაფა {n}-ის გვერდი არის {size}, რაც აღემატება PDF-ის გვერდის ლიმიტს 14 400 pt (200 in): {label} გვერდები იწერება UserUnit-ის გარეშე, პუნქტებში, და აპები, რომლებიც ლიმიტს იცავენ, გვერდს 200 in-ზე ჭრიან
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5-ს არ აქვს UserUnit, რომელიც 14 400 pt-ზე (200 in) გრძელ გვერდს ზომის შესანარჩუნებლად სჭირდება: ფაილი იწერება როგორც PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4-ს არ აქვს UserUnit, რომელიც 14 400 pt-ზე (200 in) გრძელ გვერდს PDF/A-2-ის 14 400 ერთეულიანი გვერდის ზღვარში დასარჩენად სჭირდება: ფაილი იწერება როგორც PDF 1.6
@@ -4687,6 +4720,7 @@ font-technology	Variable	ცვლადი
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	უარყოფილია აღდგენილი დოკუმენტები: {n}
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	აღდგენილია დოკუმენტები: {n}: შესანარჩუნებლად შეინახეთ ისინი
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	გაიხსნა, შენიშვნები: {n}: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. გაიხსნა, შენიშვნები: {n}: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	შენახულია {path}, შენიშვნები: {n}: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	ჩაშენებულია გამოსახულებები: {n}; აკლია {missing}: ჯერ ხელახლა მიაბით
 @msgplural	Embedded {n} image|Embedded {n} images	ჩაშენებულია გამოსახულებები: {n}
@@ -6091,6 +6125,9 @@ imageTrace	Outline	კონტური
 @msg	byColor can't regroup a trace with a live Pathfinder effect: expand without byColor	byColor ვერ გადააჯგუფებს ტრასირებას აქტიური Pathfinder ეფექტით: გააფართოვეთ byColor-ის გარეშე
 @msg	`{given}` isn't a library panel (see window.swatchLibrary)	`{given}` ბიბლიოთეკის პანელი არ არის (იხ. window.swatchLibrary)
 @msg	`{key}` must be a #rrggbb color	`{key}` უნდა იყოს #rrggbb ფერი
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` უნდა იყოს #rrggbb ფერი ან ფენის ფერის სახელი
+@msg	unknown Live Paint option `{key}`	ცოცხალი შეღებვის უცნობი პარამეტრი `{key}`
+@msg	unknown Shape Builder option `{key}`	ფიგურების კონსტრუქტორის უცნობი პარამეტრი `{key}`
 @msg	a key object sits on that point	ამ წერტილზე საკვანძო ობიექტი მდებარეობს
 @msg	a linked image can't become a gradient mesh: embed it first	დაკავშირებული გამოსახულება გრადიენტულ ბადედ ვერ გადაიქცევა: ჯერ ჩააშენეთ ის
 @msg	a mask has more than one art block	ნიღაბს ერთზე მეტი ნახატის ბლოკი აქვს
@@ -6889,6 +6926,8 @@ anchor	Points:	წერტილები:
 	Anchor Inspector	საყრდენი წერტილების ინსპექტორი
 	Add Points at Crossings	წერტილების დამატება გადაკვეთებზე
 	Split at Crossings	დაყოფა გადაკვეთებზე
+	Trim at Crossings Tool	გადაკვეთებზე წაკვეთის ხელსაწყო
+	Trim at Crossings	წაკვეთა გადაკვეთებზე
 	Extend Path	ტრაექტორიის გაგრძელება
 	Measure & Inspect	გაზომვა და შემოწმება
 	Set Anchor	საყრდენი წერტილის დაყენება
@@ -7557,3 +7596,9 @@ font-script	Japanese	იაპონური
 	Margin	ზღვარი
 	Box	ჩარჩო
 	Swatch	ფერის ნიმუში
+	Banner Hems and Grommets…	ბანერის ნაკეცები და ლუვერები…
+	Banner Hems and Grommets	ბანერის ნაკეცები და ლუვერები
+	Hem	ნაკეცი
+	Grommets	ლუვერები
+	Grommet Inset	ლუვერების დაშორება კიდიდან
+	Diameter	დიამეტრი
diff --git a/crates/ui-egui/src/i18n/ko.tsv b/crates/ui-egui/src/i18n/ko.tsv
index 06e3e47e52..d0e5750000 100644
--- a/crates/ui-egui/src/i18n/ko.tsv
+++ b/crates/ui-egui/src/i18n/ko.tsv
@@ -2429,6 +2429,29 @@ antiAlias	Sharp	날카롭게
 	Bristle Brush	강모 브러시
 	Pattern Brush	패턴 브러시
 	missing from the Brushes panel	브러시 패널에 없음
+	built in	내장
+	embedding not allowed	포함 허용 안 됨
+	embedding for editing	편집용 포함
+	embedding for preview and print	미리 보기 및 인쇄용 포함
+	embedding allowed	포함 허용
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	대체됨: {family} {style}(으)로 표시({detail})
+	missing: shown in {family} {style}	없음: {family} {style}(으)로 표시
+	missing	없음
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	선형 그레이디언트
+	Radial gradient	방사형 그레이디언트
+	Conic gradient	원뿔형 그레이디언트
+	Diamond gradient	다이아몬드 그레이디언트
+	Freeform gradient	자유 형태 그레이디언트
+@plural	{n} instance|{n} instances	인스턴스 {n}개
+@plural	{n} row|{n} rows	{n}행
+@plural	{n} column|{n} columns	{n}열
 	Select art to make a scatter, art or pattern brush.	흩뿌리기, 아트 또는 패턴 브러시를 만들려면 아트웍을 선택하세요.
 	Brush Art	브러시 아트
 	New Calligraphic Brush	새 캘리그래피 브러시
@@ -4006,6 +4029,11 @@ file-filter	Templates	템플릿
 	Tate-chu-yoko	다테추요코
 	Tate-chu-yoko Settings…	다테추요코 설정…
 	Tate-chu-yoko Settings	다테추요코 설정
+	Warichu	와리추
+	Warichu Settings…	와리추 설정…
+	Warichu Settings	와리추 설정
+	Lines:	행:
+	Line Gap:	행 간격:
 	Composite Fonts…	합성 글꼴…
 	Composite Fonts	합성 글꼴
 	Export Composite Fonts	합성 글꼴 내보내기
@@ -4524,6 +4552,9 @@ theme	Appearance	외관
 @msg	installing from a path is not available on the web; pass the module as `dataBase64`	웹에서는 경로로 설치할 수 없습니다. 모듈을 `dataBase64`로 전달하세요
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}`은(는) `auto` 또는 `en`, `zh-hant` 같은 언어 코드여야 합니다
 @msg	`{key}` must be a #rrggbb color	`{key}`은(는) #rrggbb 색상이어야 합니다
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}`은(는) #rrggbb 색상이나 레이어 색상 이름이어야 합니다
+@msg	unknown Live Paint option `{key}`	알 수 없는 라이브 페인트 옵션 `{key}`
+@msg	unknown Shape Builder option `{key}`	알 수 없는 모양 빌더 옵션 `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}`은(는) #rrggbb 색상이어야 합니다
 @msg	`{key}` must be a string	`{key}`은(는) 문자열이어야 합니다
 @msg	`{key}` must be a profile name or null	`{key}`은(는) 프로파일 이름 또는 null이어야 합니다
@@ -4731,6 +4762,7 @@ theme	Appearance	외관
 @msg	cannot read PDF: {0}	PDF를 읽을 수 없습니다: {0}
 @msg	invalid PDF setting: {0}	잘못된 PDF 설정: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	아트보드 {n}의 페이지는 {size}로 PDF 페이지 한도 14,400 pt (200 in)보다 깁니다: UserUnit {unit}(으)로 기록되므로 UserUnit을 무시하는 앱에서는 그 배수만큼 작게 표시됩니다
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	아트보드 {n}의 페이지는 {size}로 PDF 페이지 한도 14,400 pt (200 in)보다 깁니다: UserUnit {unit}(으)로 기록되므로 UserUnit을 무시하는 앱에서는 그 배수만큼 작게 표시됩니다: "200 in보다 긴 페이지를 실제 크기의 포인트로 기록"을 켜세요
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	아트보드 {n}의 페이지는 {size}로 PDF 페이지 한도 14,400 pt (200 in)보다 깁니다: {label} 페이지는 UserUnit 없이 포인트 단위로 기록되며, 한도를 지키는 앱은 페이지를 200 in으로 자릅니다
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5에는 14,400 pt (200 in)보다 긴 페이지가 크기를 유지하는 데 필요한 UserUnit이 없습니다: 파일이 PDF 1.6으로 기록됩니다
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4에는 14,400 pt (200 in)보다 긴 페이지가 PDF/A-2의 페이지 한도인 14,400 단위 안에 들어가는 데 필요한 UserUnit이 없습니다: 파일이 PDF 1.6으로 기록됩니다
@@ -5129,10 +5161,15 @@ theme	Appearance	외관
 @msg	the print job has no data	인쇄 작업에 데이터가 없습니다
 @msg	there are no printer settings to open here	여기에는 열 수 있는 프린터 설정이 없습니다
 @msg	Couldn't save recovery data: {e}	복구 데이터를 저장할 수 없습니다: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	{title}의 복구 데이터를 저장할 수 없습니다: {e}. 복사본은 기본 복구 폴더인 {folder}에 저장됩니다. 다른 폴더를 사용하려면 환경 설정 → 파일 처리 → 데이터 복구 → 폴더(recoveryFolder)를 지정하세요
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	{title}의 복구 데이터를 저장할 수 없습니다: {e}. 복사본은 환경 설정에서 지정한 폴더인 {folder}에 저장됩니다. 다른 폴더를 사용하려면 환경 설정 → 파일 처리 → 데이터 복구 → 폴더(recoveryFolder)를 지정하세요
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	복구 데이터를 저장할 수 없습니다: {e}. 복사본은 기본 복구 폴더인 {folder}에 저장됩니다. 다른 폴더를 사용하려면 환경 설정 → 파일 처리 → 데이터 복구 → 폴더(recoveryFolder)를 지정하세요
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	복구 데이터를 저장할 수 없습니다: {e}. 복사본은 환경 설정에서 지정한 폴더인 {folder}에 저장됩니다. 다른 폴더를 사용하려면 환경 설정 → 파일 처리 → 데이터 복구 → 폴더(recoveryFolder)를 지정하세요
 @msg	Saved recovery data for {title}	{title}의 복구 데이터를 저장했습니다
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	복구된 문서 {n}개를 삭제했습니다
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	복구된 문서 {n}개를 복원했습니다: 보관하려면 저장하세요
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	참고 {n}건과 함께 열었습니다: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. 참고 {n}건과 함께 열었습니다: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	참고 {n}건과 함께 {path}을(를) 저장했습니다: {first}
 @msg	Saving recovery data for {_1}	{_1}의 복구 데이터를 저장하는 중
 @msg	bad shortcut	잘못된 단축키
@@ -6452,6 +6489,8 @@ anchor	Points:	포인트:
 	Anchor Inspector	앵커 포인트 검사기
 	Add Points at Crossings	교차점에 포인트 추가
 	Split at Crossings	교차점에서 분할
+	Trim at Crossings Tool	교차점에서 트림 도구
+	Trim at Crossings	교차점에서 트림
 	Extend Path	패스 연장
 	Measure & Inspect	측정 및 검사
 	Set Anchor	앵커 포인트 설정
@@ -7034,3 +7073,9 @@ breakText	Glyphs	글리프
 	Margin	여백
 	Box	상자
 	Swatch	견본
+	Banner Hems and Grommets…	배너 단 접기 및 아일렛…
+	Banner Hems and Grommets	배너 단 접기 및 아일렛
+	Hem	단 접기
+	Grommets	아일렛
+	Grommet Inset	가장자리에서 아일렛까지 거리
+	Diameter	지름
diff --git a/crates/ui-egui/src/i18n/nl.tsv b/crates/ui-egui/src/i18n/nl.tsv
index 8b91f8f3b9..0d4ceaf795 100644
--- a/crates/ui-egui/src/i18n/nl.tsv
+++ b/crates/ui-egui/src/i18n/nl.tsv
@@ -169,6 +169,7 @@
 @msg	the Simplify slider is not open	de schuifregelaar Vereenvoudigen is niet geopend
 @msg	the Smooth slider is not open	de schuifregelaar Gladmaken is niet geopend
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	de pagina van tekengebied {n} is {size}, langer dan de paginalimiet van PDF van 14.400 pt (200 in): hij wordt geschreven met een UserUnit van {unit}, dus apps die UserUnit negeren tonen hem zoveel keer kleiner
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	de pagina van tekengebied {n} is {size}, langer dan de paginalimiet van PDF van 14.400 pt (200 in): hij wordt geschreven met een UserUnit van {unit}, dus apps die UserUnit negeren tonen hem zoveel keer kleiner: schakel 'Pagina's langer dan 200 in op ware grootte in punten schrijven' in
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	de pagina van tekengebied {n} is {size}, langer dan de paginalimiet van PDF van 14.400 pt (200 in): {label}-pagina’s worden zonder UserUnit in punten geschreven, en apps die zich aan de limiet houden snijden de pagina af op 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 heeft geen UserUnit, die een pagina langer dan 14.400 pt (200 in) nodig heeft om zijn formaat te behouden: het bestand wordt geschreven als PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 heeft geen UserUnit, die een pagina langer dan 14.400 pt (200 in) nodig heeft om binnen de paginalimiet van PDF/A-2 van 14.400 eenheden te blijven: het bestand wordt geschreven als PDF 1.6
@@ -2058,6 +2059,11 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Tate-chu-yoko-instellingen…
 	Tate-chu-yoko Settings	Tate-chu-yoko-instellingen
+	Warichu	Warichu
+	Warichu Settings…	Warichu-instellingen…
+	Warichu Settings	Warichu-instellingen
+	Lines:	Regels:
+	Line Gap:	Regelafstand:
 	Composite Fonts…	Samengestelde lettertypen…
 	Composite Fonts	Samengestelde lettertypen
 	Export Composite Fonts	Samengestelde lettertypen exporteren
@@ -3650,6 +3656,29 @@ theme	Appearance	Vormgeving
 	Bristle Brush	Borstelpenseel
 	Pattern Brush	Patroonpenseel
 	missing from the Brushes panel	ontbreekt in het deelvenster Penselen
+	built in	ingebouwd
+	embedding not allowed	insluiten niet toegestaan
+	embedding for editing	insluiten voor bewerken
+	embedding for preview and print	insluiten voor voorvertoning en afdrukken
+	embedding allowed	insluiten toegestaan
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	vervangen: weergegeven in {family} {style} ({detail})
+	missing: shown in {family} {style}	ontbreekt: weergegeven in {family} {style}
+	missing	ontbreekt
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} – {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Lineair verloop
+	Radial gradient	Radiaal verloop
+	Conic gradient	Conisch verloop
+	Diamond gradient	Ruitverloop
+	Freeform gradient	Vrijvormverloop
+@plural	{n} instance|{n} instances	{n} exemplaar|{n} exemplaren
+@plural	{n} row|{n} rows	{n} rij|{n} rijen
+@plural	{n} column|{n} columns	{n} kolom|{n} kolommen
 	Select art to make a scatter, art or pattern brush.	Selecteer illustratie om een verspreidings-, art- of patroonpenseel te maken.
 	Brush Art	Penseelillustratie
 	New Symbol	Nieuw symbool
@@ -4774,6 +4803,10 @@ imageTrace	Outline	Contour
 @msg	Couldn't paste: the document it was pasted in was reverted	Kon niet plakken: het document waarin werd geplakt, is teruggezet
 @msg	Couldn't read {name}: {e}	Kon {name} niet lezen: {e}
 @msg	Couldn't save recovery data: {e}	Kon herstelgegevens niet opslaan: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kon herstelgegevens voor {title} niet opslaan: {e}. Kopieën gaan naar {folder}, de standaardherstelmap; stel voor een andere map Voorkeuren → Bestandsafhandeling → Gegevensherstel → Map (recoveryFolder) in
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kon herstelgegevens voor {title} niet opslaan: {e}. Kopieën gaan naar {folder}, de map die in Voorkeuren is ingesteld; stel voor een andere map Voorkeuren → Bestandsafhandeling → Gegevensherstel → Map (recoveryFolder) in
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kon herstelgegevens niet opslaan: {e}. Kopieën gaan naar {folder}, de standaardherstelmap; stel voor een andere map Voorkeuren → Bestandsafhandeling → Gegevensherstel → Map (recoveryFolder) in
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kon herstelgegevens niet opslaan: {e}. Kopieën gaan naar {folder}, de map die in Voorkeuren is ingesteld; stel voor een andere map Voorkeuren → Bestandsafhandeling → Gegevensherstel → Map (recoveryFolder) in
 @msg	Create Outlines: select text objects	Contouren maken: selecteer tekstobjecten
 @msg	Create from Guides: the document has no artboard	Uit hulplijnen maken: het document heeft geen tekengebied
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Uit hulplijnen maken: de hulplijnen maken meer dan {MAX_PIECES} slices
@@ -5353,6 +5386,7 @@ imageTrace	Outline	Contour
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	{n} hersteld document verworpen|{n} herstelde documenten verworpen
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	{n} hersteld document teruggezet: sla het op om het te behouden|{n} herstelde documenten teruggezet: sla ze op om ze te behouden
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Geopend met {n} opmerking: {first}|Geopend met {n} opmerkingen: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Geopend met {n} opmerking: {first}|{notice}. Geopend met {n} opmerkingen: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	{path} opgeslagen met {n} opmerking: {first}|{path} opgeslagen met {n} opmerkingen: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	{n} afbeelding ingesloten; {missing} ontbreken: koppel ze eerst opnieuw|{n} afbeeldingen ingesloten; {missing} ontbreken: koppel ze eerst opnieuw
 @msgplural	Embedded {n} image|Embedded {n} images	{n} afbeelding ingesloten|{n} afbeeldingen ingesloten
@@ -6467,6 +6501,9 @@ swatch	Bright Violet	Felviolet
 
 @msg	Save writes {_1}, not {_2}: use file.saveAsTemplate to write it	Opslaan schrijft {_1}, niet {_2}: gebruik file.saveAsTemplate om het te schrijven
 @msg	`{key}` must be a #rrggbb color	`{key}` moet een #rrggbb-kleur zijn
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` moet een #rrggbb-kleur of de naam van een laagkleur zijn
+@msg	unknown Live Paint option `{key}`	onbekende Live Paint-optie `{key}`
+@msg	unknown Shape Builder option `{key}`	onbekende Vormopbouw-optie `{key}`
 @msg	a key object sits on that point	op dat punt ligt een sleutelobject
 @msg	a linked image can't become a gradient mesh: embed it first	een gekoppelde afbeelding kan geen verloopraster worden: sluit deze eerst in
 @msg	a mask has more than one art block	een masker heeft meer dan één illustratieblok
@@ -6941,6 +6978,8 @@ anchor	Points:	Punten:
 	Anchor Inspector	Ankerpuntinspecteur
 	Add Points at Crossings	Punten toevoegen bij kruisingen
 	Split at Crossings	Splitsen bij kruisingen
+	Trim at Crossings Tool	Afsnijden bij kruisingen-gereedschap
+	Trim at Crossings	Afsnijden bij kruisingen
 	Extend Path	Pad verlengen
 	Measure & Inspect	Meten en inspecteren
 	Set Anchor	Ankerpunt instellen
@@ -7470,3 +7509,9 @@ breakText	Glyphs	Glyphs
 	Box	Kader
 	Swatch	Staal
 	Direction	Richting
+	Banner Hems and Grommets…	Bannerzomen en zeilringen…
+	Banner Hems and Grommets	Bannerzomen en zeilringen
+	Hem	Zoom
+	Grommets	Zeilringen
+	Grommet Inset	Afstand van zeilringen tot de rand
+	Diameter	Diameter
diff --git a/crates/ui-egui/src/i18n/pl.tsv b/crates/ui-egui/src/i18n/pl.tsv
index ca34501a93..7911a22071 100644
--- a/crates/ui-egui/src/i18n/pl.tsv
+++ b/crates/ui-egui/src/i18n/pl.tsv
@@ -1548,6 +1548,11 @@ digits	Malayalam	Malajalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Ustawienia Tate-chu-yoko…
 	Tate-chu-yoko Settings	Ustawienia Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Ustawienia Warichu…
+	Warichu Settings	Ustawienia Warichu
+	Lines:	Wiersze:
+	Line Gap:	Odstęp między wierszami:
 	Composite Fonts…	Fonty złożone…
 	Composite Fonts	Fonty złożone
 	Export Composite Fonts	Eksportuj fonty złożone
@@ -3280,6 +3285,29 @@ theme	Appearance	Wygląd
 	Bristle Brush	Pędzel włosiankowy
 	Pattern Brush	Pędzel wzorka
 	missing from the Brushes panel	brak w panelu Pędzle
+	built in	wbudowany
+	embedding not allowed	osadzanie niedozwolone
+	embedding for editing	osadzanie do edycji
+	embedding for preview and print	osadzanie do podglądu i drukowania
+	embedding allowed	osadzanie dozwolone
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	zastąpiony: wyświetlany krojem {family} {style} ({detail})
+	missing: shown in {family} {style}	brak: wyświetlany krojem {family} {style}
+	missing	brak
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} – {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Gradient liniowy
+	Radial gradient	Gradient promienisty
+	Conic gradient	Gradient stożkowy
+	Diamond gradient	Gradient rombowy
+	Freeform gradient	Gradient dowolny
+@plural	{n} instance|{n} instances	{n} wystąpienie|{n} wystąpienia|{n} wystąpień
+@plural	{n} row|{n} rows	{n} wiersz|{n} wiersze|{n} wierszy
+@plural	{n} column|{n} columns	{n} kolumna|{n} kolumny|{n} kolumn
 	Select art to make a scatter, art or pattern brush.	Zaznacz kompozycję, aby utworzyć pędzel rozproszony, artystyczny lub wzorka.
 	Brush Art	Kompozycja pędzla
 	New Symbol	Nowy symbol
@@ -4487,6 +4515,10 @@ imageTrace	Outline	Kontur
 @msg	Couldn't paste: the document it was pasted in was reverted	Nie udało się wkleić: dokument, do którego wklejano, został przywrócony
 @msg	Couldn't read {name}: {e}	Nie udało się odczytać {name}: {e}
 @msg	Couldn't save recovery data: {e}	Nie udało się zapisać danych odzyskiwania: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Nie udało się zapisać danych odzyskiwania dla {title}: {e}. Kopie trafiają do {folder}, domyślnego folderu odzyskiwania; aby użyć innego folderu, ustaw Preferencje → Obsługa plików → Odzyskiwanie danych → Folder (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Nie udało się zapisać danych odzyskiwania dla {title}: {e}. Kopie trafiają do {folder}, folderu ustawionego w Preferencjach; aby użyć innego folderu, ustaw Preferencje → Obsługa plików → Odzyskiwanie danych → Folder (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Nie udało się zapisać danych odzyskiwania: {e}. Kopie trafiają do {folder}, domyślnego folderu odzyskiwania; aby użyć innego folderu, ustaw Preferencje → Obsługa plików → Odzyskiwanie danych → Folder (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Nie udało się zapisać danych odzyskiwania: {e}. Kopie trafiają do {folder}, folderu ustawionego w Preferencjach; aby użyć innego folderu, ustaw Preferencje → Obsługa plików → Odzyskiwanie danych → Folder (recoveryFolder)
 @msg	Create Outlines: select text objects	Utwórz kontury: zaznacz obiekty tekstowe
 @msg	Create from Guides: the document has no artboard	Utwórz z linii pomocniczych: dokument nie ma obszaru kompozycji
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Utwórz z linii pomocniczych: linie pomocnicze tworzą więcej niż {MAX_PIECES} plasterków
@@ -4571,6 +4603,9 @@ imageTrace	Outline	Kontur
 @msg	`{keep}` is not a side of this axis	`{keep}` nie jest stroną tej osi
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` musi mieć wartość `auto` lub kod języka, np. `en` albo `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}` musi być kolorem #rrggbb
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` musi być kolorem #rrggbb lub nazwą koloru warstwy
+@msg	unknown Live Paint option `{key}`	nieznana opcja aktywnego malowania `{key}`
+@msg	unknown Shape Builder option `{key}`	nieznana opcja kreatora kształtów `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` musi być kolorem #rrggbb
 @msg	`{key}` must be a number	`{key}` musi być liczbą
 @msg	`{key}` must be a number, not {v}	`{key}` musi być liczbą, nie {v}
@@ -4730,6 +4765,7 @@ imageTrace	Outline	Kontur
 @msg	internal error: {msg} (please report this bug)	błąd wewnętrzny: {msg} (zgłoś ten błąd)
 @msg	invalid PDF setting: {0}	nieprawidłowe ustawienie PDF: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	strona obszaru kompozycji {n} ma {size}, czyli więcej niż limit strony PDF wynoszący 14 400 pt (200 in): jest zapisywana z UserUnit {unit}, więc aplikacje ignorujące UserUnit pokazują ją tyle razy mniejszą
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	strona obszaru kompozycji {n} ma {size}, czyli więcej niż limit strony PDF wynoszący 14 400 pt (200 in): jest zapisywana z UserUnit {unit}, więc aplikacje ignorujące UserUnit pokazują ją tyle razy mniejszą: włącz „Zapisuj strony dłuższe niż 200 in w pełnym rozmiarze, w punktach”
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	strona obszaru kompozycji {n} ma {size}, czyli więcej niż limit strony PDF wynoszący 14 400 pt (200 in): strony {label} są zapisywane bez UserUnit, w punktach, a aplikacje przestrzegające limitu przycinają stronę do 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 nie ma UserUnit, którego strona dłuższa niż 14 400 pt (200 in) potrzebuje, aby zachować rozmiar: plik jest zapisywany jako PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 nie ma UserUnit, którego strona dłuższa niż 14 400 pt (200 in) potrzebuje, aby zmieścić się w limicie strony PDF/A-2 wynoszącym 14 400 jednostek: plik jest zapisywany jako PDF 1.6
@@ -5172,6 +5208,7 @@ imageTrace	Outline	Kontur
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Odrzucono {n} odzyskany dokument|Odrzucono {n} odzyskane dokumenty|Odrzucono {n} odzyskanych dokumentów
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Przywrócono {n} odzyskany dokument: zapisz go, aby go zachować|Przywrócono {n} odzyskane dokumenty: zapisz je, aby je zachować|Przywrócono {n} odzyskanych dokumentów: zapisz je, aby je zachować
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Otwarto z {n} uwagą: {first}|Otwarto z {n} uwagami: {first}|Otwarto z {n} uwagami: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Otwarto z {n} uwagą: {first}|{notice}. Otwarto z {n} uwagami: {first}|{notice}. Otwarto z {n} uwagami: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	Zapisano {path} z {n} uwagą: {first}|Zapisano {path} z {n} uwagami: {first}|Zapisano {path} z {n} uwagami: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	Osadzono {n} obraz; brakuje {missing}: najpierw połącz je ponownie|Osadzono {n} obrazy; brakuje {missing}: najpierw połącz je ponownie|Osadzono {n} obrazów; brakuje {missing}: najpierw połącz je ponownie
 @msgplural	Embedded {n} image|Embedded {n} images	Osadzono {n} obraz|Osadzono {n} obrazy|Osadzono {n} obrazów
@@ -6720,6 +6757,8 @@ anchor	Points:	Punkty:
 	Anchor Inspector	Inspektor punktów kontrolnych
 	Add Points at Crossings	Dodaj punkty na skrzyżowaniach
 	Split at Crossings	Podziel na skrzyżowaniach
+	Trim at Crossings Tool	Narzędzie Przytnij na skrzyżowaniach
+	Trim at Crossings	Przytnij na skrzyżowaniach
 	Extend Path	Przedłuż ścieżkę
 	Measure & Inspect	Mierz i badaj
 	Set Anchor	Ustaw punkt kontrolny
@@ -7300,3 +7339,9 @@ breakText	Glyphs	Glify
 	Margin	Margines
 	Box	Ramka
 	Swatch	Próbka
+	Banner Hems and Grommets…	Obszycia i oczka banera…
+	Banner Hems and Grommets	Obszycia i oczka banera
+	Hem	Obszycie
+	Grommets	Oczka
+	Grommet Inset	Odległość oczek od krawędzi
+	Diameter	Średnica
diff --git a/crates/ui-egui/src/i18n/pt-br.tsv b/crates/ui-egui/src/i18n/pt-br.tsv
index 6006f84c90..c2349359ed 100644
--- a/crates/ui-egui/src/i18n/pt-br.tsv
+++ b/crates/ui-egui/src/i18n/pt-br.tsv
@@ -1801,6 +1801,29 @@ antiAlias	Sharp	Nítido
 	Bristle Brush	Pincel de Cerdas
 	Pattern Brush	Pincel de Padrão
 	missing from the Brushes panel	ausente do painel Pincéis
+	built in	integrada
+	embedding not allowed	incorporação não permitida
+	embedding for editing	incorporação para edição
+	embedding for preview and print	incorporação para visualização e impressão
+	embedding allowed	incorporação permitida
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	substituída: exibida em {family} {style} ({detail})
+	missing: shown in {family} {style}	ausente: exibida em {family} {style}
+	missing	ausente
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppp
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Gradiente linear
+	Radial gradient	Gradiente radial
+	Conic gradient	Gradiente cônico
+	Diamond gradient	Gradiente losango
+	Freeform gradient	Gradiente de forma livre
+@plural	{n} instance|{n} instances	{n} instância|{n} instâncias
+@plural	{n} row|{n} rows	{n} linha|{n} linhas
+@plural	{n} column|{n} columns	{n} coluna|{n} colunas
 	Select art to make a scatter, art or pattern brush.	Selecione arte para criar um pincel de dispersão, de arte ou de padrão.
 	Brush Art	Arte do Pincel
 	New Calligraphic Brush	Novo Pincel Caligráfico
@@ -3822,6 +3845,10 @@ axis	Both	Ambos
 @msg	Couldn't paste: the document it was pasted in was reverted	Não foi possível colar: o documento em que estava sendo colado foi revertido
 @msg	Couldn't read {name}: {e}	Não foi possível ler {name}: {e}
 @msg	Couldn't save recovery data: {e}	Não foi possível salvar os dados de recuperação: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Não foi possível salvar os dados de recuperação de {title}: {e}. As cópias vão para {folder}, a pasta de recuperação padrão; para usar outra pasta, defina Preferências → Manipulação de arquivos → Recuperação de dados → Pasta (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Não foi possível salvar os dados de recuperação de {title}: {e}. As cópias vão para {folder}, a pasta definida em Preferências; para usar outra pasta, defina Preferências → Manipulação de arquivos → Recuperação de dados → Pasta (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Não foi possível salvar os dados de recuperação: {e}. As cópias vão para {folder}, a pasta de recuperação padrão; para usar outra pasta, defina Preferências → Manipulação de arquivos → Recuperação de dados → Pasta (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Não foi possível salvar os dados de recuperação: {e}. As cópias vão para {folder}, a pasta definida em Preferências; para usar outra pasta, defina Preferências → Manipulação de arquivos → Recuperação de dados → Pasta (recoveryFolder)
 @msg	Create Outlines: select text objects	Criar contornos: selecione objetos de texto
 @msg	Create from Guides: the document has no artboard	Criar a partir de guias: o documento não tem prancheta
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Criar a partir de guias: as guias formam mais de {MAX_PIECES} fatias
@@ -3906,6 +3933,9 @@ axis	Both	Ambos
 @msg	`{keep}` is not a side of this axis	`{keep}` não é um lado deste eixo
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` deve ser `auto` ou um código de idioma como `en` ou `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}` deve ser uma cor #rrggbb
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` deve ser uma cor #rrggbb ou o nome de uma cor de camada
+@msg	unknown Live Paint option `{key}`	opção de Pintura ao Vivo desconhecida `{key}`
+@msg	unknown Shape Builder option `{key}`	opção do Construtor de Formas desconhecida `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` deve ser uma cor #rrggbb
 @msg	`{key}` must be a number	`{key}` deve ser um número
 @msg	`{key}` must be a number, not {v}	`{key}` deve ser um número, não {v}
@@ -4055,6 +4085,7 @@ axis	Both	Ambos
 @msg	internal error: {msg} (please report this bug)	erro interno: {msg} (relate este bug)
 @msg	invalid PDF setting: {0}	configuração de PDF inválida: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	a página da prancheta {n} tem {size}, mais que o limite de página do PDF de 14.400 pt (200 in): ela é gravada com um UserUnit de {unit}, então apps que ignoram UserUnit a mostram essa quantidade de vezes menor
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	a página da prancheta {n} tem {size}, mais que o limite de página do PDF de 14.400 pt (200 in): ela é gravada com um UserUnit de {unit}, então apps que ignoram UserUnit a mostram essa quantidade de vezes menor: ative "Gravar páginas com mais de 200 in em tamanho real, em pontos"
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	a página da prancheta {n} tem {size}, mais que o limite de página do PDF de 14.400 pt (200 in): páginas {label} são gravadas sem UserUnit, em pontos, e apps que respeitam o limite cortam a página em 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	o PDF 1.5 não tem UserUnit, de que uma página com mais de 14.400 pt (200 in) precisa para manter seu tamanho: o arquivo é gravado como PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	o PDF 1.4 não tem UserUnit, de que uma página com mais de 14.400 pt (200 in) precisa para ficar dentro do limite de página do PDF/A-2, de 14.400 unidades: o arquivo é gravado como PDF 1.6
@@ -4492,6 +4523,7 @@ axis	Both	Ambos
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	{n} documento recuperado descartado|{n} documentos recuperados descartados
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	{n} documento recuperado restaurado: salve-o para mantê-lo|{n} documentos recuperados restaurados: salve-os para mantê-los
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Aberto com {n} observação: {first}|Aberto com {n} observações: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Aberto com {n} observação: {first}|{notice}. Aberto com {n} observações: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	{path} salvo com {n} observação: {first}|{path} salvo com {n} observações: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	{n} imagem incorporada; faltam {missing}: revincule-as primeiro|{n} imagens incorporadas; faltam {missing}: revincule-as primeiro
 @msgplural	Embedded {n} image|Embedded {n} images	{n} imagem incorporada|{n} imagens incorporadas
@@ -5191,6 +5223,11 @@ axis	Both	Ambos
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Configurações de Tate-chu-yoko…
 	Tate-chu-yoko Settings	Configurações de Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Configurações de Warichu…
+	Warichu Settings	Configurações de Warichu
+	Lines:	Linhas:
+	Line Gap:	Distância entre linhas:
 	Composite Fonts…	Fontes compostas…
 	Composite Fonts	Fontes compostas
 	Export Composite Fonts	Exportar fontes compostas
@@ -6780,6 +6817,8 @@ anchor	Points:	Pontos:
 	Anchor Inspector	Inspetor de Pontos de Ancoragem
 	Add Points at Crossings	Adicionar Pontos nos Cruzamentos
 	Split at Crossings	Dividir nos Cruzamentos
+	Trim at Crossings Tool	Ferramenta Aparar nos Cruzamentos
+	Trim at Crossings	Aparar nos Cruzamentos
 	Extend Path	Estender Caminho
 	Measure & Inspect	Medir e Inspecionar
 	Set Anchor	Definir Ponto de Ancoragem
@@ -7516,3 +7555,9 @@ swatch	Yellow Green	Verde-amarelado
 	Margin	Margem
 	Box	Caixa
 	Swatch	Amostra
+	Banner Hems and Grommets…	Bainhas e ilhoses de banner…
+	Banner Hems and Grommets	Bainhas e ilhoses de banner
+	Hem	Bainha
+	Grommets	Ilhoses
+	Grommet Inset	Distância dos ilhoses à borda
+	Diameter	Diâmetro
diff --git a/crates/ui-egui/src/i18n/ru.tsv b/crates/ui-egui/src/i18n/ru.tsv
index fd09504b42..f878461da5 100644
--- a/crates/ui-egui/src/i18n/ru.tsv
+++ b/crates/ui-egui/src/i18n/ru.tsv
@@ -2217,6 +2217,29 @@ file-filter	Templates	Шаблоны
 	Bristle Brush	Щетинная кисть
 	Pattern Brush	Узорная кисть
 	missing from the Brushes panel	отсутствует в панели «Кисти»
+	built in	встроенный
+	embedding not allowed	внедрение запрещено
+	embedding for editing	внедрение для редактирования
+	embedding for preview and print	внедрение для просмотра и печати
+	embedding allowed	внедрение разрешено
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	заменен: показан шрифтом {family} {style} ({detail})
+	missing: shown in {family} {style}	отсутствует: показан шрифтом {family} {style}
+	missing	отсутствует
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Линейный градиент
+	Radial gradient	Радиальный градиент
+	Conic gradient	Конический градиент
+	Diamond gradient	Ромбовидный градиент
+	Freeform gradient	Произвольный градиент
+@plural	{n} instance|{n} instances	{n} экземпляр|{n} экземпляра|{n} экземпляров
+@plural	{n} row|{n} rows	{n} строка|{n} строки|{n} строк
+@plural	{n} column|{n} columns	{n} столбец|{n} столбца|{n} столбцов
 	Select art to make a scatter, art or pattern brush.	Выделите рисунок, чтобы создать кисть-распыление, художественную или узорную кисть.
 	Brush Art	Рисунок кисти
 	New Calligraphic Brush	Новая каллиграфическая кисть
@@ -3675,6 +3698,11 @@ digits	Malayalam	Малаялам
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Параметры Tate-chu-yoko…
 	Tate-chu-yoko Settings	Параметры Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Параметры Warichu…
+	Warichu Settings	Параметры Warichu
+	Lines:	Строки:
+	Line Gap:	Интервал между строками:
 	Composite Fonts…	Составные шрифты…
 	Composite Fonts	Составные шрифты
 	Export Composite Fonts	Экспорт составных шрифтов
@@ -4390,6 +4418,10 @@ axis	Both	Оба
 @msg	Couldn't paste: the document it was pasted in was reverted	Не удалось вставить: документ, в который выполнялась вставка, был возвращён к сохранённой версии
 @msg	Couldn't read {name}: {e}	Не удалось прочитать {name}: {e}
 @msg	Couldn't save recovery data: {e}	Не удалось сохранить данные восстановления: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Не удалось сохранить данные восстановления для {title}: {e}. Копии сохраняются в {folder}, папку восстановления по умолчанию; чтобы использовать другую папку, задайте Настройки → Работа с файлами → Восстановление данных → Папка (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Не удалось сохранить данные восстановления для {title}: {e}. Копии сохраняются в {folder}, папку, заданную в настройках; чтобы использовать другую папку, задайте Настройки → Работа с файлами → Восстановление данных → Папка (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Не удалось сохранить данные восстановления: {e}. Копии сохраняются в {folder}, папку восстановления по умолчанию; чтобы использовать другую папку, задайте Настройки → Работа с файлами → Восстановление данных → Папка (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Не удалось сохранить данные восстановления: {e}. Копии сохраняются в {folder}, папку, заданную в настройках; чтобы использовать другую папку, задайте Настройки → Работа с файлами → Восстановление данных → Папка (recoveryFolder)
 @msg	Create Outlines: select text objects	Создание контуров: выделите текстовые объекты
 @msg	Create from Guides: the document has no artboard	Создание из направляющих: в документе нет монтажной области
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Создание из направляющих: направляющие образуют более {MAX_PIECES} фрагментов
@@ -4475,6 +4507,9 @@ axis	Both	Оба
 @msg	`{keep}` is not a side of this axis	`{keep}` не является стороной этой оси
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` должно быть `auto` или кодом языка, например `en` или `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}` должно быть цветом #rrggbb
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` должно быть цветом #rrggbb или названием цвета слоя
+@msg	unknown Live Paint option `{key}`	неизвестный параметр быстрой заливки `{key}`
+@msg	unknown Shape Builder option `{key}`	неизвестный параметр создания фигур `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` должно быть цветом #rrggbb
 @msg	`{key}` must be a number	`{key}` должно быть числом
 @msg	`{key}` must be a number, not {v}	`{key}` должно быть числом, а не {v}
@@ -4634,6 +4669,7 @@ axis	Both	Оба
 @msg	internal error: {msg} (please report this bug)	внутренняя ошибка: {msg} (пожалуйста, сообщите об этой ошибке)
 @msg	invalid PDF setting: {0}	недопустимый параметр PDF: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	страница монтажной области {n} имеет размер {size}, что больше ограничения PDF на размер страницы в 14 400 pt (200 in): она записывается с UserUnit {unit}, поэтому приложения, которые игнорируют UserUnit, показывают её во столько же раз меньше
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	страница монтажной области {n} имеет размер {size}, что больше ограничения PDF на размер страницы в 14 400 pt (200 in): она записывается с UserUnit {unit}, поэтому приложения, которые игнорируют UserUnit, показывают её во столько же раз меньше: включите «Записывать страницы длиннее 200 in в полном размере, в пунктах»
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	страница монтажной области {n} имеет размер {size}, что больше ограничения PDF на размер страницы в 14 400 pt (200 in): страницы {label} записываются без UserUnit, в пунктах, и приложения, соблюдающие ограничение, обрезают страницу до 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	в PDF 1.5 нет UserUnit, который нужен странице длиннее 14 400 pt (200 in), чтобы сохранить размер: файл записывается как PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	в PDF 1.4 нет UserUnit, который нужен странице длиннее 14 400 pt (200 in), чтобы уложиться в предел страницы PDF/A-2 в 14 400 единиц: файл записывается как PDF 1.6
@@ -5074,6 +5110,7 @@ axis	Both	Оба
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Отменён {n} восстановленный документ|Отменено {n} восстановленных документа|Отменено {n} восстановленных документов
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Восстановлен {n} документ: сохраните его, чтобы оставить|Восстановлено {n} документа: сохраните их, чтобы оставить|Восстановлено {n} документов: сохраните их, чтобы оставить
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Открыто с {n} примечанием: {first}|Открыто с {n} примечаниями: {first}|Открыто с {n} примечаниями: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Открыто с {n} примечанием: {first}|{notice}. Открыто с {n} примечаниями: {first}|{notice}. Открыто с {n} примечаниями: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	Сохранено: {path} с {n} примечанием: {first}|Сохранено: {path} с {n} примечаниями: {first}|Сохранено: {path} с {n} примечаниями: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	Внедрено {n} изображение; отсутствует {missing}: сначала восстановите связи|Внедрено {n} изображения; отсутствует {missing}: сначала восстановите связи|Внедрено {n} изображений; отсутствует {missing}: сначала восстановите связи
 @msgplural	Embedded {n} image|Embedded {n} images	Внедрено {n} изображение|Внедрено {n} изображения|Внедрено {n} изображений
@@ -6842,6 +6879,8 @@ anchor	Points:	Точки:
 	Anchor Inspector	Инспектор опорных точек
 	Add Points at Crossings	Добавить точки на пересечениях
 	Split at Crossings	Разрезать на пересечениях
+	Trim at Crossings Tool	Инструмент «Подрезка на пересечениях»
+	Trim at Crossings	Подрезать на пересечениях
 	Extend Path	Продлить контур
 	Measure & Inspect	Измерение и анализ
 	Set Anchor	Задать опорную точку
@@ -7532,3 +7571,9 @@ shape	Open	Открытый
 	Margin	Поле
 	Box	Рамка
 	Swatch	Образец
+	Banner Hems and Grommets…	Подгибы и люверсы баннера…
+	Banner Hems and Grommets	Подгибы и люверсы баннера
+	Hem	Подгиб
+	Grommets	Люверсы
+	Grommet Inset	Отступ люверсов от края
+	Diameter	Диаметр
diff --git a/crates/ui-egui/src/i18n/sv.tsv b/crates/ui-egui/src/i18n/sv.tsv
index 4e7b7508ae..70efcf795f 100644
--- a/crates/ui-egui/src/i18n/sv.tsv
+++ b/crates/ui-egui/src/i18n/sv.tsv
@@ -2131,6 +2131,29 @@ font-technology	Variable	Variabla
 	Bristle Brush	Borstpensel
 	Pattern Brush	Mönsterpensel
 	missing from the Brushes panel	saknas i panelen Penslar
+	built in	inbyggt
+	embedding not allowed	inbäddning inte tillåten
+	embedding for editing	inbäddning för redigering
+	embedding for preview and print	inbäddning för förhandsvisning och utskrift
+	embedding allowed	inbäddning tillåten
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	ersatt: visas med {family} {style} ({detail})
+	missing: shown in {family} {style}	saknas: visas med {family} {style}
+	missing	saknas
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} – {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Linjär gradient
+	Radial gradient	Radiell gradient
+	Conic gradient	Konisk gradient
+	Diamond gradient	Rombgradient
+	Freeform gradient	Fri gradient
+@plural	{n} instance|{n} instances	{n} instans|{n} instanser
+@plural	{n} row|{n} rows	{n} rad|{n} rader
+@plural	{n} column|{n} columns	{n} kolumn|{n} kolumner
 	Select art to make a scatter, art or pattern brush.	Markera grafik för att skapa en spridnings-, konst- eller mönsterpensel.
 	Brush Art	Penselgrafik
 	New Calligraphic Brush	Ny kalligrafisk pensel
@@ -3565,6 +3588,11 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Inställningar för Tate-chu-yoko…
 	Tate-chu-yoko Settings	Inställningar för Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Inställningar för Warichu…
+	Warichu Settings	Inställningar för Warichu
+	Lines:	Rader:
+	Line Gap:	Radavstånd:
 	Composite Fonts…	Sammansatta typsnitt…
 	Composite Fonts	Sammansatta typsnitt
 	Export Composite Fonts	Exportera sammansatta typsnitt
@@ -4263,6 +4291,10 @@ axis	Both	Båda
 @msg	Couldn't paste: the document it was pasted in was reverted	Kunde inte klistra in: dokumentet det klistrades in i har återgått till sparad version
 @msg	Couldn't read {name}: {e}	Kunde inte läsa {name}: {e}
 @msg	Couldn't save recovery data: {e}	Kunde inte spara återställningsdata: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kunde inte spara återställningsdata för {title}: {e}. Kopiorna sparas i {folder}, standardmappen för återställning; om du vill använda en annan mapp anger du Inställningar → Filhantering → Dataåterställning → Mapp (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kunde inte spara återställningsdata för {title}: {e}. Kopiorna sparas i {folder}, mappen som angetts i Inställningar; om du vill använda en annan mapp anger du Inställningar → Filhantering → Dataåterställning → Mapp (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kunde inte spara återställningsdata: {e}. Kopiorna sparas i {folder}, standardmappen för återställning; om du vill använda en annan mapp anger du Inställningar → Filhantering → Dataåterställning → Mapp (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kunde inte spara återställningsdata: {e}. Kopiorna sparas i {folder}, mappen som angetts i Inställningar; om du vill använda en annan mapp anger du Inställningar → Filhantering → Dataåterställning → Mapp (recoveryFolder)
 @msg	Create Outlines: select text objects	Skapa konturer: markera textobjekt
 @msg	Create from Guides: the document has no artboard	Skapa från stödlinjer: dokumentet har ingen rityta
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Skapa från stödlinjer: stödlinjerna ger fler än {MAX_PIECES} skivor
@@ -4348,6 +4380,9 @@ axis	Both	Båda
 @msg	`{keep}` is not a side of this axis	`{keep}` är inte en sida av den här axeln
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` måste vara `auto` eller en språkkod som `en` eller `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}` måste vara en färg i formatet #rrggbb
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` måste vara en färg i formatet #rrggbb eller namnet på en lagerfärg
+@msg	unknown Live Paint option `{key}`	okänt alternativ för direktmålning `{key}`
+@msg	unknown Shape Builder option `{key}`	okänt alternativ för formbyggaren `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` måste vara en färg i formatet #rrggbb
 @msg	`{key}` must be a number	`{key}` måste vara ett tal
 @msg	`{key}` must be a number, not {v}	`{key}` måste vara ett tal, inte {v}
@@ -4498,6 +4533,7 @@ axis	Both	Båda
 @msg	internal error: {msg} (please report this bug)	internt fel: {msg} (rapportera gärna felet)
 @msg	invalid PDF setting: {0}	ogiltig PDF-inställning: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	sidan för rityta {n} är {size}, längre än PDF:s sidgräns på 14 400 pt (200 in): den skrivs med en UserUnit på {unit}, så appar som ignorerar UserUnit visar den så många gånger mindre
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	sidan för rityta {n} är {size}, längre än PDF:s sidgräns på 14 400 pt (200 in): den skrivs med en UserUnit på {unit}, så appar som ignorerar UserUnit visar den så många gånger mindre: slå på ”Skriv sidor längre än 200 in i full storlek i punkter”
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	sidan för rityta {n} är {size}, längre än PDF:s sidgräns på 14 400 pt (200 in): {label}-sidor skrivs utan UserUnit, i punkter, och appar som håller sig till gränsen beskär sidan till 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 har ingen UserUnit, som en sida längre än 14 400 pt (200 in) behöver för att behålla sin storlek: filen skrivs som PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 har ingen UserUnit, som en sida längre än 14 400 pt (200 in) behöver för att hålla sig inom PDF/A-2:s sidgräns på 14 400 enheter: filen skrivs som PDF 1.6
@@ -4931,6 +4967,7 @@ axis	Both	Båda
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Kastade {n} återställt dokument|Kastade {n} återställda dokument
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Återställde {n} återskapat dokument: spara det för att behålla det|Återställde {n} återskapade dokument: spara dem för att behålla dem
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Öppnad med {n} anteckning: {first}|Öppnad med {n} anteckningar: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Öppnad med {n} anteckning: {first}|{notice}. Öppnad med {n} anteckningar: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	Sparade {path} med {n} anteckning: {first}|Sparade {path} med {n} anteckningar: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	Bäddade in {n} bild; {missing} saknas: länka om dem först|Bäddade in {n} bilder; {missing} saknas: länka om dem först
 @msgplural	Embedded {n} image|Embedded {n} images	Bäddade in {n} bild|Bäddade in {n} bilder
@@ -6846,6 +6883,8 @@ anchor	Points:	Punkter:
 	Anchor Inspector	Ankarpunktsgranskare
 	Add Points at Crossings	Lägg till punkter vid korsningar
 	Split at Crossings	Dela vid korsningar
+	Trim at Crossings Tool	Trimma vid korsningar-verktyget
+	Trim at Crossings	Trimma vid korsningar
 	Extend Path	Förläng bana
 	Measure & Inspect	Mät och granska
 	Set Anchor	Ange ankarpunkt
@@ -8919,3 +8958,9 @@ digits	Hindi	Hindi
 	Stroke Weight Up	Öka konturtjocklek
 	The selected objects have different graphics.	De markerade objekten har olika grafik.
 	Word Gap	Ordmellanrum
+	Banner Hems and Grommets…	Bannerfållar och öljetter…
+	Banner Hems and Grommets	Bannerfållar och öljetter
+	Hem	Fåll
+	Grommets	Öljetter
+	Grommet Inset	Öljetternas avstånd från kanten
+	Diameter	Diameter
diff --git a/crates/ui-egui/src/i18n/tests.rs b/crates/ui-egui/src/i18n/tests.rs
index 54b967701d..6c9deb97d0 100644
--- a/crates/ui-egui/src/i18n/tests.rs
+++ b/crates/ui-egui/src/i18n/tests.rs
@@ -113,6 +113,59 @@ fn hindi_rows_keep_the_meaning_of_their_english() {
     assert!(all.contains("3 आर्टबोर्ड में से 1") && all.contains("सभी आर्टबोर्ड रखने के लिए"), "{all}");
     let left_out = message(hi, "the file was read up to an error (bad xref): what follows it was left out");
     assert!(left_out.contains("उसके बाद का हिस्सा छोड़ दिया गया"), "{left_out}");
+    assert_eq!(message(hi, "unknown align `left`"), "अज्ञात संरेखण `left`");
+    assert_eq!(tr(hi, "Delete Library Group"), "लाइब्रेरी ग्रुप हटाएँ");
+    assert_eq!(message(hi, "not editing an opacity mask"), "ओपेसिटी मास्क संपादित नहीं किया जा रहा है");
+    assert_eq!(
+        message(hi, "a page thumbnail must be RGB pixels, 1 to 256 a side (got 0 × 4)"),
+        "पेज थंबनेल RGB पिक्सल का होना चाहिए, हर तरफ़ 1 से 256 (मिला 0 × 4)"
+    );
+    assert_eq!(message(hi, "invalid angle"), "अमान्य कोण");
+}
+
+/// Hindi messages keep every `a|b|c` list of accepted values exactly as their English writes it.
+#[test]
+fn hindi_messages_keep_their_lists_of_accepted_values() {
+    let hi = Lang::from_code("hi").expect("hi registered");
+    let (entries, _) = parse_entries(hi.0.source);
+    let mut wrong = Vec::new();
+    for (_, src, translation) in entries.iter().filter(|(ctx, _, _)| ctx == "@msg") {
+        let lists = src.split(|c: char| !(c.is_ascii_alphabetic() || c == '|')).filter(|w| w.contains('|') && w.split('|').all(|v| !v.is_empty()));
+        for list in lists.filter(|list| !translation.contains(*list)) {
+            wrong.push(format!("{list} in {src:?} -> {translation:?}"));
+        }
+    }
+    assert!(wrong.is_empty(), "{} Hindi messages change a list of values:\n{}", wrong.len(), wrong.join("\n"));
+}
+
+/// Hindi rows leave no English connecting word in their sentences. Text in backticks, quotes,
+/// braces and brackets is a name, value or placeholder and keeps its English.
+#[test]
+fn hindi_rows_keep_no_english_words_in_their_sentences() {
+    const ENGLISH: [&str; 13] = ["or", "and", "the", "must", "give", "see", "use", "most", "is", "of", "be", "not", "an"];
+    let hi = Lang::from_code("hi").expect("hi registered");
+    let (entries, _) = parse_entries(hi.0.source);
+    let mut wrong = Vec::new();
+    for (_, src, translation) in &entries {
+        let mut prose = String::new();
+        let mut close = None;
+        for c in translation.chars() {
+            match (close, c) {
+                (Some(end), _) if c == end => close = None,
+                (Some(_), _) => {}
+                (None, '`') => close = Some('`'),
+                (None, '"') => close = Some('"'),
+                (None, '“') => close = Some('”'),
+                (None, '{') => close = Some('}'),
+                (None, '[') => close = Some(']'),
+                (None, _) => prose.push(c),
+            }
+        }
+        if let Some(word) = prose.split(|c: char| !c.is_ascii_alphabetic()).find(|w| ENGLISH.contains(w)) {
+            wrong.push(format!("{word} in {src:?} -> {translation:?}"));
+        }
+    }
+    assert!(wrong.is_empty(), "{} Hindi rows keep an English word:\n{}", wrong.len(), wrong.join("\n"));
 }
 
 /// Locale tags name their language by region or script (in either case, with an encoding or
@@ -410,6 +463,46 @@ fn document_info_labels_are_in_complete_catalogs() {
     }
 }
 
+/// The values Document Info makes and shows in the interface language: the font states and
+/// embedding permissions, the templates of the font, image, raster effects and Repeat object
+/// values, the names of gradients named by their kind, and the counted instances, rows and columns.
+#[test]
+fn document_info_values_are_in_complete_catalogs() {
+    const VALUES: [&str; 20] = [
+        "built in",
+        "embedding not allowed",
+        "embedding for editing",
+        "embedding for preview and print",
+        "embedding allowed",
+        "{file}; {embedding}",
+        "substituted: shown in {family} {style} ({detail})",
+        "missing: shown in {family} {style}",
+        "missing",
+        "{width} × {height} px",
+        "{size} — {file}",
+        "{n} ppi",
+        "{kind}, {instances}",
+        "{kind}, {rows} × {cols}",
+        "{grid}, {instances}",
+        "Linear gradient",
+        "Radial gradient",
+        "Conic gradient",
+        "Diamond gradient",
+        "Freeform gradient",
+    ];
+    const COUNTED: [(&str, &str); 3] = [("{n} instance", "{n} instances"), ("{n} row", "{n} rows"), ("{n} column", "{n} columns")];
+    let gradient_kinds: Vec<String> = vectorcraft_color::GradientKind::ALL.iter().map(|k| format!("{} gradient", k.label())).collect();
+    assert!(gradient_kinds.iter().all(|k| VALUES.contains(&k.as_str())), "{gradient_kinds:?}");
+    for lang in LANGUAGES.iter().filter(|lang| lang.complete_menus) {
+        for value in VALUES {
+            assert!(lang.catalog().plain(value).is_some(), "{} is missing {value}", lang.code);
+        }
+        for (one, other) in COUNTED {
+            assert!(lang.catalog().plural(one, other, 0).is_some(), "{} is missing the row for {other}", lang.code);
+        }
+    }
+}
+
 /// The Character panel's Anti-aliasing Method label and its choices, with the Sharp method's
 /// own `antiAlias` row apart from the plain "Sharp" corner row.
 #[test]
@@ -2343,6 +2436,10 @@ const OPEN_SAVE_COUNTED_MESSAGES: &[(&str, &str)] = &[
     ("Saved /out/a.pdf with 1 note: a note", "Saved /out/a.pdf with 2 notes: a note"),
     ("Discarded 1 recovered document", "Discarded 2 recovered documents"),
     ("Restored 1 recovered document: save it to keep it", "Restored 2 recovered documents: save them to keep them"),
+    (
+        "1 linked image changed on disk: Update Links shows the new version. Opened with 1 note: a note",
+        "1 linked image changed on disk: Update Links shows the new version. Opened with 2 notes: a note",
+    ),
 ];
 
 /// The open, save and recovery status messages and the Global Edit options' Results line name a
@@ -2350,15 +2447,18 @@ const OPEN_SAVE_COUNTED_MESSAGES: &[(&str, &str)] = &[
 /// translates both, in the form its plural rule picks.
 #[test]
 fn open_save_and_recovery_messages_take_the_plural_form() {
-    use crate::io::{opened_with_notes, saved_status};
+    use crate::dialogs::missing_links::changed_on_disk_status;
+    use crate::io::{opened_after_notice, opened_with_notes, saved_status};
     use crate::panels::properties::global_edit_results;
     use crate::recovery::recovered_status;
     let saved = |path: &str, n: usize| saved_status(path, &serde_json::json!({ "warnings": vec!["a note"; n] }));
+    let notice = changed_on_disk_status(1);
     let made = [
         (opened_with_notes(1, "a note"), opened_with_notes(2, "a note")),
         (saved("/out/a.pdf", 1), saved("/out/a.pdf", 2)),
         (recovered_status(true, 1), recovered_status(true, 2)),
         (recovered_status(false, 1), recovered_status(false, 2)),
+        (opened_after_notice(&notice, 1, "a note"), opened_after_notice(&notice, 2, "a note")),
     ];
     for ((one, other), (want_one, want_other)) in made.iter().zip(OPEN_SAVE_COUNTED_MESSAGES) {
         assert_eq!((one.as_str(), other.as_str()), (*want_one, *want_other));
@@ -2370,7 +2470,18 @@ fn open_save_and_recovery_messages_take_the_plural_form() {
         for s in OPEN_SAVE_COUNTED_MESSAGES.iter().flat_map(|(one, other)| [one, other]) {
             assert_ne!(message(lang, s), *s, "{code}: {s}");
         }
+        // The line about linked files and the open's line are each shown as the catalog has them.
+        for n in [1, 2] {
+            let shown = message(lang, &opened_after_notice(&notice, n, "a note"));
+            let (link, open) = (message(lang, &notice), message(lang, &opened_with_notes(n, "a note")));
+            assert!(link != notice && shown.starts_with(&link) && shown.ends_with(&open), "{code}: {shown}");
+        }
     }
+    let unreadable = "2 linked files can't be read here: their previews show";
+    assert_eq!(
+        message(de(), &opened_after_notice(unreadable, 3, "a note")),
+        format!("{}. Mit 3 Hinweisen geöffnet: a note", message(de(), unreadable))
+    );
     for l in LANGUAGES.iter().filter(|l| l.complete_menus) {
         let lang = Lang::from_code(l.code).expect("registered");
         for n in [1, 2] {
diff --git a/crates/ui-egui/src/i18n/tr.tsv b/crates/ui-egui/src/i18n/tr.tsv
index ac23f62c74..ff88601736 100644
--- a/crates/ui-egui/src/i18n/tr.tsv
+++ b/crates/ui-egui/src/i18n/tr.tsv
@@ -3452,6 +3452,11 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Tate-chu-yoko Ayarları…
 	Tate-chu-yoko Settings	Tate-chu-yoko Ayarları
+	Warichu	Warichu
+	Warichu Settings…	Warichu Ayarları…
+	Warichu Settings	Warichu Ayarları
+	Lines:	Satırlar:
+	Line Gap:	Satır Aralığı:
 	Composite Fonts…	Bileşik Fontlar…
 	Composite Fonts	Bileşik Fontlar
 	Export Composite Fonts	Bileşik Fontları Dışa Aktar
@@ -4141,6 +4146,10 @@ axis	Both	Her İkisi
 @msg	Couldn't paste: the document it was pasted in was reverted	Yapıştırılamadı: yapıştırıldığı belge geri döndürüldü
 @msg	Couldn't read {name}: {e}	{name} okunamadı: {e}
 @msg	Couldn't save recovery data: {e}	Kurtarma verileri kaydedilemedi: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	{title} için kurtarma verileri kaydedilemedi: {e}. Kopyalar varsayılan kurtarma klasörüne, {folder} konumuna kaydedilir; başka bir klasör kullanmak için Tercihler → Dosya İşleme → Veri Kurtarma → Klasör (recoveryFolder) ayarını yapın
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	{title} için kurtarma verileri kaydedilemedi: {e}. Kopyalar Tercihler'de ayarlanan klasöre, {folder} konumuna kaydedilir; başka bir klasör kullanmak için Tercihler → Dosya İşleme → Veri Kurtarma → Klasör (recoveryFolder) ayarını yapın
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kurtarma verileri kaydedilemedi: {e}. Kopyalar varsayılan kurtarma klasörüne, {folder} konumuna kaydedilir; başka bir klasör kullanmak için Tercihler → Dosya İşleme → Veri Kurtarma → Klasör (recoveryFolder) ayarını yapın
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Kurtarma verileri kaydedilemedi: {e}. Kopyalar Tercihler'de ayarlanan klasöre, {folder} konumuna kaydedilir; başka bir klasör kullanmak için Tercihler → Dosya İşleme → Veri Kurtarma → Klasör (recoveryFolder) ayarını yapın
 @msg	Create Outlines: select text objects	Anahatlar Oluştur: metin nesnelerini seçin
 @msg	Create from Guides: the document has no artboard	Kılavuzlardan Oluştur: belgede çalışma yüzeyi yok
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Kılavuzlardan Oluşturun: kılavuzlar {MAX_PIECES} dilimlerinden daha fazlasını oluşturur
@@ -4356,6 +4365,7 @@ axis	Both	Her İkisi
 @msg	internal error: {msg} (please report this bug)	dahili hata: {msg} (lütfen bu hatayı bildirin)
 @msg	invalid PDF setting: {0}	geçersiz PDF ayarı: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	{n} çalışma yüzeyinin sayfası {size}, PDF'nin 14.400 pt (200 in) sayfa sınırından uzun: {unit} UserUnit değeriyle yazılır, bu yüzden UserUnit'i yok sayan uygulamalar onu o kadar kat küçük gösterir
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	{n} çalışma yüzeyinin sayfası {size}, PDF'nin 14.400 pt (200 in) sayfa sınırından uzun: {unit} UserUnit değeriyle yazılır, bu yüzden UserUnit'i yok sayan uygulamalar onu o kadar kat küçük gösterir: "200 in'den uzun sayfaları tam boyutta, punto olarak yaz" seçeneğini açın
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	{n} çalışma yüzeyinin sayfası {size}, PDF'nin 14.400 pt (200 in) sayfa sınırından uzun: {label} sayfaları UserUnit olmadan, punto cinsinden yazılır ve sınıra uyan uygulamalar sayfayı 200 in'de keser
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5'te, 14.400 pt (200 in) uzunluğunu aşan bir sayfanın boyutunu koruması için gereken UserUnit yoktur: dosya PDF 1.6 olarak yazılır
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4'te, 14.400 pt (200 in) uzunluğunu aşan bir sayfanın PDF/A-2'nin 14.400 birimlik sayfa sınırı içinde kalması için gereken UserUnit yoktur: dosya PDF 1.6 olarak yazılır
@@ -4767,6 +4777,7 @@ axis	Both	Her İkisi
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Kurtarılan {n} belge atıldı
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Kurtarılan {n} belge geri yüklendi: saklamak için kaydedin
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	{n} notla açıldı: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. {n} notla açıldı: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	{path}, {n} notla kaydedildi: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	{n} görsel gömüldü; {missing} eksik: önce onları yeniden bağlayın
 @msgplural	Embedded {n} image|Embedded {n} images	{n} görsel gömüldü
@@ -5955,6 +5966,9 @@ theme	Appearance	Görünüm
 @msg	Save writes {_1}, not {_2}: use file.saveAsTemplate to write it	Kaydet {_1} yazar, {_2} değil: yazmak için file.saveAsTemplate kullanın
 @msg	`{given}` isn't a library panel (see window.swatchLibrary)	`{given}` bir kütüphane paneli değil (bkz. window.swatchLibrary)
 @msg	`{key}` must be a #rrggbb color	`{key}` bir #rrggbb rengi olmalıdır
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` bir #rrggbb rengi ya da katman rengi adı olmalıdır
+@msg	unknown Live Paint option `{key}`	bilinmeyen Canlı Boyama seçeneği `{key}`
+@msg	unknown Shape Builder option `{key}`	bilinmeyen Şekil Oluşturucu seçeneği `{key}`
 @msg	a key object sits on that point	bu noktanın üzerinde bir anahtar nesne bulunuyor
 @msg	a linked image can't become a gradient mesh: embed it first	bağlantılı bir görüntü degrade ağına dönüştürülemez: önce görüntüyü gömün
 @msg	a mask has more than one art block	bir maskede birden fazla çizim bloğu var
@@ -6123,6 +6137,29 @@ theme	Appearance	Görünüm
 	New Brush	Yeni Fırça
 	Pattern Brush	Desen Fırçası
 	missing from the Brushes panel	Fırçalar panelinde yok
+	built in	yerleşik
+	embedding not allowed	gömmeye izin verilmiyor
+	embedding for editing	düzenleme için gömme
+	embedding for preview and print	önizleme ve yazdırma için gömme
+	embedding allowed	gömmeye izin veriliyor
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	yerine konan: {family} {style} ile gösteriliyor ({detail})
+	missing: shown in {family} {style}	eksik: {family} {style} ile gösteriliyor
+	missing	eksik
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Doğrusal degrade
+	Radial gradient	Radyal degrade
+	Conic gradient	Konik degrade
+	Diamond gradient	Elmas degrade
+	Freeform gradient	Serbest biçimli degrade
+@plural	{n} instance|{n} instances	{n} örnek
+@plural	{n} row|{n} rows	{n} satır
+@plural	{n} column|{n} columns	{n} sütun
 	Pick Color From:	Rengi Buradan Al:
 	Scatter Brush	Serpme Fırçası
 	Select art to make a scatter, art or pattern brush.	Bir serpme, resim veya desen fırçası oluşturmak için çizim seçin.
@@ -6821,6 +6858,8 @@ anchor	Points:	Noktalar:
 	Anchor Inspector	Bağlantı Noktası Denetçisi
 	Add Points at Crossings	Kesişimlere Nokta Ekle
 	Split at Crossings	Kesişimlerden Böl
+	Trim at Crossings Tool	Kesişimlerden Kırpma Aracı
+	Trim at Crossings	Kesişimlerden Kırp
 	Extend Path	Yolu Uzat
 	Measure & Inspect	Ölç ve İncele
 	Set Anchor	Bağlantı Noktasını Ayarla
@@ -7399,3 +7438,9 @@ breakText	Glyphs	Glifler
 	Margin	Kenar Boşluğu
 	Box	Kutu
 	Swatch	Renk Örneği
+	Banner Hems and Grommets…	Afiş Kenar Kıvırma ve Kuşgözleri…
+	Banner Hems and Grommets	Afiş Kenar Kıvırma ve Kuşgözleri
+	Hem	Kenar Kıvırma
+	Grommets	Kuşgözleri
+	Grommet Inset	Kuşgözlerinin kenara uzaklığı
+	Diameter	Çap
diff --git a/crates/ui-egui/src/i18n/uk.tsv b/crates/ui-egui/src/i18n/uk.tsv
index ce8e8dcef6..a7b3ea2c2e 100644
--- a/crates/ui-egui/src/i18n/uk.tsv
+++ b/crates/ui-egui/src/i18n/uk.tsv
@@ -2222,6 +2222,29 @@ file-filter	Templates	Шаблони
 	Bristle Brush	Щетинний пензель
 	Pattern Brush	Візерунковий пензель
 	missing from the Brushes panel	відсутній у панелі «Пензлі»
+	built in	вбудований
+	embedding not allowed	вбудовування заборонено
+	embedding for editing	вбудовування для редагування
+	embedding for preview and print	вбудовування для перегляду й друку
+	embedding allowed	вбудовування дозволено
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	замінено: показано шрифтом {family} {style} ({detail})
+	missing: shown in {family} {style}	відсутній: показано шрифтом {family} {style}
+	missing	відсутній
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Лінійний градієнт
+	Radial gradient	Радіальний градієнт
+	Conic gradient	Конічний градієнт
+	Diamond gradient	Ромбоподібний градієнт
+	Freeform gradient	Довільний градієнт
+@plural	{n} instance|{n} instances	{n} екземпляр|{n} екземпляри|{n} екземплярів
+@plural	{n} row|{n} rows	{n} рядок|{n} рядки|{n} рядків
+@plural	{n} column|{n} columns	{n} стовпець|{n} стовпці|{n} стовпців
 	Select art to make a scatter, art or pattern brush.	Виділіть малюнок, щоб створити пензель-розпорошення, художній або візерунковий пензель.
 	Brush Art	Малюнок пензля
 	New Calligraphic Brush	Новий каліграфічний пензель
@@ -3682,6 +3705,11 @@ effect	Points	Точки
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Параметри Tate-chu-yoko…
 	Tate-chu-yoko Settings	Параметри Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Параметри Warichu…
+	Warichu Settings	Параметри Warichu
+	Lines:	Рядки:
+	Line Gap:	Інтервал між рядками:
 	Composite Fonts…	Складені шрифти…
 	Composite Fonts	Складені шрифти
 	Export Composite Fonts	Експорт складених шрифтів
@@ -4389,6 +4417,10 @@ axis	Both	Обидві
 @msg	Couldn't paste: the document it was pasted in was reverted	Не вдалося вставити: документ, у який виконувалося вставлення, було повернуто до збереженої версії
 @msg	Couldn't read {name}: {e}	Неможливо прочитати {name}: {e}
 @msg	Couldn't save recovery data: {e}	Не вдалося зберегти дані відновлення: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Не вдалося зберегти дані відновлення для {title}: {e}. Копії зберігаються в {folder}, типовій папці відновлення; щоб використати іншу папку, задайте Установки → Робота з файлами → Відновлення даних → Папка (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Не вдалося зберегти дані відновлення для {title}: {e}. Копії зберігаються в {folder}, папці, заданій в установках; щоб використати іншу папку, задайте Установки → Робота з файлами → Відновлення даних → Папка (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Не вдалося зберегти дані відновлення: {e}. Копії зберігаються в {folder}, типовій папці відновлення; щоб використати іншу папку, задайте Установки → Робота з файлами → Відновлення даних → Папка (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Не вдалося зберегти дані відновлення: {e}. Копії зберігаються в {folder}, папці, заданій в установках; щоб використати іншу папку, задайте Установки → Робота з файлами → Відновлення даних → Папка (recoveryFolder)
 @msg	Create Outlines: select text objects	Створення контурів: виділіть текстові об’єкти
 @msg	Create from Guides: the document has no artboard	Створення з напрямних: у документі немає монтажної області
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Створення з напрямних: напрямні утворюють більше {MAX_PIECES} фрагментів
@@ -4474,6 +4506,9 @@ axis	Both	Обидві
 @msg	`{keep}` is not a side of this axis	`{keep}` не є стороною цієї осі
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` має бути `auto` або кодом мови, наприклад `en` або `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}` має бути кольором #rrggbb
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` має бути кольором #rrggbb або назвою кольору шару
+@msg	unknown Live Paint option `{key}`	невідомий параметр швидкої заливки `{key}`
+@msg	unknown Shape Builder option `{key}`	невідомий параметр створення фігур `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` має бути кольором #rrggbb
 @msg	`{key}` must be a number	`{key}` має бути числом
 @msg	`{key}` must be a number, not {v}	`{key}` має бути числом, а не {v}
@@ -4633,6 +4668,7 @@ axis	Both	Обидві
 @msg	internal error: {msg} (please report this bug)	внутрішня помилка: {msg} (будь ласка, повідомте про цю помилку)
 @msg	invalid PDF setting: {0}	неприпустимий параметр PDF: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	сторінка монтажної області {n} має розмір {size}, що більше за обмеження PDF на розмір сторінки в 14 400 pt (200 in): її записано з UserUnit {unit}, тому застосунки, які ігнорують UserUnit, показують її в стільки ж разів меншою
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	сторінка монтажної області {n} має розмір {size}, що більше за обмеження PDF на розмір сторінки в 14 400 pt (200 in): її записано з UserUnit {unit}, тому застосунки, які ігнорують UserUnit, показують її в стільки ж разів меншою: увімкніть «Записувати сторінки, довші за 200 in, у повному розмірі, у пунктах»
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	сторінка монтажної області {n} має розмір {size}, що більше за обмеження PDF на розмір сторінки в 14 400 pt (200 in): сторінки {label} записуються без UserUnit, у пунктах, і застосунки, що дотримуються обмеження, обрізають сторінку до 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	у PDF 1.5 немає UserUnit, який потрібен сторінці, довшій за 14 400 pt (200 in), щоб зберегти розмір: файл записується як PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	у PDF 1.4 немає UserUnit, який потрібен сторінці, довшій за 14 400 pt (200 in), щоб вкластися в межу сторінки PDF/A-2 у 14 400 одиниць: файл записується як PDF 1.6
@@ -5073,6 +5109,7 @@ axis	Both	Обидві
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	Скасовано {n} відновлений документ|Скасовано {n} відновлені документи|Скасовано {n} відновлених документів
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	Відновлено {n} документ: збережіть його, щоб залишити|Відновлено {n} документи: збережіть їх, щоб залишити|Відновлено {n} документів: збережіть їх, щоб залишити
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Відкрито з {n} приміткою: {first}|Відкрито з {n} примітками: {first}|Відкрито з {n} примітками: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Відкрито з {n} приміткою: {first}|{notice}. Відкрито з {n} примітками: {first}|{notice}. Відкрито з {n} примітками: {first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	Збережено: {path} з {n} приміткою: {first}|Збережено: {path} з {n} примітками: {first}|Збережено: {path} з {n} примітками: {first}
 @msgplural	Embedded {n} image; {missing} missing: relink them first|Embedded {n} images; {missing} missing: relink them first	Вбудовано {n} зображення; відсутніх: {missing}. Спочатку відновіть їхні зв’язки|Вбудовано {n} зображення; відсутніх: {missing}. Спочатку відновіть їхні зв’язки|Вбудовано {n} зображень; відсутніх: {missing}. Спочатку відновіть їхні зв’язки
 @msgplural	Embedded {n} image|Embedded {n} images	Вбудовано {n} зображення|Вбудовано {n} зображення|Вбудовано {n} зображень
@@ -6471,6 +6508,8 @@ anchor	Points:	Точки:
 	Anchor Inspector	Інспектор опорних точок
 	Add Points at Crossings	Додати точки на перетинах
 	Split at Crossings	Розрізати на перетинах
+	Trim at Crossings Tool	Інструмент «Підрізання на перетинах»
+	Trim at Crossings	Підрізати на перетинах
 	Extend Path	Подовжити контур
 	Measure & Inspect	Вимірювання й аналіз
 	Set Anchor	Задати опорну точку
@@ -7053,3 +7092,9 @@ breakText	Glyphs	Гліфи
 	Margin	Поле
 	Box	Рамка
 	Swatch	Зразок
+	Banner Hems and Grommets…	Підгини та люверси банера…
+	Banner Hems and Grommets	Підгини та люверси банера
+	Hem	Підгин
+	Grommets	Люверси
+	Grommet Inset	Відступ люверсів від краю
+	Diameter	Діаметр
diff --git a/crates/ui-egui/src/i18n/vi.tsv b/crates/ui-egui/src/i18n/vi.tsv
index 88d0185f95..518d89e4b6 100644
--- a/crates/ui-egui/src/i18n/vi.tsv
+++ b/crates/ui-egui/src/i18n/vi.tsv
@@ -2826,6 +2826,29 @@ digits	Hindi	Hindi
 	Pattern	Họa tiết
 	Pattern Brush	Cọ họa tiết
 	missing from the Brushes panel	không có trong bảng Cọ
+	built in	tích hợp sẵn
+	embedding not allowed	không cho phép nhúng
+	embedding for editing	nhúng để chỉnh sửa
+	embedding for preview and print	nhúng để xem trước và in
+	embedding allowed	cho phép nhúng
+	{file}; {embedding}	{file}; {embedding}
+	substituted: shown in {family} {style} ({detail})	đã thay thế: hiển thị bằng {family} {style} ({detail})
+	missing: shown in {family} {style}	thiếu: hiển thị bằng {family} {style}
+	missing	thiếu
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}, {instances}
+	{kind}, {rows} × {cols}	{kind}, {rows} × {cols}
+	{grid}, {instances}	{grid}, {instances}
+	Linear gradient	Chuyển sắc tuyến tính
+	Radial gradient	Chuyển sắc hướng tâm
+	Conic gradient	Chuyển sắc hình nón
+	Diamond gradient	Chuyển sắc hình thoi
+	Freeform gradient	Chuyển sắc tự do
+@plural	{n} instance|{n} instances	{n} phiên bản
+@plural	{n} row|{n} rows	{n} hàng
+@plural	{n} column|{n} columns	{n} cột
 	Pattern Brush Options	Tùy chọn cọ họa tiết
 	Pattern Editing	Chỉnh sửa họa tiết
 	Pattern Options	Tùy chọn họa tiết
@@ -4027,6 +4050,11 @@ mark-style	Japanese	Kiểu Nhật
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Cài đặt Tate-chu-yoko…
 	Tate-chu-yoko Settings	Cài đặt Tate-chu-yoko
+	Warichu	Warichu
+	Warichu Settings…	Cài đặt Warichu…
+	Warichu Settings	Cài đặt Warichu
+	Lines:	Dòng:
+	Line Gap:	Khoảng cách dòng:
 	Composite Fonts…	Phông chữ tổ hợp…
 	Composite Fonts	Phông chữ tổ hợp
 	Export Composite Fonts	Xuất phông chữ tổ hợp
@@ -4527,6 +4555,9 @@ theme	Appearance	Giao diện
 @msg	`{keep}` is not a side of this axis	`{keep}` không phải là một cạnh của trục này
 @msg	`{key}` must be `auto` or a language code such as `en` or `zh-hant`	`{key}` phải là `auto` hoặc mã ngôn ngữ như `en` hoặc `zh-hant`
 @msg	`{key}` must be a #rrggbb color	`{key}` phải là màu #rrggbb
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` phải là màu #rrggbb hoặc tên màu lớp
+@msg	unknown Live Paint option `{key}`	tùy chọn Tô trực tiếp không xác định `{key}`
+@msg	unknown Shape Builder option `{key}`	tùy chọn Tạo hình dạng không xác định `{key}`
 @msg	`{key}` must be a #rrggbb colour	`{key}` phải là màu #rrggbb
 @msg	`{key}` must be a number	`{key}` phải là một số
 @msg	`{key}` must be a number, not {v}	`{key}` phải là một số, không phải {v}
@@ -4818,6 +4849,10 @@ theme	Appearance	Giao diện
 @msg	Couldn't place {name}: {e}	Không thể đặt {name}: {e}
 @msg	Couldn't read {name}: {e}	Không thể đọc {name}: {e}
 @msg	Couldn't save recovery data: {e}	Không thể lưu dữ liệu phục hồi: {e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Không thể lưu dữ liệu phục hồi cho {title}: {e}. Bản sao được lưu vào {folder}, thư mục phục hồi mặc định; để dùng thư mục khác, hãy đặt Tùy chọn → Xử lý tệp → Phục hồi dữ liệu → Thư mục (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Không thể lưu dữ liệu phục hồi cho {title}: {e}. Bản sao được lưu vào {folder}, thư mục được đặt trong Tùy chọn; để dùng thư mục khác, hãy đặt Tùy chọn → Xử lý tệp → Phục hồi dữ liệu → Thư mục (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Không thể lưu dữ liệu phục hồi: {e}. Bản sao được lưu vào {folder}, thư mục phục hồi mặc định; để dùng thư mục khác, hãy đặt Tùy chọn → Xử lý tệp → Phục hồi dữ liệu → Thư mục (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	Không thể lưu dữ liệu phục hồi: {e}. Bản sao được lưu vào {folder}, thư mục được đặt trong Tùy chọn; để dùng thư mục khác, hãy đặt Tùy chọn → Xử lý tệp → Phục hồi dữ liệu → Thư mục (recoveryFolder)
 @msg	Create from Guides: the document has no artboard	Tạo từ đường căn: tài liệu không có bảng vẽ
 @msg	Create from Guides: the guides make more than {MAX_PIECES} slices	Tạo từ đường căn: các đường căn tạo ra hơn {MAX_PIECES} lát cắt
 @msg	Create from Selection: the selection has no area	Tạo từ vùng chọn: vùng chọn không có diện tích
@@ -4891,6 +4926,7 @@ theme	Appearance	Giao diện
 @msg	invalid parameters for `{cmd}`: {msg}	tham số không hợp lệ cho `{cmd}`: {msg}
 @msg	invalid PDF setting: {0}	cài đặt PDF không hợp lệ: {0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	trang của bảng vẽ {n} có kích thước {size}, dài hơn giới hạn trang PDF 14.400 pt (200 in): trang được ghi với UserUnit là {unit}, nên các ứng dụng bỏ qua UserUnit sẽ hiển thị nó nhỏ đi bấy nhiêu lần
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	trang của bảng vẽ {n} có kích thước {size}, dài hơn giới hạn trang PDF 14.400 pt (200 in): trang được ghi với UserUnit là {unit}, nên các ứng dụng bỏ qua UserUnit sẽ hiển thị nó nhỏ đi bấy nhiêu lần: hãy bật "Ghi các trang dài hơn 200 in ở kích thước đầy đủ, theo điểm"
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	trang của bảng vẽ {n} có kích thước {size}, dài hơn giới hạn trang PDF 14.400 pt (200 in): các trang {label} được ghi không có UserUnit, theo đơn vị điểm, và các ứng dụng tuân theo giới hạn sẽ cắt trang ở 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 không có UserUnit, thứ mà trang dài hơn 14.400 pt (200 in) cần để giữ kích thước: tệp được ghi dưới dạng PDF 1.6
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 không có UserUnit, thứ mà trang dài hơn 14.400 pt (200 in) cần để nằm trong giới hạn trang 14.400 đơn vị của PDF/A-2: tệp được ghi dưới dạng PDF 1.6
@@ -5141,6 +5177,7 @@ theme	Appearance	Giao diện
 @msg	onto must name a floating panel	onto phải đặt tên bảng đang thả nổi
 @msg	onto must name a panel floating in another group	onto phải đặt tên bảng đang thả nổi trong nhóm khác
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	Đã mở với {n} ghi chú: {first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}. Đã mở với {n} ghi chú: {first}
 @msg	Opened {url}	Đã mở {url}
 @msg	Outline Stroke: no stroked paths selected	Đường bao nét: chưa chọn đường dẫn có nét
 @msgplural	Packaged {n} file ({note}) in {folder}|Packaged {n} files ({note}) in {folder}	Đã đóng gói {n} tệp trong {folder} ({note})
@@ -6472,6 +6509,8 @@ anchor	Points:	Điểm:
 	Anchor Inspector	Trình kiểm tra điểm neo
 	Add Points at Crossings	Thêm điểm tại chỗ giao nhau
 	Split at Crossings	Tách tại chỗ giao nhau
+	Trim at Crossings Tool	Công cụ Cắt xén tại chỗ giao nhau
+	Trim at Crossings	Cắt xén tại chỗ giao nhau
 	Extend Path	Kéo dài đường dẫn
 	Measure & Inspect	Đo và kiểm tra
 	Set Anchor	Đặt điểm neo
@@ -7054,3 +7093,9 @@ breakText	Glyphs	Glyph
 	Margin	Lề
 	Box	Khung
 	Swatch	Mẫu màu
+	Banner Hems and Grommets…	Viền gấp và khoen băng rôn…
+	Banner Hems and Grommets	Viền gấp và khoen băng rôn
+	Hem	Viền gấp
+	Grommets	Khoen
+	Grommet Inset	Khoảng cách từ mép đến khoen
+	Diameter	Đường kính
diff --git a/crates/ui-egui/src/i18n/zh-hans.tsv b/crates/ui-egui/src/i18n/zh-hans.tsv
index 3a5f0ce687..26fb9e0c1b 100644
--- a/crates/ui-egui/src/i18n/zh-hans.tsv
+++ b/crates/ui-egui/src/i18n/zh-hans.tsv
@@ -2087,6 +2087,29 @@ file-filter	Templates	模板
 	Bristle Brush	鬃毛画笔
 	Pattern Brush	图案画笔
 	missing from the Brushes panel	“画笔”面板中没有
+	built in	内置
+	embedding not allowed	不允许嵌入
+	embedding for editing	允许嵌入以供编辑
+	embedding for preview and print	允许嵌入以供预览和打印
+	embedding allowed	允许嵌入
+	{file}; {embedding}	{file}；{embedding}
+	substituted: shown in {family} {style} ({detail})	已替换：以 {family} {style} 显示 ({detail})
+	missing: shown in {family} {style}	缺失：以 {family} {style} 显示
+	missing	缺失
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}，{instances}
+	{kind}, {rows} × {cols}	{kind}，{rows} × {cols}
+	{grid}, {instances}	{grid}，{instances}
+	Linear gradient	线性渐变
+	Radial gradient	径向渐变
+	Conic gradient	锥形渐变
+	Diamond gradient	菱形渐变
+	Freeform gradient	自由渐变
+@plural	{n} instance|{n} instances	{n} 个实例
+@plural	{n} row|{n} rows	{n} 行
+@plural	{n} column|{n} columns	{n} 列
 	Select art to make a scatter, art or pattern brush.	选择图稿以创建散布画笔、艺术画笔或图案画笔。
 	Brush Art	画笔图稿
 	New Calligraphic Brush	新建书法画笔
@@ -3504,6 +3527,11 @@ digits	Malayalam	马拉雅拉姆数字
 	Tate-chu-yoko	纵中横
 	Tate-chu-yoko Settings…	纵中横设置…
 	Tate-chu-yoko Settings	纵中横设置
+	Warichu	割注
+	Warichu Settings…	割注设置…
+	Warichu Settings	割注设置
+	Lines:	行数：
+	Line Gap:	行间距：
 	Composite Fonts…	复合字体…
 	Composite Fonts	复合字体
 	Export Composite Fonts	导出复合字体
@@ -4493,6 +4521,7 @@ imageTrace	Outline	轮廓
 @msg	cannot read PDF: {0}	无法读取 PDF：{0}
 @msg	invalid PDF setting: {0}	PDF 设置无效：{0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	画板 {n} 的页面为 {size}，超过 PDF 的页面上限 14,400 pt (200 in)：它以 UserUnit {unit} 写入，因此忽略 UserUnit 的应用会将其显示为缩小相应倍数
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	画板 {n} 的页面为 {size}，超过 PDF 的页面上限 14,400 pt (200 in)：它以 UserUnit {unit} 写入，因此忽略 UserUnit 的应用会将其显示为缩小相应倍数：请打开“以实际尺寸（点）写入长于 200 in 的页面”
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	画板 {n} 的页面为 {size}，超过 PDF 的页面上限 14,400 pt (200 in)：{label} 页面不带 UserUnit，以点为单位写入，遵守上限的应用会将页面裁切为 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 没有 UserUnit，而长于 14,400 pt (200 in) 的页面需要它来保持尺寸：文件将以 PDF 1.6 写入
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 没有 UserUnit，而长于 14,400 pt (200 in) 的页面需要它来保持在 PDF/A-2 的 14,400 单位页面上限之内：文件将以 PDF 1.6 写入
@@ -4885,10 +4914,15 @@ imageTrace	Outline	轮廓
 @msg	the print job has no data	打印作业没有数据
 @msg	there are no printer settings to open here	此处没有可打开的打印机设置
 @msg	Couldn't save recovery data: {e}	无法保存恢复数据：{e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	无法保存 {title} 的恢复数据：{e}。副本保存在 {folder}（默认恢复文件夹）；要使用其他文件夹，请设置“首选项 → 文件处理 → 数据恢复 → 文件夹” (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	无法保存 {title} 的恢复数据：{e}。副本保存在 {folder}（在“首选项”中设置的文件夹）；要使用其他文件夹，请设置“首选项 → 文件处理 → 数据恢复 → 文件夹” (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	无法保存恢复数据：{e}。副本保存在 {folder}（默认恢复文件夹）；要使用其他文件夹，请设置“首选项 → 文件处理 → 数据恢复 → 文件夹” (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	无法保存恢复数据：{e}。副本保存在 {folder}（在“首选项”中设置的文件夹）；要使用其他文件夹，请设置“首选项 → 文件处理 → 数据恢复 → 文件夹” (recoveryFolder)
 @msg	Saved recovery data for {title}	已保存 {title} 的恢复数据
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	已丢弃 {n} 个恢复的文档
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	已还原 {n} 个恢复的文档：请保存以保留它们
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	已打开，有 {n} 条注释：{first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}。已打开，有 {n} 条注释：{first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	已保存 {path}，有 {n} 条注释：{first}
 @msg	Saving recovery data for {_1}	正在保存 {_1} 的恢复数据
 @msg	This shortcut file is in a form VectorCraft can't read.	此快捷键文件的格式 VectorCraft 无法读取。
@@ -6027,6 +6061,9 @@ lighting	Light	光源
 @msg	a mask has more than one art block	蒙版包含多个图稿块
 @msg	mask art ends outside a mask dictionary	蒙版图稿在蒙版字典之外结束
 @msg	`{key}` must be a #rrggbb color	`{key}` 必须是 #rrggbb 格式的颜色
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` 必须是 #rrggbb 格式的颜色或图层颜色名称
+@msg	unknown Live Paint option `{key}`	未知的实时上色选项 `{key}`
+@msg	unknown Shape Builder option `{key}`	未知的形状生成器选项 `{key}`
 @msg	a linked image can't become a gradient mesh: embed it first	链接的图像无法转换为渐变网格：请先嵌入它
 @msg	the image has no usable size or position	图像没有可用的尺寸或位置
 @msg	the image's pixels can't be read	无法读取图像的像素
@@ -6704,6 +6741,8 @@ anchor	Points:	点：
 	Anchor Inspector	锚点检查器
 	Add Points at Crossings	在交叉处添加锚点
 	Split at Crossings	在交叉处分割
+	Trim at Crossings Tool	在交叉处修剪工具
+	Trim at Crossings	在交叉处修剪
 	Extend Path	延长路径
 	Measure & Inspect	测量与检查
 	Set Anchor	设置锚点
@@ -7282,3 +7321,9 @@ breakText	Glyphs	字形
 	Margin	边距
 	Box	框
 	Swatch	色板
+	Banner Hems and Grommets…	横幅折边和扣眼…
+	Banner Hems and Grommets	横幅折边和扣眼
+	Hem	折边
+	Grommets	扣眼
+	Grommet Inset	扣眼边距
+	Diameter	直径
diff --git a/crates/ui-egui/src/i18n/zh-hant.tsv b/crates/ui-egui/src/i18n/zh-hant.tsv
index e2dd01a4de..5685430cc8 100644
--- a/crates/ui-egui/src/i18n/zh-hant.tsv
+++ b/crates/ui-egui/src/i18n/zh-hant.tsv
@@ -2238,6 +2238,7 @@ file-filter	Templates	範本
 @msg	cannot read PDF: {0}	無法讀取 PDF：{0}
 @msg	invalid PDF setting: {0}	PDF 設定無效：{0}
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller	工作區域 {n} 的頁面為 {size}，超過 PDF 的頁面上限 14,400 pt (200 in)：它以 UserUnit {unit} 寫入，因此忽略 UserUnit 的應用程式會將其顯示為縮小相應倍數
+@msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): it is written with a UserUnit of {unit}, so apps that ignore UserUnit show it that many times smaller: turn on Write pages longer than 200 in at full size in points	工作區域 {n} 的頁面為 {size}，超過 PDF 的頁面上限 14,400 pt (200 in)：它以 UserUnit {unit} 寫入，因此忽略 UserUnit 的應用程式會將其顯示為縮小相應倍數：請開啟「以實際尺寸（點）寫入長於 200 in 的頁面」
 @msg	the page of artboard {n} is {size}, longer than PDF's page limit of 14,400 pt (200 in): {label} pages are written without a UserUnit, in points, and apps that keep to the limit cut the page to 200 in	工作區域 {n} 的頁面為 {size}，超過 PDF 的頁面上限 14,400 pt (200 in)：{label} 頁面不含 UserUnit，以點為單位寫入，遵守上限的應用程式會將頁面裁切為 200 in
 @msg	PDF 1.5 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to keep its size: the file is written as PDF 1.6	PDF 1.5 沒有 UserUnit，而長於 14,400 pt (200 in) 的頁面需要它來保持尺寸：檔案將以 PDF 1.6 寫入
 @msg	PDF 1.4 has no UserUnit, which a page longer than 14,400 pt (200 in) needs to stay within PDF/A-2's page limit of 14,400 units: the file is written as PDF 1.6	PDF 1.4 沒有 UserUnit，而長於 14,400 pt (200 in) 的頁面需要它來保持在 PDF/A-2 的 14,400 單位頁面上限之內：檔案將以 PDF 1.6 寫入
@@ -2629,10 +2630,15 @@ file-filter	Templates	範本
 @msg	the print job has no data	列印工作沒有資料
 @msg	there are no printer settings to open here	此處沒有可開啟的印表機設定
 @msg	Couldn't save recovery data: {e}	無法儲存復原資料：{e}
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	無法儲存 {title} 的復原資料：{e}。拷貝存放在 {folder}（預設的復原資料夾）；若要使用其他資料夾，請設定「偏好設定 → 檔案處理 → 資料復原 → 資料夾」 (recoveryFolder)
+@msg	Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	無法儲存 {title} 的復原資料：{e}。拷貝存放在 {folder}（在「偏好設定」中設定的資料夾）；若要使用其他資料夾，請設定「偏好設定 → 檔案處理 → 資料復原 → 資料夾」 (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	無法儲存復原資料：{e}。拷貝存放在 {folder}（預設的復原資料夾）；若要使用其他資料夾，請設定「偏好設定 → 檔案處理 → 資料復原 → 資料夾」 (recoveryFolder)
+@msg	Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)	無法儲存復原資料：{e}。拷貝存放在 {folder}（在「偏好設定」中設定的資料夾）；若要使用其他資料夾，請設定「偏好設定 → 檔案處理 → 資料復原 → 資料夾」 (recoveryFolder)
 @msg	Saved recovery data for {title}	已儲存 {title} 的復原資料
 @msgplural	Discarded {n} recovered document|Discarded {n} recovered documents	已捨棄 {n} 份復原的文件
 @msgplural	Restored {n} recovered document: save it to keep it|Restored {n} recovered documents: save them to keep them	已還原 {n} 份復原的文件：請儲存以保留
 @msgplural	Opened with {n} note: {first}|Opened with {n} notes: {first}	已開啟，附有 {n} 則註解：{first}
+@msgplural	{notice}. Opened with {n} note: {first}|{notice}. Opened with {n} notes: {first}	{notice}。已開啟，附有 {n} 則註解：{first}
 @msgplural	Saved {path} with {n} note: {first}|Saved {path} with {n} notes: {first}	已儲存 {path}，附有 {n} 則註解：{first}
 @msg	Saving recovery data for {_1}	正在儲存 {_1} 的復原資料
 @msg	This shortcut file is in a form VectorCraft can't read.	VectorCraft 無法讀取此快速鍵檔案的格式。
@@ -2815,6 +2821,9 @@ file-filter	Templates	範本
 @msg	a mask has more than one art block	遮色片含有多個圖稿區塊
 @msg	mask art ends outside a mask dictionary	遮色片圖稿在遮色片字典之外結束
 @msg	`{key}` must be a #rrggbb color	`{key}` 必須是 #rrggbb 格式的顏色
+@msg	`{key}` must be a #rrggbb color or a layer color name	`{key}` 必須是 #rrggbb 格式的顏色或圖層顏色名稱
+@msg	unknown Live Paint option `{key}`	未知的即時上色選項 `{key}`
+@msg	unknown Shape Builder option `{key}`	未知的形狀建立選項 `{key}`
 @msg	a linked image can't become a gradient mesh: embed it first	連結的影像無法轉換為漸層網格：請先內嵌
 @msg	the image has no usable size or position	影像沒有可用的尺寸或位置
 @msg	the image's pixels can't be read	無法讀取影像的像素
@@ -3286,6 +3295,29 @@ file-filter	Templates	範本
 	Bristle Brush	鬃毛筆刷
 	Pattern Brush	圖樣筆刷
 	missing from the Brushes panel	「筆刷」面板中沒有
+	built in	內建
+	embedding not allowed	不允許內嵌
+	embedding for editing	允許內嵌以供編輯
+	embedding for preview and print	允許內嵌以供預覽和列印
+	embedding allowed	允許內嵌
+	{file}; {embedding}	{file}；{embedding}
+	substituted: shown in {family} {style} ({detail})	已替代：以 {family} {style} 顯示 ({detail})
+	missing: shown in {family} {style}	遺失：以 {family} {style} 顯示
+	missing	遺失
+	{width} × {height} px	{width} × {height} px
+	{size} — {file}	{size} — {file}
+	{n} ppi	{n} ppi
+	{kind}, {instances}	{kind}，{instances}
+	{kind}, {rows} × {cols}	{kind}，{rows} × {cols}
+	{grid}, {instances}	{grid}，{instances}
+	Linear gradient	線性漸層
+	Radial gradient	放射狀漸層
+	Conic gradient	錐形漸層
+	Diamond gradient	菱形漸層
+	Freeform gradient	自由漸層
+@plural	{n} instance|{n} instances	{n} 個實例
+@plural	{n} row|{n} rows	{n} 列
+@plural	{n} column|{n} columns	{n} 欄
 	Select art to make a scatter, art or pattern brush.	選取圖稿以製作散佈筆刷、藝術筆刷或圖樣筆刷。
 	Brush Art	筆刷圖稿
 	New Calligraphic Brush	新增書法筆刷
@@ -4748,6 +4780,11 @@ digits	Malayalam	馬來亞拉姆數字
 	Tate-chu-yoko	縱中橫
 	Tate-chu-yoko Settings…	縱中橫設定…
 	Tate-chu-yoko Settings	縱中橫設定
+	Warichu	割註
+	Warichu Settings…	割註設定…
+	Warichu Settings	割註設定
+	Lines:	行數：
+	Line Gap:	行間距：
 	Composite Fonts…	複合字體…
 	Composite Fonts	複合字體
 	Export Composite Fonts	匯出複合字體
@@ -6510,6 +6547,8 @@ anchor	Points:	點：
 	Anchor Inspector	錨點檢查器
 	Add Points at Crossings	在交叉處增加錨點
 	Split at Crossings	在交叉處分割
+	Trim at Crossings Tool	在交叉處修剪工具
+	Trim at Crossings	在交叉處修剪
 	Extend Path	延長路徑
 	Measure & Inspect	測量與檢查
 	Set Anchor	設定錨點
@@ -7089,3 +7128,9 @@ breakText	Glyphs	字符
 	Margin	邊距
 	Box	框
 	Swatch	色票
+	Banner Hems and Grommets…	橫幅折邊與扣眼…
+	Banner Hems and Grommets	橫幅折邊與扣眼
+	Hem	折邊
+	Grommets	扣眼
+	Grommet Inset	扣眼邊距
+	Diameter	直徑
diff --git a/crates/ui-egui/src/io.rs b/crates/ui-egui/src/io.rs
index 5f70c5dc63..83f463d668 100644
--- a/crates/ui-egui/src/io.rs
+++ b/crates/ui-egui/src/io.rs
@@ -26,13 +26,13 @@ pub(crate) use export::{
     export_files, exported_with_notes, file_url, open_in_app, open_original, reveal_path, run_to_file, save_command_output_named,
 };
 pub(crate) use open::report_installed;
-pub(crate) use open::{EXPORT_PRESETS, import_presets, open_with_on, opened};
+pub(crate) use open::{EXPORT_PRESETS, import_presets, open_with_on, opened, show_opened};
 pub use open::{
     MAX_RECENT_FILES, OpensAs, ask_revert, install_module, install_plugin, new_from_template, note_recent, open_bytes, open_dialog, open_document,
     open_path, open_path_with, open_reporting, open_with, opens_as, place_bytes, recent_files, report_open_error,
 };
 #[cfg(test)]
-pub(crate) use open::{open_file, opened_with_notes};
+pub(crate) use open::{open_file, opened_after_notice, opened_with_notes};
 pub(crate) use save::save_current;
 pub use save::{ask_format_options, ask_pdf_options, remember_active_artboard, remember_view, save, save_pdf};
 pub(crate) use save::{export_path, is_web, notes_of, report_saved, show_with_notes, target_path, write_named, write_reporting, write_to};
@@ -87,9 +87,8 @@ mod tests {
 
     /// A file opened with a note about its page first and a note that its layers weren't read
     /// second: the status bar names the layers note, counts both, and keeps both, the layers note
-    /// first, for its hover. A message about its linked files still replaces that message. Two
-    /// notes of what was left out keep the order the import gave them, and an open without notes
-    /// leaves the message and the notes an earlier open left.
+    /// first, for its hover. Two notes of what was left out keep the order the import gave them,
+    /// and an open without notes leaves the message and the notes an earlier open left.
     #[test]
     fn an_open_names_the_note_of_what_was_left_out_first() {
         use vectorcraft_testkit::ai;
@@ -103,14 +102,6 @@ mod tests {
         assert_eq!(app.ui.status, opened_with_notes(2, layers));
         assert_eq!(app.ui.status_notes, Some((app.ui.status.clone(), vec![layers.clone(), page.clone()])));
 
-        // A message about its linked files replaces the open's message, as before.
-        app.session.prefs.update_links = "manually".into();
-        let mut linked = r.clone();
-        linked["modifiedLinks"] = json!([{ "ids": [1] }]);
-        opened(&mut app, &linked);
-        assert_eq!(app.ui.status, dialogs::missing_links::changed_on_disk_status(1));
-        assert_eq!(app.ui.status_notes, Some((opened_with_notes(2, layers), vec![layers.clone(), page.clone()])));
-
         let r = open_bytes(&mut app, "damaged.ai", &ai::ai(damaged, ai::page_pdf()), None).unwrap();
         let both = notes(&r);
         assert_eq!(both.len(), 2, "{r}");
@@ -130,6 +121,38 @@ mod tests {
         assert_eq!((app.ui.status.clone(), app.ui.status_notes.clone()), shown);
     }
 
+    /// A file opened with two notes and a modified linked file while Update Links doesn't ask: the
+    /// status bar shows the line about the linked file, then counts the notes and names the first
+    /// of what was left out, and keeps both notes, in that order, for its hover.
+    #[test]
+    fn an_open_with_modified_links_keeps_link_notice_and_import_notes_reachable() {
+        let (mut app, _) = app();
+        let pdf = vectorcraft_testkit::ai::pdf(b"%AI12_CompressedData not zlib", "0 g 150 20 100 60 re f");
+        let r = open_bytes(&mut app, "damaged.pdf", &pdf, None).unwrap();
+        let [page, layers] = &notes_of(&r)[..] else { panic!("two notes: {r}") };
+        app.session.prefs.update_links = "manually".into();
+        let mut linked = r.clone();
+        linked["modifiedLinks"] = json!([{ "ids": [1] }]);
+        opened(&mut app, &linked);
+        let notice = dialogs::missing_links::changed_on_disk_status(1);
+        assert_eq!(app.ui.status, opened_after_notice(&notice, 2, layers));
+        assert!(app.ui.status.starts_with(&notice) && app.ui.status.ends_with(&opened_with_notes(2, layers)), "{}", app.ui.status);
+        assert_eq!(app.ui.status_notes, Some((app.ui.status.clone(), vec![layers.clone(), page.clone()])));
+        assert!(app.ui.dialog.is_none());
+    }
+
+    /// File › New from Template… shows the notes of the file it opens, as File › Open does.
+    #[test]
+    fn new_from_template_preserves_open_warnings() {
+        let (mut app, _) = app();
+        let pdf = vectorcraft_testkit::ai::pdf(b"%AI12_CompressedData not zlib", "0 g 150 20 100 60 re f");
+        app.services.read = Some(Box::new(move |_: &str| Ok(pdf.clone())));
+        let r = new_from_template(&mut app, Some("/templates/damaged.pdf".into())).unwrap();
+        let [page, layers] = &notes_of(&r)[..] else { panic!("two notes: {r}") };
+        assert_eq!(app.ui.status, opened_with_notes(2, layers));
+        assert_eq!(app.ui.status_notes, Some((app.ui.status.clone(), vec![layers.clone(), page.clone()])));
+    }
+
     /// A save and an export with several notes: the status bar names the first, counts them, and
     /// keeps every one of them, in the reply's order, for its hover. A save without notes keeps
     /// none.
diff --git a/crates/ui-egui/src/io/open.rs b/crates/ui-egui/src/io/open.rs
index ae52b599b7..1dec3a1fc7 100644
--- a/crates/ui-egui/src/io/open.rs
+++ b/crates/ui-egui/src/io/open.rs
@@ -140,14 +140,24 @@ pub fn open_document(app: &mut VectorcraftApp, name: &str, bytes: &[u8], path: O
 /// what didn't come in as it was, and missing links are asked about. The status bar names the
 /// first of the notes that say reading the file left something out (the ones that make Save ask
 /// before writing over it), else the first note, and keeps the notes in that order for its hover.
+/// A line about the document's linked files comes before the notes ([`show_opened`]).
 pub(crate) fn opened(app: &mut VectorcraftApp, r: &Value) {
     app.sync_views();
     let notes = open_notes(app, r);
-    if let Some(first) = notes.first() {
-        let status = opened_with_notes(notes.len(), first);
-        show_with_notes(app, status, notes);
-    }
-    crate::dialogs::missing_links::after_open(app, r);
+    crate::dialogs::missing_links::after_open(app, r, notes);
+}
+
+/// Show what an open says in the status bar: `notice`, a line about the document's linked files,
+/// then the open's `notes` ([`opened_with_notes`]), kept for the message's hover. Without either
+/// the status bar keeps its message.
+pub(crate) fn show_opened(app: &mut VectorcraftApp, notice: Option<String>, notes: Vec<String>) {
+    let status = match (notice, notes.first()) {
+        (Some(notice), Some(first)) => opened_after_notice(&notice, notes.len(), first),
+        (None, Some(first)) => opened_with_notes(notes.len(), first),
+        (Some(notice), None) => notice,
+        (None, None) => return,
+    };
+    show_with_notes(app, status, notes);
 }
 
 /// The notes of the open `r`, those of what reading the file left out (its document's
@@ -166,6 +176,16 @@ pub(crate) fn opened_with_notes(n: usize, first: &str) -> String {
     crate::i18n::msg_n(n as u64, "Opened with {n} note: {first}", "Opened with {n} notes: {first}", &[("first", first)])
 }
 
+/// [`opened_with_notes`] after `notice`, a line about the document's linked files.
+pub(crate) fn opened_after_notice(notice: &str, n: usize, first: &str) -> String {
+    crate::i18n::msg_n(
+        n as u64,
+        "{notice}. Opened with {n} note: {first}",
+        "{notice}. Opened with {n} notes: {first}",
+        &[("notice", notice), ("first", first)],
+    )
+}
+
 /// A path from the open dialog, or "cancelled".
 fn pick_open(app: &mut VectorcraftApp, pick: &FilePick) -> Result<String, String> {
     crate::picks::open(app, pick).ok_or_else(|| "cancelled".into())
@@ -564,8 +584,7 @@ pub fn new_from_template(app: &mut VectorcraftApp, path: Option<String>) -> Resu
     };
     let bytes = read(app, &path)?;
     let r = fileio::open_template(&mut app.session, &path, &bytes, Some(&path)).map_err(|e| e.to_string())?;
-    app.sync_views();
-    crate::dialogs::missing_links::after_open(app, &r);
+    opened(app, &r);
     Ok(r)
 }
 
diff --git a/crates/ui-egui/src/menus/run.rs b/crates/ui-egui/src/menus/run.rs
index 263856da9b..14e5d053ef 100644
--- a/crates/ui-egui/src/menus/run.rs
+++ b/crates/ui-egui/src/menus/run.rs
@@ -937,6 +937,7 @@ fn run_ui_part10(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result
         "ui.hyphenation" => crate::dialogs::hyphenation::open(app),
         "ui.justification" => crate::dialogs::justification::open(app),
         "ui.tateChuYokoSettings" => crate::dialogs::tate_chu_yoko::open(app),
+        "ui.warichuSettings" => crate::dialogs::warichu::open(app),
         "ui.colorGuideLimit" => crate::panels::color_guide::set_limit(app, p),
         "ui.colorPanel" => crate::panels::color::command(app, p),
         "ui.colorRgbPercent" => crate::panels::color::rgb_percent_command(app, p),
diff --git a/crates/ui-egui/src/menus/state.rs b/crates/ui-egui/src/menus/state.rs
index 50885f4869..0d5775ffe9 100644
--- a/crates/ui-egui/src/menus/state.rs
+++ b/crates/ui-egui/src/menus/state.rs
@@ -285,7 +285,9 @@ pub fn enabled(app: &VectorcraftApp, id: &str) -> bool {
         "ui.sampleScreenColor" => crate::screen_color::available(app),
         "ui.newBrush" => app.session.active().is_some(),
         "ui.brushOptions" => crate::dialogs::brush_options::available(app),
-        "ui.hyphenation" | "ui.justification" | "ui.tateChuYokoSettings" => crate::panels::character::text_style(app).is_some(),
+        "ui.hyphenation" | "ui.justification" | "ui.tateChuYokoSettings" | "ui.warichuSettings" => {
+            crate::panels::character::text_style(app).is_some()
+        }
         "ui.colorBalanceDialog" | "ui.saturateDialog" | "ui.indexedColorDialog" => app.session.active().is_some_and(|d| !d.selection.is_empty()),
         "ui.saveSwatchLibrary" => app.session.active().is_some(),
         id if id.starts_with(crate::panels::swatches::USER_SLOT) => crate::panels::swatches::user_library(app, id).is_some(),
diff --git a/crates/ui-egui/src/menus/ui_commands.rs b/crates/ui-egui/src/menus/ui_commands.rs
index 925d7adf3b..0b490352e3 100644
--- a/crates/ui-egui/src/menus/ui_commands.rs
+++ b/crates/ui-egui/src/menus/ui_commands.rs
@@ -926,7 +926,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "tool.options",
         "Tool Options…",
         "",
-        "{tool: id} what double-clicking a tool button opens: hand → fits the artboard in the window (view.fitArtboard), zoom → 100% (view.actualSize), rotate|scale|reflect|shear → that Object › Transform dialog (dialog `rotate`, `scale`, `reflect` or `shear`; error `nothing selected` without a selection), selection|directSelection|groupSelection → the Move dialog (dialog `move`; the same error), gradient|magicWand → the Gradient or Magic Wand panel (window.panel), artboard → Artboard Options of the active artboard (dialog `artboardOptions`, fields index, name, x, y, width, height, showCenterMark, showCrossHairs; OK runs artboard.setProps, and with other artboards selected with the Artboard tool a new width or height goes to each of them too, in its `artboards` list, each resized about the reference point the form used for that size, or about its top-left corner when the size was set in the fields directly), flare → Flare Tool Options (dialog `flareOptions`, fields diameter and pathLength (pt), opacity, brightness, growth, fuzziness, longest, rayFuzziness, largest (%), rays, rings, direction (°), raysOn, ringsOn; OK runs tool.setOption {tool: \"flare\", values}: the next flare dragged out uses them, and a Flare click's dialog, which also has x, y and preview (on initially), previews one there and accepts it as one Undo step; Cancel rolls back the preview), lineSegment|arc|rectangularGrid|polarGrid → that tool's Tool Options, its click dialog without x and y (dialog kind = the tool id, `__toolOptions: true`; lineSegment: length (pt), angle (°), fillLine; arc: lengthX, lengthY (pt), reference (0–8), arcType: open|closed, baseAlong: x|y, slope (−100…100), fillArc; rectangularGrid: width, height (pt, the Default Size), reference (0–8), rows, columns, rowSkew, columnSkew (%), frame, fill; polarGrid: the same with concentric, radial, concentricSkew, radialSkew and compound for rows, columns, the skews and frame; OK runs tool.setOption {tool, values} and draws nothing: the next drag uses them (Fill Line, the arc's type, base, slope and fill, the grids' dividers, skews and switches) and a click's dialog opens at them), columnGraph|stackedColumnGraph|barGraph|stackedBarGraph|lineGraph|areaGraph|scatterGraph|pieGraph|radarGraph → Graph Type for the selected graph (dialog `command` running graph.setType; an error without one), typeOnPath|verticalTypeOnPath → Type on a Path Options for the selected type on a path (dialog `command` running type.pathOptions; error `nothing selected` without a selection, and the command's error when no type on a path is selected),symbolSprayer|symbolShifter|symbolScruncher|symbolSizer|symbolSpinner|symbolStainer|symbolScreener|symbolStyler → Symbolism Tools Options (dialog `symbolismOptions`, fields tool, diameter (pt), intensity and density (1–10), shared by the eight tools; OK runs tool.setOption {tool, values}), blend → Blend Options, perspectiveGrid → Perspective Grid Options, eyedropper → Eyedropper Options (dialog `eyedropperOptions`, fields sampleSize, pickUp, apply; OK runs eyedropper.setOptions), printTiling → resets the print tiling (print.tiling.set {reset: true}), warp|twirl|pucker|bloat|scallop|crystallize|wrinkle → that tool's Tool Options (dialog `liquifyOptions`, fields tool, width, height, angle, intensity %, usePressure, detail, simplify, simplifyOn, rate, complexity, horizontal %, vertical %, affectAnchors, affectIn, affectOut, showBrush; OK runs tool.setOption {tool, values}), pencil|paintbrush|smooth|blobBrush|eraser → that tool's Tool Options (dialog `freehandOptions`, fields tool and the options the tool keeps: fidelity (px for pencil and paintbrush, the same at any zoom; pt for smooth and blobBrush), fill, keepSelected (on for pencil and paintbrush, off for blobBrush), mergeOnlySelection (off), closeWithin and editWithin (px, 0 is off), livePreview (pencil, on: off draws a thin line while the stroke is drawn, and the path's fill and stroke on release), size (pt), angle (°, −180–180; 0) and roundness (%, 1–100; 100) of the eraser's tip; OK runs tool.setOption {tool, values}), livePaintSelection → Live Paint Selection Tool Options (dialog `livePaintSelectionOptions`, fields selectFills and selectStrokes (both on), color (the highlight color, #rrggbb or a layer color's name; #ff2a2a), width (the highlight's width, 1–20 px; 4); OK runs tool.setOption {tool: \"livePaintSelection\", values}; a color with an alpha part (#rrggbbaa or #rgba) is an error and OK changes nothing), livePaintBucket → Live Paint Bucket Options (dialog `livePaintBucketOptions`, fields paintFills (on) and paintStrokes (off), highlight (on), color (the highlight color, #rrggbb or a layer color's name; #ff2a2a), width (the face highlight's width, 1–20 px; 4; an edge's highlight is half as wide); OK runs tool.setOption {tool: \"livePaintBucket\", values}; a color with an alpha part (#rrggbbaa or #rgba) is an error and OK changes nothing), shapeBuilder → Shape Builder Tool Options (dialog `shapeBuilderOptions`, fields gapDetection (off), gapLength (pt, 0–72; 3), openFilledAsClosed (on), clickStrokeSplitsPath (off), pickColorFrom: artwork|swatches (artwork), cursorSwatchPreview (off), selection: freeform|straightLine (freeform), highlightFill (on), highlightStroke (on), highlightColor (#rrggbb or a layer color's name; #ff4f4f); OK runs tool.setOption {tool: \"shapeBuilder\", values}; a highlightColor with an alpha part (#rrggbbaa or #rgba) is an error and OK changes nothing), objectsOnPath → Objects on Path Tool Options (dialog `objectsOnPathOptions`, fields pivot (0–8, row by row from the top left; 4, the center) and rotate (°, −360–360; 0); Reset puts 4 and 0 back; Save runs tool.setOption {tool: \"objectsOnPath\", values}: the objects attached next use them, groups attached before keep theirs)",
+        "{tool: id} what double-clicking a tool button opens: hand → fits the artboard in the window (view.fitArtboard), zoom → 100% (view.actualSize), rotate|scale|reflect|shear → that Object › Transform dialog (dialog `rotate`, `scale`, `reflect` or `shear`; error `nothing selected` without a selection), selection|directSelection|groupSelection → the Move dialog (dialog `move`; the same error), gradient|magicWand → the Gradient or Magic Wand panel (window.panel), artboard → Artboard Options of the active artboard (dialog `artboardOptions`, fields index, name, x, y, width, height, showCenterMark, showCrossHairs; OK runs artboard.setProps, and with other artboards selected with the Artboard tool a new width or height goes to each of them too, in its `artboards` list, each resized about the reference point the form used for that size, or about its top-left corner when the size was set in the fields directly), flare → Flare Tool Options (dialog `flareOptions`, fields diameter and pathLength (pt), opacity, brightness, growth, fuzziness, longest, rayFuzziness, largest (%), rays, rings, direction (°), raysOn, ringsOn; OK runs tool.setOption {tool: \"flare\", values}: the next flare dragged out uses them, and a Flare click's dialog, which also has x, y and preview (on initially), previews one there and accepts it as one Undo step; Cancel rolls back the preview), lineSegment|arc|rectangularGrid|polarGrid → that tool's Tool Options, its click dialog without x and y (dialog kind = the tool id, `__toolOptions: true`; lineSegment: length (pt), angle (°), fillLine; arc: lengthX, lengthY (pt), reference (0–8), arcType: open|closed, baseAlong: x|y, slope (−100…100), fillArc; rectangularGrid: width, height (pt, the Default Size), reference (0–8), rows, columns, rowSkew, columnSkew (%), frame, fill; polarGrid: the same with concentric, radial, concentricSkew, radialSkew and compound for rows, columns, the skews and frame; OK runs tool.setOption {tool, values} and draws nothing: the next drag uses them (Fill Line, the arc's type, base, slope and fill, the grids' dividers, skews and switches) and a click's dialog opens at them), columnGraph|stackedColumnGraph|barGraph|stackedBarGraph|lineGraph|areaGraph|scatterGraph|pieGraph|radarGraph → Graph Type for the selected graph (dialog `command` running graph.setType; an error without one), typeOnPath|verticalTypeOnPath → Type on a Path Options for the selected type on a path (dialog `command` running type.pathOptions; error `nothing selected` without a selection, and the command's error when no type on a path is selected),symbolSprayer|symbolShifter|symbolScruncher|symbolSizer|symbolSpinner|symbolStainer|symbolScreener|symbolStyler → Symbolism Tools Options (dialog `symbolismOptions`, fields tool, diameter (pt), intensity and density (1–10), shared by the eight tools; OK runs tool.setOption {tool, values}), blend → Blend Options, perspectiveGrid → Perspective Grid Options, eyedropper → Eyedropper Options (dialog `eyedropperOptions`, fields sampleSize, pickUp, apply; OK runs eyedropper.setOptions), printTiling → resets the print tiling (print.tiling.set {reset: true}), warp|twirl|pucker|bloat|scallop|crystallize|wrinkle → that tool's Tool Options (dialog `liquifyOptions`, fields tool, width, height, angle, intensity %, usePressure, detail, simplify, simplifyOn, rate, complexity, horizontal %, vertical %, affectAnchors, affectIn, affectOut, showBrush; OK runs tool.setOption {tool, values}), pencil|paintbrush|smooth|blobBrush|eraser → that tool's Tool Options (dialog `freehandOptions`, fields tool and the options the tool keeps: fidelity (px for pencil, paintbrush and smooth, the same at any zoom; pt for blobBrush), fill, keepSelected (on for pencil and paintbrush, off for blobBrush), mergeOnlySelection (off), closeWithin and editWithin (px, 0 is off), livePreview (pencil, on: off draws a thin line while the stroke is drawn, and the path's fill and stroke on release), size (pt), angle (°, −180–180; 0) and roundness (%, 1–100; 100) of the eraser's tip; OK runs tool.setOption {tool, values}), livePaintSelection → Live Paint Selection Tool Options (dialog `livePaintSelectionOptions`, fields selectFills and selectStrokes (both on), color (the highlight color, #rrggbb or a layer color's name; #ff2a2a), width (the highlight's width, 1–20 px; 4); OK runs tool.setOption {tool: \"livePaintSelection\", values}; a color with an alpha part (#rrggbbaa or #rgba) is an error and OK changes nothing), livePaintBucket → Live Paint Bucket Options (dialog `livePaintBucketOptions`, fields paintFills (on) and paintStrokes (off), highlight (on), color (the highlight color, #rrggbb or a layer color's name; #ff2a2a), width (the face highlight's width, 1–20 px; 4; an edge's highlight is half as wide); OK runs tool.setOption {tool: \"livePaintBucket\", values}; a color with an alpha part (#rrggbbaa or #rgba) is an error and OK changes nothing), shapeBuilder → Shape Builder Tool Options (dialog `shapeBuilderOptions`, fields gapDetection (off), gapLength (pt, 0–72; 3), openFilledAsClosed (on), clickStrokeSplitsPath (off), pickColorFrom: artwork|swatches (artwork), cursorSwatchPreview (off), selection: freeform|straightLine (freeform), highlightFill (on), highlightStroke (on), highlightColor (#rrggbb or a layer color's name; #ff4f4f); OK runs tool.setOption {tool: \"shapeBuilder\", values}; a highlightColor with an alpha part (#rrggbbaa or #rgba) is an error and OK changes nothing), objectsOnPath → Objects on Path Tool Options (dialog `objectsOnPathOptions`, fields pivot (0–8, row by row from the top left; 4, the center) and rotate (°, −360–360; 0); Reset puts 4 and 0 back; Save runs tool.setOption {tool: \"objectsOnPath\", values}: the objects attached next use them, groups attached before keep theirs)",
     ),
     (
         "ui.colorGuideOptions",
@@ -1297,6 +1297,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "",
         "{} open Tate-chu-yoko Settings (the Character panel menu's Tate-chu-yoko Settings…, with Show East Asian Options) on the characters the Character panel acts on, filled in with the values they share (dialog `tateChuYokoSettings`: tcyUpDown, tcyLeftRight (pt, -1296..1296)): OK runs text.setFormat (text.setRangeStyle while the Type tool edits text) with the values that changed, as one undo step; an error with no type selected",
     ),
+    (
+        "ui.warichuSettings",
+        "Warichu Settings…",
+        "",
+        "{} open Warichu Settings (the Character panel menu's Warichu Settings…, with Show East Asian Options) on the characters the Character panel acts on, filled in with the values they share (dialog `warichuSettings`: warichuLines 1..6, warichuGap (pt, 0..100), warichuScale (%, 10..100), warichuAlign): OK runs text.setFormat (text.setRangeStyle while the Type tool edits text) with the values that changed, as one undo step, and leaves Warichu itself as it is; an error with no type selected",
+    ),
     (
         "ui.colorGuideLimit",
         "Limit Color Guide to Library",
diff --git a/crates/ui-egui/src/panel_docking/native_tests.rs b/crates/ui-egui/src/panel_docking/native_tests.rs
index 2f1d0d536c..368f7ebae8 100644
--- a/crates/ui-egui/src/panel_docking/native_tests.rs
+++ b/crates/ui-egui/src/panel_docking/native_tests.rs
@@ -1039,6 +1039,9 @@ fn ui_docking_leaves_out_the_controls_of_os_windows() {
 #[test]
 fn wheel_over_a_floating_character_font_field_changes_the_font() {
     let mut h = Harness::new();
+    // The later turns step to whichever families the process has loaded, test fonts without Latin
+    // glyphs included. Missing glyph protection would keep the text in its previous font.
+    h.app.run("prefs.set", json!({"key": "missingGlyphProtection", "value": false})).unwrap();
     h.app.run("text.create", json!({"x": 30, "y": 50, "text": "Hi", "font": "Source Sans 3"})).unwrap();
     let viewport = h.float("character");
     let field = h
diff --git a/crates/ui-egui/src/panels.rs b/crates/ui-egui/src/panels.rs
index 62538d8f2f..71019385b6 100644
--- a/crates/ui-egui/src/panels.rs
+++ b/crates/ui-egui/src/panels.rs
@@ -123,7 +123,8 @@ fn corner_fields(app: &mut VectorcraftApp, ui: &mut Ui, n: &Node, id: &str, widt
         for (k, label) in rectangle_corners() {
             dim_label(ui, label);
             if let Some(v) = crate::widgets::num_field_named(ui, (id, "corner", k), Some(label), Some(lc.radius(k)), unit, width) {
-                app.run("object.setLiveShape", json!({"radius": v, "corners": [k]})).ok();
+                // A negative radius typed in rounds nothing: the command takes 0 or more.
+                app.run("object.setLiveShape", json!({"radius": v.max(0.0), "corners": [k]})).ok();
             }
             ui.end_row();
         }
@@ -133,7 +134,7 @@ fn corner_fields(app: &mut VectorcraftApp, ui: &mut Ui, n: &Node, id: &str, widt
 /// [`corner_radius_row`]'s field, `width` wide.
 pub(crate) fn corner_radius_field(app: &mut VectorcraftApp, ui: &mut Ui, n: &Node, id: impl std::hash::Hash + std::fmt::Debug, width: f32) {
     if let Some(r) = crate::widgets::num_field(ui, id, corner_radius(app, n), app.session.general_unit(), width) {
-        app.run("object.setLiveShape", json!({"radius": r})).ok();
+        app.run("object.setLiveShape", json!({"radius": r.max(0.0)})).ok();
     }
 }
 
diff --git a/crates/ui-egui/src/panels/character.rs b/crates/ui-egui/src/panels/character.rs
index c7a3e818cd..44ae643e86 100644
--- a/crates/ui-egui/src/panels/character.rs
+++ b/crates/ui-egui/src/panels/character.rs
@@ -264,6 +264,24 @@ pub(crate) fn shared_tcy_offsets(app: &VectorcraftApp) -> (Option<f64>, Option<f
     (shared_effective(app, |s| s.tcy_up_down), shared_effective(app, |s| s.tcy_left_right))
 }
 
+/// The Warichu Settings the characters the panels act on share: Lines, Line Gap (document
+/// points), Scale (percent) and Alignment; `None` for each that differs, or with no type.
+pub(crate) struct SharedWarichu {
+    pub lines: Option<u8>,
+    pub gap: Option<f64>,
+    pub scale: Option<f64>,
+    pub align: Option<vectorcraft_doc::WarichuAlign>,
+}
+
+pub(crate) fn shared_warichu(app: &VectorcraftApp) -> SharedWarichu {
+    SharedWarichu {
+        lines: shared(app, |s| s.warichu_lines),
+        gap: shared_effective(app, |s| s.warichu_gap),
+        scale: shared(app, |s| s.warichu_scale),
+        align: shared(app, |s| s.warichu_align),
+    }
+}
+
 /// Apply character attributes: to the selected range while the Type tool edits text (the whole
 /// object when nothing is selected), else to the selected text objects.
 fn char_cmd(app: &mut VectorcraftApp, cmd: &str, p: Value) {
@@ -1503,6 +1521,18 @@ pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
         {
             app.status(e);
         }
+        // Warichu: the selected characters set smaller and stacked on lines inside their line.
+        // Checked when every selected character has it; a mixed selection turns it on.
+        let warichu = shared(app, |s| s.warichu) == Some(true);
+        if menu_item(ui, tl!("Warichu"), has, warichu) {
+            format(app, json!({"warichu": !warichu}));
+        }
+        // Warichu Settings…: the Lines, Line Gap, Scale and Alignment of a warichu block.
+        if menu_item(ui, tl!("Warichu Settings…"), has, false)
+            && let Err(e) = app.run("ui.warichuSettings", json!({}))
+        {
+            app.status(e);
+        }
         // Standard Vertical Roman Alignment: the selected half-width characters stand upright in
         // vertical type instead of being rotated. Checked when every selected character has it; a
         // mixed selection turns it on.
@@ -1580,8 +1610,9 @@ fn fractional_widths_on(app: &VectorcraftApp) -> bool {
 /// method, and the characters the panel acts on ([`char_cmd`]) take tracking 0, Auto leading and
 /// kerning, no baseline shift, 100% scales, no rotation, no underline or strikethrough, All Caps
 /// and Small Caps off, the normal position (neither superscript nor subscript), Roman Baseline
-/// character alignment, Proportional Metrics, Tate-chu-yoko, Standard Vertical Roman Alignment and
-/// No Break off, Tate-chu-yoko Settings Up/Down and Left/Right 0, Insert Aki Left and Right 0, the Default character direction,
+/// character alignment, Proportional Metrics, Tate-chu-yoko, Warichu, Standard Vertical Roman Alignment and
+/// No Break off, Tate-chu-yoko Settings Up/Down and Left/Right 0, the default Warichu Settings (2 lines, no
+/// line gap, 50%, Auto alignment), Insert Aki Left and Right 0, the Default character direction,
 /// Kashidas on, the Default digits and the Em Box font height reference, whether or not Show East Asian
 /// Options, Show Indic Options and Show Font Height Options are on. Inside an undo group that is
 /// already open, the reset is part of that group's step.
@@ -1601,6 +1632,8 @@ fn reset_panel(app: &mut VectorcraftApp) {
             "allCaps": false, "smallCaps": d.small_caps.is_some(), "position": d.position.id(), "charAlign": d.char_align,
             "proportionalMetrics": d.proportional_metrics, "tateChuYoko": d.tate_chu_yoko,
             "tcyUpDown": d.tcy_up_down, "tcyLeftRight": d.tcy_left_right, "akiLeft": d.aki_left, "akiRight": d.aki_right,
+            "warichu": d.warichu, "warichuLines": d.warichu_lines, "warichuGap": d.warichu_gap, "warichuScale": d.warichu_scale,
+            "warichuAlign": d.warichu_align,
             "standardVerticalRoman": d.standard_vertical_roman, "noBreak": d.no_break, "charDirection": "default", "kashidas": d.kashidas,
             "digits": d.digits, "fontHeightReference": d.font_height_reference
         }),
diff --git a/crates/ui-egui/src/panels/character/tests.rs b/crates/ui-egui/src/panels/character/tests.rs
index dd4b12adf5..7a2a96efb2 100644
--- a/crates/ui-egui/src/panels/character/tests.rs
+++ b/crates/ui-egui/src/panels/character/tests.rs
@@ -996,6 +996,43 @@ fn tate_chu_yoko_settings_menu_item_shows_with_east_asian_options_and_opens_the_
     assert_eq!(app.ui.dialog.as_ref().map(|d| d.kind.as_str()), Some(crate::dialogs::tate_chu_yoko::KIND));
 }
 
+/// Warichu and Warichu Settings… are in the panel menu with the East Asian options: Warichu marks
+/// the selected characters and takes the mark off again, one undo step each way, and Warichu
+/// Settings… opens the dialog on them.
+#[test]
+fn warichu_menu_items_show_with_east_asian_options_toggle_and_open_the_settings() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.run("file.new", json!({"width": 300, "height": 200})).unwrap();
+    let id = app.session.execute("text.create", &json!({"x": 20, "y": 50, "text": "abcd"})).unwrap()["id"].as_u64().unwrap();
+    app.session.execute("select.set", &json!({"ids": [id]})).unwrap();
+    let ctx = egui::Context::default();
+    let painted = |app: &mut VectorcraftApp| crate::tests_labels::painted_text(app, menu);
+    assert!(!painted(&mut app).contains("Warichu"));
+    app.session.prefs.show_east_asian_options = true;
+    let on = |app: &VectorcraftApp| match &app.session.active().unwrap().doc.node(NodeId(id)).unwrap().kind {
+        NodeKind::Text(t) => t.runs.iter().all(|r| r.style.warichu),
+        _ => panic!("text"),
+    };
+    let undo = |app: &VectorcraftApp| app.session.doc().unwrap().history.undo.len();
+    let before = undo(&app);
+    let find = |ctx: &egui::Context, app: &mut VectorcraftApp, label: &str| {
+        let texts = super::super::tests_appearance::frame_events(ctx, app, vec![], menu);
+        texts.iter().find(|(t, _)| t.trim_start_matches(['✓', ' ']) == label).unwrap_or_else(|| panic!("{texts:?}")).1
+    };
+    let at = find(&ctx, &mut app, "Warichu");
+    super::super::tests_appearance::click(&ctx, &mut app, at.center(), menu);
+    assert!(on(&app));
+    assert_eq!(undo(&app), before + 1);
+    assert!(painted(&mut app).contains("✓ Warichu"));
+    let at = find(&ctx, &mut app, "Warichu");
+    super::super::tests_appearance::click(&ctx, &mut app, at.center(), menu);
+    assert!(!on(&app));
+    assert_eq!(undo(&app), before + 2);
+    let at = find(&ctx, &mut app, "Warichu Settings…");
+    super::super::tests_appearance::click(&ctx, &mut app, at.center(), menu);
+    assert_eq!(app.ui.dialog.as_ref().map(|d| d.kind.as_str()), Some(crate::dialogs::warichu::KIND));
+}
+
 /// Standard Vertical Roman Alignment is in the panel menu with the East Asian options. Choosing it
 /// marks the selected characters, one undo step each way; its check shows only while every
 /// selected character has it, and a mixed selection turns it on.
diff --git a/crates/ui-egui/src/panels/doc_info.rs b/crates/ui-egui/src/panels/doc_info.rs
index 1d4db19979..64144a2150 100644
--- a/crates/ui-egui/src/panels/doc_info.rs
+++ b/crates/ui-egui/src/panels/doc_info.rs
@@ -72,16 +72,15 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
             if rows.is_empty() {
                 widgets::dim_label(ui, tl!("None"));
             }
-            let named = named_rows(s["id"].as_str().unwrap_or_default(), rows);
+            let id = s["id"].as_str().unwrap_or_default();
+            let named = named_rows(id, rows);
             for (k, r) in rows.iter().enumerate() {
                 let (label, value) = (r[0].as_str().unwrap_or_default(), r[1].as_str().unwrap_or_default());
-                let label = super::label_or_name(label, !named.contains(&k));
                 if value.is_empty() {
-                    widgets::dim_name(ui, label);
-                } else if s["id"] == "brushes" {
-                    row(ui, label, brush_value(value).into());
+                    widgets::dim_name(ui, super::label_or_name(label, !named.contains(&k)));
                 } else {
-                    row(ui, label, value.into());
+                    let shown = shown_value(&i, id, k, (label, value), named.contains(&k)).unwrap_or_else(|| value.to_string());
+                    row(ui, super::label_or_name(label, !named.contains(&k)), shown);
                 }
             }
         }
@@ -102,6 +101,127 @@ fn brush_value(value: &str) -> &str {
     }
 }
 
+/// Row `k` of Document Info section `id` (`label` and `value` as `document.info` gives them, the
+/// label a name when `named`) with its value in the interface language, built from what
+/// `document.info` (`info`) gives as values: the
+/// units, the raster effects resolution, each brush's type, each font's file, match and
+/// embedding permission, each image's size and file, each Repeat object's kind and counts, and the
+/// kinds of the gradients no swatch names. Names (fonts, files, faces, swatches) stay as they are.
+/// None when the row's value is shown as `document.info` gives it, or the values do not match the
+/// row.
+fn shown_value(info: &Value, id: &str, k: usize, (label, value): (&str, &str), named: bool) -> Option<String> {
+    let entry = |list: &str| info[list].get(k).filter(|e| e["name"] == label || e["font"] == label);
+    match id {
+        "document" if !named => match label {
+            "Units" => {
+                let unit = info["document"]["unitId"].as_str()?;
+                vectorcraft_doc::Unit::EAST_ASIAN.into_iter().find(|u| u.key() == unit).map(|u| tl!(u.label()).to_string())
+            }
+            "Raster Effects" => {
+                let ppi = info["document"]["rasterEffectsPpi"].as_f64()?;
+                Some(fill(tl!("{n} ppi"), &[("n", &ppi.to_string())]))
+            }
+            _ => None,
+        },
+        "brushes" => Some(brush_value(value).to_string()),
+        "fontDetails" => font_detail_value(entry("fontDetails")?),
+        "linkedImages" | "embeddedImages" => {
+            let linked = id == "linkedImages";
+            let image = info["imageObjects"].as_array()?.iter().filter(|o| o["linked"] == linked).nth(k).filter(|o| o["name"] == label)?;
+            image_value(image)
+        }
+        "repeats" => repeat_value(entry("repeatObjects")?),
+        "gradients" => gradient_value(entry("gradientObjects")?),
+        _ => None,
+    }
+}
+
+/// [`crate::i18n::fill_once`]: a name that holds `{…}` text stays as it is.
+fn fill(template: &str, args: &[(&str, &str)]) -> String {
+    crate::i18n::fill_once(template, args)
+}
+
+/// A `fontDetails` entry as Font Details shows it: the font's file (or that it is built in) and
+/// what its license allows, the face shown in place of a style the family lacks, the face shown in
+/// place of a font that is not installed, or that it is missing.
+fn font_detail_value(e: &Value) -> Option<String> {
+    let found = || {
+        let embedding = match e["embedding"].as_str()? {
+            "forbidden" => tl!("embedding not allowed"),
+            "editing" => tl!("embedding for editing"),
+            "previewPrint" => tl!("embedding for preview and print"),
+            "allowed" => tl!("embedding allowed"),
+            _ => return None,
+        };
+        let file = e["file"].as_str().unwrap_or(tl!("built in"));
+        Some(fill(tl!("{file}; {embedding}"), &[("file", file), ("embedding", embedding)]))
+    };
+    let face = || Some((e["family"].as_str()?, e["style"].as_str()?));
+    match e["match"].as_str()? {
+        "exact" => found(),
+        "style" => {
+            let ((family, style), detail) = (face()?, found()?);
+            Some(fill(tl!("substituted: shown in {family} {style} ({detail})"), &[("family", family), ("style", style), ("detail", &detail)]))
+        }
+        "missingWithFallback" => {
+            let (family, style) = face()?;
+            Some(fill(tl!("missing: shown in {family} {style}"), &[("family", family), ("style", style)]))
+        }
+        "missing" => Some(tl!("missing").to_string()),
+        _ => None,
+    }
+}
+
+/// An `imageObjects` entry as Linked Images and Embedded Images show it: its size in pixels, and
+/// for a linked image the file it shows.
+fn image_value(o: &Value) -> Option<String> {
+    let size = fill(tl!("{width} × {height} px"), &[("width", &o["width"].as_u64()?.to_string()), ("height", &o["height"].as_u64()?.to_string())]);
+    if o["linked"] == true { Some(fill(tl!("{size} — {file}"), &[("size", &size), ("file", o["file"].as_str()?)])) } else { Some(size) }
+}
+
+/// A `repeatObjects` entry as Repeat Objects shows it: its kind and the number of instances it
+/// draws, or for a grid its rows and columns, followed by the number it draws when that is fewer.
+fn repeat_value(e: &Value) -> Option<String> {
+    let kind = match e["type"].as_str()? {
+        "radial" => tl!("Radial Repeat"),
+        "grid" => tl!("Grid Repeat"),
+        "mirror" => tl!("Mirror Repeat"),
+        _ => return None,
+    };
+    let n = e["instances"].as_u64()?;
+    let instances = crate::i18n::tn(n, "{n} instance", "{n} instances");
+    if e["type"] != "grid" {
+        return Some(fill(tl!("{kind}, {instances}"), &[("kind", kind), ("instances", &instances)]));
+    }
+    let (rows, cols) = (e["rows"].as_u64()?, e["cols"].as_u64()?);
+    let (shown_rows, shown_cols) = (crate::i18n::tn(rows, "{n} row", "{n} rows"), crate::i18n::tn(cols, "{n} column", "{n} columns"));
+    let grid = fill(tl!("{kind}, {rows} × {cols}"), &[("kind", kind), ("rows", &shown_rows), ("cols", &shown_cols)]);
+    Some(if n < rows.saturating_mul(cols) { fill(tl!("{grid}, {instances}"), &[("grid", &grid), ("instances", &instances)]) } else { grid })
+}
+
+/// A `gradientObjects` entry as Gradient Objects shows it: its gradients, a swatch's name as it
+/// is and a gradient named by its kind in the interface language.
+fn gradient_value(e: &Value) -> Option<String> {
+    let (names, kinds) = (e["gradients"].as_array()?, e["kinds"].as_array()?);
+    if names.len() != kinds.len() {
+        return None;
+    }
+    let shown: Option<Vec<&str>> = names
+        .iter()
+        .zip(kinds)
+        .map(|(name, kind)| match kind.as_str() {
+            None => name.as_str(),
+            Some("linear") => Some(tl!("Linear gradient")),
+            Some("radial") => Some(tl!("Radial gradient")),
+            Some("conic") => Some(tl!("Conic gradient")),
+            Some("diamond") => Some(tl!("Diamond gradient")),
+            Some("freeform") => Some(tl!("Freeform gradient")),
+            Some(_) => name.as_str(),
+        })
+        .collect();
+    Some(shown?.join(", "))
+}
+
 /// The rows of Document Info section `id` labelled by a name (an artboard, a style, a swatch, a
 /// font, an image, a repeat object) rather than an interface label: every row of the lists, and in Document the
 /// artboards, which follow the Artboards count. Names are shown as they are.
@@ -337,4 +457,130 @@ mod tests {
         let report = app.session.execute("document.info", &json!({"category": "brushes", "format": "text"})).unwrap()["text"].to_string();
         assert!(report.contains("Charcoal: Art Brush"), "{report}");
     }
+
+    /// Section `id`'s rows as the panel shows them for `info`: each label and its shown value.
+    fn shown_rows(info: &Value, id: &str) -> Vec<(String, String)> {
+        let section = info["sections"].as_array().unwrap().iter().find(|s| s["id"] == id).unwrap_or_else(|| panic!("no {id}"));
+        let rows = section["rows"].as_array().unwrap();
+        let named = named_rows(id, rows);
+        rows.iter()
+            .enumerate()
+            .map(|(k, r)| {
+                let (label, value) = (r[0].as_str().unwrap(), r[1].as_str().unwrap());
+                (label.to_string(), shown_value(info, id, k, (label, value), named.contains(&k)).unwrap_or_else(|| value.to_string()))
+            })
+            .collect()
+    }
+
+    /// The values Document Info makes (the units, the raster effects resolution, each font's file
+    /// and state, each image's size, each Repeat object's kind and counts, and gradients named by
+    /// their kind) show in the interface language, from the same `document.info` after a language
+    /// change; font, face, file and swatch names stay as they are, also with Selection Only, and
+    /// `document.info` and the saved report stay in English.
+    #[test]
+    fn values_follow_interface_language_and_keep_names() {
+        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 400, "height": 400, "units": "Millimeters"})).unwrap();
+        app.session.execute("text.create", &json!({"x": 10, "y": 40, "text": "Hi"})).unwrap();
+        app.session.execute("text.create", &json!({"x": 10, "y": 80, "text": "Heavy", "font": "Source Sans 3", "style": "Black Wide"})).unwrap();
+        app.session.execute("text.create", &json!({"x": 10, "y": 120, "text": "Gone", "font": "Qx Absent Family"})).unwrap();
+        let rect = |app: &mut VectorcraftApp, x: f64| {
+            app.session.execute("shape.rectangle", &json!({"x": x, "y": 200, "width": 20, "height": 10})).unwrap()["id"].clone()
+        };
+        let ramp = |kind: &str| json!({"kind": kind, "stops": [{"offset": 0, "color": "#000"}, {"offset": 1, "color": "#fff"}]});
+        app.session.execute("swatch.new", &json!({"name": "Linear gradient", "gradient": ramp("radial")})).unwrap();
+        let glow = rect(&mut app, 0.0);
+        app.session.execute("paint.setFill", &json!({"ids": [glow], "swatch": "Linear gradient"})).unwrap();
+        app.session.execute("paint.setStroke", &json!({"ids": [glow], "gradient": ramp("radial")})).unwrap();
+        app.session.execute("layer.setProps", &json!({"id": glow, "name": "Glow"})).unwrap();
+        let star = rect(&mut app, 50.0);
+        app.session.execute("object.repeat.radial", &json!({"ids": [star], "instances": 6})).unwrap();
+        let tile = rect(&mut app, 100.0);
+        app.session.execute("object.repeat.grid", &json!({"ids": [tile], "rows": 2, "cols": 1})).unwrap();
+        let pic = rect(&mut app, 150.0);
+        app.session.execute("select.set", &json!({"ids": [pic]})).unwrap();
+        app.session.execute("object.rasterize", &json!({"ppi": 72})).unwrap();
+        app.session.execute("select.set", &json!({"ids": []})).unwrap();
+        let info = app.session.execute("document.info", &json!({})).unwrap();
+        let value = |rows: &[(String, String)], label: &str| {
+            rows.iter().find(|(l, _)| l == label).unwrap_or_else(|| panic!("no {label} in {rows:?}")).1.clone()
+        };
+        let english = |id: &str| shown_rows(&info, id);
+        assert_eq!((value(&english("document"), "Units"), value(&english("document"), "Raster Effects")), ("Millimeters".into(), "72 ppi".into()));
+        assert_eq!(value(&english("fontDetails"), "Source Sans 3 Regular"), "built in; embedding allowed");
+        assert_eq!(value(&english("gradients"), "Glow"), "Linear gradient, Radial gradient");
+        let repeats = english("repeats");
+        assert_eq!((repeats[0].1.as_str(), repeats[1].1.as_str()), ("Radial Repeat, 6 instances", "Grid Repeat, 2 rows × 1 column"));
+        // Every value the panel builds reads as `document.info`'s English row.
+        for s in info["sections"].as_array().unwrap() {
+            let id = s["id"].as_str().unwrap();
+            let rows: Vec<(String, String)> =
+                s["rows"].as_array().unwrap().iter().map(|r| (r[0].as_str().unwrap().into(), r[1].as_str().unwrap().into())).collect();
+            assert_eq!(shown_rows(&info, id), rows, "{id}");
+        }
+        let Some(de) = crate::i18n::Lang::from_code("de") else { panic!("no German catalog") };
+        crate::i18n::set_current(de);
+        let german = |id: &str| shown_rows(&info, id);
+        let (document, fonts, images, gradients, repeats) =
+            (german("document"), german("fontDetails"), german("embeddedImages"), german("gradients"), german("repeats"));
+        let painted = crate::tests_labels::painted_text(&mut app, show);
+        app.session.execute("select.set", &json!({"ids": [glow]})).unwrap();
+        let selected = shown_rows(&app.session.execute("document.info", &json!({"selectionOnly": true})).unwrap(), "gradients");
+        let written: std::rc::Rc<std::cell::RefCell<Vec<u8>>> = Default::default();
+        let w = written.clone();
+        app.services.write = Some(Box::new(move |_: &str, b: &[u8]| {
+            w.borrow_mut().extend_from_slice(b);
+            Ok(())
+        }));
+        app.run("docInfo.save", json!({"path": "/tmp/info.txt", "category": "gradients", "selectionOnly": true})).unwrap();
+        crate::i18n::set_current(crate::i18n::Lang::EN);
+        let saved = String::from_utf8(written.borrow().clone()).unwrap();
+        assert_eq!((value(&document, "Units"), value(&document, "Raster Effects")), ("Millimeter".into(), "72 ppi".into()));
+        assert!(painted.contains("Millimeter") && !painted.contains("Millimeters"), "{painted}");
+        assert_eq!(value(&fonts, "Source Sans 3 Regular"), "integriert; Einbetten erlaubt");
+        let wide = value(&fonts, "Source Sans 3 Black Wide");
+        assert!(wide.starts_with("ersetzt: angezeigt in Source Sans 3 ") && wide.ends_with("Einbetten erlaubt)"), "{wide}");
+        let gone = fonts.iter().find(|(l, _)| l.starts_with("Qx Absent Family")).unwrap_or_else(|| panic!("{fonts:?}")).1.clone();
+        assert!(gone == "fehlt" || gone.starts_with("fehlt: angezeigt in "), "{gone}");
+        assert_eq!(images.len(), 1);
+        assert!(images[0].1.ends_with(" px") && images[0].1.contains(" × "), "{images:?}");
+        // A swatch named like a kind keeps its name; the gradient named by its kind is translated.
+        assert_eq!(value(&gradients, "Glow"), "Linear gradient, Radialer Verlauf");
+        assert_eq!(value(&selected, "Glow"), "Linear gradient, Radialer Verlauf");
+        assert_eq!((repeats[0].1.as_str(), repeats[1].1.as_str()), ("Radiale Wiederholung, 6 Instanzen", "Rasterwiederholung, 2 Zeilen × 1 Spalte"));
+        assert!(saved.contains("(the selection only)") && saved.contains("\nGRADIENT OBJECTS\nGlow: Linear gradient, Radial gradient\n"), "{saved}");
+        let report = app.session.execute("document.info", &json!({"format": "text"})).unwrap()["text"].as_str().unwrap().to_string();
+        assert!(report.contains("Units: Millimeters\n") && report.contains("Radial Repeat, 6 instances"), "{report}");
+    }
+
+    /// A Repeat object's counts take each language's plural forms, and a grid that draws fewer
+    /// instances than its rows and columns give is followed by the number it draws.
+    #[test]
+    fn repeat_value_uses_locale_plural_forms_and_drawn_count() {
+        let radial = |n: u64| json!({"name": "R", "type": "radial", "instances": n});
+        let grid = json!({"name": "G", "type": "grid", "rows": 500, "cols": 500, "instances": 125_000});
+        let in_lang = |code: &str, e: &Value| {
+            let Some(lang) = crate::i18n::Lang::from_code(code) else { panic!("no {code} catalog") };
+            crate::i18n::set_current(lang);
+            let shown = repeat_value(e);
+            crate::i18n::set_current(crate::i18n::Lang::EN);
+            shown.unwrap_or_else(|| panic!("{e}"))
+        };
+        assert_eq!(in_lang("en", &radial(1)), "Radial Repeat, 1 instance");
+        assert_eq!(in_lang("en", &grid), "Grid Repeat, 500 rows × 500 columns, 125000 instances");
+        assert_eq!(
+            [1, 3, 5, 21].map(|n| in_lang("ru", &radial(n))),
+            [
+                "Радиальный повтор, 1 экземпляр",
+                "Радиальный повтор, 3 экземпляра",
+                "Радиальный повтор, 5 экземпляров",
+                "Радиальный повтор, 21 экземпляр"
+            ]
+        );
+        assert_eq!(in_lang("ru", &grid), "Повтор сеткой, 500 строк × 500 столбцов, 125000 экземпляров");
+        assert_eq!([1, 2].map(|n| in_lang("ja", &radial(n))), ["ラジアルリピート、インスタンス 1 個", "ラジアルリピート、インスタンス 2 個"]);
+        // A full grid shows its rows and columns alone; an unknown kind is shown as `document.info` gives it.
+        assert_eq!(in_lang("de", &json!({"type": "grid", "rows": 1, "cols": 3, "instances": 3})), "Rasterwiederholung, 1 Zeile × 3 Spalten");
+        assert_eq!(repeat_value(&json!({"type": "spiral", "instances": 2})), None);
+    }
 }
diff --git a/crates/ui-egui/src/panels/transform.rs b/crates/ui-egui/src/panels/transform.rs
index dc1e695481..b759a2df7b 100644
--- a/crates/ui-egui/src/panels/transform.rs
+++ b/crates/ui-egui/src/panels/transform.rs
@@ -448,7 +448,7 @@ pub(crate) fn polygon_rows(app: &mut VectorcraftApp, ui: &mut Ui, n: &Node, live
     let mut set = None;
     egui::Grid::new((id, "grid")).num_columns(2).spacing([6.0, 6.0]).show(ui, |ui| {
         widgets::dim_label(ui, tl!("Sides:"));
-        if let Some(s) = widgets::range_field_named(ui, (id, "sides"), Some(tl!("Sides:")), f64::from(*sides), 3.0..=f64::INFINITY, "", 0, fw) {
+        if let Some(s) = widgets::range_field_named(ui, (id, "sides"), Some(tl!("Sides:")), f64::from(*sides), 3.0..=1000.0, "", 0, fw) {
             set = Some(("sides", json!(s as u64)));
         }
         ui.end_row();
diff --git a/crates/ui-egui/src/recovery.rs b/crates/ui-egui/src/recovery.rs
index f6188babca..3b05ba0120 100644
--- a/crates/ui-egui/src/recovery.rs
+++ b/crates/ui-egui/src/recovery.rs
@@ -26,8 +26,14 @@ pub struct Timer {
     last: Option<f64>,
     /// When the heartbeat was last refreshed (app time, s).
     beat: f64,
+    /// The recovery folders that failure messages named, latest last, at most [`NAMED`]: replies to
+    /// automation clients hide those outside their read roots.
+    pub named: Vec<String>,
 }
 
+/// How many recovery folders [`Timer::named`] keeps.
+const NAMED: usize = 8;
+
 /// Each frame: the startup question once no other dialog is open, the timer and the heartbeat
 /// (`now`: app time in seconds) → in how many seconds they want the next frame (none while Data Recovery is off).
 pub fn frame(app: &mut VectorcraftApp, now: f64) -> Option<f64> {
@@ -94,34 +100,92 @@ pub fn tick(app: &mut VectorcraftApp, now: f64) -> usize {
 /// were started.
 fn write(app: &mut VectorcraftApp, store: &Arc<dyn RecoveryStore>, pick: impl Fn(u64) -> bool) -> usize {
     recovery::forget_clean(&mut app.session);
+    // The folder `store` writes to, named in a failure even when the preference changes meanwhile.
+    let place = recovery::folder(&app.session);
     let jobs = match recovery::jobs(&mut app.session, store) {
         // A document whose save or last copy is still being written waits for the next round.
         Ok((jobs, _)) => jobs.into_iter().filter(|j| pick(j.uid) && !app.background.busy_with(j.uid)).collect::<Vec<_>>(),
         Err(e) => {
-            app.status(format!("Couldn't save recovery data: {e}"));
+            failed(app, place.as_ref(), &e.to_string());
             return 0;
         }
     };
     let mut started = 0;
     for job in jobs {
         let (uid, label, title) = (job.uid, format!("Saving recovery data for {}", job.title), job.title.clone());
-        let done = job.clone();
+        let (done, at, saving) = (job.clone(), place.clone(), label.clone());
         let work = move |_: Writer| job.write();
-        let then = move |app: &mut VectorcraftApp, r: Result<Value, String>| {
-            let r = r?;
-            done.finish(&mut app.session);
-            app.status(format!("Saved recovery data for {title}"));
-            Ok(r)
+        // A failure is reported here, so the job's result is not an error: that would show as
+        // "<label> failed: <error>" over this line, or as the round's message when it ran here.
+        let then = move |app: &mut VectorcraftApp, r: Result<Value, String>| match (r, at) {
+            (Ok(r), _) => {
+                done.finish(&mut app.session);
+                app.status(format!("Saved recovery data for {title}"));
+                Ok(r)
+            }
+            (Err(e), Some(at)) => {
+                copy_failed(app, &title, &at, &e);
+                Ok(Value::Null)
+            }
+            // A store the host installed has no folder to name: the job's own line.
+            (Err(e), None) => {
+                app.status(format!("{saving} failed: {e}"));
+                log::warn!("vectorcraft: {}", app.ui.status);
+                Ok(Value::Null)
+            }
         };
         // Its own store, not the file writer: this only decides whether it runs on the worker.
         if let Err(e) = background::run(app, true, label, Some(uid), work, then) {
-            app.status(format!("Couldn't save recovery data: {e}"));
+            failed(app, place.as_ref(), &e);
         }
         started += 1;
     }
     started
 }
 
+/// Report a recovery round that couldn't start (error `e`) in the status bar and the log, with
+/// the recovery folder in use (`place`, from [`recovery::folder`]) and whether the preference or
+/// the app set it.
+fn failed(app: &mut VectorcraftApp, place: Option<&(String, bool)>, e: &str) {
+    match place {
+        Some((folder, true)) => app.status(format!(
+            "Couldn't save recovery data: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)"
+        )),
+        Some((folder, false)) => app.status(format!(
+            "Couldn't save recovery data: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)"
+        )),
+        None => app.status(format!("Couldn't save recovery data: {e}")),
+    }
+    if let Some((folder, _)) = place {
+        named(app, folder);
+    }
+    log::warn!("vectorcraft: {}", app.ui.status);
+}
+
+/// [`failed`] for the copy of document `title` that couldn't be written to folder `place`.
+fn copy_failed(app: &mut VectorcraftApp, title: &str, place: &(String, bool), e: &str) {
+    match place {
+        (folder, true) => app.status(format!(
+            "Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the folder set in Preferences; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)"
+        )),
+        (folder, false) => app.status(format!(
+            "Couldn't save recovery data for {title}: {e}. Copies go to {folder}, the default recovery folder; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)"
+        )),
+    }
+    named(app, &place.0);
+    log::warn!("vectorcraft: {}", app.ui.status);
+}
+
+/// Record that the status text named recovery folder `folder` ([`Timer::named`]).
+fn named(app: &mut VectorcraftApp, folder: &str) {
+    let named = &mut app.recovery.named;
+    named.retain(|f| f != folder);
+    named.push(folder.to_string());
+    if named.len() > NAMED {
+        named.remove(0);
+    }
+}
+
 /// The startup dialog's OK (Restore) or Discard: every copy it lists.
 pub fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
     app.ui.dialog = None;
@@ -133,7 +197,7 @@ pub fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
         match app.run(id, json!({ "file": file })) {
             Ok(r) => {
                 if let Some(restored) = r["restored"].as_array().and_then(|v| v.first()) {
-                    crate::dialogs::missing_links::after_open(app, restored);
+                    crate::dialogs::missing_links::after_open(app, restored, Vec::new());
                 }
                 done.push(r);
             }
diff --git a/crates/ui-egui/src/tests/font_menu.rs b/crates/ui-egui/src/tests/font_menu.rs
index 7ab5378e14..2c600d1aa3 100644
--- a/crates/ui-egui/src/tests/font_menu.rs
+++ b/crates/ui-egui/src/tests/font_menu.rs
@@ -1031,8 +1031,15 @@ fn open_menu_with(id: &str, left: f32, width: f32, screen: egui::Vec2, look: Men
     for _ in 0..if tokens.is_some() { 15 } else { 5 } {
         frame(vec![]);
     }
-    crate::font_menu::wait_for_samples(&ctx);
-    let shapes = frame(vec![]);
+    // A frame starts only a few samples, and none while several are rendering: draw until a frame
+    // leaves none rendering, so that frame drew every shown row's sample.
+    let mut shapes = frame(vec![]);
+    let mut frames = 0;
+    while crate::font_menu::wait_for_samples(&ctx) {
+        frames += 1;
+        assert!(frames < 1000, "the menu's samples are still rendering after {frames} frames");
+        shapes = frame(vec![]);
+    }
     let mut texts = vec![];
     let mut samples = vec![];
     let mut tints = vec![];
diff --git a/crates/ui-egui/src/tests/recovery.rs b/crates/ui-egui/src/tests/recovery.rs
index 806903148f..00ccb59b79 100644
--- a/crates/ui-egui/src/tests/recovery.rs
+++ b/crates/ui-egui/src/tests/recovery.rs
@@ -177,6 +177,131 @@ fn the_timer_asks_for_frames_while_idle() {
     assert!(recovery::frame(&mut app, 1.0).is_none());
 }
 
+/// The end of a failed recovery round's status line: how to use another folder.
+const TO_DO: &str = "; to use another folder, set Preferences → File Handling → Data Recovery → Folder (recoveryFolder)";
+
+/// An app keeping its copies in `folder` (the folder the app sets) or the one the preference
+/// names, with a modified document, a recovery round every 2 minutes and the clock started.
+fn app_in_folder(folder: &str, services: Services) -> VectorcraftApp {
+    let mut app = VectorcraftApp::new(Session::new(), services);
+    app.session.recovery.set_default_folder(Some(folder.to_string()));
+    app.run("file.new", json!({"width": 200, "height": 100})).unwrap();
+    app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 20})).unwrap();
+    app.session.prefs.autosave_interval = 2;
+    recovery::tick(&mut app, 0.0);
+    app
+}
+
+/// A fresh empty folder for test `name`.
+fn scratch(name: &str) -> std::path::PathBuf {
+    let dir = std::env::temp_dir().join(format!("vc-ui-recovery-{name}-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    dir
+}
+
+/// A recovery round that can't start names the recovery folder in use, whether the preference or
+/// the app set it, the error, and what to do.
+#[test]
+fn a_round_that_fails_names_the_folder_in_use_and_what_to_do() {
+    let dir = scratch("round");
+    let file = dir.join("not-a-folder");
+    std::fs::write(&file, b"").unwrap();
+    let shown = file.to_string_lossy().into_owned();
+    let mut app = app_in_folder(&shown, Services::default());
+    assert_eq!(recovery::tick(&mut app, 120.0), 0);
+    let start = format!("Couldn't save recovery data: {shown} is not a folder: ");
+    let end = format!(". Copies go to {shown}, the default recovery folder{TO_DO}");
+    assert!(app.ui.status.starts_with(&start) && app.ui.status.ends_with(&end), "{}", app.ui.status);
+    // A preference of spaces is no preference.
+    app.session.prefs.recovery_folder = "  ".into();
+    assert_eq!(recovery::tick(&mut app, 240.0), 0);
+    assert!(app.ui.status.starts_with(&start) && app.ui.status.ends_with(&end), "{}", app.ui.status);
+    app.session.prefs.recovery_folder = format!(" {shown} ");
+    assert_eq!(recovery::tick(&mut app, 360.0), 0);
+    let end = format!(". Copies go to {shown}, the folder set in Preferences{TO_DO}");
+    assert!(app.ui.status.starts_with(&start) && app.ui.status.ends_with(&end), "{}", app.ui.status);
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// A copy that fails on the background worker is reported the same way, not as the job's own
+/// "Saving recovery data for … failed" line.
+#[test]
+fn a_copy_that_fails_in_the_background_names_the_folder_and_what_to_do() {
+    let dir = scratch("copy");
+    let folder = dir.join("recovery");
+    let shown = folder.to_string_lossy().into_owned();
+    let services = Services { write_shared: Some(Arc::new(|_: &str, _: &[u8]| Ok(()))), ..Default::default() };
+    let mut app = app_in_folder(&shown, services);
+    assert_eq!(recovery::tick(&mut app, 120.0), 1);
+    assert_eq!(app.background.jobs.len(), 1, "on the worker");
+    background::wait_all(&mut app);
+    assert_eq!(app.ui.status, "Saved recovery data for Untitled-1");
+    // A folder with a file in it takes the copy's place, so the next copy can't be written.
+    let name = app.session.doc().unwrap().recovery.as_ref().unwrap().file.clone();
+    let copy = folder.join(format!("{name}.vectorcraft"));
+    std::fs::remove_file(&copy).unwrap();
+    std::fs::create_dir(&copy).unwrap();
+    std::fs::write(copy.join("in-the-way"), b"").unwrap();
+    app.run("shape.ellipse", json!({"x": 100, "y": 10, "width": 20, "height": 20})).unwrap();
+    assert_eq!(recovery::tick(&mut app, 240.0), 1);
+    // A folder chosen while the copy runs isn't the one that failed.
+    app.session.prefs.recovery_folder = dir.join("chosen-later").to_string_lossy().into_owned();
+    background::wait_all(&mut app);
+    let end = format!(". Copies go to {shown}, the default recovery folder{TO_DO}");
+    assert!(app.ui.status.starts_with("Couldn't save recovery data for Untitled-1: ") && app.ui.status.ends_with(&end), "{}", app.ui.status);
+    // Kept for replies to automation clients, which hide it outside their read roots.
+    assert_eq!(app.recovery.named, std::slice::from_ref(&shown));
+    drop(app);
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// A store the host installed whose document copies can't be written (other entries, such as
+/// locks, can).
+struct Refusing(MemoryStore);
+
+impl RecoveryStore for Refusing {
+    fn list(&self) -> Result<Vec<String>, String> {
+        self.0.list()
+    }
+    fn read(&self, name: &str) -> Result<Vec<u8>, String> {
+        self.0.read(name)
+    }
+    fn write(&self, name: &str, bytes: &[u8]) -> Result<(), String> {
+        if name.ends_with(".vectorcraft") { Err("the store is full".into()) } else { self.0.write(name, bytes) }
+    }
+    fn remove(&self, name: &str) -> Result<(), String> {
+        self.0.remove(name)
+    }
+    fn location(&self) -> String {
+        self.0.location()
+    }
+    fn lock(&self, area: &str) -> Result<vectorcraft_engine::cmd::recovery::Lock, String> {
+        self.0.lock(area)
+    }
+    fn now(&self) -> Option<i64> {
+        self.0.now()
+    }
+}
+
+/// With a store the host installed there is no folder to name: a copy that fails shows the job's
+/// own line with the document's title, both on the worker and when it is written right away.
+#[test]
+fn a_copy_that_fails_in_a_host_store_names_the_document() {
+    let worker = Services { write_shared: Some(Arc::new(|_: &str, _: &[u8]| Ok(()))), ..Default::default() };
+    for services in [worker, Services::default()] {
+        let store: Arc<dyn RecoveryStore> = Arc::new(Refusing(MemoryStore::default()));
+        let mut app = VectorcraftApp::new(Session::new(), Services { recovery_store: Some(store), ..services });
+        app.run("file.new", json!({"width": 200, "height": 100})).unwrap();
+        app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 20})).unwrap();
+        app.session.prefs.autosave_interval = 2;
+        recovery::tick(&mut app, 0.0);
+        assert_eq!(recovery::tick(&mut app, 120.0), 1);
+        background::wait_all(&mut app);
+        assert_eq!(app.ui.status, "Saving recovery data for Untitled-1 failed: the store is full");
+    }
+}
+
 /// Issue #367: a tab whose timers were paused (in the background) long enough for another tab to
 /// take it for gone and discard its copy writes the copy again on its first heartbeat after it
 /// resumes, even with the timer off (the copy was written by hand).
diff --git a/crates/ui-egui/src/trace_runs.rs b/crates/ui-egui/src/trace_runs.rs
index e05448b10c..3d80c1190a 100644
--- a/crates/ui-egui/src/trace_runs.rs
+++ b/crates/ui-egui/src/trace_runs.rs
@@ -44,7 +44,8 @@ pub struct Running {
     token: CancelToken,
     /// A newer trace of the same object took its place: it ends without a word.
     superseded: bool,
-    /// Colour layers traced and in all (0 while the image is prepared).
+    /// How far the trace has got and in all, as the trace counts it (color layers, or finer steps for Overlapping
+    /// with Fills; 0 in all while the image is prepared).
     steps: Arc<[AtomicU64; 2]>,
     /// The Image Trace panel started it, and takes its result ([`crate::panels::image_trace::traced`]).
     from_panel: bool,
@@ -59,7 +60,7 @@ impl Running {
         !self.hidden && !self.token.is_cancelled()
     }
 
-    /// The share of its colour layers traced, once they are known.
+    /// The share of the trace done, once its steps are known.
     fn fraction(&self) -> Option<f32> {
         let [done, total] = &*self.steps;
         let (done, total) = (done.load(Ordering::Relaxed), total.load(Ordering::Relaxed));
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index c2d4c39b06..45f4d0141b 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -107,7 +107,7 @@ the two can still win that race.
 | `ui.render` | `{path?, scale?, artboard?, data?, traceViews?}` | render an artboard headlessly (PNG with the pixels of `app.export {format: "png", background: "white"}` at the same scale; `artboard`: its 0-based index, default the first; `traceViews: true`: Image Trace objects draw in their View, as on the canvas, instead of their tracing result): written to `path`, else (or with `data: true` as well) sent back as `pngBase64` |
 | `ui.render` | `{path?, scale?, artboard?, data?}` | render an artboard headlessly (PNG with the pixels of `app.export {format: "png", background: "white"}` at the same scale; `artboard`: its 0-based index, default the first): written to `path`, else (or with `data: true` as well) sent back as `pngBase64` |
 | `ui.resize` / `ui.focus` | | |
-| `app.open` / `app.save` / `app.export` / `app.quit` | `{path, importer?, params?}` / `{path?}` / `{path?, format?, artboard?, range?, scale?, …}` | `app.open` reads every format `document.open` reads (see `document.formats`) and returns its result (`{index, title, format, warnings, …}`; `warnings` say what didn't come in as it was, such as an EPS shown as its preview image and why its PostScript couldn't be read), or null when a dialog asks first or a library loads. The status bar (`ui.inspect` → `ui.status`) counts the `warnings` and names the first that says reading the file left something out (the notes that make Save ask before writing over it), else the first; with several, hovering it lists them in that order, as many as fit in the window (at most 30), then how many more. After `app.save`, and `app.export` with a `path`, the status bar counts the reply's `warnings` and names the first, and with several, hovering it lists them in the reply's order (a save's notes start with what the format loses). With `importer` (an importer plug-in's format id, `plugin.<id>`) it runs `file.openWith`: the file opens with that importer, also when a built-in format reads its extension, with the importer's parameters `params` (their defaults when omitted; no dialog asks for them). Without `importer`, `params` go to the importer that opens the file, and a built-in format does not read them. `app.export` encodes through the engine's `document.export` (same options; the document keeps its path) and writes `path` through the host; without `path` it returns `{dataBase64, format, bytes}`, as headless mode does. It refuses a key that no format takes, and an unknown key inside a PDF or EPS option object, before it writes anything (`docs/mcp.md`, Parameter keys). It accepts a key that only another format takes and does not use it: the reply's `warnings` and the status bar name the key ("`quality` was not used: PDF files don't read it"). `app.save` refuses a key that no save format takes, beside the path or in `options`, the same way. `app.quit`, `file.close` and `file.closeAll` first open a `saveChanges` dialog for each modified document (they return `{"pending": "saveChanges"}`): `ui.dialog.confirm` saves, `ui.dialog.set {field: "discard", value: true}` then confirm discards, `ui.dialog.cancel` cancels the whole close or quit |
+| `app.open` / `app.save` / `app.export` / `app.quit` | `{path, importer?, params?}` / `{path?}` / `{path?, format?, artboard?, range?, scale?, …}` | `app.open` reads every format `document.open` reads (see `document.formats`) and returns its result (`{index, title, format, warnings, …}`; `warnings` say what didn't come in as it was, such as an EPS shown as its preview image and why its PostScript couldn't be read), or null when a dialog asks first or a library loads. The status bar (`ui.inspect` → `ui.status`), after a line about the document's linked files when there is one (Missing linked files below), counts the `warnings` and names the first that says reading the file left something out (the notes that make Save ask before writing over it), else the first; with several, hovering it lists them in that order, as many as fit in the window (at most 30), then how many more. After `app.save`, and `app.export` with a `path`, the status bar counts the reply's `warnings` and names the first, and with several, hovering it lists them in the reply's order (a save's notes start with what the format loses). With `importer` (an importer plug-in's format id, `plugin.<id>`) it runs `file.openWith`: the file opens with that importer, also when a built-in format reads its extension, with the importer's parameters `params` (their defaults when omitted; no dialog asks for them). Without `importer`, `params` go to the importer that opens the file, and a built-in format does not read them. `app.export` encodes through the engine's `document.export` (same options; the document keeps its path) and writes `path` through the host; without `path` it returns `{dataBase64, format, bytes}`, as headless mode does. It refuses a key that no format takes, and an unknown key inside a PDF or EPS option object, before it writes anything (`docs/mcp.md`, Parameter keys). It accepts a key that only another format takes and does not use it: the reply's `warnings` and the status bar name the key ("`quality` was not used: PDF files don't read it"). `app.save` refuses a key that no save format takes, beside the path or in `options`, the same way. `app.quit`, `file.close` and `file.closeAll` first open a `saveChanges` dialog for each modified document (they return `{"pending": "saveChanges"}`): `ui.dialog.confirm` saves, `ui.dialog.set {field: "discard", value: true}` then confirm discards, `ui.dialog.cancel` cancels the whole close or quit |
 | `app.export` with `useArtboards` | `{path, useArtboards: true, range? \| artboards?, …}` | Export As: PNG, JPEG and WebP write one file per chosen artboard (default all; SVG does so for a `range`), `<path stem>-<artboard>.<ext>`, and return `{path, files: [path…]}`; a PDF keeps them as pages of `path`. `useArtboards: false` covers the bounds of the visible art. The menu's Export As… is `file.exportAs`: the `exportAs` dialog (`format`, `useArtboards`, `all`, `range`), then a save dialog and the format's options: `pngOptions` / `jpgOptions` / `webpOptions`, `svgOptions`, or `savePdf` for a PDF |
 | `ui.dialog.*` on `gradientStop` | `{field: "color" \| "opacity" \| "location", value}` | double-clicking a stop on the Gradient tool's annotator opens its popover (fields `index`, `x`, `y`, `tab`); set `color` (hex), `opacity` or `location` (percentages) and `ui.dialog.confirm` to apply them to the selected stop. `gradient.selectStop {index}` picks the stop the annotator, the panels and Delete/←/→ (`ui.key`) act on |
 | `engine.execute` `ui.savePdfDialog` | `{path?, preset?, range?, …document.exportPdf options}` | opens the Save PDF dialog (`file.export.pdf` with no params opens it too). Its fields are the `document.exportPdf` options: set `compatibility` with `ui.dialog.set {field: "compatibility", value: "1.5"}`, a whole section with `{field: "compression", value: {…}}`, the artboards with `__allArtboards: false` and `range`, the visible section with `__section` (General, Compression, Marks and Bleeds, Output, Advanced, Security, Summary). `useArtboards: false` opens it for one page of the visible art's bounds, as Export As with Use Artboards off does: the dialog has no Artboards section and its `__artBounds` field is true. `ui.dialog.confirm` writes `path` (else asks for one), returns `{path, bytes, warnings}` and opens the file when `viewAfterSaving` is set. With `useArtboards: false` it writes the page as `app.export` does and returns `{path, warnings}`, or `{background: true, status}` while Background Export writes it |
@@ -648,7 +648,7 @@ agents) opens the `rasterEffectsSettings` dialog. Its fields are what `document.
 
 Missing linked files: `app.open` of a document whose linked images' files can't be found (`document.open`'s
 `missingLinks`) opens the `missingLinks` dialog for the first (fields `missing`: `[{name, path, ids}]`, `modified`,
-`applyToAll`, `path`). `ui.dialog.set {field: "path", value}` then `ui.dialog.confirm` replaces it with that file
+`notes` (the open's `warnings`), `applyToAll`, `path`). `ui.dialog.set {field: "path", value}` then `ui.dialog.confirm` replaces it with that file
 (`links.relink`; without `path` a file is picked), and with `applyToAll` the others are looked for by name in the same
 folder; `ui.dialog.set {field: "discard", value: true}` then confirm ignores it (the images keep their preview), with
 `applyToAll` the rest too. The next missing file is asked about after each answer; `ui.dialog.cancel` stops asking.
@@ -656,11 +656,14 @@ Then, with the preference `updateLinks: "askWhenModified"`, modified linked file
 `confirm` dialog whose `ui.dialog.confirm` runs `links.update`. The same happens when the app's window comes back to
 the front and a linked file of the active document changed meanwhile (asked once per change of a file); with
 `"automatically"` the files are read again at once, with `"manually"` the Links panel shows them as modified.
+After an open, the status bar's line about modified files (with `"manually"`) or, on the web, about files that can't
+be read comes first, followed by the line that counts the open's `warnings`; hovering it lists them as for any open.
+When the line about modified files follows the `missingLinks` dialog, it is followed by that dialog's `notes`.
 
 Find Linked Files: in the `missingLinks` dialog, `ui.dialog.set {field: "searchFolder", value}` then `ui.dialog.confirm`
 is Find in Folder…: the dialog becomes `findLinks`, which looks in that folder and its subfolders for every file the
 dialog still asks about (`links.findFiles`). Fields: `document` (the document's uid), `missing` (`[{name, path, ids}]`),
-`modified`, `back`, `state` (empty, `searching`, `done`, `stopped` or `failed`), `search` (the search's `id`), `folder`,
+`modified`, `notes` (from `missingLinks`), `back`, `state` (empty, `searching`, `done`, `stopped` or `failed`), `search` (the search's `id`), `folder`,
 `found` (`links.findFiles`'s `links`, with the files found), `searched`, `skipped`, `unreadable`, `stopped`, `error`,
 `picks` (the file chosen for each row of `missing`, or null; with each search result, a row not chosen in the dialog
 gets its only same file, else its only file found), `touched` (the rows whose file was chosen in the dialog; search
@@ -945,7 +948,7 @@ events take `pressure` (0..1, default 1): it is the Liquify intensity while Use
 
 Freehand Tool Options: double-clicking the Pencil, Paintbrush, Smooth, Blob Brush or Eraser tool
 (`tool.options {tool: "pencil"}`) opens a `freehandOptions` dialog. Its fields are `tool` and the options the tool
-keeps: `fidelity` (screen pixels for the Pencil and Paintbrush, the same at any zoom; pt for Smooth and Blob Brush), `fill` (Pencil, Paintbrush), `keepSelected` (Pencil,
+keeps: `fidelity` (screen pixels for the Pencil, Paintbrush and Smooth, the same at any zoom; pt for the Blob Brush), `fill` (Pencil, Paintbrush), `keepSelected` (Pencil,
 Paintbrush, Blob Brush; on by default for the Pencil and Paintbrush and off for the Blob Brush, and while it is off
 the path a stroke draws, continues or merges into is not selected afterwards), `mergeOnlySelection` (Blob Brush;
 off by default, and while it is on a stroke merges only with selected blobs), `closeWithin` and `editWithin`
diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md
index 1232e3ea49..c5cb2a78c1 100644
--- a/docs/file-format-parity.md
+++ b/docs/file-format-parity.md
@@ -252,7 +252,7 @@ private editing data. VectorCraft:
 
 ### Illustrator's private editing data
 
-The app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; a filled clipping path keeps its fill, which paints under the art it clips, except the path of a mask that covers several layers, whose fill is read as a path of its own in the layer that holds the mask's path, and a compound clipping path whose subpaths paint differently, whose filled subpaths are read as a compound path of their own under the art it clips; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, placed PDF and `.ai` pages as placed documents of the [page and Crop to box](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-other-file-types/adobe-pdf-placement-options.html) their dictionary names (`AI11 PlacedPDFPageIndex`, `AI11 PlacedPDFCropTo`; a value VectorCraft doesn't read, or a binding to an image variable, leaves a linked image), guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile on a Stroke Offset stroke or written as each side's widths) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way when nothing in the object is stroked: at any angle on a path or compound path whose segments are all straight, and up to 90° either way (a limit VectorCraft sets) on another path, compound path or group with no guide in it. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), a variable-width stroke with one centered width array, dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. When the file opens from its layers, the spot colors in the art of each brush that comes in become swatches, and that art's colors count toward the document's color mode, as a pattern's do. The swatches take at most 20,000 color names in all across the brush art, and each brush-art section keeps at most 20,000 names. Each name keeps its first definition, with the color operators' names before the gradient stops' names. A spot color past those limits makes no swatch, and its color still counts toward the color mode. A spot color that the page's art, a pattern or a symbol also defines keeps the value defined there. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path is measured for each character at its size and vertical scale (in vertical type, its horizontal scale), from the top of its font's em box (Ascender), half the height of the top of its font's H (Center) or the bottom of its font's bounding box (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). In a PDF saved with some of its artboards, the type on each page after the first goes to an artboard of that page's size after the previous page's artboard, and only to one that leaves an artboard for each later page; the first page's artboard also leaves one for each later page. When several artboards fit a later page, VectorCraft takes the one whose art draws most like the page, and compares at most 16 artboards for all the later pages together. Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. A file that comes in as its page or PDF part because its editing data has no layers (a symbol library), or because its layers can't be read or used (any of the cases below), gets the symbols its editing data defines before its first layer, in the symbol list's order, while its page art stays as the page draws it. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
+The app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; a filled clipping path keeps its fill, which paints under the art it clips, except the path of a mask that covers several layers, whose fill is read as a path of its own in the layer that holds the mask's path, and a compound clipping path whose subpaths paint differently, whose filled subpaths are read as a compound path of their own under the art it clips; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, placed PDF and `.ai` pages as placed documents of the [page and Crop to box](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-other-file-types/adobe-pdf-placement-options.html) their dictionary names (`AI11 PlacedPDFPageIndex`, `AI11 PlacedPDFCropTo`; a value VectorCraft doesn't read, or a binding to an image variable, leaves a linked image), guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile on a Stroke Offset stroke or written as each side's widths) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way when nothing in the object is stroked: up to 180° either way (a limit VectorCraft sets) on a path or compound path whose segments are all straight, and up to 90° either way (a limit VectorCraft sets) on another path, compound path or group with no guide in it. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), a variable-width stroke with one centered width array, dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. When the file opens from its layers, the spot colors in the art of each brush that comes in become swatches, and that art's colors count toward the document's color mode, as a pattern's do. The swatches take at most 20,000 color names in all across the brush art, and each brush-art section keeps at most 20,000 names. Each name keeps its first definition, with the color operators' names before the gradient stops' names. A spot color past those limits makes no swatch, and its color still counts toward the color mode. A spot color that the page's art, a pattern or a symbol also defines keeps the value defined there. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path is measured for each character at its size and vertical scale (in vertical type, its horizontal scale), from the top of its font's em box (Ascender), half the height of the top of its font's H (Center) or the bottom of its font's bounding box (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). In a PDF saved with some of its artboards, the type on each page after the first goes to an artboard of that page's size after the previous page's artboard, and only to one that leaves an artboard for each later page; the first page's artboard also leaves one for each later page. When several artboards fit a later page, VectorCraft takes the one whose art draws most like the page, and compares at most 16 artboards for all the later pages together. Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. A file that comes in as its page or PDF part because its editing data has no layers (a symbol library), or because its layers can't be read or used (any of the cases below), gets the symbols its editing data defines before its first layer, in the symbol list's order, while its page art stays as the page draws it. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 
 A run of type in the editing data whose baseline direction is 1 opens with Standard Vertical Roman Alignment (https://helpx.adobe.com/illustrator/using/formatting-asian-characters.html) on, which is VectorCraft's own mapping: its half-width characters stand upright in vertical type, and horizontal type keeps the mark with no change to its layout. A run whose baseline direction is 2 or 3 (Tate-chu-yoko), or that names none in the run, its character style or the document's defaults, opens with it off. The scripting reference lists 1, 2 and 3 as the Standard, vertical rotated and Tate-chu-yoko baseline directions (https://web.archive.org/web/20170621180804/https://wwwimages.adobe.com/content/dam/Adobe/en/devnet/illustrator/sdk/CC2015_3/Illustrator%20VBScript%20Reference.pdf, page 256).
 A Scatter brush in the editing data whose last 15 numbers start with 1 comes into the Brushes panel in Tints. Each brush art section is read without its frame: an unnamed, unpainted rectangle with no settings of its own at the art's bounds (within 1/1000 pt), closed, or open with its first corner again at the end. A wider frame stays in the art, and an art group with a state or look of its own (hidden, locked, isolated, knockout, an opacity, a blend mode, a name, a mask, a note or an appearance) stays a group.
diff --git a/docs/gaps.md b/docs/gaps.md
index 3dd5a0acc6..201823b983 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -503,8 +503,8 @@ macOS cursor delivery (#2292) is narrowed to a native host adapter using the exi
   Plug-ins & Scratch Disks › Primary and Secondary (documents are kept in memory; nothing pages to
   disk), and Clipboard Handling › Legacy vector clipboard with its Preserve Paths / Preserve Appearance and
   Overprints choice (Illustrator's own clipboard flavour, which has no public specification). Also Properties
-  panel per context, context menus beyond the canvas, Layers panel row menus and Collect for Export, SVG
-  Interactivity.
+  panel per context, context menus in the panels that have none, Layers row menu commands beyond Collect for
+  Export, and menus on guide and blend spine rows in the Layers panel.
 - **Impact:** settings that silently do nothing erode trust.
 - **Estimate:** 13–20 h.
 
diff --git a/docs/image-trace-adjustments.md b/docs/image-trace-adjustments.md
index 11de4fbda6..f1c0b7d3dd 100644
--- a/docs/image-trace-adjustments.md
+++ b/docs/image-trace-adjustments.md
@@ -86,7 +86,19 @@ size. Raster exports with Art Optimized anti-aliasing, the default, do not show
 pixels and 16,384 pixels on a side. A raster export shows the line as the canvas does when it uses
 Type Optimized anti-aliasing, or when it uses Art Optimized and is larger than either limit.
 Overlapping stacks the colors instead: a lower color continues under the edge of the color above it,
-and no background shows along that edge.
+and no background shows along that edge. With Fills and without Create Strokes, Overlapping also
+follows a fill rule of VectorCraft's own: each shape is filled whole, and the area of other colors
+that a shape encloses is traced again as shapes of its own and stacked above it. Each enclosed
+outline is then fitted once. The [Image Trace presets](https://helpx.adobe.com/illustrator/desktop/manage-objects/traces-mockups-symbols/image-trace-presets.html)
+page describes Overlapping as stacking shapes where it can and overlapping their edges elsewhere. A
+shape keeps a hole where the enclosed area holds a transparent pixel or a color that Ignore Color or
+Keep Colors leaves out. A hole smaller than Noise is filled with the shape's own color, as before.
+The pixels of an area inside other areas are scanned once more for each area around it, within a
+work budget of VectorCraft's own: four times the image's pixels (counted as at least 65,536) times
+its colors, with each area costing its bounding box times the colors in it. An area that costs more
+than what is left of the budget keeps its holes and is not charged, so a smaller area after it can
+still be filled.
+With Create Strokes, or without Fills, shapes keep their holes.
 
 **Flat Logo with named colors.** With `logoColors` named, Flat Logo decides whether the image is flat
 art by the image's own colors. It finds them the same way as when no colors are named, and looks for as
diff --git a/docs/localization-hi.md b/docs/localization-hi.md
index ad59a036a9..3d304a5d50 100644
--- a/docs/localization-hi.md
+++ b/docs/localization-hi.md
@@ -40,6 +40,13 @@ community. The stroke corner names (Bevel Join, Miter Join, Round Join) and the
 जॉइन. `hindi_rows_use_one_term_for_a_variable_and_for_joining_paths` checks both terms in every
 row.
 
+A sentence keeps no English connecting word such as "or", "must" or "give": write या, होना
+चाहिए and दें. Parameter names, enum values and command IDs stay in English, and a list of
+accepted values such as `(left|right|top|bottom)` keeps the English's spelling and its `|`
+separators. `hindi_rows_keep_no_english_words_in_their_sentences` checks every row outside
+backticks, quotes, braces and brackets, and `hindi_messages_keep_their_lists_of_accepted_values`
+checks every `@msg` row's lists.
+
 ## Terminology
 
 | English | Hindi |
diff --git a/docs/mcp.md b/docs/mcp.md
index f8049365ef..4f6eb742cc 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -1,6 +1,6 @@
 # VectorCraft MCP server
 
-> **Last updated:** 2026-11-13 · **Change:** Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter (#7097); existing response shapes retained. Previously: Save location-refusal error (#6146); existing response shapes retained.
+> **Last updated:** 2026-11-13 · **Change:** Snap to Point with Smart Guides off draws no Smart Guides labels or lines, #7250; no response-shape change. Previously: Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter (#7097); existing response shapes retained.
 
 `vectorcraft-cli mcp` runs a [Model Context Protocol](https://modelcontextprotocol.io) server on stdio
 (newline-delimited JSON-RPC 2.0; see [Protocol](#protocol) for version negotiation). Agents use it to
@@ -805,19 +805,24 @@ color changed by `paint.invert`, `paint.complement`, `edit.colors.invert`, `edit
 `addon.color.filter`, `addon.color.applyNearestSwatch` or the ink limit of `addon.color.printFixes`. The recolor
 commands store it too when they are given a series group, the graph or a group that holds the graph. A row a command
 leaves as it was keeps what the graph stores. When one command changes several paths of a series, the frontmost of
-them sets what the graph stores. A gradient is stored with its placement, and every path of the series takes that
-placement when the graph is drawn again. The graph does not store a stroke's dashes, caps, joins, arrowheads, width
-profile or brush. On a graph label, given the label or something that holds it, these commands, `paint.swap` and
-`paint.default` store what they change for every label of its kind: the label's object rows, as the `appearance.*`
-commands store them, and the fill, stroke, stroke weight, caps, joins, miter limit, dashes and stroke alignment of its
-characters when all of its characters show them alike. A gradient on the characters is stored without its placement
-(its vector, aspect ratio, focal point and freeform points), and each label fits it to its own box when the graph is
-drawn again, so `paint.setGradientGeom` and the `paint.freeform.*` edits do not store the placement they set there. A
-stroke weight and dashes are stored as the label shows them, also on a label that was scaled. When the characters of
-labels of one kind change differently, the frontmost label sets what the kind keeps. On a pie with Legends in Wedges
-whose legend labels have no fill of their own, the legend labels' fill is stored only when every legend label the
-command reaches ends up with the same fill. Otherwise they are drawn again in black, or white on a dark wedge. These commands do not store the colors they give a graph's axis lines, ticks and radar rings,
-which are drawn again with their default paint.
+them sets what the graph stores. While Global Edit is on, a path directly in a series that takes an edit from another
+match (a graph's paths are matches only while the graph is isolated) has what changed on it stored for its series: the
+paint, weight, opacity and blend mode of the topmost visible fill and stroke, and the object's opacity and blend mode.
+`addon.arrange.randomizeOpacity` and `addon.arrange.sort` with `apply: "opacity"` store the object opacity, with the
+blend mode, of the frontmost path of a series whose opacity they change. A gradient is stored with its placement, and
+every path of the series takes that placement when the graph is drawn again. The graph does not store a stroke's
+dashes, caps, joins, arrowheads, width profile or brush. On a graph label, given the label or something that holds it,
+these commands, `paint.swap` and `paint.default` store what they change for every label of its kind: the label's object
+rows, as the `appearance.*` commands store them, and the fill, stroke, stroke weight, caps, joins, miter limit, dashes
+and stroke alignment of its characters when all of its characters show them alike. A gradient on the characters is
+stored without its placement (its vector, aspect ratio, focal point and freeform points), and each label fits it to its
+own box when the graph is drawn again, so `paint.setGradientGeom` and the `paint.freeform.*` edits do not store the
+placement they set there. A stroke weight and dashes are stored as the label shows them, also on a label that was
+scaled. When the characters of labels of one kind change differently, the frontmost label sets what the kind keeps. On
+a pie with Legends in Wedges whose legend labels have no fill of their own, the legend labels' fill is stored only when
+every legend label the command reaches ends up with the same fill. Otherwise they are drawn again in black, or white on
+a dark wedge. These commands do not store the colors they give a graph's axis lines, ticks and radar rings, which are
+drawn again with their default paint.
 
 `text.setFormat` without `start` and `end`, on a graph or on its labels, stores the character and paragraph attributes
 it sets for each kind of label it reaches (value axis numbers, category labels, legend labels), and every label of that
@@ -1097,6 +1102,8 @@ Images follow the `compression` settings of their kind (`color`, `gray`, or `mon
 `abovePpi` as placed they are resampled (`downsample`: `average`, `subsample` or `bicubic`) to `ppi`, and compressed
 with `zip`, `jpeg` (at `quality`; images with transparency stay lossless) or `auto` (JPEGs stay JPEG, the others
 lossless). `none`, `jpeg2000`, CCITT and `runLength` are written as ZIP, with a warning when an image needs them.
+The pieces of an image bent by a Warp effect are resampled once, for the widest and the highest size any piece places
+the image at, and all paint that one image.
 A 16-bit PNG that is not resampled, recompressed or converted keeps its 16 bits a sample in PDF 1.5 and later files,
 and is written at 8 bits in PDF 1.3 and 1.4 files.
 CMYK images stay CMYK (DeviceCMYK, or ICC-based with the CMYK profile when colours are tagged, as in PDF/X-3 and
@@ -1130,7 +1137,10 @@ ignore `UserUnit` show such a page at its full size. The option applies
 only to files without a standard: PDF/X files write such a page in points anyway, and PDF/A files keep the `UserUnit`, which
 keeps their page boundaries within PDF/A-2's limit of 14,400 units (ISO 19005-2, 6.1.13), a PDF/A file at PDF 1.4
 included (written as PDF 1.6). The dialog disables the
-checkbox when a standard is chosen. In PDF 1.3 and 1.4 files, PDF/X-1a and PDF/X-3 among them, a real number can
+checkbox when a standard is chosen. In a PDF without a standard (the option
+off, PDF 1.5 or later), the warning for a page written with a `UserUnit` above 1 ends by naming the option; in PDF/A
+files and `.ai` saves it does not.
+In PDF 1.3 and 1.4 files, PDF/X-1a and PDF/X-3 among them, a real number can
 be at most 32,767, and whole numbers are written as integers: a page longer than 32,767 pt whose sides aren't whole
 numbers of points fails the export with an error naming the page before the thumbnails are drawn and the transparency is
 flattened, and one whose art needs a real number past 32,767 fails with the same error when the file is written. A page whose short side is 3 pt or longer but would be under 3 units at that
@@ -2696,7 +2706,10 @@ compound path or symbol instance selected, it finds the objects of the same shap
 ones), among those `select.all` would take and the objects in their groups, and returns `{active: true, count, ids}`,
 the selected object first (at most 10,000). With a group of such objects selected (nested groups and clipping paths
 included; not type or images), it finds the groups like it: as many objects, in the same order, each of the same
-shape, lying the same way relative to each other (the group moved or scaled as a whole). `appearance` also asks for
+shape, lying the same way relative to each other (the group moved or scaled as a whole). While Global Edit is off,
+the command is disabled for any other selection, including a group that holds type, an image or nothing (it is off in
+the Select menu, the Properties panel's Quick Actions do not show it, and the Control bar does not show its Global Edit
+Options). `appearance` also asks for
 the same fill and stroke (for groups, of each object in them), `size` for the same width and height; `artboards` is
 `"all"` or a range such as `"1, 3-5"`, and `includeCanvas: false` leaves out the objects on no artboard. Missing
 params come from `select.globalEditOptions` (the Global Edit Options, kept for the session; it returns them with
@@ -3472,7 +3485,10 @@ already walks Image Trace. Short agent entry points:
   tool opens them, dialog `livePaintSelectionOptions`) are `selectFills` and `selectStrokes` (both on), `color` (the
   highlight color, `#rrggbb` or a layer color's name; `#ff2a2a`) and `width` (the highlight's width, 1 to 20 screen
   pixels; 4). The dialog's OK gives an error for a `color` with an alpha part (`#rrggbbaa` or `#rgba`) and changes
-  nothing.
+  nothing. `tool.setOption` gives an error that names the option and sets none of the values, whether the tool is
+  chosen or not, for a `selectFills` or `selectStrokes` that is not `true` or `false`, a `color` that is not `#rrggbb`,
+  `#rgb` (with or without `#`), a layer color's name or a basic color name such as `white`, or that has an alpha part,
+  a `width` that is not a number, and an option the tool does not have. A `width` outside 1 to 20 is set to 1 or 20.
   With `selectStrokes` off, Alt-click selects the face under the pointer as a click does; with
   `selectFills` off, a click selects the edge nearest the pointer as Alt-click does; with both off, a click selects
   no face or edge. A drag of 3 screen pixels or more draws a marquee, and the release runs `select.set {ids}` with
@@ -3489,7 +3505,11 @@ already walks Image Trace. Short agent entry points:
   them, dialog `livePaintBucketOptions`) are `paintFills` (on), `paintStrokes` (off), `highlight` (on), `color` (the
   highlight color, `#rrggbb` or a layer color's name; `#ff2a2a`) and `width` (the face highlight's width, 1 to 20 screen
   pixels; 4; an edge's highlight is half as wide). The dialog's OK gives an error for a `color` with an alpha part
-  (`#rrggbbaa` or `#rgba`) and changes nothing. With `paintFills` alone on, a click runs `livePaint.fill` and Shift-click runs `livePaint.strokeEdge`.
+  (`#rrggbbaa` or `#rgba`) and changes nothing. `tool.setOption` gives an error that names the option and sets none of
+  the values, whether the tool is chosen or not, for a `paintFills`, `paintStrokes` or `highlight` that is not `true`
+  or `false`, a `color` that is not `#rrggbb`, `#rgb` (with or without `#`), a layer color's name or a basic color name
+  such as `white`, or that has an alpha part, a `width` that is not a number, and an option the tool does not have. A
+  `width` outside 1 to 20 is set to 1 or 20. With `paintFills` alone on, a click runs `livePaint.fill` and Shift-click runs `livePaint.strokeEdge`.
   With `paintStrokes` alone on, a click runs `livePaint.strokeEdge` on the edge within 4 screen pixels of the pointer,
   or nothing when none is in reach, and Shift-click runs `livePaint.fill`. With both on, a click runs
   `livePaint.strokeEdge` when an edge is within 4 screen pixels of the pointer and `livePaint.fill` otherwise, and
@@ -5084,6 +5104,8 @@ the canvas (coordinates out of range)".
 `path.setHandle`, `path.moveAnchor` and `path.insertAnchor` edit subpath 0 when `subpath` is absent or null, and refuse a `subpath` that
 is not a whole number of 0 or more, such as 1.5, -1 or "1" ("missing integer `subpath`"); `path.split` refuses such
 an `anchor` or `segment` in the same way. The document does not change and no undo step is recorded.
+`path.moveAnchor` to the point the anchor is at, and `path.setHandle` to the point the handle is at on an anchor that
+keeps its kind, leave the document as it is and record no undo step.
 `path.insertAnchor` keeps the direct-selected anchors and selected segments of the path on the same points: those
 after the new anchor on its subpath are numbered one higher, and a selected segment that the new anchor splits stays
 selected as its two halves, with the new anchor as an end of both that moves with them. Undo restores the path and
@@ -5226,6 +5248,13 @@ round, such as a rectangle, stays as it is. Closed paths stay closed and open pa
 {"name":"run_command","arguments":{"command":"object.path.smooth","params":{"level":80}}}
 ```
 
+`path.smoothRegion` (the Smooth tool) keeps the end points of an open path where they are. When the stretch it refits
+reaches the first or last anchor of an open path, the curve there leaves or arrives along the smoothed path within
+`radius` of that end rather than along the first or last segment, so a jagged end turns with the rest of the path; it
+keeps the segment's direction when the smoothed path there turns back by 90° or more. Where the stretch ends inside a
+path, the curve keeps the direction of the part outside the drag. `object.path.smooth` and Simplify keep each end's
+direction.
+
 In the desktop app, Object › Path › Smooth and the canvas context menu's Smooth… (listed while the selection holds a
 path) open the slider (`ui.menuDialog {command: "object.path.smooth"}`, dialog `smoothSlider` with field `level`) at
 the Auto-Smooth level, and the slider previews the result until `ui.dialog.confirm`; `ui.smoothAuto` moves the open
@@ -5339,6 +5368,13 @@ box is; without `from`, that box is the selection's bounds measured in the turne
 number is an error. Without `angle`, `from` is a box on the page, as before. The Free Transform tool's Perspective Distort and Free Distort send the selection's turned box
 this way, so after a rotation they start from the corners the canvas shows.
 
+After the warp, each warped object's bounding box stands at the angle the warp turns the object's own x axis to at
+the object's center, as measured before the warp. This covers the objects inside a warped group, compound path or clip
+group, each at its own center, and the art of a linked opacity mask; an unlinked mask's art keeps its angle. A warp
+that mirrors the object keeps the angle nearer the old one, and an object whose x axis the warp collapses keeps its
+angle. `object.resetBoundingBox` squares the boxes to the page again. Corners that equal the corners of the box being
+warped (`from`, or the selection's bounds) change nothing and add no undo step. This angle rule is VectorCraft's own.
+
 ```json
 {"name":"run_command","arguments":{"command":"object.distort","params":{"from":[-100,0,0,100],"angle":90,"corners":[[0,100],[0,0],[120,-20],[100,100]]}}}
 ```
@@ -5467,6 +5503,11 @@ length that isn't a number above 0 is an error. An ellipse (Ellipse Properties):
 counterclockwise from 3 o'clock; 0 to 360 is the whole ellipse) and `invertPie: true`, which swaps them. Each call is
 one undo step.
 
+`object.setLiveShape` returns a parameter error, and leaves the document and its undo history as they were, for a key
+it does not take, at the top level (`` unknown parameter `path` ``) or in one of `items`
+(`` unknown parameter `items[0].corner`; did you mean `items[0].corners`? ``), for a `sides` that is not a whole number
+from 3 to 1000, such as 2.5, 2 or 1001, and for a negative `radius`. A `radius` of 0 removes the rounding.
+
 ```json
 {"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"sides":8,"polygonAngle":22.5,"sideLength":40}}}
 {"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"makeSidesEqual":true}}}
@@ -5791,7 +5832,7 @@ The Selection & Anchor Display and General preferences apply to `pointer_gesture
 - `usePreciseCursors`: the Pen, Eyedropper, Slice and Blend tools' pointers are a crosshair.
 - `snapToPointTolerance` (1–8 px, 2 by default): with View › Snap to Point on and Smart Guides off (desktop app), the
   point a selection is dragged by, a drawn point and a transform tool's reference point land on an anchor or a ruler
-  guide that near.
+  guide that near, showing none of the Smart Guides labels or lines.
 - `moveLockedWithArtboard`: `artboard.move {moveArt: true}`, the Artboard tool and `artboard.rearrange` move locked and
   hidden art, and art that is also on a locked artboard, with the artboard too, and `artboard.setProps {scaleArt: true}`
   scales it too; off (the default) it stays where it is. `artboard.duplicate`, `artboard.copy` and `artboard.cut` copy or
@@ -7218,7 +7259,14 @@ result carries the same files as a zip (`{name: "<name>.zip", dataBase64}`, entr
 document, objects, graphicStyles, brushes, spotColors, patterns, gradients, symbols, fonts, fontDetails, linkedImages,
 embeddedImages, repeats), `fonts` (the fonts the document's type uses, the type in opacity masks and in the art of
 its symbols and pattern swatches included, which the fonts and fontDetails categories list; with `selectionOnly`, the
-fonts of the selected type), `brushNames` (the brushes the art's strokes use, each once, hidden strokes, strokes at an opacity of 0, strokes with no
+fonts of the selected type), `fontDetails` (`[{font, match, family, style, file, embedding}]`: each font of `fonts`,
+in order, as the fontDetails category's rows give it: `match` is `exact`, `style` (a style the family lacks, shown in
+`family` `style`), `missingWithFallback` (not installed, shown in `family` `style`) or `missing`; `file` is the face's
+file name, null for a built-in face; `embedding` is `allowed`, `editing`, `previewPrint` or `forbidden`, null when no
+face is found), `imageObjects` (`[{name, width, height, linked, file}]`: the image objects in the order the
+linkedImages and embeddedImages categories list them, with the file a linked image's row shows and null for an
+embedded one), `document.unitId` (the document's units as Preferences › Units names them, such as `millimeters`, beside
+the English `document.units`), `brushNames` (the brushes the art's strokes use, each once, hidden strokes, strokes at an opacity of 0, strokes with no
 paint or width, guides, paths with no segment, type that draws no characters, a group's or layer's own strokes, a compound path member's own strokes and an image's strokes without a
 shape left out; with `selectionOnly`, the brushes the selected
 objects' strokes use), `brushes` (`[{name, type}]`: those brushes with their types, `calligraphic`, `scatter`, `art`,
@@ -7231,13 +7279,16 @@ whose drawn characters use a pattern included, hidden fills and strokes, fills a
 member's own fills and strokes, an image's fills and strokes that no Convert to Shape or Outline Object effect gives a
 shape, and characters that draw nothing (spaces and line breaks without an underline or strikethrough) left out, with
 the patterns it uses, which the patterns category lists as Pattern Objects and `objects.patterns` counts; with `selectionOnly`, those in the selection),
-`patternNames` (the patterns those objects use), `gradientObjects` (`[{id, name, gradients}]`: every object filled or
+`patternNames` (the patterns those objects use), `gradientObjects` (`[{id, name, gradients, kinds}]`: every object filled or
 stroked with a gradient, by the same rules as `patternObjects`, with the gradients it uses: the name of the gradient
-swatch a gradient is linked to, else `Linear gradient`, `Radial gradient` or `Freeform gradient`; the gradients category
+swatch a gradient is linked to, else its kind's name, such as `Linear gradient`, `Radial gradient` or `Freeform gradient`;
+`kinds` gives, for each of `gradients`, the kind (`linear`, `radial`, `conic`, `diamond` or `freeform`) of a gradient
+named by its kind and null for a swatch's name; the gradients category
 lists them as Gradient Objects and `objects.gradients` counts them; gradient swatches no art uses are not listed; with
 `selectionOnly`, those in the selection), `gradientNames` (the gradients those objects use), `spotObjects`
 (`[{id, name, spotColors}]`: every object filled or stroked with a spot color swatch, as a solid color or in the
-stops of a gradient with a stop above opacity 0, at a tint above 0, leaving out fills and strokes at an opacity of 0,
+stops of a gradient that color a part of it above opacity 0 (a stop at opacity 0 counts only where it mixes with a
+stop above opacity 0 over a stretch of some width), at a tint above 0, leaving out fills and strokes at an opacity of 0,
 and every grayscale image colorized with one, by
 the same rules as `patternObjects`, with the spot colors it uses; a process
 color, even one of the same color, and Registration are not spot colors; the spotColors category lists them as Spot
@@ -8029,7 +8080,8 @@ CMYK one. Settings saved before these options load with their defaults.
 Every object keeps the angle of its own axes (counter-clockwise degrees; `document.inspect` reports it as a node's
 `rotation`, and the selection's shared angle as `selectionRotation`, 0 when the selected objects differ). Transforms
 turn it with the object while its path geometry is still baked, so after a rotation the bounding box and its handles
-stay square to it, as in the reference app. `object.rotate {angle, absolute: true}` turns the selection to an angle
+stay square to it, as in the reference app. `object.distort` turns it as the warp turns the object at its center
+(see Free Distort on a turned bounding box). `object.rotate {angle, absolute: true}` turns the selection to an angle
 (the Transform and Properties panels' Rotate field), and `object.setBounds` measures width, height and the reference
 point along the turned box (x, y stay page coordinates). Objects turned together share the box. A new group starts
 square to the page. `object.resetBoundingBox` squares the box again without moving the art. It also squares every
@@ -8585,6 +8637,44 @@ dialog open.
 {"name":"run_command","arguments":{"command":"text.setRangeStyle","params":{"id":12,"start":0,"end":4,"tateChuYoko":true,"tcyUpDown":2,"tcyLeftRight":-1}}}
 ```
 
+## Warichu
+
+`text.setFormat` and `text.setRangeStyle {warichu?, warichuLines?, warichuGap?, warichuScale?, warichuAlign?}` set the
+Character panel menu's Warichu and Warichu Settings of the characters (the menu items show with Show East Asian
+Options). Warichu characters are set at `warichuScale` percent of their size (10 to 100, default 50) and stacked on
+`warichuLines` lines (a whole number from 1 to 6, default 2) inside their line: one above the other in horizontal type
+and side by side across the column in vertical type, the first line above or to the right. `warichuGap` is the space
+between the lines in points (0 to 100, default 0, document points as `baselineShift`). The stack is centered across the
+line on the center of the line's ideographic em box, and the line keeps the height of the characters' own size.
+A stretch of warichu characters is one block that takes the settings of its first character; a character with other
+settings, another size or the other kind of leading (Auto or a number) starts a new one, and a tab, a forced line break or a tate-chu-yoko character ends it. In
+vertical type a character marked `tateChuYoko` as well is set as tate-chu-yoko at its own size, and two or three digits
+marked `warichu` are stacked with their block instead of being set across the column. In horizontal type each line's
+characters are set in their bidi order, so right-to-left text reads from the right. The Insert Aki before the block's
+first character and after its last is space before and after the block. The text is split between the lines where
+their lengths come nearest an even share, after a space or a CJK character when there are enough such places, and
+between any two characters otherwise; a block has no more lines than characters. The block is as long as its longest
+line and is not broken across lines: a block longer than its line stays whole and runs past the line's end, as No Break
+text does. `warichuAlign` sets each line along the block: `"left"`, `"center"` or `"right"` (top, center or bottom in
+vertical type), `"justifyLeft"`, `"justifyCenter"` or `"justifyRight"` (every line but the last spread to the block's
+length, the last set left, centered or right) or `"justifyAll"`. `"auto"`, the default, sets the lines as
+`"justifyLeft"` does. These rules, the ranges and the defaults are VectorCraft's own; the public page
+<https://helpx.adobe.com/illustrator/using/formatting-asian-characters.html> describes the Lines, Line Gap, Scale and
+Alignment settings. Type on a path sets warichu characters at their own size along the path. The canvas and every
+export draw the stacked lines; SVG, PDF and the `.ai` writers write type with warichu as outlines, as they do ruby.
+None of the settings turns `warichu` on. All are saved only when they differ from the defaults, and character styles
+carry them (`charStyle.new`, `charStyle.setAttrs` and `charStyle.edit` refuse a value outside the range). A value
+outside its range is refused with `` `warichuLines` must be a whole number from 1 to 6 `` or
+`` `warichuScale` must be from 10 to 100 ``, naming the key, and an unknown alignment with the list of the values. One
+undo step; a `text.setFormat` call that changes nothing records none. `ui.warichuSettings` opens the Warichu Settings dialog on the
+values the selected characters share, a blank field where they differ; OK sends the values that changed and leaves a
+blank field's value alone. OK with a field that is not a number returns `Lines must be a number`,
+`Line Gap must be a number` or `Scale must be a number` and keeps the dialog open.
+
+```json
+{"name":"run_command","arguments":{"command":"text.setRangeStyle","params":{"id":12,"start":2,"end":8,"warichu":true,"warichuLines":2,"warichuScale":50,"warichuAlign":"auto"}}}
+```
+
 ## Insert Aki
 
 `text.setFormat` and `text.setRangeStyle {akiLeft?, akiRight?}` set Insert Aki Left and Insert Aki Right of the
@@ -9735,6 +9825,11 @@ active the active artboard (the navigator's and the Artboards panel's).
 {"name":"run_command","arguments":{"command":"tool.setOption","params":{"tool":"twirl","values":{"width":60,"rate":90}}}}
 ```
 
+The Pencil's, the Paintbrush's and the Smooth tool's `fidelity` is in screen pixels: the tools send `path.freehand` and
+`path.smoothRegion` the option divided by the zoom, so a stroke keeps as many points and a Smooth drag smooths as much
+at any zoom. The Smooth tool's `fidelity` (0.05 to 100 px, 2.5 by default) is also the one an Alt smoothing drag with
+the Pencil, Paintbrush or Blob Brush uses. The Blob Brush's `fidelity` is in points.
+
 `tool.options {tool}` opens what double-clicking the tool's button opens (its params doc lists every tool), in the
 desktop app. The Flare tool's are its Flare Tool Options (dialog `flareOptions`): `diameter` and `pathLength` (pt),
 `opacity`, `brightness`, `growth`, `fuzziness`, `longest`, `rayFuzziness` and `largest` (%), `rays`, `rings`,
@@ -9774,7 +9869,12 @@ pointer show the current fill and the swatches before and after it), `selection`
 default; when it is off, merge mode shades no regions), `gapDetection` (off) with `gapLength` (pt, 0 to 72; 3), `clickStrokeSplitsPath` (In Merge Mode,
 Clicking Stroke Splits the Path; off), `highlightStroke` (Highlight Stroke When Editable; on) and `highlightColor`
 (`#rrggbb` or a layer color's name; `#ff4f4f`, the layer color Red). The dialog's OK gives an error for a
-`highlightColor` with an alpha part (`#rrggbbaa` or `#rgba`) and changes nothing. With `clickStrokeSplitsPath` on, in merge mode,
+`highlightColor` with an alpha part (`#rrggbbaa` or `#rgba`) and changes nothing. `tool.setOption` gives an error that
+names the option and sets none of the values, whether the tool is chosen or not, for a switch that is not `true` or
+`false`, a `pickColorFrom` other than `artwork` or `swatches`, a `selection` other than `freeform` or `straightLine`, a
+`gapLength` that is not a number, a `highlightColor` that is not `#rrggbb`, `#rgb` (with or without `#`), a layer
+color's name or a basic color name such as `white`, or that has an alpha part, and an option the tool does not have. A
+`gapLength` outside 0 to 72 is set to 0 or 72. With `clickStrokeSplitsPath` on, in merge mode,
 the pointer shows scissors within 4 screen pixels of a stroke, `highlightStroke` draws the run of stroke under it in
 `highlightColor`, and a click splits that run off its path: the run goes from the anchor or crossing point before the
 pointer to the one after it, the path keeps the rest of it, and a copy of the path with the run, in the path's
@@ -10548,9 +10648,9 @@ type and evening out horizontal scales are not there yet.
 Path Precision Tools is a built-in add-on for exact anchor and path work: its commands are `addon.pathtools.*`, and in
 the desktop app it lives in Object › Plug-ins › Path Precision Tools, in its Anchor Inspector panel
 (`window.panel {panel: "anchorInspector"}`), in its Parametric Shape panel (`window.panel {panel: "parametricShape"}`)
-and in seven tools that the toolbars don't show until they are added from the All Tools drawer (or chosen with
-`tool.select`): `anchorEraserBrush`, `extendPath`, `measureInspect`, `parametricShape`, `cornerTool`, `slideAnchor` and
-`sharedEdge`.
+and in eight tools that the toolbars don't show until they are added from the All Tools drawer (or chosen with
+`tool.select`): `anchorEraserBrush`, `extendPath`, `measureInspect`, `parametricShape`, `cornerTool`, `slideAnchor`,
+`sharedEdge` and `trimAtCrossings`.
 None has a shortcut. Each edit is one undo step, and an edit that changes nothing makes no step.
 
 Tools:
@@ -10599,6 +10699,12 @@ Tools:
   different in length, or at over 120° at an end, are left alone. Options (`tool.setOption`, or the panel, kept with the
   preferences): `diameter` (0.25 to 200 pt, 20), `tolerance` (how near two anchors count as coincident, 0 to 3 pt,
   0.002) and `together` (Keep Shared Points Together).
+- **Trim at Crossings Tool** (`trimAtCrossings`): removes stretches of paths between the places where they are crossed,
+  on any path that can be edited, selected or not. A click runs `addon.pathtools.trim` with `at`, for the path within 4
+  screen pixels of the pointer. A drag draws a rectangle and runs it with `rect` on release; once the pointer has
+  gone 3 screen pixels from the press, the gesture stays a drag even when it ends near the press. An Alt-drag draws a
+  freehand line and runs it with `points` on release; a line of more than 65,536 points is dropped. Nothing changes
+  while dragging, and Escape during a drag removes nothing. The tool has no options.
 
 Commands:
 
@@ -10630,7 +10736,9 @@ Commands:
   straight segment (`straight`) or with both ends made smooth (`smooth`).
 - `addon.pathtools.crossings {cut?, selfCrossings?, ids?}` adds anchors where the selected paths cross one another (and
   where each crosses itself, with `selfCrossings`), or with `cut` also cuts them there: a path of one subpath becomes a
-  path per piece. Paths that meet at a shared anchor don't cross there; at most 10,000 segments at once.
+  path per piece. Segments that meet at an anchor they share, or with only segments of no length between them, don't
+  cross there, and they cross where they meet again elsewhere. With `selfCrossings`, a curved segment that loops over
+  itself crosses itself. At most 10,000 segments at once.
 - `addon.pathtools.divideDashes {dash?, gap?, fit?, removeGaps?}` cuts the selected paths into separate open paths
   along the curve, each `dash` long (0.01 to 1,000,000 pt, 10 by default) with `gap` between them (0 to 1,000,000 pt,
   0 by default: the pieces touch), every piece keeping the path's appearance, as one undo step. The gap pieces are left
@@ -10682,6 +10790,28 @@ Commands:
   one that `addon.pathtools.slideAnchor`, `extend` or `setAnchor` moves go with it, in the same undo step; an Extend Path
   that adds an anchor leaves the old end, and what shares it, where they are. Nothing else in the app changes. It is the
   `together` option of tool `sharedEdge`, off by default. → `{enabled}`.
+- `addon.pathtools.trim {at, tolerance?}`, `{rect}` or `{points}` removes stretches of paths. A stretch runs between two
+  neighboring places where the path is crossed, by another path or by itself, or from such a place to an open end.
+  `at` ([x, y]) removes the stretch at that point of the nearest path within `tolerance` (0 to 100 pt, default 3; of
+  paths equally near, the one on top), and a point where two stretches meet is on the one that starts there. `rect`
+  ([x, y, width, height]) removes every stretch the rectangle touches. `points` (2 to 100,000 points) removes every
+  stretch the line through them crosses. Exactly one of the three is given, with coordinates within ±10,000,000 pt.
+  Every path that can be edited takes part, selected or not, compound path members included. Hidden and locked paths,
+  guides and clipping paths are not trimmed and do not count as crossing, the members of a compound clipping path
+  included; type, images and symbol instances take no part. In isolation mode only paths inside the isolated object
+  are trimmed, and paths outside it still count as crossing. A path that ends on another marks a place on the other. Paths that lie along each other do not cross there.
+  Crossings are found on the paths' own outlines, without strokes, brushes or effects. A closed path that loses a
+  stretch becomes open. An open path that loses a middle stretch becomes two paths with its appearance, in its place in
+  the stacking order. A path that nothing crosses is removed whole, a compound path that loses its last member is
+  removed, and a live shape becomes a plain path. No anchor is added where a stretch that stays meets another. The
+  pieces of a selected path are selected, and anchors and segments direct-selected on a trimmed path are deselected;
+  the rest of the selection stays as it was. One undo step, none when nothing is removed. Only a path that `at`,
+  `rect` or `points` reaches is searched for crossings. The command is refused when such a path has more than 10,000
+  segments, when more than 200,000 segments of other paths lie in its box, when the number of paths `rect` or `points`
+  reaches times the number of paths that take part is more than 50,000,000, when the paths it trims make more than about
+  60,000,000 pairs of segments to compare in all, when the curves are too tangled to find where they cross, or when
+  checking `points` against the paths would take more than 60,000,000 comparisons. These rules are VectorCraft's own.
+  → `{ids, removed}`: the paths left of those trimmed, and the stretches removed.
 - `addon.pathtools.shape.create {center, kind?, width?, height?, rotation?, count?, a?, b?, radius?}` draws a parametric
   shape with the current paint, selected. `kind`: `rectangle`, `ellipse`, `polygon` (default), `star`, `ring`, `arrow`,
   `cross`, `heart`, `gear` or `bubble` (a speech bubble). `width` and `height` are 0.01 to 16,384 pt (100);
@@ -10829,9 +10959,9 @@ it ends up in front), baked with `effect.expandAppearance`, then `object.pathfin
 
 ## Cutting Tools add-on
 
-Cutting Tools is a built-in add-on that prepares art for cutting. Its commands are `addon.cutting.bridges` and
-`addon.cutting.weed`; in the desktop app they are Object › Plug-ins › Cutting Tools › Stencil Bridges… and Weed Box and
-Lines….
+Cutting Tools is a built-in add-on that prepares art for cutting. Its commands are `addon.cutting.bridges`,
+`addon.cutting.weed` and `addon.cutting.banner`; in the desktop app they are Object › Plug-ins › Cutting Tools › Stencil
+Bridges…, Weed Box and Lines… and Banner Hems and Grommets….
 
 ### Stencil Bridges
 
@@ -10921,6 +11051,37 @@ dialog with Preview; a Spacing above 0 is used instead of the Count.
 {"name":"run_command","arguments":{"command":"addon.cutting.weed","params":{"margin":"0.25 in","direction":"both","spacing":"2 in","gap":1}}}
 ```
 
+### Banner Hems and Grommets
+
+`addon.cutting.banner {hem?, grommets?, spacing?, grommetInset?, diameter?, top?, right?, bottom?, left?, weight?,
+swatch?, allArtboards?}` marks where a printed banner is hemmed, its edge folded back and sewn
+([hem](https://en.wikipedia.org/wiki/Hem)), and where grommets, rings set into the material to hang it, are punched
+([grommet](https://en.wikipedia.org/wiki/Grommet)). The ranges, defaults and rules below are VectorCraft's own. The banner
+is the bounds of the selected art, or each artboard when `allArtboards` is true (the default when nothing is selected).
+`top`, `right`, `bottom` and `left` (each true by default) choose the sides that get marks. On each chosen side a hem
+line runs the whole length of the edge, `hem` points inside it (0 to 100000, default 72; 0 leaves the hem lines out).
+With `grommets` on (the default), each chosen side gets grommet marks `grommetInset` points inside the edge (0 to
+100000, default 36): one at each end of the side, `grommetInset` from the edges across it, and the rest spread evenly
+between them, as few as keep them at most `spacing` points apart (more than 0 and at most 100000, default 1728, 24 in). A corner that two
+chosen sides share has one grommet. Each grommet mark is a circle `diameter` points wide (0.01 to 1000, default 27) with
+a cross through its center. The marks are stroked `weight` points wide (0.01 to 1000, default 0.3) in the color swatch
+`swatch` (default `"[Registration]"`), with no fill.
+
+Each banner gets one group named "Banner Marks", holding its hem lines (named "Hem") and its grommets (groups named
+"Grommet"), added on top of the current layer and selected, as one undo step. While a clip group, or a group inside one,
+is edited in isolation, the groups go on top of the container that holds the outermost clip group around it. The command
+fails with every side off, with no hem and no grommets, with nothing selected while `allArtboards` is false, when a
+banner has no width or height, when a `hem` above 0 reaches the far edge of the banner (the full height with only one
+of the top and bottom chosen, or the full width with only one of the left and right) or meets the hem on the opposite
+side (half the height or width with both chosen), when a `grommetInset` does the same for the grommets or is more than half
+the length of a chosen side, and when the grommets would be more than 100000. Result:
+`{id, ids, hems, grommets}`: the first group's id, every group's id, and the number of hem lines and grommet marks.
+Banner Hems and Grommets… opens the command dialog with Preview.
+
+```json
+{"name":"run_command","arguments":{"command":"addon.cutting.banner","params":{"hem":"1 in","grommetInset":"0.5 in","spacing":"2 ft"}}}
+```
+
 ## Color Effects add-on
 
 Color Effects is a built-in add-on: its effects are colour adjustments in Effect › Color Effects, its command is
@@ -11391,5 +11552,6 @@ the error text. The interactive fallback applies only to ordinary File > Save, n
 
 | Date | Change |
 |---|---|
+| 2026-11-13 | Snap to Point with Smart Guides off draws no Smart Guides labels or lines (#7250). |
 | 2026-11-13 | Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter (#7097). |
 | 2026-11-11 | Document READ_ONLY_LOCATION for saves (#6146); no response-shape change. |
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index 8a003daee9..1e41bde132 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -1,6 +1,6 @@
 # Parity with Adobe Illustrator
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-13 · **Change:** minor (3D: the seams of Extrude & Bevel, Inflate and Rotate under a white light, and of the faces of Extrude & Bevel (Classic), Revolve (Classic) and Rotate (Classic), went from miter to round joins, so white-light 3D output is expected to differ from the 2026-10-17 comparison at facet corners (not measured: the scenes were not exported again); previously: `.ai` and EPS import: in layers that don't draw as the page, art that differs away from an envelope of type no longer costs it its editable type; it keeps its drawn art where, in the pixels it and its drawn art ink, the layers with it differ from the page more than its own check allows, or past the envelopes' share of the page check, #7141; Character panel: the Set Font Height Reference dropdown shows an icon before each reference, #6304; scores and estimates unchanged; previously: Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter, so a top object saved with its sides' curves in pieces draws as its `.ai` drawn art, #7097; scores and estimates unchanged; previously: Graphic Styles list fills a taller panel, #2992; scores and estimates unchanged; previously: PDF import: glyphs in a span with an empty ActualText come in as outlines, #6971; scores and estimates unchanged; previously: library panels' lists fill a taller panel, #2992; scores and estimates unchanged; previously: Swatches list fills a taller panel, #1638; scores and estimates unchanged; previously minor: Object › Rasterize with the Grayscale or Bitmap colour model makes a grayscale image, #6969; scores and estimates unchanged; previously minor: `.ai` and EPS import: type in an envelope with Distort Appearance is also tried mapped from the box of what it paints, miter tips and moved strokes included, after its glyphs grown by half its strokes' weight (#6824; #6617: Swatches panel menu: Show Recent Colors; scores unchanged; previously minor: icon-strip flyouts also resize from the top edge and the canvas-side top corner, keeping the moved top in workspaces (storytold/craft-libs#1094); scores and estimates unchanged; previously: #6865: explicitly requested oversized editing artboard; macOS: the canvas cursor stays after the pointer moves, #6362; scores and estimates unchanged; previously minor: Type tool: kerning at a caret at the start of a line moves the character after it, #5111; scores and estimates unchanged; previously minor: Rulers: the zero point dragged out of the rulers' corner snaps as a drawn point does; previously minor: Live Paint Bucket fills faces crossed in one drag (#6373); previously: #6404: transform-aware Eyedropper character copying; scores and estimates unchanged; previously: Envelopes: with Distort Appearance, type's strokes paint along the bent glyph outlines at their own weight, as users' `.ai` files draw them, which changes how VectorCraft's own envelopes of stroked type draw (#6644; scores and estimates unchanged); previously minor: G5: Energy Beams brush library; bundled content ~44% → ~46%; previously minor: G5: Skill Icons symbol library; bundled content ~42% → ~44%; previously minor: `.ai` and EPS import: an envelope saved in Edit Contents whose mesh lies away from its drawn art by a move opens live on that art (#6570; scores and estimates unchanged); previously minor: ruler double-click adds a guide at the pointer, #5239; G5: Status Effects graphic style library; bundled content ~40% → ~42%; MCP symbol libraries list UI Frames and Map Markers; previously minor: G5: Inventory Icons built-in symbol library; bundled content ~38% → ~40%; previously minor: `.ai` and EPS import: stroked type in an envelope maps from its glyphs grown by half its stroke (#3179; scores and estimates unchanged); previously minor: `.ai` and EPS import: warps of type open as mesh envelopes on their saved grid where VectorCraft's warp doesn't draw as their drawn art (#3179; scores and estimates unchanged); G5: Game Trails brush library; bundled content ~36% → ~38%; previously minor: Edit › Edit Custom Dictionary…: its dialog adds, deletes and changes the custom dictionary's words, #4936; previously minor: `.ai` and EPS import: envelopes of type open live where they draw as their drawn art and the layers with them draw as the page (#3179; scores and estimates unchanged); G5: Game HUD graphic style library; bundled content ~34% → ~36%; previously minor: Line Arrow arrowhead (#5421; scores and estimates unchanged); G5: Map Markers built-in symbol library; bundled content ~32% → ~34%; previously minor: right-click on type: Spelling › Auto Spell Check, with its check mark, #4936; previously minor: right-click on a word Auto Spell Check underlined: its suggestions, Ignore All and Add to Dictionary, #4936; previously minor: Canvas: a 3D effect changed on type or a group redraws where its solid was; Fit to Artwork Bounds and per-artboard SVG export build each solid once for all artboards; previously minor: Effect Gallery: a thumbnail for each filter and a preview area inside the dialog, on an original drawing; Raster effects 52% → 55%, hours 1–2 → none; headline numbers unchanged; Auto Spell Check: `edit.autoSpellCheck` underlines the unknown words, #4936; previously minor: PDF editable import preserves authored ActualText once, including empty/nested spans and authored ordering (#6165); cross-line/style layout remains approximate; scores and estimates unchanged; PDF marked-text export (#6309): compatible glyphs stay on one layout line with per-glyph offsets; scores and estimates unchanged; G5: UI Frames built-in symbol library with default 9-slice; bundled content ~32%; previously minor: G5: dynamic symbol part on-canvas opacity/blend/gradient/pattern; strokes remaining no longer lists Overlap/auto corners; symbols ~88%; previously minor: interim macOS cursor delivery, #2292; native validation pending; scores and estimates unchanged; previously minor: harakat paint fallback clarified; previously minor: current Guides feature-area rows consolidated using existing ruler evidence; scores and estimates unchanged; previously minor: Control bar › Snapping includes the existing Snap to Glyph and Alignment Guides toggles (#6164); scores and estimates unchanged; previously minor: G5 docs: Art brush Overlap and Pattern brush auto corners removed from strokes remaining; symbols remaining lists dynamic on-canvas beyond solid and guides outside the art; previously minor: custom dictionary and Ignore All: `text.spelling.addWord`, `removeWord`, `changeWord`, `dictionary` and `ignoreAll`, #4936; previously minor: EPS import: embedded fonts (composite, Type 42, CID-keyed, Type 1, CFF FontSet) draw their glyphs; spell check engine: `text.spelling.check` and `text.spelling.suggest` on craft-proof, #4936; previously minor: floating tab groups collapse into the side icon rail and opened rail panels fold back into it, #5925 in part; `.ai`/EPS type keeps its tab stops, and right-aligned lines with tabs lay out as the file's page, #6147; `.ai`/EPS type from the text document lays its lines out closer to the file's page, within limits, #6137; `.ai` and EPS import: older Art brush objects read; numeric fields step on wheel hover without taking keyboard focus, and a panel wheel turn cannot seed a canvas zoom glide, #5949; Character Styles panel: a double-click on a style's row opens its Character Style Options; the dialog keeps a fixed width and scrolls its sections, so its buttons stay on screen; Tools stays beside the canvas with left-side panels; new gradients follow document color mode; Selection QoL: marquee modes and visible feedback, #5313; SVG CSS classes survive export and repeated import in all four styling modes (#2480); current-main integration retains event attributes and scripts; #3380 deletion-only review follow-up: independent survivors keep gradient placement, owned subpaths avoid discarded copies, and contracts/status/evidence are clarified; endpoint highlighting remains open; scores and estimates unchanged; the canvas keeps selection outlines and anchors between frames; Indian-language hyphenation review and license allowlist, #4947; Stroke gradients: an arrowhead aligned to the tip is painted to the corners of its base, #5964; Drop Shadow and glow dialogs: spinner arrows, #5367, #5368; Stroke Weight Up and Down shortcuts, #5797; Hindi catalog and contributor loanword preferences; full wording review in progress; Properties in Edit Artboards: a Transform section with the reference point above the Artboards section, #5219; the Control bar's Stroke: and Opacity: links scrub their fields, #4088; an image zoomed in on is separated, colorized or proofed only where it shows (#4155); a document's first frame renders on the render worker, so opening a heavy file no longer freezes the window, #4155; Control bar Paragraph section with type selected, #5372; translating unchanged type reuses its glyph and character-stroke outlines; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x; public release notes through 30.7, August 2026; Units › East Asian Type acts, with Q and Ha units; scores unchanged)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-13 · **Change:** minor (Snap to Point with Smart Guides off draws no Smart Guides labels or lines, #7250; previously: 3D: the seams of Extrude & Bevel, Inflate and Rotate under a white light, and of the faces of Extrude & Bevel (Classic), Revolve (Classic) and Rotate (Classic), went from miter to round joins, so white-light 3D output is expected to differ from the 2026-10-17 comparison at facet corners (not measured: the scenes were not exported again); previously: `.ai` and EPS import: in layers that don't draw as the page, art that differs away from an envelope of type no longer costs it its editable type; it keeps its drawn art where, in the pixels it and its drawn art ink, the layers with it differ from the page more than its own check allows, or past the envelopes' share of the page check, #7141; Character panel: the Set Font Height Reference dropdown shows an icon before each reference, #6304; scores and estimates unchanged; previously: Envelopes: a top object's side whose pieces are all one curve split at anchors follows that curve's parameter, so a top object saved with its sides' curves in pieces draws as its `.ai` drawn art, #7097; scores and estimates unchanged; previously: Graphic Styles list fills a taller panel, #2992; scores and estimates unchanged; previously: PDF import: glyphs in a span with an empty ActualText come in as outlines, #6971; scores and estimates unchanged; previously: library panels' lists fill a taller panel, #2992; scores and estimates unchanged; previously: Swatches list fills a taller panel, #1638; scores and estimates unchanged; previously minor: Object › Rasterize with the Grayscale or Bitmap colour model makes a grayscale image, #6969; scores and estimates unchanged; previously minor: `.ai` and EPS import: type in an envelope with Distort Appearance is also tried mapped from the box of what it paints, miter tips and moved strokes included, after its glyphs grown by half its strokes' weight (#6824; #6617: Swatches panel menu: Show Recent Colors; scores unchanged; previously minor: icon-strip flyouts also resize from the top edge and the canvas-side top corner, keeping the moved top in workspaces (storytold/craft-libs#1094); scores and estimates unchanged; previously: #6865: explicitly requested oversized editing artboard; macOS: the canvas cursor stays after the pointer moves, #6362; scores and estimates unchanged; previously minor: Type tool: kerning at a caret at the start of a line moves the character after it, #5111; scores and estimates unchanged; previously minor: Rulers: the zero point dragged out of the rulers' corner snaps as a drawn point does; previously minor: Live Paint Bucket fills faces crossed in one drag (#6373); previously: #6404: transform-aware Eyedropper character copying; scores and estimates unchanged; previously: Envelopes: with Distort Appearance, type's strokes paint along the bent glyph outlines at their own weight, as users' `.ai` files draw them, which changes how VectorCraft's own envelopes of stroked type draw (#6644; scores and estimates unchanged); previously minor: G5: Energy Beams brush library; bundled content ~44% → ~46%; previously minor: G5: Skill Icons symbol library; bundled content ~42% → ~44%; previously minor: `.ai` and EPS import: an envelope saved in Edit Contents whose mesh lies away from its drawn art by a move opens live on that art (#6570; scores and estimates unchanged); previously minor: ruler double-click adds a guide at the pointer, #5239; G5: Status Effects graphic style library; bundled content ~40% → ~42%; MCP symbol libraries list UI Frames and Map Markers; previously minor: G5: Inventory Icons built-in symbol library; bundled content ~38% → ~40%; previously minor: `.ai` and EPS import: stroked type in an envelope maps from its glyphs grown by half its stroke (#3179; scores and estimates unchanged); previously minor: `.ai` and EPS import: warps of type open as mesh envelopes on their saved grid where VectorCraft's warp doesn't draw as their drawn art (#3179; scores and estimates unchanged); G5: Game Trails brush library; bundled content ~36% → ~38%; previously minor: Edit › Edit Custom Dictionary…: its dialog adds, deletes and changes the custom dictionary's words, #4936; previously minor: `.ai` and EPS import: envelopes of type open live where they draw as their drawn art and the layers with them draw as the page (#3179; scores and estimates unchanged); G5: Game HUD graphic style library; bundled content ~34% → ~36%; previously minor: Line Arrow arrowhead (#5421; scores and estimates unchanged); G5: Map Markers built-in symbol library; bundled content ~32% → ~34%; previously minor: right-click on type: Spelling › Auto Spell Check, with its check mark, #4936; previously minor: right-click on a word Auto Spell Check underlined: its suggestions, Ignore All and Add to Dictionary, #4936; previously minor: Canvas: a 3D effect changed on type or a group redraws where its solid was; Fit to Artwork Bounds and per-artboard SVG export build each solid once for all artboards; previously minor: Effect Gallery: a thumbnail for each filter and a preview area inside the dialog, on an original drawing; Raster effects 52% → 55%, hours 1–2 → none; headline numbers unchanged; Auto Spell Check: `edit.autoSpellCheck` underlines the unknown words, #4936; previously minor: PDF editable import preserves authored ActualText once, including empty/nested spans and authored ordering (#6165); cross-line/style layout remains approximate; scores and estimates unchanged; PDF marked-text export (#6309): compatible glyphs stay on one layout line with per-glyph offsets; scores and estimates unchanged; G5: UI Frames built-in symbol library with default 9-slice; bundled content ~32%; previously minor: G5: dynamic symbol part on-canvas opacity/blend/gradient/pattern; strokes remaining no longer lists Overlap/auto corners; symbols ~88%; previously minor: interim macOS cursor delivery, #2292; native validation pending; scores and estimates unchanged; previously minor: harakat paint fallback clarified; previously minor: current Guides feature-area rows consolidated using existing ruler evidence; scores and estimates unchanged; previously minor: Control bar › Snapping includes the existing Snap to Glyph and Alignment Guides toggles (#6164); scores and estimates unchanged; previously minor: G5 docs: Art brush Overlap and Pattern brush auto corners removed from strokes remaining; symbols remaining lists dynamic on-canvas beyond solid and guides outside the art; previously minor: custom dictionary and Ignore All: `text.spelling.addWord`, `removeWord`, `changeWord`, `dictionary` and `ignoreAll`, #4936; previously minor: EPS import: embedded fonts (composite, Type 42, CID-keyed, Type 1, CFF FontSet) draw their glyphs; spell check engine: `text.spelling.check` and `text.spelling.suggest` on craft-proof, #4936; previously minor: floating tab groups collapse into the side icon rail and opened rail panels fold back into it, #5925 in part; `.ai`/EPS type keeps its tab stops, and right-aligned lines with tabs lay out as the file's page, #6147; `.ai`/EPS type from the text document lays its lines out closer to the file's page, within limits, #6137; `.ai` and EPS import: older Art brush objects read; numeric fields step on wheel hover without taking keyboard focus, and a panel wheel turn cannot seed a canvas zoom glide, #5949; Character Styles panel: a double-click on a style's row opens its Character Style Options; the dialog keeps a fixed width and scrolls its sections, so its buttons stay on screen; Tools stays beside the canvas with left-side panels; new gradients follow document color mode; Selection QoL: marquee modes and visible feedback, #5313; SVG CSS classes survive export and repeated import in all four styling modes (#2480); current-main integration retains event attributes and scripts; #3380 deletion-only review follow-up: independent survivors keep gradient placement, owned subpaths avoid discarded copies, and contracts/status/evidence are clarified; endpoint highlighting remains open; scores and estimates unchanged; the canvas keeps selection outlines and anchors between frames; Indian-language hyphenation review and license allowlist, #4947; Stroke gradients: an arrowhead aligned to the tip is painted to the corners of its base, #5964; Drop Shadow and glow dialogs: spinner arrows, #5367, #5368; Stroke Weight Up and Down shortcuts, #5797; Hindi catalog and contributor loanword preferences; full wording review in progress; Properties in Edit Artboards: a Transform section with the reference point above the Artboards section, #5219; the Control bar's Stroke: and Opacity: links scrub their fields, #4088; an image zoomed in on is separated, colorized or proofed only where it shows (#4155); a document's first frame renders on the render worker, so opening a heavy file no longer freezes the window, #4155; Control bar Paragraph section with type selected, #5372; translating unchanged type reuses its glyph and character-stroke outlines; scores and estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x; public release notes through 30.7, August 2026; Units › East Asian Type acts, with Q and Ha units; scores unchanged)
 >
 > Oversized artboard import update (2026-11-12): Explicit editing-data import retains a single artboard beyond a capped 14,400 pt PDF page (#6865).
 >
@@ -41,6 +41,7 @@ Window → Help Bar toggles the bottom tool-help strip independently of the stat
 The shared assessment status line and revision history are current upstream; this dated section records the submission's feature evidence and revisions without rescoring upstream or claiming a new combined build or runtime measurement.
 
 - File formats and Type core (#6147): `.ai`/EPS type from the text document keeps its paragraphs' tab stops, and right-aligned area type sets the text before a line's last tab at its stops, from the left edge, and the text after it against the right edge. Evidence: `ate::tests::a_paragraph_keeps_its_tab_stops`, `ate::tests::a_story_s_tab_stops_are_bounded`, `tests::right_aligned_area_type_sets_the_text_after_its_last_tab_against_the_edge`, `import_fuzz::text_frames_with_hostile_paragraph_attributes_never_panic`; scores and estimates unchanged
+- Type core: a right-to-left line with tabs is measured in the order it is drawn, with tab stops still measured from the left edge. Each tab goes to its stop from where the glyphs drawn before it end, and right, center and decimal stops align the text drawn after the tab. Right, Auto and centered lines are aligned by that width, and area type wraps a line that is too wide when drawn. Evidence: `tests::justify::a_right_to_left_line_with_a_tab_is_aligned_as_it_is_drawn`, `tests::justify::a_right_to_left_line_with_a_tab_wraps_when_it_does_not_fit_as_drawn`, `tests::justify::right_to_left_tab_stops_align_the_text_drawn_after_them`, `tests::justify::a_right_to_left_line_with_two_tabs_and_a_latin_run_ends_on_the_right_edge`, `tests::justify::right_aligned_right_to_left_point_type_with_a_tab_ends_at_its_origin`; scores and estimates unchanged
 - File formats and Type core (#6137): `.ai`/EPS type from the text document keeps auto leading at the paragraph's share of each line's largest type, the paragraph's hyphenation options, and may show more of the last lines the file sets in an area frame of its own, when growing the frame by its lines' deepest descent plus 0.05 pt shows them; a line a soft return ends is justified as a wrapped line is. Evidence: `ate::tests::auto_leading_follows_the_size_of_each_line`, `ate::tests::a_paragraph_keeps_its_hyphenation_options`, `ate::tests::the_last_lines_the_file_sets_in_its_frame_show`, `tests::fit_source_lines_keeps_the_last_lines_the_source_sets`, `tests::typo::soft_return_in_justified_text_spreads_like_a_wrapped_line`. Limits: frames grow only for area type of one frame, horizontal, by its lines' deepest descent plus 0.05 pt; type in a font that isn't installed, and hyphenation in a language that isn't imported, still lay out differently; scores and estimates unchanged
 - Current-main conflict reconciliation retains upstream and feature behavior; scores and estimates unchanged
 - Superseded 2026-10-20 behavior, retained as history: Artboard Options shares existing presets and orientation controls and can fit artwork without moving it; artwork fitting uses the original target artboard and revision-scoped bounds caches (scores/hours unchanged)
@@ -53,6 +54,7 @@ Artboard Options forwards the active Artboard tool's Scale Artwork with Artboard
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-11-13 | minor | Snap to Point: with Smart Guides off it still pulls drawn and dragged points onto anchors and ruler guides, but draws none of the Smart Guides labels ("anchor") or lines (#7250; `guides::tests::snap_to_point_without_smart_guides_shows_no_guides`). Scores and estimates unchanged. |
 | 2026-11-13 | minor | Graphic Styles: in a panel made taller the list fills the space above the footer instead of stopping at 220 pt (#2992; `the_list_fills_a_tall_panel_above_its_footer` in `crates/ui-egui/src/panels/graphic_styles.rs`). Scores and estimates unchanged. |
 | 2026-11-13 | minor | PDF import: glyphs inside a marked-content span with an empty `ActualText` come in as outlines in their fill and stroke instead of being left out, adding no text (#6971; `empty_actual_text_keeps_the_glyphs_art` in `crates/pdf/src/tests/actual_text.rs`). Scores and estimates unchanged. |
 | 2026-11-13 | minor | Library panels (swatch, Color Book, brush, symbol and graphic style libraries): in a panel made taller the list fills the space above the footer instead of scrolling inside 220 or 280 pt (#2992; `the_list_fills_a_tall_panel_above_its_footer` in `crates/ui-egui/src/panels/library_panel/tests.rs`). Scores and estimates unchanged. |
@@ -246,7 +248,7 @@ dominate; 3D, graphs and automation are specialist). They sum to 105. Feature de
 | Raster effects (Effect Gallery) | 4 | 55% | — | — | estimated (raised from 52%: the Effect Gallery's filter thumbnails and in-dialog preview, an original landscape drawing passed through each filter, [Filter Gallery overview](https://helpx.adobe.com/photoshop/desktop/effects-filters/get-started-with-filters/filter-gallery.html), `dialogs::effect_gallery::tests::gallery_shows_thumbnails_and_an_in_dialog_preview`; the gallery itself shipped in #2883, six categories, per-filter settings, ordered stack, live canvas preview, one undo step, `stack_ok_is_one_undo_step`, `stack_preview_is_one_interaction`); measured count 57/57 (Artistic complete with Colored Pencil, Fresco, Paint Daubs, Palette Knife, Rough Pastels and Underpainting; Sketch complete with Torn Edges and Conté Crayon, `pixel::tests_sketch::conte_crayon_*`); texture redraw distances optimized (#1257), pixels verified; the score stays under 100% because the filters are original approximations; depth estimated |
 | Symbols, blends, envelopes, Repeat, perspective | 5 | 88% | remaining: dynamic symbols' `.ai` round trip, further built-in symbol libraries (Basic Shapes, UI Frames with default 9-slice, Map Markers, Inventory Icons and Skill Icons are done), envelope Anti-Alias/Preserve Shape, 9-slice guides outside the art; Symbol Options › Registration, Export Type and Symbol Type (dynamic on-canvas fill/stroke including gradient/pattern, opacity and blend, #4938) and on-canvas 9-slice guides (#5280) are done | 4–7 | estimated |
 | Image Trace, graphs, image tools | 3 | 75% | graph Column designs, Image Trace Create Strokes depth (Create Object Mosaic is done; junction-returning piece survival has source-generated regressions in `image-trace-quality.md`; large images trace with a warning; Auto Color keeps rare distinct colours) | 5–8 | estimated (raised from 72%); quick presets reveal adjustment controls, Properties reopens them |
-| Layers, artboards, document setup | 5 | 78% | Selected-artboard deletion is consistent across panel actions (all-selected retains artboard 1); history prunes removed indices while preserving valid multiselection; remaining:  30.0's artboard locking and colours and managing artboards from the canvas, Layers panel row context menus and Collect for Export (click-to-fit objects is done, #1227) | 5–8 | estimated (lowered from 82%: target moved); Artboard deletion keys keep artwork and the first of an all-selected set; Artboard Options' Show Center Mark and Show Cross Hairs draw on the canvas only (exports and print leave them out), regression-tested; Artboard Options' Show Video Safe Areas and Video Ruler Pixel Aspect Ratio (per artboard, native format) are done ([video display options](#evidence-what-ships-today-by-area)), score unchanged |
+| Layers, artboards, document setup | 5 | 78% | Selected-artboard deletion is consistent across panel actions (all-selected retains artboard 1); history prunes removed indices while preserving valid multiselection; remaining:  30.0's artboard locking and colours and managing artboards from the canvas, Layers row menu commands beyond Collect for Export and menus on guide and blend spine rows (click-to-fit objects is done, #1227) | 5–8 | estimated (lowered from 82%: target moved); Artboard deletion keys keep artwork and the first of an all-selected set; Artboard Options' Show Center Mark and Show Cross Hairs draw on the canvas only (exports and print leave them out), regression-tested; Artboard Options' Show Video Safe Areas and Video Ruler Pixel Aspect Ratio (per artboard, native format) are done ([video display options](#evidence-what-ships-today-by-area)), score unchanged |
 | View & navigation | 3 | 70% | multiple windows and the rest of Arrange (Cascade, Float in Window, Float All in Windows) | 9–14 | estimated; Window › Arrange › Tile and Consolidate All Windows done (score/hours unchanged); document-tab artwork hover/copy and lossless transfer tested (2026-10-22; score/hours unchanged); cached canvas reprojection preserves scale during resize, rotation and DPI changes (regression and contributor original-file evidence below; scores/hours unchanged); cached canvas dimensions match the renderer limit before cache-key creation, view construction and worker submission (regression evidence below) |
 | File formats | 6 | 75% | `.ai` files open with a flattened or wrong layer structure in real cases (#951), no writing of Illustrator's editing data (#868), FreeHand/CorelDRAW/DWG/HEIC import, 3D export; see [file-format-parity.md](file-format-parity.md); EPS legacy mesh/opacity-mask and raster comparison follow-up verified  PDF marked-text batching covered by M4 evidence (#6309); cross-line/style ActualText layout (#6165) and styled-cluster limits remain.| 10–20 | estimated (lowered from 85%: open issues); DXF control-point SPLINE import closure regression-tested (#1299 follow-up after #1320); DXF export's Include Placed Images and Include Fill Hatches options, off in CNC / CAM (`images_and_hatches_are_left_out_independently_and_the_cnc_preset_leaves_out_both`; score, gaps and hours unchanged); PDF writer metadata, reader streaming and immutable backend checks in `crates/pdf/src/tests.rs`, `crates/pdf/src/tests/reader_streaming.rs` and `xtask/src/pdf_deps.rs`; PDF Place and clipboard paste retain live text (synthetic regressions); EPS ordinary Save retains the page frame and editable document (2026-10-26); `.ai`/EPS editing data checked against a user's files (2026-10-30): case setting (`ate::tests`, `tests_native::type_from_the_text_document_keeps_its_case_setting`), placed-file placements (`tests_native::a_small_placed_file_goes_where_it_draws_closer_to_the_page`), pages cropped to the art (`tests_native::type_on_the_copies_of_a_page_cropped_to_the_art_is_read_once`), mesh corner weights and state (`ai::mesh::tests::corners_with_handle_weights_of_zero_are_read`, `ai::tests::a_gradient_mesh_takes_the_transparency_written_after_it`), type on a path spacing (`tests_native::type_round_a_circle_is_spaced_as_the_file_lays_it_out`; the distance from the path under Align to Path is measured from the top of each character's em box, half the height of the top of its H or the bottom of its font's bounding box (`tests_native::aligned_type_lies_as_far_from_its_path_as_the_file_lays_it_out`), and the fit under Gravity does not reproduce the file's layout), blend state (`ai::tests::a_blends_transparency_follows_its_record`); scores and estimates unchanged. PDF ActualText preserved in editable import (#6165; bounded synthetic coverage below); score/hours unchanged. |
 | File formats | 6 | 75% | `.ai` files open with a flattened or wrong layer structure in real cases (#951), a saved `.ai`'s editing copy without live effects on objects other than paths, compound paths and groups that qualify (at most a fill and a stroke, a non-zero fill rule when filled, no large canvas) and whose appearance and effects the art-style writer supports, and with live objects as their art (#868), FreeHand/CorelDRAW/DWG/HEIC import, textures, map art and shading in 3D export; see [file-format-parity.md](file-format-parity.md); EPS legacy mesh/opacity-mask and raster comparison follow-up verified  PDF marked-text batching covered by M4 evidence (#6309); cross-line/style ActualText layout (#6165) and styled-cluster limits remain.| 10–20 | estimated (lowered from 85%: open issues); DXF control-point SPLINE import closure regression-tested (#1299 follow-up after #1320); PDF writer metadata, reader streaming and immutable backend checks in `crates/pdf/src/tests.rs`, `crates/pdf/src/tests/reader_streaming.rs` and `xtask/src/pdf_deps.rs`; PDF Place and clipboard paste retain live text (synthetic regressions); EPS ordinary Save retains the page frame and editable document (2026-10-26); `.ai`/EPS editing data checked against a user's files (2026-10-30): case setting (`ate::tests`, `tests_native::type_from_the_text_document_keeps_its_case_setting`), placed-file placements (`tests_native::a_small_placed_file_goes_where_it_draws_closer_to_the_page`), pages cropped to the art (`tests_native::type_on_the_copies_of_a_page_cropped_to_the_art_is_read_once`), mesh corner weights and state (`ai::mesh::tests::corners_with_handle_weights_of_zero_are_read`, `ai::tests::a_gradient_mesh_takes_the_transparency_written_after_it`), type on a path spacing (`tests_native::type_round_a_circle_is_spaced_as_the_file_lays_it_out`), blend state (`ai::tests::a_blends_transparency_follows_its_record`); scores and estimates unchanged. PDF ActualText preserved in editable import (#6165; bounded synthetic coverage below); score/hours unchanged. |
@@ -257,7 +259,7 @@ dominate; 3D, graphs and automation are specialist). They sum to 105. Feature de
 | Export for Screens, Asset Export, slices, Save for Web | 3 | 85% | anti-aliasing ghost borders (#983); TIFF choices and settings are implemented | 2–4 | estimated |
 | Print, colour management, separations, flattener | 3 | 80% | print preview fidelity | 2–4 | estimated |
 | Automation (Actions, Variables, scripting, batch) | 3 | 60% | a scripting surface (Illustrator: JavaScript/ExtendScript), Batch, image and graph variables, dataset import/export | 8–14 | estimated; MCP `add_text` exposes existing vertical type; score and hours unchanged |
-| UI chrome (panels, Properties, workspaces, preferences) | 6 | 80% | Properties per context, 2 Preferences options stored but unused (#394, audited 2026-10-30: Scratch Disks, legacy vector clipboard), SVG Interactivity, context menus beyond the canvas, accessibility | 13–20 | estimated; floating panels in OS windows of their own on the desktop (#4135), score and hours unchanged; macOS save Format menu implemented (#866), score and hours unchanged; Eyedropper cursor and precise setting checked (#1269), OS visual QA unverified; numeric-field focus and normal text drags regression-tested (#1326); a focus click released more than 1 pt from its press keeps the caret and a tap within 1 pt selects all (#6659); artboard navigation synchronizes the tool selection before destructive actions; status messages and readouts use stable responsive allocations sized for localized labels and ordinary coordinates (sample widths cached by language/unit/DPI; regression and contributor original-file evidence below; scores/hours unchanged); effect dialogs' colour fields show a swatch that opens the Color Picker (#5365), score and hours unchanged; icon-strip flyouts retain user sizes (#5713); floating tab groups collapse into the side icon rail and opened rail panels fold back into it (#5925, in part), scores and hours unchanged ; interim macOS cursor delivery (#2292), headless coverage only; native validation pending, score and hours unchanged |
+| UI chrome (panels, Properties, workspaces, preferences) | 6 | 80% | Properties per context, 2 Preferences options stored but unused (#394, audited 2026-10-30: Scratch Disks, legacy vector clipboard), context menus in the panels that have none, accessibility | 13–20 | estimated; floating panels in OS windows of their own on the desktop (#4135), score and hours unchanged; macOS save Format menu implemented (#866), score and hours unchanged; Eyedropper cursor and precise setting checked (#1269), OS visual QA unverified; numeric-field focus and normal text drags regression-tested (#1326); a focus click released more than 1 pt from its press keeps the caret and a tap within 1 pt selects all (#6659); artboard navigation synchronizes the tool selection before destructive actions; status messages and readouts use stable responsive allocations sized for localized labels and ordinary coordinates (sample widths cached by language/unit/DPI; regression and contributor original-file evidence below; scores/hours unchanged); effect dialogs' colour fields show a swatch that opens the Color Picker (#5365), score and hours unchanged; icon-strip flyouts retain user sizes (#5713); floating tab groups collapse into the side icon rail and opened rail panels fold back into it (#5925, in part), scores and hours unchanged ; interim macOS cursor delivery (#2292), headless coverage only; native validation pending, score and hours unchanged |
 | Libraries, Links, Package | 2 | 82% | shared libraries, linked graphics, gradients and patterns as library items (no cloud by design) | 2–3 | estimated |
 | Generative AI (Text to Vector, Generative Recolor, Shape Fill, Concept to Vector, Prompt to Edit, Rewrite Text) | 2 | 0% | a pluggable provider and the panels; needs an owner decision on models | 30–60 | measured (absent) |
 | **Feature depth** | **105** | **~75%** | | **~250–420** | |
@@ -365,7 +367,7 @@ Depth here is "does the basic use work", not the area's full score.
 | Gradients, basic | 4 | 90% | Gradient panel and on-canvas annotator |
 | Type: point and area text, font, size | 8 | 88% | font menu with previews; Hyphenation… and Justification… options per paragraph (#2310, #2755) |
 | Align, group, arrange | 6 | 95% | |
-| Layers, basic | 4 | 85% | Layers panel rework; no row context menus |
+| Layers, basic | 4 | 85% | Layers panel rework; row context menus offer only Collect for Export |
 | Shape Builder | 5 | 70% | beginners lean on it; region detection failed on art of thousands of segments (#937's reproduced case, fixed, and its edge-source grid is bounded in memory; unconfirmed on the reporter's file) |
 | Pathfinder | 4 | 95% | exact booleans |
 | Place images, Image Trace | 4 | 85% | 13 trace presets |
@@ -510,15 +512,15 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Type core | 9 | 80% | Middle Eastern features beyond bidi layout, Paragraph Direction, digit types and Kashidas (the Middle Eastern composers, editable bidirectional SVG text, a split caret where directions meet); paint-only harakat keep joining with conditional GDEF-mark colour ownership, but fonts without GDEF mark classes and some AAT/`morx` ligatures can still leave marks painted as their letters; Every-line Composer fidelity for justified and ragged text (available per object; mixed type sizes in a paragraph still break single-line in non-rectangular area type and with text wrap), Optical Margin Alignment, paragraph spacing limit for vertically justified area type, hidden characters, paragraph attributes in the Type tool's copy and paste (the characters keep their styles, the paragraphs take the destination's), mixed-value display in the Paragraph panel for a selection across differing paragraphs, partial selection of type-area anchors by marquee, optional font-size preservation during group scaling (scaled character controls fixed in #1034). Hyphenation and Justification options, Fractional Widths, System Layout, styled Type-range canvas Paste (#5636), and pattern hyphenation for eleven Indian languages with grapheme/cluster protection (#4947) are done; Sanskrit automatic patterns remain pending an allowlisted source | 14–19 |
 | Symbols, blends, envelopes, Repeat, perspective | 5 | 90% | further built-in symbol libraries (Basic Shapes, UI Frames with default 9-slice, Map Markers, Inventory Icons and Skill Icons are done), dynamic symbols' `.ai` round trip, envelope Anti-Alias/Preserve Shape output and warp point editing, brush interpolation in blends (M8 fidelity pass done); Symbol Options › Registration and Export Type and on-canvas dynamic part paint (gradient/pattern, opacity, blend) are done; symbol editing shows draggable 9-slice guides (#5280), while guides outside the artwork remain unsupported | 4–7 |
 | Image Trace, graphs, image tools | 3 | 72% | graph Column designs (Graph Design, Marker designs and series colours set with Group Selection are done), Create Object Mosaic, per-feature stroke/fill choice and varying widths in Image Trace's Create Strokes (Vector Halftone and the Image Trace View modes, Palette and Create Strokes are done) | 6–10 |
-| Layers, artboards, document setup | 5 | 82% | Layers panel: a confirmation before deleting layers that hold art, Collect for Export, row context menus, the Layer Options dialog for several rows with mixed values, Paste Remembers Layers for sublayers; artboard preset polish (artboard escape routing and document setup modal handoff done; Move Artwork for artboard X/Y edits, Rearrange All Artboards, Document Setup, New Document and the rest of the Layers panel are done) | 4–7 |
+| Layers, artboards, document setup | 5 | 82% | Layers panel: a confirmation before deleting layers that hold art, row menu commands beyond Collect for Export (now on every layer, sublayer, group and object row), menus on guide and blend spine rows, the Layer Options dialog for several rows with mixed values, Paste Remembers Layers for sublayers; artboard preset polish (artboard escape routing and document setup modal handoff done; Move Artwork for artboard X/Y edits, Rearrange All Artboards, Document Setup, New Document and the rest of the Layers panel are done) | 4–7 |
 | View & navigation | 3 | 70% | New View/Edit Views, multiple windows/arrange, Snap to Pixel/Glyph (print tiling is done) | 9–14 |
 | Guides, grids, smart guides, snapping, rulers | 3 | 85% | global/video rulers, Spacing Guides' distance readouts and spacing for resized or drawn art, Alt swapping a ruler guide's orientation, ruler guides selected together with art (marquee, Shift-click), ruler guides as Layers rows with their own lock and hide (#451: Lock Guides locks them all; Make Guides paths are Layers rows already) (dragging existing guides is done, #414; new guides snapping to side midpoints and artboards, and artboard guides, #451; the drawing tools snapping, with Construction Guides, #506; Spacing Guides for moves, #394; moves snapping to the grid, #740; ruler guides pulling drawn points with Smart Guides on, and "center" and "anchor" labels while hovering with the Selection tool, #812; distance and angle labels while drawing, #2983) | 2–4; status-bar X/Y uses the active ruler origin and General units |
 | File formats | 6 | 85% | PDF import: glyphs inside a marked-content span with an empty `ActualText` come in as outlines in their fill and stroke, adding no text (#6971; scores and estimates unchanged); Explicit editing-data oversized single-artboard import fixed (#6865); scores and estimates unchanged. Affinity export, and the rest of Affinity import (adjustments, blur and bevel effects, brushes, live symbol instances, text threading), DWG (no open spec: DXF instead), PSD placement as layers (Photoshop Import Options; the merged image is done), EPS checked against more real files users send (Inkscape files open as vectors; other generators' constructs are tested with programs written from the PostScript Language Reference only; CID-keyed CJK type and `CCITTFaxDecode` images not read), legacy `.ai` files saved without the prolog that defines their operators (their own operator set isn't read yet), the rest of Illustrator's editing data (appearances and live effects, symbols, pattern fills, brushes, placed files: #637), the remaining fidelity polish; EPS, DXF, EMF/WMF, TIFF, BMP, Targa, PSD export, SVGZ, PDF security, PDF/X, PDF layers, presets and Affinity import are done | 6–10 (existing scope; Affinity export unestimated) |
 | Export for Screens, Asset Export, slices, Save for Web | 3 | 85% | polish only (all four are done) | 2–4 |
 | Print, colour management, separations, flattener | 3 | 80% | print preview fidelity (flattener presets in PDF and print, overprint in PDF and composite print, Print dialog, presets, PostScript, marks, separations, Print Tiling, print overprint/flattener/bitmap options and printer profile are done, as are the Japanese papers in its Media list: JIS B4/B5/B6, はがき, 往復はがき, 封筒 長形3号/長形4号/角形2号/角形3号 and 四六判, beside the ISO B4/B5 that settings saved before them keep) | 1–2 |
 | Automation | 3 | 65% | scripting surface, batch (MCP drops malformed app replies without replay; Variables: text/visibility variables bound to objects, an object may carry several, dataset rows applied in one undo step, panel and Window › Variables with dialogs; image/graph kinds and dataset import/export open) | 6–10 |
-| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 80% | macOS native menu dismissal fixed (M14.8); Variables, Links, Asset Export, CSS Properties, Attributes, the canvas context menu and docking panels into any dock group by dragging (as tabs, a top/bottom split or icons) are done; remaining: SVG Interactivity, Properties per context, Consolidate All Windows, floating panels outside the app window, context menus beyond the canvas, about 13 Preferences options stored but not yet acted on (#394: Open Documents As Tabs, Real-time Drawing, hyphenation language, devices…) | 13–20 |
-| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 80% | macOS native menu dismissal fixed (M14.8); Variables, Links, Asset Export, CSS Properties, Attributes, the canvas context menu and docking panels into any dock group by dragging (as tabs, a top/bottom split or icons) are done; remaining: SVG Interactivity, Properties per context, Consolidate All Windows, floating panels outside the app window, context menus beyond the canvas, about 14 Preferences options stored but not yet acted on (#394: Highlight Alternate Glyphs, Open Documents As Tabs, Real-time Drawing, hyphenation language, devices…) | 13–20 |
+| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 80% | macOS native menu dismissal fixed (M14.8); Variables, Links, Asset Export, CSS Properties, Attributes, the canvas context menu and docking panels into any dock group by dragging (as tabs, a top/bottom split or icons) are done; remaining: Properties per context, Consolidate All Windows, floating panels outside the app window, context menus in the panels that have none, about 13 Preferences options stored but not yet acted on (#394: Open Documents As Tabs, Real-time Drawing, hyphenation language, devices…) | 13–20 |
+| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 80% | macOS native menu dismissal fixed (M14.8); Variables, Links, Asset Export, CSS Properties, Attributes, the canvas context menu and docking panels into any dock group by dragging (as tabs, a top/bottom split or icons) are done; remaining: Properties per context, Consolidate All Windows, floating panels outside the app window, context menus in the panels that have none, about 14 Preferences options stored but not yet acted on (#394: Highlight Alternate Glyphs, Open Documents As Tabs, Real-time Drawing, hyphenation language, devices…) | 13–20 |
 | Libraries, Links, Package | 2 | 82% | the Libraries panel is local only (no cloud by design: libraries are files on this machine) and has no shared libraries, linked graphics or gradients and patterns as items yet; its graphics, colours and text styles (#745), its search, groups and library export/import as `.vclibrary` files (#926), a list that scrolls, with items and groups reordered by dragging and items dragged into and out of groups, art and swatches dragged in added where they are dropped, and items shown as icons or in a list with their names, are done; Links and Package are done; placed VectorCraft documents are done (linked by default, vectors in every output, previews, Break Link, Expand, Edit Original, refresh on save) | 2–3 |
 | **Feature parity** | **103** | **~75%** | | **~210–330** |
 | Interaction-fidelity pass (side by side with Illustrator: every tool modifier, cursor, dialog, Properties context) | | | | 60–90 |
@@ -616,6 +618,7 @@ since 2026-10-01.
 - **Warp effects bend images:** a Warp effect on an image, or on a group that holds one, bends the image's pixels with its frame, as the Warp effect is documented to distort bitmap images in [Reshaping with effects](https://helpx.adobe.com/illustrator/using/reshaping-objects-effects.html): after the last effect, the image is cut into 10 × 10 cells of two triangles, each a clipped piece under its own affine map. Effects after the Warp reshape only the frame, a second Warp bends the same pieces, and warps saved without a version bend the pixels with their earlier map, as they bend the frame. A placed gradient on a group that holds the image follows the group's bounds as the pieces draw them. SVG writes the image once for the pieces; PDF, EPS, `.ai` and PNG write the bent pieces. The images stay unbent when their pieces would make the art pass 2 million objects, and so does an image whose frame keeps its shape past the anchor budget. A grayscale image's fill color now colorizes the pieces of a warp or an envelope, and an image under any geometry effect keeps that color and its smoothing setting. Existing documents with a Warp effect on an image, or on a group that holds one, draw differently: before, the image showed unbent, cut by the bent frame. So do existing documents with a colorized image under an envelope or a geometry effect, or an image drawn without smoothing under a geometry effect: before, those lost the color or the setting. The cell count and the limits are VectorCraft's own (effects `tests::warped_images_stay_within_the_object_budget`, `tests::warped_images_keep_document_keys_and_hidden_images_apart`, `tests::an_image_whose_frame_passes_the_budget_stays_whole`, `tests::effects_after_a_warp_reshape_an_images_frame_and_not_its_pieces`, `tests::an_images_pixels_take_the_map_their_warps_version_names`, `tests::an_image_under_a_geometry_effect_keeps_its_color_and_smoothing`, `tests::a_nested_groups_gradient_follows_its_warped_image`; engine `warp_images::an_images_pixels_bend_with_effect_warp`, `a_warped_image_keeps_its_bend_in_svg`, `a_warped_image_keeps_its_bend_in_pdf`, `a_warped_image_keeps_its_bend_in_ai`, `a_warped_image_keeps_its_bend_in_eps`, `a_warped_image_keeps_its_bend_in_png`, `svg_writes_an_image_clipped_twice_in_a_users_group_twice`, `expand_appearance_of_a_warped_image_draws_as_the_canvas_did`, `a_colorized_image_keeps_its_color_when_warped`, `a_warp_on_a_group_bends_the_image_in_it`, `envelope_distort::a_colorized_image_keeps_its_color_in_an_envelope`). Scores and hours unchanged.
 - **`.ai` files keep an image's Warp live:** an embedded image whose appearance is one Warp effect, with no opacity mask, is saved to the `.ai` editing data with an art style of that Warp: its bent pieces are its drawn look, and the image itself follows on `%_` lines, as for other styled objects. Opening an `.ai` file reads such an image as the image with its Warp live, its pixels, placement, name and opacity kept, when the live warp draws as the file's drawn look and the import has a comparison left; otherwise the drawn look stays, with the drawn-look note. The Warp effect applies to bitmap images ([the help page](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/distort-and-transform-effects-in-illustrator.html)), and native files keep live effects ([the help page](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/supported-file-formats-in-illustrator.html)). A linked image with a Warp is saved as its drawn art, as before, and its live Warp is not saved. Images with an opacity mask, and images with a Warp and another effect or with another geometry effect, are saved and opened as their drawn art. Existing `.ai` files with an embedded image on `%_` lines open differently: before, that image also came in beside its drawn look. Which images keep the Warp and the comparison are VectorCraft's own rules (eps `ai_editing::tests::an_image_with_a_warp_reads_back_with_its_warp_live`, `an_image_whose_warp_draws_otherwise_than_its_look_keeps_its_look`, `an_image_on_hidden_lines_does_not_come_in_beside_its_look`, `other_warped_images_are_written_as_their_drawn_art`, `import::ai::read::ops::tests::an_image_takes_a_style_of_one_warp_alone`). Scores and hours unchanged.
 - **EPS writes a repeated image's samples once:** an image drawn more than once in an EPS file (the pieces of an envelope or a Warp effect, copies of one image, or one image in a symbol's instances) has its compressed samples written once in the setup, and each placement reads them from there: a reusable stream rewound for each placement at Language Level 3 ([PostScript Language Reference, 3rd ed., §3.13](https://www.adobe.com/jp/print/postscript/pdfs/PLRM.pdf)), and an array of strings of at most 49,152 bytes fed to the image by a procedure at Level 2. An image drawn once is written where it is drawn, as before. The 256 MB limit on the page counts the samples once, so an envelope of a large photo no longer loses pieces to it. A colorized image is reused per ink (eps `tests::an_image_placed_twice_writes_its_samples_once_at_both_levels`, `tests::an_envelopes_image_pieces_draw_one_copy_of_its_samples`, `tests::each_ink_of_a_colorized_image_placed_twice_is_written_once`, `tests::samples_longer_than_a_string_are_reused_at_both_levels`, `tests::the_page_limit_counts_a_repeated_images_samples_once`). Scores and hours unchanged.
+- **PDF writes a warped image once:** with downsampling on, the pieces of an image bent by a Warp effect are resampled for the widest and the highest size any piece places the image at, so every piece paints one image XObject (a colorized image: one colorized image and its soft mask), instead of one image for each size a piece is placed at. Another placement of the same image is still resampled for its own size. Without downsampling, a colorized image and a CMYK image with a grayscale image mask on its grid are decoded and encoded once for all the sizes they are placed at (pdf `tests::compression::a_warped_image_is_written_once_for_all_its_pieces`, `tests::colorize::a_colorized_warped_image_is_written_once_for_all_its_pieces`, `export::images::tests::colorized_and_grid_masked_images_are_made_once_for_every_size_without_downsampling`). Scores and hours unchanged.
 - **Distort Appearance with Transform effect options:** with Envelope Options › Distort Appearance on, a path whose Transform effect has Scale Strokes & Effects or Transform Patterns on, or copies it with a gradient, is bent as the same per-copy art it draws and expands as outside the envelope: each copy's own stroke weight, dashes, pattern placement and gradient (effects `bake::tests`). Scores and hours unchanged.
 - **Fitted gradients turn with the Transform effect:** a gradient fitted to the object (not placed with the Gradient tool) turns, reflects and stretches with the object when its Transform effect rotates, reflects or scales it unevenly, as Object › Transform already does: the gradient is fixed to its fit on the geometry the effect takes, then follows the effect and the effects after it as a placed gradient does. Under moves and even scales it draws as a refit does, and a Transform effect that scales the object to nothing across leaves it fitted, with Scale Strokes & Effects or Transform Patterns on too, and on each copy. This holds on the canvas and in Object › Expand of the fill, for an object's own effects, a fill's or stroke's own, and a group's, where the gradients fitted to its paths, to its own fill, to the groups inside it and to its images' and symbol instances' own fills each fix to their own object's fit. Existing documents with such a Transform effect on fitted-gradient art draw differently: before, the gradient refit to the turned outline. The Gradient tool still shows a fitted gradient's vector at its unturned fit. How gradients follow the effect is VectorCraft's own rule; what the effect does to the object is described in [Distort and transform effects](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/distort-and-transform-effects-in-illustrator.html) (effects `bake::tests::a_fitted_gradient_turns_reflects_and_stretches_with_a_transform_effect`, `bake::tests::a_transform_effect_that_scales_to_nothing_leaves_a_fitted_gradient_fitted`, `group::tests::a_groups_transform_turns_the_gradients_fitted_to_its_members_and_its_own_fill`; render `objectfx::a_fitted_gradient_turns_and_reflects_with_its_transform_on_the_canvas`; engine `objexpand::a_fitted_gradient_turned_by_a_transform_expands_as_the_canvas_draws_it`). Scores and hours unchanged.
 - **Placed gradients follow Transform and Free Distort effects:** a gradient placed with the Gradient tool moves, turns and scales with the object when the object's Transform effect moves its outline, and each copy of the Transform effect takes it as many times as it takes the transform. Under Free Distort it moves and scales from the path's bounds before the effect to its bounds after it. This holds on the canvas, in export, in Expand Appearance, in Pathfinder and compound shapes, and in Object › Expand of the fill, for an object's own effects, a group's (the own fills of the group, of the groups inside it, of a symbol's art, and of the images and symbol instances it moves, included) and a fill's or stroke's own. A gradient on a path inside a group with a Transform effect now moves with the path (#2214 moved only the gradients of type), and so does a gradient on an image's or symbol instance's own fill. When a path keeps its shape because the effect would pass the geometry budget, the group's own gradients stay in place; a hidden path in a layer, which the layer's bounds leave out, does not hold them. A freeform gradient whose points were edited moves its points in the same way. How gradients follow each effect is VectorCraft's own rule; what each effect does to the object is described in [Distort and transform effects](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/distort-and-transform-effects-in-illustrator.html) (effects `bake::tests::a_baked_transform_moves_a_placed_gradient_with_the_path`, `bake::tests::a_strokes_own_transform_and_free_distort_move_its_placed_gradient`, `bake::tests::a_fills_gradient_follows_the_effects_around_its_transform_with_options`, `bake::tests::baked_free_distort_moves_placed_gradients_from_the_bounds_to_the_distorted_bounds`, `group::tests::a_groups_transform_and_free_distort_move_the_gradients_placed_on_its_paths`, `group::tests::a_groups_transform_moves_the_gradient_of_its_own_fill`, `group::tests::a_nested_groups_own_gradient_follows_the_outer_groups_transform_and_free_distort`, `group::tests::a_groups_transform_moves_the_gradients_placed_on_an_images_own_fills`, `group::tests::shape_art_moves_gradients_with_a_transform_effect`, `group::tests::shape_art_moves_the_gradient_of_a_symbol_instances_art_with_its_transform`, `tests::art_past_the_budget_keeps_its_own_gradients_in_place`, `tests::a_hidden_path_past_the_budget_leaves_a_layers_gradients_free_to_move`, `tests::edited_freeform_points_follow_a_transform_effect_and_free_distort`; render `objectfx::a_paths_gradient_moves_with_its_transform_and_free_distort`; engine `objexpand::a_placed_gradient_moved_by_a_transform_or_free_distort_expands_as_the_canvas_draws_it`). Scores and hours unchanged.- **Constrain Angle (#394):** General › Constrain Angle turns the arrow keys' axes (guides stay on the page's), holds Shift drags of the Selection, Direct Selection, Free Transform, Slice Selection, Reshape and Measure tools and the Pen's handles to the turned axes, and new rectangles, rounded rectangles, ellipses, grids, point and area type, Shift-drawn polygons and stars and the shape size dialogs are drawn along it with their bounding box turned; 0° and whole turns are exactly as before, quarter turns exact (<https://helpx.adobe.com/illustrator/desktop/manage-objects/arrange-objects/rotate-objects-by-specific-angles.html>). Tests: `tests_constrain_tools`, `tests_constrain_new` (engine), `geom` `constrain_axes` / `rotate_deg`, the shape, grid and type tool tests.
@@ -627,9 +630,10 @@ since 2026-10-01.
 - **Escape in Selection tool drags:** Escape during a Selection tool move or Alt-drag copy, a bounding-box scale or rotation, a marquee, or a corner widget, pie widget or bracket drag cancels it: the art returns to its state at the press, no copy is left, no undo step is added, the release does nothing, and the tool stays chosen. This is VectorCraft's own behavior. Regression tests: `escape_cancels_*` in `select/tests.rs` and `pie.rs`, and `escape_cancels_a_selection_tool_move_copy_scale_or_rotation` in `tests/selectescape.rs`.
 - **Selection passes through raster effects:** clicks with the Selection, Direct Selection and Group Selection tools (Group Selection's repeated click included), the Selection tool's pointer and marquee, Direct Selection's marquee, pointer and anchor highlight, and Group Selection's marquee (E for enclosed objects included) leave out the area that a drop shadow, a glow, a blur or another raster effect paints beyond an object. A click on a shadow selects the object under it, or nothing over an empty canvas, a repeated Group Selection click there adds the groups of the object under it, and a press on the shadow of a selected object does not move it ([the help page](https://helpx.adobe.com/illustrator/using/selecting-objects.html)). Over a shadow, Direct Selection highlights only the anchors of the object under it, and Group Selection keeps its own pointer and highlights no anchor, as it does everywhere (VectorCraft's own rule). No setting changes this. This covers paths, groups, type, symbol instances and images. Regression tests: `crates/engine/src/tests/select_effects.rs`.
 - **Global Edit: Shift-click leaves a match out:** while Global Edit is on, a Shift-click with the Selection tool on a highlighted match, or on an object inside a matched group, leaves that match out (`select.globalEditExclude`): it is no longer highlighted and later edits leave it as it is; the object the edit started from stays, and Global Edit ends when fewer than two matches are left ([Update assets quickly with Global Edit](https://helpx.adobe.com/ph_fil/illustrator/how-to/global-editing-sensei.html)). Regression tests: `a_shift_click_*`, `an_object_left_out_*`, `a_group_left_out_*` and `leaving_out_all_but_one_*` in `crates/engine/src/tests/globaledit.rs`.
-- **Global Edit leaves out groups holding type or images:** Select › Start Global Edit on a group that holds type or an image, at any depth, refuses to start, and such a group is not taken as a match, as Global Edit does not take images or text ([Edit similar objects globally](https://helpx.adobe.com/illustrator/desktop/manage-objects/edit-objects/edit-similar-objects.html)). The menu item checks only that the selection is a group; starting checks its contents. Regression test for a group holding type: `global_edit_needs_one_supported_object` in `crates/engine/src/tests/globaledit.rs`.
+- **Global Edit leaves out groups holding type or images:** Select › Start Global Edit on a group that holds type or an image, at any depth, refuses to start, and such a group is not taken as a match, as Global Edit does not take images or text ([Edit similar objects globally](https://helpx.adobe.com/illustrator/desktop/manage-objects/edit-objects/edit-similar-objects.html)). Regression test for a group holding type: `global_edit_needs_one_supported_object` in `crates/engine/src/tests/globaledit.rs`.
 - **Global Edit Options in the Control bar:** while Select › Start Global Edit can run, the Control bar shows a Global Edit Options dropdown that opens the same options as the Properties panel's (Match: Appearance, Size; On Artboards; Include Objects On Canvas; Result(s)); both set the same options. The dropdown is off while Global Edit is on; it sits after Recolor Artwork, ahead of the X/Y/W/H fields ([Edit similar objects globally](https://helpx.adobe.com/illustrator/desktop/manage-objects/edit-objects/edit-similar-objects.html)). Regression test: `the_control_bar_shows_the_global_edit_options` in `crates/ui-egui/src/chrome/tests.rs`.
 - **Global Edit's enabled check on large paths:** the check that decides whether Select › Start Global Edit can run on the selected path, compound path or symbol instance (which the Control bar makes every frame) measures the box of its anchors and handles instead of building and normalizing a copy of every anchor, with the same answer. On a 200,000-anchor path the check takes 0.7 ms instead of 2.2 to 3.0 ms. Regression tests: `support_*` in `crates/engine/src/cmd/globaledit.rs`.
+- **Start Global Edit is offered only for a group it can start on:** with a group selected, Select › Start Global Edit is disabled, and the Properties panel's Quick Actions and the Control bar do not offer it or its options, when the group holds type, an image or nothing, at any depth; the check walks the group's objects the same way, stopping at the first one Global Edit does not take. This is VectorCraft's own rule. Regression test: `start_global_edit_is_offered_only_for_a_group_of_supported_objects` in `crates/engine/src/tests/globaledit.rs`.
 - **Control bar's inline X, Y, W and H fields fit the bar:** the Control bar shows the inline X, Y, W and H fields only when all four, their labels as drawn in the current language and the W/H link fit inside the bar's margin; otherwise it shows the Transform link alone. This is VectorCraft's own layout rule. Regression test: `the_control_bar_shows_the_inline_transform_fields_only_when_they_fit` in `crates/ui-egui/src/chrome/tests.rs`.
 - **Control bar docks to the top or the bottom, or floats:** the Control bar's panel menu, at the bar's right end, has Dock to Top and Dock to Bottom, the edge in use checked and neither while the bar floats. Dragging the bar's gripper and releasing it within 24 points of the top (under the menu bar) or the bottom of the window docks it at that edge, with a band along that edge while it moves; releasing it farther from both edges floats the bar there, with its outline under the pointer while it moves, and a floating bar's gripper moves it or docks it again (`window.control.dock {edge: "top"|"bottom"|"float"}`), as the help page describes ([Control panel overview](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/control-panel-overview.html)). Escape cancels a gripper drag. The 24-point zones, the floating bar's 800-point width and first position, a release outside the window leaving the bar where it was, a window too short for a floating bar docking it at the nearer edge, the floating bar staying inside a window that shrinks, and keeping the edge and the floating position with the workspace, with older workspaces docking the bar at their edge, are VectorCraft's own rules. Regression tests: `the_control_bar_panel_menu_docks_it_to_the_top_or_the_bottom`, `dragging_the_control_bar_gripper_docks_it_at_the_nearer_edge`, `dragging_the_control_bar_gripper_away_from_both_edges_floats_it`, `floating_control_bar_moves_and_redocks_from_each_edge`, `floating_control_bar_menu_docks_to_either_edge`, `control_bar_drag_escape_restores_placement`, `control_bar_drag_release_outside_window_keeps_previous_placement`, `floating_control_bar_stays_reachable_in_tiny_and_resized_windows`, `the_control_bar_dock_command_takes_top_bottom_or_float` and `menus_stop_above_a_control_bar_docked_at_the_bottom` in `crates/ui-egui/src/chrome/tests.rs`, `saved_workspaces_restore_the_control_bar_edge` and `saved_workspaces_restore_floating_control_bar_position` in `crates/ui-egui/src/workspaces.rs`.
 - **Control bar panel menu turns groups of options on or off:** the Control bar's panel menu lists the bar's groups of options (Snapping, Anchor Points, Tool Options, Object Options, Image Options, Fill and Stroke, Opacity, Graphic Style, Character, Paragraph, Vertical Alignment, Align and Distribute, Transform, Artboard Options and Document Options) above Dock to Top and Dock to Bottom, each checked while it is on; a click turns that group off or on (`window.control.options {group, visible?}`), and a group that is off stays out of the bar even while its tool or object is selected, as the help page describes ([Control panel overview](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/control-panel-overview.html)). The list of groups and what each holds, every group on to start, a group that is off leaving its room to the groups after it, and keeping the groups with the preferences and the workspace are VectorCraft's own rules. Regression tests: `the_control_bar_panel_menu_turns_each_group_on_or_off`, `the_control_bar_keeps_its_label_and_menu_with_every_group_off`, `the_control_bar_panel_menu_scrolls_in_a_short_window`, `the_control_bar_options_command_turns_a_group_on_or_off`, `groups_that_are_off_leave_their_room_to_the_later_groups`, `the_artboard_tool_s_control_bar_follows_its_two_groups` and `the_anchor_points_group_holds_convert_and_anchors` in `crates/ui-egui/src/chrome/tests.rs`, `the_image_options_group_holds_the_image_and_trace_controls` in `crates/ui-egui/src/tests/place.rs`, `the_character_and_paragraph_groups_hold_the_type_controls` in `crates/ui-egui/src/panels/paragraph/tests.rs`, `saved_workspaces_restore_the_control_bar_groups` in `crates/ui-egui/src/workspaces.rs`.
@@ -655,6 +659,7 @@ since 2026-10-01.
 - **Delete Empty Artboards:** the Artboards panel menu item ([Delete artboards](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/add-edit-artboards/delete-artboards.html)) runs `artboard.deleteEmpty`: every unlocked artboard with no artwork goes with its guides in one undo step, artboard 1 stays when every artboard is empty and none is locked, and the panel makes an artboard that is left active; an artboard is empty when no object (hidden, locked and template art included; guides not) has visual bounds that meet or touch it, a group counting by its members and a clip group or clipping layer by its members inside the clip (our reading of "no artwork"; the pages give no finer rule). Engine tests in `tests/panelcmds.rs` (`delete_empty_artboards_*`) and the panel test `delete_empty_artboards_deletes_the_empty_ones_and_selects_one_left`.
   The menu item's enabled check measures nothing in a document with one artboard, and Save Gradient Preset's check reads the proxy's paint without measuring the object; both give the same answer as before. An artboard that no path's control points, grown by the farthest its strokes reach, can meet is found empty without measuring the path. With an open path of 200,000 anchors selected, the checks take under 0.01 ms instead of 21.9 ms and 17.2 ms in a release build; with a second, empty artboard, Delete Empty Artboards' check takes 0.85 ms instead of 42.1 ms. Tests `delete_empty_artboards_is_enabled_exactly_when_it_deletes_something`, `delete_empty_artboards_enabled_state_matches_the_command_on_varied_documents`, `empty_artboard_checks_match_the_visual_bounds_on_varied_strokes`, `the_empty_artboard_check_matches_measuring_every_artboard`, `the_save_check_matches_saving_with_and_without_a_gradient`, `the_unmeasured_proxy_paint_is_the_measured_one` and `the_unmeasured_proxy_paint_is_the_measured_one_on_varied_objects`.
   Delete Empty Artboards' enabled check measures each version of a document once, so the panel menu does not measure the document again on every frame while it is open. With an open path of 200,000 anchors across two artboards, the check takes under 0.001 ms on a later frame instead of 70.4 ms in a release build, and with 20,000 objects on two artboards it takes under 0.001 ms instead of 9.1 ms. Tests `delete_empty_artboards_check_measures_a_document_once`, `delete_empty_artboards_check_follows_each_change_to_the_document`, `delete_empty_artboards_check_follows_a_change_in_place`, `delete_empty_artboards_check_follows_a_document_switch` and `delete_empty_artboards_check_matches_measuring_after_varied_changes`.
+  Delete Artboards, Delete Empty Artboards and Cut Artboard remove all their artboards and those artboards' guides in one walk over the artboards and one over the ruler guides and layers, however many artboards go, instead of one walk over every guide and layer per artboard. The artboards, guides and selected guides left are the same as deleting the artboards one at a time. Tests `deleting_many_artboards_walks_the_artboards_and_guides_once` and `delete_empty_and_cut_artboards_walk_the_artboards_and_guides_once`.
   The Eyedropper, the Live Paint check for paint to sample, the Appearance panel's Characters chips and the colors the Libraries panel adds from the selection also read the proxy's paint without measuring the object; the Eyedropper measures it only to sample a gradient or a pattern, and the Libraries panel only for a gradient. The colors and paints are the same as before. With an open path of 200,000 anchors, the Live Paint check and the Eyedropper's sample for a point inside it take 0.004 ms together instead of 26.0 ms in a release build. Tests `samples_give_the_measured_proxy_paints_colors` and `colors_and_gradients_come_from_compound_paths_groups_and_colorized_objects`.
 - **Artboard history selection:** headless pointer/key tests in `panels/properties.rs` pass for panel New → Undo → Delete/Backspace/Properties, Duplicate → Undo → Delete, pruning removed indices and preserving valid multiselection. They assert board survivors, artwork and object selection, Move/Scale Artwork options, saved state and Undo/Redo. Full workspace CI passes.
 - **Artboard tab-switch follow-up:** changing the active document through its tab aligns the Artboard tool with the displayed board before Properties Delete; clicking the already-active tab preserves multiselection and Move/Scale Artwork options. Three headless `chrome::tests::artboard_document_tab_*` regressions cover actual tab A → B → A clicks followed by Properties Delete, surviving boards and guides, preserved artwork/symbols and Undo/Redo; controls cover same-tab multiselection, Move/Scale Artwork options and other tools. Historical focused validation on `dbd2497b` recorded one expected RED failure with two passing controls, then all three GREEN tests passed. All three also passed in historical full CI on `a0671777`. A full CI retry on the five-unit combined source at `a0671777` passed all seven stages with 6,613 test outcomes on 2026-10-14. An earlier full-CI run on the identical source panicked in the randomized `ai_mutated_save_never_panics` test; the cause remains unresolved. This five-fix batch does not claim to repair that failure.
@@ -662,6 +667,7 @@ since 2026-10-01.
 - **Colour emoji with bitmap glyphs:** `sbix` (Apple Color Emoji) and `CBDT` (Noto Color Emoji) glyphs draw as their largest strike's PNG, placed with the type and unpainted by its fill; PDF writes them in Type 3 glyphs or as images, SVG as images with outlined text, EPS and legacy `.ai` as images, and Create Outlines makes embedded images. Synthetic test fonts in `crates/text/src/test_fonts.rs`; tests `crates/text/src/tests/bitmaps.rs`, `crates/render/src/tests/bitmapglyphs.rs`, `crates/svg/tests/it/colour_glyphs.rs`, `pdf::tests::colour_bitmap_glyphs_export_as_images`, the `eps` `colour_bitmap_glyphs_*` tests and `tests_pathops::create_outlines_turns_bitmap_glyphs_into_images`. COLR and OpenType SVG fonts remain.
 - **COLR colour fonts:** v0 and v1 glyphs draw as vector layers (solid colours, linear and radial gradients, clips, blend modes, the foreground colour from the run's fill) on the canvas, as paths in SVG, EPS, legacy `.ai` and PDF with outlined text, as Type 3 text in PDF, and as editable groups with Create Outlines; sweep gradients and Porter-Duff compositing draw the glyph as an image. Measured by `tests_colr`, `render::tests_colrglyphs`, `pdf::tests::colr_glyphs_export_as_vector_art`, `svg/tests/it/colour_glyphs.rs`, `eps` `colr_glyphs_*`, `tests_pathops::create_outlines_turns_colr_glyphs_into_layer_groups`. Scores unchanged (estimated).
 - **OpenType SVG colour fonts:** each glyph's SVG document is read by the SVG importer (registered by the engine) into vector art in the run's colours, then drawn, exported and outlined as COLR glyphs are; PDF real text writes them as text that draws nothing and draws their art where they sit. Measured by `tests_svg_glyphs`, `svg/tests/it/svg_glyphs.rs`, `tests_colourfonts::create_outlines_turns_svg_glyphs_into_groups`, `tests_colourfonts::pdf_real_text_draws_svg_glyphs_as_art_and_keeps_their_characters`. Scores unchanged (estimated).
+- **Composite fonts that two documents define differently:** when two open documents each define a composite font (Type › Composite Fonts…) by the same name with different parts, each document draws and exports its type in its own definition: in a tiled or floating window drawn while the front document draws, when it is placed in a document that defines the name differently, and in an export made while another document is in front. Evidence: `tests::composite::nested_loans_of_one_name_use_each_documents_definition` and `threads_lending_one_name_at_once_use_their_own_definitions` (`crates/text`), `tests::fontchange::a_placed_document_draws_its_own_definition_of_a_name_the_page_defines` (`crates/render`). Scores unchanged (estimated).
 - **Character-style Auto leading:** capture and explicit style attributes retain Auto as a reset, distinct from omitted leading. Redefine and later numeric updates preserve local leading overrides; the Character Styles marker recognizes Auto correctly. Regression assertions cover partial definitions, Undo/Redo and native save/load serialization. Public references: [Character and paragraph styles](https://helpx.adobe.com/illustrator/using/character-paragraph-styles.html) and [Leading](https://helpx.adobe.com/illustrator/using/line-character-spacing.html).
 - **Character-style numeric bounds:** `charStyle.new`, `charStyle.edit`, and `charStyle.setAttrs` accept size from 0.1 to 1296 pt, explicit leading from 0.1 to 5000 pt, horizontal and vertical scale from 1% to 10,000%, and baseline shift and Tate-chu-yoko offsets from -1296 to 1296 pt. Out-of-range input leaves the style and Undo history unchanged; Auto leading remains available. These limits match the Character panel controls.
 - **Character Style Options, General and Basic Character Formats:** the dialog edits a style's name and stored character formats together. Empty fields remain unset, checkboxes show an indeterminate unset state, Basic's Reset Panel clears its explicit settings, and Preview can be canceled without changing history. OK saves one undo step; New Character Style offers the same fields from captured text or the interface language's defaults without a selection. Public reference: [Character and paragraph styles](https://helpx.adobe.com/illustrator/using/character-paragraph-styles.html).
@@ -870,6 +876,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - Hindi (2026-11-06): Hindi (`hi`): 7,877-row machine-assisted catalog, zero/one singular plurals, desktop font fallback and optional Devanagari craft-fonts fallback; all 55 translation tests pass; native review and a web font remain; scores and estimates unchanged. [Terminology and limitations](localization-hi.md).
   - Hindi wording (2026-11-13): rows outside the plug-in messages keep their English's meaning, quantities and clauses, and use the catalog's save, swatch, crop, resolution, path and type terms; a test checks those terms and the point unit in every row; native review remains; scores and estimates unchanged.
   - Hindi terms (2026-11-13): every row that names a variable (data merge, variable fonts and widths, environment variables) says वेरिएबल, and joining paths, anchor points, point type and lines says जोड़ें instead of शामिल हों, which stays for joining the community; a test checks both terms in every row; scores and estimates unchanged.
+  - Hindi English words (2026-11-13): 264 rows no longer keep English words in their sentences, repeat a parameter's name in Hindi or garble them, among them "unknown align", which now names the alignment; lists of accepted values such as `(left|right|top|bottom)` stay as their English writes them; two tests check every row; native review remains; scores and estimates unchanged.
   - Window › Help Bar shows or hides the tool-help strip at the bottom of the window apart from the status bar (`window.helpBar`). Each setting is kept with the UI preferences and in saved workspaces, and Presentation Mode hides both bars. Layouts saved before the setting existed show the Help Bar where they show the status bar (`help_bar_toggle_is_independent_and_saved_in_workspaces`, `help_bar_and_status_bar_render_independently`, `legacy_help_bar_visibility_follows_each_layouts_status_bar`, `a_help_bar_setting_the_file_lacks_is_saved`).
   - Czech render-site labels: desktop/web file filters, diagnostics, suggested preset names and contributor tooltips/plurals now use catalog lookups; gradients have Czech adjective agreement and printer marks have a separate context (PDF/Print and Summary). Search, Home, toolbar/panel tooltips and Preferences already look up their labels. Every complete catalog has rows for these labels and for the Roman and Japanese printer mark styles. Evidence: `i18n::tests::czech_render_site_follow_up`, `i18n::tests::complete_catalogs_translate_render_site_labels`, `dialogs::tests_modal::printer_mark_labels_are_distinct_from_language_names`; see [localization-parity.md](localization-parity.md).
   - The History panel, Edit › Undo and Edit › Redo translate the names of the steps that apply or redefine a character or paragraph style and of the step that redefines a graphic style: each such step keeps its template (`Apply {name}`, `Redefine {name}`, `Redefine Graphic Style “{name}”`) and the style's name, every complete catalog has a row for each template, and the panel and the menu show the style's name as the document holds it, except the Normal styles' names, which they show in the interface language (`steps_named_after_a_style_list_the_template_around_the_name`, `undo_and_redo_name_a_style_step_around_the_style_name`).
@@ -890,6 +897,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - Align New Objects to Pixel Grid (`document.setup {alignNewObjectsToPixelGrid}`, a checkbox in New Document's Advanced Options and a checked item in the Transform panel menu) gives every path and compound path drawn in the document, the paths of a new grid or flare included, the pixel-aligned property, snapped in the step that draws it; it is on in the Mobile and Web presets and off in the others, saved presets and Recent keep it, and the document saves it. Type, images and groups do not take it, and art already in the document, pasted, duplicated or placed keeps its own property (VectorCraft's own rules) ([Pixel-aligned property](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/pixel-preview-mode-for-web-graphics.html); `tests::pixelalign::align_new_objects_makes_new_paths_pixel_aligned`, `align_new_objects_reaches_grids_flares_and_add_on_shapes`, `align_new_objects_is_saved_and_read_back`, `tests::newdoc::align_new_objects_to_pixel_grid_follows_the_preset`, `panels::transform::tests::align_new_objects_menu_item_toggles_the_active_document`, `dialogs::new_document::tests::align_new_objects_checkbox_follows_the_preset_and_reaches_the_document`).
   - Object › Transform › Reset Bounding Box squares the box of every object inside the selected ones as well: the children of groups, compound paths, clip groups, blends, envelopes, repeats and intertwines, and the art of linked opacity masks. Ungroup and the release commands then bring back boxes square to the page (VectorCraft's own behavior; `bboxrotate::reset_bounding_box_squares_the_objects_inside_a_group`, `reset_bounding_box_squares_the_turned_members_of_a_square_group`, `reset_bounding_box_then_release_clipping_mask` and the other `reset_bounding_box_then_*` tests, `reset_bounding_box_leaves_the_art_of_an_unlinked_opacity_mask`).
   - After a rotation the Free Transform tool shows and drags the same turned bounding box as the Selection tool: its handles, their cursors and its rotate zone sit on the selection's own sides, a handle scales along those sides from the opposite handle ([the help page](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/scale-objects.html)), Cmd/Ctrl on a side handle shears along that side, and Perspective Distort and Free Distort start from the turned box's corners (`object.distort` takes `angle` with `from`). The Scale and Reflect tools, their dialogs and commands, and the Transform panel's flips keep the page's axes (VectorCraft's own rule; `bboxrotate::free_transform_handles_turn_with_the_object_and_scale_along_its_axes`, `free_transform_shears_along_the_turned_side`, `free_transform_distort_starts_from_the_turned_box`, `xform::distort_reads_from_in_a_turned_frame_and_rejects_a_bad_angle`, tools `xform::free::tests::the_box_and_its_handles_turn_with_the_selection`).
+  - Perspective Distort and Free Distort (`object.distort`) turn each warped object's bounding box as the warp turns the object at its own center, the objects inside groups, compound paths and clip groups and the art of linked opacity masks included, so the next Selection or Free Transform drag uses the tilted box; Object › Transform › Reset Bounding Box squares it again, and corners left where they are add no undo step (VectorCraft's own rule; `bboxrotate::distort_turns_an_upright_box_with_the_warp_at_its_center`, `distort_turns_each_member_and_linked_mask_by_its_own_warp`, `mirrored_and_collapsing_distorts_keep_valid_angles`, `distort_angles_undo_redo_and_reopen_together`, `xform::unchanged_distort_records_no_history`).
   - The Free Transform widget's Constrain works in Free Distort as well as in Free Transform ([the help page](https://helpx.adobe.com/illustrator/using/tool-techniques/free-transform-tool.html)). With Constrain on, or Shift held, a corner dragged in Free Distort moves only along the line through the opposite corner, in the box's own proportions, and the other three corners stay in place; on a turned box the line runs through the box's own corners. The line is VectorCraft's own rule. Cmd/Ctrl+Alt+Shift on a corner still drags in Perspective Distort, where Constrain stays unavailable (tools `xform::free::tests::free_distort_corner_keeps_to_its_diagonal_with_shift_or_constrain`, `shift_pressed_during_a_free_distort_drag_constrains_it`, `a_turned_box_is_constrained_along_its_own_diagonal`, `along_diagonal_of_a_degenerate_box`; engine `xform::free_transform_constrained_distort_keeps_the_corner_on_its_diagonal`; ui-egui `free_transform::tests::the_widget_sets_the_mode_and_a_corner_drag_then_distorts`).
   - Native macOS menu bar, vector tool cursors, a ⌘K command palette, middle-button panning with any tool. Native menus explicitly end tracking on command selection, outside window presses and Escape; menu updates wait until tracking ends, and a dismissing press never starts a canvas gesture (M14.8).
   - The Learn panel (Window › Learn, or Explore tutorials beside the search icon on the app bar) has a For you tab with a Get started section and a Quick skill guide card, and a Skills tab that lists VectorCraft's own skills with their tutorial counts and empty progress rings; a skill lists its tutorials, a tutorial shows its numbered steps, and Back goes up a level; `learn.list` and `learn.show {tutorial}` script it ([the help page](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/learn-skills-quick-skill-guide.html); `panels::learn::tests`).
@@ -1046,6 +1054,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     With the Blob Brush, Alt held before the press, or pressed before the drag has moved, switches to the Smooth tool, as the reference app's [Default keyboard shortcuts](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html) page lists: the cursor shows the Smooth tool, the drag shows a thin line and, with a path selected that it can smooth, the dashed band it smooths, without the length label, Shift does not constrain it, and the release smooths the selected paths under the drag (`path.smoothRegion`) instead of painting; with nothing selected the release changes no path. A stroke that has moved keeps painting when Alt goes down.
     Curvature point markers are circular, with no direction handles. While drawing, its own point feedback replaces generic selection markers; existing paths use the selection overlay, including partial selections and Hide Edges. Anchor Size applies, and Direct Selection and Pen retain their handles. The real egui-frame regressions in `crates/ui-egui/src/canvas.rs` verify marker positions, counts and unchanged documents (#1236, in part); the existing-path interpolation request remains open. The curve through the points (`curvature_spline` in `crates/tools/src/draw2.rs`) makes each stretch of three points follow the circle through them: a smooth point's handles lie along that circle's tangent, each `chord / (3 cos²(α/2))` long (α between handle and chord, capped at 90°), and the ends of an open path mirror their neighbour's tangent in their chord, so a J or a U curves evenly, a turn tighter than 30° comes to a point, and uneven spacing doesn't loop; the rubber band, a dragged or inserted point and `path.convertAnchor` to smooth use the same rule, while the Pencil's fitting keeps its own; `tests/draw2.rs` checks that the rubber band is the path the click makes (#1236, in part). The Smooth tool smooths only the stretch of path under the drag (#1547, fixes #1512). A path the Smooth tool changes stays selected whole, and the anchor points and segments selected on it with Direct Selection are deselected. Selected paths the drag does not change keep their selected anchors, and undo restores the earlier selection (`tests/draw2.rs`, `smoothing_a_path_drops_its_direct_selected_anchors`). While the Smooth tool drags with a path selected that it can smooth, a dashed outline shows the band it smooths: everything within its radius of the drag (12 screen pixels, VectorCraft's own value), round at both ends; Alt smoothing with the Pencil, Paintbrush and Blob Brush shows the same band.
     While Alt is held during a Paintbrush stroke or before a press with no path selected that the Smooth tool can act on, the Paintbrush shows a closing cursor (a crosshair with a ring), and so does the Pencil with Alt key toggles to Smooth Tool off when Alt is pressed after the drag starts; releasing the mouse button with Alt still held closes the path. Before a Paintbrush press with such a path selected, Alt shows the Smooth cursor, and holding Alt at the press smooths that path with the Smooth tool's radius and Smooth Tool Options' Fidelity. A Pencil drag started with Shift or Alt held draws a straight line instead, which stays open.
+    Smooth Tool Options' Fidelity is in pixels, as [the help page](https://help.adobe.com/archive/en_US/illustrator/cs3/illustrator_cs3_help.pdf#page=79) gives it: the Smooth tool, and an Alt smoothing drag with the Pencil, Paintbrush or Blob Brush, refits the path at Fidelity divided by the zoom, so a drag smooths a path as much on screen at 25 % as at 800 %. Reading the pixels as screen pixels is VectorCraft's own rule, as for the Pencil and the Paintbrush (#5729); the range (0.05 to 100 px) and the default (2.5 px) are VectorCraft's own values, and a saved Fidelity keeps its number (`crates/tools/src/draw2/gesture/tests.rs` test `smooth_fidelity_is_in_screen_pixels_at_any_zoom`, `crates/engine/src/tests/draw2.rs` test `smooth_region_refits_at_the_tolerance_sent_at_any_zoom`).
     With Shift held at the press, the Pencil draws a straight line from the press point to the pointer at 45° steps from the Constrain Angle, as [Draw straight lines with the Pencil tool](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/draw-shapes/draw-straight-lines-with-the-pencil-tool.html) describes; pressed on an end of a selected open path, the line continues the path from that end (part of #3799). With Option/Alt held at the press and Alt key toggles to Smooth Tool off, the Pencil draws a straight line at any angle, whose ends snap to Smart Guides, and it stays open when Alt is still held at the release; Shift and Alt together keep the 45° steps (#3799). While Shift or Alt is held before the press, the Pencil shows a straight-line cursor (a crosshair with a short line), and over an end of a selected open path, where the line continues the path, a path-continuation cursor (the same line leaving a small square), as the page describes.
   - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers). A click with a grid tool asks for the size, the divider counts and the grid options (#1377, in part): a skew for each set of dividers, Use Outside Rectangle As Frame or Create Compound Path From Ellipses, and Fill Grid; they are parameters of `shape.rectangularGrid` and `shape.polarGrid`, stay as the tool's options and apply to drags too. A shape just drawn stays adjustable with its tool: its Live Shape widgets drag, a press on its centre point (Show Center) moves the selection with the Selection tool's move arrow, snapping and Alt copy, and a press in the rotate zone just outside a bounding-box corner turns it about the centre with the Selection tool's rotate cursor (#5477; tests `a_shape_tool_moves_the_selection_by_its_centre_point_and_turns_it_from_a_corner` and, through the engine, `shapetools.rs`). A drag on one of its eight bounding-box handles scales it as the Selection tool's handles do, with their cursors and snapping, instead of drawing a new shape from the handle. A shape tool takes a press as a handle's only on the drawn handle square (VectorCraft's own rule: 3 screen points from its centre along each axis at the default Anchor Size, a half point more or less per step; the Selection tool takes 5), so a press just beside a handle still draws (tests `a_shape_tool_scales_the_selection_by_its_bounding_box_handles`, `a_shape_tool_draws_from_a_press_just_beside_a_handle` and `a_shape_tool_scales_the_shape_just_drawn_by_its_bounding_box_handle`). The curve a skew percentage follows and the direction of the radial skew are our own (the public documentation gives neither), and the dialogs have no reference point locator. An ellipse's Pie Start and End Angle and Invert Pie (Transform and Properties panels' Ellipse Properties, `object.setLiveShape {pieStart, pieEnd, invertPie}`) cut it as a pie (#812). With the bounding box showing, the Selection tool shows a selected ellipse's two pie widgets just outside it; dragging one sets its angle in one undo step and double-clicking one makes the ellipse whole again. A live polygon's Polygon Properties there: side count, angle, corner type and radius, radius, side length and Make Sides Equal once an uneven scale has made its sides differ (`object.setLiveShape {sides, polygonAngle, polygonRadius, sideLength, makeSidesEqual}`, part of #812); a star is a plain path, as in Illustrator. The Flare Tool Options last as the tool's options: the next flare dragged out uses them, a click's dialog shows them and double-clicking the tool opens them (part of #812).
   - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. The Flare tool's center drag turns the rays by 0.1 radian at each drag update in which the pointer's document y grows, and back by as much at each one in which it falls, Shift held keeps their turn, and Space held during either of its drags moves the flare. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers). A click with a grid tool asks for the size, the divider counts and the grid options (#1377, in part): a skew for each set of dividers, Use Outside Rectangle As Frame or Create Compound Path From Ellipses, and Fill Grid; they are parameters of `shape.rectangularGrid` and `shape.polarGrid`, stay as the tool's options and apply to drags too. The curve a skew percentage follows and the direction of the radial skew are our own (the public documentation gives neither), and the dialogs have no reference point locator. An ellipse's Pie Start and End Angle and Invert Pie (Transform and Properties panels' Ellipse Properties, `object.setLiveShape {pieStart, pieEnd, invertPie}`) cut it as a pie (#812). With the bounding box showing, the Selection tool shows a selected ellipse's two pie widgets just outside it; dragging one sets its angle in one undo step and double-clicking one makes the ellipse whole again. A live polygon's Polygon Properties there: side count, angle, corner type and radius, radius, side length and Make Sides Equal once an uneven scale has made its sides differ (`object.setLiveShape {sides, polygonAngle, polygonRadius, sideLength, makeSidesEqual}`, part of #812); a star is a plain path, as in Illustrator. The Flare Tool Options last as the tool's options: the next flare dragged out uses them, a click's dialog shows them and double-clicking the tool opens them (part of #812).
@@ -1062,6 +1071,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     Alt-drag with the Knife cuts in a straight line, and Shift+Alt-drag cuts at 45° or 90°, as [Cut objects using the Knife and Scissors tools](https://web.archive.org/web/20260926095638/https://helpx.adobe.com/illustrator/desktop/manage-objects/edit-objects/cut-objects.html) and [Default keyboard shortcuts](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html) describe. Alt counts only when held at the press; the dashed line runs from the press point to the pointer, stays straight after Alt is let go, and release sends `path.knife` with those two points. Alt pressed after the press leaves the cut freehand. Shift+Alt keeps the endpoint at 45° steps from the horizontal and vertical, whatever the Constrain Angle.
     With Smart Guides on, a straight Knife cut snaps to anchor points and paths: [Cut objects using the Knife and Scissors tools](https://helpx.adobe.com/illustrator/desktop/manage-objects/edit-objects/cut-objects.html) describes the Knife snapping to anchor points and paths while Smart Guides are on. Its ends snap as the ends of the Pencil's straight line do, to anchor points and path segments of art that is shown: the press, and the release of an Alt-drag. Shift+Alt steps 45° from the snapped press, and its release stays on that step. With Smart Guides off, or with Snap to Pixel or Snap to Grid on, the cut is not snapped. The dashed line and `path.knife` use the snapped points.
     Eraser Tool Options has Angle and Roundness besides Size, as [Erase paths using the Eraser tool](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/modify-paths/erase-paths-using-eraser-tool.html) describes: the Eraser's tip is an ellipse Size across, its long axis at Angle and its short axis Roundness percent of the long one, and a drag with a tip that is not round shows the outline of the area it erases (`path.eraseRegion` `angle` and `roundness`).
+    The outline a Blob Brush or Eraser drag shows is built a bounded amount per frame, so a long stroke does not slow the canvas: each frame takes at most 256 new points of the drag and outlines again only the pieces of up to 32 segments they change, and the parts of a piece's outline inside the rest of the area are removed a limited amount at a time. While work is left, the canvas draws again with the pointer still, the points not outlined yet show as a thin line, and the tip shows at the pointer. With Size set to Pressure the outline also shows only the edge of the whole area. The release sends the whole stroke as before (`path.blob`, `path.eraseRegion`).
   - **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).
     A Reshape drag stretches part of a path from the dragged point without losing the path's general form, as [Adjust path segments](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/modify-paths/adjust-path-segments.html) has it. On an open path the stretch reaches both ends: the end anchors stay in place, each anchor between moves less the nearer it lies to an end, and the handles of a smooth anchor stay in line (`path.reshape`; the reach and the shares are VectorCraft's own rule, in `docs/mcp.md`). A click sets a focal point and a click on a segment adds a highlighted anchor there; Shift-click adds more, and a drag from any of them moves them all. The anchors that are not direct-selected stay in place and a closed path selected whole moves whole (VectorCraft's own rule, in `docs/mcp.md`).
     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. Align and Distribute act on the anchor points selected with Direct Selection: the points of one path align to each other, not to the artboard, and Distribute spaces them (#1641, fixes #1636; aligning to a key anchor is still missing).
@@ -1090,6 +1100,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - **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). Join merges the selected anchor points that lie on one another, as after Average, into one anchor (#1582, fixes #1533), and removes the merged anchors in one pass over the path, so a long run of them no longer moves the anchors after it once per merge (`cmd::path::tests::a_long_run_before_many_other_anchors_merges_in_one_pass`); Object › Path › Average & Join… (`path.averageJoin`, Cmd+Alt+Shift+J, the "Create corner or smooth join" shortcut of [Default keyboard shortcuts](https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html)) moves two open path ends to their midpoint and joins them there, a corner or smooth point as its dialog's Points choice asks, in one undo step.
   - **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, the paint, weight, opacity and blend mode of a mark's top visible fill or stroke row after an Appearance command or a graphic style (each given a mark or its series picked with Group Selection), the Eyedropper, Default Fill and Stroke or Swap Fill and Stroke, the paint or stroke weight a stroke weight, gradient or recolor command changes there, and a mark's object opacity and blend mode, are kept separately on the graph and reapplied when its data, type or size changes, and through save, open and undo. A series that draws Filled Lines bands keeps no stroke paint or weight: its bands are drawn again with their 0.25 pt black outline. 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 designs: Object › Graph › Design lists the designs with a preview of the selected one, and New Design (the selected art), Rename, Delete Design, Paste Design (a copy back to edit) and Select Unused, and Marker draws the data points and legend swatches of line, scatter and radar series with a design, scaled so its backmost object fills the default marker's square. Graph Data transposes rows and columns and switches a scatter graph's x and y, and a `|` in a category or series label starts a new line. Pie graphs take Legends in Wedges, Position (Even, Ratio sized by area, Stacked on one centre) and Sort (None, All, First). Graph Type takes column and cluster widths up to 1000% (overlapping past 100%) with First Row and First Column in Front (First Row orders each series' categories; across series the series order decides, so series stay one group each for Group Selection), draws filled lines, adds drop shadows behind columns, bars, lines and wedges, and puts the legend in rows across the top. Text formatted with the Character, Paragraph, Appearance, Transparency or Graphic Styles controls or the Eyedropper, or recolored, given Swap Fill and Stroke or Default Fill and Stroke, or given stroke options or a gradient, on the whole graph or on labels picked with Group Selection, is kept per kind of label (value axis numbers, category labels, legend labels) through the graph being drawn again, the paint, weight, opacity and blend mode of a label's topmost visible fill and stroke rows and its object opacity and blend mode included. Object › Graph › Data opens a worksheet: cells picked with a click and edited above the sheet (Tab moves right, Enter down, the arrows between cells), Import Data from a tab-separated text file, Transpose, Switch x/y, Cell Style (decimals shown, column width), Revert and Apply. `graph.setData` returns and takes the data as CSV with each value written exactly, not rounded to two decimals, so applying the returned CSV changes nothing (#1485).
     An Eyedropper pick that includes transparency and leaves a mark's top fill or stroke row without paint, or removes that row when the source has no row of that kind, where that row had paint before, also replaces the opacity and blend mode the graph keeps for that kind of row in the series; a row that had no paint before the pick leaves them as they are.
+    What Global Edit gives a mark from another match (in an isolated graph) is kept on the graph the same way, and so is the object opacity, with its blend mode, that Randomize Opacity and Sort Objects change on marks.
   - **Graph column designs:** Object › Graph › Column (`graph.column`) draws the columns, bars or stacked segments and the legend swatch of the series picked with Group Selection with a graph design: Vertically Scaled stretches it to each column's length, Uniformly Scaled scales it both ways and centers it, Repeating stacks a copy for each Each Design Represents value and chops or scales the last one (For Fractions), and Sliding keeps the part above the design's guide line in proportion and stretches the part below. The dialog lists the designs with a preview; the choice is saved with the graph and follows the design's rename and delete.
     Type in a column design that holds a `%` followed by two digits shows each column's value in place of the `%` and the digits: the first digit is the least number of places before the decimal point (zeros are added in front; 0 gives as many as the value needs), and the second digit sets the places after it, rounded. Unless it is inside a group that clips or has its own opacity or appearance, or inside a blend, compound shape, envelope, repeat or intertwined objects, the type keeps its size and is drawn once per column in a repeating design. The legend swatch leaves it out.
   - **Other:** Eyedropper, Gradient annotator, Artboard (Alt-drag duplicates an artboard, and its art with Move/Copy Artwork with Artboard on; Copy, Cut and Paste take the artboard with its art, Paste right of the last artboard, Paste in Place where it was, into this or another document, #446; Object › Artboards › Rearrange All Artboards lays them out in a grid by row or by column, in one row or one column, left to right or right to left, from the menu, the Artboards panel or Properties' Rearrange All, #681; Scale Artwork with Artboard, in the Control bar and Properties beside Move Artwork with Artboard, resizes the artboard proportionally with the art fully inside it and its guides, strokes and corners per the Scale preferences, #602), Measure, Type, Hand, Zoom, Rotate View.
@@ -1106,6 +1117,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - **Temporary tools:** Cmd with any other tool drags with the selection tool used last (Selection, Direct Selection or Group Selection). Held Space pans and Cmd+Space zooms (Cmd+Alt+Space out) whatever the tool. A single-key tool shortcut held for 0.25 s or more, or held while its tool is used, chooses that tool only until the key is let go, and the tool active before comes back (after a drag in progress ends); a quicker press chooses the tool for good. This is VectorCraft's own rule and its own threshold, and General › Hold a Tool Shortcut to Use the Tool Temporarily (`holdToolKeys`, on by default) turns it off.
     Space held while the Zoom tool drags a marquee moves the marquee and keeps its size ([Default keyboard shortcuts](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html)). When Space is let go, the drag sizes the marquee again from where it moved to.
     A Space+Shift drag rotates the view whatever the tool, as a Rotate View tool drag does, and Shift does not round the angle to 15°.
+    While the Type tool edits text, Space types a space: held, it does not show the hand, pan or rotate the view, and Cmd+Space still zooms ([the help page](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html) lists the Spacebar as the Hand tool when not in text-edit mode). Test: `canvas::tests::space_types_a_space_while_editing_text_and_does_not_pan`.
   - **Swatches panel clicks:** Ctrl/Cmd-clicking New Swatch makes a spot color, and Ctrl/Cmd+Shift-clicking it makes a global process color.
   - **Panel drag and drop:** art dragged off the canvas onto the Symbols panel becomes a symbol, art dragged onto the Swatches panel becomes a pattern swatch, and art dropped on the Brushes panel opens New Brush for that art; a symbol dragged onto the canvas places an instance where it is dropped, and a brush dragged onto a path is applied to it.
     New Brush asks for the type of brush first, as the [Brushes](https://web.archive.org/web/20241230205225/https://helpx.adobe.com/illustrator/using/brushes.html) page (archived copy) describes. The Brushes panel's New Brush button, its menu's New Brush… and art dropped on the panel open the New Brush dialog, where Scatter Brush, Art Brush and Pattern Brush need selected or dropped art. OK opens that type's Brush Options for the new brush, and their OK makes the brush with the name and options set; Cancel in either dialog adds no brush (`ui.newBrush`). The menu's New Calligraphic Brush, New Bristle Brush and New Art, Scatter and Pattern Brush from Selection items still make a brush at once.
@@ -1120,6 +1132,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     The Pencil's and the Paintbrush's Fidelity is in screen pixels, the same at any zoom: their Tool Options give it in px, from 0.01 px on the logarithmic slider to 20 px and up to 100 px in the field, and the tool sends `path.freehand` the value in points at the current zoom (#5729). The Smooth tool's and the Blob Brush's Fidelity stays in points.
     `path.freehand` and `brush.freehand` take a Fidelity of up to 100 / 0.0313 pt (about 3194.89 pt), the 100 px field maximum at the lowest zoom (3.13 %), and reject a value outside their range with an error, so a Pencil or Paintbrush stroke drawn zoomed out keeps the Fidelity set in pixels (engine tests `pencil_fit_keeps_its_anchors_on_a_stroke_drawn_zoomed_out` and `pencil_takes_fidelity_within_its_range_and_rejects_the_rest`).
     Each drag of the Smooth tool smooths the stretch of a selected path in its reach along its length before refitting it within Fidelity, so a wobble wider than Fidelity is smoothed out and another drag over the same place smooths it further, as [the help page](https://helpx.adobe.com/illustrator/using/tool-techniques/smooth-tool.html) describes (`path.smoothRegion`). The smoothing spread (a third of the reach) and the rule that each refit stays within twice the distance the smoothing moved the path, so repeated drags do not drift from it, are VectorCraft's own. A drag over the whole of a closed path smooths it across its first anchor too, so a bump there is smoothed like any other and no corner is left; Object › Path › Smooth smooths a closed path across its first anchor the same way.
+    When a Smooth tool drag reaches the first or last anchor of an open path, that anchor stays where it is and the curve there leaves or arrives along the smoothed path within the reach, so a jagged first or last segment no longer sets the end's direction; an end where the smoothed path turns back by 90° or more keeps its segment's direction, and where the refitted stretch ends inside the path the curve keeps the direction of the part outside the drag. This rule is VectorCraft's own (`tests/draw2.rs`, `smoothing_an_open_path_turns_its_jagged_ends_with_the_path` and `a_smooth_drag_turns_only_the_end_it_reaches`).
     A Smooth drag along a curved segment smooths the stretch of it in the drag's reach even when neither of the segment's anchors is in reach, as [the help page](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/modify-paths/refine-paths.html) describes dragging along the path segment; the segment is cut where the drag enters and leaves the reach, and the parts outside keep their shape (`path.smoothRegion`). Paths of two anchors are smoothed too, and Alt with the Paintbrush smooths a selected two-anchor curve; a two-anchor straight line still gets the closed stroke. How the reach is found on a segment (samples no more than half the reach apart) is VectorCraft's own, and a straight segment is left as it is.
     Before a press that draws a new path, the Pencil cursor shows a small star, as [Draw freeform paths with the Pencil tool](https://web.archive.org/web/20260926095638/https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/draw-shapes/draw-freeform-paths-with-the-pencil-tool.html) describes; over a selected path within Edit selected paths' distance, which the press continues from an end or redraws, the star is not shown ([Reshape paths with the Pencil tool](https://web.archive.org/web/20260106004407/https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/draw-shapes/reshape-paths-with-the-pencil-tool.html)).
     Keep selected in the Pencil and Paintbrush Tool Options is on by default: while it is on, a stroke selects the path it draws or continues and replaces the earlier selection. While it is off, a new stroke leaves nothing selected, the earlier selection included, as the reference application starts the stroke by dropping it (#5752); a continued or redrawn path is deselected while the rest of the selection stays (`path.freehand` `keepSelected`).
@@ -1138,7 +1151,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     A Blob Brush stroke merges with the topmost path of its fill color and no stroke that it touches, and with the other such paths it touches in the same group or layer that are next to that path in stacking order with no other kind of object between them; matching paths in other groups or layers are left alone, as the Blob Brush tool guidelines in [Paint with fills and strokes](https://web.archive.org/web/20241219085603/https://helpx.adobe.com/illustrator/using/painting-fills-strokes.html) describe (`path.blob`).
 - **Ruler guides as layer objects:** a guide goes on the current layer, shows, hides, locks and is deleted with it, is listed in the Layers panel (its row selects it) and moves to another layer (`guide.setLayer`, or its row dragged onto that layer's rows); guides on a hidden or locked layer can't be selected, moved or deleted, Duplicate copies a layer's guides and Merge Selected and Flatten Artwork keep them on the merged layer; guides from files saved before guides had layers go on the top visible, unlocked layer when the document opens. A guide's row has its own eye and lock, which hide or lock that guide alone in one undo step and take part in a drag down either column ([help page](https://helpx.adobe.com/in_hi/tutorial-builder/user-guide/illustrator-tutorial-builder/-ai--examples-of-common-coach-marks.html) lists a Guide among the Layers panel's items); a hidden guide is not drawn and does not snap, a locked one is drawn and snaps but can't be selected, moved or deleted, and its own state is kept through save and reopen and while its layer is hidden or locked (`layer.setProps` on its `guide.list` id). Object › Lock › Selection and Object › Hide › Selection lock or hide a selected guide with the selected art, and Unlock All and Show All unlock or show such guides and select them ([help page](https://help.adobe.com/archive/en_US/illustrator/cs3/illustrator_cs3_help.pdf) for Lock and Hide Selection). A guide row dropped on the panel's trash deletes its guide, the trash deletes a guide its row selected, and after a click on a guide row Delete deletes the guide rather than the rows highlighted before ([help page](https://helpx.adobe.com/illustrator/desktop/measure-and-align/grids-and-guides/align-graphic-objects-with-guides.html) for deleting a selected guide). Not done: guides stacked among the art of their layer (they are listed above it). Lock Guides also locks the objects made into guides: they can't be selected, moved or deleted (#1543); they are drawn in the guide colour and style of Preferences, and a dragged selection snaps to ruler guides with Smart Guides on (#1583, fixes #1534). Preferences › Guides & Grid › Lock Guides by Default locks guides when the app starts; it is off by default, and new guides can still be dragged out of a ruler while guides are locked. The Transform panel shows a selected ruler guide's X or Y, and typing a value moves it (#1659, part of #1597). This is not established by the documentation we could find: the public help pages on guides, rulers and the Transform, Control and Properties panels (read again on 2026-10-14) describe selecting and dragging unlocked guides and the panels' X and Y for a selection, not a guide's position in a panel, and the one public statement of it is a user's [community answer](https://community.adobe.com/questions-652/adding-a-new-custom-guide-785586), which is not documentation. It is kept as a convenience pending the owner's decision, with no parity claim and nothing counted towards a score.
 - **Releasing ruler guides:** View › Guides › Release Guides turns the selected ruler guides into paths with no fill or stroke. An artboard guide becomes a line across its artboard, and a canvas guide becomes a line across the artboards (`view.guides.release {index?, ids?}`). A Cmd/Ctrl+Shift double-click with the Selection, Direct Selection or Group Selection tool releases the ruler guide or guide path under the pointer.
-- **Layers panel:** every layer, sublayer, group and object is a clickable row at any depth: a click highlights it and makes its layer current (new art goes there), Shift-click a range, Ctrl/Cmd-click toggles. Sublayers are no longer treated as objects: clicks, marquees, Select All and the Select menu take the art inside them, and each sublayer selects in its own colour. Selection squares on rows with selected art (click selects a row's art, Shift adds or removes; dragging the square moves the selection to another row, Alt copies), the eye and lock on every row with drag-down-the-column (one undo step), Ctrl/Cmd-click an eye for per-layer Outline, Alt-click an eye or lock to hide or lock the other layers (again: show or unlock them all), triangles with Alt to open or close everything inside, drag and drop rows above, below or into layers and groups with a drop line (Alt copies) and a dimmed copy of the row under the pointer (layers dropped in the empty space under the last row go below the bottom layer, #2260; dropped on the trash rows are deleted, on New Layer duplicated, as in Illustrator), inline rename, Delete key on highlighted rows. Buttons and the full panel menu: New Layer/Sublayer (Alt: options, Ctrl: on top), Duplicate, Delete, Options for Selection, clipping mask, isolation, Locate Object, Merge Selected, Flatten Artwork, Collect in New Layer, Release to Layers (Sequence and Build), Reverse Order, Template, Hide/Outline/Lock Others and Show/Preview/Unlock All, Paste Remembers Layers, Panel Options (row size, thumbnails per kind, Show Layers Only). Layer Options: name, colour (presets, each with a chip of its colour, or custom), Template, Lock, Show, Print, Preview (outline drawing and clicking) and Dim Images to %. Every operation is a command (`layer.move`, `layer.highlight`, `layer.merge`…) with validation against cycles and invalid nesting. A document opens with only its top-level layers open; the rows left open are saved in the native file (nothing is written for the default) and reopen that way. Only the rows scrolled into view are laid out, from a row list made once per change: a layer of 5,000 groups of 10 paths, all open, draws the panel in 0.4 ms a frame instead of about 29 s (#638).
+- **Layers panel:** every layer, sublayer, group and object is a clickable row at any depth: a click highlights it and makes its layer current (new art goes there), Shift-click a range, Ctrl/Cmd-click toggles. Sublayers are no longer treated as objects: clicks, marquees, Select All and the Select menu take the art inside them, and each sublayer selects in its own colour. Selection squares on rows with selected art (click selects a row's art, Shift adds or removes; dragging the square moves the selection to another row, Alt copies), the eye and lock on every row with drag-down-the-column (one undo step), Ctrl/Cmd-click an eye for per-layer Outline, Alt-click an eye or lock to hide or lock the other layers (again: show or unlock them all), triangles with Alt to open or close everything inside, drag and drop rows above, below or into layers and groups with a drop line (Alt copies) and a dimmed copy of the row under the pointer (layers dropped in the empty space under the last row go below the bottom layer, #2260; dropped on the trash rows are deleted, on New Layer duplicated, as in Illustrator), inline rename, Delete key on highlighted rows. Buttons and the full panel menu: New Layer/Sublayer (Alt: options, Ctrl: on top), Duplicate, Delete, Options for Selection, clipping mask, isolation, Locate Object, Merge Selected, Flatten Artwork, Collect in New Layer, Collect for Export (As Single Asset, As Multiple Assets), Release to Layers (Sequence and Build), Reverse Order, Template, Hide/Outline/Lock Others and Show/Preview/Unlock All, Paste Remembers Layers, Panel Options (row size, thumbnails per kind, Show Layers Only). Right-clicking a layer, sublayer, group or object row offers Collect for Export for that row, or for every highlighted row when it is one of them; guide and blend spine rows have no context menu. Layer Options: name, colour (presets, each with a chip of its colour, or custom), Template, Lock, Show, Print, Preview (outline drawing and clicking) and Dim Images to %. Every operation is a command (`layer.move`, `layer.highlight`, `layer.merge`…) with validation against cycles and invalid nesting. A document opens with only its top-level layers open; the rows left open are saved in the native file (nothing is written for the default) and reopen that way. Only the rows scrolled into view are laid out, from a row list made once per change: a layer of 5,000 groups of 10 paths, all open, draws the panel in 0.4 ms a frame instead of about 29 s (#638).
   With Paste Remembers Layers on, art copied from a sublayer pastes back into that sublayer, as [the help page](https://help.adobe.com/archive/en_US/illustrator/cs5/illustrator_cs5_help.pdf#page=223) describes art going back to the layer it was copied from: in the same document while the sublayer is still there, two sublayers of the same name in different layers kept apart; in another document by the names of the sublayer and the layers around it. These rules are VectorCraft's own: a missing sublayer is made inside its layer (a missing layer on top, with the sublayer inside it), in the paste's one undo step; of layers with the same names, the topmost chain that matches the most names wins, a shown and unlocked one first; a matched layer that is hidden or locked, or inside one that is, refuses the paste, and nothing is pasted.
   The Filter button at the right of Search All keeps the rows that are of an object kind ticked under By Object (paths, shapes, text, images, effects, groups, linked files, guides) and in a state ticked under By Layer (locked, hidden), with the rows that hold them; a section with nothing ticked takes every row. The filter combines with the search, the button is lit while a filter is on, and Clear All in its popup turns the filter off (`ui.layersFilter`). The filter lasts the session.
   The panel menu's Save Selection submenu has Save Selection…, Update Selection and Edit Selection…, enabled and run as in the Select menu, and lists the document's saved selections: choosing one selects its objects again (`select.recall`).
@@ -1215,6 +1228,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - A 3D effect on one fill or stroke ([the help page](https://helpx.adobe.com/illustrator/using/effects.html)) leaves the object's other fills and strokes drawn with the path's or compound path's fill rule, so an even-odd compound path keeps its holes in them; this holds for Extrude & Bevel, Inflate, Rotate and Revolve, and for the Classic Extrude & Bevel, Rotate and Revolve. Tests: `solids::tests::a_fill_or_stroke_without_the_effect_keeps_the_even_odd_hole`, `revolve::tests::a_fill_without_the_revolve_keeps_the_even_odd_hole`.
   - With caps and opaque paint, Extrude & Bevel (both kinds) and Inflate draw each side face of the fill's solid before the faces of the same object's strokes that overlap it (strokes on closed paths without dashes, a width profile or a brush, in a solid color or an opaque gradient), so the stroke's walls cover the fill's walls at concave corners instead of showing stripes of the fill. Tests: `solids::tests::a_fills_walls_are_drawn_before_the_stroke_faces_over_them`, `solids::tests::the_draw_order_moves_a_fill_wall_before_the_stroke_faces_it_overlaps`, `solid::tests::facets_tell_the_sides_from_the_ends_and_the_faces_turned_away`.
   - When the fill and strokes are at full opacity with Normal blending, under a stroke that leaves parts of the fill's edge uncovered (dashed, with a width profile or a brush, on an open subpath, or in a paint that may show through), Extrude & Bevel (both kinds) and Inflate cut each stroke face that passes through a face of the fill's solid, or of another of the shape's strokes, where their depths meet, and draw the faces of the shape's fill and strokes that overlap in the order of their depths where they overlap, instead of by the depths of their centers. Inflate orders a plain stroke the same way, since its fill can rise in front of the stroke. The fill no longer paints over a nearer dash, and a dash's end no longer covers the fill wall in front of it; a fill wall in a gap between dashes stays visible. The same order applies inside a group member's own opacity mask or blending mode, to a gradient with transparent stops under a colored light with graphics on its caps, and to Inflate in gradients under a colored light. Tests: `solids::tests::fill_walls_and_strokes_that_leave_gaps_draw_in_the_order_of_their_depths_where_they_overlap`, `solids::tests::local_order_puts_overlapping_fill_walls_and_stroke_faces_in_depth_order`, `solids::tests::a_stroke_face_through_a_fill_wall_is_cut_where_their_depths_meet`, `solids::tests::a_masked_members_fill_and_stroke_faces_go_in_one_order`, `solids::tests::a_colored_inflate_in_gradients_draws_its_faces_in_one_order`, `solids::tests::a_depth_cycle_keeps_the_cap_last`, `solids::graphics::tests::a_transparent_gradient_with_a_graphic_keeps_the_shared_face_order`.
+  - Without a twist, a tapered Extrude & Bevel wall (and each bevel band) is one flat face; only a twist cuts walls into slices, so no seam between slices paints a light tick or a light line on a tapered, untwisted wall (#7019). Test: `solid::tests::a_tapered_wall_is_one_flat_face_and_a_twisted_one_is_sliced`.
   - Extrude & Bevel, Inflate and Rotate apply to type: it makes a solid of its glyph outlines, painted with its own fills and strokes or, when it has none, its characters' colour (the first run's), and stays type, so editing the text reshapes the solid (#4715).
   - Extrude & Bevel, Inflate and Rotate (Effect › 3D and Materials): live effects in the `three-d` crate with depth, twist, taper, solid or hollow caps, five original bevel shapes (width, height, repeat, spacing, inside, both sides), Inflate's volume, both sides, twist, taper and cap, Rotate's turned fills and strokes, Position presets, the rotation and light gizmos, SVG/PDF vector output and Expand Appearance; one 3D effect per object; covered by geometry, effect, canvas-versus-export, command and dialog tests ([three-d.md](three-d.md)).
   - Extrude & Bevel and Inflate build detailed shapes: each solid takes up to 65,536 outline points and 163,840 faces (VectorCraft's own limits, was 2,048 points and 32,768 faces), counted before any point is sampled; when the faces do not fit, every curve takes fewer pieces, down to 4. A closed path of 2,000 curves extrudes with a bevel and inflates, and paths of 5,000 and 10,000 curves build at the default settings (`crates/three-d/src/solid/tests_limits.rs`).
@@ -1269,7 +1283,9 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
 - **Type:** Character size, leading, baseline shift and horizontal-scale controls account for object/group transforms (#1034): exact document-point sizes, mixed-value display and keyboard increments, range edits, resettable horizontal stretch, undo/redo and native save/reopen (`tests_typescale`, Character panel tests). Point size is the transformed em-height axis, independent of glyph ink bounds; affine rotation, reflection and shear are retained. Group scaling still scales text; preserving font sizes is a separate enhancement. Behaviour reference: [Transform text](https://helpx.adobe.com/illustrator/desktop/design-with-text/edit-format-text/transform-text.html) (public documentation). Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity) and Options (Flip, Align to Path, Spacing; OK keeps the type where it is), type on a path's start, centre and end brackets (Selection and Direct Selection drag them to set where the type runs, slide it along its path and, across the path, flip it: #429), Character and Paragraph Styles (override-preserving redefine), paragraph attributes per paragraph (alignment, indents, spacing, hyphenation, hanging punctuation, tab stops, paragraph style, direction, mojikumi and leading model; the Paragraph, Tabs and Paragraph Styles panels act on the paragraphs the Type tool's selection or caret touches, Return continues the paragraph's style, threads and SVG keep them), Area Type Options (rows/columns/inset/first baseline, Text Flow by rows or by columns (#4978), vertical Align Top/Center/Bottom/Justify per row/column, reflowing non-rectangular frames and text wrap), threaded text across any closed shapes, Fit Headline, the Every-line Composer for justified and ragged text (paragraph-wide breaks for an even rag, Single-line per object from the Paragraph panel menu or `text.setFormat {composer}`). Area type resizes like Illustrator's type areas: a bounding-box handle drag (Selection tool) or Area Type Options Width/Height size the frame and the text reflows at its size (threads too); Direct Selection drags a frame corner or edge (`text.reshapeArea`), and an anchor of the path of type on a path outside perspective, the type reflowing along it (`text.reshapePath`, #3980). Point type still scales. Auto Size: the frame height follows the text after every edit, in the same undo step (rectangular frames of horizontal type in one row; columns get the least height that holds them; a height set by hand or threading turns it off), and the "Auto Size New Area Type" preference gives it to new area type. Shrink Text to Fit (beyond Illustrator): overflowing area type scales its sizes, leading and baseline shifts down by the largest factor (in 0.1 pt steps of the first run, down to a minimum percentage) that fits, at layout time so every export sees it. `text.areaOptions` and `document.inspect` report overflow and the shrink factor. The Selection tool shows the type widget beside selected type's bounding box (hollow on point type, filled on area type); double-clicking it converts between them (Type › Convert To Area Type / Convert To Point Type), keeping the text and its styles in place. Variable fonts list every named instance as a style of their family (Figtree Light to Black and their italics, Bahnschrift, Segoe UI Variable), and the instance chosen is shaped, drawn, outlined and measured at its axis settings; PDF and SVG embed it as that instance. The Character panel's Variable Font sliders set each axis (see Fonts). Beyond Illustrator: inline graphics (`text.insertInline`, Type ▸ Insert Inline Symbol) set a document symbol in a run of type as one character that flows, wraps and justifies like a glyph (InDesign-style inline objects, e.g. mana symbols in card rules text): sized to a multiple of the font size, centred on the cap height, opening up tall lines, following Redefine Symbol; a character of its run's size for Character Alignment and Top-to-Top leading, placed by the bidi reordering in right-to-left text (a neutral U+FFFC); drawn on the canvas, kept as live text plus a `<use>` in SVG and as vector art in PDF; Backspace removes it whole. Hebrew and Arabic are laid out right to left with the Unicode bidirectional algorithm (embedded Latin and numbers keep their direction, lines put in visual order after wrapping) in point, area and path type, with caret, selection and arrow keys in visual order; each paragraph's direction comes from its first strong character unless Paragraph Direction sets it (Paragraph panel with Show Indic Options, `text.setFormat {direction}`), and new type aligns to the start of its direction. SVG export outlines right-to-left text. Arabic typefaces: builds made with a craft-fonts checkout that holds its Arabic families (Noto Sans Arabic, the Arabic fallback, plus Cairo, Tajawal, Almarai, IBM Plex Sans Arabic, Noto Kufi Arabic, Amiri, Alexandria, Fustat, Reem Kufi, Aref Ruqaa and Gulzar once craft-fonts adds them, storytold/craft-fonts#11; releases get them when their craft-fonts pin moves) list them in the font menus on desktop; the web build fetches them from beside the wasm (Noto Sans Arabic before start, so Arabic never shows as boxes, the rest in the background). Font Size and Leading are combo boxes in the Character and Properties panels (Font Size in the Control bar too, beside the Character link, font family and style): type, step with ↑/↓ or the spinner, scrub the label, or pick a preset (6–72 pt, shown in the type unit; Leading also Auto), each pick one undo step; Kerning and Tracking list -100…200; a size, leading, kerning or tracking the selected text doesn't share shows blank (#458). Type › Bold and Italic (beyond Illustrator, as page layout apps have them; Cmd+Shift+B / Cmd+Shift+I while the Type tool edits text) switch the selected type to its family's own Bold or Italic face and back, keeping its width (a Narrow face stays Narrow); a family without that face says so (#724). The commands that make or restyle type (and the MCP `add_text` tool) say in their result when area type does not fit its frame, and `add_text` takes Auto Size and Shrink Text to Fit (#1500, fixes #1471). Cmd+Shift+C (Align center) works on Windows and Linux too (#1940). A double-click on area type's bottom middle handle turns on Auto Size (#1940). Print and Print Preview warn about the area type and type on a path that prints without the text that doesn't fit, and give their ids. A tab stop in the Tabs panel drags from where the press landed, a stop just added included (#1487, fixes #1458). Area type in a non-rectangular shape moves a word too wide for the top lines down to the first line that holds it instead of breaking it (#1617, fixes #1615). Stylistic sets (ss01–ss20), stylistic and titling alternates, proportional and lining figures, and superscript and subscript glyphs can be turned on as OpenType features of a character style (`text.setStyle {features}`), and the OpenType panel keeps them (#1611, fixes #1607). Escape while typing ends the edit, keeps the type selected and switches back to the tool that was active before type editing began (kept while clicks move editing to other text), or to the Selection tool when there was none (#1802, #1686, #1656). Select › Same matches type on its characters' fill and stroke (#1746, #1737). `text.create`, `text.createInPath` and the MCP `add_text` tool take `justify`, so point type can be centred on or end at its point (#1752, #1748).
   The Character panel menu's Show Font Height Options shows a Set Font Height Reference dropdown under Font Size (`text.setFormat` or `text.setRangeStyle` `{fontHeightReference}`). Each reference shows an icon of the height it measures before its name, in the open list and in the closed field (#6304): a frame around a letter for Em Box, a bar from the baseline to the top of a capital for Cap Height and of a lowercase x for x-Height, and a frame inset in the em square for ICF Box. With Em Box, the default, the font size is the size of the em square; with Cap Height, x-Height or ICF Box, the characters are set at the em size at which the font's OS/2 cap height, its x height or the height of its ideographic character face equals the font size. With a font that has no such value, or one outside 0.1 to 2 em, the size measures the em box. SVG, PDF and legacy `.ai` export and the CSS Properties rules write the em size the characters are drawn at, and DXF export writes 0.7 times that em size as each TEXT entity's height (group 40, the height of its capitals). Behavior reference: [Vary font height](https://web.archive.org/web/20251118174722/https://helpx.adobe.com/illustrator/desktop/design-with-text/edit-format-text/vary-font-height.html).
   The Every-line Composer composes a paragraph whose characters differ in line metrics (type size, font, leading or vertical scale, or an inline graphic taller than the text) in area type of any shape, rows, columns and text wrap included. In a frame that is not a rectangle, or with text wrap, each line it tries is measured where the lines above it put it, across the line's own height, so a taller line gets the room of the narrower part of the frame, or of the span beside a wrap object, that it reaches. Such a paragraph is broken with the Single-line Composer when the frame has no room for all of it or when the search passes VectorCraft's own limits. Behavior reference: [the help page](https://helpx.adobe.com/illustrator/desktop/design-with-text/edit-format-text/set-hyphenation-and-line-breaks.html).
+  A text wrap object's Offset may be negative as well as positive ([the help page](https://help.adobe.com/archive/en_US/illustrator/cs4/illustrator_cs4_help.pdf#page=307)). A negative Offset (to -1000 pt) shrinks the wrap object by that distance, measured from each edge itself and from the edges of its holes, so lines beside it, above it and below it run that far into it, and an object narrower than twice the distance no longer moves text aside. With Invert Wrap, a negative Offset keeps the text that far inside the object. These are VectorCraft's own rules for the shape of the shrunk object. Text Wrap Options, `object.textWrap.make` and `object.textWrap.options` and the MCP `text_wrap` tool take the negative value, and layout uses it (`crates/text/src/layout/region.rs` tests, `cmd::textwrap::tests::text_wrap_options_negative_offset_reflows_and_round_trips`).
   In area type of a shape other than a rectangle, each line's whole band, ascent to descent, stays inside the frame: where an edge pinches in within the band, the line ends at the narrowest point, and a line runs beside a hole that starts and ends within its band, not across it. In area type of any shape, a line also stays clear of a text wrap object that reaches into any part of its band, and inside an Invert Wrap object over its whole band (`crates/text/src/layout/region.rs` tests).
+  With Invert Wrap, the spans a line keeps inside a wrap shape of many parts (a comb of 500 teeth) are found by stepping through the line's spans and the shape's spans once for each piece of the band, so the work grows with the number of spans, not with its square (`crates/text/src/layout/region.rs` tests).
   The Character panel's Small Caps, Superscript and Subscript buttons and the panel menu's items of the same names turn small caps and the superscript or subscript position on and off for the selected type, or for the text the Type tool has selected (`text.setFormat` or `text.setRangeStyle` `{smallCaps, position}`), in Document Setup's proportions. Turning Superscript on turns Subscript off, and turning Subscript on turns Superscript off. A button or item shows as on when the first selected character (at a caret, the character before it) has its attribute.
   The Character panel's Anti-aliasing Method dropdown, under Character Rotation, sets how the edges of the selected type objects are drawn as pixels (`text.setFormat {antiAlias}`), for the whole object, with each frame of a thread keeping its own method and graph labels keeping it when the graph is drawn again, on the canvas, in raster exports and when the type is rasterized. VectorCraft defines the methods: Sharp, the default, draws edges as before; None paints a pixel only where the type covers at least half of it; Crisp shows a pixel covered by a share c at `2c - 0.5`, and Strong shows it at `2c`, each kept between 0 and 1. SVG, PDF and EPS export are unchanged. Scores and hours unchanged.
   The OpenType panel's Stylistic Alternates and Titling Alternates checkboxes turn `salt` and `titl` on and off for the selected type, and its Figure menu lists Default Figure, Tabular Lining, Proportional Lining, Proportional Oldstyle and Tabular Oldstyle; Proportional Lining sets `pnum` and `lnum` and turns `tnum` and `onum` off, Tabular Lining turns `pnum` off and keeps `lnum`, Proportional Oldstyle turns `lnum` off and keeps `pnum`, and Default Figure and Tabular Oldstyle turn `pnum` and `lnum` off. Behavior reference: [Format text with OpenType features](https://helpx.adobe.com/illustrator/desktop/design-with-text/special-characters-glyphs/format-text-with-opentype-features.html) and [Use swashes, titling alternates, or stylistic alternates](https://helpx.adobe.com/illustrator/desktop/design-with-text/special-characters-glyphs/use-swashes-titling-alternates-or-stylistic-alternates.html) (public documentation). Tests: `panels::opentype::tests`.
@@ -1283,7 +1299,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   Exports to PDF, EPS, SVG, EMF, WMF and the raster formats warn about the area type and type on a path that they draw without the text that doesn't fit, and give their ids, as Print and Print Preview do.
   On a shaped area type frame, Inset Spacing keeps text that far from the frame's edge, holes included, measured from the edge itself rather than along the line; the archived help treats the inset as the space an area type object leaves between its text and the path that bounds it (<https://help.adobe.com/archive/en_US/illustrator/cs5/illustrator_cs5_help.pdf#page=317>, <https://web.archive.org/web/20220911143322/https://helpx.adobe.com/pdf/cs6/illustrator_reference.pdf#page=325>). A rectangular frame keeps its inset from each side as before, and a column's inner edges keep it once. Tests: `layout::region::inset_on_a_shaped_frame_is_measured_from_its_sloped_edge`, `inset_keeps_text_clear_of_a_hole_s_sloped_edges`, `inset_applies_once_at_a_column_s_edge_and_at_the_frame_s_edge`.
   An edit copies a thread's story only when it changes one of the thread's frames: with a story of 50,000 characters threaded through 8 frames with a style change at every word, moving another object took 7.8 ms and now takes 0.013 ms, and a frame of a drag took 7.2 ms and now takes 0.012 ms (release build, `threaded_story_edit_timing`).
-  When a story flows through threaded area type, each frame is measured with the whole paragraphs of the story that it needs and a few more, not with the whole rest of the story, and it keeps the same text as before. A story of 1,500 one-line paragraphs (55,892 bytes) through 40 frames was laid out over 2,126,762 bytes of text while the frames were measured, and is now laid out over 21,035 (`thread::tests::many_frames_measure_about_the_text_they_take`). Area type with its lines aligned to the center, the bottom or justified vertically, and type on a path whose first paragraph is aligned Left, Justify Left or Auto, are measured the same way: the same story through 40 area frames aligned to the center was laid out over 2,126,762 bytes and is now laid out over 21,035, and through 40 paths aligned Left over 2,135,202 bytes and now over 20,583 (same test). Shrink Text to Fit, Dynamic Text, Optical Margin Alignment and Roman Hanging Punctuation on a path, a path aligned another way, horizontal type on a path whose first paragraph is set right to left or with right-to-left text in the rest of the story, and a frame whose share ends in the story's last paragraph are still measured with the whole rest.
+  When a story flows through threaded area type, each frame is measured with the whole paragraphs of the story that it needs and a few more, not with the whole rest of the story, and it keeps the same text as before. A story of 1,500 one-line paragraphs (55,892 bytes) through 40 frames was laid out over 2,126,762 bytes of text while the frames were measured, and is now laid out over 21,035 (`thread::tests::many_frames_measure_about_the_text_they_take`). Area type with its lines aligned to the center, the bottom or justified vertically, and type on a path whose first paragraph is aligned Left, Justify Left, Justify All or Auto, are measured the same way: the same story through 40 area frames aligned to the center was laid out over 2,126,762 bytes and is now laid out over 21,035, through 40 paths aligned Left over 2,135,202 bytes and now over 20,583, and through 40 paths aligned Justify All over 2,135,202 bytes and now over 20,583 (same test). Shrink Text to Fit, Dynamic Text, Optical Margin Alignment and Roman Hanging Punctuation on a path, a path aligned to the center or the right, horizontal type on a path whose first paragraph is set right to left or with right-to-left text in the rest of the story, and a frame whose share ends in the story's last paragraph are still measured with the whole rest.
   A paragraph that continues from one threaded frame into the next has its first-line indent and bullet or number in the frame where it starts; in the next frame its first line starts where its wrapped lines start. In frames that are no longer threaded, copies of a frame and point type converted from one, the first paragraph has its indent and bullet or number again.
   In threaded text, a paragraph format given to the empty paragraph after a frame's last paragraph break stays after the story flows again, in that frame and in the frames the paragraph continues into, unless the same edit also formats the next frame's first paragraph, whose format then applies (VectorCraft's own rule; `thread::tests::restyled_empty_last_paragraph_wins_over_unedited_next_frame`, `cmd::threads::tests::editing_a_frames_empty_last_paragraph_survives_thread_reflow`).
   Type › Convert To Point Type on a frame of threaded text makes point type of the text that frame holds and takes it out of the thread; the story flows through the other frames without that text, so each character is in the document once.
@@ -1310,6 +1326,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   The frames of threaded text share one writing direction: Type › Type Orientation (`type.orientation.vertical`, `type.orientation.horizontal`) in one frame sets every frame, threading frames gives the thread its first frame's direction, frames taken out of a thread keep theirs, and the story flows through every frame in the thread's direction.
   Type › Optical Margin Alignment (`type.opticalMarginAlignment`) hangs the punctuation and letter edges at the ends of a type object's lines outside its margins: at the left of left-aligned lines, at the right of right-aligned lines, and at both ends of centered and justified lines, in point and area type of left-to-right paragraphs. Quotation marks, hyphens, full stops and commas hang wholly; asterisks, tildes, ellipses, en and em dashes, colons and semicolons hang by half; and A, V, W, Y, v, w and y hang by a tenth of their width. It is off by default and saved with the type object. Justification's Glyph Scaling leaves the glyphs that hang at their width, so they hang exactly their share, and Standard burasagari counts what hangs at a line's start as room before hanging a comma; `crates/text/src/tests/hang.rs` checks whole paragraphs with both composers, ragged, centred and justified, with Line-end Punctuation Half Width and bidirectional lines.
   Optical Margin Alignment and Roman Hanging Punctuation hang right-to-left paragraphs of point and area type, and type on a path whose first paragraph runs right to left, too. Auto aligns a right-to-left line at its right, or at the end bracket of a path, so it hangs there. A right-to-left line is read from right to left: where it hangs at its left margin, `."` ending it hangs both glyphs.
+  Type on a path with right-to-left text that does not fit shows the longest start of its text whose glyphs fit, also where tracking gives a letter a negative advance and a shorter start does not fit; the rest overflows or flows to the next threaded object (VectorCraft's own rule). Without hanging punctuation, and on a straight path or with no spacing, every start is measured without arranging it on the path again. With hanging punctuation, or spacing on a curve, when a letter has a negative advance, at most 32 of the starts that could fit are arranged one by one from the longest; when none of them fits, a binary search over the rest shows a start that fits, which is not always the longest (`overflowing_rtl_type_on_a_path_shows_the_longest_start_that_fits`, `the_longest_rtl_start_on_a_path_is_found_without_arranging_each_start`, `the_longest_rtl_start_on_a_path_is_the_one_each_start_gives` and `rtl_type_on_a_curve_whose_letters_take_the_line_back_is_arranged_a_bounded_number_of_times` in `crates/text/src/tests/bidi.rs`). Right-aligned and centered type on a curve with Spacing is placed by what its glyphs take where the line ends up, so text that fits is not cut off at the end bracket (`on_path_aligned_spaced_text_that_fits_shows_whole` in `crates/text/src/tests.rs`).
   The Paragraph panel menu's Kinsoku Shori Type (`text.setFormat {kinsokuType}`, with the East Asian options) picks Push In First, Push Out First or Push Out Only for each paragraph: a character the Kinsoku Set keeps off a line's start or end is set on the line, with the line's gaps next to CJK characters closed by at most a tenth of an em each to fit, or moved to the next line with the character before it. Push Out First pushes in only when pushing out would leave the line more than an em short. Push Out Only is the default, the setting is saved only when it is not, and paragraph styles carry it.
   The Paragraph panel menu's Bunri-Kinshi (`text.setFormat {bunriKinshi}`, with the East Asian options, and the East Asian Composition Settings section of Paragraph Style Options) keeps inseparable pairs on one line in each paragraph that has it: two em dashes, two ellipses, two two-dot leaders and the two halves of a vertical kana repeat mark (the pairs of W3C JLREQ's class cl-08, VectorCraft's set). Both composers and vertical type follow it, and justification adds no space inside a pair. It works with a Kinsoku Set only, is off by default and is saved only when on; editing the set of pairs is not available.
   The Paragraph panel menu's Korean Line Break Anywhere (`text.setFormat {koreanLineBreakAnywhere}`, with the East Asian options, and the East Asian Composition Settings section of Paragraph Style Options) sets for each paragraph whether a line may break between any two Hangul syllables. When it is off, a word that contains Hangul breaks only at its spaces and after punctuation, or where the word is wider than the line, and takes no hyphen. New type has it off; paragraphs saved before the option read as on, so their lines do not move.
@@ -1372,6 +1389,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
 - **Create Strokes baseline (2026-10-17, measured):** the ignored centre-lines class covers 23 exact code-drawn scenes in aa and hard variants, including junctions, crossings, fills meeting strokes and varying widths. [Baseline and metric definitions](image-trace-quality.md#centre-lines). Topology is recovered from emitted geometry; width-profile metrics remain unavailable. No behaviour change or score increase.
 - **Image Trace, collapsed loops keep few segments:** a loop whose fit collapses to one cubic keeps the fewest segments that hold its area and course, so a higher Paths gives no fewer segments; a code-drawn Paths sweep in `crates/trace` (see [quality notes](image-trace-quality.md#collapsed-loops-keep-few-segments)).
 - **Image Trace, stacked layers only under their own areas:** with Method Overlapping, a layer reaches under the colors above it only within the connected areas that hold its own color, so a shape that sits apart from a color is no longer written again, at the same bounds, in that color, and the edge of that color's layer no longer shows through that shape's anti-aliased rim. *Measured* by `crates/trace/tests/quality` on each preset's own inputs: High Fidelity Photo 121 paths to 69.6 with ΔE 1.74 to 1.72, Low Fidelity Photo 37.1 paths to 26.1. Code-drawn disc, square and line tests in `crates/trace`.
+- **Image Trace, Overlapping shapes filled whole:** with Method Overlapping and Fills (without Create Strokes), each shape is filled whole, and the area of other colors it encloses is traced again as shapes of its own and stacked above it, so each enclosed outline is fitted once; this fill rule and its work budget (four times the image's pixels, counted as at least 65,536, times its colors) are VectorCraft's own. A shape keeps a hole where the area holds a transparent pixel or a color left out, and an area past what is left of the budget keeps its holes. Expand by Color starts another group of a color where an area is drawn above the shape around it. Code-drawn nested disc, ring, frame, Keep Colors, transparency and budget tests in `crates/trace`.
 - **Image Trace, notches read only their own piece:** the notch rule of `subpixel::outline` reads only the shared piece, so both regions of an edge cut a corner pixel alike and leave no gap; a code-drawn noisy multi-colour coverage test in `crates/trace` (see [quality notes](image-trace-quality.md#notches-read-only-their-own-piece)).
 - **Image Trace, same shift from either side of an edge:** a crack's sub-pixel shift is averaged from its two sides, so abutting regions on one- and two-pixel slivers get the same points and leave nothing uncovered; code-drawn regressions in `crates/trace` (see [quality notes](image-trace-quality.md#same-sub-pixel-shift-from-either-side-of-an-edge)).
 - **Image Trace, band borders in smooth areas:** in Color and Grayscale traces, a border between two colors where the image changes gradually is the contour of a smooth area, by VectorCraft's own rule (`subpixel::low_contrast`, distances measured in RGB, 0 to 255 a channel): next to the border the image makes less than half the step between the two colors; it makes more of the step a few pixels further out, or changes by a distance under 12 (about 7 levels in each channel of a gray); the pixels on each side change too; and its whole change next to the border is under twice its change from one color towards the other, or under 24. Grayscale reads each pixel as its gray, for this rule and for every edge's sub-pixel position. Such a border is smoothed over about 4 px instead of 0.5 px (0.9 px for an edge without anti-aliasing), keeps no corners and is fitted to at least 0.5 px, so band borders in photos and gradients follow the image's contours with fewer anchors; without Shapes, both colors beside it share the same curve. Color traces of clean flat-color art and Black and White traces are unchanged, Grayscale traces of colored art place their edges closer to the art's outlines, and noisy flat-color art can take fewer anchors where noise splits a color into bands; see [quality notes](image-trace-quality.md#band-borders-in-smooth-areas). Tests: `tests::the_borders_of_a_gradients_bands_follow_its_contours`, `layers::tests` and `subpixel::tests` in `crates/trace`. Scores and hours unchanged.
@@ -1411,6 +1429,8 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   View › Show Live Paint Gaps (`view.livePaintGaps`) draws the gaps of the selected Live Paint groups up to their Paint Stops At size, each in its group's Gap Preview Color, until Hide Live Paint Gaps or Hide Edges hides them ([Live Paint gaps](https://web.archive.org/web/20260105111201/https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/find-and-close-gaps-in-live-paint-groups.html)).
   Double-clicking the Live Paint Selection tool opens its Tool Options ([Live Paint Selection tool options](https://web.archive.org/web/20250904012025/https://helpx.adobe.com/illustrator/using/selecting-objects.html)): with Select Fills off, a click selects an edge instead of a face; with Select Strokes off, Alt-click selects a face instead of an edge; Color and Width set the color and width of the highlight on the face or edge under the pointer (red and 4 px by default). The options last across tool switches and are saved with the preferences (`tool.setOption {tool: "livePaintSelection"}`).
   As VectorCraft's own rule, OK in Live Paint Selection Tool Options, Live Paint Bucket Options, Gap Options and Tile Edge Color gives an error for a color with an alpha part (`#rrggbbaa` or `#rgba`) and changes nothing.
+  As VectorCraft's own rule, `tool.setOption` for the Live Paint Bucket and the Live Paint Selection tool, chosen or not, checks every value before it sets any: a switch that is not `true` or `false`, a `color` that is not an RGB color or a layer color's name, or that has an alpha part, a `width` that is not a number and an option the tool does not have give an error naming the option, and nothing is set or saved. A `width` outside 1 to 20 px is still set to the nearest end of that range. Saved settings that hold an invalid value still load, and the tool keeps its default for that option. Evidence: `tests::build::{live_paint_tool_options_refuse_invalid_values_and_change_nothing, live_paint_tool_options_take_rgb_colors_and_clamp_the_width, live_paint_tools_load_saved_settings_with_invalid_values}`.
+  As VectorCraft's own rule, `tool.setOption` for the Shape Builder, chosen or not, checks every value the same way: a switch that is not `true` or `false`, a `pickColorFrom` or `selection` that is not one of its names, a `gapLength` that is not a number, a `highlightColor` that is not an RGB color or a layer color's name, or that has an alpha part, and an option the tool does not have give an error naming the option, and nothing is set or saved. A `gapLength` outside 0 to 72 pt is still set to the nearest end of that range. Evidence: `tests::build::{shape_builder_tool_options_refuse_invalid_values_and_change_nothing, shape_builder_tool_options_take_valid_values_and_clamp_the_gap}`.
   A drag of 3 screen pixels or more with the Live Paint Selection tool draws a marquee and selects the faces and edges it touches, partly enclosed ones included, and a Shift-drag adds them to the selection or removes them from it ([Modify Live Paint groups](https://web.archive.org/web/20261006115247/https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/modify-live-paint-groups.html)). A click and a marquee change the selection on release, and Escape before the release leaves the selection as it was. Locked Live Paint groups, those on a locked layer or artboard, and in isolation mode those outside the isolated art are not highlighted or selected.
   A drag with the Live Paint Selection tool draws a marquee and selects the faces and edges it touches, partly enclosed ones included, and a Shift-drag adds them to the selection or removes them from it ([Modify Live Paint groups](https://web.archive.org/web/20261006115247/https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/modify-live-paint-groups.html)). A click and a marquee change the selection on release, and Escape before the release leaves the selection as it was. Locked Live Paint groups, those on a locked layer or artboard, and in isolation mode those outside the isolated art are not highlighted or selected.
   When the object the Blend tool picked first is deleted or undone away before the second click, the next click on an object picks that object first instead of doing nothing. Regression tests: `blend_tool_picks_again_when_its_first_pick_is_gone` in `meshblend.rs` and `the_blend_tool_picks_again_when_its_first_pick_is_deleted` in `tests/blendopts.rs`.
@@ -1489,10 +1509,11 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     Document Info has a Repeat Objects category after Embedded Images. It lists each radial, grid and mirror Repeat object by name with its kind and the number of instances it makes. For a grid it gives the rows and columns instead, followed by the number of instances it draws when that is fewer. With Selection Only it lists the Repeat objects in the selection. The Document Info report and Package's report list them too (`document.info {category: "repeats"}`, `repeatObjects`).
     Document Info's Pattern Objects category lists the objects whose fill or stroke is a pattern, the category the [Document Info panel](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/document-info-panel.html) page describes, each by name with the patterns it uses. With Selection Only it lists those in the selection, and the Document Info report and Package's report list them too (`document.info {category: "patterns"}`, `patternObjects`). Listing an object with a pattern fill and a pattern stroke once, listing objects inside groups and type objects whose characters use a pattern, and leaving out hidden fills and strokes, fills and strokes at an opacity of 0, strokes with no width, guides, a compound path member's own fills and strokes, an image's fills and strokes without a shape, characters the type does not draw and patterns no art uses, and counting the listed objects in Objects, are VectorCraft's own rules. Test: `cmd::docinfo::tests::info_lists_the_pattern_objects` (vectorcraft-engine).
     Document Info's Gradient Objects category lists the objects whose fill or stroke is a gradient, the category the [Document Info panel](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/document-info-panel.html) page describes as the count of objects with gradient fills or strokes. Each object is listed by name with the gradients it uses. With Selection Only it lists those in the selection, and the Document Info report and Package's report list them too (`document.info {category: "gradients"}`, `gradientObjects`). Naming a linked gradient by its swatch and any other gradient by its kind, and leaving out paint that draws nothing by the rules Pattern Objects follows, gradient swatches no art uses, gradient meshes and gradients drawn by effects, are VectorCraft's own rules. Objects counts the listed objects as Gradient Objects. Test: `cmd::docinfo::tests::info_lists_the_gradient_objects` (vectorcraft-engine).
-    Document Info's Spot Color Objects category lists the objects that use spot colors, the category the [Document Info panel](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/document-info-panel.html) page describes as objects using spot color separations. Each object is listed by name with the spot colors it uses. With Selection Only it lists those in the selection, and the Document Info report and Package's report list them too (`document.info {category: "spotColors"}`, `spotObjects`). Taking a solid color or a gradient stop linked to a spot swatch at a tint above 0 and a grayscale image colorized with one, leaving out process colors that look the same, Registration, gradients whose stops are all at an opacity of 0, fills and strokes at an opacity of 0, paint that draws nothing by the rules Pattern Objects follows, spot swatches no art uses and spot colors inside patterns, symbols, opacity masks, effects and placed files, are VectorCraft's own rules. Objects counts the listed objects as Spot Color Objects. Tests: `cmd::docinfo::tests::info_lists_the_spot_color_objects`, `spot_color_objects_take_colorized_images_and_skip_clear_gradients` and `spot_color_objects_skip_clear_fills_and_strokes` (vectorcraft-engine).
+    Document Info's Spot Color Objects category lists the objects that use spot colors, the category the [Document Info panel](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/document-info-panel.html) page describes as objects using spot color separations. Each object is listed by name with the spot colors it uses. With Selection Only it lists those in the selection, and the Document Info report and Package's report list them too (`document.info {category: "spotColors"}`, `spotObjects`). Taking a solid color or a gradient stop linked to a spot swatch at a tint above 0 and a grayscale image colorized with one, leaving out process colors that look the same, Registration, gradients whose stops are all at an opacity of 0, gradient stops at an opacity of 0 that mix only with other stops at an opacity of 0 or only over stretches with no width, fills and strokes at an opacity of 0, paint that draws nothing by the rules Pattern Objects follows, spot swatches no art uses and spot colors inside patterns, symbols, opacity masks, effects and placed files, are VectorCraft's own rules. A stop at an opacity of 0 next to a stop above it stays listed, since the stretch between them is drawn in its color. Objects counts the listed objects as Spot Color Objects. Tests: `cmd::docinfo::tests::info_lists_the_spot_color_objects`, `spot_color_objects_take_colorized_images_and_skip_clear_gradients`, `spot_color_objects_skip_clear_fills_and_strokes`, `spot_color_objects_skip_spot_stops_only_in_clear_stretches` and `drawn_stops_follow_the_sampled_stretches` (vectorcraft-engine).
     Document Info's Brushes, Spot Color Objects, Pattern Objects and Gradient Objects categories leave out hidden objects, objects at an opacity of 0 and the objects inside a hidden group or layer or one at an opacity of 0, their characters' paints and colorized images included. With Selection Only an object selected inside such a group or layer is left out too, and Objects still counts every object as before. This is VectorCraft's own rule. Test: `cmd::docinfo::tests::info_skips_paints_on_hidden_and_clear_objects_and_their_members` (vectorcraft-engine).
     Document Info's Save… writes the category the panel shows, with Selection Only applied, as the [Document Info panel](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/document-info-panel.html) page describes ("Exports the selected category's visible information to a text file"). With All Categories shown it writes every category, which is VectorCraft's own rule (`docInfo.save {category}`). Test: `panels::doc_info::tests::save_writes_the_category_the_panel_shows`.
     Document Info's category menu and headings show every category title in the interface language, Font Details, Linked Images and Embedded Images included, and the Objects category shows every count label in it too: Compound Paths, Text Objects, Placed Documents, Symbol Instances, Gradient Meshes, Blends, Envelopes, Intertwine Groups, Opacity Masks and Objects with Effects. The Document category's Pattern Swatches row and the Objects category's Path Length row are translated in every catalog that has every menu label. `document.info` and the saved report keep the English labels. Showing these labels in the interface language is VectorCraft's own rule. Test: `i18n::tests::document_info_labels_are_in_complete_catalogs` (vectorcraft-ui-egui).
+    Document Info shows the values it makes in the interface language too: the Units, the Raster Effects resolution, each font's file, substitution and embedding permission (or that it is built in or missing), each image's size and linked file, each Repeat object's kind with its instances, rows and columns in the language's plural forms, and gradients named by their kind. Font, face, file, swatch and other names stay as they are, a gradient swatch named like a kind included, and `document.info`, Save… and Package's report keep the English values (`document.unitId`, `fontDetails`, `imageObjects`, `gradientObjects` `kinds`). Showing these values in the interface language is VectorCraft's own rule. Tests: `panels::doc_info::tests::values_follow_interface_language_and_keep_names`, `repeat_value_uses_locale_plural_forms_and_drawn_count`, `i18n::tests::document_info_values_are_in_complete_catalogs` (vectorcraft-ui-egui), `cmd::docinfo::tests::info_exposes_structured_font_details_without_changing_english_rows`, `info_exposes_ordered_images_and_unit_id` and `gradient_kinds_tell_kinds_from_swatch_names` (vectorcraft-engine).
     The Brushes panel menu's Select All Unused selects the brushes that are not used in the document, as the [Brushes](https://web.archive.org/web/20241230205225/https://helpx.adobe.com/illustrator/using/brushes.html) page (archived copy) describes. A brush counts as used when a stroke paints with it in the art (opacity masks included), in symbols, graph designs, pattern tiles or graphic styles, or in the art of a used brush (`brush.unused`).
     A rename in Brush Options and Delete Brush change every stroke that paints with the brush: in the layers and opacity masks, symbols, graph designs, pattern tiles, graphic styles and the art of other brushes. A rename gives those strokes the new name, and Delete Brush makes them plain strokes, in one undo step.
     A scatter, art or pattern brush dragged from the Brushes panel onto an empty part of the canvas places a copy of its art there to edit, as the [Modify brushes](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/apply-and-edit-strokes/modify-brushes.html) page describes (`brush.placeArt`). The copy is centered where it is dropped. A pattern brush comes out as its tiles in a row, 10 pt apart, each in a group named for its tile, with an unpainted rectangle at the back of a tile that has a repeat frame. The centering and the tile layout are VectorCraft's own rules. Evidence: `tests::brushsym::place_art_puts_a_copy_of_the_brush_art_where_it_is_dropped`, `tests::brushsym::pattern_brushes_place_their_tiles_in_a_row` (vectorcraft-engine), `canvas::tests::a_brush_with_art_dropped_off_the_art_places_a_copy_of_its_art_there` (vectorcraft-ui-egui).
@@ -1543,6 +1564,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   Create Object Mosaic (its columns and rows), Transform Each (its reference point and Random seed) and Rearrange All Artboards (its columns) refuse a fraction, a negative number or a string, such as 2.5, -1 or "4"; 4.0 counts as 4.
   Move, Rotate, Scale, Reflect, Shear, Transform Again, Nudge and the Transform panel's values (their copy, Scale Strokes & Effects, Scale Corners, Transform Patterns, Transform Objects and area type options), Align, Distribute and Distribute Spacing (Transform Patterns), Object Properties (visible, locked, Isolate Blending and Opacity & Mask Define Knockout Shape) and Live Shape Properties (Invert Pie, Make Sides Equal and relative rounding) refuse a value other than true, false or null, such as "false", and leave the document as it was.
   Object Properties (its opacity), Live Shape Properties (corner radius and polygon sides), the Transform panel's reference point and Align, Distribute and Distribute Spacing to an artboard (the artboard's number) refuse a value other than a number or null, such as "50", and leave the document as it was.
+  Live Shape Properties refuses a key it does not take, at the top level or in one of its items, a polygon side count that is not a whole number from 3 to 1000 and a negative corner radius, and leaves the document as it was; the Transform panel's Sides field takes 3 to 1000.
   Transform Each (its scales, moves and rotation), Rasterize (its resolution), Create Object Mosaic (its new width and height and its spacing), Create Trim Marks (its offset, length, bleed and weight) and Rearrange All Artboards (its spacing) refuse a value other than a number or null, such as "50", and change nothing. Crop Image refuses a rectangle that is not four numbers, such as "0, 0, 20, 20".
   Transform Each (Reflect X, Reflect Y, Random, Copy, Scale Strokes & Effects, Scale Corners, Transform Objects and Transform Patterns), Create Object Mosaic (gray tiles and deleting the image), Crop Image (its trim), Create Trim Marks (all artboards) and Rearrange All Artboards (by column, Move Artwork with Artboard and Transform Patterns) refuse a value other than true, false or null, such as "false", and change nothing. Create Trim Marks refuses a style that is not text, such as 5.
   New Artboard refuses a position or size other than a number or null, such as "10", and New Artboard and Artboard Options refuse a name other than text or null, such as 5; each leaves the artboards and the undo history as they were.
@@ -1570,6 +1592,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - `.vectorcraft` (lossless JSON, compressed, atomic saves, save down to v1), Save As with a format chooser, Save a Copy, Revert, templates, Data Recovery after a crash (browser tabs hold their copies with Web Locks too, so a background tab's copies are never taken for a crash's, and a tab repairs copies another removed when it resumes: #367), background save and export. The desktop app writes its warnings and errors (graphics adapter, a lost graphics device, panics the guard recovered from) to standard error and to `logs/vectorcraft.log` next to the preferences, the two previous runs kept and each file capped at 16 MiB, so a launch without a terminal still leaves something to attach to a bug report (#465). Native documents with a lot of path data (traced or generated art, in layers, symbols or patterns) are saved as compact JSON, about a fifth of the size; small documents stay pretty-printed (#1492). Saving to a network drive on macOS falls back to a plain fsync when the share refuses a full flush (#1625, part of #1620; not confirmed on a real share), and a save still succeeds when a folder refuses the temporary file, the rename over the document or copying permissions: the content is written elsewhere first and copied in, and a failed copy keeps the temporary file and names it (#1649, part of #1620). A document opened by a relative path finds its relatively linked images, and `vectorcraft-cli convert` lists what reading the input left out as `importWarnings` (#1606, fixes #1604).
     Preferences › File Handling › Data Recovery › Folder has a Choose… button on the desktop that picks the folder Data Recovery keeps its copies in ([Illustrator reference, Set Data Recovery preferences](https://web.archive.org/web/20210601162814/https://helpx.adobe.com/pdf/illustrator_reference.pdf)); a picked folder that Data Recovery cannot create its folders in or list is refused with a status message, and the field keeps its value. OK applies the same check to a folder typed into the field (VectorCraft's own rule): when it fails, the dialog stays open, the status bar says why and no preference changes; an empty field (the default folder) and the folder already saved are not checked. Preferences › Plug-ins & Scratch Disks is where additional plug-ins folders are set ([Illustrator preferences help](https://helpx.adobe.com/illustrator/desktop/get-started/preferences-and-settings/set-app-preferences.html)); its Additional Plug-ins Folder has a Choose… button on the desktop as well, VectorCraft's own, matching Data Recovery's, and VectorCraft's own rule refuses a picked or typed folder whose contents can't be listed. Additional Fonts Folder and Templates Folder stay typed only.
     `prefs.set` applies the dialog's check to `recoveryFolder` and `pluginsFolder` for every caller (VectorCraft's own rule): a folder that fails returns an error and no preference changes; an empty value and the folder already saved are not checked.
+    When a Data Recovery copy can't be written, the status bar and the log show the error (with the document's title when one document's copy fails), the folder copies go to, whether that is the default recovery folder or the folder set in Preferences, and the preference that picks another folder (`recoveryFolder`; VectorCraft's own message).
     A name typed in the desktop save panel without the file type's extension gets it, and when a file of that name exists, which the panel did not ask about, Save, Save As, Save a Copy, Save as Template, the exports and every other write through a save panel ask before replacing it (dialog `replaceFile`; Cancel writes nothing).
     A name returned by the desktop save panel with the extension of a format the save does not write has it replaced with the saved format's: Save As of a new document saves `card.ait` and `card.png` as `card.vectorcraft`, and Save as Template saves `card.pdf` as `card.vctemplate`. An extension that names no format stays part of the name (`notes.v2` is saved as `notes.v2.vectorcraft`).
     Export As, Save as PDF, Save for Office Documents, Save for Web, Text Export Options, print to file, the presets' Export… and the library, swatch and Document Info saves replace a typed extension of another format than the one they write in the same way: Export As PNG writes `card.svg` as `card.png`, Save as PDF writes `card.png` as `card.pdf`, and `document.exportSelection` with a `format` suggests and adds that format's extension. An extension of the written format stays as typed in any letter case (`photo.JPEG` for JPEG), Export As SVG writes `art.svgz` compressed, and `document.exportSelection` without a `format` writes the format the typed extension names (`tests/saveext.rs`).
@@ -1594,6 +1617,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     A PDF-compatible `.ai` saved with Include Editing Data for Other Apps defines every symbol in its editing copy with its art, registration point and place in the Symbols panel's order, and writes its instances as symbol instances, which VectorCraft's `.ai` reader opens as symbols and instances again (`symbols_and_their_instances_are_read_back` in `crates/eps/src/ai_editing/tests.rs`; [file-format-parity.md](file-format-parity.md) lists the instances written as their art).
     A PDF-compatible `.ai` saved with Include Editing Data for Other Apps keeps envelopes made with a warp, a mesh or a top object editable: its editing copy holds each envelope's contents, shape, Fidelity, Envelope Options and Edit Contents state in the form VectorCraft's `.ai` envelope reader reads, beside its distorted art, so the file opens with the same live envelope, Edit Contents still switching between the contents and the envelope ([Edit the contents of envelopes](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/edit-the-contents-of-envelopes.html)). Envelopes of type, envelopes in opacity masks, pattern tiles or another envelope's contents, and envelopes the reader would open with another shape or other settings (a Fidelity that isn't a whole number, bounds margins kept with Distort Appearance off), and envelopes after the first 256 in a file are written as their distorted art, with a warning (`envelopes_are_read_back_live` and `envelopes_the_reader_cannot_open_live_are_written_as_their_art` in `crates/eps/src/ai_editing/tests.rs`).
     A PDF-compatible `.ai` saved with Include Editing Data for Other Apps writes eligible paths, compound paths and groups with live effects with an art style when the writer supports their appearance and effects (not a filled path that uses the even-odd rule, and none on a large canvas), which VectorCraft's `.ai` reader opens as the same appearance with its effects live (`objects_with_live_effects_are_read_back` and `every_effect_setting_written_on_an_object_is_read_back` in `crates/eps/src/ai_editing/tests.rs`; [file-format-parity.md](file-format-parity.md) lists the objects written without one and the effects they lose).
+    The same holds for the objects of an opacity mask's art, a mask inside another mask's art and a hidden art root included, so a mask whose art has Offset Path opens drawing the image it masks as it did, with the effect live; geometry effects that no art style holds on a mask's art, such as Roughen, are written applied to the art, which opens drawing what it drew (`a_masked_image_with_live_offset_path_round_trips`, `hidden_and_nested_mask_art_keep_live_offset_path` and `a_masks_art_with_an_effect_no_style_holds_is_written_as_it_draws` in `crates/eps/src/ai_editing/tests.rs`).
     A PDF-compatible `.ai` saved with Include Editing Data for Other Apps writes point type, area type and type on a path as type in its editing copy, and objects next to it keep their own transparency (`crates/eps/src/ai_editing/tests.rs`, `cmd::fileio::tests_pdfedit::type_comes_back_from_the_editing_copy`; [file-format-parity.md](file-format-parity.md) lists what is written as outlines).
     A PDF-compatible `.ai` saved with Include Editing Data for Other Apps keeps the document's variables, data sets and the bindings of objects to variables in its editing copy, in the form the variable library reader above reads, so they come back when the file is opened. Bindings to layers, to type written as outlines, to graphs and to linked images written as other objects, data set values of graphs, and variables, data sets, bindings and values past the writer's limits are left out with a warning (#6024; `crates/eps/src/ai_editing/tests.rs` `variables_data_sets_and_bindings_are_read_back`; `crates/eps/src/ai_editing/writer/variables.rs` lists what is left out).
     In a `.ai` or EPS opened from its editing data, type has its text object's opacity, blend mode and knockout shape flag, whether it is made from the file's text document or taken from the page, and type made from the text document takes its text object's lock. Where such type has transparency and comes in with other art (the rest of its look, or page type and strokes that go with it), a group of them has it. Where the page draws its type, or the strokes around it, with transparency that is neither its text object's nor its text object's combined with that of the objects around it, the page's type and strokes keep their own instead (`crates/eps/src/import/tests_native.rs`). Where the page draws type of no text object over text objects made from the text document, with their words in any case, that type is theirs as the page draws it and is left out; the page's other type of no text object goes only to text objects whose type the text document can't make, or else is left out with a warning.
@@ -1620,7 +1644,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     In a `.ai` opened from its editing data, a path or type object with Offset Path, Outline Object or Outline Stroke on the whole object opens as itself with those effects live, in their order and shown or hidden; on a fill or stroke of type they stay on that fill or stroke. Offset Path keeps its Offset, Joins and Miter Limit, and Outline Stroke takes its width from the stroke. An Offset Path with a setting missing, out of range or not read keeps the drawn art, as does a path with a Path effect on one fill or stroke (`crates/eps/src/import/ai/style/tests.rs`, `crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/tests_native.rs`).
     In a `.ai` or EPS opened from its editing data, a Scatter brush whose last 15 numbers start with 1 comes into the Brushes panel in Tints, and each brush art section is read without its frame, an unnamed, unpainted rectangle with no settings of its own at the art's bounds (within 1/1000 pt). A wider frame stays in the art, and an art group with a state or look of its own (hidden, locked, isolated, knockout, an opacity, a blend mode, a name, a mask, a note or an appearance) stays a group (`crates/eps/src/import/ai/tests.rs`).
     In a `.ai` opened from its editing data, type with Warp on the object or on one of its fills or strokes opens as type with the effect live when the live warp draws as the art saved with it. When it draws differently, or when the file's limit of checks has no check left for it, it opens as that art, and one note says how many did. Type stays live without a comparison when the saved art paints nothing or draws type of its own, in frames of threaded type, when a text variable binds it, and when its text object doesn't come in as one text object (`crates/eps/src/import/ai/envelope.rs`, `crates/eps/src/import/tests_native.rs`).
-    In a `.ai` opened from its editing data, an object with a Tweak that moves nothing or Pucker & Bloat at 0 opens as itself with the effect live. A path, compound path or group whose only effect is Transform without copies, or a Free Distort whose corners make a parallelogram, opens as itself with it live, and so does an object with nothing stroked whose only effect is Twist: a path or compound path with straight segments at any angle, and another path, compound path or group with no guide in it at up to 90° either way (a limit VectorCraft sets). A gradient or pattern, an image, type, a clipping group, an opacity mask or effects inside the object, or a stroke with a Transform that scales, rotates or reflects, keep the drawn art (`crates/eps/src/import/ai/style/tests.rs`, `crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/ai/read/ops.rs`).
+    In a `.ai` opened from its editing data, an object with a Tweak that moves nothing or Pucker & Bloat at 0 opens as itself with the effect live. A path, compound path or group whose only effect is Transform without copies, or a Free Distort whose corners make a parallelogram, opens as itself with it live, and so does an object with nothing stroked whose only effect is Twist: a path or compound path with straight segments at up to 180° either way, and another path, compound path or group with no guide in it at up to 90° either way (limits VectorCraft sets); one twisted further keeps the drawn art. A gradient or pattern, an image, type, a clipping group, an opacity mask or effects inside the object, or a stroke with a Transform that scales, rotates or reflects, keep the drawn art (`crates/eps/src/import/ai/style/tests.rs`, `crates/eps/src/import/ai/tests.rs`, `crates/eps/src/import/ai/read/ops.rs`).
     A PDF page whose `UserUnit` (PDF 1.6) is above 1 opens at its size in points, its numbers times the `UserUnit` (one above 75,000 counts as 75,000), and `document.pdfInfo` gives its size and boxes in points too. A `.ai` whose editing data has its artboards in the units of such a page opens from that data at the page's size, with its layers, and when the layers can't be read its pages still take the artboard layout of the data, scaled the same way (part of #1482).
     `document.open`, `file.place` and `document.pdfInfo` reject a `cropTo`, `crop`, `password`, `colorMode` or `textAs` that is not a string, such as `"textAs": true`, and `document.pdfInfo` rejects a `thumbnailSize` that is not a number; the error names the param, and nothing opens or is placed. A param left out or given as null keeps its default (`crates/engine/src/cmd/fileio/tests_pdfimport.rs`).
     When the PDF content of a `.ai` has a page for each artboard, the layers are compared with every page on its artboard (until the pages compared take 8,388,608 pixels at the comparison's scale, about 67 letter-size pages, or number 128): art that only the layers or only a later page draws is handled as art that differs on the first page is, and a text object that a later page doesn't draw is left out unless its layer doesn't print (`crates/eps/src/import/tests_native.rs`).
@@ -1636,6 +1660,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     Export As PDF with Use Artboards off also opens the Save PDF dialog, without its Artboards section, and writes one page of the visible art's bounds with the dialog's options (`document.exportPdf {useArtboards: false}`; `crates/ui-egui/src/dialogs/tests_export.rs`, `crates/engine/src/cmd/fileio/tests_pdf.rs`).
     A `.ai` export with Use Artboards off writes one page of the visible art's bounds without the native document or the editing copy for other apps, with a warning, so the file does not reopen with one artboard in place of the document's; without PDF content it is refused (`crates/engine/src/cmd/fileio/tests_pdfedit.rs`).
     PDF export warns when a PDF/X file has no bleed on a side where the document's bleed has one, and writes the file as asked.
+    In a PDF without a standard, the warning for a page longer than 14,400 pt written with a `UserUnit` names "Write pages longer than 200 in at full size in points" (`crates/engine/src/cmd/fileio/tests_pdf.rs`).
     A PDF/A-2b export at PDF 1.4 with a page longer than 14,400 pt is written as PDF 1.6 with a `UserUnit` and a warning, whether or not `longPagesInPoints` is on, so its page boundaries stay within PDF/A-2's limit of 14,400 units (ISO 19005-2, 6.1.13) unless the page is too narrow for that (`crates/pdf/src/tests/marks.rs`).
     PDF/X-1a, PDF/X-3 and PDF 1.3 files keep the art under the hidden part of a picture, gradient, pattern, mesh or raster effect that a clipping mask or clipping layer crops: flattening rasterizes only the part of such art that its clipping path shows, on its own page and on the next one. Layers the file leaves out are left out of the flattening, and transparent art that a clipping path hides entirely is removed (`crates/engine/src/cmd/fileio/tests_pdfx.rs`).
     Placed (linked) files in a `.ai`'s editing data come in as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (a file found next to the document, at its path, or in the folder the editing data names relative to the document's, such as `src/`, is read as the document opens, and its link takes that file's size, modification time and hash). A file with them no longer falls back to its PDF part, so its guides, sublayers and hidden objects open (#1264; `crates/eps/src/import/ai/tests.rs`, `crates/engine/src/tests/links.rs`). In a file opened that way, a gradient with stops in the middle runs its whole ramp across its shape and a gradient object no longer passes its fill to the next path (#1390); text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line, the frame made taller with a warning in the open result (#1392).
@@ -1705,6 +1730,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - A photo whose EXIF orientation turns or flips it (a camera held upright or upside down) is placed and opened upright, as it was taken; the image is stored as it is seen (#4284). A quarter turn swaps the resolution's axes, so the image keeps its physical size. TIFFs read without the image decoder (grayscale with extra channels, CCITT Group 3, CMYK with one plane per ink) follow their Orientation tag too, and a turned CMYK JPEG or TIFF keeps its inks, at the 8 or 16 bits the file has, as a CMYK TIFF.
   - An image that Open and Place store again keeps the ICC profile its file embeds and its 16-bit samples. A turned PNG, JPEG, WebP or TIFF stored as PNG, and a TIFF the image decoder reads, keep their gray or RGB samples at 8 or 16 bits with their gray or RGB profile in the PNG's `iCCP` chunk ([PNG specification, iCCP](https://www.w3.org/TR/png-3/#11iCCP)). A CMYK TIFF stored with one plane per ink and a turned CMYK JPEG or TIFF keep their CMYK profile as TIFF tag 34675, a JPEG's put together from all its APP2 segments ([ICC image-format guide](https://github.com/InternationalColorConsortium/iccDEV/blob/master/iccdev-mcp/docs/icc-format-guide.md)). A profile whose color space differs from the stored samples' is left out. The profile is kept in the stored image; how CMYK inks are drawn and exported to PDF does not change (`crates/engine/src/cmd/fileio/tests.rs`).
   - SVG import shows a raster `<image>` whose EXIF orientation or TIFF Orientation tag turns or flips it upright, linked or as a data URL, and inside an SVG shown as an image: the pixels are stored turned, the width and height swap, and the `<image>` box fits the turned image under `preserveAspectRatio`, as CSS `image-orientation: from-image` describes (<https://www.w3.org/TR/css-images-3/#the-image-orientation>). A turned CMYK JPEG or TIFF keeps its inks as a CMYK TIFF, as does a CMYK TIFF that is not turned. TIFF data URLs (`image/tiff`, or untyped TIFF bytes) are read, and TIFFs with an alpha or other extra channel, CCITT Group 3 TIFFs and CMYK TIFFs stored one plane per ink are read as Open and Place read them. The pixels are decoded within the decode allowance, and a TIFF claiming more strips or tiles than the decoder can count is refused before it is decoded (`crates/svg/tests/it/image_orientation.rs`).
+  - SVG import leaves out an SVG shown as an image that it can't read (text that isn't XML, an SVG without a size) and goes on with the images after it, as SVG 2's error processing describes (<https://www.w3.org/TR/SVG2/conform.html>). Only images that decode count toward the 256 nested SVG images an SVG may show, so an image after many broken ones is imported. Every nested SVG image read, decoded or not, counts toward VectorCraft's own limits of 1,024 reads and 512 MB of text per import; past them, nested SVG images are left out with a warning (`crates/svg/tests/it/import_details.rs`).
   - File › Place and a file dropped on the canvas refuse a PNG, JPEG, GIF or WebP file whose pixels can't be read, such as one cut short by a download or a sync still running, and the status bar shows "Couldn't place <name>: the image's pixels can't be read". Paste and Relink refuse such an image too, and Update Links, or Open when it reads the file again, counts it as missing. A JPEG cut short still places when its pixels can be decoded (`file.place`, `crates/engine/src/tests_place.rs`).
   - On the desktop, Copy and Cut make the system clipboard's formats (text, SVG, PDF, PNG) from a copy of the clipboard on the thread that writes background saves and exports, and write them when they are ready; while that thread has a save, an export, a print or a recovery copy to finish, they are made and written at once. Until they are written, Paste in VectorCraft takes the internal clipboard, and while a text field or the Type tool has the keyboard the app waits for them. Another Copy or Cut, or a copy of text in VectorCraft, drops them.
   - In the Linux Flatpak on GNOME, where the clipboard goes through the compositor's core Wayland protocol, one Copy offers the PNG (`image/png`), the SVG (`image/svg+xml`, with Include SVG Code on) and the text, and Paste takes another app's SVG, text or PNG in that order, a picture over blank text or text that only names it; the Paste menu item is enabled by the types offered (`clipboard::wayland` tests in `apps/vectorcraft/src/clipboard.rs`; not yet run in the Flatpak on a GNOME session).
@@ -1718,6 +1744,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - On Windows, a document opened from a mapped network drive finds its links stored with the share's own path (`\\server\share\…`), as the same document opened from the share does; links on other computers stay missing.
   - On Windows, a link on a drive mapped to a network share other than the document's (`Y:\…`) is missing, with the reason that the path is on another computer, as a link stored with that share's own path is; links on this computer's drives and on the document's share are followed.
   - In the Links panel, Shift-click selects a range of links and Ctrl/Cmd-click adds or removes one.
+  - When a document opens with notes and with linked files that changed on disk (Update Links: Manually) or, on the web, can't be read, the status bar shows the line about the linked files, then counts the notes and names the first, and hovering it lists the notes. The same holds when the line about modified files follows the Linked File Not Found dialog, and File › New from Template… shows the notes of the file it opens as File › Open does (`an_open_with_modified_links_keeps_link_notice_and_import_notes_reachable`, `new_from_template_preserves_open_warnings`, `an_open_with_unreadable_links_keeps_import_notes_reachable`, `modified_links_after_the_missing_ones_keep_the_open_notes`, `combined_open_and_link_status_lists_notes_on_hover_and_for_accessibility`).
   - Linked images and placed documents kept only in symbols, graph designs, patterns or opacity masks are listed in the Links panel after the layers' own, one row per stored object, with their status in its Missing and Modified filters, in Check Links, in the missing and modified files reported when a document opens, in the link watch and in Find in Folder; Relink, Update, Embed, Placement Options and Link Info act on them, and Go To says they have no place on the canvas. Opening a document gives such an object whose id is 0 or repeats another object's a new id.
   - Linked files another app changes while their document is open follow Preferences › File Handling › Update Links, as they do when it opens: Automatically reads them again (an Update Links undo step), Ask When Modified offers to, Manually leaves them modified in the Links panel. The desktop app compares the active document’s linked files by size and modification time every two seconds and when its window comes back to the front, on a worker thread; a file still being written is tried again (`links.updateChanged`).
   - A look at the linked files whose worker thread ends without a result, such as after a panic, no longer stops later looks: the app clears it, stops asking for a frame every 100 ms, and the next look starts on schedule (`crates/engine/src/tests/linkwatch.rs`, `crates/ui-egui/src/tests/place.rs`).
@@ -1749,6 +1776,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   Pathfinder › Merge and the `pathfinder.merge` group effect find the faces of every fill in a few contour passes over the arrangement, as Trim and Crop do, instead of one pass for each distinct fill. The output paths and their order are the same. With 8,000 squares that do not touch, each with its own fill, Merge takes 72 to 107 ms instead of 17 to 32 s (release build).
   The Pathfinder panel, Offset Path, Clean Up, Divide Objects Below, Make and Release Blend, Envelope Distort's Make and Release, Repeat (Radial, Grid, Mirror and Release), Vector Halftone, New and Redefine Symbol, Delete Symbol, erasing with the Symbol Sprayer, Rasterize, Convert to Artboards, Flatten Transparency, Clear Guides, Shape Builder, Live Paint, Release Image Trace, Make and Release Opacity Mask, Delete with direct-selected anchor points, Remove Anchor Points, Cut Path, and the Shaper, Knife, Eraser, Path Eraser, Line Cut, Rectangle Cut, Mirror & Cut and Blob Brush tools add and remove objects in one pass over each layer or group they change, and Outline Stroke and Expand write each new object in the place of the object it replaces (#1429).
   Offset Path looks up the segments near each candidate hole or island in a tree of the source path's segment bounds when it decides whether to drop that contour, instead of testing the bounds of every segment. The output paths are the same. On compound and open paths of 25,000 to 40,000 anchors with 6,400 to 11,976 candidate contours, that check takes 11 to 13 ms instead of 140 to 649 ms (medians of five interleaved runs). The limit on overlapping segment pairs is the same, so a path that stops with "Offset Path: the path is too complex to offset" still stops there.
+  Offset Path on several selected paths, or on a group of them, works out their offsets on as many threads as the computer has logical CPUs (one thread on the web and for a single path), and then makes the new objects one after another in the selection's order. The new objects, their ids, their stacking, the selection and the undo step are the same as when the paths were offset one at a time, and when more than one path fails, the error is the one for the first of them in that order (`tests::pathops::offset_path_of_several_objects_keeps_their_order`, `tests::pathops::offset_path_works_on_several_threads_in_order`, `tests::pathops::offset_path_stops_after_the_first_failure`).
   Finding the distinct regions of an arrangement lists the shapes that cover each region instead of keeping a flag for every shape, so that step's time follows how many shapes cover each region rather than how many shapes there are. Divide, Hard Mix, Soft Mix, Shape Builder, Flatten Transparency, trapping, Intertwine and the Pathfinder effects are among the commands that use that step. The regions, their order and the output are the same. Divide on 3,000 overlapping rectangles takes 0.84 to 1.13 billion CPU cycles on its thread instead of 1.25 to 1.46 billion (dev build, six runs of each, alternating, while other builds were running).
   The contour passes of the two-path boolean operations, Offset Path, compound shapes and Intertwine test the list of shapes that cover each face instead of a flag for every shape, so each test's time follows how many shapes cover the face rather than how many shapes there are. The contours, their order and the output are the same. The many-shape boolean that compound shapes use takes 0.75 to 0.83 billion CPU cycles on its thread instead of 1.28 to 1.33 billion to unite 10,000 squares that do not touch, and 2.27 to 2.30 billion instead of 2.43 to 2.47 billion for 1,500 members of two squares each over 3,000 overlapping squares (dev build, six runs of each, alternating, while other builds were running).
   Pathfinder › Unite and the other commands that unite filled paths sweep a single input once instead of twice when its own sweep neither splits nor drops any of its segments and no two of its segments lie within twice the sweep tolerance. The output is the same. Unite on one compound path of 4,000 rings takes 485 to 542 ms instead of 872 to 1,008 ms, and on one zigzag polygon of 20,000 teeth 70 to 76 ms instead of 118 to 130 ms (release build, medians of three alternating rounds of five runs, while other builds were running).
@@ -1761,6 +1789,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   When the stroke of a path moved this way has a gradient along or across it, the renderer also draws the gradient from the slices it made before the move, moved by the same offset. It makes the slices again when the path is scaled, rotated or edited, and when the stroke or its gradient changes. The pixels are the same. On Windows at 1600 × 1000, the frame after a 1 pt nudge of an open path of 200,000 anchors takes 75 ms instead of 1,237 ms with the gradient along the stroke and 69 ms instead of 1,420 ms with it across, and with an open path of 50,000 anchors 22 ms instead of 313 ms and 21 ms instead of 352 ms (medians of five interleaved runs).
   When an edit changes a 3D effect (Extrude & Bevel, Inflate, Rotate, Revolve), the canvas draws again where its art was and is, measured by that art: type and groups were measured by their letters or members, so a shallower or turned solid left pieces of the old one on the canvas. When the canvas draws the part on its own thread, it measures through its renderer and draws the part with the art it made to measure it. Exports and Object › Rasterize take the solid of 3D type, where they cropped it to the letters, and Fit to Artwork Bounds and per-artboard SVG export measure every artboard through one renderer, building each solid once unless the object has brushed strokes: 30 extruded type objects measured over 30 artboards take about 2 ms in a release build, where measuring their letters took under 1 ms. A document's first frame builds every 3D object's solid, off the view too, to know whether it reaches into the view.
   When only anchors of a path or compound path move, the canvas draws again only around the segments that start or end at a moved anchor, grown by the farthest its strokes reach, instead of the whole object before and after. This holds while every fill and stroke is a solid color, and the strokes have no dashes, width profile, arrowheads or brush, and the object has no effects or opacity mask; any other object still counts whole. On a loaded Windows machine at 1600 × 1200, single-threaded in a development build, the frame after one anchor of a filled closed path moves takes 16.6 million CPU cycles instead of 56.4 million with 50,000 anchors and 65.6 million instead of 180.0 million with 200,000 anchors (medians of 15 edits, the two builds run in turn three times).
+  The check after an edit that a selected path or compound path stays within the canvas passes without measuring the path when every anchor and handle of it is within the canvas, and measures it only when one is not. Moving one anchor of a selected open path of 10,000 anchors (`path.moveAnchor`, `path.setHandle`, `path.moveAnchors` or a nudge) measured all 9,999 segments of the path and now measures at most 16 (counted in the engine's tests). The edit still copies the path's anchors for undo, and the renderer still compares every anchor of the path to find the moved ones.
   Opening a document keeps the layouts it makes for its type objects, up to 128 MiB, and the first frame uses them instead of laying those objects out again. It does not keep a layout with bitmap or color glyphs or a text object with a gradient. The frame uses a layout only for a text object equal to the one laid out, and only while the fonts and the hyphenation exceptions have not changed. It uses each layout once. The renderer drops the rest when a frame that used one ends, and all of them after eight frames that use none. The frames of a threaded story are laid out while the file is read, and the first frame lays them out again. The pixels are the same. On Windows at 1600 × 1200, in medians of seven interleaved rounds of a local example, counted in the main thread's CPU cycles because other builds were running: with 5,000 point type objects in view the first frame takes 409 million cycles instead of 894 million and the open 816 million instead of 665 million, so the two together take 1,225 million instead of 1,559 million; with one area type object of 500 paragraphs the first frame takes 697 million instead of 1,193 million and the open 535 million instead of 568 million.
   Type › Show Hidden Characters keeps the marks it places on each text object from one frame to the next. The canvas lays a text object out again when an edit changes it or its threaded story, or when the last frame that showed the marks did not draw it, and it lays out all type in view again when the fonts or the hyphenation exceptions change. With 1,000 two-line labels in view, drawing the marks takes 0.8 ms per frame in a release build instead of 19.7 ms.
   A selection with more than 100,000 points to outline shows its bounds instead of each object's outline and anchors. Paths count their anchors. Area type and type on a path count the anchors of their frame or path, and point type counts six: its box's corners and the ends of its baseline marker. Images, symbol instances, placed documents, and area type or type on a path in perspective count the four corners of their box, and gradient meshes and envelopes count their points and the ends of their mesh lines. The hover highlight leaves out an object past that count, and such an object shows its bounds as the key object. With 32,768 type objects, images, symbol instances, gradient meshes or envelopes selected, the selection's outlines and anchors add fewer than 100 vertices to the canvas's mesh (#2460).
@@ -1852,7 +1881,9 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
 
 - **Blend widgets without a spine:** a blend made with Create Spine set to Never shows the Appearance widget alone with the Selection and Blend tools, and its drag sets Shift as on a blend with a spine; there is no Easing widget, as the [Blend panel help page](https://helpx.adobe.com/illustrator/desktop/manage-colors/apply-transparency-and-blending/blend-panel-overview.html) makes Easing available only on a blend with a spine. The widget sits 16 px above the halfway point, by length, of the straight lines between the key centers that the steps are laid out along, and a drag follows those lines' direction there; the lines are not drawn. Showing the widget without a spine and its placement are VectorCraft's own rules. Evidence: `blendwidget::tests::{a_blend_without_a_spine_shows_the_appearance_widget_alone, dragging_the_appearance_widget_of_a_blend_without_a_spine}`, `tests::blendopts::dragging_the_appearance_widget_of_a_blend_without_a_spine_is_one_undo_step`, `blend::tests::a_blend_without_a_spine_has_a_layout_line_through_its_key_centers`.
 
-- **Positions along a blend spine:** blend steps, keys spread along a spine, the blend widgets and Objects on Path find the spine segment for each arc length with a binary search over the anchors' arc lengths, so a spine of 4,096 segments takes at most 13 comparisons per position instead of one per segment before it. Points and tangents are unchanged, including at anchors shared by zero-length segments. Evidence: `blend::tests::{spine_lookup_compares_a_few_segment_ends, spine_lookup_matches_walking_the_segments}`.
+- **Positions along a blend spine:** blend steps, the blend widgets and Objects on Path find the spine segment for each arc length with a binary search over the anchors' arc lengths, so a spine of 4,096 segments takes at most 13 comparisons per position instead of one per segment before it. Points and tangents are unchanged, including at anchors shared by zero-length segments. Evidence: `blend::tests::{spine_lookup_compares_a_few_segment_ends, spine_lookup_matches_walking_the_segments}`.
+
+- **Keys spread along a replaced spine:** when the keys of a blend whose spine came from Replace Spine get anchors of their own (a key moved off the spine, or an edit of the spine), the spine is flattened and measured once. Each split measures again only the segments from the split to the next key, and a binary search finds each key's segment. 1,000 keys on a spine of 4,096 segments flatten the spine once instead of 999 times. The keys' anchors and the spine are the same as before. A spine so large that its length overflows gets no anchors and is left as it was. Evidence: `blend::tests::{spreading_keys_matches_measuring_the_spine_for_each_key, spreading_keys_measures_the_spine_once, spreading_keys_along_a_spine_whose_length_overflows_changes_nothing, a_failed_anchor_keeps_none_of_the_earlier_splits}`.
 
 - **Objects on Path measures its path once:** placing the objects, finding one object's place and transforming the group flatten each path once and use it both for the path's length and for the points along it, where they flattened it two or three times before; a request for an object past the last one returns nothing without flattening the path, and a move of the group flattens no path. A path whose length adds up past the largest finite number no longer counts as one objects can be attached to. Evidence: `objects_on_path::tests::{stops_and_stop_flatten_the_path_once, transforming_the_group_flattens_each_path_once, placing_the_objects_flattens_the_path_once, a_path_too_long_to_measure_is_not_attachable}` in `crates/doc`.
 
@@ -1867,6 +1898,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
 
 - **Plug-in parameters as their manifest presents them (G17):** each parameter may have a `label`, a `unit` shown after its value, `help` on its label and a `helpUrl` page opened from a button, a `group` (sections that fold, after the parameters outside any group) and a `visibleWhen` that shows it only while the checkboxes and choices it names have one of the listed values (a hidden parameter still goes to the plug-in). `string` and `numberList` parameters join number, int, bool and choice, and a plug-in declares up to 256 parameters, at most 64 outside groups. The filter, live-effect and exporter dialogs use these keys, and the Appearance panel's effect editor the labels, units, help and conditions; hosts from before them ignore them. Regressions: `crates/plugins/src/dialog.rs`, `crates/plugins/src/manifest.rs`, `crates/ui-egui/src/dialogs/tests_plugin_fields.rs`, `crates/ui-egui/src/panels/appearance.rs`. Scores and hours unchanged.
 - **Live-effect plug-ins read their object's paints (G17):** a live effect is given the object's `fills` and `strokes` as a filter gets them, read only, and `_context.item` (`"object"`, or the fill or stroke whose own effects hold it); the result is cached by paint too, so a change of paint runs it again. Regressions: `crates/engine/src/tests/plugins.rs`, `crates/plugins/src/effect.rs`. Scores and hours unchanged.
+- **Live-effect plug-ins before a fill's or stroke's own 3D effect:** a live effect listed before a fill's or stroke's own Extrude & Bevel, Inflate or Rotate effect is given `_context.item` for that fill or stroke (`{"fill": i}` or `{"stroke": i}`), not `"object"`, in the drawn art, in the 3D meshes and in Expand as Wireframes; a deferred stage there is listed at that fill's or stroke's place. Regressions: `crates/effects/src/tests/solidcontext.rs`. Scores and hours unchanged.
 - **Filter plug-ins set effects and stroke styles (G17):** a filter is given each object's effect records and its strokes' `join`, `cap` and `miterLimit`, and may return them; the records are admitted as `effect.apply` admits them (a known effect or installed live-effect plug-in, parameters it takes, one 3D effect that fits, no texture read from a file), and one refused refuses the output. Regressions: `crates/engine/src/tests/plugins.rs`, `crates/plugins/src/objects/tests.rs`. Scores and hours unchanged.
 - **Gradient stop plates from filter plug-ins are clamped (G17):** the four process `plates` of a gradient stop in a filter's or importer's output are clamped to 0–1, as its other colors are; a value that is not a number becomes 0, and an infinite one becomes 0 or 1 by its sign. Painted live effects still refuse such a stop. Regressions: `crates/plugins/src/objects/tests.rs`. Scores and hours unchanged.
 - **Plug-in data kept with the document (G17):** a filter writes JSON of at most 1 MiB with `documentData` (one undo step with its objects; `null` removes it) and reads it back in `_context.documentData`, which no other filter is given. It is the document's foreign data (`unknown.pluginData`, by plug-in id), as the perspective grid is, so the native file keeps it with no section of its own; an exporter is given the whole document, so it can read every plug-in's. Regressions: `crates/engine/src/tests/plugins.rs`, `crates/engine/tests/plugin_export.rs` (the exporter), `crates/doc/src/plugin_data.rs`, `crates/plugins/src/objects/tests.rs`. Scores and hours unchanged.
@@ -2144,6 +2176,10 @@ A VectorCraft addition, so no area score moves. Object › Plug-ins › Cutting
 
 A VectorCraft addition, not a feature of the reference app, so no area score moves. Object › Plug-ins › Cutting Tools › Weed Box and Lines… (`addon.cutting.weed`) adds a weed box and weeding lines around the selected art for vinyl cutting ([what a weeding border is](https://help.arlon.com/what-is-a-weeding-border)). The rest is VectorCraft's own: the box is a rectangle at a margin around the art, and the lines run across it horizontally, vertically or both ways, by count or by spacing, and stop at the art's outlines or at a gap from them. The box and the lines are straight paths stroked in a chosen swatch ([Registration] by default), in one group named Weeding on top of the current layer, added as one undo step. The art is measured by the outlines a cutter cuts: compound paths by their fill rule, type by its glyph outlines, clip groups by what shows, images by their frames, placed files by the art they show, symbol instances by their art, and blends and other live objects by the art they draw. The dialog has Preview. Tests: `cmd::addons::cutting::weed::tests` in `vectorcraft-engine`, `weed_box_and_lines_previews_cancels_and_runs_on_ok` in `vectorcraft-ui-egui` and `command_sweep`. Commands: `docs/mcp.md` › Cutting Tools add-on › Weed Box and Lines.
 
+## Cutting Tools add-on: Banner Hems and Grommets (2026-11-13)
+
+A VectorCraft addition, so no area score moves. Object › Plug-ins › Cutting Tools › Banner Hems and Grommets… (`addon.cutting.banner`) marks where a printed banner is hemmed ([hem](https://en.wikipedia.org/wiki/Hem)) and where its grommets go ([grommet](https://en.wikipedia.org/wiki/Grommet)). The rest is VectorCraft's own: the banner is the selected art's bounds or each artboard; each chosen side gets a hem line at a set depth inside its edge (1 in by default) and grommet marks at a set inset (0.5 in), one at each end of the side and the rest spread evenly at most a set spacing apart (24 in), with one grommet at a shared corner. Each grommet mark is a circle with a cross through its center. The marks are stroked in a chosen swatch ([Registration] by default), in one group named Banner Marks per banner on top of the current layer, added as one undo step. The dialog has Preview. Tests: `cmd::addons::cutting::banner::tests` in `vectorcraft-engine`, `banner_hems_and_grommets_previews_cancels_and_runs_on_ok` in `vectorcraft-ui-egui` and `command_sweep`. Commands: `docs/mcp.md` › Cutting Tools add-on › Banner Hems and Grommets.
+
 ## Path Precision Tools add-on: Divide into Dashes (2026-11-01)
 
 A VectorCraft addition, not a feature of the reference app, so no area score moves. Object › Plug-ins › Path Precision Tools › Divide into Dashes… cuts the selected paths into separate open paths along the curve (arc length, not straight distance): each `dash` long (0.01 to 1000000 pt, 10 by default) with `gap` between them (0 by default: the pieces touch); the gap pieces are left out unless Remove Gaps is off. With direct-selected segments (or anchors) only those runs are divided, the pattern running on across segments that follow one another, and the rest of such a path stays as pieces of its own. Fit to Corners and Ends gives every run between corners and ends a whole number of dashes, all stretched or squeezed alike so it starts and ends on a dash (a closed path without corners holds whole periods); otherwise the lengths are exact and each run's last piece is what is left. Every piece keeps the path's appearance and is selected; one undo step; at most 100000 pieces (more is refused). The dialog takes lengths in any unit and previews on the canvas. Tests: `dashes::tests` in `vectorcraft-pathops` (exact and fitted lengths, curves measured along them, picked segments on open and closed paths, the piece cap and bad patterns), `divide_into_dashes_*` in `cmd::addons::pathtools::tests` in `vectorcraft-engine` (gaps removed or kept, fitted lengths, the stroke kept, one undo step, selected segments only, bad params and too many pieces refused), `divide_into_dashes_opens_its_dialog_previews_and_runs_on_ok` in `vectorcraft-ui-egui` and `command_sweep`. Commands: `docs/mcp.md` › Path Precision Tools add-on.
@@ -2152,6 +2188,10 @@ A VectorCraft addition, not a feature of the reference app, so no area score mov
 
 A VectorCraft addition, not a feature of the reference app, so no area score moves. Object › Plug-ins › Path Precision Tools › Expand Dashes into Paths turns the dashed stroke of each selected path and compound path into separate open paths, one per dash, for cutters and plotters that need the centre lines rather than Outline Stroke's filled outlines. The dashes are laid out by the renderer's own dash code, so they match what the canvas draws: the dash pattern, its offset and Align Dashes to Corners and Path Ends, a dash running on through the start of a closed path, a dash all the way round staying closed, and under a round or projecting cap each dot (a dash of no length) as a path on its point. Each dash keeps the path's appearance with the top stroke's dashes and arrowheads off; the path's fills stay on it, below its dashes; a compound path's dashes are plain paths. One undo step; the dashes are selected; at most 100000 (more, or a pattern too fine to draw, is refused). Tests: `expand_dashes_*` in `cmd::addons::pathtools::tests` in `vectorcraft-engine` (the stroke kept with dashes off, the offset, one undo step, the fill kept below, dashes centred on corners when aligned, dots under round and butt caps, compound paths, refusals and the piece cap), `the_plugins_submenu_selects_the_tools_and_opens_the_anchor_inspector` in `vectorcraft-ui-egui` and `command_sweep`. Commands: `docs/mcp.md` › Path Precision Tools add-on.
 
+## Path Precision Tools add-on: Trim at Crossings (2026-11-13)
+
+A VectorCraft addition, not a feature of the reference app, so no area score moves. Object › Plug-ins › Path Precision Tools › Trim at Crossings Tool (kept out of the shipped toolbars, listed in the All Tools drawer, no shortcut) removes stretches of paths between the places where they are crossed by another path or by themselves, on any path that can be edited, selected or not. A click removes the stretch under the pointer, a drag removes every stretch its rectangle touches, and an Alt-drag removes every stretch its freehand line crosses; each is one undo step, and Escape during a drag removes nothing. A closed path that loses a stretch becomes open, an open path that loses a middle stretch becomes two paths with its appearance in its place in the stacking order, a path that nothing crosses is removed whole, and the stretches that stay get no new anchors. Hidden and locked paths, guides and clipping paths are not trimmed and do not count as crossing. Add Points at / Split at Crossings share the crossing search: segments that meet at an anchor now count where they cross again elsewhere, and with Self Crossings a curved segment that loops over itself crosses itself. Command `addon.pathtools.trim`; `vectorcraft_pathops::addons::pathtools::{crossings_on, spans, without_spans}`. Not yet: a highlight of the stretch under the pointer before the click, and crossings with type, images and symbol instances. Tests: `crossings_on_*`, `segments_*`, `a_segment_that_loops_over_itself_crosses_itself`, `one_work_budget_*`, `spans_divide_*`, `a_subpath_without_*` and `a_slice_*` in `addons::pathtools::tests` in `vectorcraft-pathops`, `addons::trim` in `vectorcraft-tools` (click, rectangle, freehand line, Escape), `cmd::addons::pathtools::trim::tests` in `vectorcraft-engine` (a middle and an end stretch, a closed path opening, a rectangle and a line as one undo step, locked and hidden paths, guides and clipping paths, paths nothing crosses, compound path members, the selection, 3,000 other paths, a path too large to search left alone until touched, bad params refused), `the_plugins_submenu_selects_the_tools_and_opens_the_anchor_inspector` in `vectorcraft-ui-egui`, `edit_toolbar::tests` and `command_sweep`. Commands: `docs/mcp.md` › Path Precision Tools add-on.
+
 ## Document Tools add-on: Save a Timestamped Copy (2026-11-01)
 
 A VectorCraft addition, not a feature of the reference app, so no area score moves. Object › Plug-ins › Document Tools › Save a Timestamped Copy writes a copy of the document named `<name>_YYYY-MM-DD_HH-MM.<ext>` (the date and time in UTC, through chrono; `-2`, `-3`… added when that name is taken) next to the document, or into a folder picked (the folder picker) when it was never saved, in the document's own format or another save format. It writes through File › Save a Copy's save, so the document keeps its path, title and modified state, no undo step is made, and the write stays inside the automation roots in force. It is off on the web, which has no clock. Tests: `cmd::addons::document::tests` in `vectorcraft-engine` (the name and place, numbered names, the document unchanged and its content in the copy, an unsaved document needing a folder, other formats, bad params refused, automation roots), `addons::document::tests` in `vectorcraft-ui-egui` (the submenu, beside the document, the folder picked or cancelled) and `command_sweep`. Commands: `docs/mcp.md` › Document Tools add-on.
diff --git a/docs/three-d.md b/docs/three-d.md
index 79f9de806c..7baf430ecf 100644
--- a/docs/three-d.md
+++ b/docs/three-d.md
@@ -77,7 +77,7 @@ object is where the art was.
 |---|---|
 | Depth | 0–2,000 pt. At 0 the object is flat (the art turned like Rotate). |
 | Twist | 0° to 360°: the back face turned against the front, the walls following in slices. |
-| Taper | 1–100 %: the back face's size against the front's. |
+| Taper | 1–100 %: the back face's size against the front's. Without a twist, each wall (and each bevel band) stays flat, so it is one face, not cut into slices. |
 | Cap | **Solid** closes the front and back; **Hollow** leaves them open, showing the insides of the walls. |
 | Bevel Shape | **None**, **Classic** (a straight chamfer), **Rounded** (convex quarter round), **Cove** (concave), **Step** (two steps) or **Ogee** (an S curve). Our own cross-sections. |
 | Width, Height | How far the bevel reaches across the face and along the depth (0–1,000 pt each). The height is limited to the depth (half of it on each side with Bevel both sides). |
@@ -491,6 +491,7 @@ Release measurements and a repeatable CLI scene are in [3D lighting performance]
 
 | Date | Change |
 |---|---|
+| 2026-11-13 | Extrude & Bevel cuts its walls into slices only for a twist. A taper alone keeps each wall flat, so it is one face, without the light ticks at the joints between slices or the light line down a wall (#7019). Inflate still slices its sides for a taper. |
 | 2026-11-12 | The seams of Extrude & Bevel, Inflate and Rotate under a white light, and of the faces of Extrude & Bevel (Classic), Revolve (Classic) and Rotate (Classic), went from miter to round joins (the seams of Revolve and of colored lights, and 3D (Classic) Wireframe edges, were already round): no thorns on edge-on facets, and facets with no neighbor now have rounded convex corners ([Seams](#seams)). |
 | 2026-11-08 | Contours that cross, touch or overlap are merged by vectorcraft-pathops before Extrude & Bevel, Inflate and Rotate build a solid, sharing its limits; others are built as drawn. |
 | 2026-11-06 | Extrude & Bevel, Inflate and Rotate apply to groups and layers: every path, compound path and type in them turns about one shared axis (#4506). |
diff --git a/docs/type-parity.md b/docs/type-parity.md
index a559f760c8..308a395670 100644
--- a/docs/type-parity.md
+++ b/docs/type-parity.md
@@ -69,6 +69,7 @@ against Illustrator's public documentation; **estimated** unless noted.
 | CJK: East Asian Type units (Q, Ha) | done | Preferences › Units › East Asian Type (`unitsAsianType`, Points by default) offers every unit and Q and Ha, a quarter of a millimetre each ([Scripting Guide](https://ai-scripting.docsforadobe.dev/scripting/measurementUnits/): 0.709 pt per Q; [InDesign's unit notation](https://helpx.adobe.com/in/indesign/desktop/layout-and-grid-tools/rulers-and-measure-tools/change-ruler-measurement-units.html): `q`, `h`). The public pages do not say which fields follow it, so no field uses it yet and that waits for a source. Evidence: `q_and_ha_are_a_quarter_millimetre`, `east_asian_type_unit_*` |
 | CJK: manual tate-chu-yoko | done | Character panel menu › Tate-chu-yoko (`text.setFormat` / `text.setRangeStyle {tateChuYoko}`), with Show East Asian Options: marked characters stand side by side across one em of a vertical column, squeezed to the em when wider; two or three half-width digits still do so without the mark; horizontal type keeps the mark and does not move them. Tate-chu-yoko Settings… (`ui.tateChuYokoSettings`, `{tcyUpDown, tcyLeftRight}` in points) moves a marked block up or down and right or left as one piece. Evidence: `tests_vertical::manual_tate_chu_yoko_sets_marked_characters_across_one_em`, `tests_vertical::tate_chu_yoko_settings_move_a_marked_block_up_down_left_and_right`, `typecmd::tate_chu_yoko_is_a_character_attribute_saved_only_when_on`, `typecmd::tate_chu_yoko_settings_are_character_attributes_saved_only_when_set`, `dialogs::tate_chu_yoko::tests` |
 | CJK: Standard Vertical Roman Alignment | done | Character panel menu › Standard Vertical Roman Alignment (`text.setFormat` / `text.setRangeStyle {standardVerticalRoman}`), with Show East Asian Options, off by default: in vertical type the marked half-width characters (Latin letters, digits and other characters that would lie on their side) stand upright one below the other, each in its upright cell; spaces keep their width and tate-chu-yoko blocks stay across the column; horizontal type keeps the mark and does not change. Character Style Options has its own checkbox for it. Evidence: `tests_vertical::standard_vertical_roman_alignment_stands_half_width_characters_upright`, `typecmd::standard_vertical_roman_is_a_character_attribute_saved_only_when_on` |
+| CJK: warichu | done | Character panel menu › Warichu and Warichu Settings… (`text.setFormat` / `text.setRangeStyle {warichu, warichuLines, warichuGap, warichuScale, warichuAlign}`, `ui.warichuSettings`), with Show East Asian Options ([Format East Asian characters](https://helpx.adobe.com/illustrator/using/formatting-asian-characters.html)): marked characters set at a percentage of their size and stacked on 1 to 6 lines inside their line, one above the other in horizontal type and side by side in vertical type, with a line gap and eight alignments; a block stays whole on one line. Saved natively, carried by character styles, drawn on the canvas and in every export (SVG, PDF and `.ai` write such type as outlines). Type on a path sets the characters at their own size. Evidence: `tests::warichu`, `dialogs::warichu::tests`, `typecmd::area_tests::warichu_is_a_character_attribute_set_saved_and_exported` |
 | CJK: composite fonts | partial | Type › Composite Fonts… (`type.compositeFonts.set`), with Show East Asian Options: a font made of a font per class of character (Kanji, Kana, Punctuation, Symbols, Roman, Numerals), each with its own style, size and baseline in percent of the type's size, Kana, Roman and Numerals with horizontal and vertical scale, and Kana with Scale at Center; New, Delete Font, Import… and Export… (`.vccomposite`, `type.compositeFonts.import` and `.export`) ([Creating composite fonts](https://help.adobe.com/archive/en_US/illustrator/cs3/illustrator_cs3_help.pdf#page=347)). Composite fonts are listed first in the font menus, saved with the document, and their type is laid out per class; SVG and legacy `.ai` write it as outlines. Not yet: custom character sets, the Units menu, Show Sample. Evidence: `text::composite::tests::characters_fall_in_their_classes`, `tests::composite::composite_type_draws_each_class_in_its_font`, `compositefonts::tests`, `dialogs::composite_fonts::tests` |
 | CJK: ruby | partial | ruby (ふりがな) for live text (`type.ruby`): a reading over a byte range, above (right of the column in vertical type) or below, start/centre/end alignment, size, overhang or squeeze; saved natively, laid out with its line growing, drawn on the canvas, in SVG and PDF (as outlines where ruby is present), in EPS, EMF/WMF and legacy `.ai` (legacy `.ai` writes type with ruby as outlines), and kept by Create Outlines, Expand Appearance and flattening, each glyph where the layout puts it (`typecmd::ruby_tests::create_outlines_keeps_the_ruby_where_it_is_laid_out`) | #633 |
 | Language per character (Character panel › Language, character styles), text shaped in it | done | `text.setFormat` / `text.setRangeStyle {language}` by name or BCP 47 tag, one of Document Setup's languages (Hindi, Marathi, Gujarati, Bengali, Punjabi, Tamil, Telugu, Kannada, Malayalam, Odia and Urdu added, #4943; Assamese and Sanskrit added, #4947; Serbian: Cyrillic, Serbian: Latin and Croatian); the shaper gets the tag, so the font's language forms apply (OpenType `locl`: Turkish keeps `fi` apart and the dot on its i, #4940); new type takes the document's language; saved as the tag only when set, carried by character styles (#4946). English and eleven Indian languages hyphenate by run language; Sanskrit automatic hyphenation awaits allowlisted patterns (#4947). Not yet: `.ai`/PDF import of a text's language, paragraph styles. Evidence: `features::tests::language_picks_the_fonts_forms`, `features::tests::serbian_gets_the_fonts_serbian_forms`, `typecmd::area_tests::language_is_a_character_attribute_saved_only_when_set`, `tests::typo::indic_language_runs_hyphenate_with_both_composers`, `hyphen::tests::sanskrit_without_allowlisted_patterns_uses_only_exceptions`; spelling is checked in each run's Language (`text.spelling.check`, #4936) |
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index 974fbb440e..62a99726a2 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -434,7 +434,7 @@ next unit in the order a right-click on a ruler lists them, from Feet back to Po
 | Pathfinder panel › Pathfinder Options…: Precision, Remove Redundant Points, Divide and Outline Will Remove Unpainted Artwork | done | #3426; `object.pathfinder.options`, kept in the preferences; defaults (0.01 pt, both off) keep the earlier results; [spec](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/pathfinder-panel-overview.html) |
 | Cmd/Ctrl+4 repeats the last successful Shape Mode or Pathfinder operation on the selection | done | Panel operations, direct `object.pathfinder.*` commands and `command.batch` steps (Actions playback) set history; `action.batch`, Trap, compound-shape edits and live effects do not. Repeat uses current Pathfinder Options; [key spec](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html), [menu spec](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/pathfinder-panel-overview.html) |
 | Pathfinder panel: compound shapes (Make, Release and Expand Compound Shape in the panel menu, Alt-click a Shape Mode, a Shape Mode for selected members, the Expand button) | partial | #4522; `object.compoundShape.make`/`setMode`/`release`/`expand`; members stay editable, the area draws, exports and saves; the button of the members' shared mode is lit; blends, envelopes and warped objects are members as they draw; [spec](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/create-compound-shapes-with-pathfinder.html); missing: question marks for mixed modes, hit-testing by the area |
-| Canvas context menu | done | Layers rows, panels and type have none (gap) |
+| Canvas context menu | done | Right-clicking type opens the canvas menu, with Bullets and Numbering and Spelling. Layer, sublayer, group and object rows in the Layers panel offer Collect for Export (As Single Asset, As Multiple Assets) for the row, or for every highlighted row when it is one of them; artboard rows, library groups and items, the rulers and floating toolbar grips have menus too. Gaps: the Layers row menu has no other commands, guide and blend spine rows have no menu, and other panels have none |
 | SVG Interactivity panel: JavaScript for each object's events and the document's linked JavaScript files, written to SVG and read back as text | done | `svgInteractivity.*`, `ui.javascriptFilesDialog` |
 | Retype, Comments, Version History panels | missing | the last two are cloud features (out of scope) |
 | Blend panel (30.7) | partial | Window › Blend provides Type (Ease In, Ease Out, Ease In Out, Ease Out In), Ramp 0–100% and independent color Shift, alongside the existing blend controls. Easing is disabled without a spine. Original polynomial distributions approximate the publicly documented behavior. On-canvas Appearance and Easing widgets set Shift and Ramp; a blend without a spine shows the Appearance widget alone. [Public source](https://helpx.adobe.com/illustrator/desktop/manage-colors/apply-transparency-and-blending/blend-panel-overview.html) |
@@ -442,7 +442,6 @@ next unit in the order a right-click on a ruler lists them, from Feet back to Po
 | Gradient panel: Method, Classic or Perceptual (30.0) | done | Method menu under the Stroke buttons for linear and radial gradients (`paint.editGradient` `method`); [public source](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/create-and-edit-gradients/control-perceptual-interpolation-in-gradients.html); `panels::gradient` test |
 | Gradient panel: Presets (30.0) | done | Presets menu by library (theme) plus Saved: applies a preset to the gradient behind the active proxy, keeping its placement, one undo step; panel menu Save Gradient Preset…, Delete Gradient Preset, Hide/Show Presets (`gradient.presets.*`); `panels::gradient` tests |
 | Gradient panel: delete a stop | done | Delete Stop at the right end of the ramp deletes the selected stop, and a stop dragged down off the ramp is deleted on release, never below two stops, one undo step each; [Gradient panel options](https://helpx.adobe.com/illustrator/desktop/paint-and-fill/create-and-edit-gradients/gradient-tool-and-panel.html); `panels::gradient` test |
-| SVG Interactivity, Retype, Comments, Version History panels | missing | the last two are cloud features (out of scope) |
 | Workspaces (save, reset, switch); each remembers the layout changes made in it across switches and restarts until Reset <name> | done | `UiState::workspace_changes` |
 | Opening a file: after 0.4 s a progress window with the file name, a moving bar (reading counts no steps), how many more files wait, Cancel (Esc: the file doesn't open) and Continue in Background; never over another dialog or progress window | done | #5930; `opening::show`, `file.cancelOpen`, `file.openInBackground`. Save, Place and Close still show only the status bar's spinner (Place and Save run off the UI thread; Close is immediate) |
 | Window › Help Bar shows or hides the tool-help strip apart from the status bar; kept with the preferences and in saved workspaces; Presentation Mode hides both bars | done | `window.helpBar`; `help_bar_toggle_is_independent_and_saved_in_workspaces`, `help_bar_and_status_bar_render_independently`, `legacy_help_bar_visibility_follows_each_layouts_status_bar` |
@@ -465,9 +464,10 @@ next unit in the order a right-click on a ruler lists them, from Feet back to Po
 | Document Tools add-on (VectorCraft addition): Object › Plug-ins › Document Tools › Batch Trace Folder asks for a folder of images, then a destination folder, traces each image with a preset (optionally expanded) and saves it there as `.vectorcraft`, `.svg`, `.pdf`, `.ai` or `.eps` under its own name (taken names numbered, nothing replaced), closing each image again; the status bar counts the images traced and those that couldn't be; off on the web | done | #4921; `addon.document.batchTraceFolder`, `crates/engine/src/cmd/addons/document/batch_trace.rs`, `crates/ui-egui/src/addons/document.rs` and their tests; not a feature of the reference app |
 | Document Tools add-on (VectorCraft addition): Object › Plug-ins › Document Tools › New Symbols from Layers makes a symbol of each layer's art named after the layer (the highlighted layers when two or more are, else all); Convert Layers to Symbols also replaces each layer's art with an instance in place; empty layers skipped, one undo step | done | #4927; `addon.document.symbolsFromLayers`, `crates/engine/src/cmd/addons/document.rs`, `crates/ui-egui/src/addons/document.rs` and their tests; not a feature of the reference app, so it is not scored |
 | Smart Pen add-on (VectorCraft addition): Object › Plug-ins › Smart Pen selects the Smart Pen Tool, which the All Tools drawer lists under its own heading but neither toolbar shows as shipped (no shortcut), and opens the Smart Pen panel (next segment straight or curved; Remove Points Keep Shape, Make Smooth, Make Corner, Retract Handles, Close or Join). The tool draws (click: straight or curved segment, a curve after a straight one tangent; drag: smooth anchor, Alt breaks the handle, Shift 45°, Space moves it; Tab switches a segment; rubber band; close, join, continue) and edits without switching tools (click selects a point, drag moves it, Alt-click removes it keeping the shape, Shift+Alt-click deletes it, double-click toggles smooth/corner; handle drags with Shift and Alt; segment drags reshape, Alt-click adds a point) | done | `addon.pen.*`, `crates/tools/src/addons/smart_pen.rs`, `crates/ui-egui/src/addons/pen.rs` and their tests; not a feature of the reference app, so it is not scored |
-| Path Precision Tools add-on (VectorCraft addition): Object › Plug-ins › Path Precision Tools selects its seven tools (Anchor Eraser Brush, Extend Path, Measure & Inspect, Parametric Shape, Corner Tool, Slide Anchor Along Path, Shared Edge Merge Tool), which the All Tools drawer lists under their own heading but neither toolbar shows as shipped, opens the Anchor Inspector panel (the selected anchor's X/Y and handle lengths and angles as fields; Make Smooth, Make Corner, Equalize Handles, Remove Points Keep Shape, Add Points, the three ways to close) and the Parametric Shape panel (kind, count, W/H, rotation, the kind's own values and corner radius of the selected parametric shape, or of the tool's next one), and runs Add Points at / Split at Crossings and Convert to Parametric Shape; the Parametric Shape Tool draws ten re-editable kinds from the centre (↑/↓ and ←/→ change their numbers while dragging) and edits a selected one with handles; the Corner Tool cuts editable corners on any path (hover shows the anchor, a click uses its radius and kind, a drag sizes the corner, Shift whole values; a corner's marker selects it and loads its values, drags to resize, to 0 or double-clicked removes it; never past what fits; Alt-marquee cuts every anchor inside) with a Corners section in the Anchor Inspector (radius, kind, selected count, Apply to Selected Anchors); Slide Anchor Along Path drags an anchor along its curve with the segments beside it refitted, Shift snapping where the tangent is a multiple of 45°; the Shared Edge Merge Tool shows, over two paths touching at two coincident anchors, the two stretches and the edge merging them, a click merges them (half way; Shift the upper path, Alt the lower), and near anchors meet or an anchor one path lacks is added to match (Shift+Alt asks for this inside a stretch), with a Shared Edges section in the Anchor Inspector (brush diameter, coincidence 0 to 3 pt, Keep Shared Points Together, which takes coincident anchors along with the add-on's own anchor moves); a double-click on the brush or Extend Path tool opens its options | done | `addon.pathtools.*`, `crates/tools/src/addons/`, `crates/ui-egui/src/addons/pathtools.rs`, `crates/ui-egui/src/addons/pathtools/` and their tests; not a feature of the reference app, so it is not scored |
+| Path Precision Tools add-on (VectorCraft addition): Object › Plug-ins › Path Precision Tools selects its eight tools (Anchor Eraser Brush, Extend Path, Measure & Inspect, Parametric Shape, Corner Tool, Slide Anchor Along Path, Shared Edge Merge Tool, Trim at Crossings Tool), which the All Tools drawer lists under their own heading but neither toolbar shows as shipped, opens the Anchor Inspector panel (the selected anchor's X/Y and handle lengths and angles as fields; Make Smooth, Make Corner, Equalize Handles, Remove Points Keep Shape, Add Points, the three ways to close) and the Parametric Shape panel (kind, count, W/H, rotation, the kind's own values and corner radius of the selected parametric shape, or of the tool's next one), and runs Add Points at / Split at Crossings and Convert to Parametric Shape; the Parametric Shape Tool draws ten re-editable kinds from the centre (↑/↓ and ←/→ change their numbers while dragging) and edits a selected one with handles; the Corner Tool cuts editable corners on any path (hover shows the anchor, a click uses its radius and kind, a drag sizes the corner, Shift whole values; a corner's marker selects it and loads its values, drags to resize, to 0 or double-clicked removes it; never past what fits; Alt-marquee cuts every anchor inside) with a Corners section in the Anchor Inspector (radius, kind, selected count, Apply to Selected Anchors); Slide Anchor Along Path drags an anchor along its curve with the segments beside it refitted, Shift snapping where the tangent is a multiple of 45°; the Shared Edge Merge Tool shows, over two paths touching at two coincident anchors, the two stretches and the edge merging them, a click merges them (half way; Shift the upper path, Alt the lower), and near anchors meet or an anchor one path lacks is added to match (Shift+Alt asks for this inside a stretch), with a Shared Edges section in the Anchor Inspector (brush diameter, coincidence 0 to 3 pt, Keep Shared Points Together, which takes coincident anchors along with the add-on's own anchor moves); a double-click on the brush or Extend Path tool opens its options | done | `addon.pathtools.*`, `crates/tools/src/addons/`, `crates/ui-egui/src/addons/pathtools.rs`, `crates/ui-egui/src/addons/pathtools/` and their tests; not a feature of the reference app, so it is not scored |
 | Path Precision Tools add-on (VectorCraft addition): Object › Plug-ins › Path Precision Tools › Divide into Dashes… (Dash and Gap in any unit, Fit to Corners and Ends, Remove Gaps; Preview) cuts the selected paths, or only their direct-selected segments, into open pieces along the curve, keeping their appearance, one undo step | done | #4950; `addon.pathtools.divideDashes`, `crates/pathops/src/addons/pathtools/dashes.rs`, `crates/ui-egui/src/addons/pathtools/dashes.rs` and their tests; not a feature of the reference app, so it is not scored |
 | Path Precision Tools add-on (VectorCraft addition): Object › Plug-ins › Path Precision Tools › Set Corners… (also a button in the Anchor Inspector's Corners section: Radius in any unit, Corner kind, Anchors: All, Odd-Numbered or Even-Numbered, counted from each path's first anchor; Angle: from … to …°, only the corners whose sides meet at an angle in that range; Preview) cuts corners on the chosen anchors of every selected path, one undo step | done | #5546, #5545; `addon.pathtools.cornerSet` (`every`, `minAngle`, `maxAngle`), `crates/ui-egui/src/addons/pathtools/set_corners.rs` and their tests; not a feature of the reference app, so it is not scored |
+| Path Precision Tools add-on (VectorCraft addition): Object › Plug-ins › Path Precision Tools › Trim at Crossings Tool (in the All Tools drawer under the add-on's heading, in neither toolbar as shipped, no shortcut) removes stretches of paths between the places where they are crossed, on any editable path, selected or not: a click removes the stretch under the pointer, a drag every stretch its rectangle touches, an Alt-drag every stretch its freehand line crosses; one undo step each; Escape during a drag removes nothing | done | `addon.pathtools.trim` (in `crates/engine/src/cmd/addons/pathtools/trim.rs`), `crates/tools/src/addons/trim.rs` and their tests; not a feature of the reference app, so it is not scored |
 | Path Precision Tools add-on (VectorCraft addition): Object › Plug-ins › Path Precision Tools › Expand Dashes into Paths turns each selected path's dashed stroke into separate open paths, one per dash, laid out as the stroke draws them (pattern, offset, Align Dashes to Corners and Path Ends), each keeping the stroke with the dashes off; one undo step | done | #4922; `addon.pathtools.expandDashes` (in `crates/engine/src/cmd/addons/pathtools.rs`, using the renderer's dash layout) and its tests; not a feature of the reference app, so it is not scored |
 | Path Precision Tools add-on (VectorCraft addition): Effect › Path Effects lists its live effects (Dashes to Geometry, Add Anchors, Extend Path, Close Path, Smooth Anchors, Retract Handles, Reverse Direction, Simplify Anchors, Split at Anchors), each with the effect dialog's live Preview except Reverse Direction, which has no options, and listed in the Appearance panel like any effect | done | `addon.path.*`, `crates/effects/src/addons/path.rs`, `crates/ui-egui/src/addons/pathtools.rs` and their tests; not a feature of the reference app, so it is not scored |
 | Path Precision Tools add-on (VectorCraft addition): Object › Plug-ins › Path Precision Tools selects its four tools (Anchor Eraser Brush, Extend Path, Measure & Inspect, Parametric Shape), which the All Tools drawer lists under their own heading but neither toolbar shows as shipped, opens the Anchor Inspector panel (the selected anchor's X/Y and handle lengths and angles as fields; Make Smooth, Make Corner, Equalize Handles, Remove Points Keep Shape, Add Points, the three ways to close) and the Parametric Shape panel (kind, count, W/H, rotation, the kind's own values and corner radius of the selected parametric shape, or of the tool's next one), and runs Add Points at / Split at Crossings and Convert to Parametric Shape; the Parametric Shape Tool draws ten re-editable kinds from the centre (↑/↓ and ←/→ change their numbers while dragging) and edits a selected one with handles; a double-click on the brush or Extend Path tool opens its options | done | `addon.pathtools.*`, `crates/tools/src/addons/`, `crates/ui-egui/src/addons/pathtools.rs`, `crates/ui-egui/src/addons/pathtools/shape.rs` and their tests; not a feature of the reference app, so it is not scored |