diff --git a/crates/svg/src/import.rs b/crates/svg/src/import.rs
index aa827d762..fea237c61 100644
--- a/crates/svg/src/import.rs
+++ b/crates/svg/src/import.rs
@@ -22,6 +22,22 @@ pub use depth::MAX_ELEMENT_DEPTH;
 pub(crate) use depth::xml_too_deep;
 pub(crate) use fx::BLEND;
 
+mod convert;
+mod importer;
+mod layers;
+mod prepass;
+
+pub(super) use convert::href;
+use convert::{aff, made_up, mask_flags, midpoint_stops, only_clips};
+pub(super) use importer::PT_PER_IN;
+use importer::SymbolMade;
+pub(super) use layers::DEFAULT_FONT_SIZE;
+pub(crate) use layers::SUBLAYER;
+use layers::{RootUnits, inkscape_pages, promote_sublayers, root_layer_name};
+pub(super) use prepass::Edits;
+pub use prepass::{MAX_FOREIGN, MAX_FOREIGN_VALUE};
+use prepass::{labels, prepass};
+
 mod css;
 mod css_transform;
 mod depth;
@@ -204,162 +220,6 @@ pub(crate) fn import(svg: &str, opts: &ImportOptions) -> Result<(Document, Vec<S
     Ok((im.doc, im.warnings))
 }
 
-/// What marks a nested `<g>` as a sublayer rather than a group: our export writes it on the layers
-/// it writes inside layers. (Inkscape's `inkscape:groupmode="layer"` counts too.)
-pub(crate) const SUBLAYER: &str = "data-vc-layer";
-
-/// The Inkscape namespace (its layers and their labels).
-const INKSCAPE: &str = "http://www.inkscape.org/namespaces/inkscape";
-
-/// The layer name on root element `root` (`<svg id="Main">`, or its `data-name`), as exports of
-/// one-layer documents write it. An Inkscape root's id (`svg8`) is one Inkscape made up, not a name.
-fn root_layer_name(root: XNode) -> Option<String> {
-    let id = root.attribute("id").filter(|_| root.attribute((INKSCAPE, "version")).is_none());
-    root.attribute("data-name").or(id).map(str::trim).filter(|n| !n.is_empty()).map(str::to_string)
-}
-
-/// Is element `g` a `<g>` marked as a layer ([`SUBLAYER`])? Only one with an id counts: the id (or
-/// the label beside it) is its name.
-fn marked_layer(g: XNode) -> bool {
-    g.tag_name().name() == "g"
-        && g.attribute("id").is_some_and(|id| !id.is_empty())
-        && (g.has_attribute(SUBLAYER) || g.attribute((INKSCAPE, "groupmode")) == Some("layer"))
-}
-
-/// Turn the groups made of elements marked as layers (`marked`, see [`marked_layer`]) right inside
-/// layer `l` into its sublayers, in its colour, and theirs in turn. A marked group anywhere else
-/// (in a group, a mask, a symbol) stays a group: only layers hold layers.
-fn promote_sublayers(l: &mut Node, marked: &HashSet<NodeId>) {
-    let NodeKind::Layer { color, children, .. } = &mut l.kind else { return };
-    let color = *color;
-    for c in children.iter_mut().filter(|c| marked.contains(&c.id)) {
-        let c = Arc::make_mut(c);
-        let NodeKind::Group { children, clip } = &mut c.kind else { continue };
-        let mut sub = Node::layer(c.id, "", color);
-        sub.set_clips(*clip);
-        if let Some(ch) = sub.children_mut() {
-            *ch = std::mem::take(children);
-        }
-        c.kind = sub.kind;
-        promote_sublayers(c, marked);
-    }
-}
-
-/// SVG's initial `font-size` (`medium`) in user units.
-pub(super) const DEFAULT_FONT_SIZE: f64 = 12.0;
-
-/// How lengths become points, from the root `<svg>`'s `width` / `height`.
-///
-/// A pixel (and a unitless user unit) is a point, as we export, and absolute lengths keep their
-/// physical size at 72 pt per inch: `font-size="12pt"` is 12 pt, `1in` is 72 pt. A root size in
-/// absolute units (`width="210mm"`) is that physical size, and its user units are CSS pixels of it
-/// (96 per inch, 0.75 pt each), so a drawing without a `viewBox` keeps its proportions. With one
-/// side absolute and the other not (`width="96pt" height="96"`), both are: the unitless side is
-/// CSS pixels too, so the drawing isn't stretched (#1010).
-struct RootUnits {
-    /// Pixels per inch usvg (and the text pass) convert absolute lengths at.
-    dpi: f64,
-    /// Points per user unit of the root, along both axes.
-    k: f64,
-    /// Document units: those of the root `width` (pixels when it has none).
-    unit: Unit,
-}
-
-impl RootUnits {
-    fn of(root: XNode) -> Self {
-        let unit = |name: &str| root.attribute(name).and_then(|v| svgtypes::Length::from_str(v.trim()).ok()).map(|l| l.unit);
-        use svgtypes::LengthUnit as U;
-        let physical = |u: Option<U>| matches!(u, Some(U::In | U::Cm | U::Mm | U::Pt | U::Pc));
-        let (w, h) = (unit("width"), unit("height"));
-        let (dpi, k) = if physical(w) || physical(h) { (CSS_PX_PER_IN, PT_PER_IN / CSS_PX_PER_IN) } else { (PT_PER_IN, 1.0) };
-        let unit = match w {
-            Some(U::Mm) => Unit::Millimeters,
-            Some(U::Cm) => Unit::Centimeters,
-            Some(U::In) => Unit::Inches,
-            Some(U::Pt) => Unit::Points,
-            Some(U::Pc) => Unit::Picas,
-            _ => Unit::Pixels,
-        };
-        Self { dpi, k, unit }
-    }
-}
-
-/// `'id' (feA, feB)` for each filter: its id and the primitives it uses, for warnings.
-fn filter_names(filters: &[Arc<usvg::filter::Filter>]) -> String {
-    use usvg::filter::Kind as K;
-    let names: Vec<String> = filters
-        .iter()
-        .map(|f| {
-            let mut kinds: Vec<&str> = Vec::new();
-            for p in f.primitives() {
-                let k = match p.kind() {
-                    K::Blend(_) => "feBlend",
-                    K::ColorMatrix(_) => "feColorMatrix",
-                    K::ComponentTransfer(_) => "feComponentTransfer",
-                    K::Composite(_) => "feComposite",
-                    K::ConvolveMatrix(_) => "feConvolveMatrix",
-                    K::DiffuseLighting(_) => "feDiffuseLighting",
-                    K::DisplacementMap(_) => "feDisplacementMap",
-                    K::DropShadow(_) => "feDropShadow",
-                    K::Flood(_) => "feFlood",
-                    K::GaussianBlur(_) => "feGaussianBlur",
-                    K::Image(_) => "feImage",
-                    K::Merge(_) => "feMerge",
-                    K::Morphology(_) => "feMorphology",
-                    K::Offset(_) => "feOffset",
-                    K::SpecularLighting(_) => "feSpecularLighting",
-                    K::Tile(_) => "feTile",
-                    K::Turbulence(_) => "feTurbulence",
-                };
-                if !kinds.contains(&k) {
-                    kinds.push(k);
-                }
-            }
-            let id = if f.id().is_empty() || made_up(f.id()) { String::new() } else { format!("'{}' ", f.id()) };
-            format!("{id}({})", kinds.join(", "))
-        })
-        .collect();
-    names.join(", ")
-}
-
-/// Inkscape's pages (`<inkscape:page>` in its `<sodipodi:namedview>`, in user units) as artboards
-/// through `user` (user units → document points), named by their labels; `None` without any.
-fn inkscape_pages(xml: &roxmltree::Document, user: Affine) -> Option<Vec<vectorcraft_doc::Artboard>> {
-    let num = |n: roxmltree::Node, a: &str| n.attribute(a).and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite());
-    let pages: Vec<vectorcraft_doc::Artboard> = xml
-        .descendants()
-        .filter(|n| n.is_element() && n.tag_name().name() == "page" && n.tag_name().namespace() == Some(INKSCAPE))
-        .filter_map(|p| {
-            let (w, h) = (num(p, "width")?, num(p, "height")?);
-            let (x, y) = (num(p, "x").unwrap_or(0.0), num(p, "y").unwrap_or(0.0));
-            // A box too large to add up or to place (1e308 wide) is no page.
-            let r = user.transform_rect_bbox(Rect::new(x, y, x + w, y + h));
-            (w > 0.0 && h > 0.0 && r.is_finite()).then_some((p, r))
-        })
-        .take(1000)
-        .enumerate()
-        .map(|(i, (p, r))| vectorcraft_doc::Artboard {
-            id: i as u32 + 1,
-            name: p.attribute((INKSCAPE, "label")).filter(|l| !l.trim().is_empty()).map_or_else(|| format!("Artboard {}", i + 1), str::to_string),
-            rect: r,
-            locked: false,
-            show_center_mark: false,
-            show_cross_hairs: false,
-            show_video_safe_areas: false,
-            video_ruler_pixel_aspect_ratio: 1.0,
-            color: None,
-        })
-        .collect();
-    (!pages.is_empty()).then_some(pages)
-}
-/// How many clip paths deep (`<clipPath clip-path>`) an object's clip is read.
-const MAX_CLIP_NEST: usize = 16;
-
-/// Points per inch.
-pub(super) const PT_PER_IN: f64 = 72.0;
-/// CSS pixels per inch.
-const CSS_PX_PER_IN: f64 = 96.0;
-
 struct Importer {
     doc: Document,
     warnings: Vec<String>,
@@ -401,1189 +261,3 @@ struct Importer {
     /// stroke's width is measured in.
     screen: f64,
 }
-
-/// A `<symbol>` made a symbol: its name, its art with no object ids (what each `<use>` has to show
-/// to be an instance of it) and the instance transforms the art can stand for.
-struct SymbolMade {
-    name: String,
-    art: Node,
-    reuse: Reuse,
-}
-
-/// `n` with every object id (its descendants' and its mask art's too) zeroed, to compare art.
-fn without_ids(n: &Node) -> Node {
-    let mut n = n.clone();
-    n.id = vectorcraft_doc::NodeId(0);
-    if let Some(m) = n.extras_if_any().and_then(|e| e.mask.as_deref_mut()) {
-        m.art = Arc::new(without_ids(&m.art));
-    }
-    for c in n.children_mut().into_iter().flatten() {
-        *c = Arc::new(without_ids(c));
-    }
-    n
-}
-
-/// `base`, or `base 2`, `base 3`… : the first that isn't `taken`.
-fn unique_name(base: &str, taken: impl Fn(&str) -> bool) -> String {
-    let mut name = base.to_string();
-    let mut k = 2;
-    while taken(&name) {
-        name = format!("{base} {k}");
-        k += 1;
-    }
-    name
-}
-
-/// The stops our export added for midpoints (`data-vc-midpoint`), by gradient id: for each stop,
-/// the midpoint it stands for.
-fn midpoint_stops(xml: &roxmltree::Document) -> HashMap<String, Vec<Option<f32>>> {
-    xml.descendants()
-        .filter(|n| matches!(n.tag_name().name(), "linearGradient" | "radialGradient"))
-        .filter_map(|g| {
-            let id = g.attribute("id")?;
-            let marks: Vec<Option<f32>> = g
-                .children()
-                .filter(|c| c.tag_name().name() == "stop")
-                .map(|c| c.attribute("data-vc-midpoint").and_then(|v| v.parse().ok()))
-                .collect();
-            marks.iter().any(Option::is_some).then(|| (id.to_string(), marks))
-        })
-        .collect()
-}
-
-/// A gradient's stops, with the midpoint stops `marks` names folded back into the midpoints of
-/// the stops before them.
-fn gradient_stops(g: &usvg::BaseGradient, marks: Option<&[Option<f32>]>) -> Vec<GradientStop> {
-    let marks = marks.filter(|m| m.len() == g.stops().len());
-    let mut out: Vec<GradientStop> = Vec::with_capacity(g.stops().len());
-    for (i, s) in g.stops().iter().enumerate() {
-        if let (Some(mid), Some(prev)) = (marks.and_then(|m| m.get(i).copied().flatten()), out.last_mut()) {
-            prev.midpoint = mid.clamp(0.0, 1.0);
-            continue;
-        }
-        let c = s.color();
-        out.push(GradientStop { opacity: s.opacity().get(), ..GradientStop::new(s.offset().get(), Color::rgb8(c.red, c.green, c.blue)) });
-    }
-    out
-}
-
-/// The options [`crate::export::MASK_FLAGS`] records on exported `<mask>` elements, by mask id:
-/// (clip, invert).
-fn mask_flags(xml: &roxmltree::Document) -> HashMap<String, (bool, bool)> {
-    let attr = crate::export::MASK_FLAGS;
-    if !xml.input_text().contains(attr) {
-        return HashMap::new();
-    }
-    let flags = |n: roxmltree::Node| {
-        let has = |f: &str| n.attribute(attr).is_some_and(|v| v.split_whitespace().any(|x| x == f));
-        Some((n.attribute("id")?.to_string(), (!has("noclip"), has("invert"))))
-    };
-    xml.descendants().filter(|n| n.tag_name().name() == "mask" && n.has_attribute(attr)).filter_map(flags).collect()
-}
-
-/// Prefix of the ids [`prepass`] gives the elements it has to find again that have none.
-const MADE_UP_ID: &str = "vectorcraft-id-";
-
-/// Is `id` one [`prepass`] made up (not a name)?
-fn made_up(id: &str) -> bool {
-    id.starts_with(MADE_UP_ID)
-}
-
-/// The URL an `<a>` element links to.
-pub(super) fn href<'a>(a: XNode<'a, '_>) -> Option<&'a str> {
-    a.attribute("href").or_else(|| a.attribute(("http://www.w3.org/1999/xlink", "href"))).filter(|h| !h.is_empty())
-}
-
-/// What usvg would lose, found in the XML before it runs ([`prepass`]).
-#[derive(Default)]
-struct Found {
-    /// The URL of each `<a href>`'s group, by its id.
-    links: HashMap<String, String>,
-    /// Ids of the undisplayed objects shown for usvg: they come back hidden.
-    hidden: HashSet<String>,
-    /// The `<symbol>` id each `<use>` of a symbol shows, by the `<use>`'s id.
-    uses: HashMap<String, String>,
-    /// The files `<image>` elements link to.
-    files: files::Files,
-    /// Ids of the shapes whose strokes don't scale ([`vector_effect`]).
-    non_scaling: HashSet<String>,
-    /// The `data-*` attributes of elements, by id ([`user_data`]).
-    data: HashMap<String, Vec<(String, String)>>,
-    /// The event attributes of elements, by id ([`user_events`]).
-    events: HashMap<String, Vec<(String, String)>>,
-    /// The attributes of elements in other applications' namespaces, by id ([`foreign`]).
-    foreign: HashMap<String, Vec<ForeignAttribute>>,
-    /// The JavaScript files `<script>` elements link to ([`linked_scripts`]).
-    scripts: Vec<String>,
-    /// Ids of the `<g>` elements marked as layers ([`marked_layer`]).
-    sublayers: HashSet<String>,
-    warnings: Vec<String>,
-}
-
-/// Changes to the SVG text: `(range, replacement)`, an empty range inserting.
-#[derive(Default)]
-pub(super) struct Edits {
-    list: Vec<(std::ops::Range<usize>, String)>,
-    /// The ids made up so far, by element.
-    ids: HashMap<roxmltree::NodeId, String>,
-    /// Declarations added to elements' `style`s, by element: (where they go, whether the element
-    /// has a `style` attribute, the declarations, XML-escaped).
-    styles: HashMap<roxmltree::NodeId, (usize, bool, String)>,
-}
-
-impl Edits {
-    fn insert(&mut self, at: usize, text: String) {
-        self.list.push((at..at, text));
-    }
-
-    /// The id of element `n` (in `svg`), made up and written in when it has none.
-    fn id(&mut self, svg: &str, n: XNode) -> String {
-        if let Some(id) = n.attribute("id").filter(|id| !id.is_empty()) {
-            return id.to_string();
-        }
-        if let Some(id) = self.ids.get(&n.id()) {
-            return id.clone();
-        }
-        let id = format!("{MADE_UP_ID}{}", self.ids.len());
-        self.set(svg, n, "id", &id);
-        self.ids.insert(n.id(), id.clone());
-        id
-    }
-
-    /// Set attribute `name` of element `n` (in `svg`) to `value` (XML-escaped already).
-    pub(super) fn set(&mut self, svg: &str, n: XNode, name: &str, value: &str) {
-        match n.attributes().find(|a| a.name() == name && a.namespace().is_none()) {
-            Some(a) => self.list.push((a.range_value(), value.to_string())),
-            None => self.insert(tag_name_end(svg, n), format!(" {name}=\"{value}\"")),
-        }
-    }
-
-    /// Add the declaration `decl` (XML-escaped already) to the `style` of element `n` (in `svg`),
-    /// after the ones already there (so it wins over them and over style sheet rules).
-    fn style(&mut self, svg: &str, n: XNode, decl: &str) {
-        let (_, _, decls) =
-            self.styles.entry(n.id()).or_insert_with(|| match n.attributes().find(|a| a.name() == "style" && a.namespace().is_none()) {
-                Some(a) => (a.range_value().end, true, String::new()),
-                None => (tag_name_end(svg, n), false, String::new()),
-            });
-        decls.push(';');
-        decls.push_str(decl);
-    }
-
-    /// `svg` with the edits made; overlapping ones and ranges off character boundaries are
-    /// skipped.
-    fn apply(mut self, svg: &str) -> Cow<'_, str> {
-        for (at, has_style, decls) in std::mem::take(&mut self.styles).into_values() {
-            self.insert(at, if has_style { decls } else { format!(" style=\"{}\"", decls.strip_prefix(';').unwrap_or(&decls)) });
-        }
-        if self.list.is_empty() {
-            return svg.into();
-        }
-        // Stable: inserts at one place keep their order.
-        self.list.sort_by_key(|(r, _)| (r.start, r.end));
-        let mut out = String::with_capacity(svg.len() + self.list.iter().map(|(_, t)| t.len()).sum::<usize>());
-        let mut last = 0;
-        for (r, text) in self.list {
-            let (Some(part), Some(_)) = (svg.get(last..r.start), svg.get(r.clone())) else { continue };
-            out.push_str(part);
-            out.push_str(&text);
-            last = r.end;
-        }
-        out.push_str(svg.get(last..).unwrap_or(""));
-        out.into()
-    }
-}
-
-/// usvg reads `<a href>` and `<use>` as plain groups, drops what isn't displayed and reads linked
-/// files on its own. Before it runs, the SVG is changed so that what we keep can be found:
-/// * every `<a href>` and every `<use>` of a `<symbol>` gets an id when it has none
-///   ([`MADE_UP_ID`]…), recorded with its URL or symbol;
-/// * undisplayed objects (`display: none`, as Save writes hidden layers) are shown and recorded,
-///   to come back hidden; one something links to (a `<use>` template) stays as it is;
-/// * shapes with a non-scaling stroke get an id when they have none, recorded ([`vector_effect`]);
-/// * objects with event attributes get an id when they have none, recorded with them
-///   ([`user_events`]), and the `<script>` links are recorded ([`linked_scripts`]);
-/// * so do objects with attributes in other applications' namespaces ([`foreign`]);
-/// * 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`]).
-///
-/// Whether each is there at all is read from `markers`: `svg` with its data URLs left out
-/// ([`depth::prescan`]), so an embedded picture isn't searched a dozen times. The edits are made
-/// in `svg` itself.
-fn prepass<'s>(svg: &'s str, markers: &str, xml: &roxmltree::Document, opts: &ImportOptions) -> (Cow<'s, str>, Found) {
-    let mut found = Found::default();
-    // (`:` for prefixed elements such as `<svg:image>`.)
-    let css_transform = has_css_transform(markers);
-    let not = markers.contains(":not(");
-    let events = SVG_EVENTS.iter().any(|e| markers.contains(e));
-    let foreign_attrs = markers.contains("xmlns:") && has_foreign_attributes(xml);
-    if !css_transform
-        && !not
-        && !events
-        && !foreign_attrs
-        && !["<a", "display", "<use", ":use", "<image", ":image", vector_effect::NON_SCALING, "data-", "groupmode", "script"]
-            .iter()
-            .any(|t| markers.contains(t))
-    {
-        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") {
-        if let Some(url) = href(a) {
-            found.links.insert(edits.id(svg, a), url.to_string());
-        }
-    }
-    if markers.contains("data-") {
-        for e in elements().filter(|e| OBJECT_ELEMENTS.contains(&e.tag_name().name())) {
-            let data = user_data(e);
-            if !data.is_empty() {
-                found.data.insert(edits.id(svg, e), data);
-            }
-        }
-    }
-    if foreign_attrs {
-        for e in elements().filter(|e| OBJECT_ELEMENTS.contains(&e.tag_name().name())) {
-            let kept = foreign(e, &mut found.warnings);
-            if !kept.is_empty() {
-                found.foreign.insert(edits.id(svg, e), kept);
-            }
-        }
-    }
-    if events {
-        for e in elements().filter(|e| EVENT_ELEMENTS.contains(&e.tag_name().name())) {
-            let events = user_events(e);
-            if !events.is_empty() {
-                found.events.insert(edits.id(svg, e), events);
-            }
-        }
-    }
-    if markers.contains("script") {
-        found.scripts = linked_scripts(xml, &mut found.warnings);
-    }
-    found.sublayers = elements().filter(|g| marked_layer(*g)).filter_map(|g| g.attribute("id")).map(str::to_string).collect();
-    let symbols: HashSet<&str> = elements().filter(|n| n.tag_name().name() == "symbol").filter_map(|n| n.attribute("id")).collect();
-    for u in elements().filter(|n| n.tag_name().name() == "use") {
-        if let Some(sym) = href(u).and_then(|h| h.strip_prefix('#')).filter(|s| symbols.contains(s)) {
-            found.uses.insert(edits.id(svg, u), sym.to_string());
-        }
-    }
-    let (display, non_scaling) = (markers.contains("display"), markers.contains(vector_effect::NON_SCALING));
-    if display || non_scaling || not {
-        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);
-        }
-        if display {
-            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);
-        }
-    }
-    found.files = files::Files::read(svg, xml, opts, &mut edits, &mut found.warnings);
-    if !symbols.is_empty() && markers.contains('%') {
-        edits.list.extend(symbol_units::rewrites(xml));
-    }
-    if css_transform {
-        edits.list.extend(css_transform::rewrites(svg, xml));
-    }
-    (edits.apply(svg), found)
-}
-
-/// Is there a `transform` CSS declaration in `markers` (`transform` followed by `:`)?
-fn has_css_transform(markers: &str) -> bool {
-    markers.match_indices("transform").any(|(i, t)| markers.get(i + t.len()..).is_some_and(|s| s.trim_start().starts_with(':')))
-}
-
-/// usvg's style sheets drop rules with a `:not()` selector (#1557). The properties such rules set
-/// on an element go in its `style` attribute, with the value that wins the cascade there (which
-/// can be another rule's or the attribute's own), so usvg reads what CSS would.
-fn not_rules(svg: &str, xml: &roxmltree::Document, css: &css::Styles, edits: &mut Edits) {
-    for n in xml.descendants().filter(XNode::is_element) {
-        for (name, value) in css.set_by_not_rules(n) {
-            let value = if name == "transform" { css_transform::to_svg(&value).unwrap_or(value) } else { value };
-            edits.style(svg, n, &crate::xml_escape(&format!("{name}:{value}")));
-        }
-    }
-}
-
-/// The elements that are objects (what [`hidden_objects`] shows).
-const OBJECTS: &[&str] = &["g", "a", "path", "rect", "circle", "ellipse", "line", "polyline", "polygon", "image", "text", "use"];
-
-/// Show the undisplayed objects outside `<defs>` (and the like) for usvg, recording their ids. The
-/// objects in a `<switch>` count too (some apps wrap all their layers in one).
-fn hidden_objects(svg: &str, xml: &roxmltree::Document, css: &css::Styles, edits: &mut Edits, ids: &mut HashSet<String>) {
-    let linked: HashSet<&str> = xml.descendants().filter_map(href).filter_map(|h| h.strip_prefix('#')).collect();
-    let mut todo: Vec<XNode> = xml.root_element().children().filter(XNode::is_element).collect();
-    while let Some(n) = todo.pop() {
-        let tag = n.tag_name().name();
-        if n.attribute("id").is_some_and(|id| linked.contains(id)) {
-            continue;
-        }
-        if matches!(tag, "g" | "a" | "switch") {
-            todo.extend(n.children().filter(XNode::is_element));
-        }
-        if !OBJECTS.contains(&tag) || css.own(n, "display").as_deref() != Some("none") {
-            continue;
-        }
-        ids.insert(edits.id(svg, n));
-        // A `style` declaration wins over the attribute and style sheet rules.
-        edits.style(svg, n, "display:inline");
-    }
-}
-
-/// Where the start tag of element `n` ends its name (where an attribute can go).
-fn tag_name_end(svg: &str, n: XNode) -> usize {
-    let start = n.range().start;
-    svg.get(start + 1..).and_then(|s| s.find(|c: char| c.is_whitespace() || c == '/' || c == '>')).map_or(start + 2, |i| start + 1 + i)
-}
-
-/// The elements that become objects, whose `data-*` attributes are kept.
-const OBJECT_ELEMENTS: &[&str] = &["g", "a", "use", "path", "rect", "circle", "ellipse", "line", "polyline", "polygon", "image"];
-
-/// The most `data-*` attributes kept per element (the file is untrusted).
-const MAX_DATA: usize = 64;
-
-/// The `data-*` attributes of element `e`, in order, without the `data-` (ours, `data-name` and
-/// `data-vc-*`, aside).
-fn user_data(e: XNode) -> Vec<(String, String)> {
-    e.attributes()
-        .filter(|a| a.namespace().is_none())
-        .filter_map(|a| Some((a.name().strip_prefix("data-")?, a.value())))
-        .filter(|(k, _)| !k.is_empty() && *k != "name" && !k.starts_with("vc-"))
-        .take(MAX_DATA)
-        .map(|(k, v)| (k.to_string(), v.to_string()))
-        .collect()
-}
-
-/// The namespaces whose attributes VectorCraft reads, writes or makes again itself: their
-/// attributes aren't kept as another application's ([`foreign`]).
-const OWN_NAMESPACES: &[&str] = &[
-    "http://www.w3.org/2000/svg",
-    "http://www.w3.org/1999/xlink",
-    "http://www.w3.org/XML/1998/namespace",
-    "http://www.w3.org/2000/xmlns/",
-    INKSCAPE,
-    "http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd",
-    crate::EDITING_NS,
-];
-
-/// The most attributes in other applications' namespaces kept per element (the file is untrusted).
-pub const MAX_FOREIGN: usize = 64;
-
-/// The longest value of such an attribute kept, in bytes; a longer one is left out.
-pub const MAX_FOREIGN_VALUE: usize = 64 * 1024;
-
-/// The namespace of attribute `a` when it is another application's ([`OWN_NAMESPACES`] aside).
-fn foreign_ns<'a>(a: &roxmltree::Attribute<'a, '_>) -> Option<&'a str> {
-    a.namespace().filter(|ns| !OWN_NAMESPACES.contains(ns))
-}
-
-/// Does any element of `xml` have an attribute in another application's namespace? Most files
-/// declare only namespaces VectorCraft reads itself (XLink), and skip the scan for them.
-fn has_foreign_attributes(xml: &roxmltree::Document) -> bool {
-    xml.descendants().filter(XNode::is_element).any(|e| e.attributes().any(|a| foreign_ns(&a).is_some()))
-}
-
-/// The attributes of element `e` in other applications' namespaces, in order, with the prefix the
-/// file gives each namespace: `plotter:pen="2"`. Those past [`MAX_FOREIGN`], and values longer
-/// than [`MAX_FOREIGN_VALUE`], are left out with a warning.
-fn foreign(e: XNode, warnings: &mut Vec<String>) -> Vec<ForeignAttribute> {
-    let mut kept = vec![];
-    let mut left_out = false;
-    for a in e.attributes() {
-        let Some(ns) = foreign_ns(&a) else { continue };
-        if kept.len() == MAX_FOREIGN || a.value().len() > MAX_FOREIGN_VALUE {
-            left_out = true;
-            continue;
-        }
-        // A namespaced attribute always has a prefix in the file; `ns` stands in where the only
-        // one found is the default namespace's (export makes it unique).
-        let prefix = e.lookup_prefix(ns).filter(|p| !p.is_empty()).unwrap_or("ns");
-        kept.push(ForeignAttribute { ns: ns.to_string(), prefix: prefix.to_string(), name: a.name().to_string(), value: a.value().to_string() });
-    }
-    if left_out {
-        let w = format!(
-            "other applications' attributes past {MAX_FOREIGN} on an element, or longer than {} KiB, were left out",
-            MAX_FOREIGN_VALUE / 1024
-        );
-        if !warnings.contains(&w) {
-            warnings.push(w);
-        }
-    }
-    kept
-}
-
-/// The elements whose event attributes are kept: the objects, and type.
-const EVENT_ELEMENTS: &[&str] = &["g", "a", "use", "path", "rect", "circle", "ellipse", "line", "polyline", "polygon", "image", "text"];
-
-/// The event attributes of element `e` that the SVG Interactivity panel lists ([`SVG_EVENTS`]),
-/// in order: the JavaScript is kept as text and never run.
-fn user_events(e: XNode) -> Vec<(String, String)> {
-    e.attributes()
-        .filter(|a| a.namespace().is_none() && SVG_EVENTS.contains(&a.name()))
-        .map(|a| (a.name().to_string(), a.value().to_string()))
-        .collect()
-}
-
-/// The JavaScript files the `<script>` elements link to, in order and each once, at most
-/// [`MAX_SVG_SCRIPTS`] (the file is untrusted): the links are kept as text, and the files are never
-/// read or run. Inline scripts and the links past the limit are left out with a warning.
-fn linked_scripts(xml: &roxmltree::Document, warnings: &mut Vec<String>) -> Vec<String> {
-    let mut out: Vec<String> = vec![];
-    let mut over = false;
-    for s in xml.descendants().filter(|n| n.is_element() && n.tag_name().name() == "script") {
-        match href(s) {
-            Some(h) if out.iter().any(|o| o == h) => {}
-            Some(h) if out.len() < MAX_SVG_SCRIPTS => out.push(h.to_string()),
-            Some(_) => over = true,
-            None if s.text().is_some_and(|t| !t.trim().is_empty()) => {
-                let w = "inline scripts were left out: only linked JavaScript files are kept".to_string();
-                if !warnings.contains(&w) {
-                    warnings.push(w);
-                }
-            }
-            None => {}
-        }
-    }
-    if over {
-        warnings.push(format!("more than {MAX_SVG_SCRIPTS} JavaScript files are linked: only the first {MAX_SVG_SCRIPTS} were kept"));
-    }
-    out
-}
-
-/// Make `n` link to `url`, unless it links somewhere already (an inner link wins).
-fn link(n: &mut Node, url: &str) {
-    if n.url().is_none() {
-        n.edit_attrs(|a| a.url = url.to_string());
-    }
-}
-
-/// The names apps keep beside element ids, by id: `data-name`, `inkscape:label`, `serif:id` or
-/// `aria-label` (the first one present).
-fn labels(xml: &roxmltree::Document) -> HashMap<String, String> {
-    const SERIF: &str = "http://www.serif.com/";
-    xml.descendants()
-        .filter_map(|n| {
-            let id = n.attribute("id").filter(|id| !id.is_empty())?;
-            let name = n
-                .attribute("data-name")
-                .or_else(|| n.attribute((INKSCAPE, "label")))
-                .or_else(|| n.attribute((SERIF, "id")))
-                .or_else(|| n.attribute("aria-label"))?;
-            Some((id.to_string(), name.to_string()))
-        })
-        .collect()
-}
-
-fn aff(t: usvg::Transform) -> Affine {
-    Affine::new([t.sx as f64, t.ky as f64, t.kx as f64, t.sy as f64, t.tx as f64, t.ty as f64])
-}
-
-fn is_plain(g: &usvg::Group) -> bool {
-    g.clip_path().is_none() && only_clips(g)
-}
-
-/// Does group `g` leave its art as it is, but for a clip path (no mask, filter, opacity or blend)?
-fn only_clips(g: &usvg::Group) -> bool {
-    g.mask().is_none() && g.filters().is_empty() && g.opacity().get() >= 1.0 && g.blend_mode() == usvg::BlendMode::Normal
-}
-
-fn blend(b: usvg::BlendMode) -> BlendMode {
-    use usvg::BlendMode as B;
-    match b {
-        B::Normal => BlendMode::Normal,
-        B::Multiply => BlendMode::Multiply,
-        B::Screen => BlendMode::Screen,
-        B::Overlay => BlendMode::Overlay,
-        B::Darken => BlendMode::Darken,
-        B::Lighten => BlendMode::Lighten,
-        B::ColorDodge => BlendMode::ColorDodge,
-        B::ColorBurn => BlendMode::ColorBurn,
-        B::HardLight => BlendMode::HardLight,
-        B::SoftLight => BlendMode::SoftLight,
-        B::Difference => BlendMode::Difference,
-        B::Exclusion => BlendMode::Exclusion,
-        B::Hue => BlendMode::Hue,
-        B::Saturation => BlendMode::Saturation,
-        B::Color => BlendMode::Color,
-        B::Luminosity => BlendMode::Luminosity,
-    }
-}
-
-fn bezpath(p: &usvg::tiny_skia_path::Path, m: Affine) -> BezPath {
-    use usvg::tiny_skia_path::PathSegment as S;
-    let pt = |p: usvg::tiny_skia_path::Point| m * Point::new(p.x as f64, p.y as f64);
-    let mut bp = BezPath::new();
-    for s in p.segments() {
-        match s {
-            S::MoveTo(p) => bp.move_to(pt(p)),
-            S::LineTo(p) => bp.line_to(pt(p)),
-            S::QuadTo(a, p) => bp.quad_to(pt(a), pt(p)),
-            S::CubicTo(a, b, p) => bp.curve_to(pt(a), pt(b), pt(p)),
-            S::Close => bp.close_path(),
-        }
-    }
-    bp
-}
-
-/// The shapes of clip path `cp` on an element whose user space `ts` maps to the document.
-fn clip_shapes(cp: &usvg::ClipPath, ts: Affine) -> Vec<(BezPath, FillRule)> {
-    fn collect(g: &usvg::Group, m: Affine, out: &mut Vec<(BezPath, FillRule)>) {
-        for c in g.children() {
-            match c {
-                usvg::Node::Group(g) => collect(g, m * aff(g.transform()), out),
-                usvg::Node::Path(p) => out.push((bezpath(p.data(), m), p.fill().map(|f| rule(f.rule())).unwrap_or_default())),
-                _ => {}
-            }
-        }
-    }
-    let mut shapes = Vec::new();
-    collect(cp.root(), ts * aff(cp.transform()), &mut shapes);
-    shapes
-}
-
-/// Does clip path `cp` (on an element whose user space `ts` maps to the document) leave `art`,
-/// placed by `xf`, whole? (Only its bounds are checked: the box must be inside a clip shape.)
-fn uncut(cp: &usvg::ClipPath, ts: Affine, art: &Node, xf: Affine) -> bool {
-    let Some(b) = art.visual_bounds() else { return false };
-    if cp.clip_path().is_some() {
-        return false;
-    }
-    // Art touching the clip's edge isn't cut by it.
-    let e = 1e-6 * (b.width() + b.height()).max(1e-9);
-    let b = b.inflate(-e, -e);
-    let shapes = clip_shapes(cp, ts);
-    let corners = [Point::new(b.x0, b.y0), Point::new(b.x1, b.y0), Point::new(b.x1, b.y1), Point::new(b.x0, b.y1)];
-    corners.iter().all(|c| shapes.iter().any(|(s, _)| kurbo::Shape::contains(s, xf * *c)))
-}
-
-fn rule(r: usvg::FillRule) -> FillRule {
-    match r {
-        usvg::FillRule::NonZero => FillRule::NonZero,
-        usvg::FillRule::EvenOdd => FillRule::EvenOdd,
-    }
-}
-
-impl Importer {
-    fn warn(&mut self, s: String) {
-        if !self.warnings.contains(&s) {
-            self.warnings.push(s);
-        }
-    }
-
-    /// The child of `g` when it's all `g` holds and only wraps art: an id-less group that leaves
-    /// it as it is (but for a transform) and isn't a text.
-    fn wrapper<'g>(&self, g: &'g usvg::Group) -> Option<&'g usvg::Group> {
-        match g.children() {
-            [usvg::Node::Group(w)] if w.id().is_empty() && is_plain(w) && self.text_slot(w).is_none() => Some(w),
-            _ => None,
-        }
-    }
-
-    fn children(&mut self, g: &usvg::Group, acc: Affine) -> Vec<Arc<Node>> {
-        g.children().iter().filter_map(|c| self.node(c, acc)).map(Arc::new).collect()
-    }
-
-    /// The object usvg node `n` makes under transform `acc`, with what the file kept on its element
-    /// (data, event and other applications' attributes); `None` for what imports as nothing.
-    fn node(&mut self, n: &usvg::Node, acc: Affine) -> Option<Node> {
-        let mut out = match n {
-            usvg::Node::Group(g) => self.group(g, acc),
-            usvg::Node::Path(p) => self.path(p, acc),
-            usvg::Node::Image(i) => self.image(i, acc),
-            // Only present when usvg had fonts; text is read from the XML instead.
-            usvg::Node::Text(_) => None,
-        }?;
-        if self.hidden.contains(n.id()) {
-            out.visible = false;
-        }
-        self.keep_data(n.id(), &mut out);
-        self.keep_events(n.id(), &mut out);
-        self.keep_foreign(n.id(), &mut out);
-        Some(out)
-    }
-
-    /// Give `n` the `data-*` attributes of element `id`, unless it has data already (what an
-    /// inner element made of it keeps).
-    fn keep_data(&self, id: &str, n: &mut Node) {
-        if let Some(data) = self.data.get(id).filter(|_| n.extras().attrs.as_ref().is_none_or(|a| a.data.is_empty())) {
-            n.edit_attrs(|a| a.data = data.clone());
-        }
-    }
-
-    /// Give `n` the event attributes of element `id`, unless it has events already (what an inner
-    /// element made of it keeps).
-    fn keep_events(&self, id: &str, n: &mut Node) {
-        if let Some(events) = self.events.get(id).filter(|_| n.extras().attrs.as_ref().is_none_or(|a| a.events.is_empty())) {
-            n.edit_attrs(|a| a.events = events.clone());
-        }
-    }
-
-    /// Give `n` the attributes of element `id` in other applications' namespaces, unless it has
-    /// some already (what an inner element made of it keeps).
-    fn keep_foreign(&self, id: &str, n: &mut Node) {
-        if let Some(kept) = self.foreign.get(id).filter(|_| n.extras().attrs.as_ref().is_none_or(|a| a.foreign.is_empty())) {
-            n.edit_attrs(|a| a.foreign = kept.clone());
-        }
-    }
-
-    /// A gradient's stops, midpoints restored.
-    fn stops(&self, g: &usvg::BaseGradient) -> Vec<GradientStop> {
-        gradient_stops(g, self.midpoints.get(g.id()).map(Vec::as_slice))
-    }
-
-    /// The object name for an element id: its label (see [`labels`]), else the id itself.
-    fn name_of<'a>(&'a self, id: &'a str) -> &'a str {
-        self.labels.get(id).map_or(id, String::as_str)
-    }
-
-    /// A new object named after element `id` (unless it has none or a made-up one).
-    fn named(&mut self, id: &str, kind: NodeKind) -> Node {
-        let nid = self.doc.alloc_id();
-        let mut n = Node::new(nid, kind);
-        if !id.is_empty() && !made_up(id) {
-            n.name = Some(self.name_of(id).to_string());
-        }
-        n
-    }
-
-    fn group(&mut self, g: &usvg::Group, acc: Affine) -> Option<Node> {
-        let url = self.links.get(g.id()).cloned();
-        let mut n = match self.instance(g, acc) {
-            Some(n) => n,
-            None => self.group_node(g, acc)?,
-        };
-        if let Some(url) = url {
-            link(&mut n, &url);
-        }
-        Some(n)
-    }
-
-    /// The group of a `<use>` of a `<symbol>` → an instance of the symbol made from it (on its
-    /// first `<use>`). `None` when the group has to be plain art: it shows the symbol differently
-    /// (properties inherited from the `<use>`), or the canvas would paint the instance differently
-    /// under its transform (see [`Reuse`]), or its viewport cuts the art, or it filters.
-    fn instance(&mut self, g: &usvg::Group, acc: Affine) -> Option<Node> {
-        let sym = self.uses.get(g.id())?.clone();
-        if !g.filters().is_empty() {
-            return None;
-        }
-        // usvg puts the art in a group moved by the `<use>`'s position and the symbol's viewBox.
-        let ts = acc * aff(g.transform());
-        let (mut xf, mut inner) = (ts, g);
-        while let [usvg::Node::Group(s)] = inner.children()
-            && s.id().is_empty()
-            && is_plain(s)
-            && self.text_slot(s).is_none()
-        {
-            xf *= aff(s.transform());
-            inner = s;
-        }
-        let mut kids = self.children(inner, Affine::IDENTITY);
-        let art = match kids.len() {
-            0 => return None,
-            1 => Arc::unwrap_or_clone(kids.pop()?),
-            _ => self.named("", NodeKind::Group { children: kids, clip: false }),
-        };
-        // usvg clips a `<use>` of a symbol to its viewport: that only counts when it cuts the art.
-        let whole = g.clip_path().is_none_or(|cp| uncut(cp, ts, &art, xf));
-        let name = match self.symbols.get(&sym) {
-            Some(made) if whole && made.art == without_ids(&art) && made.reuse.allows(xf) => made.name.clone(),
-            Some(_) => return None,
-            None => {
-                let name = unique_name(self.name_of(&sym), |n| self.doc.symbols.iter().any(|s| s.name == n));
-                let reuse = Reuse::of(&self.doc, &art);
-                let made = SymbolMade { name: name.clone(), art: without_ids(&art), reuse };
-                self.doc.symbols.push(vectorcraft_doc::Symbol { name: name.clone(), art: Arc::new(art) });
-                self.symbols.insert(sym, made);
-                if !whole || !reuse.allows(xf) {
-                    return None;
-                }
-                name
-            }
-        };
-        let label = if made_up(g.id()) { "a symbol instance".to_string() } else { format!("'{}'", g.id()) };
-        let mask = g.mask().and_then(|m| self.opacity_mask(m, ts, &label));
-        let mut n = self.named(g.id(), NodeKind::SymbolInstance { symbol: name, xf });
-        n.opacity = g.opacity().get();
-        n.blend = blend(g.blend_mode());
-        n.isolate = g.isolate();
-        n.extras_mut().mask = mask;
-        Some(n)
-    }
-
-    /// The text a placeholder group stands for (see [`text`]) and the index of its main path.
-    fn text_slot(&self, g: &usvg::Group) -> Option<(usize, usize)> {
-        g.children().iter().enumerate().find_map(|(k, c)| match c {
-            usvg::Node::Path(p) => self.slots.find(p).map(|i| (i, k)),
-            _ => None,
-        })
-    }
-
-    /// A text placeholder group → its text object (nothing when the text is hidden).
-    fn text(&mut self, g: &usvg::Group, ts: Affine) -> Option<Vec<Arc<Node>>> {
-        let (i, main) = self.text_slot(g)?;
-        let kids = g.children();
-        if !matches!(kids.get(main), Some(usvg::Node::Path(p)) if p.is_visible()) {
-            return Some(vec![]);
-        }
-        let text::PendingText { name, mut obj, servers, paints, non_scaling, under, .. } = self.slots.texts.get(i)?.clone();
-        // The scale the type draws at becomes its size (last, below): text space grows by `grow`.
-        let xf = ts * obj.xf;
-        let grow = text::size_scale(&obj, xf);
-        // usvg resolved the `url(#…)` paints (the paths after the main one) in the element's user
-        // space; runs paint in text space.
-        let to_text = Affine::scale(grow) * obj.xf.inverse();
-        let slot_paint = |im: &mut Self, k: usize, m: Affine| match kids.get(main + 1 + k) {
-            Some(usvg::Node::Path(p)) => p.fill().map_or(Paint::None, |f| {
-                let area = kurbo::Shape::bounding_box(&bezpath(p.data(), m));
-                im.paint(f.paint(), m, Some(area))
-            }),
-            _ => Paint::None,
-        };
-        let resolved: Vec<Paint> = (0..paints).map(|k| slot_paint(self, k, to_text)).collect();
-        let server = |k: usize| resolved.get(k).cloned().unwrap_or(Paint::None);
-        for (run, (fill, stroke)) in obj.runs.iter_mut().zip(servers) {
-            if let Some(k) = fill {
-                run.style.fill = server(k);
-            }
-            if let Some(k) = stroke {
-                run.style.stroke = server(k);
-            }
-        }
-        obj.xf = xf;
-        if non_scaling && !vector_effect::unscale_text(&mut obj, self.screen) {
-            let label = if name.is_empty() || made_up(&name) { "a text".to_string() } else { format!("text '{name}'") };
-            self.warn(format!("non-scaling stroke on {label} approximated: the text is stretched or skewed"));
-        }
-        // A stroke under the characters is the object's own: it paints in the document.
-        let under = under.map(|(mut sl, k)| {
-            if let Some(k) = k {
-                sl.paint = slot_paint(self, k, ts);
-            }
-            let mut ap = Appearance { items: vec![AppearanceItem::Stroke(sl)], ..Default::default() };
-            ap.scale_strokes(if non_scaling { self.screen } else { obj.xf.determinant().abs().sqrt() });
-            ap.set_contents_at(1);
-            ap
-        });
-        text::fold_scale(&mut obj, grow);
-        let mut n = self.named(&name, NodeKind::Text(Box::new(obj)));
-        if let Some(ap) = under {
-            n.appearance = ap.into();
-        }
-        Some(vec![Arc::new(n)])
-    }
-
-    fn group_node(&mut self, g: &usvg::Group, acc: Affine) -> Option<Node> {
-        let ts = acc * aff(g.transform());
-        // A text placeholder becomes its text, named after the element (the group stays unnamed).
-        let text = self.text(g, ts);
-        if text.as_ref().is_some_and(Vec::is_empty) {
-            return None;
-        }
-        let is_text = text.is_some();
-        // Made-up ids aren't names.
-        let id = if is_text || made_up(g.id()) { "" } else { g.id() };
-        let label = match (&text, id) {
-            (Some(t), _) => t.first().and_then(|n| n.name.as_deref()).map_or_else(|| "a text".to_string(), |n| format!("text '{n}'")),
-            (None, "") => "a group".to_string(),
-            (None, id) => format!("'{id}'"),
-        };
-        let mask = g.mask().and_then(|m| self.opacity_mask(m, ts, &label));
-        // Blurs, shadows and glows become live effects (see [`fx`]).
-        let effects = match g.filters() {
-            [] => vec![],
-            filters => fx::effects(filters, ts, &self.blends).unwrap_or_else(|| {
-                // usvg wraps a filtered element in a group of its own: name the element then.
-                let on = match g.children() {
-                    [usvg::Node::Group(_)] | [] => label.clone(),
-                    [one] if made_up(g.id()) || g.id().is_empty() => {
-                        if one.id().is_empty() || made_up(one.id()) {
-                            "an object".to_string()
-                        } else {
-                            format!("'{}'", one.id())
-                        }
-                    }
-                    _ => label.clone(),
-                };
-                self.warn(format!("filter {} on {on} isn't supported; drawn without it", filter_names(filters)));
-                vec![]
-            }),
-        };
-        let mut children = match text {
-            Some(t) => t,
-            None => self.children(g, ts),
-        };
-        let mut n = if let Some(cp) = g.clip_path() {
-            // SVG filters before it clips: the effects go on the art inside the clip.
-            if !effects.is_empty() {
-                let mut inner = self.named("", NodeKind::Group { children, clip: false });
-                inner.appearance.effects = effects.clone();
-                children = vec![Arc::new(inner)];
-            }
-            let children = self.clipped(cp, ts, children, &label)?;
-            self.named(id, NodeKind::Group { children, clip: true })
-        } else {
-            if children.is_empty() {
-                return None;
-            }
-            // An id-less wrapper around a single object (usvg adds these for opacity/transform on
-            // shapes): fold its opacity, blend and effects into the object (unless the object
-            // blends or masks before the effects). A text takes its own mask too. A group with
-            // `data-*` or event attributes of its own stays a group, and keeps them.
-            let own = self.data.contains_key(g.id()) || self.events.contains_key(g.id());
-            if (is_text || id.is_empty() && mask.is_none() && !own)
-                && children.len() == 1
-                && (g.blend_mode() == usvg::BlendMode::Normal || children[0].blend == BlendMode::Normal)
-                && (effects.is_empty() || children[0].blend == BlendMode::Normal && children[0].extras().mask.is_none())
-                && let Some(only) = children.pop()
-            {
-                let mut c = Arc::unwrap_or_clone(only);
-                c.opacity *= g.opacity().get();
-                if g.blend_mode() != usvg::BlendMode::Normal {
-                    c.blend = blend(g.blend_mode());
-                }
-                c.isolate |= g.isolate();
-                if mask.is_some() {
-                    c.extras_mut().mask = mask;
-                }
-                c.appearance.effects.extend(effects);
-                return Some(c);
-            }
-            let mut n = self.named(id, NodeKind::Group { children, clip: false });
-            n.appearance.effects = effects;
-            n
-        };
-        n.opacity = g.opacity().get();
-        n.blend = blend(g.blend_mode());
-        n.isolate = g.isolate();
-        n.extras_mut().mask = mask;
-        if !is_text && self.sublayers.contains(g.id()) {
-            self.sublayer_groups.insert(n.id);
-        }
-        Some(n)
-    }
-
-    /// `<mask>` → opacity mask. An alpha mask's art comes in white with its opacity kept, so its
-    /// luminance is its alpha (images in it keep their colours, with a warning). A mask our export wrote gets its
-    /// options back ([`mask_flags`]) and its art without what stands for them: the inverting
-    /// filter group and the backdrop rectangle.
-    fn opacity_mask(&mut self, m: &usvg::Mask, ts: Affine, label: &str) -> Option<Box<vectorcraft_doc::OpacityMask>> {
-        if m.mask().is_some() {
-            self.warn(format!("nested mask on {label} ignored"));
-        }
-        let (clip, invert) = self.mask_flags.get(m.id()).copied().unwrap_or((true, false));
-        let (mut nodes, mut ts) = (m.root().children(), ts);
-        if invert
-            && let [usvg::Node::Group(g)] = nodes
-            && !g.filters().is_empty()
-        {
-            (nodes, ts) = (g.children(), ts * aff(g.transform()));
-        }
-        if (!clip || invert)
-            && let [usvg::Node::Path(_), rest @ ..] = nodes
-        {
-            nodes = rest;
-        }
-        let mut children: Vec<Arc<Node>> = nodes.iter().filter_map(|c| self.node(c, ts)).map(Arc::new).collect();
-        if m.kind() == usvg::MaskType::Alpha {
-            children.iter_mut().for_each(|c| vectorcraft_doc::node::whiten(Arc::make_mut(c)));
-            let mut image = false;
-            children.iter().for_each(|c| c.walk(&mut |n| image |= matches!(n.kind, NodeKind::Image(_))));
-            if image {
-                self.warn(format!("image in the alpha mask on {label} counts by its luminance"));
-            }
-        }
-        // Mask art that is all hidden draws nothing: that is an empty mask, not no mask (black all
-        // over when clipped, white when not, inverted when the mask is).
-        let art = match children.len() {
-            1 => Arc::unwrap_or_clone(children.pop()?),
-            _ => self.named("", NodeKind::Group { children, clip: false }),
-        };
-        let mut mask = vectorcraft_doc::OpacityMask::new(art, clip);
-        mask.invert = invert;
-        Some(Box::new(mask))
-    }
-
-    /// `children` clipped by `cp` (on an element whose user space `ts` maps to the document): the
-    /// children of a clip group or clipping layer, its clipping path first. A clip path clipped in
-    /// turn (`<clipPath clip-path>`) nests one clip group in another, so the clips intersect.
-    /// `None` when the clip path has no shape (nothing shows).
-    fn clipped(&mut self, cp: &usvg::ClipPath, ts: Affine, mut children: Vec<Arc<Node>>, label: &str) -> Option<Vec<Arc<Node>>> {
-        let mut clips = vec![self.clip_node(cp, ts)?];
-        let mut next = cp.clip_path();
-        while let Some(c) = next {
-            if clips.len() > MAX_CLIP_NEST {
-                self.warn(format!("clip paths nested more than {MAX_CLIP_NEST} deep on {label}: the deeper ones are ignored"));
-                break;
-            }
-            clips.push(self.clip_node(c, ts)?);
-            next = c.clip_path();
-        }
-        let outer = clips.pop()?;
-        for clip in clips {
-            let mut ch = vec![Arc::new(clip)];
-            ch.extend(children);
-            children = vec![Arc::new(self.named("", NodeKind::Group { children: ch, clip: true }))];
-        }
-        let mut ch = vec![Arc::new(outer)];
-        ch.extend(children);
-        Some(ch)
-    }
-
-    /// Put `art` in layer `l` at `index` (at most its end) unclipped: a clipping mask on the layer
-    /// becomes a clip group in it, holding the art it clipped.
-    fn add_unclipped(&mut self, l: &mut Node, index: usize, art: Vec<Arc<Node>>) {
-        if art.is_empty() {
-            return;
-        }
-        if let NodeKind::Layer { children, clip: clip @ true, .. } = &mut l.kind {
-            *clip = false;
-            let clipped = std::mem::take(children);
-            children.push(Arc::new(self.named("", NodeKind::Group { children: clipped, clip: true })));
-        }
-        if let Some(ch) = l.children_mut() {
-            let i = index.min(ch.len());
-            ch.splice(i..i, art);
-        }
-    }
-
-    fn clip_node(&mut self, cp: &usvg::ClipPath, ts: Affine) -> Option<Node> {
-        let shapes = clip_shapes(cp, ts);
-        if shapes.is_empty() {
-            return None;
-        }
-        let r = shapes[0].1;
-        let mut subs = Vec::new();
-        for (bp, _) in &shapes {
-            subs.extend(PathData::from_bezpath(bp).subpaths);
-        }
-        let id = cp.id().to_string();
-        if subs.len() == 1 {
-            let path = PathData::new(subs);
-            return Some(self.named(&id, NodeKind::Path { path, rule: r, live: None, clipping: true, guide: false }));
-        }
-        let children = subs
-            .into_iter()
-            .map(|sp| {
-                let nid = self.doc.alloc_id();
-                Arc::new(Node::new(nid, NodeKind::Path { path: PathData::single(sp), rule: r, live: None, clipping: false, guide: false }))
-            })
-            .collect();
-        Some(self.named(&id, NodeKind::Compound { children, rule: r }))
-    }
-
-    /// A usvg paint mapped by `m`, for art covering `area` (after `m`: where a reflected or
-    /// repeated gradient has to reach).
-    fn paint(&mut self, p: &usvg::Paint, m: Affine, area: Option<Rect>) -> Paint {
-        let (kind, base, mut geom) = match p {
-            usvg::Paint::Color(c) => return Paint::solid(Color::rgb8(c.red, c.green, c.blue)),
-            usvg::Paint::Pattern(pt) => return self.pattern(pt, m),
-            usvg::Paint::LinearGradient(lg) => {
-                let geom = GradientGeom {
-                    start: Point::new(lg.x1() as f64, lg.y1() as f64),
-                    end: Point::new(lg.x2() as f64, lg.y2() as f64),
-                    aspect: 1.0,
-                    focal: None,
-                };
-                let base: &usvg::BaseGradient = lg;
-                (GradientKind::Linear, base, geom)
-            }
-            usvg::Paint::RadialGradient(rg) => {
-                if rg.fr().get() > 1e-4 {
-                    self.warn(format!("gradient '{}': focal radius ignored", rg.id()));
-                }
-                let c = Point::new(rg.cx() as f64, rg.cy() as f64);
-                let mut geom = GradientGeom { start: c, end: c + Vec2::new(rg.r().get() as f64, 0.0), aspect: 1.0, focal: None };
-                // A focal point outside the circle is pulled inside it.
-                geom.set_focal(Some(Point::new(rg.fx() as f64, rg.fy() as f64)));
-                let base: &usvg::BaseGradient = rg;
-                (GradientKind::Radial, base, geom)
-            }
-        };
-        geom.transform(m * aff(base.transform()), kind);
-        let mut stops = self.stops(base);
-        let reflect = match base.spread_method() {
-            usvg::SpreadMethod::Pad => None,
-            usvg::SpreadMethod::Reflect => Some(true),
-            usvg::SpreadMethod::Repeat => Some(false),
-        };
-        if let Some(reflect) = reflect {
-            match area.map(|a| spread::expand(kind, &mut geom, &mut stops, reflect, a)) {
-                Some(spread::Expanded::Whole) => {}
-                Some(spread::Expanded::Capped) => {
-                    self.warn(format!("gradient '{}': spreadMethod repeats more than {} times; it pads after that", base.id(), spread::MAX_PERIODS))
-                }
-                None => self.warn(format!("gradient '{}': spreadMethod approximated as pad", base.id())),
-            }
-        }
-        Paint::Gradient(Box::new(GradientPaint {
-            gradient: Gradient::new(kind, stops),
-            geom: Some(geom),
-            angle: geom.angle_deg(),
-            swatch: None,
-            freeform: None,
-        }))
-    }
-
-    /// `<pattern>` → a pattern swatch painted with the pattern's tile placement. The swatch art is
-    /// the pattern content clipped to the tile, as SVG draws it.
-    fn pattern(&mut self, pt: &Arc<usvg::Pattern>, m: Affine) -> Paint {
-        let r = pt.rect();
-        let xf = m * aff(pt.transform()) * Affine::translate((r.x() as f64, r.y() as f64));
-        let key = Arc::as_ptr(pt) as usize;
-        if let Some(name) = self.patterns.get(&key) {
-            return Paint::Pattern { pattern: name.clone(), xf };
-        }
-        let tile = Rect::new(0.0, 0.0, r.width() as f64, r.height() as f64);
-        let content = self.children(pt.root(), aff(pt.root().transform()));
-        if content.is_empty() {
-            return Paint::None;
-        }
-        let clip =
-            self.named("", NodeKind::Path { path: shapes::rectangle(tile), rule: FillRule::NonZero, live: None, clipping: true, guide: false });
-        let mut children = vec![Arc::new(clip)];
-        children.extend(content);
-        let art = self.named("", NodeKind::Group { children, clip: true });
-        let base = if pt.id().is_empty() { "Pattern" } else { pt.id() };
-        let name = unique_name(base, |n| self.doc.pattern(n).is_some());
-        let mut def = PatternDef::new(&name, vec![Arc::new(art)]);
-        def.tile = tile;
-        self.doc.patterns.push(def);
-        self.patterns.insert(key, name.clone());
-        Paint::Pattern { pattern: name, xf }
-    }
-
-    /// The fill and stroke of `p` mapped by `m`; `area`: the bounds of the path after `m`.
-    fn appearance(&mut self, p: &usvg::Path, m: Affine, area: Option<Rect>) -> (Appearance, FillRule) {
-        let mut fill = None;
-        let mut r = FillRule::NonZero;
-        if let Some(f) = p.fill() {
-            let paint = self.paint(f.paint(), m, area);
-            let mut fl = FillLayer::new(paint);
-            fl.opacity = f.opacity().get();
-            r = rule(f.rule());
-            fill = Some(AppearanceItem::Fill(fl));
-        }
-        let mut stroke = None;
-        if let Some(s) = p.stroke() {
-            // A non-scaling stroke is as wide on screen whatever `m` does: the path takes `m`, so a
-            // stroke of that width in the document is exact.
-            let scale = if self.non_scaling.contains(p.id()) { self.screen } else { m.determinant().abs().sqrt() };
-            // The stroke reaches past the path (miters further: a generous margin).
-            let reach = s.width().get() as f64 * scale * (s.miterlimit().get() as f64).max(1.0);
-            let paint = self.paint(s.paint(), m, area.map(|a| a.inflate(reach, reach)));
-            let mut sl = StrokeLayer::new(paint, s.width().get() as f64 * scale);
-            sl.opacity = s.opacity().get();
-            sl.cap = match s.linecap() {
-                usvg::LineCap::Butt => LineCap::Butt,
-                usvg::LineCap::Round => LineCap::Round,
-                usvg::LineCap::Square => LineCap::Square,
-            };
-            sl.join = match s.linejoin() {
-                usvg::LineJoin::Miter | usvg::LineJoin::MiterClip => LineJoin::Miter,
-                usvg::LineJoin::Round => LineJoin::Round,
-                usvg::LineJoin::Bevel => LineJoin::Bevel,
-            };
-            sl.miter_limit = s.miterlimit().get() as f64;
-            if let Some(d) = s.dasharray() {
-                sl.dash = Some(Dash {
-                    pattern: d.iter().map(|v| *v as f64 * scale).collect(),
-                    offset: s.dashoffset() as f64 * scale,
-                    align_corners: false,
-                });
-            }
-            stroke = Some(AppearanceItem::Stroke(sl));
-        }
-        let items = match p.paint_order() {
-            usvg::PaintOrder::FillAndStroke => [fill, stroke],
-            usvg::PaintOrder::StrokeAndFill => [stroke, fill],
-        };
-        (Appearance { items: items.into_iter().flatten().collect(), ..Default::default() }, r)
-    }
-
-    fn path(&mut self, p: &usvg::Path, acc: Affine) -> Option<Node> {
-        if !p.is_visible() {
-            return None;
-        }
-        let path = PathData::from_bezpath(&bezpath(p.data(), acc));
-        if path.is_empty() {
-            return None;
-        }
-        let (appearance, r) = self.appearance(p, acc, path.bounds());
-        // Shared, so a compound path's subpaths don't each copy a gradient's stops.
-        let appearance: vectorcraft_doc::Shared<Appearance> = appearance.into();
-        let mut n = if path.subpaths.len() > 1 {
-            // Multi-subpath SVG paths are compound paths (as in Illustrator).
-            let children = path
-                .subpaths
-                .into_iter()
-                .map(|sp| {
-                    let id = self.doc.alloc_id();
-                    let mut c = Node::new(id, NodeKind::Path { path: PathData::single(sp), rule: r, live: None, clipping: false, guide: false });
-                    c.appearance = appearance.clone();
-                    Arc::new(c)
-                })
-                .collect();
-            self.named(p.id(), NodeKind::Compound { children, rule: r })
-        } else {
-            self.named(p.id(), NodeKind::Path { path, rule: r, live: None, clipping: false, guide: false })
-        };
-        n.appearance = appearance;
-        Some(n)
-    }
-
-    fn image(&mut self, i: &usvg::Image, acc: Affine) -> Option<Node> {
-        if !i.is_visible() {
-            return None;
-        }
-        let (bytes, mime) = match i.kind() {
-            usvg::ImageKind::JPEG(d) => (d, "image/jpeg"),
-            usvg::ImageKind::PNG(d) => (d, "image/png"),
-            usvg::ImageKind::GIF(d) => (d, "image/gif"),
-            usvg::ImageKind::WEBP(d) => (d, "image/webp"),
-            usvg::ImageKind::SVG(tree) => return self.svg_image(tree, acc),
-        };
-        let size = i.size();
-        let (pw, ph) = image::ImageReader::new(std::io::Cursor::new(&bytes[..]))
-            .with_guessed_format()
-            .ok()
-            .and_then(|r| r.into_dimensions().ok())
-            .unwrap_or((size.width().round().max(1.0) as u32, size.height().round().max(1.0) as u32));
-        let key = format!("img-{:016x}", fnv1a(bytes));
-        // A linked file keeps a preview; a placeholder is all a missing one has (its preview).
-        let linked = self.files.linked(i.kind());
-        let missing = linked.is_some_and(|l| l.missing);
-        let link = linked.map(|l| l.link.clone());
-        self.doc.images.entry(key.clone()).or_insert_with(|| {
-            let blob = ImageBlob { mime: mime.into(), bytes: bytes.clone(), proxy: missing.then(|| bytes.clone()) };
-            if link.is_some() && !missing { blob.with_proxy() } else { blob }
-        });
-        let xf = acc * Affine::scale_non_uniform(size.width() as f64 / pw as f64, size.height() as f64 / ph as f64);
-        Some(self.named(
-            i.id(),
-            NodeKind::Image(Box::new(ImageObject { key, width: pw, height: ph, xf, link, placement: Default::default(), pixels: None })),
-        ))
-    }
-
-    /// An SVG shown as an image (a data URL or a linked file) → its art, `acc` mapping its size.
-    /// Its ids are its own: they mean nothing in the SVG around it.
-    fn svg_image(&mut self, tree: &usvg::Tree, acc: Affine) -> Option<Node> {
-        let outer = (
-            std::mem::take(&mut self.links),
-            std::mem::take(&mut self.hidden),
-            std::mem::take(&mut self.uses),
-            std::mem::take(&mut self.labels),
-            std::mem::take(&mut self.non_scaling),
-            std::mem::take(&mut self.data),
-            std::mem::take(&mut self.events),
-        );
-        let art = self.group_node(tree.root(), acc);
-        (self.links, self.hidden, self.uses, self.labels, self.non_scaling, self.data, self.events) = outer;
-        art
-    }
-}
diff --git a/crates/svg/src/import/convert.rs b/crates/svg/src/import/convert.rs
new file mode 100644
index 000000000..18e8b756b
--- /dev/null
+++ b/crates/svg/src/import/convert.rs
@@ -0,0 +1,174 @@
+use super::*;
+
+/// `n` with every object id (its descendants' and its mask art's too) zeroed, to compare art.
+pub(super) fn without_ids(n: &Node) -> Node {
+    let mut n = n.clone();
+    n.id = vectorcraft_doc::NodeId(0);
+    if let Some(m) = n.extras_if_any().and_then(|e| e.mask.as_deref_mut()) {
+        m.art = Arc::new(without_ids(&m.art));
+    }
+    for c in n.children_mut().into_iter().flatten() {
+        *c = Arc::new(without_ids(c));
+    }
+    n
+}
+
+/// `base`, or `base 2`, `base 3`… : the first that isn't `taken`.
+pub(super) fn unique_name(base: &str, taken: impl Fn(&str) -> bool) -> String {
+    let mut name = base.to_string();
+    let mut k = 2;
+    while taken(&name) {
+        name = format!("{base} {k}");
+        k += 1;
+    }
+    name
+}
+
+/// The stops our export added for midpoints (`data-vc-midpoint`), by gradient id: for each stop,
+/// the midpoint it stands for.
+pub(super) fn midpoint_stops(xml: &roxmltree::Document) -> HashMap<String, Vec<Option<f32>>> {
+    xml.descendants()
+        .filter(|n| matches!(n.tag_name().name(), "linearGradient" | "radialGradient"))
+        .filter_map(|g| {
+            let id = g.attribute("id")?;
+            let marks: Vec<Option<f32>> = g
+                .children()
+                .filter(|c| c.tag_name().name() == "stop")
+                .map(|c| c.attribute("data-vc-midpoint").and_then(|v| v.parse().ok()))
+                .collect();
+            marks.iter().any(Option::is_some).then(|| (id.to_string(), marks))
+        })
+        .collect()
+}
+
+/// A gradient's stops, with the midpoint stops `marks` names folded back into the midpoints of
+/// the stops before them.
+pub(super) fn gradient_stops(g: &usvg::BaseGradient, marks: Option<&[Option<f32>]>) -> Vec<GradientStop> {
+    let marks = marks.filter(|m| m.len() == g.stops().len());
+    let mut out: Vec<GradientStop> = Vec::with_capacity(g.stops().len());
+    for (i, s) in g.stops().iter().enumerate() {
+        if let (Some(mid), Some(prev)) = (marks.and_then(|m| m.get(i).copied().flatten()), out.last_mut()) {
+            prev.midpoint = mid.clamp(0.0, 1.0);
+            continue;
+        }
+        let c = s.color();
+        out.push(GradientStop { opacity: s.opacity().get(), ..GradientStop::new(s.offset().get(), Color::rgb8(c.red, c.green, c.blue)) });
+    }
+    out
+}
+
+/// The options [`crate::export::MASK_FLAGS`] records on exported `<mask>` elements, by mask id:
+/// (clip, invert).
+pub(super) fn mask_flags(xml: &roxmltree::Document) -> HashMap<String, (bool, bool)> {
+    let attr = crate::export::MASK_FLAGS;
+    if !xml.input_text().contains(attr) {
+        return HashMap::new();
+    }
+    let flags = |n: roxmltree::Node| {
+        let has = |f: &str| n.attribute(attr).is_some_and(|v| v.split_whitespace().any(|x| x == f));
+        Some((n.attribute("id")?.to_string(), (!has("noclip"), has("invert"))))
+    };
+    xml.descendants().filter(|n| n.tag_name().name() == "mask" && n.has_attribute(attr)).filter_map(flags).collect()
+}
+
+/// Prefix of the ids [`prepass`] gives the elements it has to find again that have none.
+pub(super) const MADE_UP_ID: &str = "vectorcraft-id-";
+
+/// Is `id` one [`prepass`] made up (not a name)?
+pub(super) fn made_up(id: &str) -> bool {
+    id.starts_with(MADE_UP_ID)
+}
+
+/// The URL an `<a>` element links to.
+pub(crate) fn href<'a>(a: XNode<'a, '_>) -> Option<&'a str> {
+    a.attribute("href").or_else(|| a.attribute(("http://www.w3.org/1999/xlink", "href"))).filter(|h| !h.is_empty())
+}
+
+pub(super) fn aff(t: usvg::Transform) -> Affine {
+    Affine::new([t.sx as f64, t.ky as f64, t.kx as f64, t.sy as f64, t.tx as f64, t.ty as f64])
+}
+
+pub(super) fn is_plain(g: &usvg::Group) -> bool {
+    g.clip_path().is_none() && only_clips(g)
+}
+
+/// Does group `g` leave its art as it is, but for a clip path (no mask, filter, opacity or blend)?
+pub(super) fn only_clips(g: &usvg::Group) -> bool {
+    g.mask().is_none() && g.filters().is_empty() && g.opacity().get() >= 1.0 && g.blend_mode() == usvg::BlendMode::Normal
+}
+
+pub(super) fn blend(b: usvg::BlendMode) -> BlendMode {
+    use usvg::BlendMode as B;
+    match b {
+        B::Normal => BlendMode::Normal,
+        B::Multiply => BlendMode::Multiply,
+        B::Screen => BlendMode::Screen,
+        B::Overlay => BlendMode::Overlay,
+        B::Darken => BlendMode::Darken,
+        B::Lighten => BlendMode::Lighten,
+        B::ColorDodge => BlendMode::ColorDodge,
+        B::ColorBurn => BlendMode::ColorBurn,
+        B::HardLight => BlendMode::HardLight,
+        B::SoftLight => BlendMode::SoftLight,
+        B::Difference => BlendMode::Difference,
+        B::Exclusion => BlendMode::Exclusion,
+        B::Hue => BlendMode::Hue,
+        B::Saturation => BlendMode::Saturation,
+        B::Color => BlendMode::Color,
+        B::Luminosity => BlendMode::Luminosity,
+    }
+}
+
+pub(super) fn bezpath(p: &usvg::tiny_skia_path::Path, m: Affine) -> BezPath {
+    use usvg::tiny_skia_path::PathSegment as S;
+    let pt = |p: usvg::tiny_skia_path::Point| m * Point::new(p.x as f64, p.y as f64);
+    let mut bp = BezPath::new();
+    for s in p.segments() {
+        match s {
+            S::MoveTo(p) => bp.move_to(pt(p)),
+            S::LineTo(p) => bp.line_to(pt(p)),
+            S::QuadTo(a, p) => bp.quad_to(pt(a), pt(p)),
+            S::CubicTo(a, b, p) => bp.curve_to(pt(a), pt(b), pt(p)),
+            S::Close => bp.close_path(),
+        }
+    }
+    bp
+}
+
+/// The shapes of clip path `cp` on an element whose user space `ts` maps to the document.
+pub(super) fn clip_shapes(cp: &usvg::ClipPath, ts: Affine) -> Vec<(BezPath, FillRule)> {
+    fn collect(g: &usvg::Group, m: Affine, out: &mut Vec<(BezPath, FillRule)>) {
+        for c in g.children() {
+            match c {
+                usvg::Node::Group(g) => collect(g, m * aff(g.transform()), out),
+                usvg::Node::Path(p) => out.push((bezpath(p.data(), m), p.fill().map(|f| rule(f.rule())).unwrap_or_default())),
+                _ => {}
+            }
+        }
+    }
+    let mut shapes = Vec::new();
+    collect(cp.root(), ts * aff(cp.transform()), &mut shapes);
+    shapes
+}
+
+/// Does clip path `cp` (on an element whose user space `ts` maps to the document) leave `art`,
+/// placed by `xf`, whole? (Only its bounds are checked: the box must be inside a clip shape.)
+pub(super) fn uncut(cp: &usvg::ClipPath, ts: Affine, art: &Node, xf: Affine) -> bool {
+    let Some(b) = art.visual_bounds() else { return false };
+    if cp.clip_path().is_some() {
+        return false;
+    }
+    // Art touching the clip's edge isn't cut by it.
+    let e = 1e-6 * (b.width() + b.height()).max(1e-9);
+    let b = b.inflate(-e, -e);
+    let shapes = clip_shapes(cp, ts);
+    let corners = [Point::new(b.x0, b.y0), Point::new(b.x1, b.y0), Point::new(b.x1, b.y1), Point::new(b.x0, b.y1)];
+    corners.iter().all(|c| shapes.iter().any(|(s, _)| kurbo::Shape::contains(s, xf * *c)))
+}
+
+pub(super) fn rule(r: usvg::FillRule) -> FillRule {
+    match r {
+        usvg::FillRule::NonZero => FillRule::NonZero,
+        usvg::FillRule::EvenOdd => FillRule::EvenOdd,
+    }
+}
diff --git a/crates/svg/src/import/importer.rs b/crates/svg/src/import/importer.rs
new file mode 100644
index 000000000..f487eb4ee
--- /dev/null
+++ b/crates/svg/src/import/importer.rs
@@ -0,0 +1,641 @@
+use super::convert::{aff, bezpath, blend, clip_shapes, gradient_stops, is_plain, made_up, rule, uncut, unique_name, without_ids};
+use super::layers::filter_names;
+use super::prepass::link;
+use super::*;
+
+/// How many clip paths deep (`<clipPath clip-path>`) an object's clip is read.
+const MAX_CLIP_NEST: usize = 16;
+
+/// Points per inch.
+pub(crate) const PT_PER_IN: f64 = 72.0;
+
+/// CSS pixels per inch.
+pub(super) const CSS_PX_PER_IN: f64 = 96.0;
+
+/// A `<symbol>` made a symbol: its name, its art with no object ids (what each `<use>` has to show
+/// to be an instance of it) and the instance transforms the art can stand for.
+pub(super) struct SymbolMade {
+    name: String,
+    art: Node,
+    reuse: Reuse,
+}
+
+impl Importer {
+    pub(super) fn warn(&mut self, s: String) {
+        if !self.warnings.contains(&s) {
+            self.warnings.push(s);
+        }
+    }
+
+    /// The child of `g` when it's all `g` holds and only wraps art: an id-less group that leaves
+    /// it as it is (but for a transform) and isn't a text.
+    pub(super) fn wrapper<'g>(&self, g: &'g usvg::Group) -> Option<&'g usvg::Group> {
+        match g.children() {
+            [usvg::Node::Group(w)] if w.id().is_empty() && is_plain(w) && self.text_slot(w).is_none() => Some(w),
+            _ => None,
+        }
+    }
+
+    pub(super) fn children(&mut self, g: &usvg::Group, acc: Affine) -> Vec<Arc<Node>> {
+        g.children().iter().filter_map(|c| self.node(c, acc)).map(Arc::new).collect()
+    }
+
+    /// The object usvg node `n` makes under transform `acc`, with what the file kept on its element
+    /// (data, event and other applications' attributes); `None` for what imports as nothing.
+    pub(super) fn node(&mut self, n: &usvg::Node, acc: Affine) -> Option<Node> {
+        let mut out = match n {
+            usvg::Node::Group(g) => self.group(g, acc),
+            usvg::Node::Path(p) => self.path(p, acc),
+            usvg::Node::Image(i) => self.image(i, acc),
+            // Only present when usvg had fonts; text is read from the XML instead.
+            usvg::Node::Text(_) => None,
+        }?;
+        if self.hidden.contains(n.id()) {
+            out.visible = false;
+        }
+        self.keep_data(n.id(), &mut out);
+        self.keep_events(n.id(), &mut out);
+        self.keep_foreign(n.id(), &mut out);
+        Some(out)
+    }
+
+    /// Give `n` the `data-*` attributes of element `id`, unless it has data already (what an
+    /// inner element made of it keeps).
+    pub(super) fn keep_data(&self, id: &str, n: &mut Node) {
+        if let Some(data) = self.data.get(id).filter(|_| n.extras().attrs.as_ref().is_none_or(|a| a.data.is_empty())) {
+            n.edit_attrs(|a| a.data = data.clone());
+        }
+    }
+
+    /// Give `n` the event attributes of element `id`, unless it has events already (what an inner
+    /// element made of it keeps).
+    pub(super) fn keep_events(&self, id: &str, n: &mut Node) {
+        if let Some(events) = self.events.get(id).filter(|_| n.extras().attrs.as_ref().is_none_or(|a| a.events.is_empty())) {
+            n.edit_attrs(|a| a.events = events.clone());
+        }
+    }
+
+    /// Give `n` the attributes of element `id` in other applications' namespaces, unless it has
+    /// some already (what an inner element made of it keeps).
+    pub(super) fn keep_foreign(&self, id: &str, n: &mut Node) {
+        if let Some(kept) = self.foreign.get(id).filter(|_| n.extras().attrs.as_ref().is_none_or(|a| a.foreign.is_empty())) {
+            n.edit_attrs(|a| a.foreign = kept.clone());
+        }
+    }
+
+    /// A gradient's stops, midpoints restored.
+    fn stops(&self, g: &usvg::BaseGradient) -> Vec<GradientStop> {
+        gradient_stops(g, self.midpoints.get(g.id()).map(Vec::as_slice))
+    }
+
+    /// The object name for an element id: its label (see [`labels`]), else the id itself.
+    pub(super) fn name_of<'a>(&'a self, id: &'a str) -> &'a str {
+        self.labels.get(id).map_or(id, String::as_str)
+    }
+
+    /// A new object named after element `id` (unless it has none or a made-up one).
+    fn named(&mut self, id: &str, kind: NodeKind) -> Node {
+        let nid = self.doc.alloc_id();
+        let mut n = Node::new(nid, kind);
+        if !id.is_empty() && !made_up(id) {
+            n.name = Some(self.name_of(id).to_string());
+        }
+        n
+    }
+
+    fn group(&mut self, g: &usvg::Group, acc: Affine) -> Option<Node> {
+        let url = self.links.get(g.id()).cloned();
+        let mut n = match self.instance(g, acc) {
+            Some(n) => n,
+            None => self.group_node(g, acc)?,
+        };
+        if let Some(url) = url {
+            link(&mut n, &url);
+        }
+        Some(n)
+    }
+
+    /// The group of a `<use>` of a `<symbol>` → an instance of the symbol made from it (on its
+    /// first `<use>`). `None` when the group has to be plain art: it shows the symbol differently
+    /// (properties inherited from the `<use>`), or the canvas would paint the instance differently
+    /// under its transform (see [`Reuse`]), or its viewport cuts the art, or it filters.
+    fn instance(&mut self, g: &usvg::Group, acc: Affine) -> Option<Node> {
+        let sym = self.uses.get(g.id())?.clone();
+        if !g.filters().is_empty() {
+            return None;
+        }
+        // usvg puts the art in a group moved by the `<use>`'s position and the symbol's viewBox.
+        let ts = acc * aff(g.transform());
+        let (mut xf, mut inner) = (ts, g);
+        while let [usvg::Node::Group(s)] = inner.children()
+            && s.id().is_empty()
+            && is_plain(s)
+            && self.text_slot(s).is_none()
+        {
+            xf *= aff(s.transform());
+            inner = s;
+        }
+        let mut kids = self.children(inner, Affine::IDENTITY);
+        let art = match kids.len() {
+            0 => return None,
+            1 => Arc::unwrap_or_clone(kids.pop()?),
+            _ => self.named("", NodeKind::Group { children: kids, clip: false }),
+        };
+        // usvg clips a `<use>` of a symbol to its viewport: that only counts when it cuts the art.
+        let whole = g.clip_path().is_none_or(|cp| uncut(cp, ts, &art, xf));
+        let name = match self.symbols.get(&sym) {
+            Some(made) if whole && made.art == without_ids(&art) && made.reuse.allows(xf) => made.name.clone(),
+            Some(_) => return None,
+            None => {
+                let name = unique_name(self.name_of(&sym), |n| self.doc.symbols.iter().any(|s| s.name == n));
+                let reuse = Reuse::of(&self.doc, &art);
+                let made = SymbolMade { name: name.clone(), art: without_ids(&art), reuse };
+                self.doc.symbols.push(vectorcraft_doc::Symbol { name: name.clone(), art: Arc::new(art) });
+                self.symbols.insert(sym, made);
+                if !whole || !reuse.allows(xf) {
+                    return None;
+                }
+                name
+            }
+        };
+        let label = if made_up(g.id()) { "a symbol instance".to_string() } else { format!("'{}'", g.id()) };
+        let mask = g.mask().and_then(|m| self.opacity_mask(m, ts, &label));
+        let mut n = self.named(g.id(), NodeKind::SymbolInstance { symbol: name, xf });
+        n.opacity = g.opacity().get();
+        n.blend = blend(g.blend_mode());
+        n.isolate = g.isolate();
+        n.extras_mut().mask = mask;
+        Some(n)
+    }
+
+    /// The text a placeholder group stands for (see [`text`]) and the index of its main path.
+    pub(super) fn text_slot(&self, g: &usvg::Group) -> Option<(usize, usize)> {
+        g.children().iter().enumerate().find_map(|(k, c)| match c {
+            usvg::Node::Path(p) => self.slots.find(p).map(|i| (i, k)),
+            _ => None,
+        })
+    }
+
+    /// A text placeholder group → its text object (nothing when the text is hidden).
+    fn text(&mut self, g: &usvg::Group, ts: Affine) -> Option<Vec<Arc<Node>>> {
+        let (i, main) = self.text_slot(g)?;
+        let kids = g.children();
+        if !matches!(kids.get(main), Some(usvg::Node::Path(p)) if p.is_visible()) {
+            return Some(vec![]);
+        }
+        let text::PendingText { name, mut obj, servers, paints, non_scaling, under, .. } = self.slots.texts.get(i)?.clone();
+        // The scale the type draws at becomes its size (last, below): text space grows by `grow`.
+        let xf = ts * obj.xf;
+        let grow = text::size_scale(&obj, xf);
+        // usvg resolved the `url(#…)` paints (the paths after the main one) in the element's user
+        // space; runs paint in text space.
+        let to_text = Affine::scale(grow) * obj.xf.inverse();
+        let slot_paint = |im: &mut Self, k: usize, m: Affine| match kids.get(main + 1 + k) {
+            Some(usvg::Node::Path(p)) => p.fill().map_or(Paint::None, |f| {
+                let area = kurbo::Shape::bounding_box(&bezpath(p.data(), m));
+                im.paint(f.paint(), m, Some(area))
+            }),
+            _ => Paint::None,
+        };
+        let resolved: Vec<Paint> = (0..paints).map(|k| slot_paint(self, k, to_text)).collect();
+        let server = |k: usize| resolved.get(k).cloned().unwrap_or(Paint::None);
+        for (run, (fill, stroke)) in obj.runs.iter_mut().zip(servers) {
+            if let Some(k) = fill {
+                run.style.fill = server(k);
+            }
+            if let Some(k) = stroke {
+                run.style.stroke = server(k);
+            }
+        }
+        obj.xf = xf;
+        if non_scaling && !vector_effect::unscale_text(&mut obj, self.screen) {
+            let label = if name.is_empty() || made_up(&name) { "a text".to_string() } else { format!("text '{name}'") };
+            self.warn(format!("non-scaling stroke on {label} approximated: the text is stretched or skewed"));
+        }
+        // A stroke under the characters is the object's own: it paints in the document.
+        let under = under.map(|(mut sl, k)| {
+            if let Some(k) = k {
+                sl.paint = slot_paint(self, k, ts);
+            }
+            let mut ap = Appearance { items: vec![AppearanceItem::Stroke(sl)], ..Default::default() };
+            ap.scale_strokes(if non_scaling { self.screen } else { obj.xf.determinant().abs().sqrt() });
+            ap.set_contents_at(1);
+            ap
+        });
+        text::fold_scale(&mut obj, grow);
+        let mut n = self.named(&name, NodeKind::Text(Box::new(obj)));
+        if let Some(ap) = under {
+            n.appearance = ap.into();
+        }
+        Some(vec![Arc::new(n)])
+    }
+
+    fn group_node(&mut self, g: &usvg::Group, acc: Affine) -> Option<Node> {
+        let ts = acc * aff(g.transform());
+        // A text placeholder becomes its text, named after the element (the group stays unnamed).
+        let text = self.text(g, ts);
+        if text.as_ref().is_some_and(Vec::is_empty) {
+            return None;
+        }
+        let is_text = text.is_some();
+        // Made-up ids aren't names.
+        let id = if is_text || made_up(g.id()) { "" } else { g.id() };
+        let label = match (&text, id) {
+            (Some(t), _) => t.first().and_then(|n| n.name.as_deref()).map_or_else(|| "a text".to_string(), |n| format!("text '{n}'")),
+            (None, "") => "a group".to_string(),
+            (None, id) => format!("'{id}'"),
+        };
+        let mask = g.mask().and_then(|m| self.opacity_mask(m, ts, &label));
+        // Blurs, shadows and glows become live effects (see [`fx`]).
+        let effects = match g.filters() {
+            [] => vec![],
+            filters => fx::effects(filters, ts, &self.blends).unwrap_or_else(|| {
+                // usvg wraps a filtered element in a group of its own: name the element then.
+                let on = match g.children() {
+                    [usvg::Node::Group(_)] | [] => label.clone(),
+                    [one] if made_up(g.id()) || g.id().is_empty() => {
+                        if one.id().is_empty() || made_up(one.id()) {
+                            "an object".to_string()
+                        } else {
+                            format!("'{}'", one.id())
+                        }
+                    }
+                    _ => label.clone(),
+                };
+                self.warn(format!("filter {} on {on} isn't supported; drawn without it", filter_names(filters)));
+                vec![]
+            }),
+        };
+        let mut children = match text {
+            Some(t) => t,
+            None => self.children(g, ts),
+        };
+        let mut n = if let Some(cp) = g.clip_path() {
+            // SVG filters before it clips: the effects go on the art inside the clip.
+            if !effects.is_empty() {
+                let mut inner = self.named("", NodeKind::Group { children, clip: false });
+                inner.appearance.effects = effects.clone();
+                children = vec![Arc::new(inner)];
+            }
+            let children = self.clipped(cp, ts, children, &label)?;
+            self.named(id, NodeKind::Group { children, clip: true })
+        } else {
+            if children.is_empty() {
+                return None;
+            }
+            // An id-less wrapper around a single object (usvg adds these for opacity/transform on
+            // shapes): fold its opacity, blend and effects into the object (unless the object
+            // blends or masks before the effects). A text takes its own mask too. A group with
+            // `data-*` or event attributes of its own stays a group, and keeps them.
+            let own = self.data.contains_key(g.id()) || self.events.contains_key(g.id());
+            if (is_text || id.is_empty() && mask.is_none() && !own)
+                && children.len() == 1
+                && (g.blend_mode() == usvg::BlendMode::Normal || children[0].blend == BlendMode::Normal)
+                && (effects.is_empty() || children[0].blend == BlendMode::Normal && children[0].extras().mask.is_none())
+                && let Some(only) = children.pop()
+            {
+                let mut c = Arc::unwrap_or_clone(only);
+                c.opacity *= g.opacity().get();
+                if g.blend_mode() != usvg::BlendMode::Normal {
+                    c.blend = blend(g.blend_mode());
+                }
+                c.isolate |= g.isolate();
+                if mask.is_some() {
+                    c.extras_mut().mask = mask;
+                }
+                c.appearance.effects.extend(effects);
+                return Some(c);
+            }
+            let mut n = self.named(id, NodeKind::Group { children, clip: false });
+            n.appearance.effects = effects;
+            n
+        };
+        n.opacity = g.opacity().get();
+        n.blend = blend(g.blend_mode());
+        n.isolate = g.isolate();
+        n.extras_mut().mask = mask;
+        if !is_text && self.sublayers.contains(g.id()) {
+            self.sublayer_groups.insert(n.id);
+        }
+        Some(n)
+    }
+
+    /// `<mask>` → opacity mask. An alpha mask's art comes in white with its opacity kept, so its
+    /// luminance is its alpha (images in it keep their colours, with a warning). A mask our export wrote gets its
+    /// options back ([`mask_flags`]) and its art without what stands for them: the inverting
+    /// filter group and the backdrop rectangle.
+    fn opacity_mask(&mut self, m: &usvg::Mask, ts: Affine, label: &str) -> Option<Box<vectorcraft_doc::OpacityMask>> {
+        if m.mask().is_some() {
+            self.warn(format!("nested mask on {label} ignored"));
+        }
+        let (clip, invert) = self.mask_flags.get(m.id()).copied().unwrap_or((true, false));
+        let (mut nodes, mut ts) = (m.root().children(), ts);
+        if invert
+            && let [usvg::Node::Group(g)] = nodes
+            && !g.filters().is_empty()
+        {
+            (nodes, ts) = (g.children(), ts * aff(g.transform()));
+        }
+        if (!clip || invert)
+            && let [usvg::Node::Path(_), rest @ ..] = nodes
+        {
+            nodes = rest;
+        }
+        let mut children: Vec<Arc<Node>> = nodes.iter().filter_map(|c| self.node(c, ts)).map(Arc::new).collect();
+        if m.kind() == usvg::MaskType::Alpha {
+            children.iter_mut().for_each(|c| vectorcraft_doc::node::whiten(Arc::make_mut(c)));
+            let mut image = false;
+            children.iter().for_each(|c| c.walk(&mut |n| image |= matches!(n.kind, NodeKind::Image(_))));
+            if image {
+                self.warn(format!("image in the alpha mask on {label} counts by its luminance"));
+            }
+        }
+        // Mask art that is all hidden draws nothing: that is an empty mask, not no mask (black all
+        // over when clipped, white when not, inverted when the mask is).
+        let art = match children.len() {
+            1 => Arc::unwrap_or_clone(children.pop()?),
+            _ => self.named("", NodeKind::Group { children, clip: false }),
+        };
+        let mut mask = vectorcraft_doc::OpacityMask::new(art, clip);
+        mask.invert = invert;
+        Some(Box::new(mask))
+    }
+
+    /// `children` clipped by `cp` (on an element whose user space `ts` maps to the document): the
+    /// children of a clip group or clipping layer, its clipping path first. A clip path clipped in
+    /// turn (`<clipPath clip-path>`) nests one clip group in another, so the clips intersect.
+    /// `None` when the clip path has no shape (nothing shows).
+    pub(super) fn clipped(&mut self, cp: &usvg::ClipPath, ts: Affine, mut children: Vec<Arc<Node>>, label: &str) -> Option<Vec<Arc<Node>>> {
+        let mut clips = vec![self.clip_node(cp, ts)?];
+        let mut next = cp.clip_path();
+        while let Some(c) = next {
+            if clips.len() > MAX_CLIP_NEST {
+                self.warn(format!("clip paths nested more than {MAX_CLIP_NEST} deep on {label}: the deeper ones are ignored"));
+                break;
+            }
+            clips.push(self.clip_node(c, ts)?);
+            next = c.clip_path();
+        }
+        let outer = clips.pop()?;
+        for clip in clips {
+            let mut ch = vec![Arc::new(clip)];
+            ch.extend(children);
+            children = vec![Arc::new(self.named("", NodeKind::Group { children: ch, clip: true }))];
+        }
+        let mut ch = vec![Arc::new(outer)];
+        ch.extend(children);
+        Some(ch)
+    }
+
+    /// Put `art` in layer `l` at `index` (at most its end) unclipped: a clipping mask on the layer
+    /// becomes a clip group in it, holding the art it clipped.
+    pub(super) fn add_unclipped(&mut self, l: &mut Node, index: usize, art: Vec<Arc<Node>>) {
+        if art.is_empty() {
+            return;
+        }
+        if let NodeKind::Layer { children, clip: clip @ true, .. } = &mut l.kind {
+            *clip = false;
+            let clipped = std::mem::take(children);
+            children.push(Arc::new(self.named("", NodeKind::Group { children: clipped, clip: true })));
+        }
+        if let Some(ch) = l.children_mut() {
+            let i = index.min(ch.len());
+            ch.splice(i..i, art);
+        }
+    }
+
+    fn clip_node(&mut self, cp: &usvg::ClipPath, ts: Affine) -> Option<Node> {
+        let shapes = clip_shapes(cp, ts);
+        if shapes.is_empty() {
+            return None;
+        }
+        let r = shapes[0].1;
+        let mut subs = Vec::new();
+        for (bp, _) in &shapes {
+            subs.extend(PathData::from_bezpath(bp).subpaths);
+        }
+        let id = cp.id().to_string();
+        if subs.len() == 1 {
+            let path = PathData::new(subs);
+            return Some(self.named(&id, NodeKind::Path { path, rule: r, live: None, clipping: true, guide: false }));
+        }
+        let children = subs
+            .into_iter()
+            .map(|sp| {
+                let nid = self.doc.alloc_id();
+                Arc::new(Node::new(nid, NodeKind::Path { path: PathData::single(sp), rule: r, live: None, clipping: false, guide: false }))
+            })
+            .collect();
+        Some(self.named(&id, NodeKind::Compound { children, rule: r }))
+    }
+
+    /// A usvg paint mapped by `m`, for art covering `area` (after `m`: where a reflected or
+    /// repeated gradient has to reach).
+    fn paint(&mut self, p: &usvg::Paint, m: Affine, area: Option<Rect>) -> Paint {
+        let (kind, base, mut geom) = match p {
+            usvg::Paint::Color(c) => return Paint::solid(Color::rgb8(c.red, c.green, c.blue)),
+            usvg::Paint::Pattern(pt) => return self.pattern(pt, m),
+            usvg::Paint::LinearGradient(lg) => {
+                let geom = GradientGeom {
+                    start: Point::new(lg.x1() as f64, lg.y1() as f64),
+                    end: Point::new(lg.x2() as f64, lg.y2() as f64),
+                    aspect: 1.0,
+                    focal: None,
+                };
+                let base: &usvg::BaseGradient = lg;
+                (GradientKind::Linear, base, geom)
+            }
+            usvg::Paint::RadialGradient(rg) => {
+                if rg.fr().get() > 1e-4 {
+                    self.warn(format!("gradient '{}': focal radius ignored", rg.id()));
+                }
+                let c = Point::new(rg.cx() as f64, rg.cy() as f64);
+                let mut geom = GradientGeom { start: c, end: c + Vec2::new(rg.r().get() as f64, 0.0), aspect: 1.0, focal: None };
+                // A focal point outside the circle is pulled inside it.
+                geom.set_focal(Some(Point::new(rg.fx() as f64, rg.fy() as f64)));
+                let base: &usvg::BaseGradient = rg;
+                (GradientKind::Radial, base, geom)
+            }
+        };
+        geom.transform(m * aff(base.transform()), kind);
+        let mut stops = self.stops(base);
+        let reflect = match base.spread_method() {
+            usvg::SpreadMethod::Pad => None,
+            usvg::SpreadMethod::Reflect => Some(true),
+            usvg::SpreadMethod::Repeat => Some(false),
+        };
+        if let Some(reflect) = reflect {
+            match area.map(|a| spread::expand(kind, &mut geom, &mut stops, reflect, a)) {
+                Some(spread::Expanded::Whole) => {}
+                Some(spread::Expanded::Capped) => {
+                    self.warn(format!("gradient '{}': spreadMethod repeats more than {} times; it pads after that", base.id(), spread::MAX_PERIODS))
+                }
+                None => self.warn(format!("gradient '{}': spreadMethod approximated as pad", base.id())),
+            }
+        }
+        Paint::Gradient(Box::new(GradientPaint {
+            gradient: Gradient::new(kind, stops),
+            geom: Some(geom),
+            angle: geom.angle_deg(),
+            swatch: None,
+            freeform: None,
+        }))
+    }
+
+    /// `<pattern>` → a pattern swatch painted with the pattern's tile placement. The swatch art is
+    /// the pattern content clipped to the tile, as SVG draws it.
+    fn pattern(&mut self, pt: &Arc<usvg::Pattern>, m: Affine) -> Paint {
+        let r = pt.rect();
+        let xf = m * aff(pt.transform()) * Affine::translate((r.x() as f64, r.y() as f64));
+        let key = Arc::as_ptr(pt) as usize;
+        if let Some(name) = self.patterns.get(&key) {
+            return Paint::Pattern { pattern: name.clone(), xf };
+        }
+        let tile = Rect::new(0.0, 0.0, r.width() as f64, r.height() as f64);
+        let content = self.children(pt.root(), aff(pt.root().transform()));
+        if content.is_empty() {
+            return Paint::None;
+        }
+        let clip =
+            self.named("", NodeKind::Path { path: shapes::rectangle(tile), rule: FillRule::NonZero, live: None, clipping: true, guide: false });
+        let mut children = vec![Arc::new(clip)];
+        children.extend(content);
+        let art = self.named("", NodeKind::Group { children, clip: true });
+        let base = if pt.id().is_empty() { "Pattern" } else { pt.id() };
+        let name = unique_name(base, |n| self.doc.pattern(n).is_some());
+        let mut def = PatternDef::new(&name, vec![Arc::new(art)]);
+        def.tile = tile;
+        self.doc.patterns.push(def);
+        self.patterns.insert(key, name.clone());
+        Paint::Pattern { pattern: name, xf }
+    }
+
+    /// The fill and stroke of `p` mapped by `m`; `area`: the bounds of the path after `m`.
+    fn appearance(&mut self, p: &usvg::Path, m: Affine, area: Option<Rect>) -> (Appearance, FillRule) {
+        let mut fill = None;
+        let mut r = FillRule::NonZero;
+        if let Some(f) = p.fill() {
+            let paint = self.paint(f.paint(), m, area);
+            let mut fl = FillLayer::new(paint);
+            fl.opacity = f.opacity().get();
+            r = rule(f.rule());
+            fill = Some(AppearanceItem::Fill(fl));
+        }
+        let mut stroke = None;
+        if let Some(s) = p.stroke() {
+            // A non-scaling stroke is as wide on screen whatever `m` does: the path takes `m`, so a
+            // stroke of that width in the document is exact.
+            let scale = if self.non_scaling.contains(p.id()) { self.screen } else { m.determinant().abs().sqrt() };
+            // The stroke reaches past the path (miters further: a generous margin).
+            let reach = s.width().get() as f64 * scale * (s.miterlimit().get() as f64).max(1.0);
+            let paint = self.paint(s.paint(), m, area.map(|a| a.inflate(reach, reach)));
+            let mut sl = StrokeLayer::new(paint, s.width().get() as f64 * scale);
+            sl.opacity = s.opacity().get();
+            sl.cap = match s.linecap() {
+                usvg::LineCap::Butt => LineCap::Butt,
+                usvg::LineCap::Round => LineCap::Round,
+                usvg::LineCap::Square => LineCap::Square,
+            };
+            sl.join = match s.linejoin() {
+                usvg::LineJoin::Miter | usvg::LineJoin::MiterClip => LineJoin::Miter,
+                usvg::LineJoin::Round => LineJoin::Round,
+                usvg::LineJoin::Bevel => LineJoin::Bevel,
+            };
+            sl.miter_limit = s.miterlimit().get() as f64;
+            if let Some(d) = s.dasharray() {
+                sl.dash = Some(Dash {
+                    pattern: d.iter().map(|v| *v as f64 * scale).collect(),
+                    offset: s.dashoffset() as f64 * scale,
+                    align_corners: false,
+                });
+            }
+            stroke = Some(AppearanceItem::Stroke(sl));
+        }
+        let items = match p.paint_order() {
+            usvg::PaintOrder::FillAndStroke => [fill, stroke],
+            usvg::PaintOrder::StrokeAndFill => [stroke, fill],
+        };
+        (Appearance { items: items.into_iter().flatten().collect(), ..Default::default() }, r)
+    }
+
+    fn path(&mut self, p: &usvg::Path, acc: Affine) -> Option<Node> {
+        if !p.is_visible() {
+            return None;
+        }
+        let path = PathData::from_bezpath(&bezpath(p.data(), acc));
+        if path.is_empty() {
+            return None;
+        }
+        let (appearance, r) = self.appearance(p, acc, path.bounds());
+        // Shared, so a compound path's subpaths don't each copy a gradient's stops.
+        let appearance: vectorcraft_doc::Shared<Appearance> = appearance.into();
+        let mut n = if path.subpaths.len() > 1 {
+            // Multi-subpath SVG paths are compound paths (as in Illustrator).
+            let children = path
+                .subpaths
+                .into_iter()
+                .map(|sp| {
+                    let id = self.doc.alloc_id();
+                    let mut c = Node::new(id, NodeKind::Path { path: PathData::single(sp), rule: r, live: None, clipping: false, guide: false });
+                    c.appearance = appearance.clone();
+                    Arc::new(c)
+                })
+                .collect();
+            self.named(p.id(), NodeKind::Compound { children, rule: r })
+        } else {
+            self.named(p.id(), NodeKind::Path { path, rule: r, live: None, clipping: false, guide: false })
+        };
+        n.appearance = appearance;
+        Some(n)
+    }
+
+    fn image(&mut self, i: &usvg::Image, acc: Affine) -> Option<Node> {
+        if !i.is_visible() {
+            return None;
+        }
+        let (bytes, mime) = match i.kind() {
+            usvg::ImageKind::JPEG(d) => (d, "image/jpeg"),
+            usvg::ImageKind::PNG(d) => (d, "image/png"),
+            usvg::ImageKind::GIF(d) => (d, "image/gif"),
+            usvg::ImageKind::WEBP(d) => (d, "image/webp"),
+            usvg::ImageKind::SVG(tree) => return self.svg_image(tree, acc),
+        };
+        let size = i.size();
+        let (pw, ph) = image::ImageReader::new(std::io::Cursor::new(&bytes[..]))
+            .with_guessed_format()
+            .ok()
+            .and_then(|r| r.into_dimensions().ok())
+            .unwrap_or((size.width().round().max(1.0) as u32, size.height().round().max(1.0) as u32));
+        let key = format!("img-{:016x}", fnv1a(bytes));
+        // A linked file keeps a preview; a placeholder is all a missing one has (its preview).
+        let linked = self.files.linked(i.kind());
+        let missing = linked.is_some_and(|l| l.missing);
+        let link = linked.map(|l| l.link.clone());
+        self.doc.images.entry(key.clone()).or_insert_with(|| {
+            let blob = ImageBlob { mime: mime.into(), bytes: bytes.clone(), proxy: missing.then(|| bytes.clone()) };
+            if link.is_some() && !missing { blob.with_proxy() } else { blob }
+        });
+        let xf = acc * Affine::scale_non_uniform(size.width() as f64 / pw as f64, size.height() as f64 / ph as f64);
+        Some(self.named(
+            i.id(),
+            NodeKind::Image(Box::new(ImageObject { key, width: pw, height: ph, xf, link, placement: Default::default(), pixels: None })),
+        ))
+    }
+
+    /// An SVG shown as an image (a data URL or a linked file) → its art, `acc` mapping its size.
+    /// Its ids are its own: they mean nothing in the SVG around it.
+    fn svg_image(&mut self, tree: &usvg::Tree, acc: Affine) -> Option<Node> {
+        let outer = (
+            std::mem::take(&mut self.links),
+            std::mem::take(&mut self.hidden),
+            std::mem::take(&mut self.uses),
+            std::mem::take(&mut self.labels),
+            std::mem::take(&mut self.non_scaling),
+            std::mem::take(&mut self.data),
+            std::mem::take(&mut self.events),
+        );
+        let art = self.group_node(tree.root(), acc);
+        (self.links, self.hidden, self.uses, self.labels, self.non_scaling, self.data, self.events) = outer;
+        art
+    }
+}
diff --git a/crates/svg/src/import/layers.rs b/crates/svg/src/import/layers.rs
new file mode 100644
index 000000000..8dad45368
--- /dev/null
+++ b/crates/svg/src/import/layers.rs
@@ -0,0 +1,152 @@
+use super::convert::made_up;
+use super::importer::{CSS_PX_PER_IN, PT_PER_IN};
+use super::*;
+
+/// What marks a nested `<g>` as a sublayer rather than a group: our export writes it on the layers
+/// it writes inside layers. (Inkscape's `inkscape:groupmode="layer"` counts too.)
+pub(crate) const SUBLAYER: &str = "data-vc-layer";
+
+/// The Inkscape namespace (its layers and their labels).
+pub(super) const INKSCAPE: &str = "http://www.inkscape.org/namespaces/inkscape";
+
+/// The layer name on root element `root` (`<svg id="Main">`, or its `data-name`), as exports of
+/// one-layer documents write it. An Inkscape root's id (`svg8`) is one Inkscape made up, not a name.
+pub(super) fn root_layer_name(root: XNode) -> Option<String> {
+    let id = root.attribute("id").filter(|_| root.attribute((INKSCAPE, "version")).is_none());
+    root.attribute("data-name").or(id).map(str::trim).filter(|n| !n.is_empty()).map(str::to_string)
+}
+
+/// Is element `g` a `<g>` marked as a layer ([`SUBLAYER`])? Only one with an id counts: the id (or
+/// the label beside it) is its name.
+pub(super) fn marked_layer(g: XNode) -> bool {
+    g.tag_name().name() == "g"
+        && g.attribute("id").is_some_and(|id| !id.is_empty())
+        && (g.has_attribute(SUBLAYER) || g.attribute((INKSCAPE, "groupmode")) == Some("layer"))
+}
+
+/// Turn the groups made of elements marked as layers (`marked`, see [`marked_layer`]) right inside
+/// layer `l` into its sublayers, in its colour, and theirs in turn. A marked group anywhere else
+/// (in a group, a mask, a symbol) stays a group: only layers hold layers.
+pub(super) fn promote_sublayers(l: &mut Node, marked: &HashSet<NodeId>) {
+    let NodeKind::Layer { color, children, .. } = &mut l.kind else { return };
+    let color = *color;
+    for c in children.iter_mut().filter(|c| marked.contains(&c.id)) {
+        let c = Arc::make_mut(c);
+        let NodeKind::Group { children, clip } = &mut c.kind else { continue };
+        let mut sub = Node::layer(c.id, "", color);
+        sub.set_clips(*clip);
+        if let Some(ch) = sub.children_mut() {
+            *ch = std::mem::take(children);
+        }
+        c.kind = sub.kind;
+        promote_sublayers(c, marked);
+    }
+}
+
+/// SVG's initial `font-size` (`medium`) in user units.
+pub(crate) const DEFAULT_FONT_SIZE: f64 = 12.0;
+
+/// How lengths become points, from the root `<svg>`'s `width` / `height`.
+///
+/// A pixel (and a unitless user unit) is a point, as we export, and absolute lengths keep their
+/// physical size at 72 pt per inch: `font-size="12pt"` is 12 pt, `1in` is 72 pt. A root size in
+/// absolute units (`width="210mm"`) is that physical size, and its user units are CSS pixels of it
+/// (96 per inch, 0.75 pt each), so a drawing without a `viewBox` keeps its proportions. With one
+/// side absolute and the other not (`width="96pt" height="96"`), both are: the unitless side is
+/// CSS pixels too, so the drawing isn't stretched (#1010).
+pub(super) struct RootUnits {
+    /// Pixels per inch usvg (and the text pass) convert absolute lengths at.
+    pub(super) dpi: f64,
+    /// Points per user unit of the root, along both axes.
+    pub(super) k: f64,
+    /// Document units: those of the root `width` (pixels when it has none).
+    pub(super) unit: Unit,
+}
+
+impl RootUnits {
+    pub(super) fn of(root: XNode) -> Self {
+        let unit = |name: &str| root.attribute(name).and_then(|v| svgtypes::Length::from_str(v.trim()).ok()).map(|l| l.unit);
+        use svgtypes::LengthUnit as U;
+        let physical = |u: Option<U>| matches!(u, Some(U::In | U::Cm | U::Mm | U::Pt | U::Pc));
+        let (w, h) = (unit("width"), unit("height"));
+        let (dpi, k) = if physical(w) || physical(h) { (CSS_PX_PER_IN, PT_PER_IN / CSS_PX_PER_IN) } else { (PT_PER_IN, 1.0) };
+        let unit = match w {
+            Some(U::Mm) => Unit::Millimeters,
+            Some(U::Cm) => Unit::Centimeters,
+            Some(U::In) => Unit::Inches,
+            Some(U::Pt) => Unit::Points,
+            Some(U::Pc) => Unit::Picas,
+            _ => Unit::Pixels,
+        };
+        Self { dpi, k, unit }
+    }
+}
+
+/// `'id' (feA, feB)` for each filter: its id and the primitives it uses, for warnings.
+pub(super) fn filter_names(filters: &[Arc<usvg::filter::Filter>]) -> String {
+    use usvg::filter::Kind as K;
+    let names: Vec<String> = filters
+        .iter()
+        .map(|f| {
+            let mut kinds: Vec<&str> = Vec::new();
+            for p in f.primitives() {
+                let k = match p.kind() {
+                    K::Blend(_) => "feBlend",
+                    K::ColorMatrix(_) => "feColorMatrix",
+                    K::ComponentTransfer(_) => "feComponentTransfer",
+                    K::Composite(_) => "feComposite",
+                    K::ConvolveMatrix(_) => "feConvolveMatrix",
+                    K::DiffuseLighting(_) => "feDiffuseLighting",
+                    K::DisplacementMap(_) => "feDisplacementMap",
+                    K::DropShadow(_) => "feDropShadow",
+                    K::Flood(_) => "feFlood",
+                    K::GaussianBlur(_) => "feGaussianBlur",
+                    K::Image(_) => "feImage",
+                    K::Merge(_) => "feMerge",
+                    K::Morphology(_) => "feMorphology",
+                    K::Offset(_) => "feOffset",
+                    K::SpecularLighting(_) => "feSpecularLighting",
+                    K::Tile(_) => "feTile",
+                    K::Turbulence(_) => "feTurbulence",
+                };
+                if !kinds.contains(&k) {
+                    kinds.push(k);
+                }
+            }
+            let id = if f.id().is_empty() || made_up(f.id()) { String::new() } else { format!("'{}' ", f.id()) };
+            format!("{id}({})", kinds.join(", "))
+        })
+        .collect();
+    names.join(", ")
+}
+
+/// Inkscape's pages (`<inkscape:page>` in its `<sodipodi:namedview>`, in user units) as artboards
+/// through `user` (user units → document points), named by their labels; `None` without any.
+pub(super) fn inkscape_pages(xml: &roxmltree::Document, user: Affine) -> Option<Vec<vectorcraft_doc::Artboard>> {
+    let num = |n: roxmltree::Node, a: &str| n.attribute(a).and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite());
+    let pages: Vec<vectorcraft_doc::Artboard> = xml
+        .descendants()
+        .filter(|n| n.is_element() && n.tag_name().name() == "page" && n.tag_name().namespace() == Some(INKSCAPE))
+        .filter_map(|p| {
+            let (w, h) = (num(p, "width")?, num(p, "height")?);
+            let (x, y) = (num(p, "x").unwrap_or(0.0), num(p, "y").unwrap_or(0.0));
+            // A box too large to add up or to place (1e308 wide) is no page.
+            let r = user.transform_rect_bbox(Rect::new(x, y, x + w, y + h));
+            (w > 0.0 && h > 0.0 && r.is_finite()).then_some((p, r))
+        })
+        .take(1000)
+        .enumerate()
+        .map(|(i, (p, r))| vectorcraft_doc::Artboard {
+            id: i as u32 + 1,
+            name: p.attribute((INKSCAPE, "label")).filter(|l| !l.trim().is_empty()).map_or_else(|| format!("Artboard {}", i + 1), str::to_string),
+            rect: r,
+            locked: false,
+            show_center_mark: false,
+            show_cross_hairs: false,
+            show_video_safe_areas: false,
+            video_ruler_pixel_aspect_ratio: 1.0,
+            color: None,
+        })
+        .collect();
+    (!pages.is_empty()).then_some(pages)
+}
diff --git a/crates/svg/src/import/prepass.rs b/crates/svg/src/import/prepass.rs
new file mode 100644
index 000000000..eb9519567
--- /dev/null
+++ b/crates/svg/src/import/prepass.rs
@@ -0,0 +1,388 @@
+use super::convert::{MADE_UP_ID, href};
+use super::layers::{INKSCAPE, marked_layer};
+use super::*;
+
+/// What usvg would lose, found in the XML before it runs ([`prepass`]).
+#[derive(Default)]
+pub(super) struct Found {
+    /// The URL of each `<a href>`'s group, by its id.
+    pub(super) links: HashMap<String, String>,
+    /// Ids of the undisplayed objects shown for usvg: they come back hidden.
+    pub(super) hidden: HashSet<String>,
+    /// The `<symbol>` id each `<use>` of a symbol shows, by the `<use>`'s id.
+    pub(super) uses: HashMap<String, String>,
+    /// The files `<image>` elements link to.
+    pub(super) files: files::Files,
+    /// Ids of the shapes whose strokes don't scale ([`vector_effect`]).
+    pub(super) non_scaling: HashSet<String>,
+    /// The `data-*` attributes of elements, by id ([`user_data`]).
+    pub(super) data: HashMap<String, Vec<(String, String)>>,
+    /// The event attributes of elements, by id ([`user_events`]).
+    pub(super) events: HashMap<String, Vec<(String, String)>>,
+    /// The attributes of elements in other applications' namespaces, by id ([`foreign`]).
+    pub(super) foreign: HashMap<String, Vec<ForeignAttribute>>,
+    /// The JavaScript files `<script>` elements link to ([`linked_scripts`]).
+    pub(super) scripts: Vec<String>,
+    /// Ids of the `<g>` elements marked as layers ([`marked_layer`]).
+    pub(super) sublayers: HashSet<String>,
+    pub(super) warnings: Vec<String>,
+}
+
+/// Changes to the SVG text: `(range, replacement)`, an empty range inserting.
+#[derive(Default)]
+pub(crate) struct Edits {
+    list: Vec<(std::ops::Range<usize>, String)>,
+    /// The ids made up so far, by element.
+    ids: HashMap<roxmltree::NodeId, String>,
+    /// Declarations added to elements' `style`s, by element: (where they go, whether the element
+    /// has a `style` attribute, the declarations, XML-escaped).
+    styles: HashMap<roxmltree::NodeId, (usize, bool, String)>,
+}
+
+impl Edits {
+    fn insert(&mut self, at: usize, text: String) {
+        self.list.push((at..at, text));
+    }
+
+    /// The id of element `n` (in `svg`), made up and written in when it has none.
+    pub(super) fn id(&mut self, svg: &str, n: XNode) -> String {
+        if let Some(id) = n.attribute("id").filter(|id| !id.is_empty()) {
+            return id.to_string();
+        }
+        if let Some(id) = self.ids.get(&n.id()) {
+            return id.clone();
+        }
+        let id = format!("{MADE_UP_ID}{}", self.ids.len());
+        self.set(svg, n, "id", &id);
+        self.ids.insert(n.id(), id.clone());
+        id
+    }
+
+    /// Set attribute `name` of element `n` (in `svg`) to `value` (XML-escaped already).
+    pub(crate) fn set(&mut self, svg: &str, n: XNode, name: &str, value: &str) {
+        match n.attributes().find(|a| a.name() == name && a.namespace().is_none()) {
+            Some(a) => self.list.push((a.range_value(), value.to_string())),
+            None => self.insert(tag_name_end(svg, n), format!(" {name}=\"{value}\"")),
+        }
+    }
+
+    /// Add the declaration `decl` (XML-escaped already) to the `style` of element `n` (in `svg`),
+    /// after the ones already there (so it wins over them and over style sheet rules).
+    fn style(&mut self, svg: &str, n: XNode, decl: &str) {
+        let (_, _, decls) =
+            self.styles.entry(n.id()).or_insert_with(|| match n.attributes().find(|a| a.name() == "style" && a.namespace().is_none()) {
+                Some(a) => (a.range_value().end, true, String::new()),
+                None => (tag_name_end(svg, n), false, String::new()),
+            });
+        decls.push(';');
+        decls.push_str(decl);
+    }
+
+    /// `svg` with the edits made; overlapping ones and ranges off character boundaries are
+    /// skipped.
+    fn apply(mut self, svg: &str) -> Cow<'_, str> {
+        for (at, has_style, decls) in std::mem::take(&mut self.styles).into_values() {
+            self.insert(at, if has_style { decls } else { format!(" style=\"{}\"", decls.strip_prefix(';').unwrap_or(&decls)) });
+        }
+        if self.list.is_empty() {
+            return svg.into();
+        }
+        // Stable: inserts at one place keep their order.
+        self.list.sort_by_key(|(r, _)| (r.start, r.end));
+        let mut out = String::with_capacity(svg.len() + self.list.iter().map(|(_, t)| t.len()).sum::<usize>());
+        let mut last = 0;
+        for (r, text) in self.list {
+            let (Some(part), Some(_)) = (svg.get(last..r.start), svg.get(r.clone())) else { continue };
+            out.push_str(part);
+            out.push_str(&text);
+            last = r.end;
+        }
+        out.push_str(svg.get(last..).unwrap_or(""));
+        out.into()
+    }
+}
+
+/// usvg reads `<a href>` and `<use>` as plain groups, drops what isn't displayed and reads linked
+/// files on its own. Before it runs, the SVG is changed so that what we keep can be found:
+/// * every `<a href>` and every `<use>` of a `<symbol>` gets an id when it has none
+///   ([`MADE_UP_ID`]…), recorded with its URL or symbol;
+/// * undisplayed objects (`display: none`, as Save writes hidden layers) are shown and recorded,
+///   to come back hidden; one something links to (a `<use>` template) stays as it is;
+/// * shapes with a non-scaling stroke get an id when they have none, recorded ([`vector_effect`]);
+/// * objects with event attributes get an id when they have none, recorded with them
+///   ([`user_events`]), and the `<script>` links are recorded ([`linked_scripts`]);
+/// * so do objects with attributes in other applications' namespaces ([`foreign`]);
+/// * 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`]).
+///
+/// Whether each is there at all is read from `markers`: `svg` with its data URLs left out
+/// ([`depth::prescan`]), so an embedded picture isn't searched a dozen times. The edits are made
+/// in `svg` itself.
+pub(super) fn prepass<'s>(svg: &'s str, markers: &str, xml: &roxmltree::Document, opts: &ImportOptions) -> (Cow<'s, str>, Found) {
+    let mut found = Found::default();
+    // (`:` for prefixed elements such as `<svg:image>`.)
+    let css_transform = has_css_transform(markers);
+    let not = markers.contains(":not(");
+    let events = SVG_EVENTS.iter().any(|e| markers.contains(e));
+    let foreign_attrs = markers.contains("xmlns:") && has_foreign_attributes(xml);
+    if !css_transform
+        && !not
+        && !events
+        && !foreign_attrs
+        && !["<a", "display", "<use", ":use", "<image", ":image", vector_effect::NON_SCALING, "data-", "groupmode", "script"]
+            .iter()
+            .any(|t| markers.contains(t))
+    {
+        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") {
+        if let Some(url) = href(a) {
+            found.links.insert(edits.id(svg, a), url.to_string());
+        }
+    }
+    if markers.contains("data-") {
+        for e in elements().filter(|e| OBJECT_ELEMENTS.contains(&e.tag_name().name())) {
+            let data = user_data(e);
+            if !data.is_empty() {
+                found.data.insert(edits.id(svg, e), data);
+            }
+        }
+    }
+    if foreign_attrs {
+        for e in elements().filter(|e| OBJECT_ELEMENTS.contains(&e.tag_name().name())) {
+            let kept = foreign(e, &mut found.warnings);
+            if !kept.is_empty() {
+                found.foreign.insert(edits.id(svg, e), kept);
+            }
+        }
+    }
+    if events {
+        for e in elements().filter(|e| EVENT_ELEMENTS.contains(&e.tag_name().name())) {
+            let events = user_events(e);
+            if !events.is_empty() {
+                found.events.insert(edits.id(svg, e), events);
+            }
+        }
+    }
+    if markers.contains("script") {
+        found.scripts = linked_scripts(xml, &mut found.warnings);
+    }
+    found.sublayers = elements().filter(|g| marked_layer(*g)).filter_map(|g| g.attribute("id")).map(str::to_string).collect();
+    let symbols: HashSet<&str> = elements().filter(|n| n.tag_name().name() == "symbol").filter_map(|n| n.attribute("id")).collect();
+    for u in elements().filter(|n| n.tag_name().name() == "use") {
+        if let Some(sym) = href(u).and_then(|h| h.strip_prefix('#')).filter(|s| symbols.contains(s)) {
+            found.uses.insert(edits.id(svg, u), sym.to_string());
+        }
+    }
+    let (display, non_scaling) = (markers.contains("display"), markers.contains(vector_effect::NON_SCALING));
+    if display || non_scaling || not {
+        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);
+        }
+        if display {
+            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);
+        }
+    }
+    found.files = files::Files::read(svg, xml, opts, &mut edits, &mut found.warnings);
+    if !symbols.is_empty() && markers.contains('%') {
+        edits.list.extend(symbol_units::rewrites(xml));
+    }
+    if css_transform {
+        edits.list.extend(css_transform::rewrites(svg, xml));
+    }
+    (edits.apply(svg), found)
+}
+
+/// Is there a `transform` CSS declaration in `markers` (`transform` followed by `:`)?
+fn has_css_transform(markers: &str) -> bool {
+    markers.match_indices("transform").any(|(i, t)| markers.get(i + t.len()..).is_some_and(|s| s.trim_start().starts_with(':')))
+}
+
+/// usvg's style sheets drop rules with a `:not()` selector (#1557). The properties such rules set
+/// on an element go in its `style` attribute, with the value that wins the cascade there (which
+/// can be another rule's or the attribute's own), so usvg reads what CSS would.
+fn not_rules(svg: &str, xml: &roxmltree::Document, css: &css::Styles, edits: &mut Edits) {
+    for n in xml.descendants().filter(XNode::is_element) {
+        for (name, value) in css.set_by_not_rules(n) {
+            let value = if name == "transform" { css_transform::to_svg(&value).unwrap_or(value) } else { value };
+            edits.style(svg, n, &crate::xml_escape(&format!("{name}:{value}")));
+        }
+    }
+}
+
+/// The elements that are objects (what [`hidden_objects`] shows).
+const OBJECTS: &[&str] = &["g", "a", "path", "rect", "circle", "ellipse", "line", "polyline", "polygon", "image", "text", "use"];
+
+/// Show the undisplayed objects outside `<defs>` (and the like) for usvg, recording their ids. The
+/// objects in a `<switch>` count too (some apps wrap all their layers in one).
+fn hidden_objects(svg: &str, xml: &roxmltree::Document, css: &css::Styles, edits: &mut Edits, ids: &mut HashSet<String>) {
+    let linked: HashSet<&str> = xml.descendants().filter_map(href).filter_map(|h| h.strip_prefix('#')).collect();
+    let mut todo: Vec<XNode> = xml.root_element().children().filter(XNode::is_element).collect();
+    while let Some(n) = todo.pop() {
+        let tag = n.tag_name().name();
+        if n.attribute("id").is_some_and(|id| linked.contains(id)) {
+            continue;
+        }
+        if matches!(tag, "g" | "a" | "switch") {
+            todo.extend(n.children().filter(XNode::is_element));
+        }
+        if !OBJECTS.contains(&tag) || css.own(n, "display").as_deref() != Some("none") {
+            continue;
+        }
+        ids.insert(edits.id(svg, n));
+        // A `style` declaration wins over the attribute and style sheet rules.
+        edits.style(svg, n, "display:inline");
+    }
+}
+
+/// Where the start tag of element `n` ends its name (where an attribute can go).
+fn tag_name_end(svg: &str, n: XNode) -> usize {
+    let start = n.range().start;
+    svg.get(start + 1..).and_then(|s| s.find(|c: char| c.is_whitespace() || c == '/' || c == '>')).map_or(start + 2, |i| start + 1 + i)
+}
+
+/// The elements that become objects, whose `data-*` attributes are kept.
+const OBJECT_ELEMENTS: &[&str] = &["g", "a", "use", "path", "rect", "circle", "ellipse", "line", "polyline", "polygon", "image"];
+
+/// The most `data-*` attributes kept per element (the file is untrusted).
+const MAX_DATA: usize = 64;
+
+/// The `data-*` attributes of element `e`, in order, without the `data-` (ours, `data-name` and
+/// `data-vc-*`, aside).
+fn user_data(e: XNode) -> Vec<(String, String)> {
+    e.attributes()
+        .filter(|a| a.namespace().is_none())
+        .filter_map(|a| Some((a.name().strip_prefix("data-")?, a.value())))
+        .filter(|(k, _)| !k.is_empty() && *k != "name" && !k.starts_with("vc-"))
+        .take(MAX_DATA)
+        .map(|(k, v)| (k.to_string(), v.to_string()))
+        .collect()
+}
+
+/// The namespaces whose attributes VectorCraft reads, writes or makes again itself: their
+/// attributes aren't kept as another application's ([`foreign`]).
+const OWN_NAMESPACES: &[&str] = &[
+    "http://www.w3.org/2000/svg",
+    "http://www.w3.org/1999/xlink",
+    "http://www.w3.org/XML/1998/namespace",
+    "http://www.w3.org/2000/xmlns/",
+    INKSCAPE,
+    "http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd",
+    crate::EDITING_NS,
+];
+
+/// The most attributes in other applications' namespaces kept per element (the file is untrusted).
+pub const MAX_FOREIGN: usize = 64;
+
+/// The longest value of such an attribute kept, in bytes; a longer one is left out.
+pub const MAX_FOREIGN_VALUE: usize = 64 * 1024;
+
+/// The namespace of attribute `a` when it is another application's ([`OWN_NAMESPACES`] aside).
+fn foreign_ns<'a>(a: &roxmltree::Attribute<'a, '_>) -> Option<&'a str> {
+    a.namespace().filter(|ns| !OWN_NAMESPACES.contains(ns))
+}
+
+/// Does any element of `xml` have an attribute in another application's namespace? Most files
+/// declare only namespaces VectorCraft reads itself (XLink), and skip the scan for them.
+fn has_foreign_attributes(xml: &roxmltree::Document) -> bool {
+    xml.descendants().filter(XNode::is_element).any(|e| e.attributes().any(|a| foreign_ns(&a).is_some()))
+}
+
+/// The attributes of element `e` in other applications' namespaces, in order, with the prefix the
+/// file gives each namespace: `plotter:pen="2"`. Those past [`MAX_FOREIGN`], and values longer
+/// than [`MAX_FOREIGN_VALUE`], are left out with a warning.
+fn foreign(e: XNode, warnings: &mut Vec<String>) -> Vec<ForeignAttribute> {
+    let mut kept = vec![];
+    let mut left_out = false;
+    for a in e.attributes() {
+        let Some(ns) = foreign_ns(&a) else { continue };
+        if kept.len() == MAX_FOREIGN || a.value().len() > MAX_FOREIGN_VALUE {
+            left_out = true;
+            continue;
+        }
+        // A namespaced attribute always has a prefix in the file; `ns` stands in where the only
+        // one found is the default namespace's (export makes it unique).
+        let prefix = e.lookup_prefix(ns).filter(|p| !p.is_empty()).unwrap_or("ns");
+        kept.push(ForeignAttribute { ns: ns.to_string(), prefix: prefix.to_string(), name: a.name().to_string(), value: a.value().to_string() });
+    }
+    if left_out {
+        let w = format!(
+            "other applications' attributes past {MAX_FOREIGN} on an element, or longer than {} KiB, were left out",
+            MAX_FOREIGN_VALUE / 1024
+        );
+        if !warnings.contains(&w) {
+            warnings.push(w);
+        }
+    }
+    kept
+}
+
+/// The elements whose event attributes are kept: the objects, and type.
+const EVENT_ELEMENTS: &[&str] = &["g", "a", "use", "path", "rect", "circle", "ellipse", "line", "polyline", "polygon", "image", "text"];
+
+/// The event attributes of element `e` that the SVG Interactivity panel lists ([`SVG_EVENTS`]),
+/// in order: the JavaScript is kept as text and never run.
+fn user_events(e: XNode) -> Vec<(String, String)> {
+    e.attributes()
+        .filter(|a| a.namespace().is_none() && SVG_EVENTS.contains(&a.name()))
+        .map(|a| (a.name().to_string(), a.value().to_string()))
+        .collect()
+}
+
+/// The JavaScript files the `<script>` elements link to, in order and each once, at most
+/// [`MAX_SVG_SCRIPTS`] (the file is untrusted): the links are kept as text, and the files are never
+/// read or run. Inline scripts and the links past the limit are left out with a warning.
+fn linked_scripts(xml: &roxmltree::Document, warnings: &mut Vec<String>) -> Vec<String> {
+    let mut out: Vec<String> = vec![];
+    let mut over = false;
+    for s in xml.descendants().filter(|n| n.is_element() && n.tag_name().name() == "script") {
+        match href(s) {
+            Some(h) if out.iter().any(|o| o == h) => {}
+            Some(h) if out.len() < MAX_SVG_SCRIPTS => out.push(h.to_string()),
+            Some(_) => over = true,
+            None if s.text().is_some_and(|t| !t.trim().is_empty()) => {
+                let w = "inline scripts were left out: only linked JavaScript files are kept".to_string();
+                if !warnings.contains(&w) {
+                    warnings.push(w);
+                }
+            }
+            None => {}
+        }
+    }
+    if over {
+        warnings.push(format!("more than {MAX_SVG_SCRIPTS} JavaScript files are linked: only the first {MAX_SVG_SCRIPTS} were kept"));
+    }
+    out
+}
+
+/// Make `n` link to `url`, unless it links somewhere already (an inner link wins).
+pub(super) fn link(n: &mut Node, url: &str) {
+    if n.url().is_none() {
+        n.edit_attrs(|a| a.url = url.to_string());
+    }
+}
+
+/// The names apps keep beside element ids, by id: `data-name`, `inkscape:label`, `serif:id` or
+/// `aria-label` (the first one present).
+pub(super) fn labels(xml: &roxmltree::Document) -> HashMap<String, String> {
+    const SERIF: &str = "http://www.serif.com/";
+    xml.descendants()
+        .filter_map(|n| {
+            let id = n.attribute("id").filter(|id| !id.is_empty())?;
+            let name = n
+                .attribute("data-name")
+                .or_else(|| n.attribute((INKSCAPE, "label")))
+                .or_else(|| n.attribute((SERIF, "id")))
+                .or_else(|| n.attribute("aria-label"))?;
+            Some((id.to_string(), name.to_string()))
+        })
+        .collect()
+}