Docs: Image Trace Shapes rework, stroke caps, enhanced presets and gradients over noise (#1845 to #1848)

ROADMAP.md

@@ -6,7 +6,7 @@
 
 **Stage: alpha** · next: beta, ~13 points (ready for real work ~62% → ~75%, and reliable `.ai` exchange) and ~170–270 h away
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (verified PngSuite downloads, #1729; synthetic control-input budgets, #1709; merges of 2026-10-14: anchor Align and Distribute, #1636; Direct Selection fixes, #1674, #1666, #1743; Escape while typing, #1686; Pen clicks and a Precise Cursors command, #1663; Expand on repeats, #1756; Roughen and Scribble, #1643, #1648; file and input hardening, #1776–#1783, #1786, #1807; MCP limits and envelope, #1727, #1728; Image Trace levelling and Flat Logo on scans, #1647, #1657; a guide's position in the Transform panel is a convenience, not a parity claim, #1659; headline numbers unchanged; later merges of 2026-10-13: SVG import of CSS transforms, percentage lengths in symbols, Inkscape flowed text and pages, #1565, #1596, #1568, #1601; Warp Arc, #1578; Pathfinder Trim, Merge and Crop strokes, #1570; saves to folders that refuse the temporary file, #1620 in part; OpenType stylistic sets, #1607; intersect Smart Guides, #1602 in part; headline numbers unchanged; control transport deadlines, #1726; Image Trace edges, strokes, memory and three new options, measured in `docs/image-trace-quality.md`, headline numbers unchanged; community PRs and fixes of 2026-10-13: Polish interface, #1498; compact native saves, #1492; PDF and EPS paste as vector art, #1499; `.ai`, PDF, EPS and SVG import fixes, #1528, #1530, #1531, #1544, #1551, #1553; guide objects, #1534; Join after Average, #1533; Keyboard Shortcuts lists commands outside the menus, #1539; headline numbers unchanged; community PRs and fixes of late 2026-10-12: type that does not fit its frame is reported, #1471; Tabs panel drags, #1458; template layers in Outline view, #1486; dialog slider rails, #1483; Direct Selection anchor precedence, #1508; print-size images, #1517; French catalog complete again, #1511; headline numbers unchanged; Image Trace colour and photo presets, measured in `docs/image-trace-quality.md`, headline numbers unchanged; community PRs and fixes of 2026-10-12: Split Into Grid options, #1462; Transform Objects and Reflect across an angle, #1448 and #1460; Pathfinder on a group, #1450; unknown parameter keys refused, #1442; grayscale TIFFs with alpha, #1466 in part; many-object edits, #1429 in part; headline numbers unchanged; Image Trace places edges to a fraction of a pixel, measured in `docs/image-trace-quality.md`, headline numbers unchanged; Transform dialogs preview and the transform tools act on direct-selected anchors, #1412 and #1408; `.ai` compound path paint, #1410, overprint, #1388, and text-only PDF parts, #1387; community PRs: strokes wider than their shape, corner drags without the bounding box, pasted pictures, compound paths in `document.inspect`, MCP guide; headline numbers unchanged; community PRs: `.ai` editing-data follow-ups (gradient stops, type of objects with an appearance, short area-type frames), PDF bleed with editing data, dialog keyboard focus, art flush with an artboard, font rescan, symbol instance redraw, `--control` port check; headline numbers unchanged; Rectangular Grid and Polar Grid tool options, #1377 in part; `.ai` files with placed (linked) pictures open from their editing data, #1264; community PRs: `.ai` and PDF bleed and editing-data import, gradient shapes imported as paths, ruler origin, Align To, Live Corners corner selection; headline numbers unchanged; G2: Film Grain added; Photoshop effects 29/57; 28 filters remain; community PRs: graph designs, Graph Data worksheet and Graph Type options; Align both centres; Pen endpoint fixes; earlier: Effect › Brush Strokes landed: Photoshop-style filters 28 of 57, raster effects 40% → 48%; `.ai` gradients, meshes and artboard names from the editing data; headline numbers unchanged; `.ai` art styles and clipping fills from the editing data; headline numbers unchanged; `editingData: "always"`; headline numbers unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (Image Trace: Shapes, stroke caps, enhanced presets, gradients over noise, #1845 to #1848, headline numbers unchanged; verified PngSuite downloads, #1729; synthetic control-input budgets, #1709; merges of 2026-10-14: anchor Align and Distribute, #1636; Direct Selection fixes, #1674, #1666, #1743; Escape while typing, #1686; Pen clicks and a Precise Cursors command, #1663; Expand on repeats, #1756; Roughen and Scribble, #1643, #1648; file and input hardening, #1776–#1783, #1786, #1807; MCP limits and envelope, #1727, #1728; Image Trace levelling and Flat Logo on scans, #1647, #1657; a guide's position in the Transform panel is a convenience, not a parity claim, #1659; headline numbers unchanged; later merges of 2026-10-13: SVG import of CSS transforms, percentage lengths in symbols, Inkscape flowed text and pages, #1565, #1596, #1568, #1601; Warp Arc, #1578; Pathfinder Trim, Merge and Crop strokes, #1570; saves to folders that refuse the temporary file, #1620 in part; OpenType stylistic sets, #1607; intersect Smart Guides, #1602 in part; headline numbers unchanged; control transport deadlines, #1726; Image Trace edges, strokes, memory and three new options, measured in `docs/image-trace-quality.md`, headline numbers unchanged; community PRs and fixes of 2026-10-13: Polish interface, #1498; compact native saves, #1492; PDF and EPS paste as vector art, #1499; `.ai`, PDF, EPS and SVG import fixes, #1528, #1530, #1531, #1544, #1551, #1553; guide objects, #1534; Join after Average, #1533; Keyboard Shortcuts lists commands outside the menus, #1539; headline numbers unchanged; community PRs and fixes of late 2026-10-12: type that does not fit its frame is reported, #1471; Tabs panel drags, #1458; template layers in Outline view, #1486; dialog slider rails, #1483; Direct Selection anchor precedence, #1508; print-size images, #1517; French catalog complete again, #1511; headline numbers unchanged; Image Trace colour and photo presets, measured in `docs/image-trace-quality.md`, headline numbers unchanged; community PRs and fixes of 2026-10-12: Split Into Grid options, #1462; Transform Objects and Reflect across an angle, #1448 and #1460; Pathfinder on a group, #1450; unknown parameter keys refused, #1442; grayscale TIFFs with alpha, #1466 in part; many-object edits, #1429 in part; headline numbers unchanged; Image Trace places edges to a fraction of a pixel, measured in `docs/image-trace-quality.md`, headline numbers unchanged; Transform dialogs preview and the transform tools act on direct-selected anchors, #1412 and #1408; `.ai` compound path paint, #1410, overprint, #1388, and text-only PDF parts, #1387; community PRs: strokes wider than their shape, corner drags without the bounding box, pasted pictures, compound paths in `document.inspect`, MCP guide; headline numbers unchanged; community PRs: `.ai` editing-data follow-ups (gradient stops, type of objects with an appearance, short area-type frames), PDF bleed with editing data, dialog keyboard focus, art flush with an artboard, font rescan, symbol instance redraw, `--control` port check; headline numbers unchanged; Rectangular Grid and Polar Grid tool options, #1377 in part; `.ai` files with placed (linked) pictures open from their editing data, #1264; community PRs: `.ai` and PDF bleed and editing-data import, gradient shapes imported as paths, ruler origin, Align To, Live Corners corner selection; headline numbers unchanged; G2: Film Grain added; Photoshop effects 29/57; 28 filters remain; community PRs: graph designs, Graph Data worksheet and Graph Type options; Align both centres; Pen endpoint fixes; earlier: Effect › Brush Strokes landed: Photoshop-style filters 28 of 57, raster effects 40% → 48%; `.ai` gradients, meshes and artboard names from the editing data; headline numbers unchanged; `.ai` art styles and clipping fills from the editing data; headline numbers unchanged; `editingData: "always"`; headline numbers unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
 
 VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adobe Illustrator workflow. It runs
 on macOS, Windows, Linux, FreeBSD and the web (WASM), and agents can drive all of it over MCP, the CLI and a JSON
@@ -129,6 +129,7 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
 
 | Date | What landed |
 |---|---|
+| 2026-10-14 | Image Trace: Shapes finds rounded rectangles and shapes in blurred and scanned art (98 to 100% of the plain-shape inputs, from 57 to 62%; #1845), square-ended lines get square caps (Outline's largest distance 2.94 px to 0.88; #1846), each documented preset has an enhanced version with Auto Grouping and Shapes that measures no worse than the preset (#1847), and blurred or noisy linear gradients trace as one gradient-filled path instead of 3 to 56 (#1848) ([`docs/image-trace-quality.md`](docs/image-trace-quality.md)). No headline number moves. |
 | 2026-10-13 | Synthetic control input has finite click/drag counts and pending-event limits, checked before queue mutation; control-channel bursts yield after 64 requests per frame (#1709). |
 | 2026-10-14 | Align and Distribute act on the anchor points selected with Direct Selection: the points of one path align to each other, not to the artboard, and Distribute spaces them (#1641, fixes #1636; aligning to a key anchor is still missing). Delete removes every selected anchor of a closed path (it used to remove the wrong ones), removes objects selected whole along with the selected anchors of others, and keeps the remainder selected so a second Delete removes it (#1674). In isolation mode Direct Selection and Group Selection pick only inside the isolated object (#1666). Escape cancels a Direct Selection drag (#1803, #1743). Escape while typing ends the edit, keeps the type selected and switches to the Selection tool (#1802, #1686, #1656). A filled Pencil path keeps a stroke of None (#1804, part of #1679). With the Pen, a press that moves under 3 screen pixels is a click (a corner without handles), and a Precise Cursors command toggles the existing preference and can take a shortcut (#1663). The [ and ] keys reach the Blob Brush, the Eraser and the Symbolism tools in the app (#1734, part of #1661). In the Pathfinder panel a group selected alone counts its nested shapes, so an expanded stroked object keeps the Shape Modes enabled (#1642, #1635). Object › Expand turns radial, grid and mirror repeats into groups of their instances (#1765, #1756). Select › Same matches type on its characters' fill and stroke (#1746, #1737). Fields commit what was typed when you click away or move to another field, as Enter does; Escape still discards it (#1787). Up and Down move through the command search results and Enter runs the highlighted one (#1798, #1757). Slider rails show on Medium Dark (#1808, #1662). On Windows the custom title bar's window stays truly borderless, so the pointer lines up with what is drawn on systems where the hidden caption offset it (#1791, #1758; awaiting the reporter's confirmation). Tool cursors are painted into the window on Wayland (#1652; not run on Linux, #1645 stays open until confirmed). Roughen with Smooth keeps turn-backs smooth instead of making cusps that draw as spikes (#1646, #1643). Scribble draws one zig-zag per region, with no lines across holes and notches; convex shapes are unchanged (#1651, #1648). EPS import: a stitched shading keeps its hard colour changes (#1654, #1653). WMF/EMF import refuses an oversized embedded PNG or JPEG from its header, before any pixels are decoded (#1776). PDF open no longer takes exponential time on a crafted name tree with shared nodes when it looks for the editing data (#1781). The size limits on a native file's embedded data also apply to files read from memory, not only streamed ones (#1783). Saving over a private file on Unix no longer leaves a readable temporary copy beside it while the file is written (#1778). An Export for Screens suffix can no longer place files outside the export folder (#1777). Package refuses a folder where it would overwrite the open document or one of its linked files (#1786). ruzstd 0.9.1 fixes a decompression bomb (RUSTSEC-2026-0344) reachable from EPS/`.ai` and Affinity import (#1807). File Info dates are stamped only after a save succeeds, so a failed save no longer changes them (#1774). Linked files that change during a drag are updated after the drag instead of being missed (#1773). Scatter graph data near the largest number is refused with a message instead of hanging the app (#1780). One very long Liquify stroke segment can no longer create an unbounded number of dabs (#1779). A drag whose last preview failed is no longer recorded as a committed command in the journal that actions and scripts read (#1775). Tests: text import fuzzing no longer searches installed fonts (#1785). Tests: render tests that add fonts no longer race the frame cache tests (#1795). `text.create`, `text.createInPath` and the MCP `add_text` tool take `justify`, so point type can be centred on or end at its point (#1752, #1748). Control replies are written through a 64 KiB buffer: a 10 MB `document.inspect` reply over loopback on Windows takes 0.25 s instead of 36 s (#1684). MCP limits: 16 MiB lines, 64-message batches, 256-step `command_batch` with 8 MiB of kept results and 256 MiB control replies (#1764, fixes #1727). MCP requires the JSON-RPC 2.0 envelope and matches control replies by id, and an app refusal without an id reports the app's reason (#1768, fixes #1728). The MCP server reconnects to the app before a call when the connection was closed or holds stray bytes, after an app restart or an idle expiry (#1739). Image Trace, measured in `image-trace-quality.md`: 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). No headline number movLine truncated
 | 2026-10-13 | SVGs that move objects with a CSS transform (`translate(100px, 0)`, `rotate(45deg)`) or style type with the `font` shorthand import as drawn (#1565). SVG symbols whose shapes use percentage lengths import at the size and place they are drawn, the percentages being of the symbol's `viewBox` (#1596). Inkscape's flowed text (`flowRoot`) opens as area type in its rectangle, a paragraph per `flowPara`, instead of being dropped, and a region that can't be read is left out with a warning (#1569, fixes #1568). The warning for an unsupported SVG filter names the filter, its primitives and the object, and says the object is drawn without it (#1599, fixes #1598). The pages of an Inkscape multi-page SVG become artboards, named by their labels (#1603, fixes #1601). SVG export with CSS classes or style entities stays fast in documents with many distinct styles (#1567). PDF and `.ai` import: evenly letter-spaced or tightened type on a path keeps its length along the path instead of closing up to the font's advances (#1586), and type on a path whose stroke is written glyph by glyph comes in as one text object with its stroke, not one object per glyph (#1585). The ICC profiles embedded in JPEG, TIFF and PSD exports have every tag on a 4-byte boundary (ICC.1 §7.1.2), so strict readers accept them (#1589, fixes #1584). GIF, PNG-8 and other indexed exports find each pixel's palette colour through an index instead of a scan, with identical output (#1576). Saving to a network drive on macOS falls back to a plain fsync when the share refuses a full flush (#1625, part of #1620; not confirmed on a real share), and a save still succeeds when a folder refuses the temporary file, the rename over the document or copying permissions: the content is written elsewhere first and copied in, and a failed copy keeps the temporary file and names it (#1649, part of #1620). A document opened by a relative path finds its relatively linked images, and `vectorcraft-cli convert` lists what reading the input left out as `importWarnings` (#1606, fixes #1604). A zero-length subpath draws its round cap as a dot and its projecting cap as a square, so dots in imported `.ai` and SVG files show (#1619, fixes #1613). Pathfinder's Trim, Merge and Crop remove the objects' strokes, and Merge joins same-fill objects whatever their strokes were, as the public Pathfinder page describes (#1572, fixes #1570). Offset Path with an inset larger than the shapes says the offset leaves nothing, instead of asking to select paths (#1591, fixes #1590). The Symbols panel's New Symbol opens Symbol Options to name the symbol first, and Alt-click skips it (#1566, fixes #1560). Tool flyouts are as wide as their longest translated name and shortcut need, so names no longer run into shortcuts in Spanish and other languages (#1650, fixes #1616). Smart Guides: a point drawn with the Pen or a shape tool, and an anchor dragged with Direct Selection, snaps to where paths and ruler guides cross, labelled "intersect" (#1658, part of #1602; a moved selection's own anchors don't). The Transform panel shows a selected ruler guide's X or Y, and typing a value moves it (#1659, part of #1597). This is not established by the documentation we could find: the public help pages on guides, rulers and the Transform, Control and Properties panels (read again on 2026-10-14) describe selecting and dragging unlocked guides and the panels' X and Y for a selection, not a guide's position in a panel, and the one public statement of it is a user's [community answer](https://community.adobe.com/questions-652/adding-a-new-custom-guide-785586), which is not documentation. It is kept as a convenience pending the owner's decision, with no parity claim and nothing counted towards a score. Select Behind (Ctrl/Cmd-click) tests each object once, so a deep stack of overlapping objects no longer slows it; same objects in the same order (#1571). Commands that take `ids` run on the objects given with nothing selected, over MCP, the control channel and the CLI too (#1577, fixes #1575). Zig Zag spaces its ridges evenly along each segment, so lines and curves get a regular wave in Corner and Smooth (#1558). Warp › Arc (the effect and Envelope › Make with Warp) bends in the object's real proportions: a circular arc with concentric edges and no fold-over at 100%, so Arc on art that isn't square draws differently from before (#1581, fixes #1578). `effect.apply` and `effect.setParams` give an error for a misspelt or wrongly typed effect parameter instead of running the effect with its default (#1623, #1592). Area type in a non-rectangular shape moves a word too wide for the top lines down to the first line that holds it instead of breaking it (#1617, fixes #1615). Stylistic sets (ss01–ss20), stylistic and titling alternates, proportional and lining figures, and superscript and subscript glyphs can be turned on as OpenType features of a character style (`text.setStyle {features}`), and the OpenType panel kLine truncated

crates/cad/src/import.rs

@@ -214,7 +214,6 @@ pub fn import(bytes: &[u8], o: &ImportOptions) -> Result<Imported, String> {
     let (mut document, mut warnings) = build::Build::new(&d, o).run(layout, natural, ratio)?;
     document.units = if o.fit { unit } else { o.unit.unwrap_or(unit) };
     warnings.extend(damaged);
-    document.limit_depth_noting(&mut warnings);
     Ok(Imported { document, warnings })
 }
 

crates/doc/src/clipnest.rs

@@ -24,10 +24,8 @@ pub struct Clip {
 }
 
 /// Deepest nesting of clips, and of groups, an importer records ([`nest`] goes one level deeper
-/// for each): deeper ones are left out. As deep as a document's objects may nest
-/// ([`crate::MAX_DEPTH`]) under a layer, around the art; clips in groups that deep together are
-/// merged by [`Document::limit_depth`].
-pub const MAX_NEST: usize = crate::MAX_DEPTH - 2;
+/// for each): deeper ones are left out.
+pub const MAX_NEST: usize = 128;
 
 /// The warning for clips left out for nesting deeper than [`MAX_NEST`].
 pub fn deep_clips() -> String {

crates/doc/src/depth.rs

@@ -1,588 +0,0 @@
-//! How deep objects may nest.
-//!
-//! The tree is walked by recursion everywhere (drawing, bounds, hit tests, saving, exporting), so
-//! a tree of unbounded depth overflows the stack: an abort no guard catches. No document deeper
-//! than [`MAX_DEPTH`] is ever kept, nor one whose symbols and patterns draw deeper than
-//! [`MAX_DRAWN_DEPTH`] (a symbol holding an instance of itself, or a pattern painting its own
-//! tile, draws without end): importers and the native reader merge deeper objects into the group
-//! around them and leave such instances and paints out
-//! ([`Document::limit_depth`], with [`merged_note`] and [`symbols_note`] as their warnings), and
-//! the engine refuses an edit that would nest deeper ([`Document::too_deep`]).
-
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use vectorcraft_color::Paint;
-
-use crate::{Document, Node, NodeKind};
-
-/// The deepest an object may be: a top-level layer is 1 deep, what it holds 2, and so on (the art
-/// of an opacity mask is one deeper than the object it masks). A symbol's or pattern's art counts
-/// from 1 again.
-///
-/// A native file writes three levels of JSON for each level of objects, and its reader stops at
-/// 128 levels: 32 leaves the deepest object 29 of them for its own data, so every document that
-/// can be made can be saved and opened again.
-pub const MAX_DEPTH: usize = 32;
-
-/// The deepest an object may be drawn: as [`MAX_DEPTH`], the art of a symbol counted under its
-/// instance and a pattern's tile under the object it paints (and what those use, under them).
-/// Symbols a few objects deep nest in one another dozens deep within it.
-pub const MAX_DRAWN_DEPTH: usize = 4 * MAX_DEPTH;
-
-/// The warning of a file whose objects were nested deeper than [`MAX_DEPTH`].
-pub fn merged_note() -> String {
-    format!("objects nested more than {MAX_DEPTH} deep were merged into the group around them")
-}
-
-/// The warning of a file with symbols or patterns that use themselves or are drawn deeper than
-/// [`MAX_DRAWN_DEPTH`].
-pub fn symbols_note() -> String {
-    format!(
-        "symbol instances and pattern paints inside their own symbol or pattern, or drawn more than {MAX_DRAWN_DEPTH} objects deep, were left out"
-    )
-}
-
-/// Run `f` where recursion has room: on a thread of its own with a 16 MB stack (the main thread
-/// has 1 MB on Windows), or here where there are no threads (the web) or none can be started. For
-/// readers whose recursion is capped but heavy; a panic in `f` goes on to the caller.
-pub fn with_deep_stack<T: Send>(f: impl Fn() -> T + Sync) -> T {
-    #[cfg(not(target_arch = "wasm32"))]
-    {
-        let threaded = std::thread::scope(|s| {
-            let thread = std::thread::Builder::new().stack_size(16 << 20).spawn_scoped(s, &f).ok()?;
-            Some(thread.join().unwrap_or_else(|panic| std::panic::resume_unwind(panic)))
-        });
-        if let Some(done) = threaded {
-            return done;
-        }
-    }
-    f()
-}
-
-/// Is anything in `now` (each `depth` deep) deeper than [`MAX_DEPTH`], or `over` (given its
-/// depth)? Without recursion: the trees may be of any depth. With `before` (the same list before
-/// an edit, within the caps), only what the edit changed is looked at: a subtree still shared with
-/// it, in the same place, is as it was.
-fn deeper(now: &[Arc<Node>], before: Option<&[Arc<Node>]>, depth: usize, over: &dyn Fn(&Node, usize) -> bool) -> bool {
-    type Pending<'a> = Vec<(&'a Node, Option<&'a Node>, usize)>;
-    fn push<'a>(stack: &mut Pending<'a>, now: &'a [Arc<Node>], before: Option<&'a [Arc<Node>]>, depth: usize) {
-        for (i, n) in now.iter().enumerate() {
-            let was = before.and_then(|b| b.get(i));
-            if !was.is_some_and(|w| Arc::ptr_eq(w, n)) {
-                stack.push((n, was.map(|w| &**w), depth));
-            }
-        }
-    }
-    let mut stack = vec![];
-    push(&mut stack, now, before, depth);
-    while let Some((n, was, d)) = stack.pop() {
-        if d > MAX_DEPTH || over(n, d) {
-            return true;
-        }
-        if let Some(ch) = n.children() {
-            push(&mut stack, ch, was.and_then(Node::children).map(Vec::as_slice), d + 1);
-        }
-        if let Some(m) = &n.extras().mask {
-            let was = was.and_then(|w| w.extras().mask.as_ref()).map(|m| std::slice::from_ref(&m.art));
-            push(&mut stack, std::slice::from_ref(&m.art), was, d + 1);
-        }
-    }
-    false
-}
-
-/// [`deeper`] for the nesting alone.
-fn nested_deeper(now: &[Arc<Node>], depth: usize) -> bool {
-    deeper(now, None, depth, &|_, _| false)
-}
-
-/// Merge what is deeper than [`MAX_DEPTH`] in `nodes` (each `depth` deep) into the group around
-/// it: a container at the cap is replaced by what it holds (a clipping group's clipping path and
-/// an opacity mask too deep are left out); what it held stays hidden or locked as it was. Returns
-/// whether anything changed. Recurses no deeper than the cap.
-fn limit(nodes: &mut Vec<Arc<Node>>, depth: usize) -> bool {
-    let mut changed = false;
-    let mut i = 0;
-    while let Some(n) = nodes.get_mut(i) {
-        if !nested_deeper(std::slice::from_ref(n), depth) {
-            i += 1;
-            continue;
-        }
-        changed = true;
-        let n = Arc::make_mut(n);
-        if n.extras().mask.as_ref().is_some_and(|m| nested_deeper(std::slice::from_ref(&m.art), depth + 1)) {
-            n.extras_mut().mask = None;
-        }
-        if depth < MAX_DEPTH {
-            if let Some(ch) = n.children_mut() {
-                limit(ch, depth + 1);
-            }
-            i += 1;
-            continue;
-        }
-        let clip = matches!(n.kind, NodeKind::Group { clip: true, .. } | NodeKind::Layer { clip: true, .. });
-        let (visible, locked) = (n.visible, n.locked);
-        let mut held = n.children_mut().map(std::mem::take).unwrap_or_default();
-        if clip && !held.is_empty() {
-            held.remove(0);
-        }
-        for c in &mut held {
-            if (!visible && c.visible) || (locked && !c.locked) {
-                let c = Arc::make_mut(c);
-                c.visible &= visible;
-                c.locked |= locked;
-            }
-        }
-        // What it held takes its place, and is looked at in its turn.
-        nodes.splice(i..=i, held);
-    }
-    changed
-}
-
-/// A symbol (`false`) or a pattern (`true`) of the document, by name: what art draws by name, an
-/// instance its symbol's art and a pattern paint its tile's.
-type Def<'a> = (bool, &'a str);
-
-/// How deep each symbol's and pattern's art is drawn, the art of the symbols and patterns it uses
-/// included (drawn under the object that uses them): `None` for one that uses itself, in its art
-/// or through what that uses, or is drawn deeper than [`MAX_DRAWN_DEPTH`].
-type Heights<'a> = HashMap<Def<'a>, Option<usize>>;
-
-/// What `n` itself draws by name: the symbol it is an instance of, the patterns that paint it.
-fn uses(n: &Node) -> impl Iterator<Item = Def<'_>> {
-    let symbol = match &n.kind {
-        NodeKind::SymbolInstance { symbol, .. } => Some((false, symbol.as_str())),
-        _ => None,
-    };
-    let patterns = crate::swatches::node_paints(n).filter_map(|p| match p {
-        Paint::Pattern { pattern, .. } => Some((true, pattern.as_str())),
-        _ => None,
-    });
-    symbol.into_iter().chain(patterns)
-}
-
-/// [`Heights`] of the document's symbols and patterns. Without recursion: they may use one
-/// another in a chain of any length. Their own art is within [`MAX_DEPTH`].
-fn heights(doc: &Document) -> Heights<'_> {
-    // Each one's own depth, and what its art uses with the deepest use of each.
-    type Own<'a> = (usize, Vec<(Def<'a>, usize)>);
-    let arts = (doc.symbols.iter().map(|s| ((false, s.name.as_str()), std::slice::from_ref(&s.art))))
-        .chain(doc.patterns.iter().map(|p| ((true, p.name.as_str()), &p.art[..])));
-    let mut own: HashMap<Def, Own> = HashMap::new();
-    for (def, art) in arts {
-        let (mut deepest, mut used) = (0, HashMap::<Def, usize>::new());
-        let mut stack: Vec<(&Node, usize)> = art.iter().map(|n| (&**n, 1)).collect();
-        while let Some((n, d)) = stack.pop() {
-            deepest = deepest.max(d);
-            for u in uses(n) {
-                let at = used.entry(u).or_default();
-                *at = (*at).max(d);
-            }
-            stack.extend(n.children().into_iter().flatten().chain(n.extras().mask.as_ref().map(|m| &m.art)).map(|c| (&**c, d + 1)));
-        }
-        // (The first of two of one name is the one drawn.)
-        own.entry(def).or_insert((deepest, used.into_iter().collect()));
-    }
-    // Depth first over what uses what. One met again while it is being worked out (`None` in its
-    // entry) uses itself.
-    let mut found: HashMap<Def, Option<Option<usize>>> = HashMap::new();
-    let starts: Vec<Def> = own.keys().copied().collect();
-    for start in starts {
-        if found.contains_key(&start) {
-            continue;
-        }
-        // (which, the next of its uses to look at, the deepest found so far: `None` once it can't be drawn)
-        let mut path: Vec<(Def, usize, Option<usize>)> = vec![(start, 0, own.get(&start).map(|o| o.0))];
-        found.insert(start, None);
-        while let Some(&(def, next, deepest)) = path.last() {
-            let used = own.get(&def).map_or(&[][..], |o| &o.1);
-            let Some(&(other, at)) = used.get(next) else {
-                // Everything it uses is worked out.
-                let deepest = deepest.filter(|d| *d <= MAX_DRAWN_DEPTH);
-                found.insert(def, Some(deepest));
-                path.pop();
-                if let Some((user, next, held)) = path.last_mut() {
-                    let at = own.get(user).and_then(|o| o.1.get(next.wrapping_sub(1))).map_or(1, |u| u.1);
-                    *held = held.zip(deepest).map(|(h, d)| h.max(at + d));
-                }
-                continue;
-            };
-            let known = found.get(&other).copied();
-            if known.is_none() && own.contains_key(&other) {
-                found.insert(other, None);
-            }
-            let Some((_, next, deepest)) = path.last_mut() else { break };
-            *next += 1;
-            match known {
-                // Not in the document: it draws nothing.
-                None if !own.contains_key(&other) => {}
-                None => path.push((other, 0, own.get(&other).map(|o| o.0))),
-                Some(Some(Some(d))) => *deepest = deepest.map(|h| h.max(at + d)),
-                // It uses itself (it is on the way down here), or can't be drawn.
-                Some(None | Some(None)) => *deepest = None,
-            }
-        }
-    }
-    found.into_iter().map(|(def, h)| (def, h.flatten())).collect()
-}
-
-/// Can't `used`, by an object `depth` deep, be drawn there?
-fn undrawable(heights: &Heights, used: Def, depth: usize) -> bool {
-    heights.get(&used).is_some_and(|h| h.is_none_or(|h| depth + h > MAX_DRAWN_DEPTH))
-}
-
-/// Take out of `nodes` (each `depth` deep) the uses `bad` picks (given the depth of the object):
-/// an instance goes, a pattern paint becomes no paint. Returns whether anything changed. For trees
-/// within [`MAX_DEPTH`].
-fn strip(nodes: &mut Vec<Arc<Node>>, depth: usize, bad: &dyn Fn(Def, usize) -> bool) -> bool {
-    let any = |n: &Node, d: usize| uses(n).any(|u| bad(u, d));
-    let before = nodes.len();
-    nodes.retain(|n| !matches!(&n.kind, NodeKind::SymbolInstance { symbol, .. } if bad((false, symbol.as_str()), depth)));
-    let mut changed = nodes.len() != before;
-    for n in nodes.iter_mut() {
-        if !deeper(std::slice::from_ref(n), None, depth, &any) {
-            continue;
-        }
-        changed = true;
-        let n = Arc::make_mut(n);
-        if uses(n).any(|u| bad(u, depth)) {
-            for p in crate::swatches::node_paints_mut(n) {
-                if matches!(p, Paint::Pattern { pattern, .. } if bad((true, pattern.as_str()), depth)) {
-                    *p = Paint::None;
-                }
-            }
-        }
-        // An opacity mask whose art is such an instance goes with it.
-        let mut mask = n.extras().mask.as_ref().map(|m| vec![m.art.clone()]);
-        if let Some(art) = &mut mask
-            && strip(art, depth + 1, bad)
-        {
-            match art.pop() {
-                Some(art) => {
-                    if let Some(m) = n.extras_mut().mask.as_mut() {
-                        m.art = art;
-                    }
-                }
-                None => n.extras_mut().mask = None,
-            }
-        }
-        if let Some(ch) = n.children_mut() {
-            strip(ch, depth + 1, bad);
-        }
-    }
-    changed
-}
-
-impl Document {
-    /// Is anything nested deeper than [`MAX_DEPTH`], or drawn deeper than [`MAX_DRAWN_DEPTH`]
-    /// (a symbol or pattern that uses itself is)? With `before` (this document before an edit,
-    /// itself within the caps), only what the edit changed is looked at.
-    pub fn too_deep(&self, before: Option<&Document>) -> bool {
-        fn symbol(d: &Document, i: usize) -> Option<&[Arc<Node>]> {
-            d.symbols.get(i).map(|s| std::slice::from_ref(&s.art))
-        }
-        fn pattern(d: &Document, i: usize) -> Option<&[Arc<Node>]> {
-            d.patterns.get(i).map(|p| &p.art[..])
-        }
-        let nested = |_: &Node, _: usize| false;
-        if (0..self.symbols.len()).any(|i| symbol(self, i).is_some_and(|art| deeper(art, before.and_then(|b| symbol(b, i)), 1, &nested)))
-            || (0..self.patterns.len()).any(|i| pattern(self, i).is_some_and(|art| deeper(art, before.and_then(|b| pattern(b, i)), 1, &nested)))
-        {
-            return true;
-        }
-        if self.symbols.is_empty() && self.patterns.is_empty() {
-            return deeper(&self.layers, before.map(|b| &b.layers[..]), 1, &nested);
-        }
-        let heights = heights(self);
-        if heights.values().any(Option::is_none) {
-            return true;
-        }
-        // Symbols and patterns draw as deep as before when none changed; else every use of them
-        // is looked at again.
-        let same = |x: &[Arc<Node>], y: &[Arc<Node>]| x.len() == y.len() && x.iter().zip(y).all(|(x, y)| Arc::ptr_eq(x, y));
-        let before = before.filter(|b| {
-            b.symbols.len() == self.symbols.len()
-                && b.patterns.len() == self.patterns.len()
-                && b.symbols.iter().zip(&self.symbols).all(|(x, y)| x.name == y.name && Arc::ptr_eq(&x.art, &y.art))
-                && b.patterns.iter().zip(&self.patterns).all(|(x, y)| x.name == y.name && same(&x.art, &y.art))
-        });
-        let over = |n: &Node, d: usize| uses(n).any(|u| undrawable(&heights, u, d));
-        deeper(&self.layers, before.map(|b| &b.layers[..]), 1, &over)
-    }
-
-    /// [`Self::limit_depth`] → whether objects were merged, and whether uses of symbols and
-    /// patterns were left out.
-    fn limit_depths(&mut self) -> (bool, bool) {
-        let mut merged = limit(&mut self.layers, 1);
-        for s in &mut self.symbols {
-            // The art itself is 1 deep, so it stays the one object it is.
-            let mut art = vec![s.art.clone()];
-            if limit(&mut art, 1)
-                && let Some(one) = art.pop()
-            {
-                s.art = one;
-                merged = true;
-            }
-        }
-        for p in &mut self.patterns {
-            merged |= limit(&mut p.art, 1);
-        }
-        if self.symbols.is_empty() && self.patterns.is_empty() {
-            return (merged, false);
-        }
-        // The symbols and patterns that can't be drawn lose what their art uses: each is then as
-        // deep as its own art, and what uses it can be drawn.
-        let (symbols, patterns): (Vec<usize>, Vec<usize>) = {
-            let heights = heights(self);
-            let bad = |def: Def| heights.get(&def).is_some_and(Option::is_none);
-            (
-                (0..self.symbols.len()).filter(|i| self.symbols.get(*i).is_some_and(|s| bad((false, s.name.as_str())))).collect(),
-                (0..self.patterns.len()).filter(|i| self.patterns.get(*i).is_some_and(|p| bad((true, p.name.as_str())))).collect(),
-            )
-        };
-        let mut left_out = !(symbols.is_empty() && patterns.is_empty());
-        let all = |_: Def, _: usize| true;
-        for i in symbols {
-            let Some(s) = self.symbols.get_mut(i) else { continue };
-            let mut art = vec![s.art.clone()];
-            strip(&mut art, 1, &all);
-            // (An instance alone was the whole art: an empty group stands in.)
-            s.art = art.pop().unwrap_or_else(|| Arc::new(Node::group(s.art.id, vec![])));
-        }
-        for i in patterns {
-            if let Some(p) = self.patterns.get_mut(i) {
-                strip(&mut p.art, 1, &all);
-            }
-        }
-        // Then the uses drawn too deep where they are.
-        let mut layers = self.layers.clone();
-        left_out |= {
-            let heights = heights(self);
-            strip(&mut layers, 1, &|used, depth| undrawable(&heights, used, depth))
-        };
-        self.layers = layers;
-        (merged, left_out)
-    }
-
-    /// Bring the document within the caps: merge the objects nested deeper than [`MAX_DEPTH`]
-    /// into the group around them, and leave out the uses of symbols and patterns that can't be
-    /// drawn (inside their own symbol or pattern, or deeper than [`MAX_DRAWN_DEPTH`]). What an
-    /// importer does to what it read. Returns whether anything changed.
-    pub fn limit_depth(&mut self) -> bool {
-        let (merged, left_out) = self.limit_depths();
-        merged || left_out
-    }
-
-    /// [`Self::limit_depth`], adding [`merged_note`] and [`symbols_note`] to an importer's
-    /// `warnings` for what it did.
-    pub fn limit_depth_noting(&mut self, warnings: &mut Vec<String>) {
-        let (merged, left_out) = self.limit_depths();
-        warnings.extend(merged.then(merged_note));
-        warnings.extend(left_out.then(symbols_note));
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{NodeId, OpacityMask};
-
-    /// One path in `levels` groups, each holding a second path beside the next group.
-    fn nested(levels: usize) -> Arc<Node> {
-        let mut id = 0;
-        let mut next = || {
-            id += 1;
-            NodeId(id)
-        };
-        let path = |id| Arc::new(Node::path(id, Default::default(), Default::default()));
-        let mut inner = path(next());
-        for _ in 0..levels {
-            inner = Arc::new(Node::group(next(), vec![inner, path(next())]));
-        }
-        inner
-    }
-
-    fn doc(art: Arc<Node>) -> Document {
-        let mut d = Document::new(100.0, 100.0);
-        if let Some(ch) = d.layers.first_mut().and_then(|l| Arc::make_mut(l).children_mut()) {
-            ch.push(art);
-        }
-        d
-    }
-
-    #[test]
-    fn a_document_at_the_cap_is_left_alone() {
-        // The layer, the groups and the path in them: MAX_DEPTH deep.
-        let mut d = doc(nested(MAX_DEPTH - 2));
-        let before = d.clone();
-        assert!(!d.too_deep(None));
-        assert!(!d.limit_depth());
-        assert_eq!(d, before);
-    }
-
-    #[test]
-    fn deeper_objects_are_merged_into_the_group_around_them() {
-        for levels in [MAX_DEPTH - 1, MAX_DEPTH + 5, 100_000] {
-            let mut d = doc(nested(levels));
-            assert!(d.too_deep(None), "{levels}");
-            assert!(d.limit_depth(), "{levels}");
-            assert!(!d.too_deep(None), "{levels}");
-            // Every path is kept, under the layer and the groups down to the cap.
-            assert_eq!(d.node_count(), 1 + (MAX_DEPTH - 2) + (levels + 1), "{levels}");
-            assert!(!d.limit_depth(), "nothing more to merge");
-        }
-    }
-
-    #[test]
-    fn a_clipping_path_and_a_mask_too_deep_are_left_out_and_hidden_art_stays_hidden() {
-        let mut inner = Node::new(NodeId(9000), NodeKind::Group { children: vec![nested(0), nested(0)], clip: true });
-        inner.visible = false;
-        let mut art = Arc::new(inner);
-        for i in 0..MAX_DEPTH {
-            art = Arc::new(Node::group(NodeId(9001 + i as u64), vec![art]));
-        }
-        let mut masked = Node::group(NodeId(8000), vec![]);
-        masked.extras_mut().mask = Some(Box::new(OpacityMask::new((*nested(MAX_DEPTH)).clone(), true)));
-        let mut d = doc(art);
-        if let Some(ch) = d.layers.first_mut().and_then(|l| Arc::make_mut(l).children_mut()) {
-            ch.push(Arc::new(masked));
-        }
-        assert!(d.limit_depth());
-        assert!(!d.too_deep(None));
-        let mut leaves = vec![];
-        d.walk(|n| {
-            if n.children().is_none() {
-                leaves.push(n.visible);
-            }
-        });
-        assert_eq!(leaves, [false], "the clipping path is gone, what it clipped is still hidden");
-        assert!(d.node(NodeId(8000)).is_some_and(|n| n.extras().mask.is_none()));
-    }
-
-    #[test]
-    fn an_edit_is_checked_by_what_it_changed() {
-        let before = doc(nested(MAX_DEPTH - 2));
-        let mut wrapped = before.clone();
-        if let Some(ch) = wrapped.layers.first_mut().and_then(|l| Arc::make_mut(l).children_mut()) {
-            let all = std::mem::take(ch);
-            ch.push(Arc::new(Node::group(NodeId(7000), all)));
-        }
-        assert!(wrapped.too_deep(Some(&before)), "the same art, one deeper");
-        let mut beside = before.clone();
-        if let Some(ch) = beside.layers.first_mut().and_then(|l| Arc::make_mut(l).children_mut()) {
-            ch.push(nested(3));
-        }
-        assert!(!beside.too_deep(Some(&before)));
-        assert!(!before.too_deep(Some(&before)));
-    }
-
-    #[test]
-    fn symbols_and_patterns_are_limited_too() {
-        let mut d = Document::new(10.0, 10.0);
-        d.symbols.push(crate::Symbol { name: "s".into(), art: nested(MAX_DEPTH + 3) });
-        assert!(d.too_deep(None));
-        assert!(d.limit_depth());
-        assert!(!d.too_deep(None));
-        assert!(d.symbols.first().is_some_and(|s| s.art.children().is_some()), "still one object");
-    }
-
-    fn instance(id: u64, of: &str) -> Arc<Node> {
-        Arc::new(Node::new(NodeId(id), NodeKind::SymbolInstance { symbol: of.into(), xf: Default::default() }))
-    }
-
-    /// `count` symbols, each `levels` groups around an instance of the next; the last one's of `last`.
-    fn symbols(count: usize, levels: usize, last: &str) -> Document {
-        let mut d = doc(instance(1, "s0"));
-        for i in 0..count {
-            let mut art = instance(2, &if i + 1 < count { format!("s{}", i + 1) } else { last.to_string() });
-            for _ in 0..levels {
-                art = Arc::new(Node::group(NodeId(3), vec![art]));
-            }
-            d.symbols.push(crate::Symbol { name: format!("s{i}"), art });
-        }
-        d
-    }
-
-    fn instances(d: &Document) -> usize {
-        let mut n = 0;
-        let mut count = |x: &Node| n += usize::from(matches!(x.kind, NodeKind::SymbolInstance { .. }));
-        d.walk(&mut count);
-        d.symbols.iter().for_each(|s| s.art.walk(&mut count));
-        n
-    }
-
-    #[test]
-    fn symbols_in_symbols_are_drawn_only_so_deep() {
-        // Three objects deep each (two groups and the instance), under the instance on the layer.
-        let fits = MAX_DRAWN_DEPTH / 3 - 1;
-        let mut d = symbols(fits, 2, "none");
-        assert!(!d.too_deep(None) && !d.limit_depth());
-        let mut d = symbols(fits + 2, 2, "none");
-        assert!(d.too_deep(None));
-        let before = instances(&d);
-        assert!(d.limit_depth() && !d.too_deep(None));
-        assert!(instances(&d) < before && instances(&d) > 0, "only the instances drawn too deep go");
-        // A chain of any length is measured, not walked by recursion.
-        let mut d = symbols(100_000, 0, "none");
-        assert!(d.too_deep(None) && d.limit_depth() && !d.too_deep(None));
-    }
-
-    #[test]
-    fn a_symbol_holding_itself_loses_the_instance() {
-        for (count, last) in [(1, "s0"), (3, "s0"), (3, "s1")] {
-            let mut d = symbols(count, 1, last);
-            assert!(d.too_deep(None), "{count} {last}");
-            let mut warnings = vec![];
-            d.limit_depth_noting(&mut warnings);
-            assert_eq!(warnings, [symbols_note()]);
-            assert!(!d.too_deep(None), "{count} {last}");
-            assert!(d.symbols.iter().all(|s| s.art.children().is_some()), "the art is still a group");
-        }
-        // An edit that makes one hold itself is seen, whatever else stayed as it was.
-        let before = symbols(2, 1, "none");
-        let mut after = before.clone();
-        after.symbols[1].art = Arc::new(Node::group(NodeId(9), vec![instance(8, "s0")]));
-        assert!(!before.too_deep(None) && after.too_deep(Some(&before)));
-    }
-
-    /// A path painted with the pattern named `with`.
-    fn painted(id: u64, with: &str) -> Arc<Node> {
-        let fill = Paint::Pattern { pattern: with.into(), xf: Default::default() };
-        Arc::new(Node::path(NodeId(id), Default::default(), crate::Appearance::basic(fill, Paint::None, 0.0)))
-    }
-
-    fn pattern_fills(d: &Document) -> usize {
-        let mut n = 0;
-        d.visit_paints(&mut |p| n += usize::from(matches!(p, Paint::Pattern { .. })));
-        n
-    }
-
-    #[test]
-    fn a_pattern_painting_its_own_tile_loses_the_paint() {
-        // One that paints its own tile; two that paint each other's; one in a symbol it holds.
-        let itself = |d: &mut Document| d.patterns.push(crate::PatternDef::new("p", vec![painted(2, "p")]));
-        let each_other = |d: &mut Document| {
-            d.patterns.push(crate::PatternDef::new("p", vec![painted(2, "q")]));
-            d.patterns.push(crate::PatternDef::new("q", vec![painted(3, "p")]));
-        };
-        let through_a_symbol = |d: &mut Document| {
-            d.patterns.push(crate::PatternDef::new("p", vec![instance(2, "s")]));
-            d.symbols.push(crate::Symbol { name: "s".into(), art: painted(3, "p") });
-        };
-        for make in [&itself as &dyn Fn(&mut Document), &each_other, &through_a_symbol] {
-            let mut d = doc(painted(1, "p"));
-            make(&mut d);
-            assert!(d.too_deep(None));
-            let mut warnings = vec![];
-            d.limit_depth_noting(&mut warnings);
-            assert_eq!(warnings, [symbols_note()]);
-            assert!(!d.too_deep(None));
-            assert_eq!(pattern_fills(&d), 1, "the object on the layer keeps its pattern");
-        }
-        // A pattern whose tile is painted with another is fine.
-        let mut d = doc(painted(1, "p"));
-        d.patterns.push(crate::PatternDef::new("p", vec![painted(2, "q")]));
-        d.patterns.push(crate::PatternDef::new("q", vec![painted(3, "none")]));
-        assert!(!d.too_deep(None) && !d.limit_depth());
-    }
-}

crates/doc/src/lib.rs

@@ -11,7 +11,6 @@ pub mod blend;
 pub mod clipnest;
 pub mod cmyk;
 pub mod corners;
-pub mod depth;
 pub mod graph;
 pub mod hit;
 mod id_index;
@@ -80,7 +79,6 @@ pub use appearance::{
 };
 pub use assets::ExportAsset;
 pub use corners::LiveCorners;
-pub use depth::MAX_DEPTH;
 pub use graph::{
     GraphDesign, GraphKind, GraphSpec, LabelStyles, MAX_GRAPH_CATEGORIES, MAX_GRAPH_SERIES, PiePosition, PieSort, SeriesPaint, TickLength,
     ValueAxisSide,

crates/doc/src/swatches.rs

@@ -224,7 +224,7 @@ fn item_paint_mut(it: &mut AppearanceItem) -> &mut Paint {
 }
 
 /// The paints a node holds itself (not its children): appearance items, then text runs.
-pub(crate) fn node_paints(n: &Node) -> impl Iterator<Item = &Paint> {
+fn node_paints(n: &Node) -> impl Iterator<Item = &Paint> {
     let runs = match &n.kind {
         NodeKind::Text(t) => t.runs.as_slice(),
         _ => &[],
@@ -233,7 +233,7 @@ pub(crate) fn node_paints(n: &Node) -> impl Iterator<Item = &Paint> {
 }
 
 /// Mutable [`node_paints`], in the same order.
-pub(crate) fn node_paints_mut(n: &mut Node) -> impl Iterator<Item = &mut Paint> {
+fn node_paints_mut(n: &mut Node) -> impl Iterator<Item = &mut Paint> {
     let runs = match &mut n.kind {
         NodeKind::Text(t) => t.runs.as_mut_slice(),
         _ => &mut [],

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

@@ -32,7 +32,6 @@ pub(super) fn import(name: &str, bytes: &[u8]) -> Result<Imported> {
         Ok(d) => {
             let mut b = Builder { doc: Document::new(0.0, 0.0), warnings: Vec::new(), k: 72.0 / d.dpi, layer: 0 };
             b.document(&d)?;
-            b.doc.limit_depth_noting(&mut b.warnings);
             let mut warnings = d.warnings.iter().map(|w| format!("Affinity: not imported or approximated: {w}.")).collect::<Vec<_>>();
             warnings.extend(b.warnings.iter().map(|w| format!("Affinity: {w}.")));
             Ok(Imported { doc: b.doc, warnings, preview_only: false })

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

@@ -139,8 +139,7 @@ fn restore_or_import(
 /// (with a warning for each that can't be used).
 pub(crate) fn native_file(bytes: &[u8]) -> Result<(Document, vectorcraft_format::FileInfo, Vec<String>)> {
     let f = vectorcraft_format::load_file(bytes).map_err(err)?;
-    let mut warnings = super::native::install_profiles(f.profiles);
-    warnings.extend(f.depth_notes);
+    let warnings = super::native::install_profiles(f.profiles);
     Ok((f.doc, f.info, warnings))
 }
 

crates/engine/src/lib.rs

@@ -583,10 +583,6 @@ pub(crate) fn is_guide_path(d: &Document, id: NodeId) -> bool {
     d.node(id).is_some_and(|n| matches!(n.kind, NodeKind::Path { guide: true, .. }))
 }
 
-/// The error of an edit that would nest objects deeper than [`vectorcraft_doc::MAX_DEPTH`].
-pub const TOO_DEEP: &str = "objects can't be nested more than 32 deep";
-const _: () = assert!(vectorcraft_doc::MAX_DEPTH == 32, "TOO_DEEP (and its catalog rows) names the cap");
-
 /// Cheap sanity check after an edit: artboards and the objects just touched (the selection) must
 /// have finite, in-range geometry, so saved files always reload and renderers never see NaN/∞.
 fn doc_sane(d: &Document, sel: &Selection) -> bool {
@@ -1249,9 +1245,6 @@ impl Session {
     }
     /// Add a document and make it active.
     pub fn add_document(&mut self, mut doc: Document, path: Option<String>) -> usize {
-        // Every edit is checked against the document before it, so the first one is within the cap
-        // (importers and the native reader have seen to theirs already, with a warning).
-        doc.limit_depth();
         Self::refresh_text_bounds(&mut doc);
         // Guides from files saved before guides had layers go on a layer.
         doc.adopt_guides();
@@ -1269,7 +1262,6 @@ impl Session {
         if index >= self.docs.len() {
             return false;
         }
-        doc.limit_depth();
         Self::refresh_text_bounds(&mut doc);
         doc.adopt_guides();
         if self.active == Some(index) {
@@ -1484,10 +1476,7 @@ impl Session {
                     if !st.doc.variables.bindings.is_empty() {
                         Arc::make_mut(&mut st.doc).prune_variable_bindings();
                     }
-                    if st.doc.too_deep(Some(&before)) {
-                        // Deeper trees overflow the stack of what walks them.
-                        Err(EngineError::Other(TOO_DEEP.into()))
-                    } else if doc_sane(&st.doc, &st.selection) {
+                    if doc_sane(&st.doc, &st.selection) {
                         Ok(v)
                     } else {
                         Err(EngineError::Other("result would exceed the canvas (coordinates out of range)".into()))

crates/engine/tests/import_fuzz.rs

@@ -2440,345 +2440,3 @@ proptest! {
         checked("mutated script", json!({"dataBase64": vectorcraft_format::base64_encode(&bytes), "name": "sample.jsx"}))?;
     }
 }
-
-// ---------- deep nesting ----------
-//
-// The tree is walked by recursion, so a file nested deeply enough overflowed the stack: an abort,
-// which nothing catches. Every reader caps what it reads, and no document is deeper than
-// `MAX_DEPTH`. These run on a thread with the stack of a Windows main thread (1 MB), where an
-// overflow ends the test run.
-
-use vectorcraft_doc::MAX_DEPTH;
-
-/// `f` on a thread with a 1 MB stack.
-fn on_a_small_stack(f: impl FnOnce() + Send + 'static) {
-    std::thread::Builder::new().stack_size(1 << 20).spawn(f).unwrap().join().unwrap();
-}
-
-/// Open `bytes` as the file `name`: an error, or a document within the cap that renders and
-/// exports. Returns the document and the import's warnings.
-fn open_deep(name: &str, bytes: &[u8]) -> Option<(Document, Vec<String>)> {
-    let loaded = vectorcraft_engine::cmd::fileio::load(name, bytes).ok()?;
-    assert!(!loaded.doc.too_deep(None), "{name}: deeper than the cap");
-    let doc = loaded.doc.clone();
-    survive(name, move || Some(doc)).unwrap();
-    Some((loaded.doc, loaded.warnings))
-}
-
-fn merged(warnings: &[String]) -> bool {
-    warnings.iter().any(|w| w.contains("nested more than"))
-}
-
-fn paths_in(doc: &Document) -> usize {
-    let mut paths = 0;
-    doc.walk(|n| paths += usize::from(n.path_data().is_some()));
-    paths
-}
-
-const SVG_NS: &str = "xmlns=\"http://www.w3.org/2000/svg\"";
-
-/// `n` groups in one another, each named (so it is kept) and with a rectangle beside the next.
-fn nested_svg(n: usize) -> String {
-    let open: String = (0..n).map(|i| format!("<g id=\"g{i}\"><rect width=\"5\" height=\"5\"/>")).collect();
-    format!("<svg {SVG_NS} width=\"100\" height=\"100\">{open}<rect width=\"10\" height=\"10\"/>{}</svg>", "</g>".repeat(n))
-}
-
-#[test]
-fn deeply_nested_svg_is_refused_or_merged() {
-    on_a_small_stack(|| {
-        // Within what the reader takes: opened, the groups past the cap merged into the last.
-        let (doc, warnings) = open_deep("deep.svg", nested_svg(40).as_bytes()).expect("40 groups open");
-        assert!(merged(&warnings), "{warnings:?}");
-        assert_eq!(paths_in(&doc), 41, "no art is lost");
-        let (_, warnings) = open_deep("shallow.svg", nested_svg(20).as_bytes()).expect("20 groups open");
-        assert!(!merged(&warnings), "{warnings:?}");
-        // As deep as the reader goes (on a stack of its own): opened and merged the same.
-        let most = vectorcraft_svg::MAX_ELEMENT_DEPTH;
-        let (doc, warnings) = open_deep("deepest.svg", nested_svg(most - 2).as_bytes()).expect("opens at the reader's cap");
-        assert!(merged(&warnings), "{warnings:?}");
-        assert_eq!(paths_in(&doc), most - 1, "no art is lost");
-        // Past it: an error that says why, whatever the depth.
-        for n in [most, 2 * most, 200_000] {
-            let e = vectorcraft_engine::cmd::fileio::load("deep.svg", nested_svg(n).as_bytes()).err().expect("refused").to_string();
-            assert!(e.contains(&format!("nested more than {most} deep")), "{n}: {e}");
-        }
-        // Unnamed groups of one object aren't kept, but usvg walks them all the same.
-        let plain = format!(
-            "<svg {SVG_NS} width=\"9\" height=\"9\">{}<rect width=\"1\" height=\"1\"/>{}</svg>",
-            "<g>".repeat(2 * most),
-            "</g>".repeat(2 * most)
-        );
-        assert!(open_deep("plain.svg", plain.as_bytes()).is_none());
-        // A chain of `<use>`: shallow XML, a deep tree.
-        let links: String = (0..3000).map(|i| format!("<g id=\"u{i}\"><use href=\"#u{}\"/></g>", i + 1)).collect();
-        let chain = format!(
-            "<svg {SVG_NS} width=\"9\" height=\"9\"><defs>{links}<rect id=\"u3000\" width=\"1\" height=\"1\"/></defs><use href=\"#u0\"/></svg>"
-        );
-        assert!(open_deep("chain.svg", chain.as_bytes()).is_none());
-        // Placed and pasted, as opened.
-        let mut s = vectorcraft_engine::Session::new();
-        s.execute("file.new", &json!({"width": 300, "height": 200})).unwrap();
-        for n in [40, 2 * most] {
-            let p = json!({"name": "deep.svg", "dataBase64": vectorcraft_format::base64_encode(nested_svg(n).as_bytes())});
-            let _ = no_panic(s.execute("file.place", &p));
-            let _ = no_panic(s.execute("clipboard.importSvg", &json!({"svg": nested_svg(n)})));
-            let _ = no_panic(s.execute("edit.paste", &json!({})));
-            assert!(!s.doc().unwrap().doc.too_deep(None));
-        }
-    });
-}
-
-/// A page whose content is `content`, with `resources`.
-fn deep_pdf(content: &str, resources: &str) -> Vec<u8> {
-    handmade_pdf(content, resources, "[0 0 100 100]")
-}
-
-/// An EPS whose program is `body`.
-fn deep_eps(body: &str) -> Vec<u8> {
-    format!("%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 100 100\n%%EndComments\n{body}\nshowpage\n%%EOF\n").into_bytes()
-}
-
-/// A test for each file: it opens as an error or as a document within the cap, on a small stack.
-macro_rules! deep_files {
-    ($($test:ident: $name:literal, $bytes:expr;)*) => {$(
-        #[test]
-        fn $test() {
-            on_a_small_stack(|| {
-                open_deep($name, &$bytes);
-            });
-        }
-    )*};
-}
-
-deep_files! {
-    // PDF: clips inside clips (saved states never restored); arrays in arrays as an operand and as
-    // an object; dictionaries in dictionaries as a resource and inline; marked content never ended.
-    pdf_clips_in_clips: "clips.pdf", deep_pdf(&format!("{} 0 0 5 5 re f", "q 0 0 50 50 re W n ".repeat(20_000)), "<< >>");
-    pdf_arrays_in_an_operand: "arrays.pdf", deep_pdf(&format!("BT {}{} TJ ET 0 0 5 5 re f", "[".repeat(100_000), "]".repeat(100_000)), "<< >>");
-    pdf_arrays_in_an_object: "boxes.pdf", handmade_pdf("0 0 5 5 re f", "<< >>", &format!("{}0 0 100 100{}", "[".repeat(100_000), "]".repeat(100_000)));
-    pdf_dictionaries_in_resources: "dicts.pdf", deep_pdf("0 0 5 5 re f", &format!("{}{}", "<< /A ".repeat(50_000), ">> ".repeat(50_000)));
-    pdf_dictionaries_in_content: "inline.pdf", deep_pdf(&format!("/P {}{} DP 0 0 5 5 re f", "<< /A ".repeat(50_000), ">> ".repeat(50_000)), "<< >>");
-    pdf_marked_content_never_ended: "marked.pdf", deep_pdf(&format!("{} 0 0 5 5 re f", "/Span << /MCID 0 >> BDC ".repeat(50_000)), "<< >>");
-    // PostScript: clips inside clips; procedures in procedures; arrays in arrays; a procedure that
-    // calls itself; dictionaries never ended.
-    eps_clips_in_clips: "clips.eps", deep_eps(&format!("{} 0 0 5 5 rectfill", "gsave 0 0 50 50 rectclip ".repeat(20_000)));
-    eps_procedures_in_procedures: "procs.eps", deep_eps(&format!("{}{} 0 0 5 5 rectfill", "{".repeat(100_000), "}".repeat(100_000)));
-    eps_arrays_in_arrays: "arrays.eps", deep_eps(&format!("{}{} pop 0 0 5 5 rectfill", "[".repeat(100_000), "]".repeat(100_000)));
-    eps_a_procedure_calling_itself: "runaway.eps", deep_eps("/f { 0 0 5 5 rectfill f } def f");
-    eps_dictionaries_never_ended: "dicts.eps", deep_eps(&format!("{} 0 0 5 5 rectfill", "1 dict begin ".repeat(100_000)));
-}
-
-#[test]
-fn deeply_nested_dxf_blocks_are_read_within_the_cap() {
-    on_a_small_stack(|| {
-        // Block `B0` inserts `B1`, which inserts `B2`, and so on; the last one holds a line.
-        let pair = |c: i32, v: &str| (c, v.to_string());
-        let mut pairs = vec![pair(0, "SECTION"), pair(2, "BLOCKS")];
-        for i in 0..2_000 {
-            pairs.extend([pair(0, "BLOCK"), pair(2, &format!("B{i}")), pair(10, "0"), pair(20, "0")]);
-            if i + 1 < 2_000 {
-                pairs.extend([pair(0, "INSERT"), pair(2, &format!("B{}", i + 1)), pair(10, "1"), pair(20, "1")]);
-            } else {
-                pairs.extend([pair(0, "LINE"), pair(10, "0"), pair(20, "0"), pair(11, "5"), pair(21, "5")]);
-            }
-            pairs.push(pair(0, "ENDBLK"));
-        }
-        pairs.extend([pair(0, "ENDSEC"), pair(0, "SECTION"), pair(2, "ENTITIES"), pair(0, "INSERT"), pair(2, "B0"), pair(10, "0"), pair(20, "0")]);
-        pairs.extend([pair(0, "LINE"), pair(10, "0"), pair(20, "0"), pair(11, "9"), pair(21, "9"), pair(0, "ENDSEC"), pair(0, "EOF")]);
-        open_deep("blocks.dxf", dxf_text(&pairs).as_bytes()).expect("opens");
-    });
-}
-
-/// A layer holding `levels` groups in one another around a rectangle, each with a second
-/// rectangle beside the next: `levels + 2` deep.
-fn nested_document(levels: usize) -> Document {
-    use vectorcraft_doc::Node;
-    use vectorcraft_testkit::fixtures::DocBuilder;
-    let mut b = DocBuilder::new(100.0, 100.0);
-    let rect =
-        |b: &mut DocBuilder, x: f64| b.rect_node(vectorcraft_geom::Rect::new(x, 0.0, x + 10.0, 10.0), vectorcraft_color::Color::rgb8(200, 0, 0));
-    let mut inner = rect(&mut b, 0.0);
-    for _ in 0..levels {
-        let beside = rect(&mut b, 20.0);
-        inner = Node::group(b.alloc(), vec![std::sync::Arc::new(inner), std::sync::Arc::new(beside)]);
-        inner.opacity = 0.9;
-    }
-    b.add(inner);
-    b.build()
-}
-
-#[test]
-fn a_document_at_the_cap_saves_opens_and_exports() {
-    on_a_small_stack(|| {
-        let doc = nested_document(MAX_DEPTH - 2);
-        assert!(!doc.too_deep(None));
-        let back = vectorcraft_format::load_file(&vectorcraft_format::save_file(&doc)).expect("what can be made opens again");
-        assert!(back.depth_notes.is_empty());
-        assert_eq!(back.doc.layers, doc.layers);
-        survive("at the cap", || Some(doc.clone())).unwrap();
-        // Every format that keeps the nesting reads its own file back within the cap.
-        let mut s = vectorcraft_engine::Session::new();
-        s.add_document(doc, None);
-        for format in ["svg", "pdf", "eps", "ai"] {
-            let r = s.execute("document.export", &json!({"format": format})).unwrap();
-            let bytes = vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap();
-            open_deep(&format!("cap.{format}"), &bytes).unwrap_or_else(|| panic!("{format} opens"));
-        }
-        for cmd in ["select.all", "document.inspect", "document.info", "edit.copy", "edit.paste", "object.ungroup", "edit.undo"] {
-            no_panic(s.execute(cmd, &json!({}))).unwrap_or_else(|e| panic!("{cmd}: {e}"));
-        }
-    });
-}
-
-#[test]
-fn a_native_file_nested_too_deep_is_merged_or_refused() {
-    on_a_small_stack(|| {
-        // Saved before the cap by a version that could still open it: opened, the deepest merged.
-        let old = vectorcraft_format::save_file(&nested_document(MAX_DEPTH + 2));
-        let (doc, warnings) = open_deep("old.vectorcraft", &old).expect("opens");
-        assert!(merged(&warnings), "{warnings:?}");
-        assert_eq!(paths_in(&doc), MAX_DEPTH + 3, "no art is lost");
-        // Deeper than any version could open, and a hostile file: an error that says why. Written
-        // by hand: a tree this deep can't be built and saved.
-        let text = String::from_utf8(vectorcraft_format::save(&nested_document(0), false)).unwrap();
-        let (open, close) = ("{\"id\":900000,\"kind\":{\"type\":\"group\",\"children\":[", "]}}");
-        let at = text.find("\"children\":[").expect("the layer's children") + "\"children\":[".len();
-        for levels in [100, 50_000] {
-            let deep = format!("{}{}{},{}", &text[..at], open.repeat(levels), close.repeat(levels), &text[at..]);
-            let e = vectorcraft_engine::cmd::fileio::load("deep.vectorcraft", deep.as_bytes()).err().expect("refused").to_string();
-            assert!(e.contains("nested too deep"), "{levels}: {e}");
-        }
-    });
-}
-
-#[test]
-fn commands_cannot_nest_deeper_than_the_cap() {
-    on_a_small_stack(|| {
-        let mut s = vectorcraft_engine::Session::new();
-        s.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
-        s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap();
-        s.execute("select.all", &json!({})).unwrap();
-        let mut grouped = 0;
-        for _ in 0..10_000 {
-            match no_panic(s.execute("object.group", &json!({}))) {
-                Ok(_) => grouped += 1,
-                Err(e) => assert!(e.to_string().contains(vectorcraft_engine::TOO_DEEP), "after {grouped} groups: {e}"),
-            }
-        }
-        // The layer, the groups and the rectangle.
-        assert_eq!(grouped, MAX_DEPTH - 2);
-        assert!(!s.doc().unwrap().doc.too_deep(None));
-        // Other ways down: a clipping mask, a copy pasted, a symbol made of it.
-        for (cmd, p) in [
-            ("object.clippingMask.make", json!({})),
-            ("edit.copy", json!({})),
-            ("edit.pasteInFront", json!({})),
-            ("symbol.new", json!({"name": "deep"})),
-        ] {
-            let _ = no_panic(s.execute(cmd, &p));
-            assert!(!s.doc().unwrap().doc.too_deep(None), "{cmd}");
-        }
-        survive("grouped to the cap", || Some((*s.doc().unwrap().doc).clone())).unwrap();
-    });
-}
-
-/// A document whose one object is an instance of the first of `count` symbols: each symbol's art
-/// is `levels` groups around an instance of the next symbol, the last one of `last`.
-fn symbols_document(count: usize, levels: usize, last: &str) -> Document {
-    use vectorcraft_doc::{Node, NodeKind, Symbol};
-    let instance =
-        |doc: &mut Document, of: String| Node::new(doc.alloc_id(), NodeKind::SymbolInstance { symbol: of, xf: vectorcraft_geom::Affine::IDENTITY });
-    let mut doc = nested_document(1);
-    for i in 0..count {
-        let mut art = instance(&mut doc, if i + 1 < count { format!("s{}", i + 1) } else { last.to_string() });
-        for _ in 0..levels {
-            art = Node::group(doc.alloc_id(), vec![std::sync::Arc::new(art)]);
-        }
-        doc.symbols.push(Symbol { name: format!("s{i}"), art: std::sync::Arc::new(art) });
-    }
-    let first = instance(&mut doc, "s0".into());
-    let layer = doc.layers[0].id;
-    doc.insert(Some(layer), usize::MAX, first).unwrap();
-    doc
-}
-
-/// `doc` saved (as an older version, or a hostile file, could have) and opened again: within the
-/// caps (`kept`: as it was), drawn, exported and edited.
-fn symbols_survive(what: &str, doc: Document, kept: bool) {
-    let (back, warnings) = open_deep("symbols.vectorcraft", &vectorcraft_format::save_file(&doc)).expect("opens");
-    assert_eq!(!warnings.iter().any(|w| w.contains("symbol instances")), kept, "{what}: {warnings:?}");
-    let mut s = vectorcraft_engine::Session::new();
-    s.add_document(back, None);
-    for cmd in [
-        "select.all",
-        "document.inspect",
-        "document.info",
-        "object.expand",
-        "symbol.breakLink",
-        "object.flattenTransparency",
-        "edit.copy",
-        "edit.paste",
-    ] {
-        let _ = no_panic(s.execute(cmd, &json!({})));
-        assert!(!s.doc().unwrap().doc.too_deep(None), "{what}: {cmd}");
-    }
-    for format in ["svg", "pdf", "eps", "png"] {
-        let _ = no_panic(s.execute("document.export", &json!({"format": format})));
-    }
-}
-
-#[test]
-fn a_symbol_holding_itself_opens_without_the_instance() {
-    on_a_small_stack(|| {
-        symbols_survive("a symbol holding itself", symbols_document(1, 1, "s0"), false);
-        symbols_survive("symbols holding one another", symbols_document(3, 2, "s0"), false);
-    });
-}
-
-#[test]
-fn symbols_in_symbols_are_drawn_only_so_deep() {
-    on_a_small_stack(|| {
-        // As deep as symbols draw: each one's art as deep as art goes.
-        symbols_survive("symbols at the cap", symbols_document(3, MAX_DEPTH - 2, "none"), true);
-        symbols_survive("symbols in symbols", symbols_document(40, MAX_DEPTH - 1, "none"), false);
-        // A symbol can't be made to hold itself, or one that holds it, by editing either.
-        let mut s = vectorcraft_engine::Session::new();
-        s.add_document(symbols_document(2, 1, "none"), None);
-        s.execute("select.all", &json!({})).unwrap();
-        for (cmd, p) in [
-            ("symbol.new", json!({"name": "s1"})),
-            ("symbol.update", json!({"name": "s1"})),
-            ("symbol.update", json!({"name": "s0"})),
-            ("symbol.replace", json!({"name": "s1"})),
-        ] {
-            let _ = no_panic(s.execute(cmd, &p));
-            assert!(!s.doc().unwrap().doc.too_deep(None), "{cmd} {p}");
-        }
-    });
-}
-
-#[test]
-fn a_pattern_painting_its_own_tile_opens_without_the_paint() {
-    on_a_small_stack(|| {
-        use vectorcraft_color::Paint;
-        use vectorcraft_doc::{Appearance, PatternDef};
-        let painted = |doc: &mut Document, with: &str| {
-            let fill = Paint::Pattern { pattern: with.into(), xf: vectorcraft_geom::Affine::IDENTITY };
-            let square = vectorcraft_geom::shapes::rectangle(vectorcraft_geom::Rect::new(0.0, 0.0, 20.0, 20.0));
-            vectorcraft_doc::Node::path(doc.alloc_id(), square, Appearance::basic(fill, Paint::None, 0.0))
-        };
-        // One pattern painting its own tile, and two painting each other's.
-        for names in [["p", "p"], ["p", "q"]] {
-            let mut doc = nested_document(1);
-            let (first, second) = (painted(&mut doc, names[1]), painted(&mut doc, names[0]));
-            doc.patterns.push(PatternDef::new(names[0], vec![std::sync::Arc::new(first)]));
-            if names[0] != names[1] {
-                doc.patterns.push(PatternDef::new(names[1], vec![std::sync::Arc::new(second)]));
-            }
-            let on_layer = painted(&mut doc, "p");
-            let layer = doc.layers[0].id;
-            doc.insert(Some(layer), usize::MAX, on_layer).unwrap();
-            symbols_survive("a pattern painting its own tile", doc, false);
-        }
-    });
-}

crates/eps/src/import/interp.rs

@@ -4,6 +4,7 @@
 //! Every operation counts against a budget and procedures nest only so deep, so a looping or
 //! recursing program ends with [`PsError::Limit`] instead of hanging.
 
+use std::cell::RefCell;
 use std::rc::Rc;
 
 use vectorcraft_geom::Affine;
@@ -85,7 +86,7 @@ struct SaveMark {
 }
 
 fn new_dict() -> DictRef {
-    DictRef::new(Dict::new())
+    Rc::new(RefCell::new(Dict::new()))
 }
 
 /// An encoding vector: 256 `/.notdef` names (type is read as Latin-1 whatever the encoding).

crates/eps/src/import/mod.rs

@@ -268,7 +268,5 @@ fn finish_with(out: Out, layers: Vec<Arc<Node>>) -> Imported {
         }
     }
     doc.layers = layers;
-    let mut warnings = out.warnings;
-    doc.limit_depth_noting(&mut warnings);
-    Imported { document: doc, warnings, preview: false }
+    Imported { document: doc, warnings: out.warnings, preview: false }
 }

crates/eps/src/import/native.rs

@@ -993,7 +993,6 @@ fn build(data: &[u8], visible: Option<&Document>, page: Page, outlined: bool, tr
         }
         None => unmark(&mut doc.layers, true, &mut vec![]),
     }
-    doc.limit_depth_noting(&mut notes);
     Ok((doc, notes))
 }
 

crates/eps/src/import/obj.rs

@@ -12,73 +12,7 @@ use super::graphics::GState;
 pub(crate) type Dict = HashMap<Key, Obj>;
 
 /// A shared, mutable dictionary.
-#[derive(Clone, Debug)]
-pub(crate) struct DictRef(Rc<RefCell<Dict>>);
-
-impl DictRef {
-    pub fn new(d: Dict) -> Self {
-        Self(Rc::new(RefCell::new(d)))
-    }
-}
-
-impl std::ops::Deref for DictRef {
-    type Target = Rc<RefCell<Dict>>;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl Drop for DictRef {
-    fn drop(&mut self) {
-        if Rc::strong_count(&self.0) == 1
-            && let Ok(mut d) = self.0.try_borrow_mut()
-        {
-            drop_held(d.drain().map(|(_, v)| v));
-        }
-    }
-}
-
-thread_local! {
-    /// What the composite objects being dropped held, waiting for their turn (while any is).
-    static HELD: RefCell<Option<Vec<Obj>>> = const { RefCell::new(None) };
-}
-
-/// Drop what a composite object held, now that nothing else refers to it, without recursion: a
-/// program nests arrays and dictionaries as deep as it likes (`[ exch ]` in a loop), and dropping
-/// them one inside the other overflows the stack. What `held` holds in its turn waits in [`HELD`]
-/// for the outermost drop, which works through it.
-fn drop_held(held: impl Iterator<Item = Obj>) {
-    let holds = |o: &Obj| matches!(o, Obj::Array { .. } | Obj::Dict(_) | Obj::File { .. } | Obj::GState(_));
-    // (Without the list, when the thread is ending: dropped as they come.)
-    let outermost = HELD.try_with(|h| {
-        let Ok(mut h) = h.try_borrow_mut() else { return false };
-        let outermost = h.is_none();
-        h.get_or_insert_with(Vec::new).extend(held.filter(holds));
-        outermost
-    });
-    if !matches!(outermost, Ok(true)) {
-        return;
-    }
-    // Each drop here puts what it held on the list instead of dropping it.
-    while let Ok(Some(next)) = HELD.try_with(|h| h.try_borrow_mut().ok().and_then(|mut h| h.as_mut().and_then(Vec::pop))) {
-        drop(next);
-    }
-    let _ = HELD.try_with(|h| h.try_borrow_mut().map(|mut h| *h = None)); // Nothing to do when the thread is ending.
-}
-
-/// What [`Shared`] values may be: bytes, or objects (which may hold more of themselves).
-pub(crate) trait Held: Sized {
-    /// Drop the values of storage nothing refers to any more.
-    fn release(_values: Vec<Self>) {}
-}
-
-impl Held for u8 {}
-
-impl Held for Obj {
-    fn release(values: Vec<Self>) {
-        drop_held(values.into_iter());
-    }
-}
+pub(crate) type DictRef = Rc<RefCell<Dict>>;
 
 /// A dictionary key.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -138,7 +72,7 @@ impl Obj {
     }
 
     pub fn dict(d: Dict) -> Self {
-        Self::Dict(DictRef::new(d))
+        Self::Dict(Rc::new(RefCell::new(d)))
     }
 
     /// The number this is (integers and reals).
@@ -201,23 +135,13 @@ impl Obj {
 /// The values of a string or an array: a run of storage that other strings or arrays may share
 /// (`getinterval` makes a new object over part of the same values, as PostScript does).
 #[derive(Clone, Debug)]
-pub(crate) struct Shared<T: Held> {
+pub(crate) struct Shared<T> {
     buf: Rc<RefCell<Vec<T>>>,
     at: usize,
     len: usize,
 }
 
-impl<T: Held> Drop for Shared<T> {
-    fn drop(&mut self) {
-        if Rc::strong_count(&self.buf) == 1
-            && let Ok(mut values) = self.buf.try_borrow_mut()
-        {
-            T::release(std::mem::take(&mut *values));
-        }
-    }
-}
-
-impl<T: Clone + Held> Shared<T> {
+impl<T: Clone> Shared<T> {
     pub fn new(v: Vec<T>) -> Self {
         Self { len: v.len(), buf: Rc::new(RefCell::new(v)), at: 0 }
     }
@@ -274,7 +198,7 @@ impl<T: Clone + Held> Shared<T> {
 }
 
 /// Hashes what [`Shared::same`] compares: the storage and the run of it.
-impl<T: Held> Hash for Shared<T> {
+impl<T> Hash for Shared<T> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         Rc::as_ptr(&self.buf).hash(state);
         (self.at, self.len).hash(state);

crates/eps/src/import/text.rs

@@ -389,7 +389,7 @@ impl Interp<'_> {
         d.insert(Key::name("FontMatrix"), matrix_obj(Affine::scale(0.001)));
         d.insert(Key::name("FontBBox"), Obj::array(vec![Obj::Int(0), Obj::Int(-250), Obj::Int(1000), Obj::Int(1000)]));
         d.insert(Key::name("Encoding"), Obj::array(vec![Obj::name(".notdef"); 256]));
-        let font = DictRef::new(d);
+        let font = Rc::new(std::cell::RefCell::new(d));
         self.fonts.borrow_mut().insert(key, Obj::Dict(font.clone()));
         Ok(font)
     }
@@ -489,7 +489,7 @@ fn transformed(font: &DictRef, m: Affine) -> DictRef {
     let mut d = font.borrow().clone();
     let fm = d.get(&Key::name("FontMatrix")).and_then(|o| o.items().and_then(|i| matrix_of(&i.borrow()))).unwrap_or(Affine::scale(0.001));
     d.insert(Key::name("FontMatrix"), matrix_obj(m * fm));
-    DictRef::new(d)
+    Rc::new(std::cell::RefCell::new(d))
 }
 
 /// The character a glyph name stands for (`A`, `space`, `uni20AC`), else a bullet.

crates/format/src/lib.rs

@@ -482,9 +482,6 @@ pub fn load(bytes: &[u8]) -> Result<Document, FormatError> {
 #[derive(Debug)]
 pub struct NativeFile {
     pub doc: Document,
-    /// What was done to bring the document within the nesting caps
-    /// ([`Document::limit_depth_noting`]: a file saved before them, or a damaged one).
-    pub depth_notes: Vec<String>,
     pub info: FileInfo,
     /// ICC files by profile name (saved with Embed ICC Profiles; undecodable ones are left out).
     pub profiles: BTreeMap<String, Vec<u8>>,
@@ -514,11 +511,7 @@ pub fn load_info(bytes: &[u8]) -> Result<(Document, FileInfo), FormatError> {
 /// [`load`], with everything else the file carries.
 pub fn load_file(bytes: &[u8]) -> Result<NativeFile, FormatError> {
     let file = unpack::Unpacked::new(bytes)?;
-    // The JSON reader stops at 128 levels (a document's objects use three each).
-    let f: File = serde_json::from_slice(file.json()).map_err(|e| {
-        let why = if e.to_string().contains("recursion limit") { format!("its objects are nested too deep ({e})") } else { e.to_string() };
-        FormatError::NotVectorcraft(why)
-    })?;
+    let f: File = serde_json::from_slice(file.json()).map_err(|e| FormatError::NotVectorcraft(e.to_string()))?;
     if f.format != EXTENSION && f.format != LEGACY_EXTENSION {
         return Err(FormatError::NotVectorcraft(format!("format is `{}`", f.format)));
     }
@@ -552,10 +545,8 @@ pub fn load_file(bytes: &[u8]) -> Result<NativeFile, FormatError> {
     // Untrusted: capped, named and pointing at objects the file has.
     doc.tidy_saved_selections();
     doc.tidy_graph_designs();
-    let mut depth_notes = vec![];
-    doc.limit_depth_noting(&mut depth_notes);
     let profiles = f.profiles.into_iter().filter_map(|(name, icc)| Some((name, bytes_of(&icc)?))).collect();
-    Ok(NativeFile { doc, depth_notes, info: FileInfo { version: f.version, legacy: f.format == LEGACY_EXTENSION }, profiles })
+    Ok(NativeFile { doc, info: FileInfo { version: f.version, legacy: f.format == LEGACY_EXTENSION }, profiles })
 }
 
 /// The members of a native file besides its document (which is skipped, not decoded).

crates/metafile/src/lib.rs

@@ -102,9 +102,7 @@ pub struct Imported {
 /// Read an EMF or WMF file (with or without a placeable header) into a document whose one
 /// artboard is the picture's frame.
 pub fn import(bytes: &[u8]) -> Result<Imported, String> {
-    let mut i = import::import(bytes)?;
-    i.document.limit_depth_noting(&mut i.warnings);
-    Ok(i)
+    import::import(bytes)
 }
 
 #[cfg(test)]

crates/pdf/src/import.rs

@@ -149,7 +149,6 @@ pub const PAST_PAGE_NOTE: &str = "art reaching past the page was clipped to it,
 pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportReport, PdfError> {
     let original = crate::pages::open(bytes, opts.password.as_deref())?;
     let picked = crate::pages::picked(opts, original.pages().len())?;
-    picked.iter().filter_map(|&n| original.pages().get(n)).try_for_each(crate::pages::content_too_deep)?;
     let mut ocgs = Ocgs::read(&original);
     let route = opts.layers && !ocgs.list.is_empty();
     // Content that is off imports as hidden layers: an update of the file turns every group on
@@ -167,7 +166,6 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
     let all_on = turned_on.is_some();
     let pdf = turned_on.unwrap_or(original);
     let pages = pdf.pages();
-    picked.iter().filter_map(|&n| pages.get(n)).try_for_each(crate::pages::content_too_deep)?;
 
     let sink: Arc<Mutex<Vec<String>>> = Arc::default();
     let sink2 = sink.clone();
@@ -419,7 +417,6 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
             }
         }
     }
-    doc.limit_depth_noting(&mut warnings);
     Ok(ImportReport { document: doc, warnings, native: crate::editing::editing_in(&pdf), only_text })
 }
 

crates/pdf/src/pages.rs

@@ -33,76 +33,12 @@ pub fn is_postscript(bytes: &[u8]) -> bool {
     bytes.starts_with(b"%!PS") || bytes.starts_with(&[0xC5, 0xD0, 0xD3, 0xC6])
 }
 
-/// The deepest a file's arrays and dictionaries may nest. The PDF reader (hayro) reads them by
-/// recursion, without a cap of its own: a file nested deeply enough overflows the stack, which is
-/// an abort, not an error. Far beyond what a PDF writer makes.
-const MAX_OBJECT_NESTING: usize = 256;
-
-fn too_deep() -> PdfError {
-    PdfError::Parse(format!("its arrays and dictionaries are nested more than {MAX_OBJECT_NESTING} deep"))
-}
-
-/// Do the arrays and dictionaries in the text of `pdf` nest deeper than [`MAX_OBJECT_NESTING`]?
-/// Read as tokens (strings and comments hold none), an object at a time. The data of a stream
-/// with a filter is skipped: it isn't PDF text until decoded, which this doesn't do, so nesting
-/// inside compressed streams is not seen here.
-fn nests_too_deep(pdf: &[u8]) -> bool {
-    let after =
-        |from: usize, what: &[u8]| pdf.get(from..).and_then(|rest| rest.windows(what.len()).position(|w| w == what)).map(|at| from + at + what.len());
-    let word = |at: usize, w: &[u8]| pdf.get(at..).is_some_and(|rest| rest.starts_with(w));
-    let (mut depth, mut filtered) = (0usize, false);
-    let mut i = 0;
-    while let Some(&c) = pdf.get(i) {
-        i += 1;
-        match c {
-            b'%' => i += pdf.get(i..).and_then(|rest| rest.iter().position(|c| matches!(c, b'\n' | b'\r'))).unwrap_or(pdf.len()),
-            b'(' => {
-                // A string: parentheses nest in it, a backslash takes the next byte.
-                let mut open = 1usize;
-                while open > 0 {
-                    match pdf.get(i) {
-                        None => return false,
-                        Some(b'\\') => i += 1,
-                        Some(b'(') => open += 1,
-                        Some(b')') => open -= 1,
-                        Some(_) => {}
-                    }
-                    i += 1;
-                }
-            }
-            b'[' => depth += 1,
-            b']' => depth = depth.saturating_sub(1),
-            b'<' if pdf.get(i) == Some(&b'<') => (depth, i) = (depth + 1, i + 1),
-            b'>' if pdf.get(i) == Some(&b'>') => (depth, i) = (depth.saturating_sub(1), i + 1),
-            // A string in hexadecimal.
-            b'<' => i = after(i, b">").unwrap_or(pdf.len()),
-            b'/' if word(i - 1, b"/Filter") => filtered = true,
-            b'e' if word(i - 1, b"endobj") => (depth, filtered) = (0, false),
-            b'e' if word(i - 1, b"endstream") => i += 8,
-            b's' if word(i - 1, b"stream") => {
-                depth = 0;
-                if std::mem::take(&mut filtered) {
-                    i = after(i, b"endstream").unwrap_or(pdf.len());
-                }
-            }
-            _ => {}
-        }
-        if depth > MAX_OBJECT_NESTING {
-            return true;
-        }
-    }
-    false
-}
-
 /// Read a PDF, decrypting it with `password` (none: the empty user password). The permissions
 /// password opens a file too.
 pub(crate) fn open(bytes: &[u8], password: Option<&str>) -> Result<Pdf, PdfError> {
     if is_postscript(bytes) {
         return Err(PdfError::PostScript);
     }
-    if nests_too_deep(bytes) {
-        return Err(too_deep());
-    }
     let password = password.unwrap_or_default();
     let read = |pw: &str| Pdf::new_with_password(bytes.to_vec(), pw);
     read(password)
@@ -121,12 +57,6 @@ pub(crate) fn open(bytes: &[u8], password: Option<&str>) -> Result<Pdf, PdfError
         })
 }
 
-/// The error of a page whose content, decoded, nests arrays and dictionaries too deep (see
-/// [`MAX_OBJECT_NESTING`]): its operands are read the same way as the file's objects.
-pub(crate) fn content_too_deep(page: &Page<'_>) -> Result<(), PdfError> {
-    if page.page_stream().is_some_and(nests_too_deep) { Err(too_deep()) } else { Ok(()) }
-}
-
 /// The pages and their boxes. An encrypted PDF needs its `password`
 /// ([`PdfError::NeedsPassword`] / [`PdfError::WrongPassword`]).
 pub fn info(bytes: &[u8], password: Option<&str>) -> Result<PdfInfo, PdfError> {

crates/svg/src/import.rs

@@ -18,13 +18,10 @@ use crate::{ImportOptions, SvgError, fnv1a};
 use css::XNode;
 use text::TextSlots;
 
-pub use depth::MAX_ELEMENT_DEPTH;
-pub(crate) use depth::xml_too_deep;
 pub(crate) use fx::BLEND;
 
 mod css;
 mod css_transform;
-mod depth;
 mod files;
 mod fx;
 mod spread;
@@ -32,30 +29,11 @@ mod symbol_units;
 mod text;
 mod vector_effect;
 
-/// The XML of `svg`.
-fn parse(svg: &str) -> Result<roxmltree::Document<'_>, SvgError> {
-    roxmltree::Document::parse_with_options(svg, roxmltree::ParsingOptions { allow_dtd: true, ..Default::default() })
-        .map_err(|e| SvgError::Parse(e.to_string()))
-}
-
 pub(crate) fn import(svg: &str, opts: &ImportOptions) -> Result<(Document, Vec<String>), SvgError> {
-    // Before anything reads the tree: the XML reader, usvg, and what is made of its tree, all by
-    // recursion.
-    let too_deep = || SvgError::TooDeep(depth::MAX_ELEMENT_DEPTH);
-    if depth::xml_too_deep(svg) {
-        return Err(too_deep());
-    }
-    let xml = parse(svg)?;
-    if depth::too_deep(&xml) {
-        return Err(too_deep());
-    }
-    let (svg, found) = prepass(svg, &xml, opts);
-    // The prepass's edits are in the text: the XML is read again only when it made any.
-    let xml = match &svg {
-        Cow::Borrowed(_) => xml,
-        Cow::Owned(edited) => parse(edited)?,
-    };
+    let (svg, found) = prepass(svg, opts);
     let svg = svg.as_ref();
+    let xml = roxmltree::Document::parse_with_options(svg, roxmltree::ParsingOptions { allow_dtd: true, ..Default::default() })
+        .map_err(|e| SvgError::Parse(e.to_string()))?;
     let units = RootUnits::of(xml.root_element());
     let root_name = root_layer_name(xml.root_element());
     let mut warnings = found.warnings;
@@ -187,7 +165,6 @@ pub(crate) fn import(svg: &str, opts: &ImportOptions) -> Result<(Document, Vec<S
             promote_sublayers(Arc::make_mut(l), &im.sublayer_groups);
         }
     }
-    im.doc.limit_depth_noting(&mut im.warnings);
     Ok((im.doc, im.warnings))
 }
 
@@ -577,7 +554,7 @@ impl Edits {
 /// * linked files are read ([`files`]);
 /// * percentage lengths in a `<symbol>` with a `viewBox` become numbers ([`symbol_units`]);
 /// * what style sheet rules with a `:not()` set goes in `style` attributes ([`not_rules`]).
-fn prepass<'s>(svg: &'s str, xml: &roxmltree::Document, opts: &ImportOptions) -> (Cow<'s, str>, Found) {
+fn prepass<'s>(svg: &'s str, opts: &ImportOptions) -> (Cow<'s, str>, Found) {
     let mut found = Found::default();
     // (`:` for prefixed elements such as `<svg:image>`.)
     let css_transform = has_css_transform(svg);
@@ -588,6 +565,9 @@ fn prepass<'s>(svg: &'s str, xml: &roxmltree::Document, opts: &ImportOptions) ->
     {
         return (svg.into(), found);
     }
+    let Ok(xml) = roxmltree::Document::parse_with_options(svg, roxmltree::ParsingOptions { allow_dtd: true, ..Default::default() }) else {
+        return (svg.into(), found);
+    };
     let mut edits = Edits::default();
     let elements = || xml.descendants().filter(|n| n.is_element());
     for a in elements().filter(|n| n.tag_name().name() == "a") {
@@ -612,24 +592,24 @@ fn prepass<'s>(svg: &'s str, xml: &roxmltree::Document, opts: &ImportOptions) ->
     }
     let (display, non_scaling) = (svg.contains("display"), svg.contains(vector_effect::NON_SCALING));
     if display || non_scaling || not {
-        let css = css::Styles::new(xml);
+        let css = css::Styles::new(&xml);
         // First: an undisplayed object shown for usvg is shown after these.
         if not && css.has_not_rules() {
-            not_rules(svg, xml, &css, &mut edits);
+            not_rules(svg, &xml, &css, &mut edits);
         }
         if display {
-            hidden_objects(svg, xml, &css, &mut edits, &mut found.hidden);
+            hidden_objects(svg, &xml, &css, &mut edits, &mut found.hidden);
         }
         if non_scaling {
-            vector_effect::find(svg, xml, &css, &mut edits, &mut found.non_scaling, &mut found.warnings);
+            vector_effect::find(svg, &xml, &css, &mut edits, &mut found.non_scaling, &mut found.warnings);
         }
     }
-    found.files = files::Files::read(svg, xml, opts, &mut edits, &mut found.warnings);
+    found.files = files::Files::read(svg, &xml, opts, &mut edits, &mut found.warnings);
     if !symbols.is_empty() && svg.contains('%') {
-        edits.list.extend(symbol_units::rewrites(xml));
+        edits.list.extend(symbol_units::rewrites(&xml));
     }
     if css_transform {
-        edits.list.extend(css_transform::rewrites(svg, xml));
+        edits.list.extend(css_transform::rewrites(svg, &xml));
     }
     (edits.apply(svg), found)
 }

crates/svg/src/import/css.rs

@@ -17,7 +17,7 @@ pub(super) type XNode<'a, 'i> = roxmltree::Node<'a, 'i>;
 
 /// `name: value` declarations of a block or `style` attribute, with their `!important` flag. The
 /// `font` shorthand becomes its longhands, as usvg reads it for the rest of the drawing (#1557).
-pub(super) fn parse_decls(s: &str) -> Vec<(String, String, bool)> {
+fn parse_decls(s: &str) -> Vec<(String, String, bool)> {
     s.split(';')
         .filter_map(|d| {
             let (k, v) = d.split_once(':')?;
@@ -371,13 +371,8 @@ impl Styles {
         Self { rules, index, cache: RefCell::default() }
     }
 
-    /// Do the document's style sheets have any rules?
-    pub(super) fn has_rules(&self) -> bool {
-        !self.rules.is_empty()
-    }
-
     /// Properties set on `n` by rules and its `style` attribute, after the cascade.
-    pub(super) fn declared(&self, n: XNode) -> Rc<HashMap<String, String>> {
+    fn declared(&self, n: XNode) -> Rc<HashMap<String, String>> {
         if let Some(m) = self.cache.borrow().get(&n.id()) {
             return m.clone();
         }

crates/svg/src/import/depth.rs

@@ -1,264 +0,0 @@
-//! How deep an SVG's elements nest, found in the XML before usvg runs: usvg converts the tree by
-//! recursion, a few stack frames an element, so a file nested deeply enough overflows the stack
-//! (an abort, not an error). Such a file is refused: its nesting can't be merged before usvg has
-//! read it, and usvg is what can't read it.
-//!
-//! What counts is the tree usvg walks, not the XML alone: a `<use>` holds a copy of what it
-//! refers to, and a clip path, mask, pattern, marker or filter is converted where it is used
-//! (`clip-path: url(#a)` on an element of a clip path makes a chain as deep as there are clip
-//! paths). So each element's depth is the deepest of what it holds and what it refers to.
-
-use std::collections::HashMap;
-use std::collections::hash_map::Entry;
-
-use usvg::roxmltree;
-
-use super::css::{Styles, XNode, parse_decls};
-
-/// The deepest an SVG's elements may nest, references followed. Far beyond what drawing apps
-/// write, and deeper than a document's objects may nest ([`vectorcraft_doc::MAX_DEPTH`]: wrappers
-/// that hold one object aren't kept, and what is still deeper is merged into the group around
-/// it). usvg uses about 15 kB of stack for each level: the importer runs on a thread with 16 MB
-/// ([`vectorcraft_doc::depth::with_deep_stack`]), except on the web, where there is the one
-/// 1 MB stack.
-pub const MAX_ELEMENT_DEPTH: usize = if cfg!(target_arch = "wasm32") { 48 } else { 256 };
-
-/// Properties whose value an element's descendants use too: the paint server they name is
-/// converted at each descendant, under everything between.
-const INHERITED: [&str; 6] = ["fill", "stroke", "marker", "marker-start", "marker-mid", "marker-end"];
-
-/// The ids of the `url(#id)` references in a property value.
-fn urls(value: &str) -> impl Iterator<Item = &str> {
-    value.split("url(").skip(1).filter_map(|rest| {
-        let id = rest.trim_start().trim_start_matches(['"', '\'']).strip_prefix('#')?;
-        id.split([')', '"', '\'']).next().map(str::trim).filter(|id| !id.is_empty())
-    })
-}
-
-/// The elements `n` refers to, each with whether `n`'s descendants use it too.
-fn references<'a, 'i>(n: XNode<'a, 'i>, ids: &HashMap<&str, XNode<'a, 'i>>, css: &Styles, out: &mut Vec<(XNode<'a, 'i>, bool)>) {
-    let add = |out: &mut Vec<(XNode<'a, 'i>, bool)>, name: &str, value: &str| {
-        let inherited = INHERITED.contains(&name);
-        out.extend(urls(value).filter_map(|id| ids.get(id)).map(|t| (*t, inherited)));
-    };
-    for a in n.attributes() {
-        match a.name() {
-            "href" => out.extend(a.value().trim().strip_prefix('#').and_then(|id| ids.get(id)).map(|t| (*t, false))),
-            // Read with the style sheets' rules below.
-            "style" if css.has_rules() => {}
-            "style" => parse_decls(a.value()).iter().for_each(|(k, v, _)| add(out, k, v)),
-            name => add(out, name, a.value()),
-        }
-    }
-    if css.has_rules() {
-        css.declared(n).iter().for_each(|(k, v)| add(out, k, v));
-    }
-}
-
-/// Do the elements of the XML text `svg` nest deeper than [`MAX_ELEMENT_DEPTH`]? Read from the
-/// text, before any XML reader: roxmltree (ours and usvg's) reads elements by recursion too. Tags
-/// are counted as the text has them; markup in the values of a document type's entities counts
-/// ten times (how deep entities may refer to one another), on top of the deepest element.
-pub(crate) fn xml_too_deep(svg: &str) -> bool {
-    let b = svg.as_bytes();
-    let find =
-        |from: usize, what: &[u8]| b.get(from..).and_then(|rest| rest.windows(what.len()).position(|w| w == what)).map(|at| from + at + what.len());
-    // The end of the tag starting at `from` (past its `>`), and whether it closes itself.
-    let tag_end = |from: usize| {
-        let mut quote = None;
-        for (i, c) in b.iter().enumerate().skip(from) {
-            match (quote, c) {
-                (None, b'"' | b'\'') => quote = Some(*c),
-                (Some(q), c) if q == *c => quote = None,
-                (None, b'>') => return (i + 1, b.get(i.wrapping_sub(1)) == Some(&b'/')),
-                _ => {}
-            }
-        }
-        (b.len(), false)
-    };
-    // (now, deepest) of the elements, and of the markup inside the document type.
-    let (mut elements, mut entities) = ((0usize, 0usize), (0usize, 0usize));
-    let mut doctype_end = 0;
-    let mut i = 0;
-    while let Some(at) = b.get(i..).and_then(|rest| rest.iter().position(|c| *c == b'<')).map(|at| i + at) {
-        let rest = b.get(at..).unwrap_or_default();
-        let depth = if at < doctype_end { &mut entities } else { &mut elements };
-        i = if rest.starts_with(b"<!--") {
-            find(at, b"-->").unwrap_or(b.len())
-        } else if rest.starts_with(b"<![CDATA[") {
-            find(at, b"]]>").unwrap_or(b.len())
-        } else if rest.starts_with(b"<?") {
-            find(at, b"?>").unwrap_or(b.len())
-        } else if rest.starts_with(b"<!DOCTYPE") {
-            // Up to the `>` that ends it: after its internal subset (`[` … `]`) when it has one.
-            let plain = tag_end(at).0;
-            let subset = b.get(at..plain).is_some_and(|head| head.contains(&b'['));
-            doctype_end = if subset { find(at, b"]>").unwrap_or(b.len()) } else { plain };
-            at + 2
-        } else if rest.starts_with(b"<!") {
-            // A declaration of the document type: the markup in its value is counted as it comes.
-            at + 2
-        } else if rest.starts_with(b"</") {
-            depth.0 = depth.0.saturating_sub(1);
-            tag_end(at).0
-        } else if at < doctype_end {
-            // In an entity's value, itself in quotes: up to the tag's `>`.
-            let end = find(at, b">").unwrap_or(b.len());
-            depth.1 = depth.1.max(depth.0 + 1);
-            depth.0 += usize::from(b.get(end.wrapping_sub(2)) != Some(&b'/'));
-            end
-        } else {
-            let (end, empty) = tag_end(at);
-            depth.1 = depth.1.max(depth.0 + 1);
-            depth.0 += usize::from(!empty);
-            end
-        };
-        if elements.1 + 10 * entities.1 > MAX_ELEMENT_DEPTH {
-            return true;
-        }
-    }
-    false
-}
-
-/// Does anything in `xml` nest deeper than [`MAX_ELEMENT_DEPTH`], references followed? Without
-/// recursion.
-pub(super) fn too_deep(xml: &roxmltree::Document) -> bool {
-    let elements = || xml.descendants().filter(|n| n.is_element());
-    let ids: HashMap<&str, XNode> = elements().filter_map(|n| Some((n.attribute("id")?, n))).collect();
-    let css = Styles::new(xml);
-    // How deep each element's own tree goes, itself included; 0 while it is being worked out: a
-    // reference back to it then is a loop, which usvg leaves out.
-    let mut heights: HashMap<roxmltree::NodeId, usize> = HashMap::new();
-    enum Step<'a, 'i> {
-        Enter(XNode<'a, 'i>),
-        Leave(XNode<'a, 'i>, Vec<(XNode<'a, 'i>, bool)>),
-    }
-    let mut stack = vec![Step::Enter(xml.root_element())];
-    while let Some(step) = stack.pop() {
-        match step {
-            Step::Enter(n) => {
-                match heights.entry(n.id()) {
-                    Entry::Occupied(_) => continue,
-                    Entry::Vacant(v) => v.insert(0),
-                };
-                let mut refs = vec![];
-                references(n, &ids, &css, &mut refs);
-                let targets: Vec<XNode> = refs.iter().map(|(t, _)| *t).collect();
-                stack.push(Step::Leave(n, refs));
-                stack.extend(n.children().filter(|c| c.is_element()).chain(targets).map(Step::Enter));
-            }
-            Step::Leave(n, refs) => {
-                let of = |n: XNode| heights.get(&n.id()).copied().unwrap_or(0);
-                let held = n.children().filter(|c| c.is_element()).map(of).max().unwrap_or(0);
-                let used = |inherited: bool| refs.iter().filter(|(_, i)| *i == inherited).map(|(t, _)| of(*t)).max().unwrap_or(0);
-                let height = 1 + held.max(used(false)) + used(true);
-                if height > MAX_ELEMENT_DEPTH {
-                    return true;
-                }
-                heights.insert(n.id(), height);
-            }
-        }
-    }
-    false
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn deep(svg: &str) -> bool {
-        too_deep(&roxmltree::Document::parse(svg).unwrap())
-    }
-
-    fn svg(body: &str) -> String {
-        format!(r#"<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="10" height="10">{body}</svg>"#)
-    }
-
-    /// `n` groups in one another around a rectangle.
-    fn groups(n: usize) -> String {
-        format!("{}<rect width='1' height='1'/>{}", "<g>".repeat(n), "</g>".repeat(n))
-    }
-
-    #[test]
-    fn elements_nest_up_to_the_cap() {
-        // The root, the groups and the rectangle.
-        let (at, past) = (svg(&groups(MAX_ELEMENT_DEPTH - 2)), svg(&groups(MAX_ELEMENT_DEPTH - 1)));
-        assert!(!deep(&at) && !xml_too_deep(&at));
-        assert!(deep(&past) && xml_too_deep(&past));
-        assert!(xml_too_deep(&svg(&groups(200_000))), "any depth is measured");
-    }
-
-    #[test]
-    fn the_text_is_measured_as_xml_reads_it() {
-        let many = r#"<g a='>' b="<g>"><rect/></g>"#.repeat(500);
-        assert!(!xml_too_deep(&svg(&many)), "side by side, with `>` and tags in attribute values");
-        let hidden = format!("<!-- {0} --><![CDATA[{0}]]><?pi {0}?>", "<g>".repeat(500));
-        assert!(!xml_too_deep(&svg(&hidden)), "comments, character data and instructions hold no elements");
-        assert!(xml_too_deep(&format!("<svg>{}", "<g>".repeat(MAX_ELEMENT_DEPTH))), "never closed");
-        assert!(!xml_too_deep(&format!("{}<svg/>", "</g>".repeat(2 * MAX_ELEMENT_DEPTH))), "ends without beginnings");
-        // Entities: namespaces as drawing apps declare them, and markup that would be read ten deep.
-        let names = r#"<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [ <!ENTITY ns_svg "http://www.w3.org/2000/svg"> ]>"#;
-        assert!(!xml_too_deep(&format!("{names}{}", svg(&groups(30)))));
-        let tenth = MAX_ELEMENT_DEPTH / 10 + 1;
-        let bomb = format!("<!DOCTYPE svg [ <!ENTITY a \"{}&a;{}\"> ]>", "<g>".repeat(tenth), "</g>".repeat(tenth));
-        assert!(xml_too_deep(&format!("{bomb}<svg>&a;</svg>")));
-        assert!(!xml_too_deep(""));
-    }
-
-    #[test]
-    fn a_chain_of_uses_is_as_deep_as_what_it_copies() {
-        let chain = |n: usize| {
-            let defs: String = (0..n).map(|i| format!("<g id='g{i}'><use xlink:href='#g{}'/></g>", i + 1)).collect();
-            svg(&format!("<defs>{defs}<rect id='g{n}' width='1' height='1'/></defs><use href='#g0'/>"))
-        };
-        assert!(!deep(&chain(10)));
-        assert!(deep(&chain(MAX_ELEMENT_DEPTH / 2)), "two elements a link");
-        assert!(deep(&chain(5000)));
-    }
-
-    #[test]
-    fn chains_of_clips_masks_and_patterns_count_by_attribute_style_and_style_sheet() {
-        let by_attribute = |n: usize| -> String {
-            (0..n).map(|i| format!("<clipPath id='c{i}' clip-path='url(#c{})'><rect width='1' height='1'/></clipPath>", i + 1)).collect()
-        };
-        let by_style = |n: usize| -> String {
-            (0..n).map(|i| format!("<mask id='c{i}' style='mask: url( \"#c{}\" )'><rect width='1' height='1'/></mask>", i + 1)).collect()
-        };
-        let by_sheet = |n: usize| -> String {
-            let rules: String = (0..n).map(|i| format!(".p{i} {{ fill: url(#c{}) }}", i + 1)).collect();
-            let patterns: String = (0..n)
-                .map(|i| format!("<pattern id='c{i}' width='1' height='1'><g class='p{i}'><rect width='1' height='1'/></g></pattern>"))
-                .collect();
-            format!("<style>{rules}</style>{patterns}")
-        };
-        for chain in [&by_attribute as &dyn Fn(usize) -> String, &by_style, &by_sheet] {
-            let file =
-                |n| svg(&format!("<defs>{}</defs><rect width='5' height='5' fill='url(#c0)' clip-path='url(#c0)' mask='url(#c0)'/>", chain(n)));
-            assert!(!deep(&file(5)));
-            assert!(deep(&file(MAX_ELEMENT_DEPTH)));
-        }
-    }
-
-    #[test]
-    fn many_paint_servers_used_side_by_side_are_not_a_chain() {
-        // As drawing apps write gradients: a class each, used by objects that aren't inside one another.
-        let rules: String = (0..300).map(|i| format!(".c{i}{{fill:url(#g{i})}}")).collect();
-        let defs: String = (0..300).map(|i| format!("<linearGradient id='g{i}'><stop class='c{i}' offset='0'/></linearGradient>")).collect();
-        let art: String = (0..300).map(|i| format!("<g class='c{i}'><rect class='c{i}' width='1' height='1'/></g>")).collect();
-        assert!(!deep(&svg(&format!("<style>{rules}</style><defs>{defs}</defs>{art}"))));
-    }
-
-    #[test]
-    fn a_loop_of_references_is_not_deep() {
-        assert!(!deep(&svg("<g id='a'><use href='#b'/></g><g id='b'><use href='#a'/></g><clipPath id='c' clip-path='url(#c)'/>")));
-    }
-
-    #[test]
-    fn an_inherited_paint_is_converted_under_everything_between() {
-        // Neither the pattern nor the art is too deep; the pattern under the art's last object is.
-        let half = MAX_ELEMENT_DEPTH / 2;
-        let pattern = format!("<pattern id='p' width='1' height='1'>{}</pattern>", groups(half));
-        assert!(!deep(&svg(&format!("<defs>{pattern}</defs><g fill='url(#p)'>{}</g>", groups(half / 2)))));
-        assert!(deep(&svg(&format!("<defs>{pattern}</defs><g fill='url(#p)'>{}</g>", groups(half)))));
-    }
-}

crates/svg/src/import/files.rs

@@ -203,16 +203,12 @@ impl Files {
         ImageHrefResolver {
             resolve_data: Box::new(move |mime, bytes, opts| {
                 if mime == "image/svg+xml" {
-                    if nested_too_deep(&bytes) {
-                        return None;
-                    }
                     self.note_text(&bytes);
                 }
                 data(mime, bytes, opts)
             }),
             resolve_string: Box::new(move |h, opts| match self.sources.get(h).or_else(|| self.sources.get(h.trim()))? {
                 Source::Raster(kind, bytes) => Some(kind(bytes.clone())),
-                Source::Svg(bytes) if nested_too_deep(bytes) => None,
                 Source::Svg(bytes) => {
                     self.note_text(bytes);
                     usvg::Tree::from_data_nested(bytes, opts).ok().map(ImageKind::SVG)
@@ -222,12 +218,6 @@ impl Files {
     }
 }
 
-/// Is the SVG image `bytes` nested too deep for usvg to read (as the SVG holding it would be)?
-/// It is then left out, as an image usvg can't read.
-fn nested_too_deep(bytes: &[u8]) -> bool {
-    crate::text_of(bytes).is_ok_and(|text| super::xml_too_deep(&text))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

crates/svg/src/lib.rs

@@ -312,9 +312,6 @@ pub struct LinkedImage {
 pub enum SvgError {
     #[error("SVG parse error: {0}")]
     Parse(String),
-    /// Its elements nest (references followed) deeper than the reader goes.
-    #[error("the SVG's elements are nested more than {0} deep")]
-    TooDeep(usize),
 }
 
 /// Export a document as an SVG string (linked images are not returned: see [`export_full`]).
@@ -350,8 +347,7 @@ pub struct Editing {
 
 /// The native document an SVG carries, if any, and whether the SVG was edited since.
 pub fn editing(svg: &str) -> Option<Editing> {
-    // (An SVG nested too deep for the XML reader carries none: it isn't one of ours.)
-    if !svg.contains(EDITING_NS) || import::xml_too_deep(svg) {
+    if !svg.contains(EDITING_NS) {
         return None;
     }
     let opts = usvg::roxmltree::ParsingOptions { allow_dtd: true, ..Default::default() };
@@ -504,18 +500,14 @@ pub fn import_with_report(svg: &str) -> Result<(Document, Vec<String>), SvgError
     import_with(svg, &ImportOptions::default())
 }
 
-pub use import::MAX_ELEMENT_DEPTH;
-
 /// Import an SVG document reading the files it links to as `opts` says, also returning warnings.
 pub fn import_with(svg: &str, opts: &ImportOptions) -> Result<(Document, Vec<String>), SvgError> {
-    // usvg converts the tree by recursion, in large stack frames: the nesting it is given is
-    // capped (`import::depth`), and it gets room for that cap whatever thread asks.
-    vectorcraft_doc::depth::with_deep_stack(|| import::import(svg, opts))
+    import::import(svg, opts)
 }
 
 /// Reads a linked file: its bytes and the link to it (absolute path, size, time and hash), or
 /// `None` when there is no readable file at the (absolute) path.
-pub type ReadFile<'a> = &'a (dyn Fn(&str) -> Option<(Vec<u8>, vectorcraft_doc::LinkInfo)> + Sync);
+pub type ReadFile<'a> = &'a dyn Fn(&str) -> Option<(Vec<u8>, vectorcraft_doc::LinkInfo)>;
 
 /// How [`import_with`] reads the files an SVG's `<image>` elements link to.
 ///

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

@@ -4099,8 +4099,6 @@ imageTrace	Outline	Obrys
 @msg	recovery copy `{file}`: {e}	kopie pro obnovení `{file}`: {e}
 @msg	resolutions must be between 1 and 2400 ppi	rozlišení musí být mezi 1 a 2400 ppi
 @msg	result would exceed the canvas (coordinates out of range)	výsledek by přesáhl plátno (souřadnice mimo rozsah)
-@msg	objects can't be nested more than 32 deep	objekty nelze vnořit hlouběji než do 32 úrovní
-@msg	the SVG's elements are nested more than {0} deep	prvky SVG jsou vnořeny hlouběji než do {0} úrovní
 @msg	scale must be a number from {_1} to {_2}, not {_3}	měřítko musí být číslo od {_1} do {_2}, ne {_3}
 @msg	scale must be a number from {_1} to {_2}, not {s}	měřítko musí být číslo od {_1} do {_2}, ne {s}
 @msg	select (or target) objects whose appearance isn't basic	vyberte (nebo zacilte) objekty, jejichž vzhled není základní

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

@@ -3705,8 +3705,6 @@ theme	Appearance	Erscheinungsbild
 @msg	recovery copy `{file}`: {e}	Wiederherstellungskopie `{file}`: {e}
 @msg	resolutions must be between 1 and 2400 ppi	Auflösungen müssen zwischen 1 und 2400 ppi liegen
 @msg	result would exceed the canvas (coordinates out of range)	das Ergebnis würde die Arbeitsfläche überschreiten (Koordinaten außerhalb des Bereichs)
-@msg	objects can't be nested more than 32 deep	Objekte können nicht tiefer als 32 Ebenen verschachtelt werden
-@msg	the SVG's elements are nested more than {0} deep	die Elemente der SVG-Datei sind tiefer als {0} Ebenen verschachtelt
 @msg	scale must be a number from {_1} to {_2}, not {_3}	scale muss eine Zahl von {_1} bis {_2} sein, nicht {_3}
 @msg	scale must be a number from {_1} to {_2}, not {s}	scale muss eine Zahl von {_1} bis {_2} sein, nicht {s}
 @msg	select (or target) objects whose appearance isn't basic	wählen Sie Objekte aus (oder als Ziel), deren Aussehen nicht einfach ist

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

@@ -3804,8 +3804,6 @@ axis	Both	Ambos
 @msg	recovery copy `{file}`: {e}	copia de recuperación `{file}`: {e}
 @msg	resolutions must be between 1 and 2400 ppi	las resoluciones deben estar entre 1 y 2400 ppi
 @msg	result would exceed the canvas (coordinates out of range)	el resultado excedería el lienzo (coordenadas fuera de rango)
-@msg	objects can't be nested more than 32 deep	los objetos no pueden anidarse a más de 32 niveles
-@msg	the SVG's elements are nested more than {0} deep	los elementos del SVG están anidados a más de {0} niveles
 @msg	scale must be a number from {_1} to {_2}, not {_3}	la escala debe ser un número de {_1} a {_2}, no {_3}
 @msg	scale must be a number from {_1} to {_2}, not {s}	la escala debe ser un número de {_1} a {_2}, no {s}
 @msg	select (or target) objects whose appearance isn't basic	selecciona (o apunta a) objetos cuya apariencia no sea básica

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

@@ -3801,8 +3801,6 @@ axis	Both	Les deux
 @msg	recovery copy `{file}`: {e}	copie de récupération `{file}` : {e}
 @msg	resolutions must be between 1 and 2400 ppi	les résolutions doivent être comprises entre 1 et 2400 ppp
 @msg	result would exceed the canvas (coordinates out of range)	le résultat dépasserait la zone de travail (coordonnées hors limites)
-@msg	objects can't be nested more than 32 deep	les objets ne peuvent pas être imbriqués sur plus de 32 niveaux
-@msg	the SVG's elements are nested more than {0} deep	les éléments du SVG sont imbriqués sur plus de {0} niveaux
 @msg	scale must be a number from {_1} to {_2}, not {_3}	l’échelle doit être un nombre compris entre {_1} et {_2}, pas {_3}
 @msg	scale must be a number from {_1} to {_2}, not {s}	l’échelle doit être un nombre compris entre {_1} et {_2}, pas {s}
 @msg	select (or target) objects whose appearance isn't basic	sélectionnez (ou ciblez) des objets dont l’aspect n’est pas basique

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

@@ -4441,8 +4441,6 @@ imageTrace	Outline	Körvonal
 @msg	resolutions must be between 1 and 2400 ppi	a felbontás 1 és 2400 ppi között lehet
 @msg	Restored {_1} recovered document(s): save them to keep them	Helyreállított dokumentumok: {_1}; mentsd őket, ha meg akarod tartani
 @msg	result would exceed the canvas (coordinates out of range)	az eredmény túllépné a vásznat (a koordináták tartományon kívül esnek)
-@msg	objects can't be nested more than 32 deep	az objektumok legfeljebb 32 szint mélyen ágyazhatók egymásba
-@msg	the SVG's elements are nested more than {0} deep	az SVG elemei több mint {0} szint mélyen vannak egymásba ágyazva
 @msg	Save for Web: the image is empty	Mentés webre: a kép üres
 @msg	Save writes {_1}, not {_2}: use document.export for other formats	a Mentés ezt írja: {_1}, ezt nem: {_2}; más formátumhoz használd a document.export parancsot
 @msg	saved panel layout is invalid; reset the workspace first	a mentett panelelrendezés érvénytelen; előbb állítsd vissza a munkaterületet

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

@@ -3804,8 +3804,6 @@ axis	Both	Entrambi
 @msg	recovery copy `{file}`: {e}	copia di recupero `{file}`: {e}
 @msg	resolutions must be between 1 and 2400 ppi	le risoluzioni devono essere comprese tra 1 e 2400 ppi
 @msg	result would exceed the canvas (coordinates out of range)	il risultato supererebbe l'area di disegno (coordinate fuori intervallo)
-@msg	objects can't be nested more than 32 deep	gli oggetti non possono essere nidificati oltre 32 livelli
-@msg	the SVG's elements are nested more than {0} deep	gli elementi dell'SVG sono nidificati oltre {0} livelli
 @msg	scale must be a number from {_1} to {_2}, not {_3}	la scala deve essere un numero da {_1} a {_2}, non {_3}
 @msg	scale must be a number from {_1} to {_2}, not {s}	la scala deve essere un numero da {_1} a {_2}, non {s}
 @msg	select (or target) objects whose appearance isn't basic	seleziona (o imposta come destinazione) oggetti con un aspetto non di base

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

@@ -3730,8 +3730,6 @@ theme	Appearance	外観
 @msg	no interaction in progress	進行中の操作がありません
 @msg	no such object {0}	オブジェクト {0} が見つかりません
 @msg	result would exceed the canvas (coordinates out of range)	結果がカンバスの範囲を超えます (座標が範囲外です)
-@msg	objects can't be nested more than 32 deep	オブジェクトは 32 階層より深く入れ子にできません
-@msg	the SVG's elements are nested more than {0} deep	SVG の要素が {0} 階層より深く入れ子になっています
 @msg	unknown command `{0}`	`{0}` は不明なコマンドです
 @msg	`{what}` closes nothing	`{what}` に対応する開始部分がありません
 @msg	`{what}` closes something it didn't open	`{what}` が対応しない開始部分を閉じています

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

@@ -3708,8 +3708,6 @@ theme	Appearance	외관
 @msg	no interaction in progress	진행 중인 상호작용이 없습니다
 @msg	no such object {0}	개체 {0}이(가) 없습니다
 @msg	result would exceed the canvas (coordinates out of range)	결과가 캔버스를 벗어납니다(좌표 범위 초과)
-@msg	objects can't be nested more than 32 deep	개체는 32단계보다 깊게 중첩할 수 없습니다
-@msg	the SVG's elements are nested more than {0} deep	SVG 요소가 {0}단계보다 깊게 중첩되어 있습니다
 @msg	unknown command `{0}`	알 수 없는 명령 `{0}`
 @msg	`{what}` closes nothing	`{what}`이(가) 닫는 항목이 없습니다
 @msg	`{what}` closes something it didn't open	`{what}`이(가) 열지 않은 항목을 닫습니다

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

@@ -3965,8 +3965,6 @@ imageTrace	Outline	Kontur
 @msg	recovery copy `{file}`: {e}	kopia odzyskiwania `{file}`: {e}
 @msg	resolutions must be between 1 and 2400 ppi	rozdzielczości muszą mieścić się w zakresie od 1 do 2400 ppi
 @msg	result would exceed the canvas (coordinates out of range)	wynik wykroczyłby poza płótno (współrzędne poza zakresem)
-@msg	objects can't be nested more than 32 deep	obiektów nie można zagnieżdżać głębiej niż na 32 poziomy
-@msg	the SVG's elements are nested more than {0} deep	elementy SVG są zagnieżdżone głębiej niż na {0} poziomów
 @msg	scale must be a number from {_1} to {_2}, not {_3}	skala musi być liczbą od {_1} do {_2}, nie {_3}
 @msg	scale must be a number from {_1} to {_2}, not {s}	skala musi być liczbą od {_1} do {_2}, nie {s}
 @msg	select (or target) objects whose appearance isn't basic	zaznacz (lub wskaż) obiekty, których wygląd nie jest podstawowy

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

@@ -3449,8 +3449,6 @@ axis	Both	Ambos
 @msg	recovery copy `{file}`: {e}	cópia de recuperação `{file}`: {e}
 @msg	resolutions must be between 1 and 2400 ppi	as resoluções devem estar entre 1 e 2400 ppi
 @msg	result would exceed the canvas (coordinates out of range)	o resultado excederia a tela (coordenadas fora do intervalo)
-@msg	objects can't be nested more than 32 deep	os objetos não podem ser aninhados em mais de 32 níveis
-@msg	the SVG's elements are nested more than {0} deep	os elementos do SVG estão aninhados em mais de {0} níveis
 @msg	scale must be a number from {_1} to {_2}, not {_3}	a escala deve ser um número de {_1} a {_2}, não {_3}
 @msg	scale must be a number from {_1} to {_2}, not {s}	a escala deve ser um número de {_1} a {_2}, não {s}
 @msg	select (or target) objects whose appearance isn't basic	selecione (ou direcione) objetos cuja aparência não seja básica

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

@@ -3800,8 +3800,6 @@ axis	Both	Оба
 @msg	recovery copy `{file}`: {e}	копия восстановления `{file}`: {e}
 @msg	resolutions must be between 1 and 2400 ppi	разрешения должны быть от 1 до 2400 ppi
 @msg	result would exceed the canvas (coordinates out of range)	результат превысил бы холст (координаты вне диапазона)
-@msg	objects can't be nested more than 32 deep	объекты нельзя вкладывать глубже 32 уровней
-@msg	the SVG's elements are nested more than {0} deep	элементы SVG вложены глубже {0} уровней
 @msg	scale must be a number from {_1} to {_2}, not {_3}	масштаб должен быть числом от {_1} до {_2}, а не {_3}
 @msg	scale must be a number from {_1} to {_2}, not {s}	масштаб должен быть числом от {_1} до {_2}, а не {s}
 @msg	select (or target) objects whose appearance isn't basic	выделите (или укажите как объект) объекты, оформление которых не является основным

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

@@ -3788,8 +3788,6 @@ axis	Both	Обидві
 @msg	recovery copy `{file}`: {e}	копія відновлення `{file}`: {e}
 @msg	resolutions must be between 1 and 2400 ppi	дозволи мають бути від 1 до 2400 ppi
 @msg	result would exceed the canvas (coordinates out of range)	результат перевищив би полотно (координати поза діапазоном)
-@msg	objects can't be nested more than 32 deep	об’єкти не можна вкладати глибше ніж на 32 рівні
-@msg	the SVG's elements are nested more than {0} deep	елементи SVG вкладено глибше ніж на {0} рівнів
 @msg	scale must be a number from {_1} to {_2}, not {_3}	масштаб має бути числом від {_1} до {_2}, а не {_3}
 @msg	scale must be a number from {_1} to {_2}, not {s}	масштаб має бути числом від {_1} до {_2}, а не {s}
 @msg	select (or target) objects whose appearance isn't basic	виділіть (або вкажіть як об’єкт) об’єкти, оформлення яких не є основним

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

@@ -4071,8 +4071,6 @@ theme	Appearance	Giao diện
 @msg	resolutions must be between 1 and 2400 ppi	độ phân giải phải nằm trong khoảng 1 đến 2400 ppi
 @msg	Restored {_1} recovered document(s): save them to keep them	Đã phục hồi {_1} tài liệu: hãy lưu để giữ lại
 @msg	result would exceed the canvas (coordinates out of range)	kết quả sẽ vượt quá vùng vẽ (tọa độ ngoài phạm vi)
-@msg	objects can't be nested more than 32 deep	không thể lồng các đối tượng sâu quá 32 cấp
-@msg	the SVG's elements are nested more than {0} deep	các phần tử SVG lồng nhau sâu quá {0} cấp
 @msg	Save for Web: the image is empty	Lưu cho Web: ảnh trống
 @msg	Save writes {_1}, not {_2}: use document.export for other formats	Lưu ghi {_1}, không phải {_2}: dùng document.export cho các định dạng khác
 @msg	saved panel layout is invalid; reset the workspace first	bố cục bảng đã lưu không hợp lệ; hãy đặt lại không gian làm việc trước

docs/roadmap.md

@@ -1,6 +1,6 @@
 # Roadmap: milestones and what's next
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (verified PngSuite downloads, #1729; synthetic control-input budgets, #1709; 2026-10-14 merges: anchor Align and Distribute, #1636; Direct Selection and Delete fixes, #1674, #1666, #1743; Expand on repeats, #1756; file and input hardening, #1776–#1783, #1786, #1807; MCP limits and envelope, #1727, #1728; Image Trace #1647, #1657; estimates unchanged; later 2026-10-13 merges: SVG import, #1565, #1596, #1568, #1601; Warp Arc, #1578; Pathfinder strokes, #1570; saves, #1620 in part; OpenType features, #1607; intersect Smart Guides, #1602 in part; estimates unchanged; TIFF is available in Export for Screens and Asset Export with shared format settings; scores and hours unchanged; G1/M11: Artboard deletion and history selection normalization; history regressions and full workspace CI pass; scores and hours unchanged; Character styles retain explicit Auto leading, propagate resets and preserve local leading overrides; scores and hours unchanged; Width Point Edit: Shift-double-click enables adjoining adjustment; plain double-click keeps it off; scores and hours unchanged; per-corner radius fields with a link toggle, split from #1594; control transport deadlines, #1726; M12 row: Image Trace's presets and options as they are now; Polish interface, #1498; compact native saves, #1492; PDF and EPS paste as vector art, #1499; import fixes, #1528, #1530, #1531, #1544, #1551, #1553; guide objects, #1534; Join after Average, #1533; Keyboard Shortcuts, #1539; estimates unchanged; Direct Selection anchor precedence, #1508; dialog slider rails, #1483; template layers in Outline view, #1486; type that does not fit its frame is reported, #1471; 3D on outlined type, #1481; print-size images, #1517; French catalog, #1511; estimates unchanged; Split Into Grid options, #1462; Transform Objects and Reflect's angle, #1448 and #1460; Pathfinder on a group, #1450; unknown parameter keys refused, #1442; grayscale TIFFs with alpha, #1466 in part; estimates unchanged; M9: Extrude & Bevel, Inflate and Rotate; `.ai` compound path paint, #1410, overprint on import, #1388, text-only PDF parts, #1387; Transform dialogs preview, #1412, and transforms of direct-selected anchors, #1408; strokes wider than their shape, #1396; estimates unchanged; `.ai` editing-data follow-ups, #1390, #1391, #1392; dialog keyboard focus, #1367 and #1395; symbol instance redraw cache, #1386; font rescan, #1376; estimates unchanged; gradient shapes import as paths, #1304; white constant alpha masks, #1286 in part; Live Corners widget click, #1239; custom ruler origin, #1212; M11: Artboard object clicks create a fitted artboard (#1227); estimate unchanged; Pathfinder single-result source names and SVG IDs retained, #1293; DXF control-point SPLINE closure read, #1299 follow-up; desktop print transport adopts craft-print, Windows 7 fallback retained, scores unchanged; Czech render-site localization follow-up; scores and estimates unchanged; Document Setup: Edit Artboards closes the modal after applying valid settings; pointer-click regressions; scores and hours unchanged; Artboards: Escape exits editing; an active drag cancels first; shortcut-routing regression; scores and hours unchanged; M6: Simplify preview/counts and valid topology selection (#1272); estimates unchanged; G2: Film Grain added; Photoshop effects 29/57; 28 filters remain; M14: RPM runtime metadata (#1275); estimates unchanged; M5: squared-distance texture redraws (#1257); clean-machine/platform drag measurements still pending; estimates unchanged; M2: Curvature point display improved (#1236, in part); estimates unchanged; M7: full-name font matching (#1258); Windows font-service QA pending; estimates unchanged; M1: no-op anchor Align keeps Undo, Redo and saved state (#1180 follow-up); estimates unchanged; M14: dedicated Eyedropper cursor (#1269); estimates unchanged; M3: Eyedropper reads visible locked and outside-isolation sources (#1251); estimates unchanged; M2: Direct Selection segment picks and Delete (#1278); estimates unchanged; M3: adding paint to an unpainted zero-width stroke restores 1 pt (#1253); estimates unchanged; M12: graph designs, graph data, Graph Type and label options; M14: native macOS save Format menu, #866; M6: compound appearance and member fill-rule fixes, #1197; estimates unchanged; M9: PDF raster-effect cap warnings; G11: #893 fixed, #937 open; M7: accurate character controls after scaling, #1034; estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (M12 row: Image Trace's enhanced presets; verified PngSuite downloads, #1729; synthetic control-input budgets, #1709; 2026-10-14 merges: anchor Align and Distribute, #1636; Direct Selection and Delete fixes, #1674, #1666, #1743; Expand on repeats, #1756; file and input hardening, #1776–#1783, #1786, #1807; MCP limits and envelope, #1727, #1728; Image Trace #1647, #1657; estimates unchanged; later 2026-10-13 merges: SVG import, #1565, #1596, #1568, #1601; Warp Arc, #1578; Pathfinder strokes, #1570; saves, #1620 in part; OpenType features, #1607; intersect Smart Guides, #1602 in part; estimates unchanged; TIFF is available in Export for Screens and Asset Export with shared format settings; scores and hours unchanged; G1/M11: Artboard deletion and history selection normalization; history regressions and full workspace CI pass; scores and hours unchanged; Character styles retain explicit Auto leading, propagate resets and preserve local leading overrides; scores and hours unchanged; Width Point Edit: Shift-double-click enables adjoining adjustment; plain double-click keeps it off; scores and hours unchanged; per-corner radius fields with a link toggle, split from #1594; control transport deadlines, #1726; M12 row: Image Trace's presets and options as they are now; Polish interface, #1498; compact native saves, #1492; PDF and EPS paste as vector art, #1499; import fixes, #1528, #1530, #1531, #1544, #1551, #1553; guide objects, #1534; Join after Average, #1533; Keyboard Shortcuts, #1539; estimates unchanged; Direct Selection anchor precedence, #1508; dialog slider rails, #1483; template layers in Outline view, #1486; type that does not fit its frame is reported, #1471; 3D on outlined type, #1481; print-size images, #1517; French catalog, #1511; estimates unchanged; Split Into Grid options, #1462; Transform Objects and Reflect's angle, #1448 and #1460; Pathfinder on a group, #1450; unknown parameter keys refused, #1442; grayscale TIFFs with alpha, #1466 in part; estimates unchanged; M9: Extrude & Bevel, Inflate and Rotate; `.ai` compound path paint, #1410, overprint on import, #1388, text-only PDF parts, #1387; Transform dialogs preview, #1412, and transforms of direct-selected anchors, #1408; strokes wider than their shape, #1396; estimates unchanged; `.ai` editing-data follow-ups, #1390, #1391, #1392; dialog keyboard focus, #1367 and #1395; symbol instance redraw cache, #1386; font rescan, #1376; estimates unchanged; gradient shapes import as paths, #1304; white constant alpha masks, #1286 in part; Live Corners widget click, #1239; custom ruler origin, #1212; M11: Artboard object clicks create a fitted artboard (#1227); estimate unchanged; Pathfinder single-result source names and SVG IDs retained, #1293; DXF control-point SPLINE closure read, #1299 follow-up; desktop print transport adopts craft-print, Windows 7 fallback retained, scores unchanged; Czech render-site localization follow-up; scores and estimates unchanged; Document Setup: Edit Artboards closes the modal after applying valid settings; pointer-click regressions; scores and hours unchanged; Artboards: Escape exits editing; an active drag cancels first; shortcut-routing regression; scores and hours unchanged; M6: Simplify preview/counts and valid topology selection (#1272); estimates unchanged; G2: Film Grain added; Photoshop effects 29/57; 28 filters remain; M14: RPM runtime metadata (#1275); estimates unchanged; M5: squared-distance texture redraws (#1257); clean-machine/platform drag measurements still pending; estimates unchanged; M2: Curvature point display improved (#1236, in part); estimates unchanged; M7: full-name font matching (#1258); Windows font-service QA pending; estimates unchanged; M1: no-op anchor Align keeps Undo, Redo and saved state (#1180 follow-up); estimates unchanged; M14: dedicated Eyedropper cursor (#1269); estimates unchanged; M3: Eyedropper reads visible locked and outside-isolation sources (#1251); estimates unchanged; M2: Direct Selection segment picks and Delete (#1278); estimates unchanged; M3: adding paint to an unpainted zero-width stroke restores 1 pt (#1253); estimates unchanged; M12: graph designs, graph data, Graph Type and label options; M14: native macOS save Format menu, #866; M6: compound appearance and member fill-rule fixes, #1197; estimates unchanged; M9: PDF raster-effect cap warnings; G11: #893 fixed, #937 open; M7: accurate character controls after scaling, #1034; estimates unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
 
 Forward-looking plan. Where VectorCraft stands is in [`ROADMAP.md`](../ROADMAP.md) and
 [target-app-parity.md](target-app-parity.md); the ranked work list is [gaps.md](gaps.md). Hours are Opus 5.5
@@ -60,7 +60,7 @@ Checked 2026-10-10 from the code, tests and open issues; no workflow fails, so V
 | M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder, Color Adjustments and Document Raster Effects Settings; PDF export warns when the pixel cap lowers raster-effect resolution; Artistic › Film Grain done (29/57 Photoshop filters); initial Revolve, Extrude & Bevel, Inflate and Rotate; SVG Filters, remaining raster effects and 3D materials, lights and shadows pending | 81–130 |
 | M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG `<pattern>`/PDF export) and live Repeat (radial/grid/mirror) done; brushes/symbols in progress | 23–37 |
 | M11 | Artboards & views (selected-set deletion shared by Artboards menu, trash and Properties, retaining artboard 1 when all are selected; Artboard deletion keys keep the first of an all-selected set and protect artwork; history prunes invalid indices while preserving valid multiselection (history tests and full workspace CI pass); click-to-fit objects with the Artboard tool (#1227), artboard escape routing and document setup modal handoff done; artboard panel/tool with Move Artwork for X/Y fields and Artboard Options, Trim View, middle-button pan, print tiling and the status bar's artboard navigator with synchronized Artboard tool selection done; multiple windows, presentation polish) | 🟡 | 15–25 |
-| M12 | Advanced color & art (CMYK/ICC, separations, Gradient Mesh, Live Paint, Image Trace, Graphs) | 🟡 Gradient Mesh, Live Paint, Image Trace (15 presets; Ignore Color, Shapes, Auto Grouping and Gradients options; measured in `image-trace-quality.md`; the Flat Logo mode places edges to a fraction of a pixel, restores sharp corners, snaps lines and circles, and refuses gradients), Recolor Artwork, colour management (ICC, soft proofing, separations preview), Graphs (all 9 tools, Graph Data/Type, group-selected series colours persist through regenerate/save/open) done; Graph Design and Marker designs, Transpose and Switch x/y, `|` label line breaks, the pie options, drop shadows, the legend across the top, overlapping widths, First Row/Column in Front, filled lines, kept label formatting and the Graph Data worksheet done; graph Column designs pending | 6–10 |
+| M12 | Advanced color & art (CMYK/ICC, separations, Gradient Mesh, Live Paint, Image Trace, Graphs) | 🟡 Gradient Mesh, Live Paint, Image Trace (15 presets, the 14 documented ones each with an enhanced version; Ignore Color, Shapes, Auto Grouping and Gradients options; measured in `image-trace-quality.md`; the Flat Logo mode places edges to a fraction of a pixel, restores sharp corners, snaps lines and circles, and refuses gradients), Recolor Artwork, colour management (ICC, soft proofing, separations preview), Graphs (all 9 tools, Graph Data/Type, group-selected series colours persist through regenerate/save/open) done; Graph Design and Marker designs, Transpose and Switch x/y, `|` label line breaks, the pie options, drop shadows, the legend across the top, overlapping widths, First Row/Column in Front, filled lines, kept label formatting and the Graph Data worksheet done; graph Column designs pending | 6–10 |
 | M13 | Automation (Actions ✅ record/playback, persisted; variables, scripting, batch) | 🟡 | 18–27 |
 | M14 | 1.0 polish (preferences, shortcut editor, workspaces, accessibility, packaging for all OSes) | 🟡 Numeric-field pointer selection and focus regression-tested (#1326, in part; short movements still select all); RPM runtime capabilities and glibc floor checked (#1275; real-distro install/start-up pending), Eyedropper cursor with precise-setting checks (#1269), Preferences, shortcut editor (chords with Shift and a punctuation key fire as typed), workspaces, a custom title bar on Windows/Linux with a Home button, content-sized dialogs, menus that scroll when longer than the window and macOS native menu dismissal done (M14.8), and native macOS save sheets with a Format menu (#866); an experimental, unsupported Windows 7 x64 portable OpenGL build (not verified by maintainers); accessibility and broader Windows/Linux packaging/QA pending | 18–28 |
 | — | Interaction fidelity pass (every tool's modifiers, Properties panel per context, isolation, nuance; width-point creation and adjoining adjustment regression-tested; dialog layout reviewed) | ⬜ (new ruler-guide Alt orientation implemented; broader pass remains) | 60–90 |
@@ -80,6 +80,7 @@ After placed documents (File › Place of a `.vectorcraft` file, linked), M4.14
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-14 | minor | M12 row: each documented Image Trace preset has an enhanced version (#1847) |
 | 2026-10-13 | minor | Pinned PngSuite HTTPS files verified by SHA-256 before publication; bounded downloads replace archive extraction (#1729). Scores and hours unchanged. |
 | 2026-10-13 | minor | Bounded synthetic control input (#1709): counts and queued events validated before mutation; control-channel bursts yield between frames. Scores and hours unchanged. |
 | 2026-10-14 | minor | Align and Distribute act on the anchor points selected with Direct Selection: the points of one path align to each other, not to the artboard, and Distribute spaces them (#1641, fixes #1636; aligning to a key anchor is still missing); Delete removes every selected anchor of a closed path (it used to remove the wrong ones), removes objects selected whole along with the selected anchors of others, and keeps the remainder selected so a second Delete removes it (#1674); In isolation mode Direct Selection and Group Selection pick only inside the isolated object (#1666); Escape cancels a Direct Selection drag (#1803, #1743); Escape while typing ends the edit, keeps the type selected and switches to the Selection tool (#1802, #1686, #1656); A filled Pencil path keeps a stroke of None (#1804, part of #1679); With the Pen, a press that moves under 3 screen pixels is a click (a corner without handles), and a Precise Cursors command toggles the existing preference and can take a shortcut (#1663); The [ and ] keys reach the Blob Brush, the Eraser and the Symbolism tools in the app (#1734, part of #1661); In the Pathfinder panel a group selected alone counts its nested shapes, so an expanded stroked object keeps the Shape Modes enabled (#1642, #1635); Object › Expand turns radial, grid and mirror repeats into groups of their instances (#1765, #1756); Select › Same matches type on its characters' fill and stroke (#1746, #1737); Fields commit what was typed when you click away or move to another field, as Enter does; Escape still discards it (#1787); Up and Down move through the command search results and Enter runs the highlighted one (#1798, #1757); Slider rails show on Medium Dark (#1808, #1662); On Windows the custom title bar's window stays truly borderless, so the pointer lines up with what is drawn on systems where the hidden caption offset it (#1791, #1758; awaiting the reporter's confirmation); Tool cursors are painted into the window on Wayland (#1652; not run on Linux, #1645 stays open until confirmed); Roughen with Smooth keeps turn-backs smooth instead of making cusps that draw as spikes (#1646, #1643); Scribble draws one zig-zag per region, with no lines across holes and notches; convex shapes are unchanged (#1651, #1648); EPS import: a stitched shading keeps its hard colour changes (#1654, #1653); WMF/EMF import refuses an oversized embedded PNG or JPEG from its header, before any pixels are decoded (#1776); PDF open no longer takes exponential time on a crafted name tree with shared nodes when it looks for the editing data (#1781); The size limits on a native file's embedded data also apply to files read from memory, not only streamed ones (#1783); Saving over a private file on Unix no longer leaves a readable temporary copy beside it while the file is written (#1778); An Export for Screens suffix can no longer place files outside the export folder (#1777); Package refuses a folder where it would overwrite the open document or one of its linked files (#1786); ruzstd 0.9.1 fixes a decompression bomb (RUSTSEC-2026-0344) reachable from EPS/`.ai` and Affinity import (#1807); File Info dates are stamped only after a save succeeds, so a failed save no longer changes them (#1774); Linked files that change during a drag are updated after the drag instead of being missed (#1773); Scatter graph data near the largest number is refused with a message instead of hanging the app (#1780); One very long Liquify stroke segment can no longer create an unbounded number of dabs (#1779); A drag whose last preview failed is no longer recorded as a committed command in the journal that actions and scripts read (#1775); Tests: text import fuzzing no longer searches installed fonts (#1785); Tests: render tests that add fonts no longer race the frame cache tests (#1795); `text.create`, `text.createInPath` and the MCP `add_text` tool take `justify`, so point type can be centred on or end at its point (#1752, #1748); MCP limits: 16 MiB lines, 64-message batches, 256-step `command_batch` with 8 MiB of kept results and 256 MiB control replies (#1764, fixes #1727); MCP requires the JSON-RPC 2.0 envelope and matches control replies by id, and an app refusal without an id reports the app's reason (#1768, fixes #1728); The MCP server reconnects to the app before a call when the connection was closed or holds stray bytes, after an app restart or an idle expiry (#1739); Image Trace, measured in `image-trace-quality.md`: 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); milestone rows and estimates unchanged |

docs/target-app-parity.md

@@ -1,6 +1,6 @@
 # Parity with Adobe Illustrator
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (verified PngSuite downloads, #1729; synthetic control-input budgets, #1709; 2026-10-14 merges: anchor Align and Distribute, #1636; Direct Selection and Delete fixes, #1674, #1666, #1743; Escape while typing, #1686; Pen clicks, #1663; Expand on repeats, #1756; Roughen and Scribble, #1643, #1648; file and input hardening, #1776–#1783, #1786, #1807; MCP limits and envelope, #1727, #1728; Image Trace levelling and Flat Logo on scans, #1647, #1657; scores unchanged; later 2026-10-13 merges: SVG import, #1565, #1596, #1568, #1598, #1601; type on a path from PDF and `.ai`, #1585, #1586; ICC tag alignment, #1584; saves, #1620 in part; Warp Arc, #1578; Zig Zag, #1558; Pathfinder strokes, #1570; OpenType features, #1607; intersect Smart Guides, #1602 in part; a guide's position in the Transform panel, #1597 in part, a convenience with no parity claim; scores unchanged; TIFF is available in Export for Screens and Asset Export with shared format settings; scores and hours unchanged; G1/M11: Artboard deletion and history selection normalization; history regressions and full workspace CI pass; scores and hours unchanged; Character styles retain explicit Auto leading, propagate resets and preserve local leading overrides; scores and hours unchanged; Width Point Edit: Shift-double-click enables adjoining adjustment; plain double-click keeps it off; scores and hours unchanged; Units › Identify Objects By (`identifyObjectsBy`) acts on Layers, Variables and Layer Options, #394, scores unchanged; Appearance of Black › Printing / Exporting (`blackOutput`) acts on RGB raster export and Print as Bitmap, #394, scores unchanged; per-corner radius fields with a link toggle, split from #1594; control transport deadlines, #1726; Color panel: the mode picked last comes back after a restart, #1675; Image Trace: shared edges, memory, thin lines, strokes, corners, and the Shapes, Auto Grouping and Gradients options, measured in `image-trace-quality.md`, score unchanged; 2026-10-13 merges: Polish interface, #1498; compact native saves, #1492; PDF and EPS paste as vector art, #1499; import fixes for `.ai`, PDF, EPS and SVG, #1528, #1530, #1531, #1544, #1551, #1553; guide objects, #1534; Join after Average, #1533; Keyboard Shortcuts lists commands outside the menus, #1539; correction: Average and Join with a corner or smooth choice is missing; scores unchanged; late 2026-10-12 merges: type that does not fit its frame is reported, #1471; Tabs panel drags, #1458; template layers in Outline view, #1486; dialog slider rails, #1483; Direct Selection anchor precedence, #1508; print-size images, #1517; 3D on outlined type, #1481; French catalog, #1511; scores unchanged; Split Into Grid options, #1462; Transform Objects and Reflect across an angle, #1448 and #1460; Pathfinder panel on a group, #1450; unknown parameter keys refused, #1442; grayscale TIFFs with alpha, #1466 in part; Localization: Vietnamese catalog added, 63% → 71%, hours 60–100 → 55–90, full readiness unchanged at ~62%; scores and hours unchanged; Image Trace places edges to a fraction of a pixel in every mode, measured in `image-trace-quality.md`, score unchanged; 3D and Materials: Extrude & Bevel, Inflate and Rotate added, 3D ~8% → ~25% (estimated), menu stubs 25 → 22; Affinity text frames too short for their first line show it, #1423; Transform dialogs preview, #1412, and the transform tools and commands act on direct-selected anchors, #1408; `.ai` compound path paint, #1410; strokes wider than their shape, #1396; corner drags hide the bounding box, #1229; scores and hours unchanged; PDF and `.ai` import keep overprint, #1388, scores unchanged; `.ai` editing-data follow-ups: gradient stops, type of objects with an appearance, short area-type frames (#1390, #1391, #1392); dialog keyboard focus on every open (#1382, #1395); art flush with an artboard (#1375); font rescan (#1376); symbol instance redraw cache (#1386); scores and hours unchanged; grid tool options, #1377 in part, scores unchanged; `.ai` placed (linked) files read from the editing data, #1264, scores unchanged; gradient shapes import as paths, #1304; white constant alpha masks, #1286 in part; Live Corners widget click selects its corner, #1239; scores and hours unchanged; custom ruler origin, #1212; Artboard click-to-fit verified for objects, groups, visible bounds, undo and cancellation (#1227); scores and hours unchanged; Pathfinder single-result source names and SVG IDs retained, #1293; Localization: Korean catalog added, 54% → 63%, full readiness unchanged at ~62%; desktop print transport adopts craft-print, Windows 7 fallback retained, scores unchanged; Image Trace: an image over 64 megapixels traces scaled down instead of being refused, scores unchanged; Czech render-site localization follow-up; scores and estimates unchanged; Document Setup: Edit Artboards closes the modal after applying valid settings; poiLine truncated
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (Image Trace: Shapes rework, stroke caps, enhanced presets, gradients over noise, measured in `image-trace-quality.md`, score unchanged; verified PngSuite downloads, #1729; synthetic control-input budgets, #1709; 2026-10-14 merges: anchor Align and Distribute, #1636; Direct Selection and Delete fixes, #1674, #1666, #1743; Escape while typing, #1686; Pen clicks, #1663; Expand on repeats, #1756; Roughen and Scribble, #1643, #1648; file and input hardening, #1776–#1783, #1786, #1807; MCP limits and envelope, #1727, #1728; Image Trace levelling and Flat Logo on scans, #1647, #1657; scores unchanged; later 2026-10-13 merges: SVG import, #1565, #1596, #1568, #1598, #1601; type on a path from PDF and `.ai`, #1585, #1586; ICC tag alignment, #1584; saves, #1620 in part; Warp Arc, #1578; Zig Zag, #1558; Pathfinder strokes, #1570; OpenType features, #1607; intersect Smart Guides, #1602 in part; a guide's position in the Transform panel, #1597 in part, a convenience with no parity claim; scores unchanged; TIFF is available in Export for Screens and Asset Export with shared format settings; scores and hours unchanged; G1/M11: Artboard deletion and history selection normalization; history regressions and full workspace CI pass; scores and hours unchanged; Character styles retain explicit Auto leading, propagate resets and preserve local leading overrides; scores and hours unchanged; Width Point Edit: Shift-double-click enables adjoining adjustment; plain double-click keeps it off; scores and hours unchanged; Units › Identify Objects By (`identifyObjectsBy`) acts on Layers, Variables and Layer Options, #394, scores unchanged; Appearance of Black › Printing / Exporting (`blackOutput`) acts on RGB raster export and Print as Bitmap, #394, scores unchanged; per-corner radius fields with a link toggle, split from #1594; control transport deadlines, #1726; Color panel: the mode picked last comes back after a restart, #1675; Image Trace: shared edges, memory, thin lines, strokes, corners, and the Shapes, Auto Grouping and Gradients options, measured in `image-trace-quality.md`, score unchanged; 2026-10-13 merges: Polish interface, #1498; compact native saves, #1492; PDF and EPS paste as vector art, #1499; import fixes for `.ai`, PDF, EPS and SVG, #1528, #1530, #1531, #1544, #1551, #1553; guide objects, #1534; Join after Average, #1533; Keyboard Shortcuts lists commands outside the menus, #1539; correction: Average and Join with a corner or smooth choice is missing; scores unchanged; late 2026-10-12 merges: type that does not fit its frame is reported, #1471; Tabs panel drags, #1458; template layers in Outline view, #1486; dialog slider rails, #1483; Direct Selection anchor precedence, #1508; print-size images, #1517; 3D on outlined type, #1481; French catalog, #1511; scores unchanged; Split Into Grid options, #1462; Transform Objects and Reflect across an angle, #1448 and #1460; Pathfinder panel on a group, #1450; unknown parameter keys refused, #1442; grayscale TIFFs with alpha, #1466 in part; Localization: Vietnamese catalog added, 63% → 71%, hours 60–100 → 55–90, full readiness unchanged at ~62%; scores and hours unchanged; Image Trace places edges to a fraction of a pixel in every mode, measured in `image-trace-quality.md`, score unchanged; 3D and Materials: Extrude & Bevel, Inflate and Rotate added, 3D ~8% → ~25% (estimated), menu stubs 25 → 22; Affinity text frames too short for their first line show it, #1423; Transform dialogs preview, #1412, and the transform tools and commands act on direct-selected anchors, #1408; `.ai` compound path paint, #1410; strokes wider than their shape, #1396; corner drags hide the bounding box, #1229; scores and hours unchanged; PDF and `.ai` import keep overprint, #1388, scores unchanged; `.ai` editing-data follow-ups: gradient stops, type of objects with an appearance, short area-type frames (#1390, #1391, #1392); dialog keyboard focus on every open (#1382, #1395); art flush with an artboard (#1375); font rescan (#1376); symbol instance redraw cache (#1386); scores and hours unchanged; grid tool options, #1377 in part, scores unchanged; `.ai` placed (linked) files read from the editing data, #1264, scores unchanged; gradient shapes import as paths, #1304; white constant alpha masks, #1286 in part; Live Corners widget click selects its corner, #1239; scores and hours unchanged; custom ruler origin, #1212; Artboard click-to-fit verified for objects, groups, visible bounds, undo and cancellation (#1227); scores and hours unchanged; Pathfinder single-result source names and SVG IDs retained, #1293; Localization: Korean catalog added, 54% → 63%, full readiness unchanged at ~62%; desktop print transport adopts craft-print, Windows 7 fallback retained, scores unchanged; Image Trace: an image over 64 megapixels traces scaled down instead of being refused, scores unchanged; Czech render-site loLine truncated
 
 The authoritative parity assessment. [`ROADMAP.md`](../ROADMAP.md) summarizes it; [`gaps.md`](gaps.md) is
 the work list made from it. Deep areas have their own checklists: [UI and interaction](ui-parity.md),
@@ -485,7 +485,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
 - **Interface languages, vertical type:** Preferences ▸ User Interface (or VectorCraft ▸ Language on macOS) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese, German (every `de-*` locale), Spanish (neutral international Spanish, for every `es-*` locale), French (every `fr-*` locale), Italian (every `it-*` locale) Russian (every `ru-*` locale) and Ukrainian (every `uk-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); German, Spanish, French, Italian, Japanese, Russian and Ukrainian also translate status-bar and error messages as they are shown (`@msg` templates, every message literal tested; the messages themselves stay English for agents); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech, German, Spanish, French, Italian, Russian and Ukrainian ones from the bundled UI fonts. The web app follows the browser's languages (or `?lang=`). The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku applies to horizontal and vertical Japanese (Paragraph panel › Kinsoku Set, `text.setFormat {kinsoku}`: Hard, the default, keeps closing marks, iteration marks, the prolonged sound mark and small kana off the line start and opening brackets off its end; Soft lets 々, ー and small kana start a line as JLREQ's level 3 rules do; None turns it off), and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width and an opening bracket starting a line flush with its start (a paragraph's first line at its first-line indent, JIS X 4051's principle in JLREQ 3.1.5), and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline (new type in a Japanese interface starts top to top, with em box centre character alignment, #432); Paragraph panel menu › Burasagari None / Regular / Force (`text.setFormat {burasagari: "none"|"standard"|"forced"}`) hangs an East Asian comma or full stop (、。，．､｡) ending an area type line outside it, Regular (new type's default) when it doesn't fit and Force always (the rest of the line then fills the measure; closing brackets and Latin punctuation don't hang); Character panel menu › Character Alignment (with the East Asian options; `text.setFormat` or `text.setRangeStyle {charAlign}`) lines characters smaller than the largest on their line up on the Roman baseline, the em box top/right, centre or bottom/left, or the ICF (ideographic character face) top/right or bottom/left, from the font's BASE table or, without one, the average ink box of some ideographs and kana; Proportional Metrics (the same menu; `{proportionalMetrics}`) sets full-width glyphs on the font's proportional widths (OpenType `palt`) in horizontal type and upright glyphs on its proportional heights (`vpal`, shaped top to bottom; fonts without vertical metrics keep their cells) in vertical type, and Line-end Punctuation Half Width takes nothing more off the punctuation they re-spaced; Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines. The interface is available in Polish (`pl`): menus, panels, dialogs and messages, with one/few/many plurals; AI-drafted, native review pending (#1498).
 - **Transparency:** opacity masks (clip/invert/disable/link), exported as SVG `<mask>` and PDF soft masks. The constant alpha soft mask that PDF and `.ai` export draw a CMYK page with transparency through is white, so applications that read every soft mask by its luminosity show the page too (#1359, part of #1286).
   Disable, Enable, Unlink and Link Opacity Mask and Opacity Mask Options (`transparency.setOpacityMask`) record no undo step when every mask they act on already has the flags they set.
-- **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). 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, blurred, noisy and scanned gradients are found in part or in pieces, and radial gradients stay bands.
+- **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 Line truncated
 - **Image Trace Flat Logo mode:** a fourth mode beside Black and White, Grayscale and Color, for flat-colour logos. Each pixel is read as a blend of the logo's colours (found automatically or named), the blend is interpolated smoothly and every outline is placed where two colours are equally present, so edges are accurate to a fraction of a pixel. Outlines are then cleaned: corners the blur rounded are put back, near-straight runs and near-circular arcs become exact lines and arcs, the rest is fitted with as few Béziers as the tolerance allows, touching colours overlap by a hair so no gap opens, and an outline that strays from the raw contour is fitted plainly instead. Gradients and photos are refused with advice to use Color. *Measured* (a local experiment, not run in CI): a flat-colour logo's vector original was rendered down to a soft 199 × 100 px transparent PNG, traced, and the result compared with the original at 1600 px wide. The built-in colour presets (6 Colors, 16 Colors, High Fidelity Photo, Low Fidelity Photo) had a mean edge error of 2.5 to 3.4 px and region overlap of 0.88 to 0.91; Flat Logo had 0.78 px and 0.966 (0.48 px and 0.975 from a crisp source), in about 0.1 s. Limits: flat-colour art only; needle-thin sharp tips are shortened by about 1.7 source pixels because the blur erases them; it works at no more than 1024 px on the long side (larger images are averaged down first); only one logo family has been scored against a vector original.
 - **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder (stroke-only open paths and lines cut the regions they cross and enclose regions of their own, and regions they bound merge without seams where the lines cross at rounded coordinates (#893); filled open paths count as closed; erase mode while Alt/Option is held: a minus pointer, red highlights of what will go, a click or drag deletes the regions touched, the pieces of open lines and the edges (outline pieces between the points where paths meet, opening their paths there) it passes over, one undo step, `shapeBuilder.merge {erase}` and `shapeBuilder.regions` edges over MCP), Live Paint (every path an edge, open lines included), Image Trace (12 presets, colour layers traced in parallel; a trace past two million anchor points is refused with advice rather than running out of memory, an image over 64 megapixels is traced scaled down to that size (aspect kept, paths at the image's own size) and one over 192 megapixels is refused, and a selection too large to outline shows its bounds (#525); Object › Image Trace › Make and Make and Expand trace at once with the Default preset, #543; with an image selected the Control bar and the Properties panel show Image Trace, whose arrow traces with any preset, Mask (`object.maskImage`: a clipping path on the image's outline, selected so its handles crop), Crop Image (a crop box on the image, starting on its part over the artboard, dragged by its handles or inside it, the outside dimmed, with X/Y/W/H, Apply and Cancel in the Control bar, Enter and Escape, #734; `object.cropImage {rect}` for agents, `{trim: true}` cuts an image to its pixels that aren't fully transparent, pixel for pixel) and Embed or Unembed in place of Fill and Stroke; with an Image Trace object selected, its Preset (choosing another traces again), View, the Image Trace panel and Expand, plus Release in Properties; the five View modes (Tracing Result, with Outlines, Outlines, Outlines with Source Image, Source Image) redraw a trace on screen without tracing again, are saved with it and `imageTrace.setView` sets them, while exports and Expand keep the result; the panel's Advanced section is a header that stays open or closed as it was left (part of #641); Color mode's Palette: Limited, Full Tone (as many colours as the tones need, Less … More), Automatic (flat art with its own colours, else Full Tone; a heuristic) and Document Library (the most used colours of the document's swatches or a swatch library, filled with the swatch colours as they are), part of #641; Advanced › Create: Fills and/or Strokes, where lines up to the Stroke width trace as stroked centre lines (distance transform, thinning, a skeleton graph with spurs pruned, curve fitting; one width per line; without Fills, wider areas become stroked outlines), part of #641), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror). Object › Expand turns radial, grid and mirror repeats into groups of their instances (#1765, #1756).
 - **Paint and appearance (M3):**
@@ -567,6 +567,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-14 | minor | Image Trace, measured in `image-trace-quality.md`: Shapes rework (#1845), square stroke caps (#1846), enhanced presets (#1847), gradients grown over noise and soft rims (#1848). Score and hours unchanged (estimated) |
 | 2026-10-13 | minor | Pinned PngSuite HTTPS files verified by SHA-256 before publication; bounded downloads replace archive extraction (#1729). Scores and hours unchanged. |
 | 2026-10-13 | minor | Bounded synthetic control input (#1709): counts and queued events validated before mutation; control-channel bursts yield between frames. Scores and hours unchanged. |
 | 2026-10-14 | minor | Tools, UI and effects: Align and Distribute act on the anchor points selected with Direct Selection: the points of one path align to each other, not to the artboard, and Distribute spaces them (#1641, fixes #1636; aligning to a key anchor is still missing); Delete removes every selected anchor of a closed path (it used to remove the wrong ones), removes objects selected whole along with the selected anchors of others, and keeps the remainder selected so a second Delete removes it (#1674); In isolation mode Direct Selection and Group Selection pick only inside the isolated object (#1666); Escape cancels a Direct Selection drag (#1803, #1743); Escape while typing ends the edit, keeps the type selected and switches to the Selection tool (#1802, #1686, #1656); A filled Pencil path keeps a stroke of None (#1804, part of #1679); With the Pen, a press that moves under 3 screen pixels is a click (a corner without handles), and a Precise Cursors command toggles the existing preference and can take a shortcut (#1663); The [ and ] keys reach the Blob Brush, the Eraser and the Symbolism tools in the app (#1734, part of #1661); In the Pathfinder panel a group selected alone counts its nested shapes, so an expanded stroked object keeps the Shape Modes enabled (#1642, #1635); Object › Expand turns radial, grid and mirror repeats into groups of their instances (#1765, #1756); Select › Same matches type on its characters' fill and stroke (#1746, #1737); Fields commit what was typed when you click away or move to another field, as Enter does; Escape still discards it (#1787); Up and Down move through the command search results and Enter runs the highlighted one (#1798, #1757); Slider rails show on Medium Dark (#1808, #1662); On Windows the custom title bar's window stays truly borderless, so the pointer lines up with what is drawn on systems where the hidden caption offset it (#1791, #1758; awaiting the reporter's confirmation); Tool cursors are painted into the window on Wayland (#1652; not run on Linux, #1645 stays open until confirmed); Roughen with Smooth keeps turn-backs smooth instead of making cusps that draw as spikes (#1646, #1643); Scribble draws one zig-zag per region, with no lines across holes and notches; convex shapes are unchanged (#1651, #1648); correction to the 2026-10-13 rows: a guide's position in the Transform panel (#1659) is not established by the documentation found (help pages read again on 2026-10-14) and is kept as a convenience pending the owner's decision, with no parity claim; scores unchanged (estimated) |