diff --git a/crates/doc/src/pixels.rs b/crates/doc/src/pixels.rs
index 0812095826..1c231f7bbe 100644
--- a/crates/doc/src/pixels.rs
+++ b/crates/doc/src/pixels.rs
@@ -194,6 +194,27 @@ impl ImageBlob {
             .collect();
         Some((w, h, cover))
     }
+
+    /// The pixels as straight RGBA, row by row from the top, with the width and the height;
+    /// `None` when the image can't be decoded within [`MAX_RASTER_ALLOC`].
+    pub fn rgba(&self) -> Option<(u32, u32, Vec<u8>)> {
+        let img = rgba_within(&self.bytes, MAX_RASTER_ALLOC)?;
+        let (w, h) = img.dimensions();
+        Some((w, h, img.into_raw()))
+    }
+
+    /// The width and height in pixels the image's file says it has; `None` for data that isn't an
+    /// image the decoder reads. Reads only its header.
+    pub fn pixel_size(&self) -> Option<(u32, u32)> {
+        image::ImageReader::new(Cursor::new(self.bytes.as_slice())).with_guessed_format().ok()?.into_dimensions().ok()
+    }
+
+    /// Whether the image's file is a PNG that stores palette indices (an indexed-color image).
+    /// Reads only its header.
+    pub fn indexed_png(&self) -> bool {
+        // The signature, then the IHDR chunk: length, type, width, height, bit depth, color type.
+        self.bytes.starts_with(b"\x89PNG\r\n\x1a\n") && self.bytes.get(12..16) == Some(b"IHDR".as_slice()) && self.bytes.get(25) == Some(&3)
+    }
 }
 
 impl ImageBlob {
diff --git a/crates/engine/src/cmd/colorcmds.rs b/crates/engine/src/cmd/colorcmds.rs
index bbc56dbc15..b2b44a898d 100644
--- a/crates/engine/src/cmd/colorcmds.rs
+++ b/crates/engine/src/cmd/colorcmds.rs
@@ -3,7 +3,11 @@
 //! shared colour visitor [`Recolor`]: fills and strokes (solid colours, gradient stops and text
 //! runs), gradient meshes, embedded images and pattern fills. Colours linked to a global swatch are
 //! unlinked when they change; Adjust Color Balance's Global mode shifts their tints instead.
+//!
+//! Convert to Indexed Color uses the same visitor for embedded images only, and stores each one as
+//! a palette PNG.
 
+use std::cell::Cell;
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
@@ -15,7 +19,9 @@ use vectorcraft_doc::live::lerp_color;
 use vectorcraft_doc::pattern::PatternDef;
 pub(crate) use vectorcraft_doc::recolor::map_paint;
 use vectorcraft_doc::recolor::{ColorVisitor, Reach, map_links, recolor_node};
-use vectorcraft_doc::{Document, ImageBlob, Node, NodeId, NodeKind};
+use vectorcraft_doc::{Document, ImageBlob, MAX_RASTER_ALLOC, Node, NodeId, NodeKind};
+use vectorcraft_render::encode::png::{PngOptions, encode_indexed};
+use vectorcraft_render::encode::quantize::{Dither, Indexed, PaletteOptions, Reduction, quantize, quantize_to};
 
 use super::edit::selected_roots;
 use super::{
@@ -66,6 +72,15 @@ pub fn specs() -> Vec<CommandSpec> {
                 })
             }
         ),
+        cmd!(
+            "edit.colors.toIndexed",
+            "Convert to Indexed Color…",
+            ["Edit", "Edit Colors"],
+            None,
+            "{reduction?: \"selective\" (default)|\"perceptual\"|\"adaptive\"|\"web\"|\"gray\"|\"blackWhite\" (chosen as for a PNG-8 export)|\"uniform\" (evenly spaced levels of red, green and blue: the most levels, 2 to 6, whose cube fits in `colors` with one entry left for transparency)|\"document\" (the colors of the document's swatches, at most 255), colors?: 2..256 (default 256; the most palette entries, the transparent one included; at least 9 for uniform; refused for blackWhite and document), dither?: \"diffusion\" (default)|\"pattern\"|\"noise\"|\"none\", ditherAmount?: 0..100 (default 100), ids?} store each embedded image in the selection (in groups too) as an indexed-color PNG: a palette of at most 256 RGB colors, each pixel the index of one; pixels under half opacity become one transparent entry and the others opaque, keeping their color; linked images, colorized images and the images of color glyphs in outlined type keep their pixels; each image changed becomes a new image, one undo step for all; an image that is an indexed PNG already and would show the same pixels is left as it is, and no undo step is recorded when no image changes; an image of more than 134,217,728 pixels (33,554,432 in the web app) is refused with an error and nothing changes; reduction and dither ids are read as for a PNG-8 export, ignoring case → {changed: images changed, notChanged: the locked and hidden objects Select All left out that hold an image that is not an indexed PNG yet, warning?} (as edit.colors.invert)",
+            has_selection,
+            to_indexed
+        ),
         cmd!(
             "edit.colors.saturate",
             "Saturate…",
@@ -149,6 +164,13 @@ fn gray_level(c: Color) -> f32 {
 /// gradient stop): `(colour, link, tint)`, true when it changed them.
 pub(crate) type LinkMap<'a> = dyn Fn(&mut Color, &mut Option<String>, &mut f32) -> bool + 'a;
 
+/// What a pass that remakes whole images makes of one: its new copy, `None` when it stays as it is.
+type Remake<'a> = dyn Fn(&ImageBlob) -> Option<ImageBlob> + 'a;
+
+/// The objects a pass recolors, and the locked and hidden objects the selection left out, each
+/// with whether it is hidden ([`pass_targets`]).
+type Targets = (Vec<NodeId>, Vec<(NodeId, bool)>);
+
 /// The identity colour map (a pass that only maps linked colours).
 fn same(c: Color) -> Color {
     c
@@ -191,6 +213,8 @@ pub(crate) struct Recolor<'a> {
     scope: Scope,
     /// Recolored images are stored with one gray channel ([`ImageBlob::map_gray`]).
     gray_images: bool,
+    /// Makes each embedded image's new copy in place of `f` (`None`: it stays as it is).
+    remake: Option<&'a Remake<'a>>,
     /// Image key → the key of its recoloured copy (`None`: unchanged).
     images: HashMap<String, Option<String>>,
     /// Pattern name → the name of its recoloured copy (`None`: unchanged, or being recoloured).
@@ -207,6 +231,7 @@ impl<'a> Recolor<'a> {
             links: None,
             scope,
             gray_images: false,
+            remake: None,
             images: HashMap::new(),
             patterns: HashMap::new(),
             new_images: vec![],
@@ -229,7 +254,7 @@ impl<'a> Recolor<'a> {
 
     /// A pass that maps colors as this one does, with nothing recolored yet.
     fn again(&self) -> Self {
-        Self { links: self.links, gray_images: self.gray_images, ..Self::new(self.scope, self.f) }
+        Self { links: self.links, gray_images: self.gray_images, remake: self.remake, ..Self::new(self.scope, self.f) }
     }
 
     /// The entries of `objects` (ids, each with a flag) whose object this pass would change, other
@@ -328,7 +353,9 @@ impl<'a> Recolor<'a> {
         }
         let f = self.f;
         let blob = d.images.get(key)?;
-        let new = if self.gray_images {
+        let new = if let Some(remake) = self.remake {
+            remake(blob)
+        } else if self.gray_images {
             blob.map_gray(|[r, g, b]| f(Color::rgb8(r, g, b)).to_rgba8(1.0)[0])
         } else {
             blob.map_rgb(|[r, g, b]| {
@@ -534,6 +561,187 @@ impl NotChanged {
     }
 }
 
+/// The objects a pass recolors (the `ids` param's, default: the selection's) and the locked and
+/// hidden objects the selection left out ([`left_out`]), each with whether it is hidden.
+fn pass_targets(s: &Session, p: &Value, cmd: &str) -> Result<Targets> {
+    Ok(match ids_param(p, "ids", cmd)? {
+        Some(v) => (v, vec![]),
+        None => {
+            let roots = selected_roots(s)?;
+            let st = s.doc()?;
+            let left = left_out(&st.doc, st.isolation, &roots);
+            (roots, left)
+        }
+    })
+}
+
+/// Edit › Edit Colors › Convert to Indexed Color: the embedded images of the objects stored as
+/// indexed-color PNGs ([`Indexing`]). The pass runs on a copy of the document, so no undo step is
+/// recorded when no image changes.
+fn to_indexed(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "edit.colors.toIndexed";
+    let indexing = Indexing::of(s, p)?;
+    // A typing session ends here as `s.edit` would end it, before the copy is taken, so that the
+    // copy holds what was typed.
+    if !s.previewing && super::typing_in_progress(s) {
+        super::settle_interaction(s)?;
+    }
+    let remake = |b: &ImageBlob| indexing.convert(b);
+    let images = Scope { fill: false, stroke: false, images: true, patterns: false };
+    let pass = Recolor { remake: Some(&remake), ..Recolor::new(images, &same) };
+    // A left-out image counts as one the pass would change when it is an image that is not an
+    // indexed PNG yet; it is not converted to find out. The empty PNG only gives it a new key.
+    let would = |b: &ImageBlob| (!b.indexed_png() && b.pixel_size().is_some()).then(|| ImageBlob::png(vec![]));
+    let (ids, left) = pass_targets(s, p, C)?;
+    let st = s.doc()?;
+    let colorized_ok = super::paint::check_colorized(&st.doc).is_ok();
+    let not_changed = NotChanged::of(
+        Recolor { remake: Some(&would), ..Recolor::new(images, &same) }.would_change(&st.doc, &left).into_iter().map(|(_, hidden)| hidden),
+    );
+    let mut doc = (*st.doc).clone();
+    let n = pass.run(&mut doc, &ids);
+    if let Some((w, h)) = indexing.too_large.get() {
+        return Err(bad(C, format!("an image of {w} × {h} pixels is too large to convert (at most {} pixels)", Indexing::MAX_PIXELS)));
+    }
+    if n > 0 {
+        s.edit("Convert to Indexed Color", |d, _| {
+            *d = doc;
+            super::paint::check_colorized_kept(colorized_ok, d).map_err(|e| bad(C, e))
+        })?;
+    }
+    let mut out = json!({ "changed": n });
+    not_changed.report(&mut out);
+    Ok(out)
+}
+
+/// How Convert to Indexed Color reduces an image's colors: the palette options of a PNG-8
+/// export, with transparency kept and no matte, and the fixed palette of the uniform and document
+/// reductions.
+struct Indexing {
+    options: PaletteOptions,
+    fixed: Option<Vec<[u8; 3]>>,
+    /// The size of an image [`Self::convert`] left as it is because it has more than
+    /// [`Self::MAX_PIXELS`] pixels.
+    too_large: Cell<Option<(u32, u32)>>,
+}
+
+impl Indexing {
+    /// The most pixels an image may have. Converting one holds at most about 8 bytes a pixel at
+    /// once: decoding (the decoded samples and the RGBA), quantizing (the RGBA, the colors and the
+    /// indices) and writing the PNG after the RGBA is freed (the indices, the packed and filtered
+    /// rows and the compressed data). 16 bytes a pixel keeps that within [`MAX_RASTER_ALLOC`] twice
+    /// over.
+    const MAX_PIXELS: u64 = MAX_RASTER_ALLOC / 16;
+
+    /// The reduction `p` asks for (see `edit.colors.toIndexed`); a value out of range or of the
+    /// wrong type is an error. Reduction and dither ids are read as a PNG-8 export reads them.
+    fn of(s: &Session, p: &Value) -> Result<Self> {
+        const C: &str = "edit.colors.toIndexed";
+        let reduction = text_param(p, "reduction", C)?.unwrap_or("selective");
+        let colors = match p.get("colors") {
+            None | Some(Value::Null) => None,
+            Some(v) => {
+                Some(v.as_u64().filter(|n| (2..=256).contains(n)).ok_or_else(|| bad(C, "`colors` must be a whole number from 2 to 256"))? as u16)
+            }
+        };
+        let dither = match text_param(p, "dither", C)? {
+            None => Dither::Diffusion,
+            Some(d) => Dither::from_id(d).ok_or_else(|| bad(C, format!("unknown dither `{d}` (diffusion, pattern, noise or none)")))?,
+        };
+        let dither_amount = match p.get("ditherAmount") {
+            None | Some(Value::Null) => 100,
+            Some(v) => {
+                v.as_f64().filter(|x| (0.0..=100.0).contains(x)).ok_or_else(|| bad(C, "`ditherAmount` must be a number from 0 to 100"))?.round() as u8
+            }
+        };
+        let options =
+            |r: Reduction| PaletteOptions { colors: colors.unwrap_or(256), reduction: r, dither, dither_amount, transparency: true, matte: None };
+        let refuse_colors = |name: &str| match colors {
+            Some(_) => Err(bad(C, format!("`colors` does not apply to the {name} reduction"))),
+            None => Ok(()),
+        };
+        let fixed = |palette: Vec<[u8; 3]>| Self { options: options(Reduction::Adaptive), fixed: Some(palette), too_large: Cell::new(None) };
+        Ok(match reduction.to_ascii_lowercase().as_str() {
+            "uniform" => {
+                let n = colors.unwrap_or(256);
+                // One entry is kept for transparent pixels.
+                let levels =
+                    (2..=6u16).rev().find(|l| l.pow(3) < n).ok_or_else(|| bad(C, "`colors` must be at least 9 for the uniform reduction"))?;
+                let level = |i: u16| (u32::from(i) * 255 / u32::from(levels - 1)) as u8;
+                let mut palette = Vec::with_capacity(usize::from(levels.pow(3)));
+                for r in 0..levels {
+                    for g in 0..levels {
+                        for b in 0..levels {
+                            palette.push([level(r), level(g), level(b)]);
+                        }
+                    }
+                }
+                fixed(palette)
+            }
+            "document" => {
+                refuse_colors("document")?;
+                let mut palette: Vec<[u8; 3]> = vec![];
+                for c in s.doc()?.doc.swatches_iter().filter_map(|sw| sw.paint.color()) {
+                    let [r, g, b, _] = c.to_rgba8(1.0);
+                    if !palette.contains(&[r, g, b]) {
+                        palette.push([r, g, b]);
+                    }
+                }
+                if palette.is_empty() {
+                    return Err(bad(C, "the document has no color swatches"));
+                }
+                if palette.len() > 255 {
+                    return Err(bad(C, format!("the document's swatches hold {} colors; the document reduction takes at most 255", palette.len())));
+                }
+                fixed(palette)
+            }
+            id => {
+                let r = Reduction::from_id(id).ok_or_else(|| {
+                    bad(C, format!("unknown reduction `{reduction}` (selective, perceptual, adaptive, web, gray, blackWhite, uniform or document)"))
+                })?;
+                if r == Reduction::BlackWhite {
+                    refuse_colors("blackWhite")?;
+                }
+                Self { options: options(r), fixed: None, too_large: Cell::new(None) }
+            }
+        })
+    }
+
+    /// Image `b` as an indexed-color PNG; `None` when it can't be decoded, when it has more than
+    /// [`Self::MAX_PIXELS`] pixels (noted in `too_large`), or when it is an indexed PNG already and
+    /// every pixel would show as it does.
+    fn convert(&self, b: &ImageBlob) -> Option<ImageBlob> {
+        let (w, h) = b.pixel_size()?;
+        if u64::from(w) * u64::from(h) > Self::MAX_PIXELS {
+            self.too_large.set(Some((w, h)));
+            return None;
+        }
+        let (w, h, rgba) = b.rgba()?;
+        let ix = match &self.fixed {
+            Some(palette) => quantize_to(&rgba, w, h, &self.options, palette),
+            None => quantize(&rgba, w, h, &self.options),
+        };
+        if b.indexed_png() && shows_same(&ix, &rgba) {
+            return None;
+        }
+        // The PNG writer's buffers take the place of the pixels.
+        drop(rgba);
+        Some(ImageBlob::png(encode_indexed(&ix, &PngOptions::default()).ok()?))
+    }
+}
+
+/// Whether palette image `ix` shows every pixel of straight RGBA `rgba` as it is: transparent
+/// where they are transparent, and the same color where they are opaque.
+fn shows_same(ix: &Indexed, rgba: &[u8]) -> bool {
+    let px = rgba.as_chunks::<4>().0;
+    px.len() == ix.indices.len()
+        && px.iter().zip(&ix.indices).all(|(p, &i)| match (p[3], ix.transparent == Some(i)) {
+            (0, clear) => clear,
+            (255, false) => ix.palette.get(usize::from(i)).is_some_and(|c| c[..] == p[..3]),
+            _ => false,
+        })
+}
+
 fn saturate(s: &mut Session, p: &Value) -> Result<Value> {
     let i = (f64_req(p, "intensity", "edit.colors.saturate")?.clamp(-100.0, 100.0) / 100.0) as f32;
     recolor(s, p, "edit.colors.saturate", "Saturate", &move |c| {
diff --git a/crates/engine/src/cmd/docinfo.rs b/crates/engine/src/cmd/docinfo.rs
index a43325becd..a9fb07bdf8 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",
+            "{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",
             has_doc,
             info
         ),
@@ -425,6 +425,64 @@ fn applied_brushes(d: &Document, n: &Node, members: &HashSet<*const Node>) -> Ve
     if follows { used } else { vec![] }
 }
 
+/// Whether `n` draws, as far as its own state goes: a hidden object, and an object at an opacity
+/// of 0, paint no color, and neither do their members.
+fn draws(n: &Node) -> bool {
+    n.visible && n.opacity > 0.0
+}
+
+/// The object of `d` at index path `path`, with whether the groups and layers around it draw
+/// ([`draws`]).
+fn node_and_drawn<'a>(d: &'a Document, path: &[usize]) -> Option<(&'a Node, bool)> {
+    let (first, rest) = path.split_first()?;
+    let mut at: &Node = d.layers.get(*first)?;
+    let mut drawn = true;
+    for &i in rest {
+        drawn &= draws(at);
+        at = &**at.children()?.get(i)?;
+    }
+    Some((at, drawn))
+}
+
+/// 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] {
+    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 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
+    // paint (a list marker set in its run does), and a stroke with no width paints nothing.
+    if let Some((t, painted)) = &painted_runs {
+        for run in painted.iter().filter_map(|i| t.runs.get(*i)) {
+            let stroke = (run.style.stroke_width > 0.0).then_some(&run.style.stroke);
+            for paint in std::iter::once(&run.style.fill).chain(stroke) {
+                for (used, label) in used.iter_mut().zip(labels) {
+                    for name in label(paint) {
+                        if !used.contains(&name) {
+                            used.push(name);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // A grayscale or 1-bit image colorized with a spot color prints it, while its pixels take the
+    // color, as the renderer draws it.
+    if let NodeKind::Image(im) = &n.kind
+        && let Some(colorize) = n.extras().colorize.as_deref()
+        && d.image_blob(im).is_some_and(|b| b.takes_colorize())
+    {
+        for name in spot(colorize) {
+            if !used[0].contains(&name) {
+                used[0].insert(0, name);
+            }
+        }
+    }
+    used
+}
+
 fn info(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "document.info";
     let category = str_param(p, "category");
@@ -440,8 +498,13 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
     let st = s.doc()?;
     let d = &st.doc;
     let selection_only = bool_or(p, "selectionOnly", false);
-    let roots: Vec<&Node> =
-        if selection_only { st.selection.objects.iter().filter_map(|id| d.node(*id)).collect() } else { d.layers.iter().map(|l| &**l).collect() };
+    // Each root with whether the groups and layers around it draw: a selected object inside a hidden group or layer, or one
+    // at an opacity of 0, paints nothing.
+    let roots: Vec<(&Node, bool)> = if selection_only {
+        st.selection.objects.iter().filter_map(|id| node_and_drawn(d, &d.index_path(*id)?)).collect()
+    } else {
+        d.layers.iter().map(|l| (&**l, true)).collect()
+    };
     let mut counts: BTreeMap<&str, usize> = BTreeMap::new();
     // The paths' total length, as Document Info › Objects shows it (the length of a cut line, a
     // strip of LEDs along the letters, #1958).
@@ -467,7 +530,6 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
     let mut spot_objects: Vec<Value> = vec![];
     let mut spot_rows: Vec<(String, String)> = vec![];
     let mut spot = BTreeSet::new();
-    let (spot_label, pattern, gradient) = (|p: &Paint| spot_labels(&spot_swatches, p), one_label(pattern_label), one_label(gradient_label));
     let mut styles: Vec<&str> = if selection_only { vec![] } else { d.graphic_styles.iter().map(|g| g.name.as_str()).collect() };
     // `library` holds the Brushes panel's brushes, and `brushes` the brushes the visited objects' strokes draw with, each once,
     // in walk order.
@@ -494,10 +556,18 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
             members.extend(children.iter().map(|c| std::ptr::from_ref(&**c)));
         }
     });
-    for r in roots {
-        r.walk(&mut |n| {
+    // Depth first, in paint order, as `Node::walk` visits: each object with whether it and the groups and layers around it
+    // draw. An object that does not draw is still counted, and its members are visited.
+    let mut stack: Vec<(&Node, bool)> = vec![];
+    for (r, drawn) in roots {
+        stack.push((r, drawn));
+        while let Some((n, around)) = stack.pop() {
             if !seen.insert(std::ptr::from_ref(n)) {
-                return;
+                continue;
+            }
+            let drawn = around && draws(n);
+            if let Some(ch) = n.children() {
+                stack.extend(ch.iter().rev().map(|c| (&**c, drawn)));
             }
             let k = match &n.kind {
                 // The Guides row counts paths made into guides; ruler guides are not objects.
@@ -545,42 +615,8 @@ 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's fills and strokes paint, each once.
-            let painted_runs = painted_runs(d, &spot_swatches, n);
-            let mut used_spots = own_paints(d, n, &members, painted_runs.as_ref(), &spot_label);
-            let mut used_patterns = own_paints(d, n, &members, painted_runs.as_ref(), &pattern);
-            let mut used_gradients = own_paints(d, n, &members, painted_runs.as_ref(), &gradient);
-            // The characters' own paints: an inline graphic draws no outline and does not take its
-            // run's paint (a list marker set in its run does), and a stroke with no width paints
-            // nothing.
-            if let Some((t, painted)) = &painted_runs {
-                for run in painted.iter().filter_map(|i| t.runs.get(*i)) {
-                    let stroke = (run.style.stroke_width > 0.0).then_some(&run.style.stroke);
-                    for paint in std::iter::once(&run.style.fill).chain(stroke) {
-                        let labels: [(&mut Vec<String>, &PaintNames<'_>); 3] =
-                            [(&mut used_spots, &spot_label), (&mut used_patterns, &pattern), (&mut used_gradients, &gradient)];
-                        for (used, label) in labels {
-                            for name in label(paint) {
-                                if !used.contains(&name) {
-                                    used.push(name);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            // A grayscale or 1-bit image colorized with a spot color prints it, while its pixels take
-            // the color, as the renderer draws it.
-            if let NodeKind::Image(im) = &n.kind
-                && let Some(colorize) = n.extras().colorize.as_deref()
-                && d.image_blob(im).is_some_and(|b| b.takes_colorize())
-            {
-                for name in spot_label(colorize) {
-                    if !used_spots.contains(&name) {
-                        used_spots.insert(0, name);
-                    }
-                }
-            }
+            // 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() };
             // Objects counts the objects that Spot Color Objects, Pattern Objects and Gradient Objects list.
             if !used_spots.is_empty() {
                 let name = n.display_name();
@@ -615,9 +651,11 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
             {
                 styles.push(&g.name);
             }
-            for b in applied_brushes(d, n, &members) {
-                if !brushes.contains(&b) {
-                    brushes.push(b);
+            if drawn {
+                for b in applied_brushes(d, n, &members) {
+                    if !brushes.contains(&b) {
+                        brushes.push(b);
+                    }
                 }
             }
             if let NodeKind::Repeat(spec) = &n.kind {
@@ -625,7 +663,7 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
                 repeats.push(entry);
                 repeat_rows.push(row);
             }
-        });
+        }
     }
     // The document's fonts include those of the type in opacity masks and in the art of its
     // symbols and patterns, as Find Font lists them.
@@ -1455,6 +1493,115 @@ mod tests {
         assert_eq!(spots(&mut s), (vec![], None, None));
     }
 
+    /// 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
+    /// color. Objects still counts them.
+    #[test]
+    fn info_skips_paints_on_hidden_and_clear_objects_and_their_members() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+        s.execute("swatch.new", &json!({"name": "Ink", "color": {"model": "cmyk", "c": 0, "m": 1, "y": 1, "k": 0}, "spot": true})).unwrap();
+        let square = |s: &mut Session, x: f64| {
+            s.execute("shape.rectangle", &json!({"x": x, "y": 0, "width": 10, "height": 10})).unwrap()["id"].as_u64().unwrap()
+        };
+        let tile = square(&mut s, 0.0);
+        s.execute("object.pattern.make", &json!({"ids": [tile], "name": "Dots", "edit": false})).unwrap();
+        // A patterned square that stays drawn, an object at an opacity of 0 and a hidden one.
+        let (shown, clear, hidden) = (square(&mut s, 20.0), square(&mut s, 40.0), square(&mut s, 60.0));
+        s.execute("paint.setFill", &json!({"ids": [shown, clear], "swatch": "Dots"})).unwrap();
+        s.execute("paint.setFill", &json!({"ids": [hidden], "swatch": "Ink"})).unwrap();
+        s.execute("paint.setStroke", &json!({"ids": [shown, clear, hidden], "none": true})).unwrap();
+        // A brushed square in a group.
+        let (brushed, other) = (square(&mut s, 80.0), square(&mut s, 100.0));
+        s.execute("brush.apply", &json!({"ids": [brushed], "name": "Charcoal"})).unwrap();
+        s.execute("select.set", &json!({"ids": [brushed, other]})).unwrap();
+        let group = s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap();
+        // Type whose characters are filled with the spot color.
+        let word = s.execute("text.create", &json!({"x": 0, "y": 200, "text": "Hi"})).unwrap()["id"].as_u64().unwrap();
+        s.execute("paint.setFill", &json!({"ids": [word], "swatch": "Ink"})).unwrap();
+        s.execute("paint.setStroke", &json!({"ids": [word], "none": true})).unwrap();
+        // A grayscale image colorized with the spot color.
+        let mut bytes = Vec::new();
+        image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(2, 1, vec![0, 255]).unwrap())
+            .write_to(&mut std::io::Cursor::new(&mut bytes), image::ImageFormat::Png)
+            .unwrap();
+        let image = s
+            .edit("Place", |d, sel| {
+                d.images.insert("gray".into(), vectorcraft_doc::ImageBlob::png(bytes));
+                let id = d.alloc_id();
+                let im = vectorcraft_doc::ImageObject {
+                    key: "gray".into(),
+                    width: 2,
+                    height: 1,
+                    xf: Default::default(),
+                    link: None,
+                    placement: Default::default(),
+                    pixels: None,
+                };
+                d.insert(d.default_layer(), 0, Node::new(id, NodeKind::Image(Box::new(im))))?;
+                sel.set([id]);
+                Ok(id)
+            })
+            .unwrap();
+        s.execute("paint.setFill", &json!({"swatch": "Ink"})).unwrap();
+        // A square with a gradient on a layer of its own.
+        let layer = s.execute("layer.new", &json!({"name": "Back"})).unwrap()["id"].as_u64().unwrap();
+        let ramp = square(&mut s, 120.0);
+        s.execute(
+            "paint.setFill",
+            &json!({"ids": [ramp], "gradient": {"kind": "linear", "stops": [{"offset": 0, "color": "#000"}, {"offset": 1, "color": "#fff"}]}}),
+        )
+        .unwrap();
+        s.execute("paint.setStroke", &json!({"ids": [ramp], "none": true})).unwrap();
+        let listed = |s: &mut Session, p: Value| {
+            let i = s.execute("document.info", &p).unwrap();
+            let ids = |k: &str| -> Vec<u64> {
+                let mut ids: Vec<u64> = i[k].as_array().unwrap().iter().map(|o| o["id"].as_u64().unwrap()).collect();
+                ids.sort_unstable();
+                ids
+            };
+            (i["brushNames"].clone(), ids("spotObjects"), ids("patternObjects"), ids("gradientObjects"), i["objects"].clone())
+        };
+        // Everything drawn: each object is listed.
+        let (brushes, spots, patterns, gradients, before) = listed(&mut s, json!({}));
+        assert_eq!(brushes, json!(["Charcoal"]));
+        // New squares take the new spot color as their fill, the group's members included.
+        assert_eq!((spots, patterns, gradients), (vec![hidden, brushed, other, word, image.0], vec![shown, clear], vec![ramp]));
+        s.edit("hide", |d, _| {
+            d.node_mut(NodeId(clear)).unwrap().opacity = 0.0;
+            d.node_mut(NodeId(hidden)).unwrap().visible = false;
+            d.node_mut(NodeId(group)).unwrap().opacity = 0.0;
+            d.node_mut(NodeId(word)).unwrap().opacity = 0.0;
+            d.node_mut(image).unwrap().opacity = 0.0;
+            d.node_mut(NodeId(layer)).unwrap().visible = false;
+            Ok(())
+        })
+        .unwrap();
+        let (brushes, spots, patterns, gradients, after) = listed(&mut s, json!({}));
+        assert_eq!((brushes, spots, patterns, gradients), (json!([]), vec![], vec![shown], vec![]));
+        // Objects counts the listed objects, and every object as before.
+        assert_eq!((after["spots"].clone(), after["patterns"].clone(), after["gradients"].clone()), (Value::Null, json!(1), Value::Null));
+        for k in ["paths", "groups", "textObjects", "images"] {
+            assert_eq!(after[k], before[k], "{k}: {after}");
+        }
+        let rows = s.execute("document.info", &json!({"category": "brushes"})).unwrap()["sections"][0]["rows"].clone();
+        assert_eq!(rows, json!([]));
+        // Selection Only: an object selected inside a group at an opacity of 0 or a hidden layer paints nothing either.
+        s.execute("select.set", &json!({"ids": [brushed, ramp]})).unwrap();
+        let (brushes, _, _, gradients, after) = listed(&mut s, json!({"selectionOnly": true}));
+        assert_eq!((brushes, gradients, after["paths"].clone()), (json!([]), vec![], json!(2)));
+        // Drawn again, the group's brush and the layer's gradient are listed.
+        s.edit("show", |d, _| {
+            d.node_mut(NodeId(group)).unwrap().opacity = 1.0;
+            d.node_mut(NodeId(layer)).unwrap().visible = true;
+            Ok(())
+        })
+        .unwrap();
+        let (brushes, _, _, gradients, _) = listed(&mut s, json!({"selectionOnly": true}));
+        assert_eq!((brushes, gradients), (json!(["Charcoal"]), vec![ramp]));
+    }
+
     /// Document Info › Objects counts an object with a gradient or a pattern on both its fill and
     /// its stroke once, and with Selection Only a selection that holds a group and an object inside
     /// it counts that object once.
diff --git a/crates/engine/src/cmd/interactivity.rs b/crates/engine/src/cmd/interactivity.rs
index 4bcc123dcf..359c2d00d6 100644
--- a/crates/engine/src/cmd/interactivity.rs
+++ b/crates/engine/src/cmd/interactivity.rs
@@ -3,10 +3,14 @@
 //! document links (`svgInteractivity.addFile`, `removeFile`). SVG export writes the events as
 //! event attributes (`onclick="…"`) and the files as `<script xlink:href>` elements; SVG import
 //! reads both back as text. The panel reads everything with `svgInteractivity.info`.
+//!
+//! While read roots are in force, a reply names a linked file outside them by its file name alone
+//! ([`links::shown_script`]), and `removeFile` also takes that name for it.
 
 use serde_json::{Value, json};
-use vectorcraft_doc::{Document, MAX_SVG_SCRIPTS, NodeId, SVG_EVENTS};
+use vectorcraft_doc::{Document, LinkInfo, MAX_SVG_SCRIPTS, NodeId, SVG_EVENTS};
 
+use super::links::{self, LinkBase};
 use super::overprint::edit_counted;
 use super::{CommandSpec, Result, Session, bad, cmd, has_doc, str_param, targets};
 
@@ -17,7 +21,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "SVG Interactivity",
             [],
             None,
-            "{ids?|id?} → {ids, events: [{event, script}…] in the panel's order | null (the objects' events differ), files: [the linked JavaScript files…], eventNames: [the events the panel lists…]} the SVG Interactivity panel's values for ids or the selection",
+            "{ids?|id?} → {ids, events: [{event, script}…] in the panel's order | null (the objects' events differ), files: [the linked JavaScript files…; with automation read roots in force, a file outside them by its file name alone, a URL as it is], eventNames: [the events the panel lists…]} the SVG Interactivity panel's values for ids or the selection",
             has_doc,
             info
         ),
@@ -53,7 +57,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Add JavaScript File",
             [],
             None,
-            "{file: path or URL (written as given, without surrounding spaces)} link a JavaScript file to the document, after the others: SVG export writes a <script xlink:href> for each linked file. A file already linked stays where it is; a document links at most 64 files → {files}",
+            "{file: path or URL (written as given, without surrounding spaces)} link a JavaScript file to the document, after the others: SVG export writes a <script xlink:href> for each linked file. A file already linked (the same text) stays where it is; a document links at most 64 files → {files} (as svgInteractivity.info gives them)",
             has_doc,
             add_file
         ),
@@ -62,7 +66,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Remove JavaScript File",
             [],
             None,
-            "{file} unlink a JavaScript file from the document → {files}",
+            "{file} unlink a JavaScript file from the document: the file linked as `file` or, with automation read roots in force, a file outside them whose file name is `file`; an error, unlinking nothing, when `file` fits more than one → {files} (as svgInteractivity.info gives them)",
             has_doc,
             remove_file
         ),
@@ -111,7 +115,8 @@ fn edit_events(s: &mut Session, p: &Value, cmd: &str, label: &str, f: impl Fn(&m
 
 fn info(s: &mut Session, p: &Value) -> Result<Value> {
     let ids = targets(s, p)?;
-    let d = &s.doc()?.doc;
+    let st = s.doc()?;
+    let d = &st.doc;
     let lists: Vec<Vec<(String, String)>> = ids.iter().map(|id| events_of(d, *id)).collect();
     let events = lists
         .first()
@@ -120,7 +125,7 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({
         "ids": ids.iter().map(|id| id.0).collect::<Vec<_>>(),
         "events": events,
-        "files": d.svg_scripts,
+        "files": shown_files(st),
         "eventNames": SVG_EVENTS,
     }))
 }
@@ -157,8 +162,14 @@ fn file_param(p: &Value, cmd: &str) -> Result<String> {
     f.map(str::to_string).ok_or_else(|| bad(cmd, "give `file`, the JavaScript file's path or URL"))
 }
 
+/// The JavaScript files `st` links, in order, as a reply to the caller asking now may name them
+/// ([`links::shown_script`]).
+fn shown_files(st: &crate::DocState) -> Vec<String> {
+    st.doc.svg_scripts.iter().map(|f| links::shown_script(st, f).into_owned()).collect()
+}
+
 fn files(s: &Session) -> Result<Value> {
-    Ok(json!({ "files": s.doc()?.doc.svg_scripts }))
+    Ok(json!({ "files": shown_files(s.doc()?) }))
 }
 
 fn add_file(s: &mut Session, p: &Value) -> Result<Value> {
@@ -180,11 +191,21 @@ fn add_file(s: &mut Session, p: &Value) -> Result<Value> {
 fn remove_file(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "svgInteractivity.removeFile";
     let file = file_param(p, C)?;
-    if !s.doc()?.doc.svg_scripts.contains(&file) {
-        return Err(bad(C, format!("{file:?} isn't linked")));
-    }
+    let st = s.doc()?;
+    let linked = &st.doc.svg_scripts;
+    // A file a reply names by its file name alone is also unlinked by that name, unless the name
+    // also fits another linked file.
+    let doc_path = LinkBase::of(st).doc;
+    let named: Vec<&String> =
+        linked.iter().filter(|f| **f != file && LinkInfo::new(f.as_str()).name() == file && links::script_hidden(f, doc_path)).collect();
+    let stored = match (linked.contains(&file), named.as_slice()) {
+        (true, []) => file,
+        (false, [f]) => (*f).clone(),
+        (false, []) => return Err(bad(C, format!("{file:?} isn't linked"))),
+        _ => return Err(bad(C, format!("{file:?} names more than one linked JavaScript file"))),
+    };
     s.edit("Remove JavaScript File", |d, _| {
-        d.svg_scripts.retain(|f| *f != file);
+        d.svg_scripts.retain(|f| *f != stored);
         Ok(())
     })?;
     files(s)
diff --git a/crates/engine/src/cmd/links.rs b/crates/engine/src/cmd/links.rs
index d9c2ccf3ad..3e1bc8b2ef 100644
--- a/crates/engine/src/cmd/links.rs
+++ b/crates/engine/src/cmd/links.rs
@@ -1173,6 +1173,19 @@ pub(crate) fn path_shown(path: &str, doc_path: Option<&str>) -> bool {
     crate::file_access::current().is_none() || fileio::document_path(path, doc_path).is_ok_and(|p| crate::file_access::check_read(&p).is_ok())
 }
 
+/// Is the linked JavaScript file `f` (of the document saved at `doc_path`) named by its file name
+/// alone in a reply to the caller asking now? Only a path [`path_shown`] does not allow; a URL is
+/// always shown as it is.
+pub(crate) fn script_hidden(f: &str, doc_path: Option<&str>) -> bool {
+    !path_shown(f, doc_path) && !matches!(fileio::document_path(f, doc_path), Err(craft_docpath::Refused::Url))
+}
+
+/// The linked JavaScript file `f` of the open document `st` as a reply to the caller asking now
+/// may name it: as it is, or by its file name alone where [`script_hidden`] says so.
+pub fn shown_script<'a>(st: &crate::DocState, f: &'a str) -> Cow<'a, str> {
+    if script_hidden(f, LinkBase::of(st).doc) { Cow::Owned(LinkInfo::new(f).name().to_string()) } else { Cow::Borrowed(f) }
+}
+
 /// `row[key] = path` when [`path_shown`] says so; otherwise `row` has no `key`.
 pub(crate) fn note_path(row: &mut Value, key: &str, path: &str, doc_path: Option<&str>) {
     if path_shown(path, doc_path) {
@@ -1556,8 +1569,7 @@ pub(crate) fn with_hidden_paths_named<'a>(d: &'a Document, base: LinkBase) -> Co
             }
         }
     }
-    let script_hidden = |f: &str| !path_shown(f, doc_path) && !matches!(fileio::document_path(f, doc_path), Err(craft_docpath::Refused::Url));
-    for f in d.svg_scripts.iter_mut().filter(|f| script_hidden(f)) {
+    for f in d.svg_scripts.iter_mut().filter(|f| script_hidden(f, doc_path)) {
         *f = LinkInfo::new(f.as_str()).name().to_string();
     }
     Cow::Owned(d)
diff --git a/crates/engine/src/cmd/plugin_call/reviewed.rs b/crates/engine/src/cmd/plugin_call/reviewed.rs
index 21d9d65c3d..ec1a95d373 100644
--- a/crates/engine/src/cmd/plugin_call/reviewed.rs
+++ b/crates/engine/src/cmd/plugin_call/reviewed.rs
@@ -158,6 +158,7 @@ pub(super) const ALLOWED: &[&str] = &[
     "edit.colors.saturate",
     "edit.colors.toCMYK",
     "edit.colors.toGrayscale",
+    "edit.colors.toIndexed",
     "edit.colors.toRGB",
     "edit.duplicate",
     "edit.findNext",
diff --git a/crates/engine/src/doc_state.rs b/crates/engine/src/doc_state.rs
index 0ef7555e02..10d21266ba 100644
--- a/crates/engine/src/doc_state.rs
+++ b/crates/engine/src/doc_state.rs
@@ -55,6 +55,11 @@ pub struct DocState {
     pub recalled_selection: RecalledSelection,
     /// Process-unique id of this open document (tab indices shift when tabs close).
     pub uid: u64,
+    /// How many times File → Revert replaced the document's content in its tab
+    /// ([`Session::replace_document`]). Work started for the document (a file read for Place, a
+    /// pasted bitmap) is dropped when this has changed by the time it finishes; edits do not
+    /// change it, and a batch that fails puts it back with the document.
+    pub reverts: u64,
     /// Preferences › User Interface › Open Documents As Tabs when the document opened: cleared,
     /// the UI opens it in a floating window of its own.
     pub opened_as_tab: bool,
@@ -313,6 +318,7 @@ impl DocState {
             last_selection_cmd: None,
             recalled_selection: RecalledSelection::default(),
             uid: NEXT_DOC_UID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
+            reverts: 0,
             opened_as_tab: true,
             mask_view: None,
             spelling_ignored: Default::default(),
diff --git a/crates/engine/src/session/documents.rs b/crates/engine/src/session/documents.rs
index 297322fda0..da26dbfc71 100644
--- a/crates/engine/src/session/documents.rs
+++ b/crates/engine/src/session/documents.rs
@@ -370,6 +370,8 @@ impl Session {
         st.history.limit = old.history.limit;
         // Same open document (caches keyed by uid stay valid); a new revision redraws it.
         st.uid = old.uid;
+        // Work started for the content being thrown away is dropped when it finishes.
+        st.reverts = old.reverts + 1;
         st.opened_as_tab = old.opened_as_tab;
         st.revision = old.revision + 1;
         st.format = old.format;
diff --git a/crates/engine/src/tests/editcolors.rs b/crates/engine/src/tests/editcolors.rs
index a3dcea263a..e3aa59368a 100644
--- a/crates/engine/src/tests/editcolors.rs
+++ b/crates/engine/src/tests/editcolors.rs
@@ -484,6 +484,250 @@ fn adjust_colors_converting_to_gray_stores_an_image_as_grayscale() {
     assert!(source(false).is_none(), "the colors keep their model");
 }
 
+/// Convert to Indexed Color stores an image as a palette PNG in one undo step; an image with few
+/// enough colors keeps them, and converting it again changes nothing and adds no undo step.
+#[test]
+fn convert_to_indexed_stores_an_image_as_a_palette_png() {
+    let mut s = session();
+    let id = image_node(&mut s);
+    let undo = s.doc().unwrap().history.undo.len();
+    let r = s.execute("edit.colors.toIndexed", &json!({})).unwrap();
+    assert_eq!(r["changed"], 1, "{r}");
+    let key = image_key(&s, id);
+    assert!(s.doc().unwrap().doc.images[&key].indexed_png(), "an indexed PNG");
+    assert_eq!(pixels(&s, id), [[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255], [255, 255, 255, 255]], "half opaque becomes opaque");
+    assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
+    let again = s.execute("edit.colors.toIndexed", &json!({})).unwrap();
+    assert_eq!(again["changed"], 0, "{again}");
+    assert_eq!(image_key(&s, id), key);
+    assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1, "no undo step when nothing changes");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(pixels(&s, id)[3], [255, 255, 255, 128], "one undo step restores the image");
+}
+
+/// Pixels under half opacity become transparent; an indexed image converted to a palette it
+/// already shows is left as it is, and one converted to a smaller palette changes.
+#[test]
+fn convert_to_indexed_keeps_transparency_and_reduces_an_indexed_image() {
+    let mut s = session();
+    let id = image_of(&mut s, [[200, 30, 90, 255], [20, 40, 220, 255], [0, 0, 0, 100], [250, 250, 250, 255]]);
+    s.execute("edit.colors.toIndexed", &json!({"dither": "none"})).unwrap();
+    assert_eq!(pixels(&s, id)[2][3], 0, "under half opacity: transparent");
+    let r = s.execute("edit.colors.toIndexed", &json!({"reduction": "blackWhite", "dither": "none"})).unwrap();
+    assert_eq!(r["changed"], 1, "{r}");
+    let px = pixels(&s, id);
+    assert_eq!([px[0], px[1], px[3]], [[0, 0, 0, 255], [0, 0, 0, 255], [255, 255, 255, 255]]);
+    assert_eq!(px[2][3], 0);
+}
+
+/// The uniform reduction takes evenly spaced levels of each channel, and the document reduction
+/// the colors of the document's swatches.
+#[test]
+fn convert_to_indexed_uses_a_uniform_or_the_document_palette() {
+    let mut s = session();
+    let id = image_of(&mut s, [[200, 30, 90, 255], [20, 40, 220, 255], [120, 130, 140, 255], [250, 250, 250, 255]]);
+    s.execute("edit.colors.toIndexed", &json!({"reduction": "uniform", "colors": 9, "dither": "none"})).unwrap();
+    assert_eq!(pixels(&s, id), [[255, 0, 0, 255], [0, 0, 255, 255], [0, 255, 255, 255], [255, 255, 255, 255]]);
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("edit.colors.toIndexed", &json!({"reduction": "document"})).unwrap();
+    let swatches: Vec<[u8; 3]> = crate::cmd::swatchlib::library_colors(&s, "document")
+        .unwrap()
+        .iter()
+        .map(|c| {
+            let [r, g, b, _] = c.to_rgba8(1.0);
+            [r, g, b]
+        })
+        .collect();
+    for p in pixels(&s, id) {
+        assert!(swatches.contains(&[p[0], p[1], p[2]]), "{p:?} is a swatch color");
+    }
+}
+
+/// The start of a PNG of `w` × `h` RGBA pixels: its header and a first image data chunk, without
+/// the rest of the pixels.
+fn png_header(w: u32, h: u32) -> Vec<u8> {
+    let crc = |data: &[u8]| {
+        let mut c = !0u32;
+        for &b in data {
+            c ^= u32::from(b);
+            for _ in 0..8 {
+                c = if c & 1 == 1 { 0xEDB8_8320 ^ (c >> 1) } else { c >> 1 };
+            }
+        }
+        !c
+    };
+    let chunk = |ty: &[u8; 4], data: &[u8]| {
+        let body = [ty.as_slice(), data].concat();
+        [(data.len() as u32).to_be_bytes().as_slice(), &body, &crc(&body).to_be_bytes()].concat()
+    };
+    let ihdr = [w.to_be_bytes().as_slice(), &h.to_be_bytes(), &[8, 6, 0, 0, 0]].concat();
+    [b"\x89PNG\r\n\x1a\n".as_slice(), &chunk(b"IHDR", &ihdr), &chunk(b"IDAT", &[0x78, 0x9c, 0x03, 0x00])].concat()
+}
+
+/// An image larger than Convert to Indexed Color converts is refused by its size, read from the
+/// file's header, before any pixel is decoded; nothing changes.
+#[test]
+fn convert_to_indexed_refuses_an_image_too_large_to_convert() {
+    let mut s = session();
+    let id = image_node(&mut s);
+    assert_eq!(vectorcraft_doc::ImageBlob::png(png_header(30_000, 30_000)).pixel_size(), Some((30_000, 30_000)));
+    s.edit("Swap", |d, _| {
+        d.images.insert("pic".into(), vectorcraft_doc::ImageBlob::png(png_header(30_000, 30_000)));
+        Ok(())
+    })
+    .unwrap();
+    let undo = s.doc().unwrap().history.undo.len();
+    let e = s.execute("edit.colors.toIndexed", &json!({})).unwrap_err().to_string();
+    assert!(e.contains("an image of 30000 × 30000 pixels is too large to convert"), "{e}");
+    assert_eq!(image_key(&s, id), "pic");
+    assert_eq!(s.doc().unwrap().history.undo.len(), undo);
+}
+
+/// Convert to Indexed Color refuses parameters it can't use, and leaves the image as it is.
+#[test]
+fn convert_to_indexed_refuses_bad_params() {
+    let mut s = session();
+    let id = image_node(&mut s);
+    for (p, msg) in [
+        (json!({"colors": 1}), "`colors` must be a whole number from 2 to 256"),
+        (json!({"colors": 257}), "`colors` must be a whole number from 2 to 256"),
+        (json!({"colors": "8"}), "`colors` must be a whole number from 2 to 256"),
+        (json!({"colors": 16.5}), "`colors` must be a whole number from 2 to 256"),
+        (json!({"reduction": "uniform", "colors": 8}), "`colors` must be at least 9 for the uniform reduction"),
+        (json!({"reduction": "document", "colors": 16}), "`colors` does not apply to the document reduction"),
+        (json!({"reduction": "blackWhite", "colors": 2}), "`colors` does not apply to the blackWhite reduction"),
+        (json!({"reduction": "posterize"}), "unknown reduction `posterize`"),
+        (json!({"dither": "random"}), "unknown dither `random`"),
+        (json!({"ditherAmount": 101}), "`ditherAmount` must be a number from 0 to 100"),
+        (json!({"ditherAmount": "50"}), "`ditherAmount` must be a number from 0 to 100"),
+    ] {
+        let e = s.execute("edit.colors.toIndexed", &p).unwrap_err().to_string();
+        assert!(e.contains(msg), "{p}: {e}");
+    }
+    assert_eq!(image_key(&s, id), "pic");
+}
+
+/// An embedded `w` × `h` image of the pixels `f(x, y)`, placed and selected.
+fn placed(s: &mut Session, w: u32, h: u32, f: impl Fn(u32, u32) -> [u8; 4]) -> NodeId {
+    let mut png = Vec::new();
+    image::RgbaImage::from_fn(w, h, |x, y| image::Rgba(f(x, y))).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+    let r = s.execute("file.place", &json!({"name": "art.png", "dataBase64": vectorcraft_format::base64_encode(&png)})).unwrap();
+    NodeId(r["ids"][0].as_u64().unwrap())
+}
+
+/// `ids` picks the images to convert; a linked image and a colorized image keep their pixels.
+#[test]
+fn convert_to_indexed_takes_ids_and_leaves_linked_and_colorized_images() {
+    let mut s = session();
+    let a = placed(&mut s, 2, 1, |x, _| [200, 30 + x as u8, 90, 255]);
+    let b = placed(&mut s, 2, 1, |x, _| [20, 40, 200 + x as u8, 255]);
+    let (ka, kb) = (image_key(&s, a), image_key(&s, b));
+    s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
+    let r = s.execute("edit.colors.toIndexed", &json!({"ids": [b.0]})).unwrap();
+    assert_eq!(r["changed"], 1, "{r}");
+    assert_eq!(image_key(&s, a), ka, "not in `ids`");
+    assert_ne!(image_key(&s, b), kb);
+    s.edit("Link", |d, _| {
+        let NodeKind::Image(im) = &mut d.node_mut(a).unwrap().kind else { panic!("not an image") };
+        im.link = Some(vectorcraft_doc::LinkInfo::new("art.png"));
+        Ok(())
+    })
+    .unwrap();
+    let undo = s.doc().unwrap().history.undo.len();
+    let r = s.execute("edit.colors.toIndexed", &json!({"ids": [a.0]})).unwrap();
+    assert_eq!(r["changed"], 0, "a linked image: {r}");
+    assert_eq!(image_key(&s, a), ka);
+    assert_eq!(s.doc().unwrap().history.undo.len(), undo, "no undo step");
+    let mut png = Vec::new();
+    image::GrayImage::from_pixel(4, 4, image::Luma([90])).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+    let r = s.execute("file.place", &json!({"name": "gray.png", "dataBase64": vectorcraft_format::base64_encode(&png)})).unwrap();
+    let gray = NodeId(r["ids"][0].as_u64().unwrap());
+    s.execute("paint.setFill", &json!({"ids": [gray.0], "color": "#ff0000"})).unwrap();
+    assert!(s.doc().unwrap().doc.node(gray).unwrap().extras().colorize.is_some(), "the fill colorizes the image");
+    let kg = image_key(&s, gray);
+    let r = s.execute("edit.colors.toIndexed", &json!({"ids": [gray.0]})).unwrap();
+    assert_eq!(r["changed"], 0, "a colorized image: {r}");
+    assert_eq!(image_key(&s, gray), kg);
+}
+
+/// With the selection Select All makes, locked and hidden images are left out and counted in
+/// `notChanged`; a left-out image too large to convert is counted without an error.
+#[test]
+fn convert_to_indexed_counts_left_out_images() {
+    let mut s = session();
+    let a = placed(&mut s, 2, 1, |x, _| [200, 30 + x as u8, 90, 255]);
+    let locked = placed(&mut s, 2, 1, |x, _| [20, 40, 200 + x as u8, 255]);
+    let hidden = placed(&mut s, 2, 1, |x, _| [120, 140 + x as u8, 20, 255]);
+    s.edit("Huge", |d, _| {
+        let NodeKind::Image(im) = &mut d.node_mut(locked).unwrap().kind else { panic!("not an image") };
+        im.key = "huge".into();
+        d.images.insert("huge".into(), vectorcraft_doc::ImageBlob::png(png_header(30_000, 30_000)));
+        Ok(())
+    })
+    .unwrap();
+    s.execute("object.lock", &json!({"ids": [locked.0]})).unwrap();
+    s.execute("object.hide", &json!({"ids": [hidden.0]})).unwrap();
+    s.execute("select.all", &json!({})).unwrap();
+    let kh = image_key(&s, hidden);
+    let r = s.execute("edit.colors.toIndexed", &json!({})).unwrap();
+    assert_eq!(r["changed"], 1, "{r}");
+    assert_eq!(r["notChanged"], json!({"locked": 1, "hidden": 1}), "{r}");
+    assert!(r["warning"].is_string(), "{r}");
+    assert!(s.doc().unwrap().doc.images[&image_key(&s, a)].indexed_png());
+    assert_eq!((image_key(&s, locked), image_key(&s, hidden)), ("huge".to_string(), kh));
+}
+
+/// The uniform reduction takes the most levels a channel whose cube leaves one entry for
+/// transparency (3 for 64 colors, 6 for 256), and the document reduction takes 1 to 255 swatch
+/// colors.
+#[test]
+fn convert_to_indexed_sizes_the_uniform_and_document_palettes() {
+    let mut s = session();
+    let id = image_of(&mut s, [[200, 30, 90, 255], [20, 40, 220, 255], [120, 130, 140, 255], [250, 250, 250, 255]]);
+    s.execute("edit.colors.toIndexed", &json!({"reduction": "uniform", "colors": 64, "dither": "none"})).unwrap();
+    assert_eq!(pixels(&s, id), [[255, 0, 127, 255], [0, 0, 255, 255], [127, 127, 127, 255], [255, 255, 255, 255]]);
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("edit.colors.toIndexed", &json!({"reduction": "uniform", "dither": "none"})).unwrap();
+    assert_eq!(pixels(&s, id), [[204, 51, 102, 255], [0, 51, 204, 255], [102, 153, 153, 255], [255, 255, 255, 255]]);
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.edit("No swatches", |d, _| {
+        d.swatches.clear();
+        d.swatch_groups.clear();
+        Ok(())
+    })
+    .unwrap();
+    let e = s.execute("edit.colors.toIndexed", &json!({"reduction": "document"})).unwrap_err().to_string();
+    assert!(e.contains("the document has no color swatches"), "{e}");
+    s.edit("Many swatches", |d, _| {
+        for i in 0..256u32 {
+            let paint = Paint::solid(Color::rgb8(i as u8, 7, 9));
+            d.swatches.push(vectorcraft_color::swatch::Swatch { name: format!("c{i}"), paint, global: false, spot: false });
+        }
+        Ok(())
+    })
+    .unwrap();
+    let e = s.execute("edit.colors.toIndexed", &json!({"reduction": "document"})).unwrap_err().to_string();
+    assert!(e.contains("the document's swatches hold 256 colors; the document reduction takes at most 255"), "{e}");
+    assert_eq!(image_key(&s, id), "pic");
+}
+
+/// `dither` and `ditherAmount` reach the quantizer: a gray ramp reduced to black and white is
+/// dithered by each method, and at an amount of 0 it comes out as with no dither.
+#[test]
+fn convert_to_indexed_dithers_by_the_amount_given() {
+    let ramp = |p: Value| {
+        let mut s = session();
+        let id = placed(&mut s, 16, 4, |x, _| [(x * 17) as u8, (x * 17) as u8, (x * 17) as u8, 255]);
+        s.execute("edit.colors.toIndexed", &p).unwrap();
+        pixels(&s, id)
+    };
+    let none = ramp(json!({"reduction": "blackWhite", "dither": "none"}));
+    for d in ["diffusion", "pattern", "noise"] {
+        assert_eq!(ramp(json!({"reduction": "blackWhite", "dither": d, "ditherAmount": 0})), none, "{d} at 0");
+        assert_ne!(ramp(json!({"reduction": "blackWhite", "dither": d})), none, "{d} at 100");
+    }
+}
+
 /// A PDF of a CMYK document writes an image Convert to Grayscale made with one channel (#5632).
 #[test]
 fn a_converted_image_is_written_to_pdf_as_gray_in_a_cmyk_document() {
diff --git a/crates/engine/src/tests/ids_without_selection.rs b/crates/engine/src/tests/ids_without_selection.rs
index 24a1635c30..b274e7956f 100644
--- a/crates/engine/src/tests/ids_without_selection.rs
+++ b/crates/engine/src/tests/ids_without_selection.rs
@@ -368,6 +368,7 @@ fn ids_cases(d: u64) -> Vec<(&'static str, &'static str, serde_json::Value, Unse
         ("edit.colors.invert", "ids", json!({}), Selected),
         ("edit.colors.toCMYK", "ids", json!({}), Selected),
         ("edit.colors.toGrayscale", "ids", json!({}), Selected),
+        ("edit.colors.toIndexed", "ids", json!({}), Selected),
         ("edit.colors.toRGB", "ids", json!({}), Selected),
         ("edit.colors.saturate", "ids", json!({"intensity": 50}), Selected),
         ("edit.colors.adjustBalance", "ids", json!({"r": 20}), Selected),
diff --git a/crates/engine/src/tests/interactivity.rs b/crates/engine/src/tests/interactivity.rs
index 36a2855dfb..6f3878f9c9 100644
--- a/crates/engine/src/tests/interactivity.rs
+++ b/crates/engine/src/tests/interactivity.rs
@@ -3,6 +3,7 @@
 
 use serde_json::{Value, json};
 
+use crate::tests_links::{Folder, save, write};
 use crate::*;
 
 fn session() -> Session {
@@ -110,6 +111,124 @@ fn javascript_files_are_linked_once_and_unlinked() {
     assert_eq!(files(&mut s), json!(["menu.js", "https://example.com/a.js"]));
 }
 
+/// `cmd` with `p` for a caller whose read roots are `read` and whose write roots are `write`.
+fn confined(s: &mut Session, read: &[&Folder], write: &[&Folder], cmd: &str, p: Value) -> std::result::Result<Value, String> {
+    let read: Vec<&std::path::Path> = read.iter().map(|f| f.0.as_path()).collect();
+    let write: Vec<&std::path::Path> = write.iter().map(|f| f.0.as_path()).collect();
+    let roots = crate::file_access::AutomationRoots::new(&read, &write).unwrap();
+    crate::file_access::confine(roots.as_ref(), || s.execute(cmd, &p)).map_err(|e| e.to_string())
+}
+
+/// `info`, `addFile` and `removeFile` for a caller with read roots name a linked file outside them
+/// by its file name, a relative one taken from the document's folder; a file inside them and a URL
+/// are named as they are, and the document keeps every path.
+#[test]
+fn javascript_file_replies_hide_paths_outside_read_roots() {
+    let (away, home) = (Folder::new("js-replies-away"), Folder::new("js-replies-home"));
+    let (outside, inside) = (away.file("menu.js"), home.file("in.js"));
+    for f in [&outside, &inside, &away.file("lib/rel.js")] {
+        write(f, b"void 0;");
+    }
+    let url = "https://example.com/a.js";
+    let mut s = session();
+    for f in [outside.as_str(), inside.as_str(), url, "lib/rel.js"] {
+        run(&mut s, "svgInteractivity.addFile", json!({ "file": f }));
+    }
+    save(&mut s, &away.file("poster.vectorcraft"));
+    let stored = s.doc().unwrap().doc.svg_scripts.clone();
+    let shown = json!(["menu.js", inside, url, "rel.js"]);
+    let info = confined(&mut s, &[&home], &[], "svgInteractivity.info", json!({})).unwrap();
+    assert_eq!(info["files"], shown, "{info}");
+    let added = confined(&mut s, &[&home], &[], "svgInteractivity.addFile", json!({"file": "https://example.com/b.js"})).unwrap();
+    assert_eq!(added["files"], json!(["menu.js", inside, url, "rel.js", "https://example.com/b.js"]), "{added}");
+    let removed = confined(&mut s, &[&home], &[], "svgInteractivity.removeFile", json!({"file": "https://example.com/b.js"})).unwrap();
+    assert_eq!(removed["files"], shown, "{removed}");
+    assert!(!format!("{info}{added}{removed}").contains("js-replies-away"));
+    // A caller with only write roots reads none of the paths.
+    let info = confined(&mut s, &[], &[&home], "svgInteractivity.info", json!({})).unwrap();
+    assert_eq!(info["files"], json!(["menu.js", "in.js", url, "rel.js"]), "{info}");
+    // A caller whose read roots hold the files, and one without roots, sees every path.
+    assert_eq!(confined(&mut s, &[&away, &home], &[], "svgInteractivity.info", json!({})).unwrap()["files"], json!(stored));
+    assert_eq!(run(&mut s, "svgInteractivity.info", json!({}))["files"], json!(stored));
+    assert_eq!(s.doc().unwrap().doc.svg_scripts, stored, "the document keeps its paths");
+}
+
+/// A caller with read roots unlinks a file a reply names by its file name alone by that name, as
+/// one undo step; the name is not taken for a file it may read, nor without read roots.
+#[test]
+fn hidden_javascript_file_can_be_removed_by_unique_shown_name() {
+    let (away, home) = (Folder::new("js-remove-away"), Folder::new("js-remove-home"));
+    let (outside, inside) = (away.file("menu.js"), home.file("other.js"));
+    let mut s = session();
+    for f in [&outside, &inside] {
+        run(&mut s, "svgInteractivity.addFile", json!({ "file": f }));
+    }
+    assert!(s.execute("svgInteractivity.removeFile", &json!({"file": "menu.js"})).is_err(), "no name without read roots");
+    let e = confined(&mut s, &[&home], &[], "svgInteractivity.removeFile", json!({"file": "other.js"})).unwrap_err();
+    assert!(e.contains("\"other.js\" isn't linked"), "a file inside the roots is unlinked by its path: {e}");
+    let steps = s.doc().unwrap().history.undo.len();
+    let r = confined(&mut s, &[&home], &[], "svgInteractivity.removeFile", json!({"file": "menu.js"})).unwrap();
+    assert_eq!(r["files"], json!([inside]), "{r}");
+    assert_eq!(s.doc().unwrap().doc.svg_scripts, [inside.as_str()]);
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps + 1);
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(s.doc().unwrap().doc.svg_scripts, [outside.as_str(), inside.as_str()]);
+    // A caller that knows the whole path unlinks the file by it.
+    let r = confined(&mut s, &[&home], &[], "svgInteractivity.removeFile", json!({ "file": outside })).unwrap();
+    assert_eq!(r["files"], json!([inside]), "{r}");
+}
+
+/// Two linked files outside the read roots with the same file name: that name unlinks neither,
+/// and the error names no path.
+#[test]
+fn ambiguous_hidden_javascript_file_name_is_refused_without_edit() {
+    let (away, home) = (Folder::new("js-ambiguous-away"), Folder::new("js-ambiguous-home"));
+    let (a, b) = (away.file("a/menu.js"), away.file("b/menu.js"));
+    let mut s = session();
+    for f in [&a, &b] {
+        run(&mut s, "svgInteractivity.addFile", json!({ "file": f }));
+    }
+    let steps = s.doc().unwrap().history.undo.len();
+    let e = confined(&mut s, &[&home], &[], "svgInteractivity.removeFile", json!({"file": "menu.js"})).unwrap_err();
+    assert!(e.contains("\"menu.js\" names more than one linked JavaScript file") && !e.contains("js-ambiguous-away"), "{e}");
+    assert_eq!(s.doc().unwrap().doc.svg_scripts, [a.as_str(), b.as_str()]);
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps, "no undo step");
+    let e = confined(&mut s, &[&home], &[], "svgInteractivity.removeFile", json!({"file": "nav.js"})).unwrap_err();
+    assert!(e.contains("\"nav.js\" isn't linked") && !e.contains("js-ambiguous-away"), "{e}");
+    // A file linked as the name itself, beside one outside the roots shown by that name: neither.
+    run(&mut s, "svgInteractivity.removeFile", json!({ "file": b }));
+    run(&mut s, "svgInteractivity.addFile", json!({"file": "menu.js"}));
+    let e = confined(&mut s, &[&home], &[], "svgInteractivity.removeFile", json!({"file": "menu.js"})).unwrap_err();
+    assert!(e.contains("names more than one"), "{e}");
+    assert_eq!(s.doc().unwrap().doc.svg_scripts, [a.as_str(), "menu.js"]);
+    // Without read roots the name is the file linked as it.
+    run(&mut s, "svgInteractivity.removeFile", json!({"file": "menu.js"}));
+    assert_eq!(s.doc().unwrap().doc.svg_scripts, [a.as_str()]);
+}
+
+/// `addFile` takes a file the same text links as already linked: a file name that a reply shows for
+/// a different file is linked as one more file, within the 64-file limit.
+#[test]
+fn adding_a_shown_name_does_not_deduplicate_a_different_hidden_path() {
+    let (away, home) = (Folder::new("js-add-away"), Folder::new("js-add-home"));
+    let mut s = session();
+    let outside = away.file("0.js");
+    run(&mut s, "svgInteractivity.addFile", json!({ "file": outside }));
+    let r = confined(&mut s, &[&home], &[], "svgInteractivity.addFile", json!({"file": "0.js"})).unwrap();
+    assert_eq!(r["files"], json!(["0.js", "0.js"]), "{r}");
+    assert_eq!(s.doc().unwrap().doc.svg_scripts, [outside.as_str(), "0.js"]);
+    run(&mut s, "edit.undo", json!({}));
+    for i in 1..64 {
+        run(&mut s, "svgInteractivity.addFile", json!({ "file": away.file(&format!("{i}.js")) }));
+    }
+    let e = confined(&mut s, &[&home], &[], "svgInteractivity.addFile", json!({"file": "0.js"})).unwrap_err();
+    assert!(e.contains("at most 64"), "a 65th file is refused: {e}");
+    let steps = s.doc().unwrap().history.undo.len();
+    let r = confined(&mut s, &[&home], &[], "svgInteractivity.addFile", json!({ "file": outside })).unwrap();
+    assert_eq!(r["files"].as_array().map(Vec::len), Some(64), "the same path is already linked");
+    assert_eq!(s.doc().unwrap().history.undo.len(), steps);
+}
+
 #[test]
 fn a_document_links_at_most_64_javascript_files() {
     let mut s = session();
diff --git a/crates/mcp/src/ui_catalog.rs b/crates/mcp/src/ui_catalog.rs
index 8836b72ac2..dcde7c5076 100644
--- a/crates/mcp/src/ui_catalog.rs
+++ b/crates/mcp/src/ui_catalog.rs
@@ -945,6 +945,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "",
         "{} open Saturate for the selection (dialog `saturate`, fields `intensity` −100..100, `preview`): previews live, OK runs edit.colors.saturate as one undo step",
     ),
+    (
+        "ui.indexedColorDialog",
+        "Convert to Indexed Color…",
+        "",
+        "{} open Convert to Indexed Color for the selection (dialog `indexedColor`, fields `reduction`, `colors` 2..256, `dither`, `ditherAmount` 0..100, `preview`): previews live, OK runs edit.colors.toIndexed as one undo step",
+    ),
     (
         "window.swatchLibrary",
         "Swatch Library",
diff --git a/crates/render/src/encode/quantize.rs b/crates/render/src/encode/quantize.rs
index ec04c9f466..0c873fd598 100644
--- a/crates/render/src/encode/quantize.rs
+++ b/crates/render/src/encode/quantize.rs
@@ -154,18 +154,8 @@ pub fn quantize(rgba: &[u8], width: u32, height: u32, o: &PaletteOptions) -> Ind
 pub fn quantize_locked(rgba: &[u8], width: u32, height: u32, o: &PaletteOptions, locked: &[[u8; 3]]) -> Indexed {
     let px = rgba.as_chunks::<4>().0;
     let clear = |p: &[u8; 4]| o.transparency && p[3] < 128;
-    let gray = matches!(o.reduction, Reduction::Gray | Reduction::BlackWhite);
     let matte = o.matte.unwrap_or([255; 3]);
-    let blend = o.matte.is_some() || !o.transparency;
-    // The opaque colours: blended over the matte, greys for the grey reductions.
-    let colors: Vec<[u8; 3]> = px
-        .iter()
-        .map(|p| {
-            let a = if blend { p[3] as u32 } else { 255 };
-            let c = [0, 1, 2].map(|i| ((p[i] as u32 * a + matte[i] as u32 * (255 - a) + 127) / 255) as u8);
-            if gray { [luma(c); 3] } else { c }
-        })
-        .collect();
+    let colors = opaque_colors(px, o, matches!(o.reduction, Reduction::Gray | Reduction::BlackWhite));
     let has_clear = px.iter().any(clear);
     let k = (o.colors.clamp(2, 256) as usize - usize::from(has_clear)).max(1);
     let opaque = || colors.iter().zip(px).filter(|(_, p)| !clear(p)).map(|(c, _)| *c);
@@ -195,11 +185,46 @@ pub fn quantize_locked(rgba: &[u8], width: u32, height: u32, o: &PaletteOptions,
     if palette.is_empty() {
         palette.push(matte);
     }
+    finish(px, &colors, width, height, &palette, o, if exact { Dither::None } else { o.dither })
+}
+
+/// [`quantize`] to the fixed `palette`: each pixel takes its nearest entry, with `o`'s dither,
+/// transparency and matte; `o.reduction` sets only the distance weights, and `o.colors` is not
+/// used. Only the first 255 colors of `palette` are used, leaving room for the transparent entry.
+/// Entries no pixel uses are left out.
+pub fn quantize_to(rgba: &[u8], width: u32, height: u32, o: &PaletteOptions, palette: &[[u8; 3]]) -> Indexed {
+    let px = rgba.as_chunks::<4>().0;
+    let colors = opaque_colors(px, o, false);
+    let mut palette: Vec<[u8; 3]> = palette.iter().take(255).copied().collect();
+    if palette.is_empty() {
+        palette.push(o.matte.unwrap_or([255; 3]));
+    }
+    finish(px, &colors, width, height, &palette, o, o.dither)
+}
+
+/// The color of each pixel when opaque: blended over the matte, and gray when `gray`.
+fn opaque_colors(px: &[[u8; 4]], o: &PaletteOptions, gray: bool) -> Vec<[u8; 3]> {
+    let matte = o.matte.unwrap_or([255; 3]);
+    let blend = o.matte.is_some() || !o.transparency;
+    px.iter()
+        .map(|p| {
+            let a = if blend { p[3] as u32 } else { 255 };
+            let c = [0, 1, 2].map(|i| ((p[i] as u32 * a + matte[i] as u32 * (255 - a) + 127) / 255) as u8);
+            if gray { [luma(c); 3] } else { c }
+        })
+        .collect()
+}
+
+/// Map the pixels `px` (their opaque `colors`) to `palette` with `dither`, then drop the entries
+/// no pixel uses and put the transparent entry first when a pixel is transparent.
+fn finish(px: &[[u8; 4]], colors: &[[u8; 3]], width: u32, height: u32, palette: &[[u8; 3]], o: &PaletteOptions, dither: Dither) -> Indexed {
+    let clear = |p: &[u8; 4]| o.transparency && p[3] < 128;
+    let matte = o.matte.unwrap_or([255; 3]);
+    let has_clear = px.iter().any(clear);
     let weights = o.reduction.weights();
-    let dither = if exact { Dither::None } else { o.dither };
     // (A width past the pixels there are would size the error rows from a number nothing checked.)
     let mut indices =
-        map(&colors, (width as usize).min(colors.len()), &palette, weights, dither, f32::from(o.dither_amount.min(100)) / 100.0, |i| clear(&px[i]));
+        map(colors, (width as usize).min(colors.len()), palette, weights, dither, f32::from(o.dither_amount.min(100)) / 100.0, |i| clear(&px[i]));
     // Drop the entries no pixel uses (fixed palettes), keeping the order.
     let mut used = [false; 256];
     for (i, &ix) in indices.iter().enumerate() {
diff --git a/crates/render/src/encode/tests_palette.rs b/crates/render/src/encode/tests_palette.rs
index 53a139f3e1..f06217f397 100644
--- a/crates/render/src/encode/tests_palette.rs
+++ b/crates/render/src/encode/tests_palette.rs
@@ -3,7 +3,7 @@ use vectorcraft_doc::{Appearance, Node};
 use vectorcraft_geom::shapes;
 
 use super::png::{PngOptions, encode_indexed};
-use super::quantize::{Dither, Indexed, PaletteOptions, Reduction, quantize};
+use super::quantize::{Dither, Indexed, PaletteOptions, Reduction, quantize, quantize_to};
 use super::*;
 
 /// A `w`×`h` opaque image of `f(x, y)` colours.
@@ -93,6 +93,22 @@ fn fixed_palettes() {
     assert_eq!(bw.palette, [[0, 0, 0], [255, 255, 255]]);
 }
 
+#[test]
+fn a_given_palette_keeps_the_entries_pixels_use() {
+    let px: Vec<u8> = [[250, 10, 10, 255], [10, 10, 240, 255], [0, 0, 0, 40], [240, 20, 30, 255]].concat();
+    let given = [[0, 255, 0], [255, 0, 0], [0, 0, 255], [255, 255, 255]];
+    let o = PaletteOptions { dither: Dither::None, matte: None, ..Default::default() };
+    let ix = quantize_to(&px, 4, 1, &o, &given);
+    assert_eq!(ix.transparent, Some(0));
+    assert_eq!(ix.palette[1..], [[255, 0, 0], [0, 0, 255]], "unused entries left out, the order kept");
+    assert_eq!(ix.indices, [1, 2, 0, 1]);
+    // At most 255 of the given colors are used, leaving room for the transparent entry.
+    let many: Vec<[u8; 3]> = (0..300u32).map(|i| [(i % 256) as u8, (i / 256) as u8, 0]).collect();
+    let all = image(256, 2, |x, y| [x as u8, y as u8, 0]);
+    let ix = quantize_to(&all, 256, 2, &o, &many);
+    assert!(ix.palette.len() <= 255 && ix.palette.iter().all(|c| many[..255].contains(c)), "{}", ix.palette.len());
+}
+
 #[test]
 fn dithering_keeps_the_average_colour() {
     let px = image(64, 16, |x, _| [(x * 4) as u8; 3]);
diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs
index 4f3566b97d..fedd795d78 100644
--- a/crates/text/src/layout.rs
+++ b/crates/text/src/layout.rs
@@ -34,7 +34,7 @@ mod ruby;
 mod shaped;
 mod vertical;
 
-pub(crate) use bidi::{is_rtl, para_bidi};
+pub(crate) use bidi::{is_rtl, para_bidi, starts_bidi};
 use breaking::tab_advance;
 #[cfg(test)]
 use breaking::{break_line, candidates};
diff --git a/crates/text/src/layout/bidi.rs b/crates/text/src/layout/bidi.rs
index e4b6263244..3f9872983d 100644
--- a/crates/text/src/layout/bidi.rs
+++ b/crates/text/src/layout/bidi.rs
@@ -4,15 +4,21 @@ use super::{BidiInfo, Level, ParaDirection, Range, SGlyph};
 /// without one, from its first strong character. `None` for the usual paragraph with nothing right
 /// to left in it (no right-to-left character or direction), which skips the algorithm.
 pub(crate) fn para_bidi(text: &str, direction: Option<ParaDirection>) -> Option<BidiInfo<'_>> {
-    use unicode_bidi::BidiClass::{AL, AN, FSI, R, RLE, RLI, RLO};
     let rtl_set = direction == Some(ParaDirection::RightToLeft);
-    if !rtl_set && !text.chars().any(|c| matches!(unicode_bidi::bidi_class(c), R | AL | AN | RLE | RLO | RLI | FSI)) {
+    if !rtl_set && !text.chars().any(starts_bidi) {
         return None;
     }
     let level = direction.map(|d| if d == ParaDirection::RightToLeft { Level::rtl() } else { Level::ltr() });
     Some(BidiInfo::new(text, level))
 }
 
+/// Whether character `c` makes [`para_bidi`] resolve a paragraph that holds it: a right-to-left
+/// letter, an Arabic number, or a right-to-left embedding, override or isolate.
+pub(crate) fn starts_bidi(c: char) -> bool {
+    use unicode_bidi::BidiClass::{AL, AN, FSI, R, RLE, RLI, RLO};
+    matches!(unicode_bidi::bidi_class(c), R | AL | AN | RLE | RLO | RLI | FSI)
+}
+
 /// [`para_bidi`] for a paragraph whose characters in `set` (byte ranges of `text`, in order and not
 /// overlapping, from [`Ctx::char_directions`]) have a Character Direction: each range is resolved
 /// as a Unicode bidi embedding, as if an LRE or RLE stood before it and a PDF after it (UAX #9 X2,
diff --git a/crates/text/src/thread.rs b/crates/text/src/thread.rs
index b78527378d..ff22f3a5e8 100644
--- a/crates/text/src/thread.rs
+++ b/crates/text/src/thread.rs
@@ -262,22 +262,41 @@ impl<'a> Rest<'a> {
 }
 
 /// How many bytes of `rest` fit in `frame`, measured as `probe` makes the frame for some runs (with
-/// their paragraph styles, the list counts and the continuation mark).
+/// their paragraph styles, the list counts and the continuation mark). `no_rtl`: no paragraph of
+/// the rest resolves right to left on its own (no character [`crate::layout::starts_bidi`] holds
+/// and no right-to-left Character Direction).
 ///
-/// Area type without Shrink Text to Fit whose lines align to the top is first measured with the
-/// whole paragraphs of the rest that end at or after byte `want`, and then with twice as many bytes
-/// each time, while the rest goes on past them. The layout places lines in order and stops at the
-/// first line that does not fit, and each paragraph is shaped and broken on its own text. So when
-/// that line starts before the last paragraph break measured, the frame holds the same bytes 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) -> usize {
-    let by_paragraph = matches!(frame.kind, TextKind::Area { .. })
-        && frame.area.fit.min_scale().is_none()
-        && frame.area.vertical_align == vectorcraft_doc::VerticalAlign::Top;
+/// Area type without Shrink Text to Fit is first measured with the whole paragraphs of the rest
+/// that end at or after byte `want`, and then with twice as many bytes each time, while the rest
+/// goes on past them. The layout places lines in order and stops at the first line that does not
+/// fit, and each paragraph is shaped and broken on its own text. So when that line starts before
+/// the last paragraph break measured, the frame holds the same bytes with the whole rest. Lines
+/// aligned to the center, the bottom or justified vertically move by the space the placed lines
+/// leave, and a frame that is not a plain rectangle flows them again from there. A pass that places
+/// less text than the one before is undone, so no pass places more text than the final layout; when
+/// that layout stops before the last paragraph break measured, every pass stopped at the same line
+/// as with the whole rest.
+///
+/// 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.
+///
+/// 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 {
+    let on_path = matches!(frame.kind, TextKind::OnPath { .. });
+    let by_paragraph = match frame.kind {
+        TextKind::Area { .. } => frame.area.fit.min_scale().is_none(),
+        TextKind::OnPath { .. } => path_starts_at_bracket(&probe(Vec::new()), no_rtl),
+        _ => false,
+    };
     if by_paragraph {
         while let Some(end) = rest.break_after(want.saturating_sub(1)).filter(|&end| end < rest.len) {
             let (n, unplaced) = fit(db, &probe(rest.before(end)));
-            if unplaced.is_some_and(|u| u + 1 < end) {
+            let first_out = if on_path { Some(n) } else { unplaced };
+            if first_out.is_some_and(|u| u + 1 < end) {
                 return n;
             }
             want = end.saturating_mul(2);
@@ -286,6 +305,35 @@ fn fit_rest(db: &FontDb, probe: impl Fn(Vec<TextRun>) -> TextObject, frame: &Tex
     fit(db, &probe(rest.all())).0
 }
 
+/// Whether type on a path made as `head` (the frame with its first paragraph's style) places its
+/// line from the start bracket, glyph by glyph, whatever text follows: see [`fit_rest`].
+fn path_starts_at_bracket(head: &TextObject, no_rtl: bool) -> bool {
+    use vectorcraft_doc::{Justify, ParaDirection};
+    let para = head.para_at(0);
+    !head.dynamic_text
+        && !head.optical_margin
+        && !para.roman_hanging
+        && matches!(para.justify, Justify::Auto | Justify::Left | Justify::JustifyLeft)
+        && (head.vertical || (no_rtl && para.direction != Some(ParaDirection::RightToLeft)))
+}
+
+/// The end of the last character of `runs` that makes its paragraph resolve right to left
+/// ([`crate::layout::starts_bidi`], or a run with the right-to-left Character Direction); 0 when
+/// there is none.
+fn rtl_end(runs: &[TextRun]) -> usize {
+    let mut off = 0;
+    let mut end = 0;
+    for r in runs {
+        if r.style.char_direction == Some(vectorcraft_doc::ParaDirection::RightToLeft) && !r.text.is_empty() {
+            end = off + r.text.len();
+        } else if let Some((i, c)) = r.text.char_indices().rev().find(|&(_, c)| crate::layout::starts_bidi(c)) {
+            end = off + i + c.len_utf8();
+        }
+        off += r.text.len();
+    }
+    end
+}
+
 /// A frame's share of a story: its runs, its paragraphs' styles (one per paragraph) and the
 /// numbered list paragraphs counted before its first one, at level 1 and at the levels past it
 /// ([`TextObject::list_count`], [`TextObject::list_level_counts`]).
@@ -379,7 +427,10 @@ pub fn distribute_continuing_levels(
     continued: bool,
     mut counts: ListCounts,
 ) -> Vec<Slice> {
-    let mut story_rest = Rest { runs, run: 0, skip: 0, raw: true, len: runs_len(runs) };
+    let story_len = runs_len(runs);
+    let mut story_rest = Rest { runs, run: 0, skip: 0, raw: true, len: story_len };
+    // Where the story's right-to-left text ends ([`rtl_end`]), read once, for type on a path.
+    let story_rtl_end = std::cell::OnceCell::new();
     // Once the story is used up, what is left is one empty run with the style there.
     let mut used_up: Option<TextRun> = None;
     let mut out = Vec::with_capacity(frames.len());
@@ -415,7 +466,12 @@ pub fn distribute_continuing_levels(
                 probe.first_para_continues = continues;
                 probe
             };
-            fit_rest(db, probe, f, rest, want)
+            // The rest is the story after its first `story_len - len` bytes.
+            let no_rtl = len == 0
+                || (matches!(f.kind, TextKind::OnPath { .. })
+                    && !f.vertical
+                    && *story_rtl_end.get_or_init(|| rtl_end(runs)) <= story_len.saturating_sub(len));
+            fit_rest(db, probe, f, rest, want, no_rtl)
         };
         want = n.saturating_mul(2).max(MIN_MEASURE);
         let mut head = rest.slice(0, n);
diff --git a/crates/text/src/thread/tests.rs b/crates/text/src/thread/tests.rs
index 943aeb2973..7554a808f9 100644
--- a/crates/text/src/thread/tests.rs
+++ b/crates/text/src/thread/tests.rs
@@ -19,6 +19,14 @@ fn path_frame(length: f64) -> TextObject {
     t
 }
 
+/// Type on a curved path about 300 long.
+fn curved_path_frame() -> TextObject {
+    let mut t = path_frame(300.0);
+    let curve = kurbo::CubicBez::new((0.0, 0.0), (100.0, -120.0), (200.0, 120.0), (300.0, 0.0));
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&kurbo::Shape::to_path(&curve, 0.1)), 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]
@@ -543,6 +551,7 @@ fn paragraphs(n: usize) -> String {
 /// text and paragraph style that changes how much a frame holds.
 #[test]
 fn frames_take_the_shares_the_whole_rest_gives_them() {
+    use vectorcraft_doc::VerticalAlign;
     use vectorcraft_doc::text::{NumberStyle, ParaList};
     let db = FontDb::global();
     let plain = CharStyle::default();
@@ -649,6 +658,123 @@ fn frames_take_the_shares_the_whole_rest_gives_them() {
     let two = [&frames[0], &frames[1]];
     took += same_as_whole_rest(db, &two, &story(&paragraphs(200)), &[], "overflowing last frame");
 
+    // Lines aligned to the center, the bottom or justified vertically, in rectangles, ellipses and
+    // frames that wrap around an object, with Shrink Text to Fit in one frame, and a story whose
+    // last paragraph runs through several frames.
+    let last_long = format!("{}\n{}", paragraphs(6), "The quick brown fox jumps over the lazy dog. ".repeat(40));
+    for align in [VerticalAlign::Center, VerticalAlign::Bottom, VerticalAlign::Justify] {
+        let mut rects = frames.clone();
+        for f in &mut rects {
+            f.area.vertical_align = align;
+        }
+        took += same_as_whole_rest(db, &refs(&rects), &story(&paragraphs(120)), &spaced, &format!("{align:?}"));
+        took += same_as_whole_rest(db, &refs(&rects), &story(&breaks), &[], &format!("{align:?}, empty paragraphs"));
+        took += same_as_whole_rest(db, &refs(&rects), &styled, &[], &format!("{align:?}, style runs"));
+        took += same_as_whole_rest(db, &refs(&rects), &story(&paragraphs(120)), &listed, &format!("{align:?}, lists"));
+        took += same_as_whole_rest(db, &refs(&rects), &story(&last_long), &[], &format!("{align:?}, long last paragraph"));
+        let mut ellipses = rects.clone();
+        for (k, f) in ellipses.iter_mut().enumerate() {
+            let x = 200.0 * k as f64;
+            f.kind = TextKind::Area { frame: shapes::ellipse(Rect::new(x, 0.0, x + 160.0, 90.0)) };
+        }
+        took += same_as_whole_rest(db, &refs(&ellipses), &story(&paragraphs(120)), &[], &format!("{align:?}, ellipses"));
+        took += same_as_whole_rest(db, &refs(&ellipses), &story(&long_paras), &justified, &format!("{align:?}, ellipses, justified"));
+        let mut wrapped = rects.clone();
+        for (k, f) in wrapped.iter_mut().enumerate() {
+            let x = 200.0 * k as f64;
+            f.wrap = vec![vectorcraft_doc::WrapShape { path: shapes::ellipse(Rect::new(x + 40.0, 10.0, x + 90.0, 40.0)), wrap: Default::default() }];
+        }
+        took += same_as_whole_rest(db, &refs(&wrapped), &story(&paragraphs(120)), &[], &format!("{align:?}, wrapped"));
+        let mut shrink = rects.clone();
+        shrink[2].area.fit = vectorcraft_doc::AreaFit::ShrinkText { min_percent: 60.0 };
+        took += same_as_whole_rest(db, &refs(&shrink), &story(&paragraphs(120)), &[], &format!("{align:?}, Shrink Text to Fit"));
+    }
+
+    // Type on a path: lines that start at the start bracket, and lines whose place or length
+    // depends on the text after them (centered or right-aligned, hanging punctuation, Dynamic
+    // Text, right-to-left text), horizontal and vertical.
+    let paths = |edit: Edit| -> Vec<TextObject> {
+        (0..6)
+            .map(|k| {
+                let mut t = if k % 2 == 0 { path_frame(300.0) } else { curved_path_frame() };
+                if k % 3 == 2 {
+                    // Brackets inside the path, with room for the line's ends to hang past them.
+                    if let TextKind::OnPath { start, end, .. } = &mut t.kind {
+                        (*start, *end) = (0.1, Some(0.8));
+                    }
+                }
+                edit(&mut t);
+                t
+            })
+            .collect()
+    };
+    let hebrew = "\u{5e9}\u{5dc}\u{5d5}\u{5dd} \u{5e2}\u{5d5}\u{5dc}\u{5dd} ".repeat(4);
+    let rtl_early = format!("{}\n{}\n{}", paragraphs(2), hebrew.trim_end(), paragraphs(100));
+    let ends_unhung = format!("{}\nlast words", paragraphs(120));
+    let rtl_late = format!("{}\n{}\n{}", paragraphs(80), hebrew.trim_end(), paragraphs(20));
+    let whole = story(&paragraphs(120));
+    let at = paragraphs(60).len();
+    let directed = [
+        slice_runs(&whole, 0, at),
+        vec![TextRun::new(
+            " set right to left ",
+            CharStyle { char_direction: Some(vectorcraft_doc::ParaDirection::RightToLeft), ..Default::default() },
+        )],
+        slice_runs(&whole, at, runs_len(&whole)),
+    ]
+    .concat();
+    type Edit = fn(&mut TextObject);
+    let edits: [(&str, Edit); 15] = [
+        ("path", |_| {}),
+        ("path, Left", |t| t.para.justify = Justify::Left),
+        ("path, Auto", |t| t.para.justify = Justify::Auto),
+        ("path, Justify Left", |t| t.para.justify = Justify::JustifyLeft),
+        ("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, 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),
+        ("path, Dynamic Text", |t| t.dynamic_text = true),
+        ("path, right to left", |t| t.para.direction = Some(vectorcraft_doc::ParaDirection::RightToLeft)),
+        ("path, Auto right to left", |t| {
+            t.para.justify = Justify::Auto;
+            t.para.direction = Some(vectorcraft_doc::ParaDirection::RightToLeft);
+        }),
+        ("vertical path", |t| t.vertical = true),
+        ("vertical path, Center", |t| {
+            t.vertical = true;
+            t.para.justify = Justify::Center;
+        }),
+    ];
+    for (case, edit) in edits {
+        let on = paths(edit);
+        took += same_as_whole_rest(db, &refs(&on), &story(&paragraphs(120)), &[], case);
+        took += same_as_whole_rest(db, &refs(&on), &story(&rtl_early), &[], &format!("{case}, right-to-left paragraph early"));
+        took += same_as_whole_rest(db, &refs(&on), &story(&rtl_late), &[], &format!("{case}, right-to-left paragraph late"));
+        took += same_as_whole_rest(db, &refs(&on), &directed, &[], &format!("{case}, right-to-left Character Direction"));
+        took += same_as_whole_rest(db, &refs(&on), &story(&last_long), &[], &format!("{case}, long last paragraph"));
+        // 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"));
+    }
+    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");
+    took += same_as_whole_rest(db, &refs(&on), &story(&breaks), &[], "path, spaces and empty paragraphs");
+    let story_paras: Vec<ParaStyle> = (0..120)
+        .map(|i| ParaStyle { justify: [Justify::Left, Justify::Center, Justify::Auto][i % 3], roman_hanging: i % 5 == 0, ..Default::default() })
+        .collect();
+    took += same_as_whole_rest(db, &refs(&on), &story(&paragraphs(120)), &story_paras, "path, paragraph styles");
+    let mut between = frames.clone();
+    for (k, f) in between.iter_mut().enumerate() {
+        if k % 2 == 1 {
+            *f = path_frame(260.0);
+        } else {
+            f.area.vertical_align = VerticalAlign::Bottom;
+        }
+    }
+    took += same_as_whole_rest(db, &refs(&between), &story(&paragraphs(120)), &[], "paths between area type");
+
     // Short stories, an empty one and one of empty runs.
     took += same_as_whole_rest(db, &refs(&frames), &story("Hi"), &[], "short story");
     took += same_as_whole_rest(db, &refs(&frames), &story(""), &[], "empty story");
@@ -674,6 +800,9 @@ fn seeded_stories_take_the_shares_the_whole_rest_gives_them() {
         let mut paras = 1;
         for _ in 0..(150 + next(250)) {
             let mut text = words[next(words.len() as u64) as usize].to_string();
+            if next(60) == 0 {
+                text = "\u{5e9}\u{5dc}\u{5d5}\u{5dd}".to_string();
+            }
             text.push(if next(6) == 0 {
                 paras += 1;
                 '\n'
@@ -692,30 +821,80 @@ fn seeded_stories_take_the_shares_the_whole_rest_gives_them() {
                 ..Default::default()
             })
             .collect();
-        let frames: Vec<TextObject> = (0..2 + next(6)).map(|k| sized(200.0 * k as f64, 40.0 + next(120) as f64, 10.0 + next(120) as f64)).collect();
+        let mut frames: Vec<TextObject> =
+            (0..2 + next(6)).map(|k| sized(200.0 * k as f64, 40.0 + next(120) as f64, 10.0 + next(120) as f64)).collect();
+        // Lines aligned every way, and type on a path, horizontal or vertical.
+        for f in &mut frames {
+            use vectorcraft_doc::VerticalAlign;
+            f.area.vertical_align = [VerticalAlign::Top, VerticalAlign::Center, VerticalAlign::Bottom, VerticalAlign::Justify][next(4) as usize];
+            if next(4) == 0 {
+                *f = if next(2) == 0 { path_frame(80.0 + next(400) as f64) } else { curved_path_frame() };
+                f.vertical = next(3) == 0;
+            }
+        }
         same_as_whole_rest(db, &frames.iter().collect::<Vec<_>>(), &runs, &styles, &format!("case {case}"));
     }
 }
 
-/// A long story of short paragraphs through many frames: each frame is measured with about the
-/// text it takes and a little more, not with the whole rest of the story.
-#[test]
-fn many_frames_measure_about_the_text_they_take() {
-    let db = FontDb::global();
+/// Each of `frames` takes its share of a long story of short paragraphs measured with about the text
+/// it takes and a little more, not with the whole rest of the story.
+fn measures_about_the_text_taken(db: &FontDb, frames: &[TextObject], case: &str) {
     let text = paragraphs(1500);
     let story = vec![TextRun::new(text.clone(), CharStyle::default())];
-    let frames: Vec<TextObject> = (0..40).map(|k| frame(200.0 * k as f64)).collect();
     let refs: Vec<&TextObject> = frames.iter().collect();
     let before = fit_bytes();
     let parts = distribute(db, &refs, &story, &[]);
     let measured = fit_bytes() - before;
     let joined: String = parts.iter().flat_map(|p| &p.runs).map(|r| r.text.as_str()).collect();
-    assert_eq!(joined, text, "no character lost or duplicated");
+    assert_eq!(joined, text, "{case}: no character lost or duplicated");
     let placed: usize = parts[..parts.len() - 1].iter().map(|p| runs_len(&p.runs)).sum();
     let longest = text.split('\n').map(str::len).max().unwrap_or(0);
-    assert!(placed > 0 && placed < text.len() / 4, "the frames hold part of the story: {placed} of {}", text.len());
+    assert!(placed > 0 && placed < text.len() / 4, "{case}: the frames hold part of the story: {placed} of {}", text.len());
     let bound = 4 * placed + frames.len() * 2 * (MIN_MEASURE + longest);
-    assert!(measured <= bound, "measured {measured} bytes for {placed} placed in {} frames (at most {bound})", frames.len());
+    assert!(measured <= bound, "{case}: measured {measured} bytes for {placed} placed in {} frames (at most {bound})", frames.len());
+}
+
+/// A long story of short paragraphs through many frames: each frame is measured with about the
+/// text it takes and a little more, not with the whole rest of the story. That holds for area type
+/// aligned to the top, the center or the bottom or justified vertically, in rectangles and other
+/// shapes, and for type on a path whose line starts at the start bracket, horizontal or vertical.
+#[test]
+fn many_frames_measure_about_the_text_they_take() {
+    use vectorcraft_doc::VerticalAlign;
+    let db = FontDb::global();
+    let frames: Vec<TextObject> = (0..40).map(|k| frame(200.0 * k as f64)).collect();
+    measures_about_the_text_taken(db, &frames, "top");
+    for align in [VerticalAlign::Center, VerticalAlign::Bottom, VerticalAlign::Justify] {
+        let mut aligned = frames.clone();
+        for f in &mut aligned {
+            f.area.vertical_align = align;
+        }
+        measures_about_the_text_taken(db, &aligned, &format!("{align:?}"));
+        let mut shaped = aligned.clone();
+        for (k, f) in shaped.iter_mut().enumerate() {
+            let x = 200.0 * k as f64;
+            f.kind = TextKind::Area { frame: shapes::ellipse(Rect::new(x, 0.0, x + 160.0, 90.0)) };
+        }
+        measures_about_the_text_taken(db, &shaped, &format!("{align:?}, ellipses"));
+    }
+    for justify in [Justify::Left, Justify::JustifyLeft, Justify::Auto] {
+        let paths: Vec<TextObject> = (0..40)
+            .map(|_| {
+                let mut t = path_frame(300.0);
+                t.para.justify = justify;
+                t
+            })
+            .collect();
+        measures_about_the_text_taken(db, &paths, &format!("path, {justify:?}"));
+    }
+    let vertical: Vec<TextObject> = (0..40)
+        .map(|_| {
+            let mut t = path_frame(300.0);
+            t.vertical = true;
+            t
+        })
+        .collect();
+    measures_about_the_text_taken(db, &vertical, "vertical path");
 }
 
 /// Frames that already hold text and take a story over several measurements each: each frame's own
diff --git a/crates/tools/src/draw2/gesture.rs b/crates/tools/src/draw2/gesture.rs
index fb42d1e6cb..3c36d8c81a 100644
--- a/crates/tools/src/draw2/gesture.rs
+++ b/crates/tools/src/draw2/gesture.rs
@@ -26,12 +26,14 @@
 mod area;
 
 use std::cell::Cell;
+use std::collections::{BTreeMap, BTreeSet};
 
 use serde_json::{Value, json};
 use vectorcraft_doc::{NodeId, NodeKind};
-use vectorcraft_geom::{Affine, Point};
+use vectorcraft_geom::{Affine, BezPath, FillRule, ParamCurve, PathData, PathSeg, Point, Rect, Vec2, shapes};
+use vectorcraft_pathops as po;
 
-use super::{FEEDBACK, blob_tip, 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};
@@ -40,6 +42,32 @@ use area::{AreaKey, AreaPreview};
 /// Pencil, Paintbrush or Blob Brush uses the same radius.
 const SMOOTH_RADIUS: f64 = 12.0;
 
+/// The most points of a drag that one step of its band adds, as when the band is outlined again
+/// at a new zoom.
+const BAND_STEP: usize = 32;
+/// The most steps one call adds to a band: a band outlined again for a long drag shows in full
+/// over several frames ([`Tool::overlays_pending`]).
+const BAND_STEPS_PER_CALL: usize = 8;
+/// The side of the squares a smoothing drag's band is kept in, in radii: a step of the drag adds
+/// its area only to the squares it reaches, so the work of a step does not grow with the drag.
+const BAND_TILE_RADII: f64 = 8.0;
+/// Where the grid of those squares starts, in squares from the origin, so that the edge of the
+/// band of a drag along whole coordinates does not run along a side of a square.
+const BAND_TILE_OFFSET: f64 = 0.381_966;
+/// The most squares one segment of a drag is checked against: a segment longer than 2,048 squares
+/// is kept outside the squares, and shows as the two sides of its band.
+const BAND_TILE_SAMPLES: f64 = 4096.0;
+/// The side of the cells of a coarser grid, in squares: each cell lists the squares and the long
+/// segments in it, so that a new square or long segment is checked only against those near it.
+const BAND_CELL_TILES: i64 = 1024;
+/// The most points, half a cell apart, along a long segment at which its cells are listed: a
+/// longer segment is listed in no cell and checked against every square and long segment.
+const BAND_CELL_SAMPLES: f64 = 4096.0;
+/// The most work one call does on the band's long segments: comparisons of a long segment with a
+/// square or another long segment, and pieces of an outline tested. The rest waits for the next
+/// call ([`Tool::overlays_pending`]), and the band shown until then is the last one finished.
+const BAND_WORK_PER_CALL: usize = 20_000;
+
 /// The finest Fidelity (screen pixels) a Pencil or Paintbrush stroke is fitted at while it is drawn:
 /// 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.
@@ -150,6 +178,584 @@ pub struct GestureTool {
     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.
+    band_pending: Cell<bool>,
+}
+
+/// The band a smoothing drag smooths, for the drag's first `used` points at `radius`, kept as its
+/// area in each square of a grid that it reaches.
+struct SmoothBand {
+    radius: f64,
+    used: usize,
+    first: Point,
+    last: Point,
+    tiles: BTreeMap<(i64, i64), BandTile>,
+    /// The segments of the drag too long for the squares ([`BAND_TILE_SAMPLES`]).
+    long: Vec<LongSegment>,
+    /// The squares and long segments listed in each cell of a coarser grid ([`BAND_CELL_TILES`]).
+    cells: BTreeMap<(i64, i64), BandCell>,
+    /// The long segments listed in no cell ([`BAND_CELL_SAMPLES`]).
+    wide: Vec<usize>,
+    /// The squares near a long segment whose `cut` is to be made again.
+    dirty_tiles: BTreeSet<(i64, i64)>,
+    /// The long segments whose `drawn` is to be made again.
+    dirty_long: BTreeSet<usize>,
+    /// The band changed since `shown` was made.
+    changed: bool,
+    /// The outline last finished.
+    shown: Option<BezPath>,
+    /// The work done on long segments in the current call ([`BAND_WORK_PER_CALL`]).
+    work: usize,
+}
+
+/// The squares and long segments (indexes into [`SmoothBand::long`]) in one cell of the coarser grid.
+#[derive(Default)]
+struct BandCell {
+    tiles: Vec<(i64, i64)>,
+    long: Vec<usize>,
+}
+
+/// The part of a band in one square of the grid, and its outline less the square's sides.
+struct BandTile {
+    area: PathData,
+    outline: BezPath,
+    /// The long segments whose band can reach the square (indexes into [`SmoothBand::long`]).
+    near_long: Vec<usize>,
+    /// `outline` less its parts inside the band of a long segment in `near_long`.
+    cut: BezPath,
+}
+
+/// A segment of a drag too long for the squares, from `a` to `b`, with the part of it outside the
+/// squares (`from` and `to`: 0 at `a`, 1 at `b`): the squares hold its band for a square's side
+/// from each end ([`SmoothBand::add_long`]).
+struct LongSegment {
+    a: Point,
+    b: Point,
+    from: f64,
+    to: f64,
+    /// The squares its band can reach.
+    near: BTreeSet<(i64, i64)>,
+    /// The other long segments whose band can meet its band.
+    meets: Vec<usize>,
+    /// The parts of the two sides of its band that show.
+    drawn: BezPath,
+}
+
+impl LongSegment {
+    /// The two sides of its band at `radius`, over its part outside the squares.
+    fn sides(&self, radius: f64) -> [vectorcraft_geom::Line; 2] {
+        let d = self.b - self.a;
+        let s = Vec2::new(-d.y, d.x) * (radius / d.hypot());
+        let (p, q) = (self.a.lerp(self.b, self.from), self.a.lerp(self.b, self.to));
+        [vectorcraft_geom::Line::new(p + s, q + s), vectorcraft_geom::Line::new(p - s, q - s)]
+    }
+}
+
+impl SmoothBand {
+    /// The band of a drag that starts at `first`, before it has moved.
+    fn new(first: Point, radius: f64) -> Self {
+        Self {
+            radius,
+            used: 1,
+            first,
+            last: first,
+            tiles: BTreeMap::new(),
+            long: vec![],
+            cells: BTreeMap::new(),
+            wide: vec![],
+            dirty_tiles: BTreeSet::new(),
+            dirty_long: BTreeSet::new(),
+            changed: true,
+            shown: None,
+            work: 0,
+        }
+    }
+
+    /// The cell of the coarser grid that holds square `key`.
+    fn cell_of((ix, iy): (i64, i64)) -> (i64, i64) {
+        (ix.div_euclid(BAND_CELL_TILES), iy.div_euclid(BAND_CELL_TILES))
+    }
+
+    /// The cells around points half a cell apart along the segment from `a` to `b`: every cell
+    /// holding a square its band can reach, or a point within the radius of its band. `None` for
+    /// a segment longer than [`BAND_CELL_SAMPLES`] half cells or reaching far outside any document.
+    fn cells_along(&self, a: Point, b: Point) -> Option<BTreeSet<(i64, i64)>> {
+        let n = (a.distance(b) / (0.5 * BAND_CELL_TILES as f64 * self.side())).ceil().max(1.0);
+        if !n.is_finite() || n > BAND_CELL_SAMPLES {
+            return None;
+        }
+        let mut cells = BTreeSet::new();
+        for k in 0..=(n as u32) {
+            let (cx, cy) = Self::cell_of(self.tile_of(a.lerp(b, f64::from(k) / n))?);
+            for (dx, dy) in [(-1, -1), (0, -1), (1, -1), (-1, 0), (0, 0), (1, 0), (-1, 1), (0, 1), (1, 1)] {
+                cells.insert((cx + dx, cy + dy));
+            }
+        }
+        Some(cells)
+    }
+
+    /// Whether the band of the segment from `a` to `b` can reach square `key`.
+    fn reaches(&self, key: (i64, i64), a: Point, b: Point) -> bool {
+        distance_to_segment(self.tile_rect(key).center(), a, b) <= self.radius + 0.5 * std::f64::consts::SQRT_2 * self.side()
+    }
+
+    /// Whether the segment from `a` to `b` is too long for the squares: longer than
+    /// [`BAND_TILE_SAMPLES`] half squares.
+    fn too_long(&self, a: Point, b: Point) -> bool {
+        let n = a.distance(b) / (0.5 * self.side());
+        n.is_finite() && n > BAND_TILE_SAMPLES
+    }
+
+    /// Add the band of the segment from `a` to `b`, too long for the squares: the squares take its
+    /// band for a square's side from each end, where they can, and the rest is kept as the
+    /// segment.
+    fn add_long(&mut self, a: Point, b: Point) {
+        let d = b - a;
+        let stub = d * (self.side() / d.hypot());
+        let from = if self.grow(&[a, a + stub]).is_some() { self.side() / d.hypot() } else { 0.0 };
+        let to = if self.grow(&[b - stub, b]).is_some() { 1.0 - self.side() / d.hypot() } else { 1.0 };
+        let i = self.long.len();
+        // The squares and long segments listed in its cells, or all of them.
+        let mut tiles = BTreeSet::new();
+        let mut others: BTreeSet<usize> = self.wide.iter().copied().collect();
+        match self.cells_along(a, b) {
+            Some(cells) => {
+                self.work += cells.len();
+                for c in cells {
+                    let cell = self.cells.entry(c).or_default();
+                    tiles.extend(cell.tiles.iter().copied());
+                    others.extend(cell.long.iter().copied());
+                    cell.long.push(i);
+                }
+            }
+            None => {
+                tiles.extend(self.tiles.keys().copied());
+                others.extend(0..i);
+                self.wide.push(i);
+            }
+        }
+        self.work += tiles.len() + others.len();
+        let near: BTreeSet<_> = tiles.into_iter().filter(|&k| self.reaches(k, a, b)).collect();
+        for k in &near {
+            if let Some(t) = self.tiles.get_mut(k) {
+                t.near_long.push(i);
+                self.dirty_tiles.insert(*k);
+            }
+        }
+        let reach = 2.0 * self.radius + 2e-3 * self.radius;
+        let meets: Vec<usize> = others.into_iter().filter(|&j| self.long.get(j).is_some_and(|o| segment_distance(a, b, o.a, o.b) <= reach)).collect();
+        for &j in &meets {
+            if let Some(o) = self.long.get_mut(j) {
+                o.meets.push(i);
+                self.dirty_long.insert(j);
+            }
+        }
+        self.long.push(LongSegment { a, b, from, to, near, meets, drawn: BezPath::new() });
+        self.dirty_long.insert(i);
+        self.last = b;
+        self.changed = true;
+    }
+
+    /// The side of the grid's squares.
+    fn side(&self) -> f64 {
+        BAND_TILE_RADII * self.radius
+    }
+
+    /// The square of the grid `key` names.
+    fn tile_rect(&self, (ix, iy): (i64, i64)) -> Rect {
+        let s = self.side();
+        let (x0, y0) = ((ix as f64 + BAND_TILE_OFFSET) * s, (iy as f64 + BAND_TILE_OFFSET) * s);
+        Rect::new(x0, y0, x0 + s, y0 + s)
+    }
+
+    /// The square of the grid that holds `p`; `None` far outside any document.
+    fn tile_of(&self, p: Point) -> Option<(i64, i64)> {
+        let s = self.side();
+        let (x, y) = ((p.x / s - BAND_TILE_OFFSET).floor(), (p.y / s - BAND_TILE_OFFSET).floor());
+        (x.abs() < 1e15 && y.abs() < 1e15).then_some((x as i64, y as i64))
+    }
+
+    /// The squares within the radius of `piece`: those around points along it half a square apart.
+    fn tiles_near(&self, piece: &[Point]) -> Option<BTreeSet<(i64, i64)>> {
+        let mut keys = BTreeSet::new();
+        for w in piece.windows(2) {
+            let n = (w[0].distance(w[1]) / (0.5 * self.side())).ceil().max(1.0);
+            if !n.is_finite() || n > BAND_TILE_SAMPLES {
+                return None;
+            }
+            for k in 0..=(n as u32) {
+                let (ix, iy) = self.tile_of(w[0].lerp(w[1], f64::from(k) / n))?;
+                for (dx, dy) in [(-1, -1), (0, -1), (1, -1), (-1, 0), (0, 0), (1, 0), (-1, 1), (0, 1), (1, 1)] {
+                    keys.insert((ix + dx, iy + dy));
+                }
+            }
+        }
+        Some(keys)
+    }
+
+    /// Add the area within the radius of `piece`, the drag from the last point covered so far, to
+    /// the squares it reaches. `None`, with the band unchanged, when the outlines cannot be
+    /// combined.
+    fn grow(&mut self, piece: &[Point]) -> Option<()> {
+        let (r, nz) = (self.radius, FillRule::NonZero);
+        let end = *piece.last()?;
+        // Within a hundredth of the radius at any zoom.
+        let precision = (0.01 * r).min(po::DEFAULT_PRECISION);
+        let keys = self.tiles_near(piece)?;
+        let added = blob_area(piece, 2.0 * r, 0.0, 100.0);
+        let mut changed = vec![];
+        for key in keys {
+            let rect = self.tile_rect(key);
+            let clip = po::try_boolean(&added, nz, &shapes::rectangle(rect), nz, po::BoolOp::Intersect, precision).ok()?;
+            if clip.is_empty() {
+                continue;
+            }
+            let area = match self.tiles.get(&key) {
+                Some(t) => po::try_boolean(&t.area, nz, &clip, nz, po::BoolOp::Union, precision).ok().filter(|a| !a.is_empty())?,
+                None => clip,
+            };
+            changed.push((key, area));
+        }
+        // A square's outline depends on the squares across its sides, so those are outlined
+        // again too.
+        let mut redo = BTreeSet::new();
+        for (key @ (ix, iy), area) in changed {
+            redo.extend([(ix, iy), (ix - 1, iy), (ix + 1, iy), (ix, iy - 1), (ix, iy + 1)]);
+            let near_long = match self.tiles.get(&key) {
+                Some(t) => t.near_long.clone(),
+                None => {
+                    // The long segments listed in the square's cell, and those in no cell.
+                    let cell = self.cells.entry(Self::cell_of(key)).or_default();
+                    cell.tiles.push(key);
+                    let mut listed: BTreeSet<usize> = cell.long.iter().copied().collect();
+                    listed.extend(self.wide.iter().copied());
+                    let near: Vec<usize> = listed.into_iter().filter(|&i| self.long.get(i).is_some_and(|l| self.reaches(key, l.a, l.b))).collect();
+                    for &i in &near {
+                        if let Some(l) = self.long.get_mut(i) {
+                            l.near.insert(key);
+                        }
+                    }
+                    near
+                }
+            };
+            // The sides of those long segments are cut where the square's area holds them.
+            self.dirty_long.extend(near_long.iter().copied());
+            self.tiles.insert(key, BandTile { area, outline: BezPath::new(), near_long, cut: BezPath::new() });
+        }
+        self.changed = true;
+        let outlines: Vec<_> = redo.into_iter().filter(|k| self.tiles.contains_key(k)).map(|k| (k, self.tile_outline(k))).collect();
+        for (key, outline) in outlines {
+            if let Some(t) = self.tiles.get_mut(&key) {
+                t.outline = outline;
+                if !t.near_long.is_empty() {
+                    self.dirty_tiles.insert(key);
+                }
+            }
+        }
+        self.last = end;
+        Some(())
+    }
+
+    /// The band's outline: the last one finished. While the band has changed since, the parts it
+    /// changed are made again, until [`BAND_WORK_PER_CALL`] is spent in the call; when all are
+    /// made, the outline is joined from them ([`SmoothBand::make_outline`]).
+    fn outline(&mut self) -> Option<BezPath> {
+        while self.changed {
+            if !self.dirty_tiles.is_empty() || !self.dirty_long.is_empty() {
+                if self.work >= BAND_WORK_PER_CALL {
+                    break;
+                }
+                if let Some(k) = self.dirty_tiles.pop_first() {
+                    let (cut, work) = self.tile_cut(k);
+                    self.work += work;
+                    if let Some(t) = self.tiles.get_mut(&k) {
+                        t.cut = cut;
+                    }
+                } else if let Some(i) = self.dirty_long.pop_first() {
+                    let (drawn, work) = self.long_drawn(i);
+                    self.work += work;
+                    if let Some(l) = self.long.get_mut(i) {
+                        l.drawn = drawn;
+                    }
+                }
+            } else {
+                self.shown = Some(self.make_outline());
+                self.changed = false;
+            }
+        }
+        self.shown.clone()
+    }
+
+    /// The band's outline: every square's, joined, then the parts that show of the two sides of
+    /// the band of each segment too long for the squares. A square near such a segment shows its
+    /// `cut` ([`SmoothBand::tile_cut`]), and such a segment its `drawn` ([`SmoothBand::long_drawn`]).
+    fn make_outline(&self) -> BezPath {
+        let tiles = self.tiles.values().flat_map(|t| (if t.near_long.is_empty() { &t.outline } else { &t.cut }).elements().iter().copied());
+        BezPath::from_vec(tiles.chain(self.long.iter().flat_map(|l| l.drawn.elements().iter().copied())).collect())
+    }
+
+    /// The outline of square `key` less its parts inside the band of a long segment near it (more
+    /// than a thousandth of the radius in), and the work that took.
+    fn tile_cut(&self, key: (i64, i64)) -> (BezPath, usize) {
+        let Some(t) = self.tiles.get(&key) else { return (BezPath::new(), 1) };
+        let (r, eps) = (self.radius, 1e-3 * self.radius);
+        let near: Vec<&LongSegment> = t.near_long.iter().filter_map(|&i| self.long.get(i)).collect();
+        let mut out = BezPath::new();
+        let mut pen = None;
+        let mut work = 1;
+        for seg in t.outline.segments() {
+            // The pieces of the segment between the points where it crosses a side of the band
+            // of a long segment, each left out when it lies inside that band.
+            let mut ts: Vec<f64> = near
+                .iter()
+                .flat_map(|l| l.sides(r))
+                .flat_map(|line| seg.intersect_line(line))
+                .map(|x| x.segment_t)
+                .filter(|t| *t > 0.0 && *t < 1.0)
+                .collect();
+            ts.extend([0.0, 1.0]);
+            ts.sort_by(f64::total_cmp);
+            ts.dedup();
+            work += near.len() * ts.len();
+            for w in ts.windows(2) {
+                let piece = if ts.len() == 2 { seg } else { seg.subsegment(w[0]..w[1]) };
+                let m = piece.eval(0.5);
+                if near.iter().any(|l| distance_to_segment(m, l.a, l.b) < r - eps) {
+                    pen = None;
+                } else {
+                    push_seg(&mut out, &mut pen, piece);
+                }
+            }
+        }
+        (out, work)
+    }
+
+    /// The parts that show of the two sides of the band of long segment `i`, outside the squares'
+    /// part of it, and the work that took. Left out: the parts inside the band area of a square,
+    /// inside the band of another long segment (more than a thousandth of the radius in), and on
+    /// a side of an earlier long segment, which already shows. Only the squares and long segments
+    /// near it are checked.
+    fn long_drawn(&self, i: usize) -> (BezPath, usize) {
+        let Some(l) = self.long.get(i) else { return (BezPath::new(), 1) };
+        let (r, eps) = (self.radius, 1e-3 * self.radius);
+        let others: Vec<(usize, &LongSegment)> = l.meets.iter().filter_map(|&j| self.long.get(j).map(|o| (j, o))).collect();
+        // Whether a square's band area holds `q`.
+        let in_tiles = |q: Point| {
+            self.tile_of(q).and_then(|k| self.tiles.get(&k)).is_some_and(|t| vectorcraft_geom::Shape::winding(&t.area.to_bezpath(), q) != 0)
+        };
+        let mut out = BezPath::new();
+        let mut work = 1;
+        for line in l.sides(r) {
+            // Where the side crosses the band area of a square it passes, a side of another long
+            // segment's band, or the end of a side it runs along.
+            let mut ts = vec![0.0, 1.0];
+            for t in l.near.iter().filter_map(|k| self.tiles.get(k)) {
+                ts.extend(t.area.to_bezpath().segments().flat_map(|seg| seg.intersect_line(line)).map(|x| x.line_t));
+            }
+            // The stretches of the side inside the band of another long segment, and those on a
+            // side of an earlier one.
+            let mut inside = vec![];
+            let mut along = vec![];
+            for &(j, other) in &others {
+                inside.extend(capsule_span(line, other.a, other.b, r - eps));
+                for s in other.sides(r) {
+                    ts.extend(PathSeg::Line(s).intersect_line(line).into_iter().map(|x| x.line_t));
+                    if j < i {
+                        ts.extend(
+                            [s.p0, s.p1]
+                                .into_iter()
+                                .filter(|&p| distance_to_segment(p, line.p0, line.p1) <= eps)
+                                .map(|p| (p - line.p0).dot(line.p1 - line.p0) / (line.p1 - line.p0).hypot2()),
+                        );
+                        along.extend(capsule_span(line, s.p0, s.p1, eps));
+                    }
+                }
+            }
+            let (inside, along) = (merge_spans(inside), merge_spans(along));
+            ts.retain(|t| (0.0..=1.0).contains(t));
+            ts.sort_by(f64::total_cmp);
+            ts.dedup();
+            work += l.near.len() + others.len() + ts.len();
+            let mut pen = None;
+            for w in ts.windows(2) {
+                let (p, q) = (line.p0.lerp(line.p1, w[0]), line.p0.lerp(line.p1, w[1]));
+                let mid = 0.5 * (w[0] + w[1]);
+                let hidden = in_tiles(p.midpoint(q)) || spans_cover(&inside, mid, mid) || spans_cover(&along, w[0], w[1]);
+                if !hidden {
+                    push_seg(&mut out, &mut pen, PathSeg::Line(vectorcraft_geom::Line::new(p, q)));
+                }
+            }
+        }
+        (out, work)
+    }
+
+    /// The outline of the band's part in square `key`, less the parts along a side of the square
+    /// (within a thousandth of the radius) where the band goes on across that side: where the
+    /// square across it holds band area a thousandth of the radius past it.
+    fn tile_outline(&self, key: (i64, i64)) -> BezPath {
+        let Some(tile) = self.tiles.get(&key) else { return BezPath::new() };
+        let (rect, eps) = (self.tile_rect(key), 1e-3 * self.radius);
+        let (ix, iy) = key;
+        // A point's distance across a side (x for a side that runs up and down) and along it.
+        let split = |upright: bool, p: Point| if upright { (p.x, p.y) } else { (p.y, p.x) };
+        // Each side with band area across it: whether it runs up and down, where it runs, the
+        // direction away from this square, the area across, and where along the side that area's
+        // outline has a point on the side (where the area across can start or stop).
+        let sides: Vec<_> = [
+            (true, rect.x0, (ix - 1, iy), -1.0),
+            (true, rect.x1, (ix + 1, iy), 1.0),
+            (false, rect.y0, (ix, iy - 1), -1.0),
+            (false, rect.y1, (ix, iy + 1), 1.0),
+        ]
+        .into_iter()
+        .filter_map(|(upright, at, k, away)| {
+            let area = self.tiles.get(&k)?.area.to_bezpath();
+            let cuts: Vec<f64> = area
+                .segments()
+                .flat_map(|s| [s.start(), s.end()])
+                .map(|p| split(upright, p))
+                .filter(|&(off, _)| (off - at).abs() <= eps)
+                .map(|(_, along)| along)
+                .collect();
+            Some((upright, at, away, area, cuts))
+        })
+        .collect();
+        let mut out = BezPath::new();
+        let mut pen = None;
+        for seg in tile.area.to_bezpath().segments() {
+            let (a, b, mid) = (seg.start(), seg.end(), seg.eval(0.5));
+            let Some((upright, at, away, area, cuts)) = sides.iter().find(|s| [a, b, mid].iter().all(|&p| (split(s.0, p).0 - s.1).abs() <= eps))
+            else {
+                push_seg(&mut out, &mut pen, seg);
+                continue;
+            };
+            // The parts of the segment between the points where the area across starts or stops
+            // (more than `eps` from its ends), each kept unless the area across holds the point
+            // `eps` past the side beside it: the square across holds band area there exactly when
+            // its own edge of the band lies farther out than `eps`, and so shows.
+            let (la, lb) = (split(*upright, a).1, split(*upright, b).1);
+            let mut ts: Vec<f64> = cuts
+                .iter()
+                .filter(|&&c| (c - la) * (c - lb) < 0.0 && (c - la).abs() > eps && (c - lb).abs() > eps)
+                .map(|&c| (c - la) / (lb - la))
+                .collect();
+            ts.sort_by(f64::total_cmp);
+            let whole = ts.is_empty();
+            ts.insert(0, 0.0);
+            ts.push(1.0);
+            for w in ts.windows(2) {
+                let (p, q) = (a.lerp(b, w[0]), a.lerp(b, w[1]));
+                let m = if whole { mid } else { p.midpoint(q) };
+                let past = at + away * eps;
+                let probe = if *upright { Point::new(past, m.y) } else { Point::new(m.x, past) };
+                if vectorcraft_geom::Shape::winding(area, probe) != 0 {
+                    pen = None;
+                } else if whole {
+                    push_seg(&mut out, &mut pen, seg);
+                } else {
+                    push_seg(&mut out, &mut pen, PathSeg::Line(vectorcraft_geom::Line::new(p, q)));
+                }
+            }
+        }
+        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 `line_t` from and to (0 at its start, 1 at its end, and beyond),
+/// within `rad` of the segment from `a` to `b`; `None` when no point of the line is.
+fn capsule_span(line: vectorcraft_geom::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 = 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
+}
+
+/// Whether one of `spans` (from [`merge_spans`]) holds everything from `from` to `to`.
+fn spans_cover(spans: &[(f64, f64)], from: f64, to: f64) -> bool {
+    let i = spans.partition_point(|s| s.0 <= from);
+    i > 0 && spans.get(i - 1).is_some_and(|s| s.1 >= to)
 }
 
 /// The paths a stroke can redraw for selected object `id`: the path itself, or a compound path's
@@ -232,6 +838,8 @@ impl GestureTool {
             length: 0.0,
             area: Cell::new(None),
             area_pending: Cell::new(false),
+            band: Cell::new(None),
+            band_pending: Cell::new(false),
         }
     }
 
@@ -375,6 +983,56 @@ impl GestureTool {
         self.length = 0.0;
         self.area.set(None);
         self.area_pending.set(false);
+        self.band.set(None);
+        self.band_pending.set(false);
+    }
+
+    /// The outline of the band a smoothing drag smooths: every point within `radius` of the drag,
+    /// round at both ends. The band shown last is kept and grown by the steps dragged since, at
+    /// most [`BAND_STEP`] points at a time and [`BAND_STEPS_PER_CALL`] steps a call; a new radius
+    /// (the zoom changed) or another drag starts it again. While the band covers less of the drag
+    /// than it can, [`Tool::overlays_pending`] holds, so the host draws again and the band reaches
+    /// the whole drag with the pointer still. When a step cannot be added whole, its segments are
+    /// added one at a time: a segment longer than [`BAND_TILE_SAMPLES`] half squares is kept
+    /// outside the squares, and one whose outlines cannot be combined adds nothing. Either way the
+    /// band goes on past it. The work on such long segments stops for the call once
+    /// [`BAND_WORK_PER_CALL`] is spent, and the drag is added to the band only once the outline of
+    /// what it holds is finished.
+    fn smooth_band(&self, radius: f64) -> Option<BezPath> {
+        let pts = &self.points;
+        let &first = pts.first()?;
+        let mut b = self
+            .band
+            .take()
+            .filter(|b| b.radius == radius && b.first == first && b.used.checked_sub(1).and_then(|i| pts.get(i)) == Some(&b.last))
+            .unwrap_or_else(|| SmoothBand::new(first, radius));
+        b.work = 0;
+        let mut outline = b.outline();
+        if !b.changed {
+            for _ in 0..BAND_STEPS_PER_CALL {
+                let Some(from) = b.used.checked_sub(1).filter(|_| b.used < pts.len() && b.work < BAND_WORK_PER_CALL) else { break };
+                let mut to = (from + BAND_STEP).min(pts.len() - 1);
+                let Some(piece) = pts.get(from..=to) else { break };
+                if b.grow(piece).is_none() {
+                    for (k, w) in piece.windows(2).enumerate() {
+                        if b.work >= BAND_WORK_PER_CALL {
+                            to = from + k;
+                            break;
+                        }
+                        if b.too_long(w[0], w[1]) {
+                            b.add_long(w[0], w[1]);
+                        } else if b.grow(w).is_none() {
+                            b.last = w[1];
+                        }
+                    }
+                }
+                b.used = to + 1;
+            }
+            outline = b.outline();
+        }
+        self.band_pending.set(b.used < pts.len() || b.changed);
+        self.band.set(Some(b));
+        outline.filter(|o| !o.elements().is_empty())
     }
 
     /// Does the tool's Size take Fixed or Pressure (the Blob Brush and the Eraser)?
@@ -752,9 +1410,10 @@ impl Tool for GestureTool {
     fn wants_samples(&self) -> bool {
         matches!(self.id, "pencil" | "paintbrush" | "blobBrush" | "eraser" | "knife" | "smooth" | "pathEraser")
     }
-    /// The outline of a long Blob Brush or Eraser drag 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.area_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 {
@@ -807,12 +1466,21 @@ impl Tool for GestureTool {
     }
     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.
         if !self.active || self.points.len() < 2 || (self.began && self.previews()) {
             o.extend(self.tip_outline(cx));
             return o;
         }
+        // A smoothing drag with a selected path it can smooth also shows, dashed, the band its
+        // release smooths.
+        if (self.id == "smooth" || self.smoothing)
+            && has_selected_smooth_path(cx)
+            && let Some(path) = self.smooth_band(cx.tol(SMOOTH_RADIUS))
+        {
+            o.push(Overlay::Path { path, color: FEEDBACK, width: 1.0, dashed: true });
+        }
         // A Blob Brush drag that smooths shows the Smooth tool's thin line.
         let width = match self.id {
             "blobBrush" | "eraser" if !self.smoothing => (self.size * cx.zoom) as f32,
diff --git a/crates/tools/src/draw2/gesture/tests.rs b/crates/tools/src/draw2/gesture/tests.rs
index a49ecff1d9..eb2d9cfb32 100644
--- a/crates/tools/src/draw2/gesture/tests.rs
+++ b/crates/tools/src/draw2/gesture/tests.rs
@@ -1037,6 +1037,439 @@ fn pencil_alt_smooths_within_the_smooth_tools_radius() {
     }
 }
 
+/// The dashed paths among the overlays.
+fn bands(t: &GestureTool, cx: &ToolContext) -> Vec<vectorcraft_geom::BezPath> {
+    t.overlays(cx).into_iter().filter_map(|o| if let Overlay::Path { path, dashed: true, .. } = o { Some(path) } else { None }).collect()
+}
+
+/// How far `q` is from the polyline through `pts`.
+fn dist_to_drag(q: Point, pts: &[Point]) -> f64 {
+    pts.windows(2)
+        .map(|w| {
+            let ab = w[1] - w[0];
+            let t = if ab.hypot2() > 0.0 { ((q - w[0]).dot(ab) / ab.hypot2()).clamp(0.0, 1.0) } else { 0.0 };
+            q.distance(w[0] + ab * t)
+        })
+        .fold(f64::INFINITY, f64::min)
+}
+
+/// Check the band a smoothing drag through the tool's points shows at radius `r`: one dashed path,
+/// every point of which is `r` from the drag, around an area that holds every point nearer than `r`
+/// and none farther. Returns the path.
+fn check_band(t: &GestureTool, cx: &ToolContext, r: f64) -> vectorcraft_geom::BezPath {
+    use vectorcraft_geom::kurbo::Shape;
+    let pts = &t.points;
+    let found = bands(t, cx);
+    let [outline] = found.as_slice() else { panic!("one band, got {found:?}") };
+    for seg in outline.segments() {
+        for s in [0.0, 0.25, 0.5, 0.75, 1.0] {
+            let q = seg.eval(s);
+            let dq = dist_to_drag(q, pts);
+            assert!((dq - r).abs() < 0.02 * r, "{q:?} on the outline is {dq} from the drag, radius {r}");
+        }
+    }
+    let kept = t.band.take();
+    let areas: Vec<_> = kept.iter().flat_map(|b| b.tiles.values().map(|t| t.area.to_bezpath())).collect();
+    t.band.set(kept);
+    let b = outline.bounding_box();
+    let mut probes = 0;
+    for i in 0..=80 {
+        for j in 0..=80 {
+            let q = Point::new(b.x0 - r + (b.width() + 2.0 * r) * f64::from(i) / 80.0, b.y0 - r + (b.height() + 2.0 * r) * f64::from(j) / 80.0);
+            let dq = dist_to_drag(q, pts);
+            let inside = areas.iter().any(|a| a.contains(q));
+            if dq < 0.97 * r {
+                assert!(inside, "{q:?} {dq} from the drag is inside the band, radius {r}");
+                probes += 1;
+            } else if dq > 1.03 * r {
+                assert!(!inside, "{q:?} {dq} from the drag is outside the band, radius {r}");
+            }
+        }
+    }
+    assert!(probes > 100, "{probes}");
+    outline.clone()
+}
+
+/// While a smoothing drag has a selected path to smooth, it shows dashed the band its release smooths:
+/// everything within the radius it sends of the drag, round at both ends, around the drag's thin
+/// line. Alt smoothing with the Pencil, Paintbrush and Blob Brush shows it too; a drag with nothing
+/// selected and a Blob Brush stroke that paints do not.
+#[test]
+fn smoothing_drag_shows_the_band_it_smooths() {
+    use vectorcraft_geom::kurbo::{ParamCurveArclen, Shape};
+    let (d, id) = doc_with_rect();
+    let mut s = Selection::default();
+    s.set([id]);
+    let none = Selection::default();
+    let p = paint();
+    let alt = Mods { alt: true, ..Default::default() };
+    let pts = [(50.0, 150.0), (150.0, 150.0)];
+    for zoom in [1.0, 2.0, 0.5, 200.0] {
+        let mut cx = cx(&d, &s, &p);
+        cx.smart_guides = false;
+        cx.zoom = zoom;
+        let r = match drag(&mut GestureTool::new("smooth"), &cx, &pts, Mods::default()).last().and_then(|a| a.first()) {
+            Some(Action::Exec(c, v)) if c == "path.smoothRegion" => v["radius"].as_f64().unwrap_or(0.0),
+            a => panic!("expected path.smoothRegion, got: {a:?}"),
+        };
+        for (id, alt_smooth, m) in [("smooth", false, Mods::default()), ("pencil", true, alt), ("paintbrush", false, alt), ("blobBrush", false, alt)]
+        {
+            let mut t = GestureTool::new(id);
+            t.set_option("altSmooth", &json!(alt_smooth));
+            t.pointer(&cx, &PointerEvent::new(PointerKind::Down, pts[0].0, pts[0].1).with_mods(m));
+            t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, pts[1].0, pts[1].1).with_mods(m));
+            let band = check_band(&t, &cx, r);
+            let b = band.bounding_box();
+            let near = |a: f64, w: f64| (a - w).abs() < 0.02 * r;
+            assert!(near(b.x0, 50.0 - r) && near(b.x1, 150.0 + r) && near(b.y0, 150.0 - r) && near(b.y1, 150.0 + r), "{id} at zoom {zoom}: {b:?}");
+            // The whole outline shows: two sides and two half circles.
+            let length: f64 = band.segments().map(|s| s.arclen(1e-6 * r)).sum();
+            let want = 200.0 + 2.0 * std::f64::consts::PI * r;
+            assert!((length - want).abs() < 0.02 * want, "{id} at zoom {zoom}: outline {length}, band {want}");
+            assert!(
+                t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Path { width, dashed: false, .. } if *width == 1.0)),
+                "{id}: the drag's line"
+            );
+        }
+        // Nothing selected: the release smooths nothing, so no band shows.
+        let mut empty = crate::testutil::cx(&d, &none, &p);
+        empty.zoom = zoom;
+        let mut t = GestureTool::new("smooth");
+        t.pointer(&empty, &PointerEvent::new(PointerKind::Down, pts[0].0, pts[0].1));
+        t.pointer(&empty, &PointerEvent::new(PointerKind::Drag, pts[1].0, pts[1].1));
+        assert!(bands(&t, &empty).is_empty());
+        // A Blob Brush stroke that paints shows its own area, not the band.
+        let mut t = GestureTool::new("blobBrush");
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, pts[0].0, pts[0].1));
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, pts[1].0, pts[1].1));
+        assert!(bands(&t, &cx).is_empty());
+    }
+}
+
+/// The band shown while a long drag goes on, grown step by step, is one outline that holds every
+/// point within the radius of the drag and none farther, whether the drag crosses itself or runs
+/// on across the page; a zoom change mid-drag with the pointer still asks for frames until the band
+/// covers the whole drag at the new radius, and the next drag does not keep the last one's band.
+#[test]
+fn smoothing_band_follows_a_long_drag() {
+    use vectorcraft_geom::kurbo::Shape;
+    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;
+    // A curve that crosses itself, and one that runs on across the page.
+    let crossing: Vec<Point> =
+        (0..240).map(|i| f64::from(i) * 0.05).map(|a| Point::new(250.0 + 80.0 * (a * 1.3).sin(), 250.0 + 60.0 * (a * 0.7).cos())).collect();
+    let across: Vec<Point> =
+        (0..900).map(f64::from).map(|i| Point::new(20.0 + 0.5 * i, 250.0 + 100.0 * (i * 0.05).sin() + 30.0 * (i * 0.37).sin())).collect();
+    for pts in [crossing, across] {
+        cx.zoom = 1.0;
+        let mut t = GestureTool::new("smooth");
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, pts[0].x, pts[0].y));
+        for q in &pts[1..] {
+            t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, q.x, q.y));
+            assert_eq!(bands(&t, &cx).len(), 1);
+        }
+        check_band(&t, &cx, cx.tol(12.0));
+        assert!(!t.overlays_pending(), "the band covers the drag");
+        // The view zooms in mid-drag while the pointer holds still: the tool asks for frames until
+        // the band covers the whole drag at the new radius.
+        cx.zoom = 2.0;
+        let mut frames = 1;
+        bands(&t, &cx);
+        while t.overlays_pending() {
+            assert!(frames <= pts.len(), "the band reaches the whole drag");
+            bands(&t, &cx);
+            frames += 1;
+        }
+        let n = t.points.len();
+        assert_eq!(frames, (n - 1).div_ceil(BAND_STEP * BAND_STEPS_PER_CALL), "frames for {n} points");
+        check_band(&t, &cx, cx.tol(12.0));
+        assert!(!t.overlays_pending());
+        let last = pts[pts.len() - 1];
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Up, last.x, last.y));
+        // The next drag shows only its own band.
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 400.0, 450.0));
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 420.0, 450.0));
+        let b = check_band(&t, &cx, cx.tol(12.0)).bounding_box();
+        assert!(b.x0 > 390.0 && b.y0 > 440.0, "{b:?}");
+    }
+}
+
+/// A segment of a drag too long for the squares at the current zoom (a jump drawn zoomed out,
+/// viewed zoomed in, or one reaching far off the page) shows as the two sides of its band, and the
+/// band goes on past it: the parts dragged before and after it show, and nothing stays pending.
+/// Two such segments that cross show no edge inside each other's band, and one that runs back
+/// along another shows its sides once.
+#[test]
+fn smoothing_band_shows_a_segment_too_long_for_its_squares() {
+    use vectorcraft_geom::kurbo::{ParamCurveArclen, Shape};
+    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 before = [Point::new(100.0, 100.0), Point::new(130.0, 100.0)];
+    let after = [Point::new(20_100.0, 100.0), Point::new(20_100.0, 130.0), Point::new(20_130.0, 130.0)];
+    let far = [Point::new(1e17, 100.0)];
+    let crossing = [(100.0, 100.0), (30_100.0, 100.0), (30_100.0, 130.0), (15_100.0, -20_000.0), (15_130.0, -20_000.0)].map(Point::from);
+    let back = [(100.0, 100.0), (30_100.0, 100.0), (130.0, 100.0)].map(Point::from);
+    for (case, pts) in [
+        ("jump", [&before[..], &after[..]].concat()),
+        ("far", [&before[..], &far[..], &after[..]].concat()),
+        ("crossing", crossing.to_vec()),
+        ("back", back.to_vec()),
+    ] {
+        // Drawn zoomed out, where the jump is about 42 half squares, then viewed at 1,000%, where
+        // it is more than 4,096.
+        cx.zoom = 0.1;
+        let mut t = GestureTool::new("smooth");
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Down, pts[0].x, pts[0].y));
+        for q in &pts[1..] {
+            t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, q.x, q.y));
+            bands(&t, &cx);
+        }
+        cx.zoom = 10.0;
+        let r = cx.tol(12.0);
+        let mut frames = 0;
+        let mut found = bands(&t, &cx);
+        while t.overlays_pending() {
+            assert!(frames < pts.len(), "{case}: the band reaches the whole drag");
+            found = bands(&t, &cx);
+            frames += 1;
+        }
+        let [outline] = found.as_slice() else { panic!("{case}: one band, got {found:?}") };
+        for seg in outline.segments() {
+            for s in [0.0, 0.25, 0.5, 0.75, 1.0] {
+                let q = seg.eval(s);
+                let dq = dist_to_drag(q, &pts);
+                assert!((dq - r).abs() < 0.02 * r, "{case}: {q:?} on the outline is {dq} from the drag, radius {r}");
+            }
+        }
+        // The band of each long segment shows on both of its sides, as far as the release reaches,
+        // except where the band of another part of the drag holds the side (on the page: a point
+        // on a segment to 1e17 resolves only to about 10 units).
+        let on_outline = |q: Point| {
+            outline.segments().any(|seg| {
+                (0..=8).any(|k| seg.eval(f64::from(k) / 8.0).distance(q) < 0.02 * r) || dist_to_drag(q, &[seg.start(), seg.end()]) < 0.02 * r
+            })
+        };
+        for w in pts.windows(2).filter(|w| w[0].distance(w[1]) > 10_000.0 && w[0].x < 1e6 && w[1].x < 1e6) {
+            let d = w[1] - w[0];
+            let n = vectorcraft_geom::kurbo::Vec2::new(-d.y, d.x) * (r / d.hypot());
+            for k in 1..40 {
+                for q in [w[0].lerp(w[1], f64::from(k) / 40.0) + n, w[0].lerp(w[1], f64::from(k) / 40.0) - n] {
+                    if dist_to_drag(q, &pts) > 0.98 * r {
+                        assert!(on_outline(q), "{case}: {q:?} on a side of {w:?} shows");
+                    }
+                }
+            }
+        }
+        if case == "back" {
+            // Running back along the jump draws its sides once: two sides and two half circles.
+            let length: f64 = outline.segments().map(|s| s.arclen(1e-6 * r)).sum();
+            let want = 2.0 * 30_000.0 + 2.0 * std::f64::consts::PI * r;
+            assert!((length - want).abs() < 0.01 * want, "{case}: outline {length}, band {want}");
+        }
+        let kept = t.band.take();
+        let areas: Vec<_> = kept.iter().flat_map(|b| b.tiles.values().map(|t| t.area.to_bezpath())).collect();
+        t.band.set(kept);
+        // Every point near each short part dragged on either side of a long segment is in the band.
+        for w in pts.windows(2).filter(|w| w[0].distance(w[1]) < 1_000.0) {
+            for q in (0..=20).map(|k| w[0].lerp(w[1], f64::from(k) / 20.0)) {
+                for (dx, dy) in [(0.0, 0.0), (0.9, 0.0), (-0.9, 0.0), (0.0, 0.9), (0.0, -0.9)] {
+                    let probe = q + vectorcraft_geom::kurbo::Vec2::new(dx * r, dy * r);
+                    assert!(areas.iter().any(|a| a.contains(probe)), "{case}: {probe:?} near the drag is in the band");
+                }
+            }
+        }
+    }
+}
+
+/// A drag drawn zoomed out whose every segment is too long for the squares once the view zooms in,
+/// and whose segments all cross one another, is outlined over several calls: no call does more
+/// than about [`BAND_WORK_PER_CALL`] of work on the long segments, and the band then shows in full.
+#[test]
+fn smoothing_band_of_many_long_segments_is_made_in_bounded_calls() {
+    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;
+    // A star whose chords nearly all pass through its middle, 4,000 units each.
+    let step = std::f64::consts::PI * (1.0 - 1.0 / 40.3);
+    let pts: Vec<Point> = (0..161).map(|k| f64::from(k) * step).map(|a| Point::new(5000.0 + 2000.0 * a.cos(), 5000.0 + 2000.0 * a.sin())).collect();
+    cx.zoom = 0.05;
+    let mut t = GestureTool::new("smooth");
+    t.pointer(&cx, &PointerEvent::new(PointerKind::Down, pts[0].x, pts[0].y));
+    for q in &pts[1..] {
+        t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, q.x, q.y));
+        bands(&t, &cx);
+    }
+    cx.zoom = 640.0;
+    let r = cx.tol(SMOOTH_RADIUS);
+    let work = |t: &GestureTool| {
+        let kept = t.band.take();
+        let w = kept.as_ref().map_or(0, |b| b.work);
+        t.band.set(kept);
+        w
+    };
+    let mut found = bands(&t, &cx);
+    let mut frames = 1;
+    let mut most = work(&t);
+    while t.overlays_pending() {
+        assert!(frames < 10_000, "the band reaches the whole drag");
+        found = bands(&t, &cx);
+        most = most.max(work(&t));
+        frames += 1;
+    }
+    assert!(most <= 2 * BAND_WORK_PER_CALL, "{most} work in one call");
+    assert!(frames > 2, "{frames} calls");
+    let kept = t.band.take();
+    let long = kept.as_ref().map_or(0, |b| b.long.len());
+    t.band.set(kept);
+    assert_eq!(long, pts.len() - 1, "every segment is long");
+    let [outline] = found.as_slice() else { panic!("one band, got {}", found.len()) };
+    for seg in outline.segments().step_by(7) {
+        for s in [0.0, 0.5, 1.0] {
+            let q = seg.eval(s);
+            let dq = dist_to_drag(q, &pts);
+            assert!((dq - r).abs() < 0.02 * r, "{q:?} on the outline is {dq} from the drag, radius {r}");
+        }
+    }
+}
+
+/// The band is kept in squares; a straight drag whose band edge runs along a side of a square, or
+/// just inside or outside it, still shows that edge, and the sides between two squares the band
+/// fills do not show.
+#[test]
+fn smoothing_band_shows_an_edge_along_a_square_side() {
+    use vectorcraft_geom::kurbo::{ParamCurveArclen, Shape};
+    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;
+    for zoom in [1.0, 3.0] {
+        cx.zoom = zoom;
+        let r = cx.tol(SMOOTH_RADIUS);
+        let side = BAND_TILE_RADII * r;
+        // A side of the squares near 230 (across and down: the grid is square).
+        let at = (BAND_TILE_OFFSET + (230.0 / side - BAND_TILE_OFFSET).round()) * side;
+        let eps = 1e-3 * r;
+        for off in [0.0, 0.5 * eps, -0.5 * eps, 1.5 * eps, -1.5 * eps] {
+            for (edge, upright) in [(-r, false), (r, false), (-r, true), (r, true)] {
+                let c = at + edge + off;
+                let ends = if upright {
+                    [Point::new(c, 100.0), Point::new(c, 100.0 + 2.5 * side)]
+                } else {
+                    [Point::new(100.0, c), Point::new(100.0 + 2.5 * side, c)]
+                };
+                let mut t = GestureTool::new("smooth");
+                t.pointer(&cx, &PointerEvent::new(PointerKind::Down, ends[0].x, ends[0].y));
+                for i in 1..=20 {
+                    let q = ends[0].lerp(ends[1], f64::from(i) / 20.0);
+                    t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, q.x, q.y));
+                }
+                let band = check_band(&t, &cx, r);
+                // Two sides and two half circles, each shown once.
+                let length: f64 = band.segments().map(|s| s.arclen(1e-6 * r)).sum();
+                let want = 2.0 * 2.5 * side + 2.0 * std::f64::consts::PI * r;
+                assert!(
+                    (length - want).abs() < 0.02 * want,
+                    "zoom {zoom}, edge {edge}, off {off}, upright {upright}: outline {length}, band {want}, {:?}",
+                    band.bounding_box()
+                );
+            }
+        }
+    }
+}
+
+/// A drag whose band edge runs along a side of a square and then turns across it shows the edge
+/// up to the turn and no line where the band goes on across the side.
+#[test]
+fn smoothing_band_shows_no_seam_where_it_turns_across_a_square_side() {
+    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;
+    for zoom in [1.0, 3.0] {
+        cx.zoom = zoom;
+        let r = cx.tol(SMOOTH_RADIUS);
+        let side = BAND_TILE_RADII * r;
+        let at = (BAND_TILE_OFFSET + (230.0 / side - BAND_TILE_OFFSET).round()) * side;
+        let eps = 1e-3 * r;
+        for off in [0.0, 0.5 * eps, -0.5 * eps] {
+            for (edge, upright) in [(-r, false), (r, false), (-r, true), (r, true)] {
+                let c = at + edge + off;
+                // Along the side, then across it.
+                let turn = 100.0 + 1.5 * side;
+                let corners = [(100.0, c), (turn, c), (turn, c - edge.signum() * 2.0 * side)];
+                let pts: Vec<Point> = corners.into_iter().map(|(u, v)| if upright { Point::new(v, u) } else { Point::new(u, v) }).collect();
+                let mut t = GestureTool::new("smooth");
+                t.pointer(&cx, &PointerEvent::new(PointerKind::Down, pts[0].x, pts[0].y));
+                for w in pts.windows(2) {
+                    for i in 1..=12 {
+                        let q = w[0].lerp(w[1], f64::from(i) / 12.0);
+                        t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, q.x, q.y));
+                    }
+                }
+                check_band(&t, &cx, r);
+            }
+        }
+    }
+}
+
+/// One straight piece of a square's outline along a side, where the band goes on across only part
+/// of it, shows only the part with nothing across.
+#[test]
+fn smoothing_band_square_shows_only_the_open_part_of_a_side() {
+    use vectorcraft_geom::kurbo::{ParamCurveArclen, Shape};
+    let mut band = SmoothBand::new(Point::ZERO, 10.0);
+    let r = band.tile_rect((0, 0));
+    let (x, y) = (r.x0, r.y1);
+    let area = |x0: f64, y0: f64, x1: f64, y1: f64| vectorcraft_geom::shapes::rectangle(Rect::new(x0, y0, x1, y1));
+    let tile = |area| BandTile { area, outline: vectorcraft_geom::BezPath::new(), near_long: vec![], cut: vectorcraft_geom::BezPath::new() };
+    // Along the bottom side from 10 to 60, with the band across it from 40 to 60.
+    band.tiles.insert((0, 0), tile(area(x + 10.0, y - 20.0, x + 60.0, y)));
+    band.tiles.insert((0, 1), tile(area(x + 40.0, y, x + 60.0, y + 20.0)));
+    let outline = band.tile_outline((0, 0));
+    let along: f64 = outline.segments().filter(|s| s.bounding_box().height() < 1e-9 && (s.start().y - y).abs() < 1e-9).map(|s| s.arclen(1e-9)).sum();
+    assert!((along - 30.0).abs() < 1e-6, "{along} of the side shows: {}", outline.to_svg());
+    for s in outline.segments() {
+        assert!(!((s.start().y - y).abs() < 1e-9 && (s.end().y - y).abs() < 1e-9 && s.start().x.max(s.end().x) > x + 40.0 + 1e-9), "{s:?}");
+    }
+}
+
+/// A selection with no path the Smooth tool can change (a two-anchor line) shows no band.
+#[test]
+fn smoothing_drag_shows_no_band_without_a_path_it_smooths() {
+    let (mut d, _) = doc_with_rect();
+    let l = d.layers[0].id;
+    let id = d.alloc_id();
+    let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
+        vectorcraft_geom::PathEl::MoveTo(Point::new(300.0, 300.0)),
+        vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
+    ]));
+    d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
+    let mut s = Selection::default();
+    s.set([id]);
+    let p = paint();
+    let cx = cx(&d, &s, &p);
+    let mut t = GestureTool::new("smooth");
+    t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 300.0, 300.0));
+    t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 400.0, 300.0));
+    let o = t.overlays(&cx);
+    assert!(!o.iter().any(|o| matches!(o, Overlay::Path { dashed: true, .. })), "{o:?}");
+}
+
 /// An Alt smoothing drag uses the Smooth tool's Fidelity for Pencil, Paintbrush and Blob Brush.
 #[test]
 fn alt_smoothing_uses_the_smooth_tools_fidelity() {
@@ -1665,7 +2098,7 @@ fn the_eraser_sends_its_tip_and_shows_the_area_it_covers() {
 /// The Blob Brush's Angle and Roundness (Blob Brush Tool Options, 0° and 100% by default) go with
 /// its stroke, kept within −180–180° and 0–100%; while it drags, a tip that is not round shows the
 /// outline of the area it covers with the length label, and an Alt drag that smooths shows the
-/// Smooth tool's thin line.
+/// Smooth tool's thin line and the dashed band it smooths.
 #[test]
 fn the_blob_brush_sends_its_tip_and_shows_the_area_it_covers() {
     let (d, id) = doc_with_rect();
@@ -1704,7 +2137,7 @@ fn the_blob_brush_sends_its_tip_and_shows_the_area_it_covers() {
     t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 50.0, 150.0).with_mods(alt));
     t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0).with_mods(alt));
     let o = t.overlays(&cx);
-    let [Overlay::Path { path, width, .. }] = &o[..] else { panic!("{o:?}") };
+    let [Overlay::Path { dashed: true, .. }, Overlay::Path { path, width, dashed: false, .. }] = &o[..] else { panic!("{o:?}") };
     assert_eq!(*width, 1.0);
     assert!(vectorcraft_geom::Shape::bounding_box(path).height() < 0.1, "{o:?}");
 }
diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs
index 75a0bfe108..d46a7fd972 100644
--- a/crates/tools/src/lib.rs
+++ b/crates/tools/src/lib.rs
@@ -137,8 +137,8 @@ pub trait Tool: Send {
         vec![]
     }
     /// Did the last [`Tool::overlays`] leave part of its overlays for later calls (the outline of a
-    /// long Blob Brush or Eraser drag)? The host then draws again on the next frame, even when the
-    /// pointer holds still.
+    /// 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/group.rs b/crates/trace/src/group.rs
index b51ae57907..a0e3b85020 100644
--- a/crates/trace/src/group.rs
+++ b/crates/trace/src/group.rs
@@ -420,13 +420,13 @@ mod tests {
 
     #[test]
     fn a_dense_trace_is_grouped_with_a_few_box_tests_per_path() {
-        let img = noise(120, 120);
+        let img = noise(150, 150);
         for (method, stacked) in [(crate::Method::Abutting, false), (crate::Method::Overlapping, true)] {
             let paths = traced(&img, method);
             let n = paths.len();
             let counted = |by_pairs: bool| {
                 BOX_TESTS.with(|n| n.set(0));
-                let found = if by_pairs { parents_by_pairs(&paths, 120, 120, stacked) } else { parents(&paths, 120, 120, stacked) };
+                let found = if by_pairs { parents_by_pairs(&paths, 150, 150, stacked) } else { parents(&paths, 150, 150, stacked) };
                 (found, BOX_TESTS.with(std::cell::Cell::get))
             };
             let (found, tests) = counted(false);
diff --git a/crates/trace/src/quantize.rs b/crates/trace/src/quantize.rs
index 9452671def..f5a2d9fa47 100644
--- a/crates/trace/src/quantize.rs
+++ b/crates/trace/src/quantize.rs
@@ -8,7 +8,7 @@ mod denoise;
 mod palette;
 mod rare;
 
-use cut_edge::{choosing_pixels, compact, settled};
+use cut_edge::{choosing_pixels, compact, settled, settled_wide, settles_wide};
 pub(crate) use cut_edge::{continuous_tone, settle_cut_edges};
 pub use denoise::denoise;
 pub(crate) use denoise::denoise_keeping;
@@ -91,7 +91,8 @@ pub(crate) fn quantize_keeping(img: &Raster, params: &TraceParams) -> (Quantized
                 let g = l.round().clamp(0.0, 255.0) as u8;
                 [g, g, g]
             });
-            (settled(merge_mixed(compact(labels, palette.collect()), img.width as usize, img.height as usize, &[]), img, &own), vec![])
+            let q = merge_mixed(compact(labels, palette.collect()), img.width as usize, img.height as usize, &[]);
+            (if settles_wide(params) { settled_wide(q, img, &own, true) } else { settled(q, img, &own) }, vec![])
         }
         // Logo mode traces without quantising; asked directly, it quantises like Color.
         Mode::Color | Mode::Logo => {
@@ -170,7 +171,7 @@ pub(crate) fn quantize_keeping(img: &Raster, params: &TraceParams) -> (Quantized
                 if library { q } else { merge_mixed(q, img.width as usize, img.height as usize, &rare) }
             };
             let q = reduce(params.colors);
-            let q = settled(q, img, &own);
+            let q = if settles_wide(params) { settled_wide(q, img, &own, false) } else { settled(q, img, &own) };
             rare.retain(|c| q.palette.contains(c));
             (q, rare)
         }
diff --git a/crates/trace/src/quantize/cut_edge.rs b/crates/trace/src/quantize/cut_edge.rs
index 22e5c02af2..99b3c42845 100644
--- a/crates/trace/src/quantize/cut_edge.rs
+++ b/crates/trace/src/quantize/cut_edge.rs
@@ -1,5 +1,5 @@
 use super::palette::{Bin, HistKey, Used, centers, median_cut, nearest_lab};
-use super::{Quantized, Raster, TRANSPARENT, luma, oklab};
+use super::{Mode, Palette, Quantized, Raster, TRANSPARENT, TraceParams, luma, oklab};
 
 /// `q` with its blend pixels settled, and the colours that leaves unused dropped.
 ///
@@ -65,6 +65,214 @@ pub(super) fn settled(mut q: Quantized, img: &Raster, own: &[bool]) -> Quantized
     if changed { compact(q.labels, q.palette) } else { q }
 }
 
+/// The most colors (Color) or grays (Grayscale) a palette may ask for to have its blend pixels
+/// settled by [`settled_wide`] rather than [`settled`]. The limited-color presets ask for 3 to 16
+/// colors.
+const LIMITED_COLORS: u32 = 16;
+
+/// Whether a trace with `params` settles its blend pixels with [`settled_wide`]: Grayscale, and
+/// Color with a Limited palette, of at most [`LIMITED_COLORS`] colors.
+pub(super) fn settles_wide(params: &TraceParams) -> bool {
+    match params.mode {
+        Mode::Grayscale => params.colors <= LIMITED_COLORS,
+        Mode::Color | Mode::Logo => params.palette == Palette::Limited && params.colors <= LIMITED_COLORS,
+        Mode::BlackAndWhite => false,
+    }
+}
+
+/// How far (px, across, along or diagonally) [`settled_wide`] looks for the picture's own pixels
+/// around a blend pixel: blur spreads an edge over several pixels, and its two sides can lie this
+/// far apart.
+const BLEND_REACH: usize = 8;
+
+/// How far (px, across, along or diagonally) an own pixel of its color keeps a blend pixel's color
+/// in [`settled_wide`]: where three colors meet, the blend is of its color too.
+const OWN_NEAR: usize = 4;
+
+/// How many of the colors within reach of a blend pixel, nearest to its color first,
+/// [`settled_wide`] pairs up.
+const NEAR_COLORS: usize = 8;
+
+/// How many columns at a time [`settled_wide`] keeps the colors within reach for, so that its
+/// memory does not grow with the width of the picture.
+const BLEND_STRIP: usize = 7;
+
+/// How far apart (squared levels) the distances of a blend pixel off the lines between two pairs
+/// of colors may be for [`settled_wide`] to count them as equal: rounding leaves a gray that lies
+/// between two grays about 1e-28 off the line between them.
+const SAME_FIT: f64 = 1e-6;
+
+/// How much nearer (squared) to the line between a pair of colors than to its own color a blend
+/// pixel must lie for [`settled_wide`] to settle it: half as far, as [`settled`] asks.
+const BETTER_FIT: f64 = 0.25;
+
+/// How far off the line between a pair of colors (as a share of their distance apart) a blend pixel
+/// that lies between the two may be for [`settled_wide`] to settle it whatever its own color.
+const ON_THE_LINE: f64 = 0.15;
+
+/// [`settled`] for a limited palette (see [`settles_wide`]), which also settles the in-between
+/// tones of an edge blurred over several pixels: without it they trace as a ring of a third color
+/// around the edge.
+///
+/// A blend pixel (see [`own_colours`]) whose color is none of those of the picture's own pixels
+/// within [`OWN_NEAR`] pixels of it takes the side it is nearer to of the pair of the colors of own
+/// pixels within [`BLEND_REACH`] pixels that it is best a blend of (of two pairs that explain it
+/// equally well, the closer one), when that explains it twice as well as its own color does, or
+/// when it lies between the two and off the line between them by less than [`ON_THE_LINE`] of
+/// their distance apart. Only the [`NEAR_COLORS`] colors nearest to its color are paired. It keeps
+/// its own color when that color is one of the pair, or when one color is all there is around it.
+/// With `gray` (Grayscale), a pixel's color is its gray (see [`luma`]).
+pub(super) fn settled_wide(mut q: Quantized, img: &Raster, own: &[bool], gray: bool) -> Quantized {
+    let (w, h) = (img.width as usize, img.height as usize);
+    if q.labels.len() != w * h || own.len() != w * h {
+        return q;
+    }
+    let before = q.labels.clone();
+    let colors: Vec<[f64; 3]> = q.palette.iter().map(|c| c.map(f64::from)).collect();
+    let dist2 = |a: [f64; 3], b: [f64; 3]| (0..3).map(|k| (a[k] - b[k]).powi(2)).sum::<f64>();
+    // The colors of the own pixels within reach of each pixel, as bits (one word per 64 palette
+    // colors), a strip of columns at a time: along its row for the rows within reach (a window
+    // sliding along each row, kept for the last 2 × reach + 1 rows), then across those rows.
+    let words = q.palette.len().div_ceil(64).max(1);
+    let span = 2 * BLEND_REACH + 1;
+    let strip = BLEND_STRIP.min(w);
+    let mut rows = vec![0u64; span * strip * words];
+    let mut counts = vec![0u32; q.palette.len()];
+    let mut window = vec![0u64; words];
+    let mut bits = vec![0u64; words];
+    // The bits of row `y` for the columns `x0..x1` (at most `strip` of them).
+    let mut row_colors = |y: usize, x0: usize, x1: usize, rows: &mut [u64]| {
+        let Some(out) = rows.get_mut((y % span) * strip * words..(y % span + 1) * strip * words) else { return };
+        counts.fill(0);
+        window.fill(0);
+        // The own pixel at `x` enters the window (`add`) or leaves it.
+        let step = |counts: &mut [u32], window: &mut [u64], x: usize, add: bool| {
+            let i = y * w + x;
+            let l = before[i] as usize;
+            if !own[i] || l >= counts.len() {
+                return;
+            }
+            if add {
+                counts[l] += 1;
+                window[l / 64] |= 1 << (l % 64);
+            } else {
+                counts[l] -= 1;
+                if counts[l] == 0 {
+                    window[l / 64] &= !(1 << (l % 64));
+                }
+            }
+        };
+        let first = x0.saturating_sub(BLEND_REACH);
+        for x in first..(x0 + BLEND_REACH).min(w) {
+            step(&mut counts, &mut window, x, true);
+        }
+        for x in x0..x1 {
+            if x + BLEND_REACH < w {
+                step(&mut counts, &mut window, x + BLEND_REACH, true);
+            }
+            if let Some(gone) = x.checked_sub(BLEND_REACH + 1).filter(|&g| g >= first) {
+                step(&mut counts, &mut window, gone, false);
+            }
+            if let Some(o) = out.get_mut((x - x0) * words..(x - x0 + 1) * words) {
+                o.copy_from_slice(&window);
+            }
+        }
+    };
+    let mut changed = false;
+    let mut near: Vec<u16> = Vec::new();
+    let mut by_distance: Vec<(f64, u16)> = Vec::new();
+    let pixel = |p: &[u8]| if gray { [f64::from(luma([p[0], p[1], p[2], p[3]])); 3] } else { [f64::from(p[0]), f64::from(p[1]), f64::from(p[2])] };
+    for (x0, y) in (0..w).step_by(strip.max(1)).flat_map(|x0| (0..h).map(move |y| (x0, y))) {
+        let x1 = (x0 + strip).min(w);
+        if y == 0 {
+            for yy in 0..BLEND_REACH.min(h) {
+                row_colors(yy, x0, x1, &mut rows);
+            }
+        }
+        if y + BLEND_REACH < h {
+            row_colors(y + BLEND_REACH, x0, x1, &mut rows);
+        }
+        'pixels: for x in x0..x1 {
+            let i = y * w + x;
+            let mine_l = before[i];
+            if own[i] || mine_l == TRANSPARENT {
+                continue;
+            }
+            // Its color is the picture's own here.
+            for yy in y.saturating_sub(OWN_NEAR)..=(y + OWN_NEAR).min(h - 1) {
+                for xx in x.saturating_sub(OWN_NEAR)..=(x + OWN_NEAR).min(w - 1) {
+                    if own[yy * w + xx] && before[yy * w + xx] == mine_l {
+                        continue 'pixels;
+                    }
+                }
+            }
+            bits.fill(0);
+            for yy in y.saturating_sub(BLEND_REACH)..=(y + BLEND_REACH).min(h - 1) {
+                let at = (yy % span) * strip * words + (x - x0) * words;
+                for (b, r) in bits.iter_mut().zip(rows.get(at..at + words).unwrap_or_default()) {
+                    *b |= r;
+                }
+            }
+            near.clear();
+            for (k, &b) in bits.iter().enumerate() {
+                let mut b = b;
+                while b != 0 {
+                    let l = (k * 64 + b.trailing_zeros() as usize) as u16;
+                    b &= b - 1;
+                    near.push(l);
+                }
+            }
+            let (Some(p), Some(&mine)) = (img.rgba.get(i * 4..i * 4 + 4).map(pixel), colors.get(mine_l as usize)) else {
+                continue;
+            };
+            if near.iter().filter(|&&l| l != mine_l).count() < 2 {
+                continue;
+            }
+            // In busy art many colors lie within reach: only the ones nearest to its color are paired.
+            // Each distance is worked out once, and only the nearest few are sorted (nearest first,
+            // then by index).
+            if near.len() > NEAR_COLORS {
+                by_distance.clear();
+                by_distance.extend(near.iter().map(|&l| (colors.get(l as usize).map_or(f64::INFINITY, |&c| dist2(p, c)), l)));
+                let order = |a: &(f64, u16), b: &(f64, u16)| a.0.total_cmp(&b.0).then(a.1.cmp(&b.1));
+                by_distance.select_nth_unstable_by(NEAR_COLORS, order);
+                by_distance.truncate(NEAR_COLORS);
+                by_distance.sort_unstable_by(order);
+                near.clear();
+                near.extend(by_distance.iter().map(|&(_, l)| l));
+            }
+            // The pair it is best a blend of, by the square of how far it lies off the line between them,
+            // and of two pairs it lies equally far off, the closer pair (in grays it lies on the line
+            // between every pair of grays darker and lighter than it).
+            let mut best: Option<(f64, [u16; 2], u16, f64, bool)> = None;
+            for (n, &a) in near.iter().enumerate() {
+                let Some(&ca) = colors.get(a as usize) else { continue };
+                let pa = [p[0] - ca[0], p[1] - ca[1], p[2] - ca[2]];
+                for &b in &near[n + 1..] {
+                    let Some(&cb) = colors.get(b as usize) else { continue };
+                    let d = [cb[0] - ca[0], cb[1] - ca[1], cb[2] - ca[2]];
+                    let len2 = d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
+                    let along = if len2 > 0.0 { (pa[0] * d[0] + pa[1] * d[1] + pa[2] * d[2]) / len2 } else { 0.0 };
+                    let t = along.clamp(0.0, 1.0);
+                    let off2 = (pa[0] - t * d[0]).powi(2) + (pa[1] - t * d[1]).powi(2) + (pa[2] - t * d[2]).powi(2);
+                    if best.is_none_or(|x| off2 < x.0 - SAME_FIT || (off2 <= x.0 + SAME_FIT && len2 < x.3)) {
+                        best = Some((off2, [a, b], if t < 0.5 { a } else { b }, len2, along > 0.0 && along < 1.0));
+                    }
+                }
+            }
+            // A pixel already of one of the two colors it is best a blend of stays as it is.
+            if let Some((off2, pair, to, apart2, between)) = best
+                && !pair.contains(&mine_l)
+                && (off2 < BETTER_FIT * dist2(p, mine) || (between && off2 < ON_THE_LINE * ON_THE_LINE * apart2))
+            {
+                q.labels[i] = to;
+                changed = true;
+            }
+        }
+    }
+    if changed { compact(q.labels, q.palette) } else { q }
+}
+
 /// Whether `img` is continuous tone (a photo, a gradient) rather than flat art, however noisy
 /// or unevenly lit (a scan): whether eight colours leave much of it unsaid. Flat art is a few
 /// colours and what noise and lighting make of them, and eight colours come within a few levels
@@ -443,3 +651,66 @@ fn edge_blend_of(own: [f64; 3], beside: [u8; 3], alpha: u8) -> bool {
     let off2: f64 = (0..3).map(|c| (own[c] - from[c] - t * d[c]).powi(2)).sum();
     off2 <= EDGE_BLEND * EDGE_BLEND
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_gray_blend_takes_the_closer_of_two_pairs_it_lies_between_despite_rounding() {
+        // Gray 105 in the middle, with own pixels of gray 50 to its left, 200 to its right and black
+        // along the top row, and a palette gray of 120 of its own. It lies between 0 and 200 exactly
+        // and between 50 and 200 to within rounding: it takes 50, the nearer of the closer pair.
+        let gray = |x: u32, y: u32| match (x, y) {
+            (8, 8) => 105,
+            (_, 0) => 0,
+            (0..=8, _) => 50,
+            _ => 200,
+        };
+        let img = Raster::from_fn(17, 17, |x, y| {
+            let v = gray(x, y);
+            [v, v, v, 255]
+        });
+        let palette = vec![[0, 0, 0], [50, 50, 50], [200, 200, 200], [120, 120, 120]];
+        let labels: Vec<u16> = (0..17 * 17)
+            .map(|i| match gray(i % 17, i / 17) {
+                0 => 0,
+                50 => 1,
+                200 => 2,
+                _ => 3,
+            })
+            .collect();
+        let own: Vec<bool> = labels.iter().map(|&l| l != 3).collect();
+        let q = settled_wide(Quantized { labels, palette }, &img, &own, true);
+        let middle = q.labels[8 * 17 + 8];
+        assert_eq!(q.palette[usize::from(middle)], [50, 50, 50]);
+    }
+
+    #[test]
+    fn a_blend_pixel_beyond_the_end_of_a_pair_keeps_its_nearest_color() {
+        // A column of [92, 92, 92] between own pixels of [100, 100, 100] to its left and
+        // [200, 200, 200] to its right, with a palette color of [90, 90, 90]: it lies beyond the
+        // darker end of the pair, not between the two, and its own color is the nearer, so it
+        // keeps it.
+        let value = |x: u32| match x {
+            0..=7 => 100,
+            8 => 92,
+            _ => 200,
+        };
+        let img = Raster::from_fn(17, 17, |x, _| {
+            let v = value(x);
+            [v, v, v, 255]
+        });
+        let palette = vec![[100, 100, 100], [200, 200, 200], [90, 90, 90]];
+        let labels: Vec<u16> = (0..17 * 17u32)
+            .map(|i| match value(i % 17) {
+                100 => 0,
+                200 => 1,
+                _ => 2,
+            })
+            .collect();
+        let own: Vec<bool> = labels.iter().map(|&l| l != 2).collect();
+        let q = settled_wide(Quantized { labels, palette }, &img, &own, false);
+        assert_eq!(q.palette[usize::from(q.labels[8 * 17 + 8])], [90, 90, 90]);
+    }
+}
diff --git a/crates/trace/src/tests.rs b/crates/trace/src/tests.rs
index d0a589b916..b244c3b79b 100644
--- a/crates/trace/src/tests.rs
+++ b/crates/trace/src/tests.rs
@@ -1330,6 +1330,115 @@ fn a_blend_of_two_colours_is_no_sliver_of_a_third() {
     assert!(b.y0 > 89.0 && b.y1 < 110.0, "{b:?}");
 }
 
+/// A light disc of radius 32 at (55, 60) on a dark ground, its edge blurred into a ramp 10 px
+/// wide, and elsewhere a patch of the tone halfway between the two, so that the palette holds
+/// that tone. Returns the picture and whether a color is that tone.
+fn blurred_disc_and_halfway_patch() -> (Raster, impl Fn([u8; 3]) -> bool) {
+    const DARK: [f64; 3] = [20.0, 25.0, 35.0];
+    const LIGHT: [f64; 3] = [225.0, 195.0, 160.0];
+    let mid = [0, 1, 2].map(|k| (DARK[k] + LIGHT[k]) / 2.0);
+    let img = Raster::from_fn(160, 120, |x, y| {
+        let (px, py) = (f64::from(x) + 0.5, f64::from(y) + 0.5);
+        let c = if (112.0..152.0).contains(&px) && (40.0..80.0).contains(&py) {
+            mid
+        } else {
+            let t = ((32.0 - Point::new(px, py).distance(Point::new(55.0, 60.0))) / 10.0 + 0.5).clamp(0.0, 1.0);
+            [0, 1, 2].map(|k| DARK[k] + t * (LIGHT[k] - DARK[k]))
+        };
+        let c = |k: usize| c[k].round() as u8;
+        [c(0), c(1), c(2), 255]
+    });
+    (img, move |c: [u8; 3]| (0..3).all(|k| (f64::from(c[k]) - mid[k]).abs() <= 12.0))
+}
+
+#[test]
+fn a_blurred_edge_is_no_ring_of_a_tone_between_its_sides() {
+    let (img, is_mid) = blurred_disc_and_halfway_patch();
+    let res = trace(&img, &sixteen_colors());
+    let mids: Vec<&TracedPath> = res.paths.iter().filter(|p| is_mid(p.color)).collect();
+    assert_eq!(mids.len(), 1, "the patch, and no ring around the disc: {:?}", res.paths.iter().map(|p| p.color).collect::<Vec<_>>());
+    let b = mids[0].path.bounds().unwrap();
+    assert!(b.x0 > 110.0 && b.y0 > 38.0 && b.y1 < 82.0, "{b:?}");
+    // The disc's edge lies halfway along the ramp.
+    let light = res.paths.iter().find(|p| p.color[0] > 180).unwrap();
+    let off = along(&light.path).iter().map(|p| (p.distance(Point::new(55.0, 60.0)) - 32.0).abs()).fold(0.0, f64::max);
+    assert!(off < 1.0, "{off} px off the middle of the ramp");
+}
+
+#[test]
+fn grayscale_settles_a_tinted_blurred_edge_by_its_lightness() {
+    // The same blurred disc and halfway patch in grays, and tinted green at the same lightness
+    // (every pixel moved by the same color, which keeps its luma): Grayscale reads lightness
+    // alone, so both make the same grays in the same places.
+    let lightness = |x: u32, y: u32| {
+        let (px, py) = (f64::from(x) + 0.5, f64::from(y) + 0.5);
+        if (112.0..152.0).contains(&px) && (40.0..80.0).contains(&py) {
+            130
+        } else {
+            let t = ((32.0 - Point::new(px, py).distance(Point::new(55.0, 60.0))) / 10.0 + 0.5).clamp(0.0, 1.0);
+            (40.0 + 180.0 * t).round() as u8
+        }
+    };
+    let gray = Raster::from_fn(160, 120, |x, y| {
+        let v = lightness(x, y);
+        [v, v, v, 255]
+    });
+    let tinted = Raster::from_fn(160, 120, |x, y| {
+        let v = lightness(x, y);
+        [v - 40, v + 28, v - 40, 255]
+    });
+    let lumas = |img: &Raster| img.rgba.as_chunks::<4>().0.iter().map(|&p| crate::quantize::luma(p)).collect::<Vec<_>>();
+    assert_eq!(lumas(&tinted), lumas(&gray));
+    let params = TraceParams { mode: Mode::Grayscale, colors: 8, ..TraceParams::default() };
+    assert_eq!(quantize(&tinted, &params), quantize(&gray, &params));
+}
+
+#[test]
+fn grayscale_settles_a_blurred_edge_between_its_own_two_grays() {
+    // A dark gray and a light gray meet in a ramp 12 px wide, and a black band runs across the top.
+    // In grays every blend lies between black and the light gray as well as between the two grays
+    // (to within rounding): the ramp's pixels just below the band take the nearer of the two grays,
+    // the grays on either side of them.
+    for (dark, light) in [(40u8, 200u8), (50, 200), (30, 170), (60, 230), (45, 215)] {
+        let img = Raster::from_fn(160, 60, |x, y| {
+            let v = if y < 8 {
+                0
+            } else {
+                let t = ((f64::from(x) + 0.5 - 74.0) / 12.0).clamp(0.0, 1.0);
+                (f64::from(dark) + f64::from(light - dark) * t).round() as u8
+            };
+            [v, v, v, 255]
+        });
+        let params = TraceParams { mode: Mode::Grayscale, colors: 8, ..TraceParams::default() };
+        let q = quantize(&img, &params);
+        let middle = u16::from(dark) + u16::from(light);
+        for y in 10..16 {
+            for x in 74..86 {
+                let v = img.rgba[(y * 160 + x) * 4];
+                let g = q.palette[usize::from(q.labels[y * 160 + x])][0];
+                assert_eq!(2 * u16::from(g) < middle, 2 * u16::from(v) < middle, "{dark} to {light}, ({x}, {y}): {v} took gray {g}");
+                assert!(g >= dark, "{dark} to {light}, ({x}, {y}): {v} took gray {g}");
+            }
+        }
+    }
+}
+
+#[test]
+fn the_photo_presets_keep_the_tones_of_a_blurred_edge() {
+    // The photo presets ask for more colors than the limited-color presets and keep the middle of
+    // the ramp in the halfway tone: only a blend pixel with the colors on both sides within 2 px of
+    // it takes a side.
+    let (img, is_mid) = blurred_disc_and_halfway_patch();
+    for name in ["High Fidelity Photo", "Low Fidelity Photo"] {
+        let q = quantize(&img, &preset(name).unwrap());
+        let middle = (0..160 * 120)
+            .filter(|&i| (Point::new((i % 160) as f64 + 0.5, (i / 160) as f64 + 0.5).distance(Point::new(55.0, 60.0)) - 32.0).abs() < 1.0)
+            .filter(|&i| q.palette.get(usize::from(q.labels[i])).is_some_and(|&c| is_mid(c)))
+            .count();
+        assert!(middle > 100, "{name}: {middle} pixels of the halfway tone in the middle of the ramp");
+    }
+}
+
 #[test]
 fn hairlines_keep_their_colour_in_color_mode() {
     // Black lines one pixel wide on white: every black pixel is on an edge, none is a blend.
diff --git a/crates/ui-egui/src/canvas/input.rs b/crates/ui-egui/src/canvas/input.rs
index 5f06eb980d..879f86dd1e 100644
--- a/crates/ui-egui/src/canvas/input.rs
+++ b/crates/ui-egui/src/canvas/input.rs
@@ -12,7 +12,9 @@ use super::{Color32, Drag, Mods, Point, PointerEvent, PointerKind, Pos2, Shape,
 
 /// Dispatch canvas pointer, keyboard and drop events through the active document view.
 pub(super) fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Response, rect: egui::Rect) {
-    let (pointer, m, space, hover) = wheel_view(app, ui, resp, rect);
+    // A modal dialog takes the canvas's presses, finger taps, long touches and view navigation, from the frame it opens.
+    let modal = crate::panel_docking::modal_open(app, ui.ctx());
+    let (pointer, m, space, hover) = wheel_view(app, ui, resp, rect, modal);
     let v = *app.view().unwrap_or(&View::default());
     let xf = Xf::at(rect, &v, app.canvas_ui_zoom);
     // A lifted pen or finger takes the pointer away in the frame it lifts (egui's `PointerGone`),
@@ -21,11 +23,11 @@ pub(super) fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Respo
     let at = hover.or_else(|| pointer.interact_pos().filter(|p| rect.contains(*p)));
     let view = app.view_info();
     let (_, backquote_before) = backquote_seen(ui);
-    let f = Pointing { resp, rect, pointer: &pointer, m, space, xf, v, view, backquote_before };
-    touch_gestures(app, ui, rect, view);
+    let f = Pointing { resp, rect, pointer: &pointer, m, space, xf, v, view, backquote_before, modal };
+    touch_gestures(app, ui, rect, view, modal);
     // Pressed and held still, a pen or a finger opens the context menu (egui's long touch): the
-    // tool's press is dropped, as a right-click presses nothing.
-    if resp.long_touched() {
+    // tool's press is dropped, as a right-click presses nothing. Under a modal dialog it drops nothing.
+    if resp.long_touched() && !modal {
         drop_press(app, ui, view);
     }
     let drag: Option<Drag> = ui.data(|d| d.get_temp(drag_id()));
@@ -84,9 +86,11 @@ pub(super) fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Respo
     // egui counts a press a few pixels outside the canvas as on it (its interaction radius): only a
     // press on the canvas itself reaches the tools, else it would land at the canvas's centre.
     // A finger pressing with others down, or with another landing in its frame, presses nothing
-    // (`touch_gestures` made the press a gesture, #4198).
+    // (`touch_gestures` made the press a gesture, #4198). While a modal dialog is open no press
+    // reaches the tools or pans, also in the frame it opens, before its backdrop covers the canvas.
     if pointer.primary_pressed()
         && resp.hovered()
+        && !f.modal
         && !middle_pan
         && drag != Some(Drag::Gesture)
         && let Some(p) = at
@@ -110,6 +114,7 @@ pub(super) fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Respo
         }
     } else if drag.is_none()
         && resp.hovered()
+        && !f.modal
         && pointer.button_pressed(egui::PointerButton::Middle)
         && let Some(start) = hover
     {
@@ -169,6 +174,7 @@ pub(super) fn handle_input(app: &mut VectorcraftApp, ui: &Ui, resp: &egui::Respo
         select_named_artboard(app, i, shift || release_shift);
     }
     if resp.double_clicked()
+        && !f.modal
         && let Some(p) = at
     {
         double_click(app, ui, &f, p);
@@ -190,21 +196,37 @@ struct Pointing<'a> {
     view: vectorcraft_engine::ViewInfo,
     /// Whether Backtick was held at the end of the frame before ([`backquote_seen`]).
     backquote_before: Option<bool>,
+    /// Whether a modal dialog is open ([`crate::panel_docking::modal_open`]).
+    modal: bool,
 }
 
-/// Zoom around the pointer, and scroll ([`wheel`]); a trackpad rotation turns the view. Returns the pointer, the
+/// Zoom around the pointer, and scroll ([`wheel`]); a trackpad rotation turns the view. While a modal dialog is open
+/// (`modal`), and for the rest of a wheel turn made under it, the view does not move. Returns the pointer, the
 /// modifiers, whether Space is held and where the pointer hovers over the canvas.
 fn wheel_view(
     app: &mut VectorcraftApp,
     ui: &Ui,
     resp: &egui::Response,
     rect: egui::Rect,
+    modal: bool,
 ) -> (egui::PointerState, egui::Modifiers, bool, Option<Pos2>) {
     let line = ui.ctx().options(|o| o.input_options.line_scroll_speed);
     let wheel_zooms = app.session.prefs.zoom_with_mouse_wheel;
+    // A wheel turn that goes on under a modal dialog moves nothing after the dialog closes either: what egui lets out
+    // of it later is dropped until egui ends the turn.
+    // `carried` is set only while a turn that went on under the dialog is still scrolling, so a new turn
+    // made after it closes moves the view at once.
+    let carried_id = egui::Id::unique("canvas-wheel-muted");
+    let was_carried = ui.data(|d| d.get_temp::<bool>(carried_id)).unwrap_or(false);
+    let carried = (modal || was_carried) && ui.input(egui::InputState::is_scrolling);
+    if carried != was_carried {
+        ui.data_mut(|d| d.insert_temp(carried_id, carried));
+    }
+    let muted = modal || carried;
+    let navigates = resp.hovered() && !muted;
     // A docked field may be drawn later and has not consumed its wheel event yet. Only canvas
     // hover may start a zoom glide; existing glides still decay outside the canvas in `wheel`.
-    let animate = animated_zoom(&app.session.prefs) && resp.hovered();
+    let animate = animated_zoom(&app.session.prefs) && navigates;
     let turn_id = egui::Id::unique("canvas-wheel-turn");
     let turn_before: WheelTurn = ui.data(|d| d.get_temp(turn_id)).unwrap_or_default();
     let mut turn = turn_before;
@@ -216,6 +238,10 @@ fn wheel_view(
             wheel(i, &app.session.prefs, wheel_zooms, animate, line, rect.height(), &mut turn),
         )
     });
+    // A zoom glide still running when a modal dialog opens stops.
+    if muted {
+        turn.glide = 0.0;
+    }
     if turn != turn_before {
         ui.data_mut(|d| d.insert_temp(turn_id, turn));
     }
@@ -226,7 +252,7 @@ fn wheel_view(
     // Zoom around the pointer, and scroll ([`wheel`]): fingers pinching on a touch screen may also
     // slide. Then turn the view about the pointer for a trackpad rotation ([`trackpad_turn`]). The
     // tool's events below take their document points from the view this moves to.
-    if resp.hovered() {
+    if navigates {
         let ui_zoom = app.canvas_ui_zoom;
         if (factor - 1.0).abs() > 1e-6
             && let (Some(p), Some(vm)) = (hover, app.view_mut())
@@ -247,10 +273,11 @@ fn wheel_view(
 }
 
 /// In Presentation Mode a click anywhere goes to the next artboard. The tool receives no press, drag or hover, and a
-/// drag does not pan the view. A drag that began before the mode was turned on ends as usual.
+/// drag does not pan the view. A drag that began before the mode was turned on ends as usual. While a modal dialog is
+/// open, a click does not step.
 fn present_step(app: &mut VectorcraftApp, ui: &Ui, f: &Pointing, drag: Option<Drag>, at: Option<Pos2>) {
     let (resp, pointer) = (f.resp, f.pointer);
-    let pressed = drag.is_none() && pointer.primary_pressed() && resp.hovered() && at.is_some();
+    let pressed = drag.is_none() && pointer.primary_pressed() && resp.hovered() && at.is_some() && !f.modal;
     // `press` is this frame's new press, or else the press held so far. A quick tap can be
     // pressed and released in one frame.
     let press = if pressed { Some(Drag::Present) } else { drag };
@@ -258,7 +285,7 @@ fn present_step(app: &mut VectorcraftApp, ui: &Ui, f: &Pointing, drag: Option<Dr
         ui.data_mut(|dd| dd.remove::<Drag>(drag_id()));
         // A tap of several fingers leaves `Drag::Gesture` (`touch_gestures`), and its release
         // does not move the view to the next artboard.
-        if press == Some(Drag::Present) && resp.clicked() {
+        if press == Some(Drag::Present) && resp.clicked() && !f.modal {
             crate::shortcuts::presentation_step(app, true);
         }
     } else if pressed {
diff --git a/crates/ui-egui/src/canvas/tests.rs b/crates/ui-egui/src/canvas/tests.rs
index 6bf8a6fa97..d6df378c87 100644
--- a/crates/ui-egui/src/canvas/tests.rs
+++ b/crates/ui-egui/src/canvas/tests.rs
@@ -1030,6 +1030,278 @@ fn two_finger_tap_in_touch_switches_selection_and_drawing_modes() {
     assert_eq!(count(&app), before - 1, "Essentials: undone");
 }
 
+/// One frame of the canvas with `events`, with the modal backdrop drawn over it when `backdrop` is set, as the app
+/// draws it for an open dialog.
+fn modal_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>, backdrop: bool) {
+    let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0))), events, ..Default::default() };
+    let mut out = ctx.run_ui(raw, |ui| {
+        show(app, ui);
+        if backdrop {
+            crate::dialogs::modal::show(ui.ctx(), "Test", egui::Id::unique("test-dialog"), 0.0, 8, |ui| ui.label("A dialog"));
+        }
+    });
+    out.textures_delta.clear();
+}
+
+/// Finger `n` touching at `pos`.
+fn finger(n: u64, phase: egui::TouchPhase, pos: Pos2) -> egui::Event {
+    egui::Event::Touch { device_id: egui::TouchDeviceId(1), id: egui::TouchId(n), phase, pos, force: None }
+}
+
+/// The primary button pressed or released at `pos`.
+fn finger_button(pos: Pos2, pressed: bool) -> egui::Event {
+    egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }
+}
+
+/// A tap of `fingers` fingers beside `c`, the first also pressing as the pointer and moving a little, in frames drawn
+/// with the modal backdrop when `backdrop` is set ([`modal_frame`]).
+fn finger_tap(app: &mut VectorcraftApp, ctx: &egui::Context, c: Pos2, fingers: u64, backdrop: bool) {
+    use egui::TouchPhase::{End, Move, Start};
+    let at = |n: u64| c + vec2(n as f32 * 50.0, 0.0);
+    let moved = at(0) + vec2(6.0, 6.0);
+    modal_frame(app, ctx, vec![finger(0, Start, at(0)), egui::Event::PointerMoved(at(0)), finger_button(at(0), true)], backdrop);
+    modal_frame(app, ctx, vec![finger(0, Move, moved), egui::Event::PointerMoved(moved)], backdrop);
+    modal_frame(app, ctx, (1..fingers).map(|n| finger(n, Start, at(n))).collect(), backdrop);
+    modal_frame(app, ctx, vec![finger(0, End, at(0)), finger_button(moved, false), egui::Event::PointerGone], backdrop);
+    modal_frame(app, ctx, (1..fingers).map(|n| finger(n, End, at(n))).collect(), backdrop);
+    modal_frame(app, ctx, vec![], backdrop);
+}
+
+/// While a modal is open, a two-finger tap on the canvas does not undo, a three-finger tap does not redo, and in the
+/// Touch workspace a two-finger tap does not switch modes: with the app's dialog open, before its backdrop is drawn
+/// (the frame it opens) and after, and under a modal backdrop alone.
+#[test]
+fn modal_blocks_two_and_three_finger_canvas_taps() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+    app.session.execute("shape.rectangle", &json!({"x": 50, "y": 50, "width": 40, "height": 40})).unwrap();
+    app.select_tool("selection");
+    let ctx = egui::Context::default();
+    modal_frame(&mut app, &ctx, vec![], false);
+    let count = |app: &VectorcraftApp| app.session.active().unwrap().doc.layers[0].children().unwrap().len();
+    let c = app.canvas_rect.unwrap().center();
+    let settle = |app: &mut VectorcraftApp| {
+        app.ui.dialog = None;
+        modal_frame(app, &ctx, vec![], false);
+        modal_frame(app, &ctx, vec![], false);
+    };
+    for (dialog, backdrop) in [(true, true), (true, false), (false, true)] {
+        let open = |app: &mut VectorcraftApp| app.ui.dialog = dialog.then(|| crate::state::Dialog::new("preferences", json!({})));
+        open(&mut app);
+        finger_tap(&mut app, &ctx, c, 2, backdrop);
+        assert_eq!(count(&app), 1, "dialog {dialog}, backdrop {backdrop}: two fingers undo nothing");
+        settle(&mut app);
+        app.run("edit.undo", json!({})).unwrap();
+        assert_eq!(count(&app), 0);
+        open(&mut app);
+        finger_tap(&mut app, &ctx, c, 3, backdrop);
+        assert_eq!(count(&app), 0, "dialog {dialog}, backdrop {backdrop}: three fingers redo nothing");
+        settle(&mut app);
+        app.run("edit.redo", json!({})).unwrap();
+        assert_eq!(count(&app), 1);
+    }
+    crate::workspaces::switch(&mut app.ui, crate::workspaces::TOUCH).unwrap();
+    app.select_tool("selection");
+    modal_frame(&mut app, &ctx, vec![], false);
+    app.ui.dialog = Some(crate::state::Dialog::new("preferences", json!({})));
+    finger_tap(&mut app, &ctx, c, 2, true);
+    assert_eq!((app.session.tool_id(), count(&app)), ("selection", 1), "Touch: no switch to drawing mode under the dialog");
+    settle(&mut app);
+    finger_tap(&mut app, &ctx, c, 2, false);
+    assert_ne!(app.session.tool_id(), "selection", "closed: two fingers switch to drawing mode again");
+}
+
+/// Fingers down on the canvas when a modal dialog opens make no tap: lifting them while the dialog is open, or after it
+/// closes, runs nothing. A tap begun after it closes undoes again.
+#[test]
+fn opening_a_modal_discards_a_pending_canvas_tap() {
+    use egui::TouchPhase::{End, Start};
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+    app.session.execute("shape.rectangle", &json!({"x": 50, "y": 50, "width": 40, "height": 40})).unwrap();
+    app.select_tool("selection");
+    let ctx = egui::Context::default();
+    modal_frame(&mut app, &ctx, vec![], false);
+    let count = |app: &VectorcraftApp| app.session.active().unwrap().doc.layers[0].children().unwrap().len();
+    let c = app.canvas_rect.unwrap().center();
+    let at = |n: u64| c + vec2(n as f32 * 50.0, 0.0);
+    modal_frame(&mut app, &ctx, vec![finger(0, Start, at(0)), egui::Event::PointerMoved(at(0)), finger_button(at(0), true)], false);
+    modal_frame(&mut app, &ctx, vec![finger(1, Start, at(1))], false);
+    // The dialog opens in a frame with no touch, and one finger lifts while it is open.
+    app.ui.dialog = Some(crate::state::Dialog::new("preferences", json!({})));
+    modal_frame(&mut app, &ctx, vec![], true);
+    modal_frame(&mut app, &ctx, vec![finger(0, End, at(0)), finger_button(at(0), false), egui::Event::PointerGone], true);
+    assert_eq!(count(&app), 1, "nothing undone while the dialog is open");
+    // The other finger lifts after it closes.
+    app.ui.dialog = None;
+    modal_frame(&mut app, &ctx, vec![], false);
+    modal_frame(&mut app, &ctx, vec![], false);
+    modal_frame(&mut app, &ctx, vec![finger(1, End, at(1))], false);
+    modal_frame(&mut app, &ctx, vec![], false);
+    assert_eq!(count(&app), 1, "the tap begun before the dialog runs nothing after it closes");
+    finger_tap(&mut app, &ctx, c, 2, false);
+    assert_eq!(count(&app), 0, "a tap begun after it closes undoes");
+}
+
+/// While a modal is open and the canvas is not yet covered by its backdrop (the frame a dialog opens), a click in
+/// Presentation Mode does not step to the next artboard, and a pinch or a wheel does not move the view. Closed, both
+/// act again.
+#[test]
+fn modal_blocks_presentation_tap_and_touch_navigation() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+    app.session.execute("artboard.new", &json!({"x": 500, "y": 0, "width": 100, "height": 80, "name": "Far"})).unwrap();
+    let ctx = egui::Context::default();
+    let dialog = || Some(crate::state::Dialog::new("preferences", json!({})));
+    app.ui.screen_mode = 3;
+    modal_frame(&mut app, &ctx, vec![], false);
+    let c = app.canvas_rect.unwrap().center();
+    let click = |app: &mut VectorcraftApp| {
+        modal_frame(app, &ctx, vec![egui::Event::PointerMoved(c)], false);
+        modal_frame(app, &ctx, vec![finger_button(c, true)], false);
+        modal_frame(app, &ctx, vec![finger_button(c, false)], false);
+        modal_frame(app, &ctx, vec![], false);
+    };
+    let at = |app: &VectorcraftApp| crate::panels::artboards::selected(app, 2);
+    assert_eq!(at(&app), 0);
+    app.ui.dialog = dialog();
+    click(&mut app);
+    assert_eq!(at(&app), 0, "no step under the dialog");
+    app.ui.dialog = None;
+    click(&mut app);
+    assert_eq!(at(&app), 1, "closed: a click steps");
+
+    app.ui.screen_mode = 0;
+    modal_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(c)], false);
+    let view = |app: &VectorcraftApp| {
+        let v = app.view().unwrap();
+        (v.zoom, v.center)
+    };
+    let wheel = egui::Event::MouseWheel {
+        unit: egui::MouseWheelUnit::Point,
+        delta: vec2(0.0, 40.0),
+        phase: egui::TouchPhase::Move,
+        modifiers: Default::default(),
+        source: egui::MouseWheelSource::Unknown,
+    };
+    let before = view(&app);
+    app.ui.dialog = dialog();
+    modal_frame(&mut app, &ctx, vec![egui::Event::Zoom(2.0)], false);
+    modal_frame(&mut app, &ctx, vec![wheel.clone()], false);
+    for _ in 0..30 {
+        modal_frame(&mut app, &ctx, vec![], false);
+    }
+    assert_eq!(view(&app), before, "the view does not move under the dialog");
+    // A wheel turn of whole lines, which egui lets out over several frames, made just before the dialog closes.
+    let lines = egui::Event::MouseWheel {
+        unit: egui::MouseWheelUnit::Line,
+        delta: vec2(0.0, 3.0),
+        phase: egui::TouchPhase::Move,
+        modifiers: Default::default(),
+        source: egui::MouseWheelSource::Unknown,
+    };
+    modal_frame(&mut app, &ctx, vec![lines], false);
+    app.ui.dialog = None;
+    for _ in 0..30 {
+        modal_frame(&mut app, &ctx, vec![], false);
+    }
+    assert_eq!(view(&app), before, "the rest of a wheel turn made under the dialog does not move the view after it closes");
+    modal_frame(&mut app, &ctx, vec![egui::Event::Zoom(2.0)], false);
+    assert_ne!(view(&app).0, before.0, "closed: a pinch zooms");
+    let zoomed = view(&app);
+    modal_frame(&mut app, &ctx, vec![wheel.clone()], false);
+    for _ in 0..30 {
+        modal_frame(&mut app, &ctx, vec![], false);
+    }
+    assert_ne!(view(&app), zoomed, "closed: a new wheel turn moves the view");
+    // A dialog opened and closed with no wheel turn under it: a wheel turn in the first frame after it closes moves
+    // the view.
+    let scrolled = view(&app);
+    app.ui.dialog = dialog();
+    modal_frame(&mut app, &ctx, vec![], false);
+    app.ui.dialog = None;
+    modal_frame(&mut app, &ctx, vec![wheel], false);
+    for _ in 0..30 {
+        modal_frame(&mut app, &ctx, vec![], false);
+    }
+    assert_ne!(view(&app), scrolled, "a wheel turn just after the dialog closes moves the view");
+}
+
+/// While a modal is open, a pen or finger held still on the canvas does not drop the press it began.
+#[test]
+fn modal_long_touch_does_not_cancel_canvas_press() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.session.execute("file.new", &json!({"width":800,"height":600})).unwrap();
+    app.select_tool("rectangle");
+    let ctx = egui::Context::default();
+    let tick = |app: &mut VectorcraftApp, time, events| {
+        let raw = egui::RawInput {
+            screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0))),
+            time: Some(time),
+            events,
+            ..Default::default()
+        };
+        let mut out = ctx.run_ui(raw, |ui| show(app, ui));
+        out.textures_delta.clear();
+    };
+    tick(&mut app, 0.0, vec![]);
+    let pos = app.canvas_rect.unwrap().center();
+    tick(&mut app, 0.1, pen(egui::TouchPhase::Start, pos, 0.5));
+    assert!(matches!(ctx.data(|d| d.get_temp::<Drag>(drag_id())), Some(Drag::Tool)));
+    app.ui.dialog = Some(crate::state::Dialog::new("preferences", json!({})));
+    tick(&mut app, 1.5, vec![]);
+    assert!(matches!(ctx.data(|d| d.get_temp::<Drag>(drag_id())), Some(Drag::Tool)), "the press is kept under the dialog");
+}
+
+/// While a modal is open and its backdrop does not yet cover the canvas (the frame a dialog opens), a drag on the canvas
+/// draws nothing, a two-finger tap with a drawing tool draws nothing, a middle-button drag does not pan and a
+/// double-click on type does not start editing it. Closed, a drag draws again.
+#[test]
+fn modal_blocks_new_canvas_presses() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+    let id = app.session.execute("text.create", &json!({"x": 100, "y": 150, "text": "Hello world", "size": 24})).unwrap()["id"].as_u64().unwrap();
+    app.session.execute("select.none", &json!({})).unwrap();
+    app.select_tool("rectangle");
+    let ctx = egui::Context::default();
+    modal_frame(&mut app, &ctx, vec![], false);
+    let count = |app: &VectorcraftApp| app.session.active().unwrap().doc.layers[0].children().unwrap().len();
+    let from = app.canvas_rect.unwrap().center() + vec2(0.0, 80.0);
+    let drag = |app: &mut VectorcraftApp, button: egui::PointerButton| {
+        let to = from + vec2(60.0, 40.0);
+        let b = |pos, pressed| egui::Event::PointerButton { pos, button, pressed, modifiers: Default::default() };
+        modal_frame(app, &ctx, vec![egui::Event::PointerMoved(from), b(from, true)], false);
+        modal_frame(app, &ctx, vec![egui::Event::PointerMoved(from + vec2(30.0, 20.0))], false);
+        modal_frame(app, &ctx, vec![egui::Event::PointerMoved(to)], false);
+        modal_frame(app, &ctx, vec![b(to, false)], false);
+        modal_frame(app, &ctx, vec![], false);
+    };
+    let before = count(&app);
+    app.ui.dialog = Some(crate::state::Dialog::new("preferences", json!({})));
+    drag(&mut app, egui::PointerButton::Primary);
+    assert_eq!(count(&app), before, "a drag with the Rectangle tool draws nothing under the dialog");
+    finger_tap(&mut app, &ctx, from, 2, false);
+    assert_eq!(count(&app), before, "a two-finger tap with the Rectangle tool draws nothing under the dialog");
+    let center = app.view().unwrap().center;
+    drag(&mut app, egui::PointerButton::Middle);
+    assert_eq!(app.view().unwrap().center, center, "a middle-button drag does not pan under the dialog");
+    app.select_tool("selection");
+    modal_frame(&mut app, &ctx, vec![], false);
+    let xf = Xf::new(app.canvas_rect.unwrap(), app.view().unwrap());
+    let b = app.session.active().unwrap().doc.node(vectorcraft_doc::NodeId(id)).unwrap().geometric_bounds().unwrap();
+    let at = xf.to_screen(b.center());
+    let button = |pressed| finger_button(at, pressed);
+    modal_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(at), button(true), button(false), button(true), button(false)], false);
+    modal_frame(&mut app, &ctx, vec![], false);
+    assert_eq!(app.session.tool_id(), "selection", "a double-click on type does not edit it under the dialog");
+    app.ui.dialog = None;
+    app.select_tool("rectangle");
+    modal_frame(&mut app, &ctx, vec![], false);
+    modal_frame(&mut app, &ctx, vec![], false);
+    drag(&mut app, egui::PointerButton::Primary);
+    assert_eq!(count(&app), before + 1, "closed: a drag draws");
+}
+
 /// Switch Selection and Drawing Modes from the command: Pencil when no drawing tool was chosen yet,
 /// a view tool is left for Selection without becoming the drawing tool, and every selection tool
 /// switches to drawing mode.
diff --git a/crates/ui-egui/src/canvas/view.rs b/crates/ui-egui/src/canvas/view.rs
index 0304e28c17..0e43e6a545 100644
--- a/crates/ui-egui/src/canvas/view.rs
+++ b/crates/ui-egui/src/canvas/view.rs
@@ -534,10 +534,18 @@ pub(super) fn wheel(
 /// finger drops the press the first one began (its tool interaction rolled back; the rest of the
 /// gesture presses nothing), and a tap of two fingers undoes, one of three redoes. In the Touch
 /// workspace a tap of two fingers switches between selection and drawing modes instead.
-pub(super) fn touch_gestures(app: &mut VectorcraftApp, ui: &Ui, rect: egui::Rect, view: vectorcraft_engine::ViewInfo) {
+///
+/// While a modal dialog is open (`modal`) the canvas takes no finger contacts: no tap runs a command and no gesture
+/// begins. The fingers already down are forgotten, so lifting them, during the dialog or after it closes, runs nothing.
+pub(super) fn touch_gestures(app: &mut VectorcraftApp, ui: &Ui, rect: egui::Rect, view: vectorcraft_engine::ViewInfo, modal: bool) {
     if !app.session.prefs.touch_gestures {
         return;
     }
+    let key = egui::Id::unique("canvas-touch");
+    if modal {
+        ui.data_mut(|d| d.remove::<crate::touch::Taps>(key));
+        return;
+    }
     let (touches, now): (Vec<_>, f64) = ui.input(|i| {
         let t = i.events.iter().filter_map(|e| match e {
             egui::Event::Touch { id, phase, pos, .. } => Some((*id, *phase, *pos)),
@@ -548,7 +556,6 @@ pub(super) fn touch_gestures(app: &mut VectorcraftApp, ui: &Ui, rect: egui::Rect
     if touches.is_empty() {
         return;
     }
-    let key = egui::Id::unique("canvas-touch");
     let mut taps: crate::touch::Taps = ui.data(|d| d.get_temp(key)).unwrap_or_default();
     let mut tap = None;
     for (id, phase, pos) in touches {
diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index 89ab7e37b4..f2897b8833 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -251,7 +251,7 @@ pub fn inspect(app: &VectorcraftApp, ctx: &egui::Context) -> Value {
     // the layout.
     if let Some(fields) = ui.as_object_mut() {
         fields.remove("floating_panels");
-        leave_out_unreadable_paths(fields);
+        leave_out_unreadable_paths(app, fields);
     }
     json!({
         "scriptRunning": app.session.script_running(),
@@ -1091,8 +1091,10 @@ fn leave_out_unreadable_values(v: &mut Value) {
 
 /// Takes out of `ui.inspect`'s copy of the UI state the paths the request may not read: recent files,
 /// a library panel's file, folder preferences (saved, and in an open Preferences dialog) and the paths
-/// in recorded actions' steps outside the read root. The UI state itself is not changed.
-fn leave_out_unreadable_paths(ui: &mut serde_json::Map<String, Value>) {
+/// in recorded actions' steps outside the read root. The file selected in an open JavaScript Files
+/// dialog is named as `svgInteractivity.info` names the active document's linked files. The UI state
+/// itself is not changed.
+fn leave_out_unreadable_paths(app: &VectorcraftApp, ui: &mut serde_json::Map<String, Value>) {
     if let Some(Value::Array(files)) = ui.get_mut("recent_files") {
         files.retain(|f| f.as_str().is_some_and(readable));
     }
@@ -1115,6 +1117,14 @@ fn leave_out_unreadable_paths(ui: &mut serde_json::Map<String, Value>) {
     {
         leave_out_unreadable_folders(fields);
     }
+    if let Some(Value::Object(dialog)) = ui.get_mut("dialog")
+        && dialog.get("kind").and_then(Value::as_str) == Some(crate::dialogs::javascript_files::KIND)
+        && let Some(Value::Object(fields)) = dialog.get_mut("fields")
+        && let Some(Value::String(selected)) = fields.get_mut("selected")
+        && let Some(st) = app.session.active()
+    {
+        *selected = vectorcraft_engine::cmd::links::shown_script(st, selected).into_owned();
+    }
 }
 
 /// Takes out of `prefs` the folder preferences ([`PREF_FOLDERS`]) the request may not read, as written
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index 6040ac8fb4..1406d25530 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -60,6 +60,7 @@ pub mod graphic_style_options;
 pub mod halftone;
 pub mod hyphenation;
 pub mod import_pdf;
+pub mod indexed_color;
 pub mod javascript_files;
 pub mod justification;
 pub mod layer_options;
@@ -347,6 +348,7 @@ registry! {
     ColorGuideOptions: [color_guide_options::KIND] => color_guide_options::SPEC,
     ColorBalance: [color_balance::KIND] => color_balance::SPEC,
     Saturate: [saturate::KIND] => saturate::SPEC,
+    IndexedColor: [indexed_color::KIND] => indexed_color::SPEC,
     SaveSwatchLibrary: [save_swatch_library::KIND] => save_swatch_library::SPEC,
     TileEdgeColor: [tile_edge_color::KIND] => tile_edge_color::SPEC,
     EyedropperOptions: [eyedropper::KIND] => eyedropper::SPEC,
diff --git a/crates/ui-egui/src/dialogs/indexed_color.rs b/crates/ui-egui/src/dialogs/indexed_color.rs
new file mode 100644
index 0000000000..6ef266c06c
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/indexed_color.rs
@@ -0,0 +1,135 @@
+//! Edit → Edit Colors → Convert to Indexed Color: the palette (reduction and colors) and the
+//! dither of the selection's embedded images, previewed live on the canvas; OK keeps the preview
+//! as one undo step (`edit.colors.toIndexed`).
+//!
+//! Fields: `reduction`, `colors`, `dither`, `ditherAmount` and `preview`.
+
+use serde_json::{Value, json};
+use vectorcraft_render::encode::quantize::{Dither, Reduction};
+
+use super::{DialogSpec, form};
+use crate::state::Dialog;
+use crate::{VectorcraftApp, widgets};
+
+/// The dialog kind of Convert to Indexed Color.
+pub const KIND: &str = "indexedColor";
+
+const CMD: &str = "edit.colors.toIndexed";
+
+/// The reductions besides those of a PNG-8 export, as (value, label).
+const MORE_REDUCTIONS: [(&str, &str); 2] = [("uniform", "Uniform"), ("document", "Document Swatches")];
+
+/// Label column and dropdown widths.
+const WIDTHS: (f32, f32) = (110.0, 160.0);
+
+pub(super) const SPEC: DialogSpec =
+    DialogSpec { heading: |_| tl!("Convert to Indexed Color").into(), body, confirm, preview: true, min_width: 320.0, ..DialogSpec::FORM };
+
+/// Open the dialog with the defaults of `edit.colors.toIndexed`.
+pub fn open(app: &mut VectorcraftApp) {
+    let fields = json!({"reduction": "selective", "colors": 256, "dither": "diffusion", "ditherAmount": 100, "preview": true});
+    app.ui.dialog = Some(Dialog::new(KIND, fields));
+}
+
+/// Whether reduction `r` takes a number of colors.
+fn takes_colors(r: &str) -> bool {
+    !matches!(r, "blackWhite" | "document")
+}
+
+/// The fewest colors reduction `r` takes.
+fn least_colors(r: &str) -> f64 {
+    if r == "uniform" { 9.0 } else { 2.0 }
+}
+
+/// `edit.colors.toIndexed` parameters: the reduction, its colors when it takes them, and the dither.
+fn params(d: &Dialog) -> Value {
+    let reduction = d.str("reduction");
+    let dither = d.str("dither");
+    let mut p = json!({"reduction": reduction, "dither": dither});
+    if takes_colors(&reduction) {
+        p["colors"] = json!(d.f64("colors", 256.0).round().clamp(least_colors(&reduction), 256.0) as u16);
+    }
+    if dither != Dither::None.id() {
+        p["ditherAmount"] = json!(d.f64("ditherAmount", 100.0).round().clamp(0.0, 100.0));
+    }
+    p
+}
+
+fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
+    let reductions: Vec<(&str, &str)> = Reduction::ALL.iter().map(|r| (r.id(), r.label())).chain(MORE_REDUCTIONS).collect();
+    form::choice(ui, d, "reduction", tl!("Reduction:"), WIDTHS, &reductions);
+    let reduction = d.str("reduction");
+    if takes_colors(&reduction) {
+        // The field shows the number the command gets: at least the reduction's fewest.
+        let least = least_colors(&reduction);
+        let n = d.f64("colors", 256.0).round().clamp(least, 256.0);
+        d.fields.insert("colors".into(), json!(n as u16));
+        widgets::label_row(ui, tl!("Colors:"), WIDTHS.0, |ui| {
+            if let Some(n) = widgets::range_field(ui, "indexed-colors", n, least..=256.0, "", 0, 60.0) {
+                d.fields.insert("colors".into(), json!(n.round() as u16));
+            }
+        });
+    }
+    let dithers: Vec<(&str, &str)> = Dither::ALL.iter().map(|x| (x.id(), x.label())).collect();
+    form::choice(ui, d, "dither", tl!("Dither:"), WIDTHS, &dithers);
+    if d.str("dither") != Dither::None.id() {
+        widgets::label_row(ui, tl!("Amount:"), WIDTHS.0, |ui| {
+            if let Some(n) = widgets::range_field(ui, "indexed-dither-amount", d.f64("ditherAmount", 100.0), 0.0..=100.0, "%", 0, 60.0) {
+                d.fields.insert("ditherAmount".into(), json!(n.round()));
+            }
+        });
+    }
+    let p = params(d);
+    form::preview(app, ui, d, "Convert to Indexed Color", CMD, p);
+    false
+}
+
+fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
+    form::commit_preview(app, CMD, params(d))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use vectorcraft_engine::Session;
+
+    #[test]
+    fn commits_the_chosen_palette_as_one_step() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
+        let mut png = Vec::new();
+        let img = image::RgbaImage::from_raw(2, 1, vec![200, 30, 90, 255, 20, 40, 220, 255]).unwrap();
+        img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+        let id = app
+            .session
+            .edit("Place", |d, sel| {
+                d.images.insert("pic".into(), vectorcraft_doc::ImageBlob::png(png));
+                let id = d.alloc_id();
+                let im = vectorcraft_doc::ImageObject {
+                    key: "pic".into(),
+                    width: 2,
+                    height: 1,
+                    xf: Default::default(),
+                    link: None,
+                    placement: Default::default(),
+                    pixels: None,
+                };
+                d.insert(d.default_layer(), 0, vectorcraft_doc::Node::new(id, vectorcraft_doc::NodeKind::Image(Box::new(im))))?;
+                sel.set([id]);
+                Ok(id)
+            })
+            .unwrap();
+        let undo = app.session.doc().unwrap().history.undo.len();
+        app.run("ui.indexedColorDialog", json!({})).unwrap();
+        let fields = &mut app.ui.dialog.as_mut().unwrap().fields;
+        fields.insert("reduction".into(), json!("blackWhite"));
+        fields.insert("dither".into(), json!("none"));
+        super::super::confirm(&mut app).unwrap();
+        let st = app.session.doc().unwrap();
+        assert_eq!(st.history.undo.len(), undo + 1);
+        let vectorcraft_doc::NodeKind::Image(im) = &st.doc.node(id).unwrap().kind else { panic!("not an image") };
+        let blob = &st.doc.images[&im.key];
+        assert!(blob.indexed_png());
+        assert_eq!(blob.rgba().unwrap().2, [0, 0, 0, 255, 0, 0, 0, 255], "black and white only");
+    }
+}
diff --git a/crates/ui-egui/src/dialogs/javascript_files.rs b/crates/ui-egui/src/dialogs/javascript_files.rs
index 6fb734e1d8..465ebdaeb9 100644
--- a/crates/ui-egui/src/dialogs/javascript_files.rs
+++ b/crates/ui-egui/src/dialogs/javascript_files.rs
@@ -6,8 +6,12 @@
 //! linked file. Add and Remove act at once. The dialog has only Close.
 //!
 //! Fields: `file` (the path or URL to link), `selected` (a linked file).
+//!
+//! In a frame automation drives with read roots in force, the list names a file outside them by
+//! its file name alone, as `svgInteractivity.info` does; `selected` keeps the file as linked.
 
 use serde_json::{Value, json};
+use vectorcraft_engine::cmd::links::shown_script;
 
 use super::DialogSpec;
 use crate::picks::PickRequest;
@@ -63,18 +67,36 @@ enum Action {
     Remove,
 }
 
+/// The active document's linked files, each as it is linked and as the list shows it
+/// ([`shown_script`]).
+fn listed(app: &VectorcraftApp) -> Vec<(String, String)> {
+    app.session.active().map_or_else(Vec::new, |st| st.doc.svg_scripts.iter().map(|f| (f.clone(), shown_script(st, f).into_owned())).collect())
+}
+
+/// The row of `files` ([`listed`]) that `selected` names: the one row linked or shown as it. A
+/// click selects a file as it is linked; a request may also give it as the list shows it. A name
+/// that fits several rows selects none, as `svgInteractivity.removeFile` refuses it.
+fn selected_row(files: &[(String, String)], selected: &str) -> Option<usize> {
+    let mut rows = files.iter().enumerate().filter(|(_, (linked, shown))| linked == selected || shown == selected);
+    match (rows.next(), rows.next()) {
+        (Some((i, _)), None) => Some(i),
+        _ => None,
+    }
+}
+
 fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
-    let files: Vec<String> = app.session.active().map(|st| st.doc.svg_scripts.clone()).unwrap_or_default();
+    let files = listed(app);
     let selected = d.str("selected");
+    let row = selected_row(&files, &selected);
     let mut act = None;
     widgets::list_box(ui, |ui| {
         egui::ScrollArea::vertical().id_salt("javascript-files").min_scrolled_height(140.0).max_height(140.0).show(ui, |ui| {
             ui.set_width(ui.available_width());
             ui.set_min_height(140.0);
             // Paths and URLs are data: shown as they are.
-            for f in &files {
-                if ui.selectable_label(*f == selected, f.as_str()).clicked() {
-                    act = Some(Action::Select(f.clone()));
+            for (i, (linked, shown)) in files.iter().enumerate() {
+                if ui.selectable_label(row == Some(i), shown.as_str()).clicked() {
+                    act = Some(Action::Select(linked.clone()));
                 }
             }
         });
@@ -94,7 +116,7 @@ fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
         if ui.add_enabled_ui(!d.str("file").trim().is_empty(), |ui| widgets::flat_button(ui, tl!("Add"), 64.0)).inner.clicked() {
             act = Some(Action::Add);
         }
-        if ui.add_enabled_ui(files.contains(&selected), |ui| widgets::flat_button(ui, tl!("Remove"), 64.0)).inner.clicked() {
+        if ui.add_enabled_ui(row.is_some(), |ui| widgets::flat_button(ui, tl!("Remove"), 64.0)).inner.clicked() {
             act = Some(Action::Remove);
         }
     });
@@ -164,6 +186,39 @@ mod tests {
         assert!(texts.iter().any(|t| t == "https://example.com/b.js"), "the field shows `file`: {texts:?}");
     }
 
+    /// In a frame drawn with read roots in force, the list names a linked file outside them by its
+    /// file name alone, and that name unlinks it; the person sees the whole path.
+    #[test]
+    fn automation_javascript_files_dialog_hides_outside_root_paths() {
+        let base = std::env::temp_dir().join(format!("vc-js-dialog-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&base);
+        std::fs::create_dir_all(base.join("in")).unwrap();
+        let outside = base.join("outside").join("menu.js").to_string_lossy().into_owned();
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
+        app.session.execute("svgInteractivity.addFile", &json!({ "file": outside })).unwrap();
+        let mut d = Dialog::new(KIND, json!({ "file": "", "selected": "" }));
+        let texts = frame(&mut app, &mut d);
+        assert!(texts.contains(&outside), "{texts:?}");
+        let roots = vectorcraft_engine::file_access::AutomationRoots::new(&[&base.join("in")], &[]).unwrap();
+        let texts = vectorcraft_engine::file_access::confine(roots.as_ref(), || frame(&mut app, &mut d));
+        assert!(texts.iter().any(|t| t == "menu.js") && !texts.iter().any(|t| t.contains("vc-js-dialog")), "{texts:?}");
+        // A row keeps the file as linked, so a click selects it by its whole path, which stays
+        // selected in the person's list; a name a request gives selects it too.
+        let rows = vectorcraft_engine::file_access::confine(roots.as_ref(), || listed(&app));
+        assert_eq!(rows, [(outside.clone(), "menu.js".to_string())]);
+        assert_eq!((selected_row(&rows, &outside), selected_row(&rows, "menu.js")), (Some(0), Some(0)));
+        // A name two rows show selects neither.
+        let twins = [rows[0].clone(), ("/elsewhere/menu.js".to_string(), "menu.js".to_string())];
+        assert_eq!((selected_row(&twins, "menu.js"), selected_row(&twins, "/elsewhere/menu.js")), (None, Some(1)));
+        assert_eq!(listed(&app), [(outside.clone(), outside.clone())], "the person's");
+        // Remove sends the selected name.
+        let removed = vectorcraft_engine::file_access::confine(roots.as_ref(), || app.run("svgInteractivity.removeFile", json!({"file": "menu.js"})));
+        assert!(removed.is_ok(), "{removed:?}");
+        assert!(app.session.active().is_some_and(|st| st.doc.svg_scripts.is_empty()));
+        let _ = std::fs::remove_dir_all(base);
+    }
+
     /// Choose… puts the picked file in File or URL as a `file:///` URL, with no `\` and with
     /// spaces percent-encoded.
     #[test]
diff --git a/crates/ui-egui/src/dialogs/tests.rs b/crates/ui-egui/src/dialogs/tests.rs
index a7d62b6daf..55cf45ce2f 100644
--- a/crates/ui-egui/src/dialogs/tests.rs
+++ b/crates/ui-egui/src/dialogs/tests.rs
@@ -428,6 +428,7 @@ fn dialogs_do_not_stretch_to_the_screen() {
         ("ui.colorGuideOptions", json!({})),
         ("ui.colorBalanceDialog", json!({})),
         ("ui.saturateDialog", json!({})),
+        ("ui.indexedColorDialog", json!({})),
         ("ui.saveSwatchLibrary", json!({})),
         ("ui.flattenTransparencyDialog", json!({})),
         ("ui.expandDialog", json!({})),
diff --git a/crates/ui-egui/src/i18n/bg.tsv b/crates/ui-egui/src/i18n/bg.tsv
index 4c2785956f..e5e4f653ca 100644
--- a/crates/ui-egui/src/i18n/bg.tsv
+++ b/crates/ui-egui/src/i18n/bg.tsv
@@ -614,6 +614,8 @@ font-technology	Variable	Променливи
 	Convert to Artboards	Конвертиране в работни области
 	Convert to CMYK	Конвертиране в CMYK
 	Convert to Grayscale	Конвертиране в ска̀ла на сивото
+	Convert to Indexed Color	Конвертиране в индексирани цветове
+	Convert to Indexed Color…	Конвертиране в индексирани цветове…
 	Convert To Outlines	Конвертиране в контури
 	Convert To Point Type	Конвертиране в точков текст
 	Convert to RGB	Конвертиране в RGB
@@ -4130,6 +4132,9 @@ axis	Both	И двете
 @msg	Couldn't open {name}: {e}	Неуспешно отваряне на {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Неуспешно поставяне на {name}: документът, върху който беше пуснат, е затворен
 @msg	Couldn't place {name}: the document it was placed in was closed	Неуспешно поставяне на {name}: документът, в който се поставяше, е затворен
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Неуспешно поставяне на {name}: документът, върху който беше пуснат, е върнат към запазеното
+@msg	Couldn't place {name}: the document it was placed in was reverted	Неуспешно поставяне на {name}: документът, в който се поставяше, е върнат към запазеното
+@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	Create Outlines: select text objects	Създаване на контури: изберете текстови обекти
diff --git a/crates/ui-egui/src/i18n/bs.tsv b/crates/ui-egui/src/i18n/bs.tsv
index 9ccc94d3a4..42be604f40 100644
--- a/crates/ui-egui/src/i18n/bs.tsv
+++ b/crates/ui-egui/src/i18n/bs.tsv
@@ -103,6 +103,8 @@
 	Blend Vertically	Stopi okomito
 	Convert to CMYK	Pretvori u CMYK
 	Convert to Grayscale	Pretvori u nijanse sive
+	Convert to Indexed Color	Pretvori u indeksirane boje
+	Convert to Indexed Color…	Pretvori u indeksirane boje…
 	Convert to RGB	Pretvori u RGB
 	Invert Colors	Obrni boje
 	Overprint Black…	Pretisak crne…
@@ -4494,6 +4496,9 @@ imageTrace	Outline	Obris
 @msg	Couldn't open {name}: {e}	Nije moguće otvoriti {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Nije moguće postaviti {name}: dokument na koji je ispušten je zatvoren
 @msg	Couldn't place {name}: the document it was placed in was closed	Nije moguće postaviti {name}: dokument u koji je postavljen je zatvoren
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Nije moguće postaviti {name}: dokument na koji je ispušten je vraćen na sačuvano
+@msg	Couldn't place {name}: the document it was placed in was reverted	Nije moguće postaviti {name}: dokument u koji je postavljen je vraćen na sačuvano
+@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	Create Outlines: select text objects	Kreiraj obrise: odaberite tekstualne objekte
diff --git a/crates/ui-egui/src/i18n/ca.tsv b/crates/ui-egui/src/i18n/ca.tsv
index b0159ebc14..5b5c3b49d5 100644
--- a/crates/ui-egui/src/i18n/ca.tsv
+++ b/crates/ui-egui/src/i18n/ca.tsv
@@ -906,6 +906,8 @@ antiAlias	Sharp	Nítid
 	Convert to destination (preserve numbers)	Converteix al destí (conserva els números)
 	Convert to Global	Converteix en global
 	Convert to Grayscale	Converteix a escala de grisos
+	Convert to Indexed Color	Converteix a color indexat
+	Convert to Indexed Color…	Converteix a color indexat…
 	Convert To Outlines	Converteix en contorns
 	Convert To Point Type	Converteix en text de punt
 	Convert to RGB	Converteix a RGB
@@ -5542,6 +5544,9 @@ digits	Malayalam	Malaiàlam
 @msg	Couldn't paste: the document it was pasted in was closed	No s’ha pogut enganxar: el document on s’enganxava s’ha tancat
 @msg	Couldn't place {name}: the document it was dropped on was closed	No s’ha pogut col·locar {name}: el document on es va deixar anar estava tancat
 @msg	Couldn't place {name}: the document it was placed in was closed	No s’ha pogut col·locar {name}: el document on es va col·locar estava tancat
+@msg	Couldn't place {name}: the document it was dropped on was reverted	No s’ha pogut col·locar {name}: el document on es va deixar anar s’ha revertit
+@msg	Couldn't place {name}: the document it was placed in was reverted	No s’ha pogut col·locar {name}: el document on es va col·locar s’ha revertit
+@msg	Couldn't paste: the document it was pasted in was reverted	No s’ha pogut enganxar: el document on s’enganxava s’ha revertit
 @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}
diff --git a/crates/ui-egui/src/i18n/cs.tsv b/crates/ui-egui/src/i18n/cs.tsv
index 27b2d32771..dcf0ad6ed4 100644
--- a/crates/ui-egui/src/i18n/cs.tsv
+++ b/crates/ui-egui/src/i18n/cs.tsv
@@ -108,6 +108,8 @@
 	Blend Vertically	Prolnout svisle
 	Convert to CMYK	Převést na CMYK
 	Convert to Grayscale	Převést na stupně šedi
+	Convert to Indexed Color	Převést na indexované barvy
+	Convert to Indexed Color…	Převést na indexované barvy…
 	Convert to RGB	Převést na RGB
 	Invert Colors	Invertovat barvy
 	Overprint Black…	Přetisknout černou…
@@ -4651,6 +4653,9 @@ imageTrace	Outline	Obrys
 @msg	Couldn't open {name}: {e}	{name} nelze otevřít: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	{name} nelze umístit: dokument, na který byl přetažen, byl zavřen
 @msg	Couldn't place {name}: the document it was placed in was closed	{name} nelze umístit: dokument, do kterého se umísťoval, byl zavřen
+@msg	Couldn't place {name}: the document it was dropped on was reverted	{name} nelze umístit: dokument, na který byl přetažen, byl vrácen k uložené verzi
+@msg	Couldn't place {name}: the document it was placed in was reverted	{name} nelze umístit: dokument, do kterého se umísťoval, byl vrácen k uložené verzi
+@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	Create Outlines: select text objects	Převést na křivky: vyberte textové objekty
diff --git a/crates/ui-egui/src/i18n/da.tsv b/crates/ui-egui/src/i18n/da.tsv
index 3810bb2ac8..79303a36a1 100644
--- a/crates/ui-egui/src/i18n/da.tsv
+++ b/crates/ui-egui/src/i18n/da.tsv
@@ -96,6 +96,8 @@
 	Blend Vertically	Bland lodret
 	Convert to CMYK	Konvertér til CMYK
 	Convert to Grayscale	Konvertér til gråtoner
+	Convert to Indexed Color	Konvertér til indekserede farver
+	Convert to Indexed Color…	Konvertér til indekserede farver…
 	Convert to RGB	Konvertér til RGB
 	Invert Colors	Invertér farver
 	Overprint Black…	Overprint sort…
@@ -4246,6 +4248,9 @@ imageTrace	Outline	Kontur
 @msg	Couldn't open {name}: {e}	Kunne ikke åbne {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Kunne ikke placere {name}: dokumentet, den blev sluppet på, var lukket
 @msg	Couldn't place {name}: the document it was placed in was closed	Kunne ikke placere {name}: dokumentet, den blev placeret i, var lukket
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Kunne ikke placere {name}: dokumentet, den blev sluppet på, blev gendannet
+@msg	Couldn't place {name}: the document it was placed in was reverted	Kunne ikke placere {name}: dokumentet, den blev placeret i, blev gendannet
+@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	Create Outlines: select text objects	Opret konturer: markér tekstobjekter
diff --git a/crates/ui-egui/src/i18n/de.tsv b/crates/ui-egui/src/i18n/de.tsv
index 7b6cd3e8a6..3f754195c8 100644
--- a/crates/ui-egui/src/i18n/de.tsv
+++ b/crates/ui-egui/src/i18n/de.tsv
@@ -607,6 +607,8 @@ font-technology	Variable	Variabel
 	Convert to Artboards	In Zeichenflächen umwandeln
 	Convert to CMYK	In CMYK konvertieren
 	Convert to Grayscale	In Graustufen konvertieren
+	Convert to Indexed Color	In indizierte Farben konvertieren
+	Convert to Indexed Color…	In indizierte Farben konvertieren…
 	Convert To Outlines	In Pfade umwandeln
 	Convert To Point Type	In Punkttext umwandeln
 	Convert to RGB	In RGB konvertieren
@@ -4264,6 +4266,9 @@ theme	Appearance	Erscheinungsbild
 @msg	Couldn't open {name}: {e}	{name} konnte nicht geöffnet werden: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	{name} konnte nicht platziert werden: Das Dokument, auf das die Datei gezogen wurde, wurde geschlossen
 @msg	Couldn't place {name}: the document it was placed in was closed	{name} konnte nicht platziert werden: Das Dokument, in dem die Datei platziert wurde, wurde geschlossen
+@msg	Couldn't place {name}: the document it was dropped on was reverted	{name} konnte nicht platziert werden: Das Dokument, auf das die Datei gezogen wurde, wurde auf die letzte Version zurückgesetzt
+@msg	Couldn't place {name}: the document it was placed in was reverted	{name} konnte nicht platziert werden: Das Dokument, in dem die Datei platziert wurde, wurde auf die letzte Version zurückgesetzt
+@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	Create Outlines: select text objects	In Pfade umwandeln: Wählen Sie Textobjekte aus
diff --git a/crates/ui-egui/src/i18n/el.tsv b/crates/ui-egui/src/i18n/el.tsv
index 8620169f21..284944e8f9 100644
--- a/crates/ui-egui/src/i18n/el.tsv
+++ b/crates/ui-egui/src/i18n/el.tsv
@@ -588,6 +588,8 @@ font-technology	Variable	Μεταβλητές
 	Convert to Artboards	Μετατροπή σε πίνακες σχεδίασης
 	Convert to CMYK	Μετατροπή σε CMYK
 	Convert to Grayscale	Μετατροπή σε κλίμακα του γκρι
+	Convert to Indexed Color	Μετατροπή σε χρώματα με ευρετήριο
+	Convert to Indexed Color…	Μετατροπή σε χρώματα με ευρετήριο…
 	Convert To Outlines	Μετατροπή σε περιγράμματα
 	Convert To Point Type	Μετατροπή σε κείμενο σημείου
 	Convert to RGB	Μετατροπή σε RGB
@@ -2421,6 +2423,9 @@ axis	Both	Και τα δύο
 @msg	Couldn't open {name}: {e}	Δεν ήταν δυνατό το άνοιγμα του {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Δεν ήταν δυνατή η τοποθέτηση του {name}: το έγγραφο στο οποίο αποθέσατε το αρχείο έκλεισε
 @msg	Couldn't place {name}: the document it was placed in was closed	Δεν ήταν δυνατή η τοποθέτηση του {name}: το έγγραφο στο οποίο τοποθετούνταν το αρχείο έκλεισε
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Δεν ήταν δυνατή η τοποθέτηση του {name}: το έγγραφο στο οποίο αποθέσατε το αρχείο επανήλθε στην αποθηκευμένη έκδοση
+@msg	Couldn't place {name}: the document it was placed in was reverted	Δεν ήταν δυνατή η τοποθέτηση του {name}: το έγγραφο στο οποίο τοποθετούνταν το αρχείο επανήλθε στην αποθηκευμένη έκδοση
+@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	Create Outlines: select text objects	Δημιουργία περιγραμμάτων: επιλέξτε αντικείμενα κειμένου
diff --git a/crates/ui-egui/src/i18n/es.tsv b/crates/ui-egui/src/i18n/es.tsv
index a82db20a99..ff28253260 100644
--- a/crates/ui-egui/src/i18n/es.tsv
+++ b/crates/ui-egui/src/i18n/es.tsv
@@ -629,6 +629,8 @@ font-technology	Variable	Variables
 	Convert to Artboards	Convertir en mesas de trabajo
 	Convert to CMYK	Convertir a CMYK
 	Convert to Grayscale	Convertir a escala de grises
+	Convert to Indexed Color	Convertir a color indexado
+	Convert to Indexed Color…	Convertir a color indexado…
 	Convert To Outlines	Convertir en contornos
 	Convert To Point Type	Convertir en texto de punto
 	Convert to RGB	Convertir a RGB
@@ -4341,6 +4343,9 @@ axis	Both	Ambos
 @msg	Couldn't open {name}: {e}	No se pudo abrir {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	No se pudo colocar {name}: se cerró el documento en el que se soltó
 @msg	Couldn't place {name}: the document it was placed in was closed	No se pudo colocar {name}: se cerró el documento en el que se estaba colocando
+@msg	Couldn't place {name}: the document it was dropped on was reverted	No se pudo colocar {name}: se revirtió el documento en el que se soltó
+@msg	Couldn't place {name}: the document it was placed in was reverted	No se pudo colocar {name}: se revirtió el documento en el que se estaba colocando
+@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	Create Outlines: select text objects	Crear contornos: selecciona objetos de texto
diff --git a/crates/ui-egui/src/i18n/fi.tsv b/crates/ui-egui/src/i18n/fi.tsv
index db90a36316..d5aa68e741 100644
--- a/crates/ui-egui/src/i18n/fi.tsv
+++ b/crates/ui-egui/src/i18n/fi.tsv
@@ -116,6 +116,8 @@
 	Blend Vertically	Sulauta pystysuunnassa
 	Convert to CMYK	Muunna CMYK:ksi
 	Convert to Grayscale	Muunna harmaasävyiseksi
+	Convert to Indexed Color	Muunna indeksoiduiksi väreiksi
+	Convert to Indexed Color…	Muunna indeksoiduiksi väreiksi…
 	Convert to RGB	Muunna RGB:ksi
 	Invert Colors	Käännä värit
 	Overprint Black…	Päällepainata musta…
@@ -4565,6 +4567,9 @@ imageTrace	Outline	Ääriviiva
 @msg	Couldn't open {name}: {e}	Tiedostoa {name} ei voitu avata: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Kohdetta {name} ei voitu sijoittaa: asiakirja, johon se pudotettiin, on suljettu
 @msg	Couldn't place {name}: the document it was placed in was closed	Kohdetta {name} ei voitu sijoittaa: asiakirja, johon sitä sijoitettiin, on suljettu
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Kohdetta {name} ei voitu sijoittaa: asiakirja, johon se pudotettiin, on palautettu tallennettuun versioon
+@msg	Couldn't place {name}: the document it was placed in was reverted	Kohdetta {name} ei voitu sijoittaa: asiakirja, johon sitä sijoitettiin, on palautettu tallennettuun versioon
+@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	Create Outlines: select text objects	Muunna ääriviivoiksi: valitse tekstiobjekteja
diff --git a/crates/ui-egui/src/i18n/fr.tsv b/crates/ui-egui/src/i18n/fr.tsv
index 938e43dd48..a88d99fc8b 100644
--- a/crates/ui-egui/src/i18n/fr.tsv
+++ b/crates/ui-egui/src/i18n/fr.tsv
@@ -630,6 +630,8 @@ font-technology	Variable	Variables
 	Convert to Artboards	Convertir en plans de travail
 	Convert to CMYK	Convertir en CMJN
 	Convert to Grayscale	Convertir en niveaux de gris
+	Convert to Indexed Color	Convertir en couleurs indexées
+	Convert to Indexed Color…	Convertir en couleurs indexées…
 	Convert To Outlines	Vectoriser
 	Convert To Point Type	Convertir en texte de point
 	Convert to RGB	Convertir en RVB
@@ -4330,6 +4332,9 @@ axis	Both	Les deux
 @msg	Couldn't open {name}: {e}	Impossible d’ouvrir {name} : {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Impossible d’importer {name} : le document sur lequel il a été déposé a été fermé
 @msg	Couldn't place {name}: the document it was placed in was closed	Impossible d’importer {name} : le document dans lequel il était importé a été fermé
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Impossible d’importer {name} : le document sur lequel il a été déposé a été rétabli à la version précédente
+@msg	Couldn't place {name}: the document it was placed in was reverted	Impossible d’importer {name} : le document dans lequel il était importé a été rétabli à la version précédente
+@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	Create Outlines: select text objects	Vectoriser : sélectionnez des objets texte
diff --git a/crates/ui-egui/src/i18n/hi.tsv b/crates/ui-egui/src/i18n/hi.tsv
index 0eacf9629b..d7507e251b 100644
--- a/crates/ui-egui/src/i18n/hi.tsv
+++ b/crates/ui-egui/src/i18n/hi.tsv
@@ -866,7 +866,7 @@ antiAlias	Sharp	शार्प
 	Close All	सभी बंद करें
 	Close Gaps With Paths	पाथ के साथ अंतराल बंद करें
 	Close Library	लाइब्रेरी
-	Close or Join	बंद करें या शामिल हों
+	Close or Join	बंद करें या जोड़ें
 	Close Panel	पैनल बंद करें
 	Close Path	बंद पाथ
 	Close Path:	बंद पाथ:
@@ -1036,6 +1036,8 @@ antiAlias	Sharp	शार्प
 	Convert to destination (preserve numbers)	गंतव्य में कनवर्ट करें (संख्या संरक्षित करें)
 	Convert to Global	ग्लोबल में कनवर्ट करें
 	Convert to Grayscale	ग्रेस्केल में बदलें
+	Convert to Indexed Color	अनुक्रमित रंग में बदलें
+	Convert to Indexed Color…	अनुक्रमित रंग में बदलें…
 	Convert To Outlines	कन्वर्ट करने के लिए रूपरेखा
 	Convert to Parametric Shape	पैरामीट्रिक शेप में कन्वर्ट करें
 	Convert To Point Type	पॉइंट टाइप में कनवर्ट करें
@@ -1232,7 +1234,7 @@ antiAlias	Sharp	शार्प
 	Default Position	डिफ़ॉल्ट स्थिति
 	Default Printer	डिफ़ॉल्ट प्रिंटर
 	Default Swatches	डिफ़ॉल्ट स्वॉचेस
-	Define a variable first	पहले एक चर को परिभाषित करें
+	Define a variable first	पहले एक वेरिएबल परिभाषित करें
 	Define Grid…	ग्रिड परिभाषित…
 	Define Perspective Grid	पर्सपेक्टिव ग्रिड डिफ़ाइन करें
 	Define Perspective Grid…	पर्सपेक्टिव ग्रिड डिफ़ाइन करें…
@@ -1308,7 +1310,7 @@ antiAlias	Sharp	शार्प
 	Delete this saved preset	इस सेव किए गए प्रीसेट को हटा दें
 	Delete Toolbar	टूलबार हटाएं
 	Delete Transparency Flattener Preset	पारदर्शिता फ़्लैटनर प्रीसेट हटाएँ
-	Delete Variable	चर हटाएँ
+	Delete Variable	वेरिएबल हटाएँ
 	Delete Variables	वेरिएबल्स हटाएँ
 	Delete View	व्यू हटाएँ
 	Delete Width Point	चौड़ाई बिंदु हटाएँ
@@ -2251,7 +2253,7 @@ antiAlias	Sharp	शार्प
 	Highlight Substituted Fonts	हाईलाइट सबस्टिट्यूटेड फ़ॉन्ट
 	Highlight Substituted Glyphs	बदले हुए ग्लिफ़ हाइलाइट करें
 	Highlight Tracking	हाइलाइट ट्रैकिंग
-	Highlight Variable	उच्च प्रकाश परिवर्तनीय
+	Highlight Variable	वेरिएबल हाइलाइट करें
 	Highlight:	हाइलाइट:
 	Hindi	हिन्दी
 	History	हिस्ट्री
@@ -2440,9 +2442,9 @@ antiAlias	Sharp	शार्प
 	Join	जोड़ें
 	Join our Discord	हमारे डिसकॉर्ड में शामिल हों
 	Join Our Discord	हमारे डिसकॉर्ड में शामिल हों
-	Join Point Text	पॉइंट टेक्स्ट में शामिल हों
+	Join Point Text	पॉइंट टेक्स्ट जोड़ें
 	Join the ArtCraft community on Discord (discord.gg/artcraft)	Discord (discord.gg/artcraft) पर ArtCraft समुदाय में शामिल हों
-	Join the lines of each paragraph	प्रत्येक पैराग्राफ की लाइनों में शामिल हों
+	Join the lines of each paragraph	हर पैराग्राफ़ की लाइनें जोड़ें
 	Join Tool	जॉइन टूल
 	Joins	जुड़ना
 	Joins:	जुड़ना:
@@ -2644,7 +2646,7 @@ antiAlias	Sharp	शार्प
 	List Preferences	सूची प्राथमिकताएं
 	List Slices	सूची स्लाइस
 	List Toolbars	सूची टूलबार
-	List Variables	सूची चर
+	List Variables	वेरिएबल्स सूचीबद्ध करें
 	List View	सूची दृश्य
 	List Workspaces	सूची वर्कस्पेस
 	Live curve fitting	लाइव वक्र फिटिंग
@@ -2667,8 +2669,8 @@ antiAlias	Sharp	शार्प
 	Load SVG into Clipboard	SVG को क्लिपबोर्ड में लोड करें
 	Load Text into Clipboard	क्लिपबोर्ड में टेक्स्ट लोड करें
 	Load Texture…	लोड बनावट…
-	Load Variable Library	लोड परिवर्तनीय लाइब्रेरी
-	Load Variable Library…	लोड परिवर्तनीय लाइब्रेरी…
+	Load Variable Library	वेरिएबल लाइब्रेरी लोड करें
+	Load Variable Library…	वेरिएबल लाइब्रेरी लोड करें…
 	Loaded Texture	भारित बनावट
 	Loads native code	मूल कोड लोड करता है
 	Local Libraries	स्थानीय लाइब्रेरी
@@ -2690,7 +2692,7 @@ antiAlias	Sharp	शार्प
 	Lock Selected	लॉक सिलेक्टेड
 	Lock Slices	स्लाइस लॉक करें
 	Lock Station Point	लॉक स्टेशन पॉइंट
-	Lock Variables	लॉक चर
+	Lock Variables	वेरिएबल्स लॉक करें
 	Locked	लॉक्ड
 	Logo 1000×1000	लोगो 1000 × 1000
 	Long	लंबा
@@ -3007,8 +3009,8 @@ antiAlias	Sharp	शार्प
 	New theme from the current color	वर्तमान रंग से नया विषय
 	New Toolbar	नया टूलबार
 	New Toolbar…	नया टूलबार…
-	New Variable	नया परिवर्तनीय
-	New Variable…	नई परिवर्तनीय…
+	New Variable	नया वेरिएबल
+	New Variable…	नया वेरिएबल…
 	New View	नया दृश्य
 	New View…	नया दृश्य…
 	New Window	नई विंडो
@@ -3073,7 +3075,7 @@ antiAlias	Sharp	शार्प
 	No text selected	कोई टेक्स्ट नहीं चुना गया
 	No Thumbnails	कोई थंबनेल नहीं
 	No unused symbols	अप्रयुक्त सिंबल
-	no variable to rename	नाम बदलने के लिए कोई चर नहीं
+	no variable to rename	नाम बदलने के लिए कोई वेरिएबल नहीं
 	Noise	नॉइज़
 	Nonbreaking Hyphen	न टूटने वाला हाइफ़न
 	Nonbreaking Space	न टूटने वाला स्पेस
@@ -3734,7 +3736,7 @@ antiAlias	Sharp	शार्प
 	Rays	रे
 	Read Action Set File	एक्शन सेट फ़ाइल पढ़ें
 	Read Shortcut Set File	शॉर्टकट सेट फ़ाइल पढ़ें
-	Reads or sets environment variables	पर्यावरण चर पढ़ता है या सेट करता है
+	Reads or sets environment variables	एनवायरनमेंट वेरिएबल्स पढ़ता है या सेट करता है
 	Ready	तैयार
 	Real name	वास्तविक नाम
 	Real World:	रियल वर्ल्ड:
@@ -3909,7 +3911,7 @@ antiAlias	Sharp	शार्प
 	Rename Preset	प्रीसेट का नाम बदलें
 	Rename Style	स्टाइल का नाम बदलें
 	Rename Toolbar	टूलबार नाम दें
-	Rename Variable	चर का नाम बदलें
+	Rename Variable	वेरिएबल का नाम बदलें
 	Rename View	व्यू का नाम बदलें
 	Rename Workspace	वर्कस्पेस का नाम बदलें
 	Rename…	नाम बदलें…
@@ -4205,7 +4207,7 @@ antiAlias	Sharp	शार्प
 	Save To:	यहाँ सेव करें:
 	Save Transparency Flattener Preset	ट्रांसपेरेंसी फ़्लैटनर प्रीसेट सेव करें
 	Save Transparency Flattener Preset…	ट्रांसपेरेंसी फ़्लैटनर प्रीसेट सेव करें…
-	Save Variable Library…	वैरिएबल लाइब्रेरी सेव करें…
+	Save Variable Library…	वेरिएबल लाइब्रेरी सेव करें…
 	Save…	सेव…
 	Saved	सेव किए गए
 	SAVED	सेव किए गए
@@ -5377,11 +5379,11 @@ antiAlias	Sharp	शार्प
 	V Spacing:	वी स्पेसिंग:
 	V:	V:
 	Value Axis	मूल्य एक्सिस
-	Variable	चर
+	Variable	वेरिएबल
 	Variable Font	वेरिएबल फ़ॉन्ट
-	Variable Options	वैरिएबल ऑप्शन्स
-	Variable Options…	परिवर्तनीय ऑप्शन्स…
-	Variable Width Profile	वैरिएबल चौड़ाई प्रोफ़ाइल
+	Variable Options	वेरिएबल ऑप्शन्स
+	Variable Options…	वेरिएबल ऑप्शन्स…
+	Variable Width Profile	वेरिएबल चौड़ाई प्रोफ़ाइल
 	Variables	वेरिएबल्स
 	Variation	वैरिएशन
 	Variation:	भिन्नता:
@@ -6030,7 +6032,7 @@ antiAlias	Sharp	शार्प
 @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	`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	`expand` must be true or false	`expand` को true या false होना चाहिए
@@ -6246,7 +6248,7 @@ antiAlias	Sharp	शार्प
 @msg	a multi-layer mask needs one clipping path	बहुलेयर मास्क को एक क्लिपिंग पाथ की आवश्यकता होती है
 @msg	a multi-layer mask's operators are out of order	बहुलेयर मास्क ऑपरेटर क्रम से बाहर हैं
 @msg	a name names one asset: give multiple: false, or one object	एक नाम एक ही एसेट को दर्शाता है: multiple: false दें, या एक ऑब्जेक्ट
-@msg	a new document refuses this file because of these variables: {names}	एक नया डॉक्यूमेंट इन चरों के कारण इस फ़ाइल को मना कर देता है: {names}
+@msg	a new document refuses this file because of these variables: {names}	इन वेरिएबल्स के कारण नया डॉक्यूमेंट इस फ़ाइल को स्वीकार नहीं करता: {names}
 @msg	a new document won't read these variables back with their kind: {names}	नया डॉक्यूमेंट इन वेरिएबल्स का प्रकार वापस नहीं पढ़ पाएगा: {names}
 @msg	a page can't be read	एक पेज पढ़ा नहीं जा सकता
 @msg	a page is missing	एक पेज गायब हो रहा है
@@ -6298,8 +6300,8 @@ antiAlias	Sharp	शार्प
 @msg	a toolbar name has at most {MAX_NAME} characters	टूलबार नाम में सबसे {MAX_NAME} वर्ण हैं
 @msg	a value has the wrong type for the operator	एक मूल्य ऑपरेटर के लिए गलत प्रकार है
 @msg	a value is outside the range the operator takes	एक मूल्य सीमा के बाहर है जो ऑपरेटर लेता है
-@msg	a variable library holds text variables, and the document has none	एक परिवर्तनीय लाइब्रेरी टेक्स्ट चर रखती है, और डॉक्यूमेंट में कोई नहीं है
-@msg	a variable of unknown kind can't be bound to objects	अज्ञात प्रकार की एक चर ऑब्जेक्ट्स के लिए बाध्य नहीं किया जा सकता है
+@msg	a variable library holds text variables, and the document has none	वेरिएबल लाइब्रेरी में टेक्स्ट वेरिएबल होते हैं, लेकिन डॉक्यूमेंट में कोई नहीं है
+@msg	a variable of unknown kind can't be bound to objects	अज्ञात प्रकार का वेरिएबल ऑब्जेक्ट्स से नहीं बाँधा जा सकता
 @msg	a view named `{_1}` exists	`{_1}` नामक दृश्य मौजूद है
 @msg	a view named `{name}` exists	`{name}` नामक दृश्य मौजूद है
 @msg	a workspace keeps at most {MAX} toolbars	एक वर्कस्पेस सबसे {MAX} टूलबार में रहता है
@@ -6438,7 +6440,7 @@ antiAlias	Sharp	शार्प
 @msg	batches cannot nest	बैच घोंसला नहीं कर सकते
 @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	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	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 रखें
@@ -6512,20 +6514,20 @@ antiAlias	Sharp	शार्प
 @msg	colour groups can't go into colour groups	रंग समूह रंग समूहों में नहीं जा सकते हैं
 @msg	colour, mode and spot apply to solid-colour swatches only	रंग, मोड और स्पॉट केवल ठोस रंग वाले स्वॉच पर लागू होते हैं
 @msg	column {column}: `{cell}` is a `%` column of graph data files, which are not read	कॉलम {column}: `{cell}` ग्राफ़ डेटा फ़ाइल का `%` कॉलम है, जिसे पढ़ा नहीं जाता
-@msg	column {column}: `{cell}` names `{name}`, which is a {_1} variable	कॉलम {column}: `{cell}` नाम `{name}`, जो एक {_1} चर है
-@msg	column {column}: `{cell}` names no variable	कॉलम {column}: `{cell}` नाम कोई चर नहीं
-@msg	column {column}: the variable name is longer than {MAX_NAME} characters	कॉलम {column}: चर नाम {MAX_NAME} अक्षरों से लंबा है
+@msg	column {column}: `{cell}` names `{name}`, which is a {_1} variable	कॉलम {column}: `{cell}` में `{name}` नाम का {_1} वेरिएबल है
+@msg	column {column}: `{cell}` names no variable	कॉलम {column}: `{cell}` किसी वेरिएबल का नाम नहीं है
+@msg	column {column}: the variable name is longer than {MAX_NAME} characters	कॉलम {column}: वेरिएबल का नाम {MAX_NAME} कैरेक्टर से लंबा है
 @msg	column docks a set as a dock column, with no anchor or icon	कॉलम एक डॉक कॉलम के रूप में सेट करता है, जिसमें कोई एंकर या आइकन नहीं होता है
 @msg	column must be true or a number from 1	column को true या 1 या उससे बड़ी संख्या होना चाहिए
 @msg	column: true floats the whole column and takes no onto, above or below	column: true पूरे कॉलम को फ़्लोट करता है और onto, above या below नहीं लेता
-@msg	columns {first} and {column} both name the variable `{name}`	कॉलम {first} और {column} दोनों नाम चर `{name}`
+@msg	columns {first} and {column} both name the variable `{name}`	कॉलम {first} और {column} दोनों में वेरिएबल `{name}` का नाम है
 @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	commands[{i}]: missing `command`	आदेश [{i}]: लापता `command`
 @msg	composer must be "singleLine" or "everyLine"	composer: संगीतकार "singleLine" या "everyLine" होना चाहिए।
-@msg	compound {_1} must contain exactly one open path to join	यौगिक {_1} में शामिल होने के लिए बिल्कुल एक खुला रास्ता होना चाहिए
+@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 अभी तक पढ़ा नहीं जा सकता है
@@ -6659,6 +6661,9 @@ antiAlias	Sharp	शार्प
 @msg	Couldn't place {name}: {e}	नहीं रह सकता {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	नहीं था {name}: यह डॉक्यूमेंट बंद हो गया था
 @msg	Couldn't place {name}: the document it was placed in was closed	नहीं था {name}: यह डॉक्यूमेंट बंद किया गया था
+@msg	Couldn't place {name}: the document it was dropped on was reverted	{name} प्लेस नहीं कर सका: जिस डॉक्यूमेंट पर इसे छोड़ा गया था, उसे मूल स्थिति में लाया गया
+@msg	Couldn't place {name}: the document it was placed in was reverted	{name} प्लेस नहीं कर सका: जिस डॉक्यूमेंट में इसे प्लेस किया जा रहा था, उसे मूल स्थिति में लाया गया
+@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	counterPer `{c}`: item or file	counterPer `{c}`: item या file
@@ -6686,11 +6691,11 @@ antiAlias	Sharp	शार्प
 @msg	data must be an object of key: value, not {v}	data: डेटा कुंजी का एक ऑब्जेक्ट होना चाहिए: मान, नहीं {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}` में एक नियंत्रण चरित्र होता है, जो एक परिवर्तनीय लाइब्रेरी पकड़ नहीं सकता है
+@msg	data set `{name}` holds a control character, which a variable library can't hold	डेटा सेट `{name}` में एक कंट्रोल कैरेक्टर है, जिसे वेरिएबल लाइब्रेरी में नहीं रखा जा सकता
 @msg	data set `{name}` holds a value for `{var}`, which the library doesn't declare	डेटा सेट `{name}` `{var}` के लिए एक मान रखता है, जिसे लाइब्रेरी घोषित नहीं करती है
 @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 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 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}` पहले से मौजूद है
@@ -6698,7 +6703,7 @@ antiAlias	Sharp	शार्प
 @msg	date `{d}`: YYYY-MM-DD	दिनांक `{d}`: YYYYY-MM-DD
 @msg	decimals must be {_1}–{_2} (got {_3})	decimals: दशमलव होना चाहिए {_1}-{_2} ({_3})
 @msg	decoded data is too large	डीकोडेड डेटा बहुत बड़ा है
-@msg	define a variable first	पहले एक चर को परिभाषित करना
+@msg	define a variable first	पहले एक वेरिएबल परिभाषित करें
 @msg	detect must be true or false	detect को true या false होना चाहिए
 @msg	Dimension is locked or hidden	आयाम बंद या छिपा हुआ है
 @msg	Dimension mode does not match its source	आयाम मोड अपने स्रोत से मेल नहीं खाता है
@@ -7018,9 +7023,9 @@ antiAlias	Sharp	शार्प
 @msg	its Windows metafile preview was opened instead, which may simplify the art	इसके बजाय विंडोज मेटाफ़ाइल प्रीव्यू ओपन किया गया था, जो कला को सरल बना सकता है
 @msg	its zlib compression is damaged	इसके zlib संपीड़न क्षतिग्रस्त है
 @msg	its Zstandard compression is damaged	इसके Zstandard संपीड़न क्षतिग्रस्त है
-@msg	join needs open paths	join: खुले रास्ते की जरूरत
-@msg	join two different paths	दो अलग-अलग पाथ में शामिल हों
-@msg	Join: a subpath went missing	जॉइन: कोई सबपाथ नहीं मिला
+@msg	join needs open paths	जोड़ने के लिए खुले पाथ चाहिए
+@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	kerning must be a number, "auto", or "optical"	kerning एक संख्या, "auto", या "optical" होना चाहिए
@@ -7047,7 +7052,7 @@ antiAlias	Sharp	शार्प
 @msg	line {line}: unclosed quote	लाइन {line}: unclosed उद्धरण
 @msg	line {line}: value for `{var}` is longer than {MAX_GRAPH_CSV} bytes	लाइन {line}: `{var}` के लिए मूल्य {MAX_GRAPH_CSV} बाइट्स से अधिक है
 @msg	line {line}: value for `{var}` must be true or false	लाइन {line}: `{var}` के लिए मान true या false होना चाहिए
-@msg	line {line}: value for `{var}` must match its variable kind	लाइन {line}: `{var}` के लिए मान इसके परिवर्तनीय प्रकार से मेल खाता होना चाहिए
+@msg	line {line}: value for `{var}` must match its variable kind	लाइन {line}: `{var}` का मान वेरिएबल के प्रकार से मेल खाना चाहिए
 @msg	lineEndings `{other}`: lf or crlf	lineEndings `{other}`: lf या crlf
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	लिंक किए गए चित्रों से पता चलता है कि फ़ाइल में सेव किए जाने वाले निम्न-रिज़ॉल्यूशन प्रीव्यू को उनकी फ़ाइलों को मिलने तक: लिंक पैनल में उन्हें फिर से लिंक करें
 @msg	linked pictures with no preview in the file show a placeholder until their files are found: relink them in the Links panel	फ़ाइल में कोई प्रीव्यू के साथ जुड़े चित्र एक प्लेसहोल्डर दिखाते हैं जब तक कि उनकी फ़ाइलें नहीं मिलती: उन्हें लिंक पैनल में फिर से लिंक करें
@@ -7162,7 +7167,7 @@ antiAlias	Sharp	शार्प
 @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} फ़ाइलों से अधिक
-@msg	more than {MAX_CSV_COLS} variables: Import Data Sets reads at most {MAX_CSV_COLS}	{MAX_CSV_COLS} से अधिक चर: आयात डेटा सेट अधिकांश {MAX_CSV_COLS} पर पढ़ा जाता है।
+@msg	more than {MAX_CSV_COLS} variables: Import Data Sets reads at most {MAX_CSV_COLS}	{MAX_CSV_COLS} से अधिक वेरिएबल्स: डेटा सेट आयात अधिकतम {MAX_CSV_COLS} वेरिएबल्स पढ़ता है
 @msg	more than {MAX_CSV_ROWS} data rows	{MAX_CSV_ROWS} डेटा पंक्तियों से अधिक
 @msg	more than {MAX_CSV_ROWS} data sets: Import Data Sets reads at most {MAX_CSV_ROWS}	{MAX_CSV_ROWS} डेटा सेट से अधिक: आयात डेटा सेट अधिकांश {MAX_CSV_ROWS} पर पढ़ा जाता है।
 @msg	more than {MAX_FILES} images	{MAX_FILES} इमेज से अधिक
@@ -7418,10 +7423,10 @@ antiAlias	Sharp	शार्प
 @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}`
-@msg	no variable named `{from}`	कोई चर नाम `{from}`
-@msg	no variable named `{name}`	कोई चर नाम `{name}`
-@msg	no variable named `{v}`	कोई चर नाम `{v}`
-@msg	no variable named `{var}`	कोई चर नाम `{var}`
+@msg	no variable named `{from}`	`{from}` नाम का कोई वेरिएबल नहीं है
+@msg	no variable named `{name}`	`{name}` नाम का कोई वेरिएबल नहीं है
+@msg	no variable named `{v}`	`{v}` नाम का कोई वेरिएबल नहीं है
+@msg	no variable named `{var}`	`{var}` नाम का कोई वेरिएबल नहीं है
 @msg	no view named `{name}`	`{name}` नाम का कोई दृश्य
 @msg	node {_1} is not a graph	node {_1} एक graph नहीं है
 @msg	node {_1} is not an image	node {_1} एक इमेज नहीं है
@@ -7480,7 +7485,7 @@ antiAlias	Sharp	शार्प
 @msg	not JSON: {e}	JSON नहीं है: {e}
 @msg	not type on a path outside perspective	दृष्टिकोण के बाहर एक पाथ पर टाइप न करें
 @msg	nothing encoded	कुछ भी नहीं
-@msg	nothing in data set {name} was applied: no object is bound to a variable it has a value for	डेटा सेट {name} में कुछ भी लागू नहीं किया गया था: कोई ऑब्जेक्ट एक चर के लिए बाध्य नहीं है, इसके लिए एक मूल्य है।
+@msg	nothing in data set {name} was applied: no object is bound to a variable it has a value for	डेटा सेट {name} से कुछ भी लागू नहीं हुआ: उसमें मान वाले किसी भी वेरिएबल से कोई ऑब्जेक्ट नहीं बाँधा गया है
 @msg	nothing prints	कुछ भी प्रिंट
 @msg	nothing selected	कुछ भी नहीं चुना
 @msg	nothing selected is in a group	कुछ भी नहीं चुना गया है एक समूह में
@@ -7531,7 +7536,7 @@ antiAlias	Sharp	शार्प
 @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	ऑब्जेक्ट्स को छोड़ दिया गया था
-@msg	objects with several fills or strokes, variable-width strokes, effects or brushes came in as their drawn look ({_1}): their appearance isn't editable yet	कई भराव या स्ट्रोक, परिवर्तनीय चौड़ाई वाले स्ट्रोक, इफ़ेक्ट या ब्रश के साथ ऑब्जेक्टएं उनके ड्रॉइंग लुक ({_1}) के रूप में आईं: उनकी उपस्थिति अभी तक संपादन योग्य नहीं है
+@msg	objects with several fills or strokes, variable-width strokes, effects or brushes came in as their drawn look ({_1}): their appearance isn't editable yet	कई भराव या स्ट्रोक, वेरिएबल चौड़ाई वाले स्ट्रोक, इफ़ेक्ट या ब्रश के साथ ऑब्जेक्टएं उनके ड्रॉइंग लुक ({_1}) के रूप में आईं: उनकी उपस्थिति अभी तक संपादन योग्य नहीं है
 @msg	offset out of range	सीमा से बाहर ऑफसेट
 @msg	Offset Path: {e}	ऑफसेट पाथ: {e}
 @msg	Offset Path: select paths	ऑफसेट पाथ: सिलेक्शन पाथ
@@ -7688,7 +7693,7 @@ antiAlias	Sharp	शार्प
 @msg	redraw needs id	redraw: ई.डी. की आवश्यकता
 @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	Rejoin पाथ के टुकड़े: एक बार में फिर से जुड़ने के लिए कई पाथ
+@msg	Rejoin Path Pieces: too many paths to rejoin at once	पाथ के हिस्से फिर से जोड़ें: एक बार में फिर से जोड़ने के लिए बहुत अधिक पाथ हैं
 @msg	release a layer or a group	एक लेयर या एक समूह को छोड़ दें
 @msg	Release Guides: no guides	रिलीज़ गाइड: कोई गाइड नहीं
 @msg	Release: no layer to put the rectangle in	रिलीज: आयत को डालने के लिए कोई लेयर नहीं
@@ -7755,7 +7760,7 @@ antiAlias	Sharp	शार्प
 @msg	select a path	एक पाथ चुनें
 @msg	select a repeat	दोहराने सिलेक्ट करें
 @msg	select a Shaper group	एक शेपर समूह चुनें
-@msg	select a stroke with a variable width	एक चर चौड़ाई के साथ एक स्ट्रोक सिलेक्ट करें
+@msg	select a stroke with a variable width	वेरिएबल चौड़ाई वाला स्ट्रोक सिलेक्ट करें
 @msg	select a symbol instance	एक सिंबल उदाहरण चुनें
 @msg	select a text object	एक टेक्स्ट ऑब्जेक्ट चुनें
 @msg	select an envelope	एक लिफाफे सिलेक्ट करें
@@ -7800,7 +7805,7 @@ antiAlias	Sharp	शार्प
 @msg	select at least two objects	कम से कम दो ऑब्जेक्ट चुनें
 @msg	Select dimensions to update	अद्यतन करने के लिए आयाम सिलेक्ट करें
 @msg	select exactly two objects	वास्तव में दो ऑब्जेक्ट चुनें
-@msg	select exactly two path ends to join	वास्तव में दो पाथ में शामिल होने के लिए समाप्त होता है चुनें
+@msg	select exactly two path ends to join	जोड़ने के लिए ठीक दो पाथ एंड पॉइंट्स सिलेक्ट करें
 @msg	Select horizontal point or area type whose text fits	ऐसा क्षैतिज पॉइंट टाइप या एरिया टाइप सिलेक्ट करें जिसका टेक्स्ट फ़िट होता है
 @msg	select instances of one symbol	एक सिंबल के उदाहरण चुनें
 @msg	select members of a compound shape	एक मिश्रित आकार के सदस्यों सिलेक्ट करें
@@ -7817,7 +7822,7 @@ antiAlias	Sharp	शार्प
 @msg	select paths	पाथ चुनें
 @msg	select paths or anchor points	पाथ या एंकर अंक चुनें
 @msg	select paths or compound paths	पाथ या यौगिक पाथ सिलेक्ट करें
-@msg	select paths to join	शामिल होने के लिए पाथ सिलेक्ट करें
+@msg	select paths to join	जोड़ने के लिए पाथ सिलेक्ट करें
 @msg	select paths with dashed strokes to expand	विस्तृत करने के लिए डैश स्ट्रोक के साथ पाथ सिलेक्ट करें
 @msg	select paths, or segments, to divide	विभाजित करने के लिए पाथ, या खंड चुनें
 @msg	select plain rectangles, ellipses or regular polygons to convert	बदलने के लिए सादे आयत, अंडाकार या नियमित बहुभुजों सिलेक्ट करें
@@ -7846,7 +7851,7 @@ antiAlias	Sharp	शार्प
 @msg	select the objects to attach to the path	ऑब्जेक्ट्स का सिलेक्ट करने के लिए संलग्न करने के लिए पाथ
 @msg	select the objects to bind	ऑब्जेक्ट्स को बांधने के लिए चुनें
 @msg	select the objects to transform in perspective	ऑब्जेक्ट्स को पर्सपेक्टिव में बदलने के लिए चुनें
-@msg	select two open path ends, or two open paths, to average and join	दो खुले पाथ सिलेक्ट करें, या दो खुले रास्ते, औसतन और जुड़ना
+@msg	select two open path ends, or two open paths, to average and join	औसत निकालकर जोड़ने के लिए दो खुले पाथ एंड पॉइंट्स या दो खुले पाथ सिलेक्ट करें
 @msg	select two or more graphic styles to merge	दो या अधिक ग्राफिक स्टाइल्स का सिलेक्ट करने के लिए विलय
 @msg	select two or more objects to distribute	वितरित करने के लिए दो या दो से अधिक ऑब्जेक्ट चुनें
 @msg	select two or more objects to intertwine	दो या दो से अधिक ऑब्जेक्ट्स सिलेक्ट करें
@@ -7903,7 +7908,7 @@ antiAlias	Sharp	शार्प
 @msg	strokeOptions must be an object of stroke.set options	strokeOptions को stroke.set ऑप्शन्स का ऑब्जेक्ट होना चाहिए
 @msg	strokeWidth must be a positive number of pixels	strokeWidth को पिक्सेल की धनात्मक संख्या होना चाहिए
 @msg	subpath {si} is not an open subpath	उपपाथ {si} एक खुला उपपाथ नहीं है
-@msg	subpaths required when joining the same path	एक ही पाथ में शामिल होने पर आवश्यक उप-पाथ
+@msg	subpaths required when joining the same path	एक ही पाथ को जोड़ने के लिए सबपाथ चाहिए
 @msg	SVG is not UTF-8, UTF-16 or ISO 8859-1	SVG UTF-8, UTF-16 या ISO 8859-1 नहीं है।
 @msg	SVG parse error: {0}	SVG पार्स त्रुटि: {0}
 @msg	swatchConflict must be "merge" or "add", not {v}	swatchConflict को "merge" या "add" होना चाहिए, {v} नहीं
@@ -8058,9 +8063,9 @@ antiAlias	Sharp	शार्प
 @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 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}): वेरिएबल्स पैनल बाकी हिस्सों को सूचीबद्ध करता है
+@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}): वेरिएबल्स पैनल शेष प्रविष्टियाँ दिखाता है
 @msg	the files come to more than 1 GB: add fewer at a time	फ़ाइलों को 1 GB से अधिक करने के लिए आते हैं: एक समय में कम जोड़ें
 @msg	the first character of a line has no character before it to kern: it moves only up and down (dy)	एक पंक्ति के पहले चरित्र में बर्न से पहले कोई चरित्र नहीं है: यह केवल ऊपर और नीचे चला जाता है (डी)
 @msg	the font {_1} is not available	फ़ॉन्ट {_1} उपलब्ध नहीं है
@@ -8073,7 +8078,7 @@ antiAlias	Sharp	शार्प
 @msg	The graphics were lost and couldn't be restarted.	ग्राफिक्स खो गए थे और फिर से शुरू नहीं किया जा सकता था।
 @msg	The graphics were lost and have been restarted	ग्राफिक्स खो गए थे और फिर से शुरू किया गया है
 @msg	the guide is on a hidden or locked layer	गाइड एक छिपे हुए या बंद लेयर पर है
-@msg	the header `{cell}` for `{name}` would read back as the variable `{other}`: rename one of them	हेडर `{cell}` के लिए `{name}` वापस चर `{other}` के रूप में पढ़ेगा: उनमें से एक का नाम बदलें
+@msg	the header `{cell}` for `{name}` would read back as the variable `{other}`: rename one of them	हेडर `{cell}` के लिए `{name}` वापस वेरिएबल `{other}` के रूप में पढ़ेगा: उनमें से एक का नाम बदलें
 @msg	the header `{header}` for `{name}` would read back as the variable `{other}`: rename one of them	`{name}` का हेडर `{header}` दोबारा पढ़ने पर वेरिएबल `{other}` बन जाएगा: किसी एक का नाम बदलें
 @msg	the image `{path}` isn't followed: {r}	इमेज `{path}` का पालन नहीं किया गया है: {r}
 @msg	the image can't be read as a texture	इमेज को बनावट के रूप में नहीं पढ़ा जा सकता है
@@ -8238,14 +8243,14 @@ antiAlias	Sharp	शार्प
 @msg	the trailer has no size	ट्रेलर में कोई आकार नहीं है
 @msg	the type object is flattened to nothing	फ़्लैटन करने पर टाइप ऑब्जेक्ट में कुछ नहीं रहता
 @msg	the value of axis `{tag}` must be a number or null	धुरी का मूल्य `{tag}` होना चाहिए एक नंबर या null होना चाहिए
-@msg	the variable library declares more than {MAX_LIBRARY_DATASETS} data sets	परिवर्तनीय लाइब्रेरी {MAX_LIBRARY_DATASETS} डेटा सेट से अधिक घोषित करता है
+@msg	the variable library declares more than {MAX_LIBRARY_DATASETS} data sets	वेरिएबल लाइब्रेरी में {MAX_LIBRARY_DATASETS} से अधिक डेटा सेट घोषित हैं
 @msg	the variable library declares more than {MAX_LIBRARY_ENTITIES} entities	वेरिएबल लाइब्रेरी {MAX_LIBRARY_ENTITIES} संस्थाओं से अधिक की घोषणा करती है।
-@msg	the variable library declares more than {MAX_LIBRARY_VARIABLES} variables	परिवर्तनीय लाइब्रेरी {MAX_LIBRARY_VARIABLES} चर से अधिक घोषित करता है।
+@msg	the variable library declares more than {MAX_LIBRARY_VARIABLES} variables	वेरिएबल लाइब्रेरी {MAX_LIBRARY_VARIABLES} से अधिक वेरिएबल्स घोषित करती है
 @msg	the variable library declares no variables	वेरिएबल लाइब्रेरी ने कोई वेरिएबल घोषित नहीं किया है
-@msg	the variable library is larger than {MAX_LIBRARY_BYTES} bytes	परिवर्तनीय लाइब्रेरी {MAX_LIBRARY_BYTES} बाइट्स से बड़ा है
-@msg	the variable library is not UTF-8	चर लाइब्रेरी UTF-8 नहीं है
+@msg	the variable library is larger than {MAX_LIBRARY_BYTES} bytes	वेरिएबल लाइब्रेरी {MAX_LIBRARY_BYTES} बाइट से बड़ी है
+@msg	the variable library is not UTF-8	वेरिएबल लाइब्रेरी UTF-8 में नहीं है
 @msg	the variable library is not well-formed XML: {e}	वेरिएबल लाइब्रेरी अच्छी तरह से निर्मित XML नहीं है: {e}
-@msg	the variable library nests elements more than {MAX_LIBRARY_NESTING} deep	परिवर्तनीय लाइब्रेरी घोंसला तत्वों से अधिक {MAX_LIBRARY_NESTING} गहरा
+@msg	the variable library nests elements more than {MAX_LIBRARY_NESTING} deep	वेरिएबल लाइब्रेरी में एलिमेंट {MAX_LIBRARY_NESTING} स्तर से अधिक गहराई तक नेस्ट किए गए हैं
 @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	विंडो में कोई डॉक नहीं है
@@ -8464,14 +8469,14 @@ antiAlias	Sharp	शार्प
 @msg	unsupported: {0}	unsupported: {0}
 @msg	use paths or compound paths	पाथ या यौगिक पाथ का उपयोग करें
 @msg	useArtboards must be true or false, not {v}	useArtboards को true या false होना चाहिए, {v} नहीं
-@msg	value for `{var}` must match its variable kind	`{var}` के लिए मूल्य अपने परिवर्तनीय प्रकार से मेल खाता होना चाहिए
-@msg	variable `{_1}` is already defined	चर `{_1}` पहले से ही परिभाषित किया गया है
+@msg	value for `{var}` must match its variable kind	`{var}` का मान वेरिएबल के प्रकार से मेल खाना चाहिए
+@msg	variable `{_1}` is already defined	वेरिएबल `{_1}` पहले से परिभाषित है
 @msg	variable `{name}` can't be saved in a variable library: rename it to start with a letter or `_`, without spaces or symbols other than `-`, `_` and `.`	वेरिएबल `{name}` वेरिएबल लाइब्रेरी में सेव किया नहीं जा सकता: नाम अक्षर या `_` से शुरू करें, स्पेस और `-`, `_`, `.` के अलावा अन्य चिह्न न रखें
-@msg	variable `{name}` has no `trait`	चर `{name}` में कोई `trait` नहीं है
-@msg	variable `{name}` is already defined	चर `{name}` को पहले से ही परिभाषित किया गया है
-@msg	variable `{name}` is declared twice	परिवर्तनीय `{name}` को दो बार घोषित किया गया है
-@msg	variable `{to}` already exists	चर `{to}` पहले से मौजूद
-@msg	variables are locked	चर लॉक कर रहे हैं
+@msg	variable `{name}` has no `trait`	वेरिएबल `{name}` में `trait` नहीं है
+@msg	variable `{name}` is already defined	वेरिएबल `{name}` पहले से परिभाषित है
+@msg	variable `{name}` is declared twice	वेरिएबल `{name}` दो बार घोषित है
+@msg	variable `{to}` already exists	वेरिएबल `{to}` पहले से मौजूद है
+@msg	variables are locked	वेरिएबल्स लॉक हैं
 @msg	variables that aren't text were left out: {kinds}	वेरिएबल जो टेक्स्ट नहीं छोड़े गए थे: {kinds}
 @msg	vc_abi_version returned {v}; this host implements version {ABI_VERSION}	vc_abi_version ने {v} लौटाया; यह होस्ट संस्करण {ABI_VERSION} लागू करता है
 @msg	vc_alloc returned 0 (out of memory)	vc_alloc ने 0 लौटाया (मेमोरी खत्म)
@@ -8641,7 +8646,7 @@ file-filter	Swatch libraries	स्वॉच लाइब्रेरीज़
 file-filter	Templates	टेम्पलेट्स
 file-filter	VectorCraft Template	वेक्टर क्राफ्ट टेम्पलेट
 font-script	Japanese	जापानी
-font-technology	Variable	चर
+font-technology	Variable	वेरिएबल
 gradient-kind	Radial	रेडियल
 imageTrace	Outline	रूपरेखा
 lighting	Light	लाइट
diff --git a/crates/ui-egui/src/i18n/hu.tsv b/crates/ui-egui/src/i18n/hu.tsv
index 3dadc4d3b6..dfe9c1a803 100644
--- a/crates/ui-egui/src/i18n/hu.tsv
+++ b/crates/ui-egui/src/i18n/hu.tsv
@@ -820,6 +820,8 @@ font-technology	Variable	Változó
 	Convert to destination (preserve numbers)	Átalakítás a célprofilra (az értékek megőrzésével)
 	Convert to Global	Átalakítás globálissá
 	Convert to Grayscale	Átalakítás szürkeárnyalatossá
+	Convert to Indexed Color	Átalakítás indexelt színűvé
+	Convert to Indexed Color…	Átalakítás indexelt színűvé…
 	Convert To Outlines	Átalakítás útvonallá
 	Convert To Point Type	Átalakítás pontszöveggé
 	Convert to RGB	Átalakítás RGB-re
@@ -5149,6 +5151,9 @@ imageTrace	Outline	Körvonal
 @msg	Couldn't paste: the document it was pasted in was closed	Nem sikerült beilleszteni: a dokumentumot, amelybe a beillesztés történt, bezárták
 @msg	Couldn't place {name}: the document it was dropped on was closed	Nem sikerült elhelyezni: {name}; a céldokumentumot bezárták
 @msg	Couldn't place {name}: the document it was placed in was closed	Nem sikerült elhelyezni: {name}; a dokumentumot, amelybe került volna, bezárták
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Nem sikerült elhelyezni: {name}; a céldokumentumot visszaállították a mentett változatra
+@msg	Couldn't place {name}: the document it was placed in was reverted	Nem sikerült elhelyezni: {name}; a dokumentumot, amelybe került volna, visszaállították a mentett változatra
+@msg	Couldn't paste: the document it was pasted in was reverted	Nem sikerült beilleszteni: a dokumentumot, amelybe a beillesztés történt, visszaállították a mentett változatra
 @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}
diff --git a/crates/ui-egui/src/i18n/id.tsv b/crates/ui-egui/src/i18n/id.tsv
index e670840b2c..07c762997d 100644
--- a/crates/ui-egui/src/i18n/id.tsv
+++ b/crates/ui-egui/src/i18n/id.tsv
@@ -96,6 +96,8 @@
 	Blend Vertically	Blend vertikal
 	Convert to CMYK	Konversi ke CMYK
 	Convert to Grayscale	Konversi ke skala kelabu
+	Convert to Indexed Color	Konversi ke warna terindeks
+	Convert to Indexed Color…	Konversi ke warna terindeks…
 	Convert to RGB	Konversi ke RGB
 	Invert Colors	Balikkan warna
 	Overprint Black…	Overprint hitam…
@@ -4246,6 +4248,9 @@ imageTrace	Outline	Kontur
 @msg	Couldn't open {name}: {e}	Tidak dapat membuka {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Tidak dapat menempatkan {name}: dokumen tempatnya dijatuhkan sudah ditutup
 @msg	Couldn't place {name}: the document it was placed in was closed	Tidak dapat menempatkan {name}: dokumen tempatnya ditempatkan sudah ditutup
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Tidak dapat menempatkan {name}: dokumen tempatnya dijatuhkan sudah dikembalikan
+@msg	Couldn't place {name}: the document it was placed in was reverted	Tidak dapat menempatkan {name}: dokumen tempatnya ditempatkan sudah dikembalikan
+@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	Create Outlines: select text objects	Buat kontur: pilih objek teks
diff --git a/crates/ui-egui/src/i18n/it.tsv b/crates/ui-egui/src/i18n/it.tsv
index 91d1e24bf7..1e12d62295 100644
--- a/crates/ui-egui/src/i18n/it.tsv
+++ b/crates/ui-egui/src/i18n/it.tsv
@@ -629,6 +629,8 @@ font-technology	Variable	Variabili
 	Convert to Artboards	Converti in tavole da disegno
 	Convert to CMYK	Converti in CMYK
 	Convert to Grayscale	Converti in scala di grigi
+	Convert to Indexed Color	Converti in colore indicizzato
+	Convert to Indexed Color…	Converti in colore indicizzato…
 	Convert To Outlines	Converti in contorni
 	Convert To Point Type	Converti in testo per punti
 	Convert to RGB	Converti in RGB
@@ -4393,6 +4395,9 @@ axis	Both	Entrambi
 @msg	Couldn't open {name}: {e}	Impossibile aprire {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Impossibile inserire {name}: il documento su cui è stato rilasciato è stato chiuso
 @msg	Couldn't place {name}: the document it was placed in was closed	Impossibile inserire {name}: il documento in cui veniva inserito è stato chiuso
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Impossibile inserire {name}: il documento su cui è stato rilasciato è stato ripristinato
+@msg	Couldn't place {name}: the document it was placed in was reverted	Impossibile inserire {name}: il documento in cui veniva inserito è stato ripristinato
+@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	Create Outlines: select text objects	Crea contorni: seleziona oggetti di testo
diff --git a/crates/ui-egui/src/i18n/ja.tsv b/crates/ui-egui/src/i18n/ja.tsv
index 628d1ef3de..5a976660bf 100644
--- a/crates/ui-egui/src/i18n/ja.tsv
+++ b/crates/ui-egui/src/i18n/ja.tsv
@@ -182,6 +182,8 @@ digits	Malayalam	マラヤーラム数字
 	Blend Vertically	上下にブレンド
 	Convert to CMYK	CMYK に変換
 	Convert to Grayscale	グレースケールに変換
+	Convert to Indexed Color	インデックスカラーに変換
+	Convert to Indexed Color…	インデックスカラーに変換…
 	Convert to RGB	RGB に変換
 	Invert Colors	カラー反転
 	Overprint Black…	オーバープリントブラック…
@@ -5182,6 +5184,9 @@ swatch	Bright Violet	ビビッドバイオレット
 @msg	no user library folder here	この環境にはユーザーライブラリフォルダーがありません
 @msg	Couldn't place {name}: the document it was dropped on was closed	{name} を配置できませんでした: ドロップ先のドキュメントは閉じられています
 @msg	Couldn't place {name}: the document it was placed in was closed	{name} を配置できませんでした: 配置先のドキュメントは閉じられています
+@msg	Couldn't place {name}: the document it was dropped on was reverted	{name} を配置できませんでした: ドロップ先のドキュメントは保存済みの状態に戻されました
+@msg	Couldn't place {name}: the document it was placed in was reverted	{name} を配置できませんでした: 配置先のドキュメントは保存済みの状態に戻されました
+@msg	Couldn't paste: the document it was pasted in was reverted	貼り付けられませんでした: 貼り付け先のドキュメントは保存済みの状態に戻されました
 @msg	no files to place	配置するファイルがありません
 @msg	`{file}` isn't a VectorCraft document, a PDF or a PDF-compatible .ai file	`{file}` は VectorCraft ドキュメント、PDF、PDF 互換の .ai ファイルのいずれでもありません
 @msg	paths: give at least one file	paths: ファイルを 1 つ以上指定してください
diff --git a/crates/ui-egui/src/i18n/ka.tsv b/crates/ui-egui/src/i18n/ka.tsv
index aa2c27c296..e28903effc 100644
--- a/crates/ui-egui/src/i18n/ka.tsv
+++ b/crates/ui-egui/src/i18n/ka.tsv
@@ -107,6 +107,8 @@
 	Blend Vertically	ვერტიკალურად შერევა
 	Convert to CMYK	CMYK-ად გარდაქმნა
 	Convert to Grayscale	ნაცრისფერ ტონებად გარდაქმნა
+	Convert to Indexed Color	ინდექსირებულ ფერებად გარდაქმნა
+	Convert to Indexed Color…	ინდექსირებულ ფერებად გარდაქმნა…
 	Convert to RGB	RGB-ად გარდაქმნა
 	Invert Colors	ფერების ინვერსია
 	Overprint Black…	შავის ზედდაბეჭდვა…
@@ -4045,6 +4047,9 @@ font-technology	Variable	ცვლადი
 @msg	Couldn't open {name}: {e}	{name} ვერ გაიხსნა: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	{name} ვერ განთავსდა: დოკუმენტი, რომელზეც ის ჩამოაგდეს, დაიხურა
 @msg	Couldn't place {name}: the document it was placed in was closed	{name} ვერ განთავსდა: დოკუმენტი, რომელშიც ის თავსდებოდა, დაიხურა
+@msg	Couldn't place {name}: the document it was dropped on was reverted	{name} ვერ განთავსდა: დოკუმენტი, რომელზეც ის ჩამოაგდეს, წინა ვერსიაზე დაბრუნდა
+@msg	Couldn't place {name}: the document it was placed in was reverted	{name} ვერ განთავსდა: დოკუმენტი, რომელშიც ის თავსდებოდა, წინა ვერსიაზე დაბრუნდა
+@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	Create Outlines: select text objects	კონტურების შექმნა: მონიშნეთ ტექსტური ობიექტები
diff --git a/crates/ui-egui/src/i18n/ko.tsv b/crates/ui-egui/src/i18n/ko.tsv
index ca5c2ac8d1..0cf9100b0b 100644
--- a/crates/ui-egui/src/i18n/ko.tsv
+++ b/crates/ui-egui/src/i18n/ko.tsv
@@ -175,6 +175,8 @@ digits	Malayalam	말라얄람어
 	Blend Vertically	세로 혼합
 	Convert to CMYK	CMYK로 변환
 	Convert to Grayscale	회색조로 변환
+	Convert to Indexed Color	인덱스 색상으로 변환
+	Convert to Indexed Color…	인덱스 색상으로 변환…
 	Convert to RGB	RGB로 변환
 	Invert Colors	색상 반전
 	Overprint Black…	검정 겹쳐찍기…
@@ -5109,6 +5111,9 @@ theme	Appearance	외관
 @msg	no user library folder here	여기에는 사용자 라이브러리 폴더가 없습니다
 @msg	Couldn't place {name}: the document it was dropped on was closed	{name}을(를) 가져올 수 없습니다: 놓은 문서가 닫혔습니다
 @msg	Couldn't place {name}: the document it was placed in was closed	{name}을(를) 가져올 수 없습니다: 가져오던 문서가 닫혔습니다
+@msg	Couldn't place {name}: the document it was dropped on was reverted	{name}을(를) 가져올 수 없습니다: 놓은 문서가 되돌려졌습니다
+@msg	Couldn't place {name}: the document it was placed in was reverted	{name}을(를) 가져올 수 없습니다: 가져오던 문서가 되돌려졌습니다
+@msg	Couldn't paste: the document it was pasted in was reverted	붙여넣을 수 없습니다: 붙여넣던 문서가 되돌려졌습니다
 @msg	no files to place	가져올 파일이 없습니다
 @msg	`{file}` isn't a VectorCraft document, a PDF or a PDF-compatible .ai file	`{file}`은(는) VectorCraft 문서, PDF 또는 PDF 호환 .ai 파일이 아닙니다
 @msg	paths: give at least one file	paths: 파일을 하나 이상 지정하세요
diff --git a/crates/ui-egui/src/i18n/nl.tsv b/crates/ui-egui/src/i18n/nl.tsv
index d46d7e8e87..3cb3c7c5ed 100644
--- a/crates/ui-egui/src/i18n/nl.tsv
+++ b/crates/ui-egui/src/i18n/nl.tsv
@@ -598,6 +598,8 @@
 	Blend Vertically	Verticaal mengen
 	Convert to CMYK	Converteren naar CMYK
 	Convert to Grayscale	Converteren naar grijswaarden
+	Convert to Indexed Color	Converteren naar geïndexeerde kleuren
+	Convert to Indexed Color…	Converteren naar geïndexeerde kleuren…
 	Convert to RGB	Converteren naar RGB
 	Invert Colors	Kleuren omkeren
 	Overprint Black…	Zwart overprinten…
@@ -4762,6 +4764,9 @@ imageTrace	Outline	Contour
 @msg	Couldn't open {name}: {e}	Kon {name} niet openen: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Kon {name} niet plaatsen: het document waarop het werd neergezet, is gesloten
 @msg	Couldn't place {name}: the document it was placed in was closed	Kon {name} niet plaatsen: het document waarin het werd geplaatst, is gesloten
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Kon {name} niet plaatsen: het document waarop het werd neergezet, is teruggezet
+@msg	Couldn't place {name}: the document it was placed in was reverted	Kon {name} niet plaatsen: het document waarin het werd geplaatst, is teruggezet
+@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	Create Outlines: select text objects	Contouren maken: selecteer tekstobjecten
diff --git a/crates/ui-egui/src/i18n/pl.tsv b/crates/ui-egui/src/i18n/pl.tsv
index 38d5e2f497..838d4c2719 100644
--- a/crates/ui-egui/src/i18n/pl.tsv
+++ b/crates/ui-egui/src/i18n/pl.tsv
@@ -111,6 +111,8 @@
 	Blend Vertically	Przejście w pionie
 	Convert to CMYK	Konwertuj na CMYK
 	Convert to Grayscale	Konwertuj na skalę szarości
+	Convert to Indexed Color	Konwertuj na kolory indeksowane
+	Convert to Indexed Color…	Konwertuj na kolory indeksowane…
 	Convert to RGB	Konwertuj na RGB
 	Invert Colors	Odwróć kolory
 	Overprint Black…	Nadruk czerni…
@@ -4475,6 +4477,9 @@ imageTrace	Outline	Kontur
 @msg	Couldn't open {name}: {e}	Nie udało się otworzyć {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Nie udało się umieścić {name}: dokument, na który go upuszczono, został zamknięty
 @msg	Couldn't place {name}: the document it was placed in was closed	Nie udało się umieścić {name}: dokument, w którym był umieszczany, został zamknięty
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Nie udało się umieścić {name}: dokument, na który go upuszczono, został przywrócony
+@msg	Couldn't place {name}: the document it was placed in was reverted	Nie udało się umieścić {name}: dokument, w którym był umieszczany, został przywrócony
+@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	Create Outlines: select text objects	Utwórz kontury: zaznacz obiekty tekstowe
diff --git a/crates/ui-egui/src/i18n/pt-br.tsv b/crates/ui-egui/src/i18n/pt-br.tsv
index 2a45bc8e68..c3160ec6e1 100644
--- a/crates/ui-egui/src/i18n/pt-br.tsv
+++ b/crates/ui-egui/src/i18n/pt-br.tsv
@@ -573,6 +573,8 @@ antiAlias	Sharp	Nítido
 	Convert to Artboards	Converter em Mesas de Trabalho
 	Convert to CMYK	Converter para CMYK
 	Convert to Grayscale	Converter para Escala de Cinza
+	Convert to Indexed Color	Converter para Cores Indexadas
+	Convert to Indexed Color…	Converter para Cores Indexadas…
 	Convert to RGB	Converter para RGB
 	Convert to Shape	Converter em Forma
 	Convert to sRGB	Converter para sRGB
@@ -3810,6 +3812,9 @@ axis	Both	Ambos
 @msg	Couldn't open {name}: {e}	Não foi possível abrir {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Não foi possível inserir {name}: o documento em que foi solto foi fechado
 @msg	Couldn't place {name}: the document it was placed in was closed	Não foi possível inserir {name}: o documento em que estava sendo inserido foi fechado
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Não foi possível inserir {name}: o documento em que foi solto foi revertido
+@msg	Couldn't place {name}: the document it was placed in was reverted	Não foi possível inserir {name}: o documento em que estava sendo inserido foi revertido
+@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	Create Outlines: select text objects	Criar contornos: selecione objetos de texto
diff --git a/crates/ui-egui/src/i18n/ru.tsv b/crates/ui-egui/src/i18n/ru.tsv
index af93b86974..fd32a373a8 100644
--- a/crates/ui-egui/src/i18n/ru.tsv
+++ b/crates/ui-egui/src/i18n/ru.tsv
@@ -627,6 +627,8 @@ font-technology	Variable	Вариативные
 	Convert to Artboards	Преобразовать в монтажные области
 	Convert to CMYK	Преобразовать в CMYK
 	Convert to Grayscale	Преобразовать в оттенки серого
+	Convert to Indexed Color	Преобразовать в индексированные цвета
+	Convert to Indexed Color…	Преобразовать в индексированные цвета…
 	Convert To Outlines	Преобразовать в контуры
 	Convert To Point Type	Преобразовать в точечный текст
 	Convert to RGB	Преобразовать в RGB
@@ -4378,6 +4380,9 @@ axis	Both	Оба
 @msg	Couldn't open {name}: {e}	Не удалось открыть {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Не удалось поместить {name}: документ, в который его перетащили, был закрыт
 @msg	Couldn't place {name}: the document it was placed in was closed	Не удалось поместить {name}: документ, в который его помещали, был закрыт
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Не удалось поместить {name}: документ, в который его перетащили, был возвращён к сохранённой версии
+@msg	Couldn't place {name}: the document it was placed in was reverted	Не удалось поместить {name}: документ, в который его помещали, был возвращён к сохранённой версии
+@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	Create Outlines: select text objects	Создание контуров: выделите текстовые объекты
diff --git a/crates/ui-egui/src/i18n/sv.tsv b/crates/ui-egui/src/i18n/sv.tsv
index f26438a201..fe938da2fd 100644
--- a/crates/ui-egui/src/i18n/sv.tsv
+++ b/crates/ui-egui/src/i18n/sv.tsv
@@ -616,6 +616,8 @@ font-technology	Variable	Variabla
 	Convert to Artboards	Konvertera till ritytor
 	Convert to CMYK	Konvertera till CMYK
 	Convert to Grayscale	Konvertera till gråskala
+	Convert to Indexed Color	Konvertera till indexerade färger
+	Convert to Indexed Color…	Konvertera till indexerade färger…
 	Convert To Outlines	Konvertera till konturbanor
 	Convert To Point Type	Konvertera till punkttext
 	Convert to RGB	Konvertera till RGB
@@ -4251,6 +4253,9 @@ axis	Both	Båda
 @msg	Couldn't open {name}: {e}	Kunde inte öppna {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Kunde inte placera {name}: dokumentet det släpptes på har stängts
 @msg	Couldn't place {name}: the document it was placed in was closed	Kunde inte placera {name}: dokumentet det placerades i har stängts
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Kunde inte placera {name}: dokumentet det släpptes på har återgått till sparad version
+@msg	Couldn't place {name}: the document it was placed in was reverted	Kunde inte placera {name}: dokumentet det placerades i har återgått till sparad version
+@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	Create Outlines: select text objects	Skapa konturer: markera textobjekt
diff --git a/crates/ui-egui/src/i18n/tests.rs b/crates/ui-egui/src/i18n/tests.rs
index 4ac03011ac..37b6ccc738 100644
--- a/crates/ui-egui/src/i18n/tests.rs
+++ b/crates/ui-egui/src/i18n/tests.rs
@@ -63,6 +63,36 @@ fn hindi_rows_use_the_glossary_term_for_what_their_english_names() {
     assert!(wrong.is_empty(), "{} Hindi rows use the wrong term:\n{}", wrong.len(), wrong.join("\n"));
 }
 
+/// Every Hindi row that names a variable says वेरिएबल, never चर, परिवर्तनीय or वैरिएबल, and joining
+/// paths, points, type or lines is जोड़ें, never शामिल हों, which stays for joining the community.
+#[test]
+fn hindi_rows_use_one_term_for_a_variable_and_for_joining_paths() {
+    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 english = src.to_lowercase();
+        let words: Vec<&str> = english.split(|c: char| !c.is_ascii_alphabetic()).collect();
+        let hindi: Vec<&str> = translation.split(|c: char| c.is_whitespace() || c.is_ascii_punctuation() || "।…".contains(c)).collect();
+        let names = |list: &[&str]| words.iter().any(|w| list.contains(w));
+        let other_variable = hindi.iter().any(|w| ["चर", "चरों", "परिवर्तनीय"].contains(w)) || translation.contains("वैरिएबल");
+        if names(&["variable", "variables"]) && (other_variable || !translation.contains("वेरिएबल")) {
+            wrong.push(format!("variable in {src:?} -> {translation:?}"));
+        }
+        if names(&["join", "joining"]) && !names(&["discord"]) && translation.contains("शामिल") {
+            wrong.push(format!("join in {src:?} -> {translation:?}"));
+        }
+    }
+    assert!(wrong.is_empty(), "{} Hindi rows use the wrong term:\n{}", wrong.len(), wrong.join("\n"));
+    assert_eq!(tr(hi, "Variable"), "वेरिएबल");
+    assert_eq!(tr(hi, "Load Variable Library…"), "वेरिएबल लाइब्रेरी लोड करें…");
+    assert_eq!(tr(hi, "Join"), "जोड़ें");
+    assert_eq!(tr(hi, "Close or Join"), "बंद करें या जोड़ें");
+    assert_eq!(message(hi, "join needs open paths"), "जोड़ने के लिए खुले पाथ चाहिए");
+    assert_eq!(message(hi, "Join: a subpath went missing"), "जोड़ते समय एक सबपाथ नहीं मिला");
+    assert_eq!(tr(hi, "Join our Discord"), "हमारे डिसकॉर्ड में शामिल हों");
+}
+
 /// Hindi messages and labels keep the condition, quantity and clauses of their English.
 #[test]
 fn hindi_rows_keep_the_meaning_of_their_english() {
diff --git a/crates/ui-egui/src/i18n/tr.tsv b/crates/ui-egui/src/i18n/tr.tsv
index a91aab6f0e..95f8b7f128 100644
--- a/crates/ui-egui/src/i18n/tr.tsv
+++ b/crates/ui-egui/src/i18n/tr.tsv
@@ -608,6 +608,8 @@ font-technology	Variable	Değişken
 	Convert to Artboards	Çalışma Yüzeylerine Dönüştür
 	Convert to CMYK	CMYK'ye dönüştür
 	Convert to Grayscale	Gri Tonlamaya Dönüştür
+	Convert to Indexed Color	Dizinlenmiş Renge Dönüştür
+	Convert to Indexed Color…	Dizinlenmiş Renge Dönüştür…
 	Convert To Outlines	Anahatlara Dönüştür
 	Convert To Point Type	Nokta Türüne Dönüştür
 	Convert to RGB	RGB'ye dönüştür
@@ -4129,6 +4131,9 @@ axis	Both	Her İkisi
 @msg	Couldn't open {name}: {e}	{name} açılamadı: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	{name} yerleştirilemedi: bırakıldığı belge kapatıldı
 @msg	Couldn't place {name}: the document it was placed in was closed	{name} yerleştirilemedi: yerleştirildiği belge kapatıldı
+@msg	Couldn't place {name}: the document it was dropped on was reverted	{name} yerleştirilemedi: bırakıldığı belge geri döndürüldü
+@msg	Couldn't place {name}: the document it was placed in was reverted	{name} yerleştirilemedi: yerleştirildiği belge geri döndürüldü
+@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	Create Outlines: select text objects	Anahatlar Oluştur: metin nesnelerini seçin
diff --git a/crates/ui-egui/src/i18n/uk.tsv b/crates/ui-egui/src/i18n/uk.tsv
index 17ddeb2086..a62048dbe6 100644
--- a/crates/ui-egui/src/i18n/uk.tsv
+++ b/crates/ui-egui/src/i18n/uk.tsv
@@ -623,6 +623,8 @@ font-technology	Variable	Варіативні
 	Convert to Artboards	Перетворити на монтажні області
 	Convert to CMYK	Перетворити на CMYK
 	Convert to Grayscale	Перетворити на відтінки сірого
+	Convert to Indexed Color	Перетворити на індексовані кольори
+	Convert to Indexed Color…	Перетворити на індексовані кольори…
 	Convert To Outlines	Перетворити на контури
 	Convert To Point Type	Перетворити на точковий текст
 	Convert to RGB	Перетворити на RGB
@@ -4377,6 +4379,9 @@ axis	Both	Обидві
 @msg	Couldn't open {name}: {e}	Не вдалося відкрити {name}: {e}
 @msg	Couldn't place {name}: the document it was dropped on was closed	Не вдалося помістити {name}: документ, у який його перетягли, було закрито
 @msg	Couldn't place {name}: the document it was placed in was closed	Не вдалося помістити {name}: документ, у який його поміщали, було закрито
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Не вдалося помістити {name}: документ, у який його перетягли, було повернуто до збереженої версії
+@msg	Couldn't place {name}: the document it was placed in was reverted	Не вдалося помістити {name}: документ, у який його поміщали, було повернуто до збереженої версії
+@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	Create Outlines: select text objects	Створення контурів: виділіть текстові об’єкти
diff --git a/crates/ui-egui/src/i18n/vi.tsv b/crates/ui-egui/src/i18n/vi.tsv
index 7d3d89a82d..5727398643 100644
--- a/crates/ui-egui/src/i18n/vi.tsv
+++ b/crates/ui-egui/src/i18n/vi.tsv
@@ -721,6 +721,8 @@ font-technology	Variable	Biến thiên
 	Convert to Artboards	Chuyển thành bảng vẽ
 	Convert to CMYK	Chuyển sang CMYK
 	Convert to Grayscale	Chuyển sang thang xám
+	Convert to Indexed Color	Chuyển sang màu chỉ mục
+	Convert to Indexed Color…	Chuyển sang màu chỉ mục…
 	Convert To Outlines	Chuyển thành đường bao
 	Convert To Point Type	Chuyển sang chữ điểm
 	Convert to RGB	Chuyển sang RGB
@@ -4805,6 +4807,9 @@ theme	Appearance	Giao diện
 @msg	Couldn't paste: the document it was pasted in was closed	Không thể dán: tài liệu mà nó được dán vào đã đóng
 @msg	Couldn't place {name}: the document it was dropped on was closed	Không thể đặt {name}: tài liệu mà nó được thả vào đã đóng
 @msg	Couldn't place {name}: the document it was placed in was closed	Không thể đặt {name}: tài liệu mà nó được đặt vào đã đóng
+@msg	Couldn't place {name}: the document it was dropped on was reverted	Không thể đặt {name}: tài liệu mà nó được thả vào đã được hoàn về
+@msg	Couldn't place {name}: the document it was placed in was reverted	Không thể đặt {name}: tài liệu mà nó được đặt vào đã được hoàn về
+@msg	Couldn't paste: the document it was pasted in was reverted	Không thể dán: tài liệu mà nó được dán vào đã được hoàn về
 @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}
diff --git a/crates/ui-egui/src/i18n/zh-hans.tsv b/crates/ui-egui/src/i18n/zh-hans.tsv
index 34ffeb5d6b..cf2b6c9312 100644
--- a/crates/ui-egui/src/i18n/zh-hans.tsv
+++ b/crates/ui-egui/src/i18n/zh-hans.tsv
@@ -575,6 +575,8 @@ antiAlias	Sharp	锐利
 	Convert to Artboards	转换为画板
 	Convert to CMYK	转换为 CMYK
 	Convert to Grayscale	转换为灰度
+	Convert to Indexed Color	转换为索引颜色
+	Convert to Indexed Color…	转换为索引颜色…
 	Convert To Outlines	转换为轮廓
 	Convert To Point Type	转换为点文字
 	Convert to RGB	转换为 RGB
@@ -4865,6 +4867,9 @@ imageTrace	Outline	轮廓
 @msg	no user library folder here	此处没有用户库文件夹
 @msg	Couldn't place {name}: the document it was dropped on was closed	无法置入 {name}：将它拖放到的文档已关闭
 @msg	Couldn't place {name}: the document it was placed in was closed	无法置入 {name}：要置入的文档已关闭
+@msg	Couldn't place {name}: the document it was dropped on was reverted	无法置入 {name}：将它拖放到的文档已恢复
+@msg	Couldn't place {name}: the document it was placed in was reverted	无法置入 {name}：要置入的文档已恢复
+@msg	Couldn't paste: the document it was pasted in was reverted	无法粘贴：要粘贴到的文档已恢复
 @msg	no files to place	没有要置入的文件
 @msg	`{file}` isn't a VectorCraft document, a PDF or a PDF-compatible .ai file	`{file}` 不是 VectorCraft 文档、PDF 或 PDF 兼容的 .ai 文件
 @msg	paths: give at least one file	paths：请至少给出一个文件
diff --git a/crates/ui-egui/src/i18n/zh-hant.tsv b/crates/ui-egui/src/i18n/zh-hant.tsv
index 309e00346c..6bf831faa1 100644
--- a/crates/ui-egui/src/i18n/zh-hant.tsv
+++ b/crates/ui-egui/src/i18n/zh-hant.tsv
@@ -591,6 +591,8 @@ font-technology	Variable	可變
 	Convert to Artboards	轉換為工作區域
 	Convert to CMYK	轉換為 CMYK
 	Convert to Grayscale	轉換為灰階
+	Convert to Indexed Color	轉換為索引色彩
+	Convert to Indexed Color…	轉換為索引色彩…
 	Convert To Outlines	轉換為外框
 	Convert To Point Type	轉換為點狀文字
 	Convert to RGB	轉換為 RGB
@@ -2614,6 +2616,9 @@ file-filter	Templates	範本
 @msg	no user library folder here	此處沒有使用者資料庫資料夾
 @msg	Couldn't place {name}: the document it was dropped on was closed	無法置入 {name}：放置它的文件已關閉
 @msg	Couldn't place {name}: the document it was placed in was closed	無法置入 {name}：要置入的文件已關閉
+@msg	Couldn't place {name}: the document it was dropped on was reverted	無法置入 {name}：放置它的文件已回復
+@msg	Couldn't place {name}: the document it was placed in was reverted	無法置入 {name}：要置入的文件已回復
+@msg	Couldn't paste: the document it was pasted in was reverted	無法貼上：要貼上的文件已回復
 @msg	no files to place	沒有要置入的檔案
 @msg	`{file}` isn't a VectorCraft document, a PDF or a PDF-compatible .ai file	`{file}` 不是 VectorCraft 文件、PDF 或 PDF 相容的 .ai 檔案
 @msg	paths: give at least one file	paths：請提供至少一個檔案
diff --git a/crates/ui-egui/src/menus/run.rs b/crates/ui-egui/src/menus/run.rs
index fa6b17a61b..263856da9b 100644
--- a/crates/ui-egui/src/menus/run.rs
+++ b/crates/ui-egui/src/menus/run.rs
@@ -814,6 +814,10 @@ fn run_ui_part8(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<
             crate::dialogs::saturate::open(app);
             Ok(Value::Null)
         }
+        "ui.indexedColorDialog" => {
+            crate::dialogs::indexed_color::open(app);
+            Ok(Value::Null)
+        }
         "window.swatchLibrary" => crate::panels::swatches::open_library(app, p),
         "window.swatchLibrary.other" => crate::panels::swatches::other_library(app, s("path")),
         "ui.saveSwatchLibrary" => {
diff --git a/crates/ui-egui/src/menus/state.rs b/crates/ui-egui/src/menus/state.rs
index 4e4da87380..50885f4869 100644
--- a/crates/ui-egui/src/menus/state.rs
+++ b/crates/ui-egui/src/menus/state.rs
@@ -286,7 +286,7 @@ pub fn enabled(app: &VectorcraftApp, id: &str) -> bool {
         "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.colorBalanceDialog" | "ui.saturateDialog" => app.session.active().is_some_and(|d| !d.selection.is_empty()),
+        "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(),
         "ui.flattenTransparencyDialog" => app.session.active().is_some_and(|d| !d.selection.is_empty()),
diff --git a/crates/ui-egui/src/menus/tree.rs b/crates/ui-egui/src/menus/tree.rs
index 5b88346f82..4b86b4152d 100644
--- a/crates/ui-egui/src/menus/tree.rs
+++ b/crates/ui-egui/src/menus/tree.rs
@@ -121,6 +121,7 @@ pub fn menu_tree_named(english_names: bool) -> Vec<(&'static str, Vec<Item>)> {
                         c("Blend Vertically", "edit.colors.blendVertically"),
                         c("Convert to CMYK", "edit.colors.toCMYK"),
                         c("Convert to Grayscale", "edit.colors.toGrayscale"),
+                        c("Convert to Indexed Color…", "ui.indexedColorDialog"),
                         c("Convert to RGB", "edit.colors.toRGB"),
                         c("Invert Colors", "edit.colors.invert"),
                         cp(
diff --git a/crates/ui-egui/src/menus/ui_commands.rs b/crates/ui-egui/src/menus/ui_commands.rs
index 37cdcb2d56..925d7adf3b 100644
--- a/crates/ui-egui/src/menus/ui_commands.rs
+++ b/crates/ui-egui/src/menus/ui_commands.rs
@@ -946,6 +946,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "",
         "{} open Saturate for the selection (dialog `saturate`, fields `intensity` −100..100, `preview`): previews live, OK runs edit.colors.saturate as one undo step",
     ),
+    (
+        "ui.indexedColorDialog",
+        "Convert to Indexed Color…",
+        "",
+        "{} open Convert to Indexed Color for the selection (dialog `indexedColor`, fields `reduction`, `colors` 2..256, `dither`, `ditherAmount` 0..100, `preview`): previews live, OK runs edit.colors.toIndexed as one undo step",
+    ),
     (
         "window.swatchLibrary",
         "Swatch Library",
diff --git a/crates/ui-egui/src/place.rs b/crates/ui-egui/src/place.rs
index 94ae695ca4..fff3587182 100644
--- a/crates/ui-egui/src/place.rs
+++ b/crates/ui-egui/src/place.rs
@@ -33,6 +33,9 @@ pub type PlaceInbox = Arc<Mutex<Vec<PlaceArrival>>>;
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct DropAt {
     pub doc: u64,
+    /// The document's [`vectorcraft_engine::DocState::reverts`] at the drop: files that arrive
+    /// after File → Revert threw that content away are not placed.
+    pub reverts: u64,
     pub at: Point,
     pub embed: bool,
 }
@@ -455,7 +458,7 @@ impl VectorcraftApp {
             None if is_document(name) => return DropTarget::Open,
             None => v.center,
         };
-        DropTarget::Place(DropAt { doc: st.uid, at, embed: shift })
+        DropTarget::Place(DropAt { doc: st.uid, reverts: st.reverts, at, embed: shift })
     }
 }
 
@@ -473,7 +476,7 @@ pub type DropFile = (String, Option<String>, Vec<u8>);
 /// Files dropped on the window, each placed on a canvas or opened (and added to Open Recent
 /// Files) as its target says: the placed ones first, so the last document opened is the one
 /// shown. A file for a canvas goes to the document it was dropped on, which becomes active again;
-/// it isn't placed when that document has closed since.
+/// it isn't placed when that document has closed or been reverted since.
 pub fn drop_files(app: &mut VectorcraftApp, mut files: Vec<(DropTarget, DropFile)>) {
     files.sort_by_key(|(target, _)| *target == DropTarget::Open);
     for (target, (name, path, bytes)) in files {
@@ -482,6 +485,10 @@ pub fn drop_files(app: &mut VectorcraftApp, mut files: Vec<(DropTarget, DropFile
                 app.status(format!("Couldn't place {name}: the document it was dropped on was closed"));
                 continue;
             };
+            if app.session.documents().get(i).is_some_and(|st| st.reverts != d.reverts) {
+                app.status(format!("Couldn't place {name}: the document it was dropped on was reverted"));
+                continue;
+            }
             app.session.set_active(i);
         }
         let r = match target {
diff --git a/crates/ui-egui/src/placing.rs b/crates/ui-egui/src/placing.rs
index 3eacb28322..11ae770d5d 100644
--- a/crates/ui-egui/src/placing.rs
+++ b/crates/ui-egui/src/placing.rs
@@ -111,6 +111,9 @@ struct Chain {
     left: Option<Vec<vectorcraft_doc::NodeId>>,
     /// How many of its pastes wait.
     waiting: usize,
+    /// The document's [`vectorcraft_engine::DocState::reverts`] when the chain started: a paste
+    /// given after a File → Revert does not join it.
+    reverts: u64,
 }
 
 /// What a paste whose bitmap was decoded off the UI thread pastes.
@@ -129,6 +132,9 @@ pub struct Pending {
     pub label: String,
     /// The document they are placed in ([`vectorcraft_engine::DocState::uid`]).
     doc: u64,
+    /// Its [`vectorcraft_engine::DocState::reverts`] when the read started: a read for content that
+    /// File → Revert has since thrown away is dropped.
+    reverts: u64,
     /// Whether the file was dropped on the canvas (its messages say so, as
     /// [`crate::place::drop_files`]'s do).
     dropped: bool,
@@ -177,6 +183,8 @@ struct PendingSwatch {
     insertion: Insertion,
     selection: Vec<vectorcraft_doc::NodeId>,
     doc: u64,
+    /// The document's [`vectorcraft_engine::DocState::reverts`] when the dialog opened.
+    reverts: u64,
     chain: u64,
 }
 
@@ -254,14 +262,19 @@ pub fn adopt_for_paste(app: &mut VectorcraftApp, id: &str, p: &Value) -> Result<
         return Ok(None);
     }
     let copied = app.clipboard_publishing.latest();
-    let (doc, objects) = app.session.doc().map(|st| (st.uid, st.selection.objects.clone())).map_err(|e| e.to_string())?;
+    let (doc, reverts, objects) = app.session.doc().map(|st| (st.uid, st.reverts, st.selection.objects.clone())).map_err(|e| e.to_string())?;
     let insertion = Insertion::of(app).ok_or("no document")?;
     // A paste given while one of the document's latest chain waits, with the selection and the
     // insertion context that chain expects, joins it: it goes next to what the paste before it
-    // leaves selected, as at once. Otherwise it starts a chain.
+    // leaves selected, as at once. Otherwise (also when the document was reverted since the chain
+    // started) it starts a chain.
     let context = (objects, insertion.clone());
-    let joins =
-        app.placing.latest_chain.get(&doc).copied().filter(|c| app.placing.chains.get(c).is_some_and(|ch| ch.waiting > 0 && ch.context == context));
+    let joins = app
+        .placing
+        .latest_chain
+        .get(&doc)
+        .copied()
+        .filter(|c| app.placing.chains.get(c).is_some_and(|ch| ch.waiting > 0 && ch.reverts == reverts && ch.context == context));
     let (chain, selection) = match joins {
         Some(chain) => (chain, None),
         None => (app.placing.next_chain, Some(context.0.clone())),
@@ -285,7 +298,7 @@ pub fn adopt_for_paste(app: &mut VectorcraftApp, id: &str, p: &Value) -> Result<
     if started.is_some() {
         if joins.is_none() {
             app.placing.next_chain += 1;
-            app.placing.chains.insert(chain, Chain { context, left: None, waiting: 0 });
+            app.placing.chains.insert(chain, Chain { context, left: None, waiting: 0, reverts });
             app.placing.latest_chain.insert(doc, chain);
         }
         if let Some(ch) = app.placing.chains.get_mut(&chain) {
@@ -321,7 +334,7 @@ fn spawn_labeled(
     chain: Option<u64>,
     read: impl FnOnce() -> Result<Read, String> + Send + 'static,
 ) -> Result<Option<Value>, String> {
-    let doc = app.session.doc().map_err(|e| e.to_string())?.uid;
+    let (doc, reverts) = app.session.doc().map(|st| (st.uid, st.reverts)).map_err(|e| e.to_string())?;
     let (tx, done) = channel();
     // The automation roots in force here are in force there.
     let scope = ScopeHandle::capture();
@@ -360,7 +373,7 @@ fn spawn_labeled(
         let _ = reader.send(job);
         app.placing.reader = Some(reader);
     }
-    app.placing.pending.push(Pending { name, label: label.clone(), doc, dropped, paste: chain.is_some(), chain, done, scope: completion });
+    app.placing.pending.push(Pending { name, label: label.clone(), doc, reverts, dropped, paste: chain.is_some(), chain, done, scope: completion });
     let status = format!("{label}…");
     app.status(status.clone());
     Ok(Some(json!({ "background": true, "status": status })))
@@ -416,6 +429,19 @@ fn finish(app: &mut VectorcraftApp, p: &Pending, r: Result<Read, String>) {
         }
         return;
     };
+    // File → Revert threw away the content the read was started for: what was read is dropped,
+    // with the document, its selection, the clipboard and the tools as they are.
+    if app.session.documents().get(i).is_some_and(|st| st.reverts != p.reverts) {
+        let name = &p.name;
+        if p.paste {
+            app.status("Couldn't paste: the document it was pasted in was reverted");
+        } else if p.dropped {
+            app.status(format!("Couldn't place {name}: the document it was dropped on was reverted"));
+        } else {
+            app.status(format!("Couldn't place {name}: the document it was placed in was reverted"));
+        }
+        return;
+    }
     if p.paste {
         let error = match &r {
             Ok(Read::Paste(paste)) => match &paste.pasted {
@@ -508,6 +534,7 @@ fn finish_paste(app: &mut VectorcraftApp, paste: Paste) {
                         insertion: paste.insertion.clone(),
                         selection: requested_selection,
                         doc: st.uid,
+                        reverts: st.reverts,
                         chain,
                     });
                     deferred = true;
@@ -579,6 +606,12 @@ pub(crate) fn confirm_swatch_paste(app: &mut VectorcraftApp, id: &str, params: V
         finish_chain(app, waiting.chain);
         return Err("Couldn't paste: the document it was pasted in was closed".into());
     };
+    // File → Revert threw away the content the paste was given in: nothing is pasted, and the
+    // clipboard, selection and insertion context stay as they are.
+    if app.session.documents().get(index).is_some_and(|st| st.reverts != waiting.reverts) {
+        finish_chain(app, waiting.chain);
+        return Err("Couldn't paste: the document it was pasted in was reverted".into());
+    }
     app.session.set_active(index);
     app.sync_views();
     let current = std::mem::replace(&mut app.session.clipboard, waiting.clipboard);
diff --git a/crates/ui-egui/src/placing/tests.rs b/crates/ui-egui/src/placing/tests.rs
index 9afe94b9ee..dbb37ff446 100644
--- a/crates/ui-egui/src/placing/tests.rs
+++ b/crates/ui-egui/src/placing/tests.rs
@@ -971,7 +971,7 @@ fn what_the_user_places_is_read_off_the_ui_thread_and_commands_read_at_once() {
     app.select_tool("selection");
     // A drop and bytes placed without a path.
     let doc = app.session.doc().unwrap().uid;
-    let drop = DropTarget::Place(DropAt { doc, at: vectorcraft_geom::Point::new(100.0, 100.0), embed: false });
+    let drop = DropTarget::Place(DropAt { doc, reverts: 0, at: vectorcraft_geom::Point::new(100.0, 100.0), embed: false });
     crate::place::drop_files(&mut app, vec![(drop, ("b.bmp".into(), Some(b.clone()), vec![]))]);
     crate::io::place_bytes(&mut app, "c.png", &picture(Png, 10, 10)).unwrap();
     assert_eq!(app.placing.pending.len(), 2);
@@ -1044,7 +1044,7 @@ fn files_dropped_together_are_placed_in_the_order_dropped() {
     let small = [saved("order", "small1.png", &picture(Png, 8, 8)), saved("order", "small2.png", &picture(Png, 8, 8))];
     let mut app = app(true);
     let doc = app.session.doc().unwrap().uid;
-    let drop = DropTarget::Place(DropAt { doc, at: vectorcraft_geom::Point::new(200.0, 150.0), embed: false });
+    let drop = DropTarget::Place(DropAt { doc, reverts: 0, at: vectorcraft_geom::Point::new(200.0, 150.0), embed: false });
     let files = [&large, &small[0], &small[1]].map(|p| (drop, (vectorcraft_engine::cmd::fileio::file_name(p), Some(p.clone()), vec![])));
     crate::place::drop_files(&mut app, files.into());
     assert_eq!(app.placing.pending.len(), 3);
@@ -1059,7 +1059,7 @@ fn files_dropped_together_are_read_one_at_a_time() {
     let files: Vec<String> = (0..4).map(|i| saved("one-at-a-time", &format!("large{i}.tif"), &picture(Tiff, 1500, 1500))).collect();
     let mut app = app(true);
     let doc = app.session.doc().unwrap().uid;
-    let drop = DropTarget::Place(DropAt { doc, at: vectorcraft_geom::Point::new(200.0, 150.0), embed: false });
+    let drop = DropTarget::Place(DropAt { doc, reverts: 0, at: vectorcraft_geom::Point::new(200.0, 150.0), embed: false });
     let dropped = files.iter().map(|p| (drop, (vectorcraft_engine::cmd::fileio::file_name(p), Some(p.clone()), vec![]))).collect();
     crate::place::drop_files(&mut app, dropped);
     placed(&mut app);
@@ -1123,7 +1123,7 @@ fn a_file_that_cant_be_read_off_the_ui_thread_reports_as_at_once() {
         let name = vectorcraft_engine::cmd::fileio::file_name(&path);
         for app in [&mut at_once, &mut app] {
             let doc = app.session.doc().unwrap().uid;
-            let drop = DropTarget::Place(DropAt { doc, at: vectorcraft_geom::Point::new(100.0, 100.0), embed: false });
+            let drop = DropTarget::Place(DropAt { doc, reverts: 0, at: vectorcraft_geom::Point::new(100.0, 100.0), embed: false });
             crate::place::drop_files(app, vec![(drop, (name.clone(), Some(path.clone()), vec![]))]);
             placed(app);
         }
@@ -1152,6 +1152,164 @@ fn a_file_whose_document_closed_meanwhile_is_not_placed() {
     }
 }
 
+/// `app`, which also writes files, with its active document saved to a file in a folder of
+/// `test`'s own and then changed (a rectangle drawn since the save) → the app and the file.
+fn saved_and_changed(mut app: VectorcraftApp, test: &str) -> (VectorcraftApp, String) {
+    app.services.write = Some(Box::new(|p: &str, b: &[u8]| std::fs::write(p, b).map_err(|e| e.to_string())));
+    let path = saved(test, "saved.vectorcraft", b"");
+    std::fs::remove_file(&path).unwrap();
+    app.run("file.saveAs", json!({"path": path})).unwrap();
+    app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+    (app, path)
+}
+
+/// A file read for Place, for the place cursor or dropped on the canvas is not placed when File ›
+/// Revert threw away the content of its document before it was read: the reverted document, its
+/// undo steps and the tool stay as they are, and the status bar says why. A file read after the
+/// Revert is placed.
+#[test]
+fn a_file_whose_document_was_reverted_meanwhile_is_not_placed() {
+    let tif = saved("reverted", "photo.tif", &picture(Tiff, 60, 40));
+    for kind in ["place", "drop", "queue"] {
+        let (mut app, _) = saved_and_changed(app(true), &format!("reverted-{kind}"));
+        let read = |app: &mut VectorcraftApp| match kind {
+            "queue" => start_queue(app, &json!({"paths": [tif]})),
+            _ => start(app, &json!({"path": tif}), kind == "drop"),
+        };
+        read(&mut app).unwrap();
+        app.run("file.revert", json!({"confirmed": true})).unwrap();
+        let reverted = state(&app);
+        placed(&mut app);
+        let why = if kind == "drop" { "dropped on" } else { "placed in" };
+        assert_eq!(app.ui.status, format!("Couldn't place photo.tif: the document it was {why} was reverted"), "{kind}");
+        assert!(state(&app) == reverted, "{kind}: nothing is placed");
+        assert_ne!(app.session.tool_id(), "place", "{kind}: the place cursor is not loaded");
+        read(&mut app).unwrap();
+        placed(&mut app);
+        if kind == "queue" {
+            assert_eq!((app.session.tool_id(), app.session.tool_options()["count"].as_u64()), ("place", Some(1)));
+        } else {
+            assert_eq!(names(&app), ["photo.tif"], "{kind}: a file read after the Revert is placed");
+        }
+    }
+}
+
+/// A Revert that fails, or that a batch rolls back, leaves a file being read for its document to
+/// be placed, and a Revert of one document leaves the files read for another to be placed.
+#[test]
+fn a_file_is_placed_after_a_revert_that_failed_or_of_another_document() {
+    let tif = saved("revert-failed", "photo.tif", &picture(Tiff, 60, 40));
+    let (mut first, path) = saved_and_changed(app(true), "revert-failed");
+    start(&mut first, &json!({"path": tif}), false).unwrap();
+    let revert = json!({"command": "file.revert", "params": {"confirmed": true}});
+    let failing = json!({"command": "select.set", "params": {"ids": [999999]}});
+    assert!(first.run("command.batch", json!({"commands": [revert, failing]})).is_err(), "the batch is rolled back");
+    std::fs::remove_file(&path).unwrap();
+    assert!(first.run("file.revert", json!({"confirmed": true})).is_err(), "the saved file is gone");
+    placed(&mut first);
+    assert_eq!(names(&first), ["photo.tif"]);
+    let (mut second, _) = saved_and_changed(app(true), "revert-other");
+    second.run("file.new", json!({"width": 100, "height": 100})).unwrap();
+    start(&mut second, &json!({"path": tif}), false).unwrap();
+    second.session.set_active(0);
+    second.sync_views();
+    second.run("file.revert", json!({"confirmed": true})).unwrap();
+    placed(&mut second);
+    assert_eq!(second.session.active_index(), Some(1));
+    assert_eq!(names(&second), ["photo.tif"], "the other document's file is placed");
+}
+
+/// Files dropped on a canvas that arrive after File › Revert threw away the content of their
+/// document (the web reads dropped files asynchronously) are not placed.
+#[test]
+fn files_dropped_on_a_document_reverted_before_they_arrive_are_not_placed() {
+    let tif = saved("revert-drop", "photo.tif", &picture(Tiff, 60, 40));
+    let (mut app, _) = saved_and_changed(app(true), "revert-drop");
+    let (doc, reverts) = app.session.doc().map(|st| (st.uid, st.reverts)).unwrap();
+    let drop = DropTarget::Place(DropAt { doc, reverts, at: vectorcraft_geom::Point::new(100.0, 100.0), embed: false });
+    app.run("file.revert", json!({"confirmed": true})).unwrap();
+    let reverted = state(&app);
+    crate::place::drop_files(&mut app, vec![(drop, ("photo.tif".into(), Some(tif), vec![]))]);
+    placed(&mut app);
+    assert_eq!(app.ui.status, "Couldn't place photo.tif: the document it was dropped on was reverted");
+    assert!(state(&app) == reverted, "nothing is placed");
+}
+
+/// Pastes whose bitmaps are read off the UI thread paste nothing when File › Revert threw away the
+/// content of their document before they were read: the clipboard and the selection stay as they
+/// are, and the status bar says why. A Paste in Front given after the Revert, while a paste given
+/// before it waits, does not follow that paste: it goes in front of what was selected when it was
+/// given.
+#[test]
+fn a_paste_whose_document_was_reverted_meanwhile_pastes_nothing() {
+    let bitmap = Some(Flavour { mime: PNG, data: picture(Png, 60, 40) });
+    let (pasting, _) = pasting_app(true, bitmap, None, true);
+    let (mut app, _) = saved_and_changed(pasting, "revert-paste");
+    app.run("select.set", json!({"ids": []})).unwrap();
+    crate::menus::invoke(&mut app, "edit.paste", json!({}));
+    crate::menus::invoke(&mut app, "edit.paste", json!({}));
+    assert_eq!(app.placing.pending.len(), 2);
+    app.run("file.revert", json!({"confirmed": true})).unwrap();
+    let (reverted, clipboard) = (state(&app), app.session.clipboard.clone());
+    placed(&mut app);
+    assert_eq!(app.ui.status, "Couldn't paste: the document it was pasted in was reverted");
+    assert!(state(&app) == reverted, "nothing is pasted");
+    assert!(app.session.clipboard == clipboard, "the clipboard is unchanged");
+    assert!(app.placing.chains.is_empty() && app.placing.latest_chain.is_empty(), "no paste waits");
+    // A paste given before a Revert, and one given after it with the same (empty) selection.
+    app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap();
+    app.run("select.set", json!({"ids": []})).unwrap();
+    crate::menus::invoke(&mut app, "edit.pasteInFront", json!({}));
+    app.run("file.revert", json!({"confirmed": true})).unwrap();
+    crate::menus::invoke(&mut app, "edit.pasteInFront", json!({}));
+    assert_eq!(app.placing.pending.len(), 2);
+    let below = app.run("shape.rectangle", json!({"x": 100, "y": 10, "width": 20, "height": 20})).unwrap()["id"].as_u64().unwrap();
+    app.run("shape.rectangle", json!({"x": 200, "y": 10, "width": 20, "height": 20})).unwrap();
+    app.run("select.set", json!({"ids": [below]})).unwrap();
+    placed(&mut app);
+    let st = app.session.doc().unwrap();
+    let order: Vec<_> = st.doc.layers[0].children().unwrap().iter().map(|n| n.id).collect();
+    assert_eq!(order.len(), 3, "one picture is pasted");
+    assert_eq!(st.selection.objects, [order[2]], "pasted on top, with nothing selected as when it was given");
+    assert!(matches!(st.doc.node(order[2]).map(|n| &n.kind), Some(vectorcraft_doc::NodeKind::Image(_))));
+}
+
+/// A paste that waits for its own Swatch Conflict dialog pastes nothing once File › Revert (on its
+/// own or in a batch) threw away the content of its document: confirming the dialog gives an
+/// error, and the document and the clipboard stay as they are.
+#[test]
+fn a_deferred_swatch_paste_is_dropped_when_its_document_is_reverted() {
+    for batch in [false, true] {
+        let (mut app, _) = pasting_app(true, None, None, true);
+        app.run("swatch.new", json!({"name": "Brand", "color": "#ff0000", "global": true})).unwrap();
+        let source = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap()["id"].clone();
+        app.run("paint.setFill", json!({"ids": [source], "swatch": "Brand"})).unwrap();
+        app.run("edit.copy", json!({})).unwrap();
+        let clipboard = app.session.clipboard.clone();
+        app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+        app.run("swatch.new", json!({"name": "Brand", "color": "#0000ff", "global": true})).unwrap();
+        let (mut app, _) = saved_and_changed(app, &format!("revert-swatch-{batch}"));
+        crate::menus::invoke(&mut app, "edit.pasteInPlace", json!({}));
+        placed(&mut app);
+        assert_eq!(app.ui.dialog.as_ref().unwrap().kind, crate::dialogs::swatch_conflict::KIND);
+        let revert = json!({"command": "file.revert", "params": {"confirmed": true}});
+        if batch {
+            app.run("command.batch", json!({"commands": [revert]})).unwrap();
+        } else {
+            app.run("file.revert", json!({"confirmed": true})).unwrap();
+        }
+        let reverted = state(&app);
+        assert_eq!(app.ui.dialog.as_ref().unwrap().kind, crate::dialogs::swatch_conflict::KIND, "batch {batch}");
+        app.ui.dialog.as_mut().unwrap().fields.insert("choice".into(), json!("add"));
+        let error = crate::dialogs::confirm(&mut app).unwrap_err();
+        assert_eq!(error, "Couldn't paste: the document it was pasted in was reverted");
+        assert!(app.ui.dialog.is_none() && app.placing.swatch_paste.is_none());
+        assert!(app.placing.chains.is_empty() && app.placing.latest_chain.is_empty());
+        assert!(app.session.clipboard == clipboard);
+        assert!(state(&app) == reverted, "batch {batch}: nothing is pasted");
+    }
+}
+
 /// Replace swaps the object selected when Place started; when that object was deleted before the
 /// file was read, nothing is placed and the status bar says why.
 #[test]
diff --git a/crates/ui-egui/src/tests/automation.rs b/crates/ui-egui/src/tests/automation.rs
index 6d7c7075c5..56f18399f5 100644
--- a/crates/ui-egui/src/tests/automation.rs
+++ b/crates/ui-egui/src/tests/automation.rs
@@ -545,6 +545,30 @@ fn ui_inspect_checks_a_folder_preference_as_written() {
     let _ = std::fs::remove_dir_all(base);
 }
 
+/// `ui.inspect` names the file selected in JavaScript Files by its file name alone when it is
+/// outside the read root, and keeps one inside it; the person sees the whole path.
+#[test]
+fn ui_inspect_hides_a_selected_javascript_file_outside_the_read_root() {
+    let (mut app, tx, base) = confined("inspect-javascript-files");
+    let (inside, outside) = (s(base.join("in/menu.js")), s(base.join("outside/menu.js")));
+    app.run("file.new", json!({"width": 100, "height": 100})).unwrap();
+    for f in [&inside, &outside] {
+        app.run("svgInteractivity.addFile", json!({ "file": f })).unwrap();
+    }
+    let kind = crate::dialogs::javascript_files::KIND;
+    app.ui.dialog = Some(Dialog::new(kind, json!({"file": "", "selected": outside})));
+    let selected = |v: &Value| v["ui"]["dialog"]["fields"]["selected"].clone();
+    assert_eq!(selected(&crate::control::inspect(&app, &egui::Context::default())), json!(outside), "the person's");
+    let r = request(&mut app, &tx, "ui.inspect", json!({}));
+    assert_eq!(selected(&r["result"]), "menu.js", "{r}");
+    assert!(!r.to_string().contains(&json!(outside).to_string().trim_matches('"').to_string()), "{r}");
+    app.ui.dialog = Some(Dialog::new(kind, json!({"file": "", "selected": inside})));
+    let r = request(&mut app, &tx, "ui.inspect", json!({}));
+    assert_eq!(selected(&r["result"]), json!(inside), "{r}");
+    assert_eq!(app.ui.dialog.as_ref().map(|d| d.str("selected")), Some(inside), "the dialog is not changed");
+    let _ = std::fs::remove_dir_all(base);
+}
+
 /// `ui.inspect` checks a folder preference as the app uses it, trimmed, as well: with the working
 /// folder as the read root, a path outside it with a space before it reads as a name in the working
 /// folder, and is still left out, because the app trims it and uses the path outside.
diff --git a/crates/ui-egui/src/tests/place.rs b/crates/ui-egui/src/tests/place.rs
index 9c67861eeb..19c39879af 100644
--- a/crates/ui-egui/src/tests/place.rs
+++ b/crates/ui-egui/src/tests/place.rs
@@ -111,7 +111,7 @@ fn a_drop_with_a_position_places_on_the_canvas_and_opens_off_it() {
     let want = Xf::new(rect, app.view().unwrap()).to_doc(pos);
     let uid = app.session.active().unwrap().uid;
     for name in ["a.png", "a.svg", "a.ai", "a.vectorcraft"] {
-        assert_eq!(app.drop_target(name, Some(pos), true), DropTarget::Place(DropAt { doc: uid, at: want, embed: true }), "{name}");
+        assert_eq!(app.drop_target(name, Some(pos), true), DropTarget::Place(DropAt { doc: uid, reverts: 0, at: want, embed: true }), "{name}");
         assert_eq!(app.drop_target(name, Some(Pos2::new(300.0, rect.top() - 10.0)), false), DropTarget::Open, "{name} on the tab bar");
     }
 }
@@ -129,7 +129,7 @@ fn a_drop_without_a_position_opens_documents_and_places_pictures() {
         assert_eq!(app.drop_target(name, None, false), DropTarget::Open, "{name}");
     }
     for name in ["a.png", "a.jpg", "a.tiff", "a.webp", "a.txt"] {
-        assert_eq!(app.drop_target(name, None, false), DropTarget::Place(DropAt { doc: uid, at: center, embed: false }), "{name}");
+        assert_eq!(app.drop_target(name, None, false), DropTarget::Place(DropAt { doc: uid, reverts: 0, at: center, embed: false }), "{name}");
     }
 }
 
diff --git a/docs/image-trace-quality.md b/docs/image-trace-quality.md
index f949d06071..40f6fe43b9 100644
--- a/docs/image-trace-quality.md
+++ b/docs/image-trace-quality.md
@@ -156,6 +156,34 @@ under 0.9 px RMS from the gradient's contours, 1.13 px when smoothed as edges, a
 four corners); `layers::tests` (a ramp, flat colors in palette entries far apart, close flat colors, a
 thin flat stroke, colors off the line between their entries, and Grayscale's grays, each read from both
 sides of the crack) and `subpixel::tests` (the rule, and one decision for a whole piece from either side).
+## Blurred edges
+`settled` moved a blend pixel to a side of its edge only when the picture's own colors on both sides lay
+within 2 px of it, so the middle of an edge blurred over more than about 4 px kept the palette's
+in-between tones and traced as rings of thin paths around the edge. In Color with a Limited palette of
+at most 16 colors and in Grayscale with at most 16 grays, `cut_edge::settled_wide` now does the work, by
+VectorCraft's own rule (RGB distances, 0 to 255 a channel; Grayscale reads each pixel as its gray). A
+blend pixel with no own pixel of its color within 4 px pairs the 8 own colors within 8 px that are nearest
+to its color. It takes the nearer side of the pair it is best a blend of when that pair explains it twice
+as well as its own color, or when it lies between the two and off the line between them by less than 0.15
+of their distance apart. Of two pairs that fit equally well it takes the closer pair. Other palettes,
+High Fidelity Photo, Low Fidelity Photo and Black and White keep `settled`.
+Measured with the harness below on `main` at `77970c6924`, before and after the change (256 px variants
+unless stated): 16 Colors on blurred flat art 9.0 paths to 3.0, 158 anchors to 34, 0.239 px off to 0.069;
+6 Colors 6.0 paths to 3.0, 118 anchors to 33, 0.226 px off to 0.071; scanned, 16 Colors 8.0 paths to 3.0
+and 0.259 px off to 0.110, 6 Colors 7.5 paths to 3.0 and 0.235 px off to 0.093. On each preset's own
+inputs (section 1), 6 Colors went from 4.1 paths to 3.0 and 0.143 px off to 0.101, and 16 Colors from 4.6
+paths to 3.0 and 0.145 px off to 0.100. Auto Color does not change. Worse by more than 5% (25 of 211 rows
+that moved, most of them variants of the same inputs): askew shapes, odd px 11 to 22 with 6 Colors (paths
+4.0 to 4.3, odd colours 0.3 to 0.7), 23 to 26 with 3 Colors, 17 to 22 with 16 Colors and 27 to 30 with
+Shades of Gray; thin lines, missed max 23.5 to 45.3 px with 16 Colors, and with Shades of Gray paths 5.3 to
+7.3, anchors 36 to 41 and odd colours 3.0 to 5.0; linear gradients with 3 Colors, paths 3.0 to 3.3, and
+with 6 Colors with Gradients, paths 1.3 to 1.5 and anchors 13 to 16; two- and three-stop gradients with 6
+Colors with Gradients, paths 1.2 to 1.3; gradient and photo with 16 Colors, overlap px 0.0 to 0.2 and
+specks 0.8 to 1.0. The tables below are the previous measurement, not a rerun.
+Tests on code-drawn images: `tests::a_blurred_edge_is_no_ring_of_a_tone_between_its_sides` (a disc
+blurred into a 10 px ramp, 16 Colors), `tests::grayscale_settles_a_blurred_edge_between_its_own_two_grays`,
+`tests::grayscale_settles_a_tinted_blurred_edge_by_its_lightness`,
+`tests::the_photo_presets_keep_the_tones_of_a_blurred_edge` and `quantize::cut_edge::tests`.
 ## Staircases in smooth areas
 Where a band border in a gradient or a shaded area runs at a slant, its pixels form a staircase whose
 steps are two or more pixels long. One piece of outline can run along a sharp edge in the image and then
diff --git a/docs/localization-hi.md b/docs/localization-hi.md
index d8dbcaf145..ad59a036a9 100644
--- a/docs/localization-hi.md
+++ b/docs/localization-hi.md
@@ -32,6 +32,14 @@ every clause such as "all" or "what follows it". Type as a text object is टा
 in `crates/ui-egui/src/i18n/tests.rs` checks the save, swatch, crop, resolution and path terms
 and the point unit in every row.
 
+A variable is वेरिएबल (plural वेरिएबल्स) in every sense: a data-merge variable and the
+variable library, a variable font, a variable stroke width and an environment variable. It is
+never चर, परिवर्तनीय or वैरिएबल. Joining paths, anchor points, point type or the lines of a
+paragraph is जोड़ें (जोड़ने के लिए in a purpose clause); शामिल हों is kept for joining the
+community. The stroke corner names (Bevel Join, Miter Join, Round Join) and the Join tool keep
+जॉइन. `hindi_rows_use_one_term_for_a_variable_and_for_joining_paths` checks both terms in every
+row.
+
 ## Terminology
 
 | English | Hindi |
@@ -52,6 +60,8 @@ and the point unit in every row.
 | Type (text object) / Crop / Resolution | टाइप / क्रॉप / रिज़ॉल्यूशन |
 | Appearance / Graphic style | अपीयरेंस / ग्राफ़िक स्टाइल |
 | Symbol / Envelope | सिंबल / एन्वेलप |
+| Variable / Variables / Variable library | वेरिएबल / वेरिएबल्स / वेरिएबल लाइब्रेरी |
+| Join (paths, points, type, lines) | जोड़ें |
 | Clipping mask / Opacity mask | क्लिपिंग मास्क / ओपेसिटी मास्क |
 | Image Trace / Live Paint | इमेज ट्रेस / लाइव पेंट |
 | Shape Builder / Pathfinder | शेप बिल्डर / पाथफ़ाइंडर |
@@ -69,7 +79,7 @@ The draft has 7,877 unique rows, including 2,537 `@msg`, 45 `@msgplural` and 38
 Its source set combines the sibling catalogs with the current test scanner's UI/undo and error
 message dumps, so it includes runtime labels outside the literal scanner. Row count is not a
 percentage of the application's entire interface.
-On 2026-11-13 the catalog has 8,732 rows, including 3,003 `@msg`, 47 `@msgplural` and 41
+On 2026-11-13 the catalog has 8,782 rows, including 3,014 `@msg`, 47 `@msgplural` and 41
 `@plural` rows. A wording pass on that date corrected 193 rows outside the plug-in
 messages for meaning, dropped clauses, English left in place and the save, swatch, crop,
 resolution, path and type terms. It is not a native proofread.
diff --git a/docs/localization-parity.md b/docs/localization-parity.md
index db3d26f7ce..cd8dc33f30 100644
--- a/docs/localization-parity.md
+++ b/docs/localization-parity.md
@@ -29,7 +29,7 @@ Chinese by `imachus`). Only Georgian is recorded as reviewed by a native speaker
 | English | `en` | source, 100% | all | Latin | — | full | — |
 | Simplified Chinese (Mandarin) | `zh-hans` | 5,102 rows, 791 of them `@msg` (counted 2026-10-21): menus, `tl!` literals and messages complete when counted | all | CJK UI font from craft-fonts (BIZ UDPGothic) when embedded, else a system font; IME with marked text at the caret; vertical type partial ([type-parity.md](type-parity.md)) | no | full | — (review) |
 | Spanish | `es` | 4,009 / 4,020 (99.7%) | all (604 messages) | Latin | no | full | — (review) |
-| Hindi | `hi` | 8,732 rows (2026-11-13): 3,003 `@msg`, 47 `@msgplural`, 41 `@plural`; no gaps in the untranslated report | menus, dialogs, tooltips and scanned messages; contributor-approved loanword terminology; agent wording pass | UI and document text shape with HarfRust; installed desktop Devanagari fallback, or a `Deva` craft-fonts face; web font still needed | contributor terminology review; 2026-11-13 wording pass on messages and longer labels, with a glossary-term test; wider proofread welcome | complete catalog, machine-assisted draft | native review, layout and web font |
+| Hindi | `hi` | 8,782 rows (2026-11-13): 3,014 `@msg`, 47 `@msgplural`, 41 `@plural`; no gaps in the untranslated report | menus, dialogs, tooltips and scanned messages; contributor-approved loanword terminology; agent wording pass | UI and document text shape with HarfRust; installed desktop Devanagari fallback, or a `Deva` craft-fonts face; web font still needed | contributor terminology review; 2026-11-13 wording pass on messages and longer labels, with a glossary-term test; wider proofread welcome | complete catalog, machine-assisted draft | native review, layout and web font |
 | Arabic | `ar` | 0 | none | document text: bidi layout and Paragraph Direction; interface: no right-to-left layout, no Arabic shaping in egui | no | none | 25–40 |
 | French | `fr` | 4,020 / 4,020 (100%) | all | Latin | no | full | — (review) |
 | Portuguese | `pt-br` | 6,106 catalog entries (counted 2026-10-31 on `main` at `d26dd933a`): menus, `tl!` literals and messages complete when counted; one/other plurals | all | Latin | contributor is a Brazilian Portuguese speaker; further native review welcome | full | — (review) |
diff --git a/docs/mcp.md b/docs/mcp.md
index 269ab4995d..cb5c40501c 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -230,6 +230,10 @@ the suite) keep the agent to the folders you give it:
   value and a linked JavaScript file in `svg_scripts` outside them by its file name alone (a JavaScript file given
   as a URL is kept), and leaves out the `folder` of `export_settings` (the settings Export
   for Screens last used) when that folder is outside them. The document itself is not changed.
+- `svgInteractivity.info`, `svgInteractivity.addFile` and `svgInteractivity.removeFile` name a linked JavaScript
+  file outside the read roots by its file name alone in `files`, as `document.json` does, and `removeFile` takes that
+  name for it (see SVG interactivity). In a frame a request drives, the JavaScript Files dialog lists such a file by
+  its file name, and `ui_inspect` gives the file selected in the dialog the same way.
 - `plugin.list`, `plugin.safeMode`, `file.recovery.*` and `ui_inspect`'s `scriptReport` leave out the paths
   outside the read roots, also those the person or an earlier request put there. In `plugin.list`, the plug-in
   folder last loaded is `null` in `folder.folder`, and a failed file in `folder.failed` and a plug-in's `source`
@@ -3860,11 +3864,32 @@ with one gray channel, so a PDF writes it in gray.
 `edit.colors.saturate` needs `intensity`, a number from -100 to 100 (a number outside the range counts as its nearest
 end). Without one, or with `null`, it answers `` missing number `intensity` ``; with a value that is not a number, such as
 `"40"`, it answers `` `intensity` must be a number, not "40" ``. Either way it changes nothing.
-The `edit.colors.*` commands, `edit.colors.overprintBlack` and `addon.color.filter` answer a `fill`, `stroke`,
-`includeImages`, `includePatterns`, `convert`, `remove`, `includeCmyBlacks` or `includeSpotBlacks` that is not true or
-false with `` `fill` must be true or false ``, naming the key, a `percentage` that is not a number with
-`` `percentage` must be a number ``, and a `mode` that is not a string with `` `mode` must be a string ``. They change
-nothing and record no undo step. A null counts as a key left out.
+The `edit.colors.*` commands other than `edit.colors.toIndexed`, `edit.colors.overprintBlack` and
+`addon.color.filter` answer a `fill`, `stroke`, `includeImages`, `includePatterns`, `convert`, `remove`,
+`includeCmyBlacks` or `includeSpotBlacks` that is not true or false with `` `fill` must be true or false ``, naming the
+key, a `percentage` that is not a number with `` `percentage` must be a number ``, and a `mode` that is not a string
+with `` `mode` must be a string ``. They change nothing and record no undo step. A null counts as a key left out.
+
+`edit.colors.toIndexed` (Edit › Edit Colors › Convert to Indexed Color…) stores each embedded image in the selection (or
+`ids`), in groups too, as an indexed-color PNG: a palette of at most 256 RGB colors, with each pixel the index of one.
+`reduction` chooses the palette: `selective` (the default), `perceptual`, `adaptive`, `web`, `gray` and `blackWhite`
+choose it as a PNG-8 export does; `uniform` takes evenly spaced levels of red, green and blue (2 to 6 levels, the most
+whose cube fits in `colors` with one entry left for transparency); `document` takes the colors of the document's
+swatches (at most 255). `colors` (2 to 256, default 256) is the most palette entries, the transparent one included;
+`uniform` needs at least 9, and `blackWhite` and `document` refuse it. `dither` is `diffusion` (the default), `pattern`,
+`noise` or `none`, and `ditherAmount` is 0 to 100 (default 100). Reduction and dither ids are read as a PNG-8 export
+reads them, ignoring case. Pixels under half opacity become one transparent entry and the others become opaque in their
+own color. Linked images, colorized image fills and the images of color glyphs in outlined type keep their pixels. Each
+image that changes becomes a new image, in one undo step for all of them. An image that is already an indexed PNG and
+would show the same pixels is left as it is, and no undo step is recorded when no image changes. `notChanged` counts the
+locked and hidden objects Select All left out that hold an image that is not an indexed PNG yet. An image of more than
+134,217,728 pixels (33,554,432 in the web app) is refused with an error, read from the file's header before any pixel is
+decoded, and nothing changes. A value out of range or of the wrong type, such as `"colors": "8"`, is refused with an
+error and changes nothing.
+
+```json
+{"name":"run_command","arguments":{"command":"edit.colors.toIndexed","params":{"reduction":"adaptive","colors":32,"dither":"pattern"}}}
+```
 
 The reply of `recolor.apply` and of every command above except the Blend commands has `notChanged: {locked, hidden}`.
 When the selection is exactly what `select.all` takes (in isolation mode, what it takes inside the isolated group), it
@@ -4883,7 +4908,12 @@ files) and `eventNames` (the 19 events the panel lists, from `onfocusin` to `ons
 event's script where they have one (an empty `script` removes it); `svgInteractivity.removeEvent {event, ids?}` and
 `svgInteractivity.clearEvents {ids?}` remove one event or all of them. Each is one undo step.
 `svgInteractivity.addFile {file}` and `svgInteractivity.removeFile {file}` link and unlink a JavaScript file (a path
-or a URL, kept as given without surrounding spaces); a document links at most 64 files. `ui.javascriptFilesDialog {}`
+or a URL, kept as given without surrounding spaces); a document links at most 64 files. `addFile` takes a file as
+already linked only when the same text is linked. With automation read roots in force, `info`, `addFile` and
+`removeFile` name a linked file outside them by its file name alone in `files` (a relative path is taken from the
+document's folder, and a URL is kept), and `removeFile` also unlinks such a file by that name. When the name fits
+more than one linked file (two such files, or such a file and a file linked as that name), `removeFile` returns an
+error and unlinks nothing. `ui.javascriptFilesDialog {}`
 opens the JavaScript Files dialog, whose Choose… puts a picked file in as a `file:///` URL. SVG export writes each event
 as an event attribute on the object's element (`onclick="…"`; with the SVG Tiny 1.2 profile it leaves them out with a
 warning) and each file as `<script xlink:href>`. SVG import reads the event attributes the panel lists and the
@@ -5795,7 +5825,9 @@ From the Selection, Direct Selection, Group Selection, Magic Wand, Lasso or Pers
 drawing tool chosen last in the window, or the Pencil tool when none has been chosen yet; from any other tool it
 chooses the Selection tool, and the tool left becomes the drawing tool unless it is the Hand, Rotate View, Zoom or Print
 Tiling tool. It returns `{tool}` and adds no undo step. Pencil as the first drawing tool and the list of selection tools
-are VectorCraft's own rules. A tap in Presentation Mode runs nothing.
+are VectorCraft's own rules. A tap in Presentation Mode runs nothing. Under VectorCraft's own rule, a tap on the canvas
+while a modal dialog is open runs nothing, and fingers already down when it opens make no tap when they lift, during
+the dialog or after it closes.
 
 `gridlineEvery` (72 pt by default) and `gridSubdivisions` (8 by default) set the document grid that View › Show Grid
 draws, and View › Snap to Grid snaps to its subdivisions. Changing either sets the grid of every open document.
@@ -7148,6 +7180,10 @@ color, even one of the same color, and Registration are not spot colors; the spo
 Color Objects and `objects.spots` counts them; spot swatches no art uses are not listed; with `selectionOnly`, those
 in the selection), `spotColorNames` and `spotColors` (the spot colors those objects use) and `pathLength` (pt: the total length of the paths, compound paths' pieces included and guides left
 out, which objects lists as Path Length in the document's units, say for a cut line or an LED strip along the letters);
+`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, their characters' paints and
+colorized images included, and so does `selectionOnly` for an object selected inside such a group or layer, while
+`objects` still counts them as paths, groups and the other kinds;
 `format: "text"` returns the plain-text report Document Info › Save… (`docInfo.save {path?, selectionOnly?, category?}`:
 only `category` when given, else every category) and the package report write.
 
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index b15c35969b..78c727929a 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -834,6 +834,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - Medium Dark theme, categorized and Advanced toolbars (a tool group's flyout opens on a right press, a long press or a press on its corner triangle), 35 pt document tabs, 33 pt panel tabs.
   - Hint bar, contextual task bar, 19 dock panels with ≡ menus.
   - Window › SVG Interactivity attaches JavaScript to the selected objects' events (`onclick`, `onmouseover` and 17 more) and links JavaScript files to the document (Link JavaScript Files…); SVG export writes the events as event attributes and the files as `<script xlink:href>`, SVG import reads both back as text without running them, and the native format keeps them (`svgInteractivity.*`).
+  - With automation read roots in force, `svgInteractivity.info`, `addFile` and `removeFile`, the JavaScript Files dialog in a frame a request drives and `ui_inspect`'s selected file name a linked JavaScript file outside the roots by its file name alone, as `document.json` does; `removeFile` unlinks it by that name and refuses a name that fits more than one linked file (`tests/interactivity.rs`).
   - Numeric fields keep the pointer's pressed character as the text-drag start when movement exceeds the click threshold (#1326); a completed focus click selects the unit too. Pixel/point, plain and optional fields are regression-tested in both directions, before/after focus, with replacement text; keyboard focus, double-click, arrows and wheel keep their prior behavior. Native egui input confirms partial replacement gives 17 px instead of 700 px, one Undo/Redo, window captures and an exact saved-document read in a separate CLI process. A focus click released more than 1 pt from its press keeps the caret, and a tap within 1 pt still selects all (#6659; short-drag and jitter-tap regressions in `tests/numfields.rs`).
   - Unit fields and length strings take `%` in arithmetic: `3cm*50%` reads as 1.5 cm, and `50pt+25%` reads as 62.5 pt.
   - The contextual task bar's handle drags it anywhere on the canvas (kept whole on it as the window resizes); unpinned it keeps that offset as it follows the selection, and its More Options menu hides it, pins its position across selection changes (`window.taskBar.pin`), resets it under the selection (`window.taskBar.reset`) and shows the Properties panel. As in Illustrator the position isn't kept across launches. Not done: the bar's variants for other tools (only the selection tools, the Type tools and the Artboard tool show it).
@@ -866,6 +867,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - Window › Toolbars › Keep Tools Beside the Canvas, a VectorCraft layout option that is off by default, docks the Tools panel between left-side panels and the canvas instead of at the window's left edge; the canvas's left edge then also docks a floating Tools panel, and workspaces keep the setting. Scores are unchanged (`window.toolsBesideCanvas`; `docked_tools_keep_the_window_edge_unless_kept_beside_the_canvas`, `tools_redock_at_the_targets_of_the_chosen_placement`).
   - 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.
   - 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`).
@@ -1039,8 +1041,8 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - **Drawing:** Pen, Curvature, anchor tools, Pencil, Paintbrush, Blob Brush, Smooth, Path Eraser, Join. Direction handles dragged with Direct Selection or the Anchor Point tool snap to smart guides, and Shift keeps them at 45° steps from their anchor. The Pen continues any open path from the end clicked, and while drawing, a click on an end of another open path joins the two into one (#776). The Curvature tool edits any selected path, whatever drew it, keeping its shape except where edited (#798): a click on a point makes it current and a drag moves it, re-curving only its two segments; double-click, or Alt-click on any point but an end of an open path, toggles it smooth or corner and Delete removes it; a click on a segment adds a point without changing the shape; with an end of an open path current, clicks go on from it and its other end closes it (`path.curvatureEdit`). An Alt-click on an end of a selected open path makes that end current without changing it, so the next click goes on from it, as [the help page](https://helpx.adobe.com/illustrator/desktop/draw-shapes-and-paths/draw-shapes/draw-shapes-with-the-curvature-tool.html) describes for continuing a path; an Alt-click that starts a new path places a corner point, as later Alt-clicks do. Every point a drawing tool places snaps to Smart Guides through one snapper (#506): the Pen's and Curvature tool's anchors, the Pencil's ends, the shape tools' start and dragged corner or radius (Rectangle, Rounded Rectangle, Ellipse, Polygon, Star, Line Segment, Arc, Spiral, the grids), the Type tool's click and frame, a new artboard's corners. A filled Pencil path keeps a stroke of None (#1804, part of #1679). While a Pencil or Paintbrush stroke is drawn back to within Close Paths When Ends Are Within of its start, the cursor shows the closing ring and a release there closes the path, 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 for the Pencil. The [ and ] keys reach the Blob Brush, the Eraser and the Symbolism tools in the app (#1734, part of #1661).
     Blob Brush and Eraser Tool Options' Size is Fixed or Pressure with a Variation (#4590, #3961): with Pressure a pen stroke is Size − Variation wide where it presses lightest and Size + Variation where it presses hardest, and a mouse stroke keeps the Size.
     With the Blob Brush, Shift held during a drag keeps the stroke on the horizontal or vertical line through the press point, whichever is nearer to the pointer (90° steps from the Constrain Angle preference), and the points dragged since Shift went down move to the other line when the pointer crosses to it; the points dragged while Shift is up follow the pointer.
-    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 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`).
+    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.
     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).
@@ -1196,6 +1198,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   A two-finger rotation on a Mac trackpad turns the view about the pointer once it reaches 5° (Preferences › General › Trackpad Gesture to Rotate View, on by default).
   On a touch screen a second finger cancels the tool press the first finger began, in the frame it lands or later: the Pencil's stroke or a Selection move is rolled back with no undo entry, and a finger that lands while another is down presses nothing, so a pinch or two-finger pan only zooms and pans (#4198; canvas test `a_second_finger_cancels_the_tool_gesture_the_first_began`).
   In the Touch workspace a two-finger tap switches between the Selection tool and the drawing tool chosen last (the Pencil tool when none has been chosen yet) and undoes nothing; outside Touch it still undoes, and a three-finger tap still redoes ([the help page](https://helpx.adobe.com/illustrator/desktop/get-started/learn-the-basics/touch-workspace-in-illustrator.html); `tool.toggleTouchMode`; canvas test `two_finger_tap_in_touch_switches_selection_and_drawing_modes`).
+  While a modal dialog is open, from the frame it opens, the canvas takes no new presses, double-clicks, finger taps, long touches, pinches or wheel turns, and a click in Presentation Mode does not step to the next artboard: a two-finger tap undoes nothing, a three-finger tap redoes nothing, a two-finger tap in the Touch workspace switches no mode, and fingers already down when the dialog opens make no tap when they lift, during the dialog or after it closes. This is VectorCraft's own rule (canvas tests `modal_blocks_two_and_three_finger_canvas_taps`, `opening_a_modal_discards_a_pending_canvas_tap`, `modal_blocks_presentation_tap_and_touch_navigation`, `modal_long_touch_does_not_cancel_canvas_press` and `modal_blocks_new_canvas_presses`).
   A tool press dropped by a second finger, a long touch or a canceled touch cancels the tool's drag as Escape does: the tool gets back the options it had when the press began (the Polygon tool's sides, set with ↑ and ↓) and they are not stored, a press held still opens no size dialog, a Selection or Artboard tool marquee selects nothing, and the Pen goes on drawing its path without the dropped anchor (canvas tests `a_canceled_touch_drops_the_drag_without_keeping_its_options` and `long_touch_drops_a_tool_press_without_committing_art`; engine tests in `tests::toolsettings`).
   The status bar navigator's field shows the active artboard's number and name, and its drop-down lists every artboard by number and name, as the Artboards panel does. Choosing an artboard in the list makes it the active artboard and fits it in the window (`view.goToArtboard`). The list opens on the active artboard's row and lays out only the rows in view and at most one more.
 - **Geometry and effects:**
@@ -1277,7 +1280,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`). Type on a path, Shrink Text to Fit, lines aligned other than to the top, 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 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.
   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.
@@ -1372,6 +1375,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
 - **Image Trace, staircases in smooth areas:** in Color and Grayscale traces, a staircase of three or more steps of 1 to 8 px along a border between two colors, where the image changes gradually by the same rule (`subpixel::low_contrast`, read for the staircase alone, which ends at any step that shows half of the step between the two colors or more; the 8 px limit and the one-half cut are VectorCraft's own values), is traced as the slope through the middles of its steps with no corner at each step, also on an outline that runs on along a sharp edge in the image. The corner where a staircase meets a straight edge longer than 8 px stays. Longer steps, staircases along a sharp edge and Black and White traces keep their corners; 6 Colors on gradient and photo leaves a gap of 0.9 px (was 1.2) and an overlap of 1.0 px (was 0.8), and High Fidelity Photo with Gradients on a blurred input takes 50 anchors (was 47); see [quality notes](image-trace-quality.md#staircases-in-smooth-areas) for these and the other rows that got worse. Tests: eight `subpixel::tests` in `crates/trace`, starting with `a_staircase_of_longer_steps_in_a_smooth_area_becomes_the_slope_through_its_steps`. Scores and hours unchanged.
 - **Image Trace, cut-out edges:** in Color and Grayscale, a semi-transparent pixel (alpha 128 to 254) on the edge of a cut-out image, beside a pixel that is less than half opaque, traces as a color of the fully opaque pixels within two pixels of it when its own color is that color or a darker shade of it, and of several such colors, as the one the most of those pixels have (art across a transparent gap does not count), so a darkened edge tone no longer traces as a 1 px sliver of an unrelated palette color, while a thin semi-transparent outline of another color keeps its own; code-drawn cut-out, opaque-edge and thin-outline tests in `crates/trace`.
 - **Image Trace, cut-out edges choose no color:** in Color and Grayscale, the edge pixels that take the color beside them, and the semi-transparent pixels within two pixels of them whose color is also the opaque art's color blended with the background, do not count when the palette or the grays are chosen, so the edge of a cut-out image no longer adds a second shade of a color to Auto Color's palette, takes away an outline's color or takes a gray of its own; beside those pixels, the anti-aliasing between a color and an outline drawn along the edge is no color of Auto Color's own when it lies at least 0.45 of the way from the color to the outline and at least one in 32 of its pixels has both around it (edge pixels that choose no color count when they lie within 2.5 Oklab × 100 of the nearest of those colors): its pixels trace as the outline, so a thin outline stays a ring of few pieces, except beside an outline along the edge with a region of 8 pixels of its own, where each takes the nearer of the two, so a wider outline is not drawn wider; an outline over the edge in the color of other art traces in that color, while an opaque rim drawn along the edge keeps its color, also where other art reaches it; a thin semi-transparent outline of another color still counts, and opaque images trace as before; code-drawn cut-out outline, rim, opaque line and grayscale edge tests in `crates/trace`.
+- **Image Trace, blurred edges:** in Color with a Limited palette of at most 16 colors (3 Colors, 6 Colors, 16 Colors) and in Grayscale with at most 16 grays (Shades of Gray), by VectorCraft's own rule (RGB distances, 0 to 255 a channel), a blend pixel with no unblended pixel of its own color within 4 pixels takes the nearer side of the pair of colors within 8 pixels that it is best a blend of, of the 8 colors within 8 pixels nearest to its color, when that pair explains it twice as well as its own color, or when it lies between the two and off the line between them by less than 0.15 of their distance apart; it keeps its color when it is one of the pair. Grayscale compares lightness. The in-between tones of an edge blurred over several pixels no longer trace as rings around it. High Fidelity Photo, Low Fidelity Photo and Black and White trace as before, and so do Automatic, Full Tone and Document Library palettes. Noisy and textured images settle more of their pixels. By `crates/trace/tests/quality` (256 px variants), 16 Colors on blurred flat art went from 9.0 paths to 3.0, 158 anchors to 34 and 0.239 px off to 0.069, and 6 Colors from 6.0 paths to 3.0 and 0.226 px off to 0.071; askew shapes take up to 11 px more area in colors the art does not have, and with 16 Colors the largest distance from a thin line's outline to the trace goes from 23.5 px to 45.3 (see [quality notes](image-trace-quality.md#blurred-edges)). Code-drawn blurred-disc and grayscale ramp tests in `crates/trace`.
 - **Image Trace, simpler contour walk:** `contour::trace_mask` works out each turn from the pixels during the walk, with no precomputed direction table and no assertion; identical loops to the previous walk on every 4 × 4 mask (see [quality notes](image-trace-quality.md#a-simpler-contour-walk)).
 - **Image Trace, measured:** `crates/trace/tests/quality` traces drawings made from known vector art with every preset and [`image-trace-quality.md`](image-trace-quality.md) records the numbers against the baseline. Black and White, Grayscale and Color place each edge by the blend of the pixels across it (to a fraction of a pixel on anti-aliased and blurred images; hard-edged images are read as staircases) and fit outlines as Flat Logo does. *Measured* on each preset's own inputs, all sizes and variants: Default's outlines went from 0.31 px off on average to 0.09 (largest 1.51 to 1.02), Black and White Logo's from 0.27 to 0.06 with 0.3 kinks per trace where it had 15, and the gaps between abutting paths from 64 px to 22. On clean curved shapes Black and White Logo is 0.02 px off (the open tracer measured beside it: 0.20). The palette is made of the picture's own colours (blends along edges take none of it, colours that noise made of one colour merge, a blend pixel goes to one of the two colours it lies between; #1504): 16 Colors on flat art, all variants, went from 70 paths to 4.2 and from 5.1 px off to 0.13, with no path left in a colour the art doesn't have (5.9 before). Photos are smoothed within their tones before they are quantised and stacked layers go by lightness (#1516): High Fidelity Photo went from 3,653 paths to 121 with its colour error down from 2.30 to 1.75, and a 16 megapixel photo-like image is traced in 3.5 s where 4 megapixels were refused. Since then, by the same harness: outlines are cut at their junctions and each shared piece is fitted once (#1535: gaps and overlaps between abutting paths 22 to 50 px of area down to under 2); layers are traced within the box of their pixels and a few at a time (#1546: a 16 megapixel photo 3.9 GB to 0.9 GB); black and white are read against the image's own black and the paper near each edge (#1563, for thin lines in blurred and scanned art); Ignore Color and the Auto Color and Outline presets (#1574); Snap Curves To Lines levels lines within 2.5 degrees of level or upright (#1593, the angle our choice); Create: Strokes puts centre lines in the middle of their ink and makes them as wide as it (#1595: Outline 0.295 to 0.052 px from the true centre line, 18.4 to 2.7 anchors a stroke); sharp corners whose pixel is mostly outside the shape stay corners (#1609: Default 69% to 76% kept). Three options, each off unless asked for as the legacy presets have them: Shapes (#1609: 57 to 62% of plain circles, ellipses, rectangles and regular polygons come out as live shapes, rounded rectangles rarely), Auto Grouping (#1618: paths grouped with what lies inside them, the same picture) and Gradients (#1627: linear gradients traced as one gradient-filled path; on gradient inputs 6 Colors' colour error 2.12 to 0.62 with 6.4 to 3.4 paths, none found in flat art). Snap Curves To Lines moves no end of a line by more than 1.6 px, so long lines a degree or two off stay as the image has them (#1647: Technical Drawing's largest distance 4.21 px to 1.46). Flat Logo takes the tones a scan's uneven paper makes of one colour for one colour (#1657: on scans 470 paths and 21 px off to 8.5 paths and 0.09 px). Shapes finds rounded rectangles and shapes in aliased, blurred and scanned art (#1845: 57 to 62% of the plain shapes up to 98 to 100%, no false shape but one line 2 px wide). Stroked lines get square caps where their ink is cut square, and a wide end that turned towards a corner goes back on its line (#1846: Outline's largest distance 2.94 px to 0.88, 14 anchors to 10). Each of the 14 documented presets has an enhanced version with Auto Grouping and, in all but High Fidelity Photo, Shapes (#1847), measured beside its preset: equal or better within 0.005 px and 1% of edge ΔE on every preset's own inputs (Default 0.091 to 0.083 px); Auto Grouping keeps traced order in its groups, which removed a light seam along the counters of letters. Gradients grows a gradient over the pixels noise and soft rims took off it (#1848: blurred and noisy linear gradients 3 to 11 paths beside the gradient down to 0.5 with 6 Colors, 24 to 56 down to 0.5 to 1.5 with High Fidelity Photo). Silhouettes is 0.52 px off because its threshold is 200 (0.11 px at 128). Still weak, by the same numbers: rounded rectangles and other line-and-arc outlines take 12 to 16 anchors (the fitter does not split lines from arcs), blurred and scanned polygons lose corners, hairlines under half a pixel are lost to the threshold, aliased art is about 0.25 px off, a scan's uneven paper splits into tones when more colours are asked for than the art has, stroke junctions stay at their skeleton pixels, a three-stop gradient in a small or scanned disc is not found, radial gradients stay bands (a draft, #1849, traces them; the documented option is for linear ones, so it waits for a decision), near-regular polygons a few dozen pixels across are made regular with Shapes (up to 0.5 px off), and aliased stroked lines are 0.8 px off at worst.
 - **Gradient mesh from an image:** Object › Create Gradient Mesh (`object.mesh.create`) on an embedded image makes a mesh of 1 to 50 rows and columns over the picture's rectangle, placed with the image's transform; each point takes the alpha-weighted average colour and the opacity of the area around it, and Appearance and Highlight apply. A linked image is refused with a message to embed it (#1676). Scores and hours unchanged.
@@ -1444,6 +1448,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - **Recolor Artwork layout (#3416):** the Edit chip list uses the modal scroll helper and its actual remaining height; the tab's minimum-height space scrolls with the chips. `tests_recolor` covers 5/20/200/400 colors, window resizing, 100/125/150/200% UI scaling, scrolling to and editing the final chip, Preview, Cancel, Confirm and Undo, alongside the existing #1733 drag regressions. Scores and estimates unchanged.
   - **Recolor Artwork Edit displays:** buttons beside the Edit tab's wheel show the colors on a smooth color wheel, a segmented color wheel or as color bars ([Edit colors using Recolor Artwork](https://helpx.adobe.com/illustrator/desktop/manage-colors/modify-colors/edit-colors-using-edit-colors-dialog.html)). The segmented wheel draws 24 hues by 5 saturations as solid patches, and its markers move freely as on the smooth wheel. The bars show one solid bar per recolored color in row order: a click selects a bar for the color sliders, and a drag moves its row without changing a color ([Advanced recolor options overview](https://helpx.adobe.com/illustrator/desktop/manage-colors/learn-color-basics/edit-colors-dialog-overview.html)). The dialog opens on the smooth wheel; `display` (`smooth`, `segmented`, `bars`) is the dialog field. `tests_recolor` covers switching, the dialog height, segmented dragging and Brightness, and bar selection, editing, reordering, scrolling, Preview, Cancel and OK. Scores and estimates unchanged.
   - **Edit Colors parameters:** `edit.colors.saturate` needs a number `intensity`, the value from -100% to 100% that Saturate takes ([Adjusting colors](https://web.archive.org/web/20230128232631/https://helpx.adobe.com/illustrator/using/adjusting-colors.html)), and answers "missing number `intensity`" without one; a number outside the range counts as its nearest end. A value that is not a number, such as `"40"`, is refused with `` `intensity` must be a number, not "40" ``, as in every command that needs a number (`tests::params::a_malformed_required_number_is_not_reported_as_missing`). `edit.colors.adjustBalance` refuses a channel and `color.harmony` refuses `steps` or `amount` that is not a number; both read `null` as a value left out. `tests::editcolors` and `tests::colorguide` cover them.
+  - **Convert to Indexed Color:** Edit › Edit Colors › Convert to Indexed Color… (`edit.colors.toIndexed`) stores the embedded images in the selection as indexed-color PNGs of at most 256 colors. The palette is chosen as for a PNG-8 export, as evenly spaced levels of red, green and blue, or from the document's swatches, with diffusion, pattern or noise dithering; pixels under half opacity become transparent. The dialog previews live, and OK is one undo step. This is VectorCraft's own command and counts toward no score. `tests::editcolors` and `encode::tests_palette` cover it. Scores and estimates unchanged.
   - **Working RGB numeric controls:** the Color panel and Color Picker read RGB, HSB, hex and Web Safe RGB values in the active working RGB space. Editing one RGB channel preserves the other native channels, including colors outside display sRGB. Regressions cover sRGB, Display P3, Wide Gamut RGB and ProPhoto RGB, picker initialization, native numeric round trips, and a slider click with one Undo step. Scores and estimates unchanged.
   - **Pasting into hex color fields:** in the hex fields of the Color Picker, Swatch Options, Recolor Artwork, the Color panel, Document Setup, Duotone, Color Themes and Perspective Grid, a click or keyboard focus selects the digits. A pasted code of six digits, with or without `#`, replaces them wherever the caret is. A pasted code of three digits also replaces them, unless the paste holds only those digits and exactly three digits stay; those digits then edit the text in place. A press on another field commits the text as Tab and Enter do. As VectorCraft's own rule, a paste that is not a color leaves the field as it was. Tests: `a_hex_code_pasted_into_the_hex_field_replaces_its_digits` in `crates/ui-egui/src/dialogs/tests.rs`, `define_grid_takes_a_three_digit_color` in `crates/ui-egui/src/dialogs/tests_perspective.rs` and `a_paste_into_a_hex_field_replaces_or_edits_its_digits` in `crates/ui-egui/src/tests/numfields.rs`.
   - **Color Picker layout (#2008):** a centered draggable header, equal-width actions above aligned HSB/RGB/Hex and Lab/CMYK fields, compact field and slider, and warnings below the preview. No horizontal scrolling; narrow windows stack the sections with vertical scrolling. Tests in `dialogs/color_picker.rs` cover actual pointer/key input, typed values before OK/Enter, Cancel/Escape rollback, one Undo step, mode-size stability, warnings and layout at two UI scales. The screen sampler sits above the field and the upstream two-grid Tab order is retained. AccessKit regressions check the action names and each channel slider's displayed value, units and range. German and enlarged English UI renders were reviewed locally; no reference images are shipped. This is a layout improvement, with no change to scores or remaining-hour estimates.
@@ -1481,6 +1486,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     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 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).
     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`).
@@ -1690,6 +1696,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - On the desktop, File › Place reads and decodes files off the UI thread, one at a time, and places each once it is read, with "Placing" in the status bar and the busy spinner until then: the Place dialog's OK, a file dropped on the canvas, a click or drag of the place cursor, and the OK of the PDF, DXF and text import options. The files and thumbnails the place cursor is loaded with are read the same way, and the Place dialog's lines about its files are read on a thread of their own. Files are placed in the order they were started; a file is not placed while a dialog is open or a drag is under way, and a file whose document was closed meanwhile is not placed. `file.place` and `file.place.queue` over MCP and scripts reply as before.
   - A file read for `file.place`, or files read for the place cursor, apart from the session (`Session::place_read`, `Session::place_queue_read`) go only into the document they were read for: while another document is active, or once that document is closed, they are refused with "the document it was prepared for is no longer active" and no document, selection, tool or undo step changes (`crates/engine/src/tests/place.rs`).
   - On the desktop, Paste from a menu or shortcut captures another app's bitmap or reads a copied image file on the UI thread, then decodes the image on the file-reading worker. The status bar shows "Pasting" until the image is pasted. Windows device-independent bitmaps and Linux clipboard images are encoded as PNG on that worker. A Copy or Cut made while the image is read keeps its internal clipboard. `edit.paste*` over MCP and scripts reads the bitmap at once.
+  - File › Revert also drops what was started for the content it discards: a file being read for Place, for the place cursor or dropped on the canvas, a bitmap being read for Paste, and a paste waiting at its Swatch Conflict dialog are not placed or pasted in the reverted document, and the status bar says the document was reverted. Edits made while a file is read, a Revert that fails or that a batch rolls back, and a Revert of another document leave the read to finish as before (`crates/ui-egui/src/placing/tests.rs`).
   - The pixels of a PNG, JPEG, GIF or WebP file that Place decodes to check them are kept in the image store the renderers share, so the canvas's first frame with the placed image draws them without decoding the file again on the UI thread: File › Place, a file dropped on the canvas, a click or drag of the place cursor, `file.place`, and Paste of such an image. A CMYK JPEG is still decoded when it is first drawn (`crates/ui-egui/src/placing.rs`, `crates/render/src/tests.rs`).
   - 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`).