From 0555509a59092b3c506558605b59b4e5a228e6ef Mon Sep 17 00:00:00 2001
From: strebdom <dominik.strebel@gmail.com>
Date: Sat, 24 Oct 2026 13:38:33 +0200
Subject: [PATCH 1/5] feat(map): open QGIS projects as maps and apply QGIS
 layer styles
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`project.importQgis` opens a QGIS project (.qgs, or a .qgz archive) as a
new map: its layers in the layer tree's order, from their files (relative
paths from the project's folder), CSV points, XYZ tiles or WMS, hidden
where unchecked; the project's coordinate system and saved view (its
layers' extent when that shows none of them); a blank basemap and no
graticule. `style.importQgis` gives a layer a .qml style. One undo step
each (`Session::run_part` runs the commands an import is made of).

What carries over (`rustgis_map::qgis`, reading both the <Option> and
the older <prop> settings): single, categorized, graduated and
rule-based renderers (rules on one field's values as Unique Values, an
else rule the rest; wrapping renderers by the one inside); simple fills,
lines and markers, units, symbol opacity, a line's simple lines as
stacked strokes with their passes as levels; opacity, blending, scale
ranges, filters as definition queries, reference scales; simple and
rule-based labels as label classes (filters as SQL clauses, an else
rule's from its siblings', placement, size, colour, bold, italic, halo,
scale range). QGIS's scales are taken at RustGIS's 0.28 mm pixel.

The rest is drawn as near as it can be or left out, and the import's
notes say so layer by layer (pattern fills as a tint, font and SVG
markers as circles, dashes solid, marker lines, data-defined settings,
raster colouring, PostGIS and WFS sources). The XML is read with a node
limit and no entity declarations; a database password never reaches the
notes.

UI: Open takes .qgs/.qgz on the desktop; Project › New › QGIS Project…;
Import QGIS Style… in the Symbology pane. Docs: workspace.md › QGIS
projects and styles; the QGIS comparison page.
---
 crates/engine/src/cmd/mod.rs    |   2 +
 crates/engine/src/cmd/qgis.rs   | 244 ++++++++++++++++++
 crates/engine/src/lib.rs        |   9 +
 crates/engine/src/tests.rs      |  70 +++++
 crates/map/src/lib.rs           |   1 +
 crates/map/src/palette.rs       |  28 +-
 crates/map/src/qgis/expr.rs     | 190 ++++++++++++++
 crates/map/src/qgis/labels.rs   | 258 +++++++++++++++++++
 crates/map/src/qgis/mod.rs      | 435 ++++++++++++++++++++++++++++++++
 crates/map/src/qgis/renderer.rs | 325 ++++++++++++++++++++++++
 crates/map/src/qgis/source.rs   | 227 +++++++++++++++++
 crates/map/src/qgis/symbol.rs   | 261 +++++++++++++++++++
 crates/map/src/qgis/tests.rs    | 239 ++++++++++++++++++
 crates/ui-egui/src/backstage.rs |   6 +-
 crates/ui-egui/src/chrome.rs    |   2 +
 crates/ui-egui/src/lib.rs       |  10 +-
 crates/ui-egui/src/panes.rs     |   4 +
 docs/comparison/qgis.md         |   9 +-
 docs/user-guide/workspace.md    |  41 +++
 19 files changed, 2329 insertions(+), 32 deletions(-)
 create mode 100644 crates/engine/src/cmd/qgis.rs
 create mode 100644 crates/map/src/qgis/expr.rs
 create mode 100644 crates/map/src/qgis/labels.rs
 create mode 100644 crates/map/src/qgis/mod.rs
 create mode 100644 crates/map/src/qgis/renderer.rs
 create mode 100644 crates/map/src/qgis/source.rs
 create mode 100644 crates/map/src/qgis/symbol.rs
 create mode 100644 crates/map/src/qgis/tests.rs

diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index fe5bdf9b0..df0ce1e1b 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -29,6 +29,7 @@ pub mod plugins;
 pub mod portals;
 pub mod presentation;
 pub mod project;
+pub mod qgis;
 pub mod raster;
 pub mod report;
 pub mod s3;
@@ -55,6 +56,7 @@ use crate::{CommandSpec, Session};
 pub fn all() -> Vec<CommandSpec> {
     let mut v = Vec::new();
     v.extend(project::commands());
+    v.extend(qgis::commands());
     v.extend(navigate::commands());
     v.extend(geocode::commands());
     v.extend(directions::commands());
diff --git a/crates/engine/src/cmd/qgis.rs b/crates/engine/src/cmd/qgis.rs
new file mode 100644
index 000000000..0c5857475
--- /dev/null
+++ b/crates/engine/src/cmd/qgis.rs
@@ -0,0 +1,244 @@
+//! QGIS projects and layer styles: `project.importQgis` opens a `.qgs` (or `.qgz`) as a new map,
+//! with its layers, their order, visibility and styles, its coordinate system and its view;
+//! `style.importQgis` gives a layer a `.qml` style. Both say what they couldn't carry over
+//! (`rustgis_map::qgis::Report`).
+
+use rustgis_geom::{Coord, Extent};
+use rustgis_map::qgis::{self, NoteKind, Report, Source};
+use serde_json::{Value, json};
+
+use super::{need_feature_layer, ps};
+use crate::{CmdResult, CommandSpec as C, Session};
+
+pub fn commands() -> Vec<C> {
+    vec![
+        C::new("project.importQgis", "Import QGIS Project", "Project › Import", import_project).params(
+            r#"{"path"?: "*.qgs|*.qgz", "text"?: "a .qgs file's text", "data"?: "a .qgs or .qgz file, base64", "dir"?: "the folder its relative paths start from (default: the file's)"} → the layers added and notes on what wasn't carried over"#,
+        ),
+        C::new("style.importQgis", "Import QGIS Style", "Style › Styles", import_style).when(need_feature_layer).params(
+            r#"{"layer"?, "path"?: "*.qml", "text"?: "a .qml file's text", "data"?: "a .qml file, base64"} → notes on what wasn't carried over"#,
+        ),
+    ]
+}
+
+/// A QGIS file's text: a `.qgs` or `.qml` as it is, a `.qgz` (a zip archive) its `.qgs`.
+fn qgis_text(p: &Value) -> Result<String, String> {
+    let bytes = match (ps(p, "data"), ps(p, "text"), ps(p, "path")) {
+        (Some(d), ..) => {
+            use base64::Engine;
+            base64::engine::general_purpose::STANDARD.decode(d.trim()).map_err(|_| "data must be base64".to_string())?
+        }
+        (None, Some(t), _) => return Ok(t.to_string()),
+        (None, None, Some(path)) => read_file(path)?,
+        _ => return Err("path, text or data is required".into()),
+    };
+    if bytes.starts_with(b"PK") {
+        let entries = rustgis_data::zip::read_matching(&bytes, |n| n.to_ascii_lowercase().ends_with(".qgs"))?;
+        let (_, qgs) = entries.into_iter().next().ok_or("the .qgz holds no .qgs project")?;
+        return String::from_utf8(qgs).map_err(|_| "the .qgz's project isn't text".to_string());
+    }
+    String::from_utf8(bytes).map_err(|_| "not a QGIS file (it isn't text)".to_string())
+}
+
+/// The most bytes of a QGIS file read.
+const MAX_FILE: u64 = 256 << 20;
+
+fn read_file(path: &str) -> Result<Vec<u8>, String> {
+    let len = std::fs::metadata(path).map_err(|e| format!("{path}: {e}"))?.len();
+    if len > MAX_FILE {
+        return Err(format!("{path} is too large for a QGIS project"));
+    }
+    std::fs::read(path).map_err(|e| format!("{path}: {e}"))
+}
+
+fn import_project(s: &mut Session, p: &Value) -> CmdResult {
+    let text = qgis_text(p)?;
+    let dir = ps(p, "dir")
+        .map(str::to_string)
+        .or_else(|| ps(p, "path").and_then(|path| std::path::Path::new(path).parent()).map(|d| d.to_string_lossy().into_owned()));
+    let mut report = Report::default();
+    let project = qgis::read_project(&text, dir.as_deref().unwrap_or_default(), &mut report)?;
+    // A map of its own, named as the project.
+    let name = if project.title.is_empty() { "QGIS project" } else { project.title.as_str() };
+    s.run_part("map.new", &json!({"name": name}))?;
+    // QGIS draws a project on its canvas alone: no basemap, no graticule.
+    let m = s.map_mut();
+    m.basemap = rustgis_map::Basemap::Blank;
+    m.graticule = false;
+    if let Some(crs) = &project.crs {
+        let code = match crs.as_str() {
+            "EPSG:3857" | "EPSG:900913" => "mercator",
+            other => other,
+        };
+        if let Err(e) = s.run_part("map.projection", &json!({"type": code})) {
+            report.approximated("", format!("the project's coordinate system {crs} ({e}), drawn in Web Mercator"));
+        }
+    }
+    // Bottom first, so each is added on top of the ones below it.
+    let mut added = Vec::new();
+    for layer in project.layers.iter().rev() {
+        match add_layer(s, layer, &mut report) {
+            Ok(Some(name)) => added.push(name),
+            Ok(None) => {}
+            Err(e) => report.skipped(&layer.name, format!("the layer: {e}")),
+        }
+    }
+    go_to_view(s, &project);
+    let notes: Vec<Value> = report.notes.iter().map(note_json).collect();
+    if !report.notes.is_empty() {
+        let left = report.notes.iter().filter(|n| n.kind == NoteKind::Skipped).count();
+        s.notify(
+            format!(
+                "Imported {} of {} QGIS layers; {} things drawn differently, {left} left out (see the import's notes)",
+                added.len(),
+                project.layers.len(),
+                report.notes.len() - left
+            ),
+            false,
+        );
+    }
+    Ok(json!({"map": name, "layers": added, "notes": notes}))
+}
+
+/// Adds one QGIS layer to the active map with its style: `Ok(Some(name))` when added, `Ok(None)`
+/// when its source is one RustGIS doesn't read (noted).
+fn add_layer(s: &mut Session, layer: &qgis::ProjectLayer, report: &mut Report) -> Result<Option<String>, String> {
+    let name = layer.name.as_str();
+    match &layer.source {
+        Source::File { path, layer: table, .. } => {
+            let mut q = json!({"path": path, "name": name});
+            if let Some(t) = table {
+                q["layer"] = json!(t);
+            }
+            s.run_part("layer.addData", &q)?;
+        }
+        Source::Csv { path, x, y, wkt, crs } => {
+            let mut q = json!({"path": path, "name": name});
+            for (k, v) in [("x", x), ("y", y), ("wkt", wkt), ("crs", crs)] {
+                if let Some(v) = v {
+                    q[k] = json!(v);
+                }
+            }
+            s.run_part("layer.addData", &q)?;
+        }
+        Source::Xyz { url, zmin, zmax, vector } => {
+            let mut q = json!({"url": url, "name": name, "kind": if *vector { "vector" } else { "raster" }});
+            if let Some(z) = zmin {
+                q["minZoom"] = json!(z);
+            }
+            if let Some(z) = zmax {
+                q["maxZoom"] = json!(z);
+            }
+            s.run_part("map.addTiles", &q)?;
+            if !layer.visible {
+                // A tile layer has no visibility of its own: an invisible one isn't wanted.
+                report.approximated(name, "a hidden tile layer, added shown");
+            }
+            return Ok(Some(name.to_string()));
+        }
+        Source::Wms { url, layer: wms, .. } => {
+            s.run_part("service.add", &json!({"url": url, "type": "wms", "layer": wms, "name": name}))?;
+            return Ok(Some(name.to_string()));
+        }
+        Source::Wfs { url, layer: typename } => {
+            report.skipped(name, format!("the WFS layer {typename} at {url} (add it with Add Data › Web Data)"));
+            return Ok(None);
+        }
+        Source::Postgres { connection, table } => {
+            report.skipped(name, format!("the PostGIS table {table} ({connection}): connect to the database to add it"));
+            return Ok(None);
+        }
+        Source::Other { provider } => {
+            report.skipped(name, format!("the layer: RustGIS doesn't read QGIS's {provider} sources"));
+            return Ok(None);
+        }
+    }
+    let id = s.active_layer.ok_or("the layer wasn't added")?;
+    let Some(l) = s.map_mut().layer_mut(id) else { return Err("the layer wasn't added".into()) };
+    let added_name = l.name.clone();
+    l.visible = layer.visible;
+    if l.is_raster() {
+        // A raster takes its opacity, visibility and scale range; its colouring is noted.
+        let st = &layer.style;
+        let t = st.transparency;
+        let (min, max) = (st.min_scale, st.max_scale);
+        if let Some(t) = t {
+            l.transparency = t;
+        }
+        if let Some(m) = min {
+            l.min_scale = m;
+        }
+        if let Some(m) = max {
+            l.max_scale = m;
+        }
+        return Ok(Some(added_name));
+    }
+    layer.style.apply(l);
+    // What reads only against the layer's fields: its definition query and its label clauses.
+    if let Some(q) = &layer.definition_query {
+        match rustgis_data::query::parse(q, &l.dataset) {
+            Ok(_) => l.definition_query = Some(q.clone()),
+            Err(e) => report.skipped(name, format!("its filter `{q}` ({e})")),
+        }
+    }
+    for c in std::iter::once(&mut l.labels.default).chain(l.labels.classes.iter_mut()) {
+        if let Some(w) = c.where_.clone()
+            && let Err(e) = rustgis_data::query::parse(&w, &l.dataset)
+        {
+            report.skipped(name, format!("the label class \"{}\", whose clause `{w}` doesn't fit the layer ({e})", c.name));
+            c.visible = false;
+        }
+        if l.dataset.field_index(&c.field).is_none() && c.visible {
+            report.skipped(name, format!("labels from the field {}, which the layer hasn't", c.field));
+            c.visible = false;
+        }
+    }
+    let field = match &l.renderer {
+        rustgis_map::Renderer::Unique { field, .. } | rustgis_map::Renderer::Graduated { field, .. } => Some(field.clone()),
+        _ => None,
+    };
+    if let Some(f) = field.filter(|f| l.dataset.field_index(f).is_none()) {
+        report.approximated(name, format!("classes by the field {f}, which the layer hasn't: every feature draws as the rest"));
+    }
+    Ok(Some(added_name))
+}
+
+/// Goes to the project's saved view, or to its layers when that view shows none of them.
+fn go_to_view(s: &mut Session, project: &qgis::Project) {
+    let data = s.map().full_extent();
+    let saved = project.extent.and_then(|[x0, y0, x1, y1]| {
+        let m = s.map();
+        let corners = [(x0, y0), (x1, y0), (x0, y1), (x1, y1)].map(|(x, y)| m.to_lonlat(Coord::new(x, y)));
+        corners.iter().flatten().fold(None, |e: Option<Extent>, c| Some(e.unwrap_or(Extent::EMPTY).union(&Extent::new(c.x, c.y, c.x, c.y))))
+    });
+    let target = match saved {
+        Some(e) if !e.is_empty() && (data.is_empty() || e.intersects(&data)) => e,
+        _ => data,
+    };
+    if !target.is_empty() {
+        s.zoom_to(&target);
+    }
+}
+
+fn note_json(n: &qgis::Note) -> Value {
+    json!({"layer": n.layer, "kind": n.kind, "text": n.text, "count": n.count})
+}
+
+fn import_style(s: &mut Session, p: &Value) -> CmdResult {
+    let text = qgis_text(p)?;
+    let id = s.layer_id(p)?;
+    let name = s.map().layer(id).map(|l| l.name.clone()).ok_or("no such layer")?;
+    let mut report = Report::default();
+    let style = qgis::read_style(&text, &name, &mut report)?;
+    let l = s.map_mut().layer_mut(id).ok_or("no such layer")?;
+    style.apply(l);
+    for c in std::iter::once(&mut l.labels.default).chain(l.labels.classes.iter_mut()) {
+        if let Some(w) = c.where_.clone()
+            && rustgis_data::query::parse(&w, &l.dataset).is_err()
+        {
+            report.skipped(&name, format!("the label class \"{}\", whose clause `{w}` doesn't fit the layer", c.name));
+            c.visible = false;
+        }
+    }
+    Ok(json!({"notes": report.notes.iter().map(note_json).collect::<Vec<_>>()}))
+}
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index c40d164fa..ada2bf854 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -837,6 +837,15 @@ impl Session {
 
     /// Runs a command by id. Mutating commands snapshot the project for undo; an error or a
     /// panic restores it.
+    /// Runs command `id` as a part of the one running now (a command made of others): its
+    /// changes are in that command's one undo step, not a step of their own.
+    pub(crate) fn run_part(&mut self, id: &str, params: &Value) -> CmdResult {
+        let (undo, redo) = (std::mem::take(&mut self.undo), std::mem::take(&mut self.redo));
+        let res = self.run(id, params);
+        (self.undo, self.redo) = (undo, redo);
+        res
+    }
+
     pub fn run(&mut self, id: &str, params: &Value) -> CmdResult {
         // The merge key asked for ([`Session::merge_undo`]) goes to this command if it runs, and is
         // gone if it's refused first, so it can't merge a later command into the last step.
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 033cefa8c..59c404b44 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -623,6 +623,76 @@ fn rivers_are_labelled_along_their_lines_in_italics() {
     assert!(!text.contains("italic"), "{text}");
 }
 
+#[test]
+fn a_qgis_project_opens_as_a_map_and_a_qgis_style_styles_a_layer() {
+    let dir = std::env::temp_dir().join(format!("rustgis-qgis-{}", std::process::id()));
+    std::fs::create_dir_all(dir.join("data")).unwrap();
+    let roads = r#"{"type":"FeatureCollection","features":[
+        {"type":"Feature","properties":{"class":"motorway","name":"A1","lanes":3},"geometry":{"type":"LineString","coordinates":[[8.70,47.49],[8.75,47.51]]}},
+        {"type":"Feature","properties":{"class":"track","name":"Feldweg","lanes":1},"geometry":{"type":"LineString","coordinates":[[8.71,47.50],[8.74,47.48]]}}]}"#;
+    std::fs::write(dir.join("data/roads.geojson"), roads).unwrap();
+    std::fs::write(dir.join("data/towns.csv"), "name,lon,lat\nWinterthur,8.72,47.50\n").unwrap();
+    let qgs = r#"<!DOCTYPE qgis PUBLIC 'http://mrcc.com/qgis.dtd' 'SYSTEM'>
+<qgis version="3.42.0"><title>Winterthur</title>
+  <projectCrs><spatialrefsys><authid>EPSG:2056</authid></spatialrefsys></projectCrs>
+  <layer-tree-group><layer-tree-layer id="t" checked="Qt::Checked"/><layer-tree-layer id="r" checked="Qt::Unchecked"/><layer-tree-layer id="db" checked="Qt::Checked"/></layer-tree-group>
+  <mapcanvas name="theMapCanvas"><extent><xmin>0</xmin><ymin>0</ymin><xmax>10</xmax><ymax>10</ymax></extent></mapcanvas>
+  <projectlayers>
+    <maplayer type="vector" labelsEnabled="1"><id>r</id><datasource>./data/roads.geojson|subset="lanes" &gt; 0</datasource><layername>Roads</layername><provider>ogr</provider>
+      <renderer-v2 type="categorizedSymbol" attr="class" referencescale="25000"><categories><category value="motorway" symbol="0" render="true"/><category value="" symbol="1" render="true"/></categories>
+        <symbols><symbol type="line" name="0" alpha="1"><layer class="SimpleLine" enabled="1"><prop k="line_color" v="0,0,0,255"/><prop k="line_width" v="1"/></layer><layer class="SimpleLine" enabled="1"><prop k="line_color" v="250,150,50,255"/><prop k="line_width" v="0.6"/></layer></symbol>
+        <symbol type="line" name="1" alpha="1"><layer class="SimpleLine" enabled="1"><prop k="line_color" v="120,120,120,255"/></layer></symbol></symbols></renderer-v2>
+      <labeling type="rule-based"><rules key="x"><rule filter="&quot;class&quot; = 'motorway'" description="Big"><settings><text-style fieldName="name" fontSize="9" namedStyle="Italic"/><placement placement="2"/></settings></rule>
+        <rule filter="&quot;nofield&quot; = 1" description="Broken"><settings><text-style fieldName="name"/></settings></rule></rules></labeling></maplayer>
+    <maplayer type="vector"><id>t</id><datasource>file:./data/towns.csv?type=csv&amp;xField=lon&amp;yField=lat&amp;crs=EPSG:4326</datasource><layername>Towns</layername><provider>delimitedtext</provider>
+      <renderer-v2 type="singleSymbol"><symbols><symbol type="marker" name="0" alpha="1"><layer class="SimpleMarker" enabled="1"><prop k="name" v="square"/><prop k="color" v="200,0,0,255"/></layer></symbol></symbols></renderer-v2></maplayer>
+    <maplayer type="vector"><id>db</id><datasource>dbname='gis' host=db password='secret' table="public"."parcels" (geom)</datasource><layername>Parcels</layername><provider>postgres</provider></maplayer>
+  </projectlayers></qgis>"#;
+    let path = dir.join("winterthur.qgs");
+    std::fs::write(&path, qgs).unwrap();
+    let mut s = world();
+    let maps = s.project.maps.len();
+    let depth = s.undo_depth();
+    let out = s.run("project.importQgis", &json!({"path": path.display().to_string()})).unwrap();
+    assert_eq!((s.project.maps.len(), s.map().name.as_str()), (maps + 1, "Winterthur"), "a map of its own");
+    assert_eq!(s.undo_depth(), depth + 1, "one step");
+    assert_eq!(s.map().projection.code(), "EPSG:2056");
+    assert_eq!(s.map().basemap, rustgis_map::Basemap::Blank);
+    let names: Vec<&str> = s.map().layers.iter().map(|l| l.name.as_str()).collect();
+    assert_eq!(names, ["Towns", "Roads"], "top first; the database table isn't added");
+    let roads = s.map().layer_by_name("Roads").unwrap();
+    assert!(!roads.visible, "unchecked in the layer tree");
+    assert_eq!(roads.definition_query.as_deref(), Some("\"lanes\" > 0"));
+    assert!(roads.reference_scale.is_some());
+    let rustgis_map::Renderer::Unique { field, class_strokes, .. } = &roads.renderer else { panic!("{:?}", roads.renderer) };
+    assert_eq!((field.as_str(), class_strokes.get("motorway").map(Vec::len)), ("class", Some(2)));
+    let classes: Vec<(&str, bool)> = roads.labels.classes.iter().map(|c| (c.name.as_str(), c.visible)).collect();
+    assert_eq!(classes, [("Big", true), ("Broken", false)], "a clause the layer can't read is switched off");
+    assert_eq!(roads.labels.classes[0].placement, rustgis_map::LabelPlacement::Parallel);
+    let towns = s.map().layer_by_name("Towns").unwrap();
+    assert_eq!((towns.dataset.features.len(), towns.renderer.base_symbol().marker), (1, rustgis_map::Marker::Square));
+    // What wasn't carried over: the database table, with no password in the note.
+    let notes = out["notes"].as_array().unwrap();
+    let text = serde_json::to_string(notes).unwrap();
+    assert!(text.contains("parcels") && !text.contains("secret"), "{text}");
+    assert!(text.contains("Broken"), "{text}");
+    // Drawn, and gone again with one undo.
+    s.run("share.exportMap", &json!({"path": dir.join("map.png").display().to_string(), "width": 320, "height": 200})).unwrap();
+    s.run("edit.undo", &Value::Null).unwrap();
+    assert_eq!(s.project.maps.len(), maps);
+
+    // A style file on a sample layer: Rivers drawn as a cased line.
+    let qml = r#"<!DOCTYPE qgis PUBLIC 'http://mrcc.com/qgis.dtd' 'SYSTEM'><qgis version="3.22"><renderer-v2 type="singleSymbol"><symbols><symbol type="line" name="0" alpha="1">
+        <layer class="SimpleLine" enabled="1"><Option type="Map"><Option name="line_color" value="20,60,120,255"/><Option name="line_width" value="1.2"/></Option></layer>
+        <layer class="SimpleLine" enabled="1"><Option type="Map"><Option name="line_color" value="150,200,255,255"/><Option name="line_width" value="0.5"/></Option></layer>
+        </symbol></symbols></renderer-v2><layerOpacity>0.5</layerOpacity></qgis>"#;
+    s.run("style.importQgis", &json!({"layer": "Rivers", "text": qml})).unwrap();
+    let rivers = s.map().layer_by_name("Rivers").unwrap();
+    assert_eq!((rivers.line_strokes.len(), rivers.transparency), (2, 50.0));
+    assert!(s.run("style.importQgis", &json!({"layer": "Rivers", "text": "<nonsense"})).is_err());
+    std::fs::remove_dir_all(&dir).ok();
+}
+
 #[test]
 fn project_save_and_open_roundtrip() {
     let mut s = world();
diff --git a/crates/map/src/lib.rs b/crates/map/src/lib.rs
index b6aed7995..4b174d19b 100644
--- a/crates/map/src/lib.rs
+++ b/crates/map/src/lib.rs
@@ -14,6 +14,7 @@ pub mod palette;
 pub mod planets;
 pub mod presentation;
 pub mod projection;
+pub mod qgis;
 pub mod raster;
 pub mod report;
 pub mod source;
diff --git a/crates/map/src/palette.rs b/crates/map/src/palette.rs
index 27ee53b14..cc85af0eb 100644
--- a/crates/map/src/palette.rs
+++ b/crates/map/src/palette.rs
@@ -264,22 +264,7 @@ fn qgis_ramp(node: Node, name: &str) -> Result<Option<CustomRamp>, String> {
 /// A ramp's properties: `<prop k v>` children (older QGIS) or `<Option name value>` inside an
 /// `<Option type="Map">` (QGIS 3.26 and later).
 fn qgis_props(node: Node) -> Vec<(String, String)> {
-    let mut props = Vec::new();
-    for c in node.children().filter(Node::is_element) {
-        if c.has_tag_name("prop")
-            && let (Some(k), Some(v)) = (c.attribute("k"), c.attribute("v"))
-        {
-            props.push((k.to_string(), v.to_string()));
-        }
-        if c.has_tag_name("Option") {
-            for o in c.children().filter(|o| o.has_tag_name("Option")) {
-                if let (Some(k), Some(v)) = (o.attribute("name"), o.attribute("value")) {
-                    props.push((k.to_string(), v.to_string()));
-                }
-            }
-        }
-    }
-    props
+    crate::qgis::props(node)
 }
 
 /// The stops of a QGIS gradient, `pos;color[;spec;direction]` joined by `:`. Newer colours
@@ -302,16 +287,7 @@ fn qgis_stops(s: &str) -> Vec<&str> {
 
 /// A QGIS colour: `r,g,b,a` (with anything after, such as `,rgb:…`) or `#RRGGBB[AA]`.
 fn qgis_color(s: &str) -> Option<Rgba> {
-    let s = s.trim();
-    if s.starts_with('#') {
-        return Rgba::from_hex(s);
-    }
-    let v: Vec<u8> = s.split(',').take(4).map(|p| p.trim().parse::<u8>().ok()).collect::<Option<_>>()?;
-    match v.as_slice() {
-        [r, g, b] => Some(Rgba::rgb(*r, *g, *b)),
-        [r, g, b, a] => Some(Rgba::new(*r, *g, *b, *a)),
-        _ => None,
-    }
+    crate::qgis::color(s)
 }
 
 /// Stops at 0..=1 made into steps: each colour holds until the next stop's position.
diff --git a/crates/map/src/qgis/expr.rs b/crates/map/src/qgis/expr.rs
new file mode 100644
index 000000000..ba7a524b6
--- /dev/null
+++ b/crates/map/src/qgis/expr.rs
@@ -0,0 +1,190 @@
+//! QGIS expressions as RustGIS SQL clauses: the part of QGIS's expression language a filter
+//! mostly is (fields compared with values, `LIKE`, `IS NULL`, `IN`, joined by `AND`, `OR` and
+//! `NOT`) carried over as it is, and anything else (functions, arithmetic, `CASE`, variables)
+//! refused rather than guessed at, so the caller can note it.
+
+/// The most characters of an expression read.
+const MAX_LEN: usize = 10_000;
+
+#[derive(Clone, Debug, PartialEq)]
+enum Token {
+    /// A field name: written back double-quoted.
+    Field(String),
+    /// A text value: written back single-quoted.
+    Text(String),
+    /// A number, a comparison, a keyword, a bracket or a comma: written back as it is.
+    Word(String),
+}
+
+/// `expr` as a RustGIS SQL clause, or `None` when it uses more of QGIS's language than that has.
+/// The clause is checked against a layer's fields where it is used.
+pub fn to_sql(expr: &str) -> Option<String> {
+    let expr = expr.trim();
+    if expr.is_empty() || expr.len() > MAX_LEN {
+        return None;
+    }
+    let tokens = tokenize(expr)?;
+    let mut out = Vec::with_capacity(tokens.len());
+    for t in &tokens {
+        out.push(match t {
+            Token::Field(f) => format!("\"{}\"", f.replace('"', "")),
+            Token::Text(s) => format!("'{}'", s.replace('\'', "''")),
+            Token::Word(w) => w.clone(),
+        });
+    }
+    Some(out.join(" "))
+}
+
+/// The field and values of a filter that only picks values of one field: `"f" = 'v'`, `f = 3`,
+/// `"f" IN ('a', 'b')`. `None` for any other.
+pub(super) fn equality(expr: &str) -> Option<(String, Vec<String>)> {
+    let tokens = tokenize(expr.trim())?;
+    let value = |t: &Token| match t {
+        Token::Text(s) => Some(s.clone()),
+        Token::Word(w) if w.parse::<f64>().is_ok() => Some(w.clone()),
+        _ => None,
+    };
+    match tokens.as_slice() {
+        [Token::Field(f), Token::Word(eq), v] if eq == "=" => Some((f.clone(), vec![value(v)?])),
+        [Token::Field(f), Token::Word(kw), Token::Word(open), rest @ .., Token::Word(close)]
+            if kw == "IN" && open == "(" && close == ")" =>
+        {
+            let values: Vec<String> = rest.iter().step_by(2).map(value).collect::<Option<_>>()?;
+            let commas_ok = rest.iter().skip(1).step_by(2).all(|t| *t == Token::Word(",".into()));
+            (commas_ok && !values.is_empty()).then(|| (f.clone(), values))
+        }
+        _ => None,
+    }
+}
+
+/// The words RustGIS's SQL has (`ILIKE` is its `LIKE`, which ignores case).
+fn keyword(w: &str) -> Option<&'static str> {
+    Some(match w.to_ascii_uppercase().as_str() {
+        "AND" => "AND",
+        "OR" => "OR",
+        "NOT" => "NOT",
+        "IN" => "IN",
+        "LIKE" | "ILIKE" => "LIKE",
+        "IS" => "IS",
+        "NULL" => "NULL",
+        _ => return None,
+    })
+}
+
+fn tokenize(s: &str) -> Option<Vec<Token>> {
+    let chars: Vec<char> = s.chars().collect();
+    let mut out = Vec::new();
+    let mut i = 0;
+    while let Some(&c) = chars.get(i) {
+        match c {
+            c if c.is_whitespace() => i += 1,
+            '"' => {
+                let (text, next) = quoted(&chars, i, '"')?;
+                out.push(Token::Field(text));
+                i = next;
+            }
+            '\'' => {
+                let (text, next) = quoted(&chars, i, '\'')?;
+                out.push(Token::Text(text));
+                i = next;
+            }
+            '(' | ')' | ',' => {
+                out.push(Token::Word(c.to_string()));
+                i += 1;
+            }
+            '=' => {
+                out.push(Token::Word("=".into()));
+                i += 1;
+            }
+            '<' | '>' | '!' => {
+                let two: String = chars.get(i..(i + 2).min(chars.len())).unwrap_or_default().iter().collect();
+                let op = match two.as_str() {
+                    "<=" | ">=" | "<>" | "!=" => two,
+                    _ if c != '!' => c.to_string(),
+                    _ => return None,
+                };
+                i += op.chars().count();
+                out.push(Token::Word(op));
+            }
+            c if c.is_ascii_digit() || (c == '-' && chars.get(i + 1).is_some_and(char::is_ascii_digit)) => {
+                let start = i;
+                i += 1;
+                while chars.get(i).is_some_and(|d| d.is_ascii_digit() || *d == '.') {
+                    i += 1;
+                }
+                // An exponent: 1e3, 2.5E-4.
+                if chars.get(i).is_some_and(|e| *e == 'e' || *e == 'E') {
+                    let sign = usize::from(chars.get(i + 1).is_some_and(|s| *s == '-' || *s == '+'));
+                    if chars.get(i + 1 + sign).is_some_and(char::is_ascii_digit) {
+                        i += 1 + sign;
+                        while chars.get(i).is_some_and(char::is_ascii_digit) {
+                            i += 1;
+                        }
+                    }
+                }
+                let n: String = chars.get(start..i).unwrap_or_default().iter().collect();
+                n.parse::<f64>().ok()?;
+                out.push(Token::Word(n));
+            }
+            c if c.is_alphabetic() || c == '_' => {
+                let start = i;
+                while chars.get(i).is_some_and(|d| d.is_alphanumeric() || *d == '_') {
+                    i += 1;
+                }
+                let w: String = chars.get(start..i).unwrap_or_default().iter().collect();
+                // A word followed by a bracket is a function call.
+                let next = chars.get(i..).unwrap_or_default().iter().find(|c| !c.is_whitespace());
+                match keyword(&w) {
+                    Some(k) => out.push(Token::Word(k.into())),
+                    None if next == Some(&'(') => return None,
+                    None => out.push(Token::Field(w)),
+                }
+            }
+            // Arithmetic, concatenation, variables (@…) and the rest.
+            _ => return None,
+        }
+        if out.len() > 2000 {
+            return None;
+        }
+    }
+    (!out.is_empty()).then_some(out)
+}
+
+/// The text between the quote at `start` and its closing one (a doubled quote stands for
+/// itself), and where reading goes on.
+fn quoted(chars: &[char], start: usize, q: char) -> Option<(String, usize)> {
+    let mut text = String::new();
+    let mut i = start + 1;
+    loop {
+        match chars.get(i) {
+            None => return None,
+            Some(&c) if c == q && chars.get(i + 1) == Some(&q) => {
+                text.push(q);
+                i += 2;
+            }
+            Some(&c) if c == q => return Some((text, i + 1)),
+            Some(&c) => {
+                text.push(c);
+                i += 1;
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::to_sql;
+
+    #[test]
+    fn filters_carry_over_and_the_rest_is_refused() {
+        assert_eq!(to_sql(r#""Symbol" = 'Ortsteil_20-49'"#).as_deref(), Some(r#""Symbol" = 'Ortsteil_20-49'"#));
+        assert_eq!(
+            to_sql(r#"pop >= 1e3 AND ("name" ILIKE 'z%' OR kind IN ('a', 'b''s')) AND note IS NOT NULL"#).as_deref(),
+            Some(r#""pop" >= 1e3 AND ( "name" LIKE 'z%' OR "kind" IN ( 'a' , 'b''s' ) ) AND "note" IS NOT NULL"#)
+        );
+        assert_eq!(to_sql("a <> -2.5").as_deref(), Some(r#""a" <> -2.5"#));
+        for refused in ["upper(\"name\") = 'X'", "\"a\" + 1 > 2", "\"a\" || 'x' = 'y'", "@map_scale < 5000", "'unclosed", "", "a ! b"] {
+            assert_eq!(to_sql(refused), None, "{refused}");
+        }
+    }
+}
diff --git a/crates/map/src/qgis/labels.rs b/crates/map/src/qgis/labels.rs
new file mode 100644
index 000000000..9e507e626
--- /dev/null
+++ b/crates/map/src/qgis/labels.rs
@@ -0,0 +1,258 @@
+//! QGIS labels (`<labeling type="simple|rule-based">`) as RustGIS label classes: each rule a
+//! class whose SQL clause is its filter (and its parents'), an else rule the features no other
+//! rule takes; the text's field, size, colour, weight and slant, its buffer as a halo, its
+//! placement and its scale range.
+
+use roxmltree::Node;
+
+use super::{QGIS_SCALE, Report, child, color, expr};
+use crate::Rgba;
+use crate::symbology::{DEFAULT_LABEL_CLASS, LABEL_SIZE, LabelClass, LabelPlacement, Labeling, MAX_LABEL_CLASSES};
+
+/// A layer's labels from its `<labeling>`, or `None` when none can be carried over.
+pub(super) fn read(l: Node, layer: &str, report: &mut Report) -> Option<Labeling> {
+    let mut classes: Vec<LabelClass> = Vec::new();
+    match l.attribute("type") {
+        Some("simple") => {
+            let settings = child(l, "settings")?;
+            classes.extend(class(settings, DEFAULT_LABEL_CLASS, None, (None, None), layer, report));
+        }
+        Some("rule-based") => {
+            let mut rules = Vec::new();
+            if let Some(root) = child(l, "rules") {
+                flatten(root, Vec::new(), (None, None), &mut rules, 0);
+            }
+            for (i, r) in rules.iter().enumerate() {
+                let Some(settings) = child(r.node, "settings") else { continue };
+                let name = r
+                    .node
+                    .attribute("description")
+                    .filter(|d| !d.trim().is_empty())
+                    .map_or_else(|| format!("Rule {}", i + 1), str::to_string);
+                // Its filters and its parents', and for an else rule, none of its siblings'.
+                let mut parts: Vec<Option<String>> = r.filters.iter().map(|f| expr::to_sql(f)).collect();
+                if let Some(siblings) = &r.else_of {
+                    let others: Option<Vec<String>> = siblings.iter().map(|f| expr::to_sql(f)).collect();
+                    parts.push(others.map(|o| if o.is_empty() { String::new() } else { format!("NOT (({}))", o.join(") OR (")) }));
+                }
+                let where_ = parts.into_iter().collect::<Option<Vec<String>>>().map(|p| {
+                    let p: Vec<String> = p.into_iter().filter(|c| !c.is_empty()).collect();
+                    match p.as_slice() {
+                        [] => None,
+                        [one] => Some(one.clone()),
+                        many => Some(format!("({})", many.join(") AND ("))),
+                    }
+                });
+                let Some(where_) = where_ else {
+                    report.skipped(
+                        layer,
+                        format!(
+                            "the label rule \"{name}\", whose filter `{}` doesn't read as a RustGIS SQL clause",
+                            r.filters.join(" AND ")
+                        ),
+                    );
+                    continue;
+                };
+                if r.node.attribute("active") == Some("0") {
+                    continue;
+                }
+                classes.extend(class(settings, &name, where_, r.scales, layer, report));
+            }
+        }
+        Some(other) => {
+            report.skipped(layer, format!("its {other} labels"));
+            return None;
+        }
+        None => return None,
+    }
+    if classes.is_empty() {
+        return None;
+    }
+    if classes.len() > MAX_LABEL_CLASSES {
+        report.skipped(layer, format!("label rules past the first {MAX_LABEL_CLASSES}"));
+        classes.truncate(MAX_LABEL_CLASSES);
+    }
+    // A simple labeling is the Default class; rules are classes of their own, Default off.
+    let default = if l.attribute("type") == Some("simple") {
+        classes.remove(0)
+    } else {
+        let first = classes.first()?.clone();
+        LabelClass { name: DEFAULT_LABEL_CLASS.into(), visible: false, where_: None, ..first }
+    };
+    let classes = if l.attribute("type") == Some("simple") { Vec::new() } else { classes };
+    Some(Labeling { enabled: true, default, classes })
+}
+
+fn is_else(f: &str) -> bool {
+    f.trim().eq_ignore_ascii_case("ELSE")
+}
+
+/// A rule-based labeling's rule with settings: its filter and its parents' (an else rule's own
+/// left out), for an else rule its siblings' filters (it takes what none of them does), and the
+/// scale range along the way (RustGIS's min and max scale).
+struct Rule<'a, 'i> {
+    node: Node<'a, 'i>,
+    filters: Vec<String>,
+    else_of: Option<Vec<String>>,
+    scales: (Option<f64>, Option<f64>),
+}
+
+fn flatten<'a, 'i>(
+    node: Node<'a, 'i>,
+    filters: Vec<String>,
+    scales: (Option<f64>, Option<f64>),
+    out: &mut Vec<Rule<'a, 'i>>,
+    depth: usize,
+) {
+    if depth > 32 || out.len() > MAX_LABEL_CLASSES * 4 {
+        return;
+    }
+    let rules: Vec<Node> = node.children().filter(|c| c.has_tag_name("rule")).collect();
+    // The filters an else rule here is the rest of.
+    let siblings: Vec<String> = rules
+        .iter()
+        .filter_map(|r| r.attribute("filter").map(str::trim))
+        .filter(|f| !f.is_empty() && !is_else(f))
+        .map(str::to_string)
+        .collect();
+    for rule in rules {
+        let mut f = filters.clone();
+        let own = rule.attribute("filter").map(str::trim).filter(|f| !f.is_empty());
+        let else_of = own.filter(|o| is_else(o)).map(|_| siblings.clone());
+        if let Some(filter) = own.filter(|o| !is_else(o)) {
+            f.push(filter.to_string());
+        }
+        // A rule's scalemaxdenom is the out-beyond limit, its scalemindenom the in-beyond.
+        let denom = |k: &str| {
+            rule.attribute(k).and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite() && *v > 0.0).map(|v| v * QGIS_SCALE)
+        };
+        let s = (denom("scalemaxdenom").or(scales.0), denom("scalemindenom").or(scales.1));
+        if child(rule, "settings").is_some() {
+            out.push(Rule { node: rule, filters: f.clone(), else_of, scales: s });
+        }
+        flatten(rule, f, s, out, depth + 1);
+    }
+}
+
+/// A label class from QGIS's label `settings`, or `None` when its text can't be carried over.
+fn class(
+    settings: Node,
+    name: &str,
+    where_: Option<String>,
+    scales: (Option<f64>, Option<f64>),
+    layer: &str,
+    report: &mut Report,
+) -> Option<LabelClass> {
+    let text = child(settings, "text-style")?;
+    let field = text.attribute("fieldName").map(str::trim).unwrap_or_default();
+    let field = if text.attribute("isExpression") == Some("1") {
+        // An expression that is only a field.
+        let bare = field.strip_prefix('"').and_then(|f| f.strip_suffix('"')).unwrap_or(field);
+        if bare.is_empty() || !bare.chars().all(|c| c.is_alphanumeric() || c == '_' || c == ' ') {
+            report.skipped(layer, format!("labels whose text is the expression `{field}` (only a field's)"));
+            return None;
+        }
+        bare.to_string()
+    } else {
+        field.to_string()
+    };
+    if field.is_empty() {
+        return None;
+    }
+    let num = |n: Node, k: &str| n.attribute(k).and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite());
+    // The size in typographic points, as RustGIS's label sizes are.
+    let raw = num(text, "fontSize").unwrap_or(10.0);
+    let size = match text.attribute("fontSizeUnit").unwrap_or("Point") {
+        "Point" => raw,
+        "MM" => raw * 72.0 / 25.4,
+        "Pixel" => raw * 0.75,
+        "Inch" => raw * 72.0,
+        _ => {
+            report.approximated(layer, "label sizes in map units, taken at 1:25,000");
+            raw / 25_000.0 * 72.0 / 0.0254
+        }
+    };
+    let opacity = num(text, "textOpacity").unwrap_or(1.0).clamp(0.0, 1.0) as f32;
+    let c = text.attribute("textColor").and_then(color).unwrap_or(Rgba::rgb(0, 0, 0));
+    let c = c.with_alpha((f32::from(c.a()) * opacity).round() as u8);
+    let style = text.attribute("namedStyle").unwrap_or_default().to_ascii_lowercase();
+    let weight = num(text, "fontWeight").unwrap_or(50.0);
+    let bold = style.contains("bold")
+        || style.contains("black")
+        || style.contains("heavy")
+        || weight >= 63.0
+        || text.attribute("fontBold") == Some("1");
+    let italic = style.contains("italic") || style.contains("oblique") || text.attribute("fontItalic") == Some("1");
+    if let Some(family) = text.attribute("fontFamily").filter(|f| !f.is_empty()) {
+        report.approximated(layer, format!("labels in {family}, drawn in RustGIS's label font"));
+    }
+    if num(text, "fontLetterSpacing").is_some_and(|s| s != 0.0) {
+        report.approximated(layer, "label letter spacing, left out");
+    }
+    let halo = child(text, "text-buffer").is_some_and(|b| b.attribute("bufferDraw") == Some("1"));
+    if child(text, "background").is_some_and(|b| b.attribute("shapeDraw") == Some("1")) {
+        report.approximated(layer, "label backgrounds (shapes behind the text), left out");
+    }
+    if child(text, "shadow").is_some_and(|b| b.attribute("shadowDraw") == Some("1")) {
+        report.approximated(layer, "label shadows, left out");
+    }
+    let placement = child(settings, "placement").map_or(LabelPlacement::Auto, |p| placement(p, layer, report));
+    // The settings' own scale range, else the rule's.
+    let rendering = child(settings, "rendering");
+    let (mut min_scale, mut max_scale) = scales;
+    if let Some(r) = rendering.filter(|r| r.attribute("scaleVisibility") == Some("1")) {
+        min_scale = num(r, "scaleMin").filter(|v| *v > 0.0).map(|v| v * QGIS_SCALE).or(min_scale);
+        max_scale = num(r, "scaleMax").filter(|v| *v > 0.0).map(|v| v * QGIS_SCALE).or(max_scale);
+    }
+    Some(LabelClass {
+        name: name.to_string(),
+        visible: true,
+        where_,
+        field,
+        size: size.clamp(*LABEL_SIZE.start(), *LABEL_SIZE.end()) as f32,
+        color: c,
+        halo,
+        bold,
+        min_scale,
+        max_scale,
+        closest: None,
+        farthest: None,
+        placement,
+        italic,
+    })
+}
+
+/// QGIS's label placement, as RustGIS's.
+fn placement(p: Node, layer: &str, report: &mut Report) -> LabelPlacement {
+    let quad = |q: Option<&str>| match q {
+        Some("0") => LabelPlacement::AboveLeft,
+        Some("1") => LabelPlacement::Above,
+        Some("2") => LabelPlacement::AboveRight,
+        Some("3") => LabelPlacement::Left,
+        Some("5") => LabelPlacement::Right,
+        Some("6") => LabelPlacement::BelowLeft,
+        Some("7") => LabelPlacement::Below,
+        Some("8") => LabelPlacement::BelowRight,
+        _ => LabelPlacement::Center,
+    };
+    match p.attribute("placement").unwrap_or("0") {
+        // Around the point: QGIS picks the best spot, RustGIS's automatic is above it.
+        "0" | "6" => LabelPlacement::Auto,
+        "1" => quad(p.attribute("quadOffset")),
+        "2" => LabelPlacement::Parallel,
+        "3" => LabelPlacement::Curved,
+        "4" | "5" => LabelPlacement::Center,
+        other => {
+            report.approximated(layer, format!("label placement {}, centred", placement_name(other)));
+            LabelPlacement::Center
+        }
+    }
+}
+
+fn placement_name(code: &str) -> &'static str {
+    match code {
+        "7" => "around polygon outlines",
+        "8" => "outside polygons",
+        _ => "of an unknown kind",
+    }
+}
diff --git a/crates/map/src/qgis/mod.rs b/crates/map/src/qgis/mod.rs
new file mode 100644
index 000000000..3769f0123
--- /dev/null
+++ b/crates/map/src/qgis/mod.rs
@@ -0,0 +1,435 @@
+//! QGIS projects (`.qgs`) and layer styles (`.qml`) read into RustGIS: a project's layers (their
+//! data sources, order, visibility, scale ranges and opacity), its coordinate system and view,
+//! and each layer's style (renderer, symbols, labels, reference scale and symbol levels), as the
+//! map's own types. What RustGIS can't draw as QGIS does is carried over as near as it can, and
+//! the [`Report`] says so, layer by layer: nothing is left out without a note.
+//!
+//! The XML is hostile input: it is read with a node limit and no DTD, every list is bounded, and
+//! sizes and scales are brought into range before they reach a layer. Both of QGIS's ways of
+//! writing a symbol layer's settings are read: the `<Option type="Map">` of QGIS 3.26 and later,
+//! and the `<prop k="…" v="…">` before it.
+
+mod expr;
+mod labels;
+mod renderer;
+mod source;
+mod symbol;
+#[cfg(test)]
+mod tests;
+
+use roxmltree::{Document, Node, ParsingOptions};
+use serde::Serialize;
+
+use crate::Rgba;
+use crate::effects::Blend;
+use crate::symbology::{Labeling, LineStroke, Renderer};
+pub use expr::to_sql;
+pub use source::Source;
+
+/// The most XML nodes a project or style is read with (a large project's file is some hundred
+/// thousand).
+const MAX_NODES: u32 = 5_000_000;
+/// The most layers read from a project.
+pub const MAX_LAYERS: usize = 1000;
+/// The most notes a report keeps.
+const MAX_NOTES: usize = 5000;
+
+/// RustGIS's scale takes a screen pixel to be 0.28 mm (OGC); QGIS works out its scale at the
+/// screen's 96 dots to the inch. The same view is a larger scale in QGIS by this much, so QGIS's
+/// scales (reference scales, visibility ranges) are multiplied by it.
+pub const QGIS_SCALE: f64 = (25.4 / 96.0) / 0.28;
+
+/// What an import carried over only in part, or left out, layer by layer.
+#[derive(Clone, Debug, Default, PartialEq, Serialize)]
+pub struct Report {
+    pub notes: Vec<Note>,
+}
+
+/// One thing an import couldn't carry over as QGIS has it.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct Note {
+    /// The layer it is about (empty for the project).
+    pub layer: String,
+    pub kind: NoteKind,
+    pub text: String,
+    /// How many times it came up (once per symbol, class or rule it applies to).
+    pub count: usize,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum NoteKind {
+    /// Drawn, but not quite as QGIS draws it.
+    Approximated,
+    /// Not carried over at all.
+    Skipped,
+}
+
+impl Report {
+    /// Notes `text` about `layer`, counting a repeat rather than listing it again.
+    pub fn note(&mut self, layer: &str, kind: NoteKind, text: impl Into<String>) {
+        let text = text.into();
+        if let Some(n) = self.notes.iter_mut().find(|n| n.layer == layer && n.kind == kind && n.text == text) {
+            n.count = n.count.saturating_add(1);
+        } else if self.notes.len() < MAX_NOTES {
+            self.notes.push(Note { layer: layer.to_string(), kind, text, count: 1 });
+        }
+    }
+
+    pub fn approximated(&mut self, layer: &str, text: impl Into<String>) {
+        self.note(layer, NoteKind::Approximated, text);
+    }
+
+    pub fn skipped(&mut self, layer: &str, text: impl Into<String>) {
+        self.note(layer, NoteKind::Skipped, text);
+    }
+
+    /// Takes in another report's notes, on top of its own.
+    pub fn extend(&mut self, other: Report) {
+        for n in other.notes {
+            for _ in 0..n.count.min(MAX_NOTES) {
+                self.note(&n.layer, n.kind, n.text.clone());
+            }
+        }
+    }
+}
+
+/// A layer's look as a QGIS style has it, in RustGIS's terms. Each part is `None` (or empty) when
+/// the style doesn't set it, so applying it leaves the layer's own.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Style {
+    pub renderer: Option<Renderer>,
+    /// A line layer's stacked strokes (a single-symbol line with more than one line, or an
+    /// offset one).
+    pub line_strokes: Option<Vec<LineStroke>>,
+    pub stroke_levels: Option<bool>,
+    pub reference_scale: Option<f64>,
+    pub labels: Option<Labeling>,
+    /// 0 opaque to 100 invisible.
+    pub transparency: Option<f32>,
+    pub blend: Option<Blend>,
+    /// Drawn between these scales (RustGIS's, see [`QGIS_SCALE`]): zoomed in beyond 1:`min_scale`
+    /// and out beyond 1:`max_scale`. `Some(None)` clears a limit.
+    pub min_scale: Option<Option<f64>>,
+    pub max_scale: Option<Option<f64>>,
+}
+
+impl Style {
+    /// Gives `layer` this style's parts (those it sets).
+    pub fn apply(&self, layer: &mut crate::Layer) {
+        if let Some(r) = &self.renderer {
+            layer.renderer = r.clone();
+        }
+        if let Some(s) = &self.line_strokes {
+            layer.line_strokes = s.clone();
+        }
+        if let Some(on) = self.stroke_levels {
+            layer.stroke_levels = on;
+        }
+        if let Some(r) = self.reference_scale {
+            layer.reference_scale = Some(r);
+        }
+        if let Some(l) = &self.labels {
+            layer.labels = l.clone();
+        }
+        if let Some(t) = self.transparency {
+            layer.transparency = t;
+        }
+        if let Some(b) = self.blend {
+            layer.blend = b;
+        }
+        if let Some(s) = self.min_scale {
+            layer.min_scale = s;
+        }
+        if let Some(s) = self.max_scale {
+            layer.max_scale = s;
+        }
+    }
+}
+
+/// A QGIS project's layers and view, read from its `.qgs` text.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Project {
+    pub title: String,
+    /// The project's coordinate system (`EPSG:2056`, or a PROJ string), the map's projection.
+    pub crs: Option<String>,
+    /// The view when it was saved: [xmin, ymin, xmax, ymax] in the project's coordinate system.
+    pub extent: Option<[f64; 4]>,
+    /// Its layers, top first, as its layer tree orders them.
+    pub layers: Vec<ProjectLayer>,
+}
+
+/// One layer of a QGIS project.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ProjectLayer {
+    pub id: String,
+    pub name: String,
+    /// QGIS's data provider (`ogr`, `gdal`, `wms`, `delimitedtext`, …).
+    pub provider: String,
+    pub source: Source,
+    /// Its coordinate system (`EPSG:…`), when QGIS records one.
+    pub crs: Option<String>,
+    /// A vector layer (`false`: raster, mesh, point cloud and the like).
+    pub vector: bool,
+    /// Checked in the layer tree, and every group holding it too.
+    pub visible: bool,
+    /// Its subset string, as a RustGIS definition query when it reads as one.
+    pub definition_query: Option<String>,
+    pub style: Style,
+}
+
+/// Reads a QGIS project. `dir` is the folder the project is in, which its relative paths start
+/// from. Notes on what can't be carried over go to `report`.
+pub fn read_project(text: &str, dir: &str, report: &mut Report) -> Result<Project, String> {
+    let doc = parse(text, "a QGIS project")?;
+    let root = doc.root_element();
+    if !root.has_tag_name("qgis") {
+        return Err("not a QGIS project (.qgs): its root element isn't <qgis>".into());
+    }
+    let mut project = Project {
+        title: child(root, "title").and_then(|t| t.text()).map(str::trim).unwrap_or_default().to_string(),
+        crs: child(root, "projectCrs").and_then(crs_of),
+        extent: None,
+        layers: Vec::new(),
+    };
+    // The main map canvas's view.
+    let canvas = root.children().find(|c| c.has_tag_name("mapcanvas") && c.attribute("name").is_none_or(|n| n == "theMapCanvas"));
+    project.extent = canvas.and_then(|c| child(c, "extent")).and_then(extent_of);
+    // The layer tree: the order layers draw in (top first) and which are checked.
+    let tree = child(root, "layer-tree-group");
+    let mut order: Vec<(String, bool)> = Vec::new();
+    if let Some(t) = tree {
+        tree_layers(t, true, &mut order, 0);
+    }
+    let maplayers: Vec<Node> =
+        child(root, "projectlayers").map(|p| p.children().filter(|c| c.has_tag_name("maplayer")).collect()).unwrap_or_default();
+    if maplayers.len() > MAX_LAYERS {
+        report.skipped("", format!("layers past the first {MAX_LAYERS}"));
+    }
+    let mut layers: Vec<(Option<usize>, ProjectLayer)> = Vec::new();
+    for ml in maplayers.into_iter().take(MAX_LAYERS) {
+        let id = child(ml, "id").and_then(|n| n.text()).unwrap_or_default().trim().to_string();
+        let name = child(ml, "layername").and_then(|n| n.text()).unwrap_or_default().trim().to_string();
+        let name = if name.is_empty() { id.clone() } else { name };
+        let at = order.iter().position(|(i, _)| *i == id);
+        let checked = at.and_then(|i| order.get(i)).is_none_or(|(_, c)| *c);
+        let provider = child(ml, "provider").and_then(|n| n.text()).unwrap_or_default().trim().to_string();
+        let datasource = child(ml, "datasource").and_then(|n| n.text()).unwrap_or_default().trim().to_string();
+        let source = source::read(&provider, &datasource, dir);
+        let vector = ml.attribute("type") == Some("vector");
+        let definition_query = match &source {
+            Source::File { subset: Some(q), .. } => match expr::to_sql(q) {
+                Some(sql) => Some(sql),
+                None => {
+                    report.skipped(&name, format!("its filter (subset string) `{q}`, which doesn't read as a RustGIS definition query"));
+                    None
+                }
+            },
+            _ => None,
+        };
+        let style = read_style_node(ml, &name, report);
+        layers.push((
+            at,
+            ProjectLayer {
+                id,
+                name,
+                provider,
+                source,
+                crs: child(ml, "srs").and_then(crs_of),
+                vector,
+                visible: checked,
+                definition_query,
+                style,
+            },
+        ));
+    }
+    // In the layer tree's order; layers it doesn't hold go below.
+    layers.sort_by_key(|(at, _)| at.unwrap_or(usize::MAX));
+    project.layers = layers.into_iter().map(|(_, l)| l).collect();
+    Ok(project)
+}
+
+/// Reads a QGIS layer style (a `.qml` file's text) for the layer named `layer` (for the notes).
+pub fn read_style(text: &str, layer: &str, report: &mut Report) -> Result<Style, String> {
+    let doc = parse(text, "a QGIS layer style")?;
+    let root = doc.root_element();
+    if !root.has_tag_name("qgis") {
+        return Err("not a QGIS layer style (.qml): its root element isn't <qgis>".into());
+    }
+    Ok(read_style_node(root, layer, report))
+}
+
+/// A layer's style from its `<maplayer>` (a project's) or a style file's `<qgis>` root.
+fn read_style_node(node: Node, layer: &str, report: &mut Report) -> Style {
+    let mut style = Style::default();
+    let opacity = child(node, "layerOpacity").and_then(|n| n.text()).and_then(|t| t.trim().parse::<f32>().ok());
+    if let Some(o) = opacity.filter(|o| o.is_finite()) {
+        style.transparency = Some(((1.0 - o.clamp(0.0, 1.0)) * 100.0).round());
+    }
+    if let Some(mode) = child(node, "blendMode").and_then(|n| n.text()).and_then(|t| t.trim().parse::<i32>().ok()) {
+        style.blend = Some(blend_of(mode).unwrap_or_else(|| {
+            report.approximated(layer, "its blending mode, drawn as Normal");
+            Blend::Normal
+        }));
+    }
+    if node.attribute("hasScaleBasedVisibilityFlag") == Some("1") {
+        // QGIS's minScale is the out-beyond limit (the larger number), maxScale the in-beyond.
+        let scale = |k: &str| node.attribute(k).and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite() && *v > 0.0);
+        style.min_scale = Some(scale("minScale").map(|s| s * QGIS_SCALE));
+        style.max_scale = Some(scale("maxScale").map(|s| s * QGIS_SCALE));
+    }
+    if let Some(r) = child(node, "renderer-v2") {
+        renderer::read(r, layer, &mut style, report);
+    }
+    // A raster's renderer: its opacity carried over, its colouring not yet.
+    if let Some(r) = child(node, "pipe").and_then(|p| child(p, "rasterrenderer")) {
+        if let Some(o) = r.attribute("opacity").and_then(|o| o.trim().parse::<f32>().ok()).filter(|o| o.is_finite() && *o < 1.0) {
+            style.transparency = Some(((1.0 - o.clamp(0.0, 1.0)) * 100.0).round());
+        }
+        report.skipped(layer, format!("its raster colouring ({} renderer)", r.attribute("type").unwrap_or("unknown")));
+    }
+    if node.attribute("labelsEnabled") != Some("0")
+        && let Some(l) = child(node, "labeling")
+    {
+        style.labels = labels::read(l, layer, report);
+    }
+    if node.attribute("labelsEnabled") == Some("0")
+        && let Some(l) = child(node, "labeling")
+    {
+        // Set up but switched off: carried over, switched off.
+        style.labels = labels::read(l, layer, report).map(|mut l| {
+            l.enabled = false;
+            l
+        });
+    }
+    style
+}
+
+/// The layers in a layer tree group, top first, each with whether it is checked (and every
+/// group above it). Groups are walked to a bounded depth.
+fn tree_layers(group: Node, checked: bool, out: &mut Vec<(String, bool)>, depth: usize) {
+    if depth > 64 || out.len() > MAX_LAYERS * 4 {
+        return;
+    }
+    let on = |n: Node| n.attribute("checked").is_none_or(|c| c == "Qt::Checked" || c == "Qt::PartiallyChecked");
+    for c in group.children().filter(Node::is_element) {
+        if c.has_tag_name("layer-tree-layer") {
+            if let Some(id) = c.attribute("id") {
+                out.push((id.to_string(), checked && on(c)));
+            }
+        } else if c.has_tag_name("layer-tree-group") {
+            tree_layers(c, checked && on(c), out, depth + 1);
+        }
+    }
+}
+
+/// QGIS's blending modes (`QPainter::CompositionMode`) RustGIS has.
+fn blend_of(mode: i32) -> Option<Blend> {
+    Some(match mode {
+        0 => Blend::Normal,
+        13 => Blend::Multiply,
+        14 => Blend::Screen,
+        15 => Blend::Overlay,
+        16 => Blend::Darken,
+        17 => Blend::Lighten,
+        22 => Blend::Difference,
+        _ => return None,
+    })
+}
+
+/// A coordinate system element's (`<srs>`, `<projectCrs>`) `EPSG:…`, or its PROJ string.
+fn crs_of(node: Node) -> Option<String> {
+    let srs = node.descendants().find(|d| d.has_tag_name("spatialrefsys"))?;
+    let text = |tag: &str| child(srs, tag).and_then(|n| n.text()).map(str::trim).filter(|t| !t.is_empty());
+    text("authid").filter(|a| a.contains(':')).or_else(|| text("proj4")).map(str::to_string)
+}
+
+/// An `<extent>`'s [xmin, ymin, xmax, ymax], when all four are numbers and it isn't empty.
+fn extent_of(node: Node) -> Option<[f64; 4]> {
+    let v = |tag: &str| child(node, tag).and_then(|n| n.text()).and_then(|t| t.trim().parse::<f64>().ok()).filter(|v| v.is_finite());
+    let e = [v("xmin")?, v("ymin")?, v("xmax")?, v("ymax")?];
+    (e[0] < e[2] && e[1] < e[3]).then_some(e)
+}
+
+/// Parses QGIS's XML with a node limit. QGIS starts its files with `<!DOCTYPE qgis …>`, which
+/// declares nothing: the document is read from past it, and one declaring entities (`[…]`) is
+/// refused rather than expanded.
+fn parse<'a>(text: &'a str, what: &str) -> Result<Document<'a>, String> {
+    let opts = ParsingOptions { allow_dtd: false, nodes_limit: MAX_NODES, ..ParsingOptions::default() };
+    let doctype = text.find("<!DOCTYPE").filter(|at| text.get(..*at).is_some_and(|before| !before.contains("<q")));
+    let Some(at) = doctype else {
+        return Document::parse_with_options(text, opts).map_err(|e| format!("not {what}: {e}"));
+    };
+    let end = text.get(at..).and_then(|t| t.find('>')).map(|e| at + e + 1).ok_or_else(|| format!("not {what}: an unclosed <!DOCTYPE"))?;
+    if text.get(at..end).is_some_and(|d| d.contains('[')) {
+        return Err(format!("not {what}: it declares entities (a DTD), which aren't read"));
+    }
+    let rest = text.get(end..).unwrap_or_default();
+    Document::parse_with_options(rest, opts).map_err(|e| format!("not {what}: {e}"))
+}
+
+/// The first child element named `tag`.
+fn child<'a, 'i>(node: Node<'a, 'i>, tag: &str) -> Option<Node<'a, 'i>> {
+    node.children().find(|c| c.has_tag_name(tag))
+}
+
+/// A symbol layer's (or ramp's) settings, by name: QGIS 3.26's `<Option type="Map">` and the
+/// `<prop k v>` before it.
+pub(crate) fn props(node: Node) -> Vec<(String, String)> {
+    let mut props = Vec::new();
+    for c in node.children().filter(Node::is_element) {
+        if c.has_tag_name("prop")
+            && let (Some(k), Some(v)) = (c.attribute("k"), c.attribute("v"))
+        {
+            props.push((k.to_string(), v.to_string()));
+        }
+        if c.has_tag_name("Option") {
+            for o in c.children().filter(|o| o.has_tag_name("Option")) {
+                if let (Some(k), Some(v)) = (o.attribute("name"), o.attribute("value")) {
+                    props.push((k.to_string(), v.to_string()));
+                }
+            }
+        }
+    }
+    props
+}
+
+/// The setting `k` of `props`.
+fn prop<'a>(props: &'a [(String, String)], k: &str) -> Option<&'a str> {
+    props.iter().find(|(n, _)| n == k).map(|(_, v)| v.as_str())
+}
+
+/// A QGIS colour: `r,g,b[,a]` (newer files add `,rgb:…` after), or `#rrggbb[aa]`.
+pub(crate) fn color(s: &str) -> Option<Rgba> {
+    let s = s.trim();
+    if s.starts_with('#') {
+        return Rgba::from_hex(s);
+    }
+    let v: Vec<u8> = s.split(',').take(4).map(|p| p.trim().parse::<u8>().ok()).collect::<Option<_>>()?;
+    match v.as_slice() {
+        [r, g, b] => Some(Rgba::rgb(*r, *g, *b)),
+        [r, g, b, a] => Some(Rgba::new(*r, *g, *b, *a)),
+        _ => None,
+    }
+}
+
+/// A size in QGIS's `unit` as RustGIS points (1/96 inch, a screen pixel at 1×). Map units have
+/// no fixed size on screen: they are taken at the layer's reference scale when it has one
+/// (`reference`, RustGIS's), else as metres at 1:25,000, and noted.
+fn points(v: f64, unit: Option<&str>, reference: Option<f64>, layer: &str, report: &mut Report) -> f32 {
+    let pt = match unit.unwrap_or("MM") {
+        "MM" => v * 96.0 / 25.4,
+        "Point" => v * 96.0 / 72.0,
+        "Pixel" => v,
+        "Inch" => v * 96.0,
+        "MapUnit" | "RenderMetersInMapUnits" => {
+            report.approximated(layer, "sizes in map units, taken at a fixed scale");
+            v / reference.unwrap_or(25_000.0) * 96.0 / 0.0254
+        }
+        other => {
+            report.approximated(layer, format!("sizes in {other}, taken as millimetres"));
+            v * 96.0 / 25.4
+        }
+    };
+    if pt.is_finite() { pt.clamp(0.0, 1000.0) as f32 } else { 0.0 }
+}
diff --git a/crates/map/src/qgis/renderer.rs b/crates/map/src/qgis/renderer.rs
new file mode 100644
index 000000000..1b529b3bf
--- /dev/null
+++ b/crates/map/src/qgis/renderer.rs
@@ -0,0 +1,325 @@
+//! QGIS renderers (`<renderer-v2>`) as RustGIS ones: single symbol, categorized (Unique Values),
+//! graduated (Graduated Colors), rule-based (Unique Values where every rule picks values of one
+//! field), the null renderer, and the renderers that wrap another (point cluster and
+//! displacement, inverted polygons, merged features) by the one inside.
+
+use std::collections::BTreeMap;
+
+use roxmltree::Node;
+
+use super::symbol::{self, Converted};
+use super::{QGIS_SCALE, Report, Style, child, expr};
+use crate::color::Ramp;
+use crate::symbology::{ClassMethod, LineStroke, Renderer, Symbol};
+
+/// The most classes a renderer is imported with: every feature is matched against them.
+const MAX_CLASSES: usize = 4096;
+
+/// Reads the renderer `r` into `style`: its renderer, a line layer's strokes, and its reference
+/// scale and symbol levels.
+pub(super) fn read(r: Node, layer: &str, style: &mut Style, report: &mut Report) {
+    read_depth(r, layer, style, report, 0);
+}
+
+fn read_depth(r: Node, layer: &str, style: &mut Style, report: &mut Report, depth: usize) {
+    // QGIS's reference scale (its own scale, at 96 dpi): kept for sizes in map units.
+    let reference = r.attribute("referencescale").and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite() && *v > 0.0);
+    if let Some(s) = reference {
+        style.reference_scale = Some((s * QGIS_SCALE).clamp(1.0, 1e9));
+    }
+    if r.attribute("symbollevels") == Some("1") {
+        style.stroke_levels = Some(true);
+    }
+    // The symbols the renderer names, by name.
+    let symbols: BTreeMap<String, Node> = child(r, "symbols")
+        .map(|s| {
+            s.children()
+                .filter(|c| c.has_tag_name("symbol"))
+                .filter_map(|c| Some((c.attribute("name")?.to_string(), c)))
+                .take(MAX_CLASSES * 2)
+                .collect()
+        })
+        .unwrap_or_default();
+    let sym = |name: Option<&str>, report: &mut Report| -> Option<Converted> {
+        symbols.get(name?).map(|n| symbol::read(*n, reference, layer, report))
+    };
+    let kind = r.attribute("type").unwrap_or_default();
+    match kind {
+        "singleSymbol" => {
+            let Some(c) = sym(Some("0"), report).or_else(|| symbols.values().next().map(|n| symbol::read(*n, reference, layer, report)))
+            else {
+                return;
+            };
+            style.line_strokes = Some(if c.stacked() { c.strokes.clone() } else { Vec::new() });
+            style.renderer = Some(Renderer::Single(c.symbol));
+        }
+        "nullSymbol" => {
+            style.renderer = Some(Renderer::Single(symbol::hidden()));
+            style.line_strokes = Some(Vec::new());
+        }
+        "categorizedSymbol" => categorized(r, layer, style, report, &sym),
+        "graduatedSymbol" => graduated(r, layer, style, report, &sym),
+        "RuleRenderer" => rules(r, layer, style, report, &sym),
+        "pointCluster" | "pointDisplacement" | "invertedPolygonRenderer" | "mergedFeatureRenderer" | "25dRenderer" => {
+            report.approximated(layer, format!("its {} renderer, drawn by the renderer inside it", wrapper_name(kind)));
+            if let Some(inner) = child(r, "renderer-v2").filter(|_| depth < 8) {
+                read_depth(inner, layer, style, report, depth + 1);
+            }
+        }
+        "heatmapRenderer" => report.skipped(layer, "its heatmap renderer"),
+        other => report.skipped(layer, format!("its {other} renderer")),
+    }
+}
+
+/// A renderer's classifying attribute as a field: `name` or `"name"`; `None` for an expression.
+fn field_of(attr: &str, layer: &str, report: &mut Report) -> Option<String> {
+    let a = attr.trim();
+    let unquoted = a.strip_prefix('"').and_then(|s| s.strip_suffix('"')).unwrap_or(a);
+    if !unquoted.is_empty() && !unquoted.contains('"') && (a.starts_with('"') || unquoted.chars().all(|c| c.is_alphanumeric() || c == '_'))
+    {
+        return Some(unquoted.to_string());
+    }
+    report.skipped(layer, format!("classes by the expression `{a}` (only by a field)"));
+    None
+}
+
+type SymbolOf<'a> = dyn Fn(Option<&str>, &mut Report) -> Option<Converted> + 'a;
+
+fn categorized(r: Node, layer: &str, style: &mut Style, report: &mut Report, sym: &SymbolOf) {
+    let cats: Vec<Node> = child(r, "categories").map(|c| c.children().filter(|n| n.has_tag_name("category")).collect()).unwrap_or_default();
+    let Some(field) = field_of(r.attribute("attr").unwrap_or_default(), layer, report) else {
+        // Drawn as one: the first category's symbol.
+        if let Some(c) = cats.first().and_then(|c| sym(c.attribute("symbol"), report)) {
+            style.renderer = Some(Renderer::Single(c.symbol));
+        }
+        return;
+    };
+    let mut classes: Vec<(String, Symbol)> = Vec::new();
+    let (mut class_labels, mut class_strokes) = (BTreeMap::new(), BTreeMap::new());
+    let mut other = symbol::hidden();
+    let mut other_strokes = Vec::new();
+    for cat in &cats {
+        let Some(mut c) = sym(cat.attribute("symbol"), report) else { continue };
+        if cat.attribute("render") == Some("false") {
+            c = Converted { symbol: symbol::hidden(), strokes: Vec::new() };
+        }
+        // A category of several values (QGIS's merged categories) lists them as <val>s.
+        let mut values: Vec<String> = cat
+            .descendants()
+            .filter(|v| v.has_tag_name("Option") && v.attribute("type") == Some("QString"))
+            .filter_map(|v| v.attribute("value").map(str::to_string))
+            .collect();
+        if values.is_empty() {
+            values.push(cat.attribute("value").unwrap_or_default().to_string());
+        }
+        for v in values {
+            // An empty value is QGIS's "all other values".
+            if v.is_empty() || v == "NULL" {
+                other = c.symbol;
+                other_strokes = if c.stacked() { c.strokes.clone() } else { Vec::new() };
+                continue;
+            }
+            if classes.len() >= MAX_CLASSES {
+                report.skipped(layer, format!("categories past the first {MAX_CLASSES}"));
+                break;
+            }
+            if let Some(label) = cat.attribute("label").filter(|l| *l != v && !l.is_empty()) {
+                class_labels.insert(v.clone(), label.to_string());
+            }
+            if c.stacked() {
+                class_strokes.insert(v.clone(), c.strokes.clone());
+            }
+            classes.push((v, c.symbol));
+        }
+    }
+    style.line_strokes = Some(Vec::new());
+    style.renderer = Some(Renderer::Unique {
+        field,
+        classes,
+        other,
+        ramp: Ramp::default(),
+        class_labels,
+        other_label: None,
+        class_strokes,
+        other_strokes,
+    });
+}
+
+fn graduated(r: Node, layer: &str, style: &mut Style, report: &mut Report, sym: &SymbolOf) {
+    let mut ranges: Vec<(f64, f64, Converted, Option<String>)> = Vec::new();
+    for rg in child(r, "ranges").map(|c| c.children().filter(|n| n.has_tag_name("range")).collect::<Vec<_>>()).unwrap_or_default() {
+        let num = |k: &str| rg.attribute(k).and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite());
+        let (Some(lower), Some(upper)) = (num("lower"), num("upper")) else { continue };
+        let Some(mut c) = sym(rg.attribute("symbol"), report) else { continue };
+        if rg.attribute("render") == Some("false") {
+            c = Converted { symbol: symbol::hidden(), strokes: Vec::new() };
+        }
+        ranges.push((lower, upper, c, rg.attribute("label").map(str::to_string)));
+        if ranges.len() >= MAX_CLASSES {
+            report.skipped(layer, format!("ranges past the first {MAX_CLASSES}"));
+            break;
+        }
+    }
+    let Some(field) = field_of(r.attribute("attr").unwrap_or_default(), layer, report) else {
+        if let Some((.., c, _)) = ranges.first() {
+            style.renderer = Some(Renderer::Single(c.symbol));
+        }
+        return;
+    };
+    if ranges.is_empty() {
+        return;
+    }
+    ranges.sort_by(|a, b| a.0.total_cmp(&b.0));
+    if ranges.windows(2).any(|w| w.first().map(|a| a.1) != w.get(1).map(|b| b.0)) {
+        report.approximated(layer, "ranges with gaps or overlaps between them, drawn as if each began where the one before ends");
+    }
+    let min = ranges.first().map_or(0.0, |r| r.0);
+    let mut class_labels = BTreeMap::new();
+    let mut class_strokes: BTreeMap<usize, Vec<LineStroke>> = BTreeMap::new();
+    for (i, (.., c, label)) in ranges.iter().enumerate() {
+        if let Some(l) = label.as_ref().filter(|l| !l.is_empty()) {
+            class_labels.insert(i, l.clone());
+        }
+        if c.stacked() {
+            class_strokes.insert(i, c.strokes.clone());
+        }
+    }
+    style.line_strokes = Some(Vec::new());
+    style.renderer = Some(Renderer::Graduated {
+        field,
+        breaks: ranges.iter().map(|r| r.1).collect(),
+        symbols: ranges.iter().map(|r| r.2.symbol).collect(),
+        ramp: Ramp::default(),
+        method: ClassMethod::default(),
+        min,
+        class_labels,
+        class_strokes,
+    });
+}
+
+/// A rule of a rule-based renderer that draws: its filter and its parents' (`ELSE` for an else
+/// rule), and whether a scale range applies along the way.
+struct Rule<'a, 'i> {
+    filters: Vec<String>,
+    node: Node<'a, 'i>,
+    scaled: bool,
+}
+
+fn rules(r: Node, layer: &str, style: &mut Style, report: &mut Report, sym: &SymbolOf) {
+    let mut leaves = Vec::new();
+    if let Some(root) = child(r, "rules") {
+        flatten(root, Vec::new(), false, &mut leaves, 0);
+    }
+    // Rules that draw: those with a symbol and not switched off.
+    let drawn: Vec<&Rule> =
+        leaves.iter().filter(|l| l.node.attribute("symbol").is_some() && l.node.attribute("active") != Some("0")).collect();
+    if drawn.iter().any(|l| l.scaled) {
+        report.approximated(layer, "rules shown only at some scales, drawn at every scale");
+    }
+    // Every rule picks values of one field (an else rule for the rest): Unique Values.
+    let mut field: Option<String> = None;
+    let mut classes: Vec<(String, Converted, Option<String>)> = Vec::new();
+    let mut other: Option<Converted> = None;
+    let mut simple = !drawn.is_empty();
+    for rule in &drawn {
+        let Some(c) = sym(rule.node.attribute("symbol"), report) else { continue };
+        let label = rule.node.attribute("label").map(str::to_string);
+        if rule.filters.iter().any(|f| f.trim().eq_ignore_ascii_case("ELSE")) {
+            if rule.filters.len() == 1 {
+                other = Some(c);
+                continue;
+            }
+            simple = false;
+            break;
+        }
+        let parts: Option<Vec<(String, Vec<String>)>> = rule.filters.iter().map(|f| expr::equality(f)).collect();
+        match parts.as_deref() {
+            Some([(f, values)]) if field.as_ref().is_none_or(|g| g.eq_ignore_ascii_case(f)) => {
+                field = Some(f.clone());
+                for v in values {
+                    if classes.len() < MAX_CLASSES {
+                        classes.push((v.clone(), c.clone(), label.clone()));
+                    }
+                }
+            }
+            _ => {
+                simple = false;
+                break;
+            }
+        }
+    }
+    if simple && let Some(field) = field {
+        let mut class_strokes = BTreeMap::new();
+        let mut class_labels = BTreeMap::new();
+        for (v, c, label) in &classes {
+            if c.stacked() {
+                class_strokes.insert(v.clone(), c.strokes.clone());
+            }
+            if let Some(l) = label.as_ref().filter(|l| !l.is_empty() && *l != v) {
+                class_labels.insert(v.clone(), l.clone());
+            }
+        }
+        let (other_symbol, other_strokes) = match &other {
+            Some(c) => (c.symbol, if c.stacked() { c.strokes.clone() } else { Vec::new() }),
+            None => (symbol::hidden(), Vec::new()),
+        };
+        style.line_strokes = Some(Vec::new());
+        style.renderer = Some(Renderer::Unique {
+            field,
+            classes: classes.into_iter().map(|(v, c, _)| (v, c.symbol)).collect(),
+            other: other_symbol,
+            ramp: Ramp::default(),
+            class_labels,
+            other_label: None,
+            class_strokes,
+            other_strokes,
+        });
+        return;
+    }
+    // One rule (or none but an else): its symbol for every feature.
+    if drawn.len() == 1 && drawn.first().is_some_and(|r| r.filters.is_empty()) || drawn.is_empty() {
+        if let Some(c) = drawn.first().and_then(|r| sym(r.node.attribute("symbol"), report)) {
+            style.line_strokes = Some(if c.stacked() { c.strokes.clone() } else { Vec::new() });
+            style.renderer = Some(Renderer::Single(c.symbol));
+        }
+        return;
+    }
+    report
+        .approximated(layer, format!("its {} rules (filters beyond one field's values), drawn with the first rule's symbol", drawn.len()));
+    if let Some(c) = drawn.first().and_then(|r| sym(r.node.attribute("symbol"), report)) {
+        style.line_strokes = Some(if c.stacked() { c.strokes.clone() } else { Vec::new() });
+        style.renderer = Some(Renderer::Single(c.symbol));
+    }
+}
+
+/// The leaf rules under `node`, each with its own filter and its parents', and whether a scale
+/// range applies along the way. Bounded in depth and number.
+fn flatten<'a, 'i>(node: Node<'a, 'i>, filters: Vec<String>, scaled: bool, out: &mut Vec<Rule<'a, 'i>>, depth: usize) {
+    if depth > 32 || out.len() >= MAX_CLASSES {
+        return;
+    }
+    for rule in node.children().filter(|c| c.has_tag_name("rule")) {
+        let mut f = filters.clone();
+        if let Some(filter) = rule.attribute("filter").map(str::trim).filter(|f| !f.is_empty()) {
+            f.push(filter.to_string());
+        }
+        let scaled = scaled || rule.attribute("scalemindenom").is_some() || rule.attribute("scalemaxdenom").is_some();
+        let children = rule.children().any(|c| c.has_tag_name("rule"));
+        if rule.attribute("symbol").is_some() || !children {
+            out.push(Rule { filters: f.clone(), node: rule, scaled });
+        }
+        if children {
+            flatten(rule, f, scaled, out, depth + 1);
+        }
+    }
+}
+
+fn wrapper_name(kind: &str) -> &'static str {
+    match kind {
+        "pointCluster" => "point cluster",
+        "pointDisplacement" => "point displacement",
+        "invertedPolygonRenderer" => "inverted polygon",
+        "mergedFeatureRenderer" => "merged feature",
+        _ => "2.5D",
+    }
+}
diff --git a/crates/map/src/qgis/source.rs b/crates/map/src/qgis/source.rs
new file mode 100644
index 000000000..ed3709034
--- /dev/null
+++ b/crates/map/src/qgis/source.rs
@@ -0,0 +1,227 @@
+//! QGIS data sources: a layer's provider and `<datasource>` text, read into where RustGIS finds
+//! the data. Paths are made absolute from the project's folder; web addresses are decoded.
+
+/// Where a QGIS layer's data is.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Source {
+    /// A file (`ogr`, `gdal`, `spatialite`): its path, the layer or table in it, and the filter
+    /// QGIS's subset string sets (as QGIS has it).
+    File { path: String, layer: Option<String>, subset: Option<String> },
+    /// A delimited text file (`delimitedtext`): its path, and the fields its points (or WKT
+    /// geometry) are in.
+    Csv { path: String, x: Option<String>, y: Option<String>, wkt: Option<String>, crs: Option<String> },
+    /// XYZ tiles (`wms` with `type=xyz`), raster or vector (`vectortile`).
+    Xyz { url: String, zmin: Option<u8>, zmax: Option<u8>, vector: bool },
+    /// A WMS or WMTS layer.
+    Wms { url: String, layer: String, crs: Option<String> },
+    /// A WFS or OGC API Features layer.
+    Wfs { url: String, layer: String },
+    /// A PostGIS table: QGIS's connection text (its password left out) and the table.
+    Postgres { connection: String, table: String },
+    /// One RustGIS doesn't read.
+    Other { provider: String },
+}
+
+/// The source of a layer with QGIS's `provider` and `datasource`, relative paths taken from `dir`.
+pub fn read(provider: &str, datasource: &str, dir: &str) -> Source {
+    match provider {
+        "ogr" | "gdal" => file(datasource, dir),
+        "spatialite" => {
+            let kv = conninfo(datasource);
+            match (kv.iter().find(|(k, _)| k == "dbname"), table_of(datasource)) {
+                (Some((_, db)), Some(t)) => Source::File { path: absolute(db, dir), layer: Some(t), subset: None },
+                _ => Source::Other { provider: provider.into() },
+            }
+        }
+        "delimitedtext" => csv(datasource, dir),
+        "wms" | "vectortile" => {
+            let q = query(datasource);
+            let get = |k: &str| q.iter().find(|(n, _)| n == k).map(|(_, v)| v.clone()).filter(|v| !v.is_empty());
+            let zoom = |k: &str| get(k).and_then(|v| v.parse::<u8>().ok());
+            match (get("type").as_deref(), get("url")) {
+                (Some("xyz"), Some(url)) => Source::Xyz { url, zmin: zoom("zmin"), zmax: zoom("zmax"), vector: provider == "vectortile" },
+                (_, Some(url)) if provider == "wms" => match get("layers") {
+                    Some(layer) => Source::Wms { url, layer, crs: get("crs") },
+                    None => Source::Other { provider: provider.into() },
+                },
+                _ => Source::Other { provider: provider.into() },
+            }
+        }
+        "WFS" | "wfs" | "OAPIF" | "oapif" => {
+            let kv = conninfo(datasource);
+            let get = |k: &str| kv.iter().find(|(n, _)| n.eq_ignore_ascii_case(k)).map(|(_, v)| v.clone());
+            match (get("url"), get("typename")) {
+                (Some(url), Some(layer)) => Source::Wfs { url, layer },
+                _ => Source::Other { provider: provider.into() },
+            }
+        }
+        "postgres" => match table_of(datasource) {
+            Some(table) => {
+                // The password stays out of what the import keeps or reports.
+                let kept: Vec<String> = conninfo(datasource)
+                    .into_iter()
+                    .filter(|(k, _)| matches!(k.as_str(), "dbname" | "host" | "port" | "user" | "service" | "sslmode"))
+                    .map(|(k, v)| format!("{k}={v}"))
+                    .collect();
+                Source::Postgres { connection: kept.join(" "), table }
+            }
+            None => Source::Other { provider: provider.into() },
+        },
+        _ => Source::Other { provider: provider.into() },
+    }
+}
+
+/// An `ogr` or `gdal` source: `path|layername=…|subset=…` (or `|layerid=…`), or GDAL's
+/// `GPKG:path:table`.
+fn file(datasource: &str, dir: &str) -> Source {
+    if let Some(rest) = datasource.strip_prefix("GPKG:") {
+        // GPKG:path:table, the path itself possibly with a drive letter's colon.
+        if let Some((path, table)) = rest.rsplit_once(':') {
+            return Source::File { path: absolute(path, dir), layer: Some(table.to_string()), subset: None };
+        }
+    }
+    let mut parts = datasource.split('|');
+    let path = parts.next().unwrap_or_default().trim();
+    let (mut layer, mut subset) = (None, None);
+    for p in parts {
+        if let Some(v) = p.strip_prefix("layername=") {
+            layer = Some(v.to_string());
+        } else if let Some(v) = p.strip_prefix("subset=") {
+            subset = Some(v.to_string()).filter(|s| !s.trim().is_empty());
+        }
+    }
+    Source::File { path: absolute(path, dir), layer, subset }
+}
+
+/// A `delimitedtext` source: `file:///path.csv?type=csv&xField=…&yField=…&crs=…`.
+fn csv(datasource: &str, dir: &str) -> Source {
+    let (path, q) = datasource.split_once('?').unwrap_or((datasource, ""));
+    // file:///absolute/path, or a relative one as file:./path.
+    let path = path.strip_prefix("file://").or_else(|| path.strip_prefix("file:")).unwrap_or(path);
+    let q = query(q);
+    let get = |k: &str| q.iter().find(|(n, _)| n == k).map(|(_, v)| v.clone()).filter(|v| !v.is_empty());
+    Source::Csv { path: absolute(&decode(path), dir), x: get("xField"), y: get("yField"), wkt: get("wktField"), crs: get("crs") }
+}
+
+/// `key=value` pairs joined by `&`, each value percent-decoded (QGIS's web sources).
+fn query(s: &str) -> Vec<(String, String)> {
+    s.split('&').take(200).filter_map(|kv| kv.split_once('=').or(Some((kv, "")))).map(|(k, v)| (k.to_string(), decode(v))).collect()
+}
+
+/// `key=value` and `key='value'` pairs joined by spaces (QGIS's connection texts).
+fn conninfo(s: &str) -> Vec<(String, String)> {
+    let mut out = Vec::new();
+    let mut rest = s.trim();
+    while !rest.is_empty() && out.len() < 100 {
+        let Some((k, after)) = rest.split_once('=') else { break };
+        let k = k.trim().to_string();
+        let (v, next) = if let Some(quoted) = after.strip_prefix('\'') {
+            match quoted.find('\'') {
+                Some(end) => (quoted.get(..end).unwrap_or_default(), quoted.get(end + 1..).unwrap_or_default()),
+                None => (quoted, ""),
+            }
+        } else {
+            let end = after.find(' ').unwrap_or(after.len());
+            (after.get(..end).unwrap_or_default(), after.get(end..).unwrap_or_default())
+        };
+        out.push((k, v.to_string()));
+        rest = next.trim_start();
+    }
+    out
+}
+
+/// A connection text's `table="schema"."table" (geom)`, as `schema.table` (or `table`).
+fn table_of(s: &str) -> Option<String> {
+    let at = s.find("table=")?;
+    let rest = s.get(at + 6..)?;
+    let end = rest.find(" (").or_else(|| rest.find(' ')).unwrap_or(rest.len());
+    let t = rest.get(..end)?.replace('"', "");
+    (!t.is_empty()).then_some(t)
+}
+
+/// `path` from the project's folder `dir`, unless it is absolute or a web address.
+fn absolute(path: &str, dir: &str) -> String {
+    let path = path.trim();
+    let windows_drive = path.as_bytes().get(1) == Some(&b':') && path.as_bytes().first().is_some_and(u8::is_ascii_alphabetic);
+    if path.is_empty() || path.starts_with('/') || path.starts_with('\\') || windows_drive || path.contains("://") || dir.is_empty() {
+        return path.to_string();
+    }
+    let rel = path.strip_prefix("./").unwrap_or(path);
+    format!("{}/{}", dir.trim_end_matches(['/', '\\']), rel)
+}
+
+/// Percent-decodes `s` (`%7B` to `{`); a broken escape is kept as it is.
+fn decode(s: &str) -> String {
+    let b = s.as_bytes();
+    let mut out = Vec::with_capacity(b.len());
+    let mut i = 0;
+    while let Some(&c) = b.get(i) {
+        let hex = |j: usize| b.get(j).and_then(|h| (*h as char).to_digit(16));
+        match (c, hex(i + 1), hex(i + 2)) {
+            (b'%', Some(h), Some(l)) => {
+                out.push((h * 16 + l) as u8);
+                i += 3;
+            }
+            _ => {
+                out.push(c);
+                i += 1;
+            }
+        }
+    }
+    String::from_utf8_lossy(&out).into_owned()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sources_read_as_their_providers_write_them() {
+        let dir = "/data/project";
+        assert_eq!(
+            read("ogr", "./roads.gpkg|layername=roads|subset=\"type\" = 'motorway'", dir),
+            Source::File {
+                path: "/data/project/roads.gpkg".into(),
+                layer: Some("roads".into()),
+                subset: Some("\"type\" = 'motorway'".into())
+            }
+        );
+        assert_eq!(read("ogr", "/abs/rivers.shp", dir), Source::File { path: "/abs/rivers.shp".into(), layer: None, subset: None });
+        assert_eq!(read("gdal", "C:/maps/dem.tif", dir), Source::File { path: "C:/maps/dem.tif".into(), layer: None, subset: None });
+        assert_eq!(
+            read("gdal", "GPKG:./m.gpkg:relief", dir),
+            Source::File { path: "/data/project/m.gpkg".into(), layer: Some("relief".into()), subset: None }
+        );
+        assert_eq!(
+            read("delimitedtext", "file:///data/pts%20a.csv?type=csv&xField=lon&yField=lat&crs=EPSG:4326", dir),
+            Source::Csv {
+                path: "/data/pts a.csv".into(),
+                x: Some("lon".into()),
+                y: Some("lat".into()),
+                wkt: None,
+                crs: Some("EPSG:4326".into())
+            }
+        );
+        assert_eq!(
+            read("wms", "type=xyz&url=https://tile.openstreetmap.org/%7Bz%7D/%7Bx%7D/%7By%7D.png&zmax=19&zmin=0", dir),
+            Source::Xyz { url: "https://tile.openstreetmap.org/{z}/{x}/{y}.png".into(), zmin: Some(0), zmax: Some(19), vector: false }
+        );
+        assert_eq!(
+            read("wms", "crs=EPSG:2056&format=image/png&layers=ch.swisstopo.pixelkarte-farbe&styles&url=https://wms.geo.admin.ch/", dir),
+            Source::Wms {
+                url: "https://wms.geo.admin.ch/".into(),
+                layer: "ch.swisstopo.pixelkarte-farbe".into(),
+                crs: Some("EPSG:2056".into())
+            }
+        );
+        // A password stays behind.
+        let pg = read("postgres", "dbname='gis' host=db port=5432 user='me' password='secret' table=\"public\".\"roads\" (geom)", dir);
+        assert_eq!(pg, Source::Postgres { connection: "dbname=gis host=db port=5432 user=me".into(), table: "public.roads".into() });
+        assert_eq!(read("memory", "Point?crs=EPSG:4326", dir), Source::Other { provider: "memory".into() });
+        assert_eq!(
+            read("delimitedtext", "file:./pts.csv?wktField=geom", dir),
+            Source::Csv { path: "/data/project/pts.csv".into(), x: None, y: None, wkt: Some("geom".into()), crs: None }
+        );
+        assert_eq!(decode("%E2%9C%93%zz"), "✓%zz");
+    }
+}
diff --git a/crates/map/src/qgis/symbol.rs b/crates/map/src/qgis/symbol.rs
new file mode 100644
index 000000000..b8a33eb85
--- /dev/null
+++ b/crates/map/src/qgis/symbol.rs
@@ -0,0 +1,261 @@
+//! QGIS symbols (`<symbol type="fill|line|marker">`) as a RustGIS [`Symbol`], and a line's
+//! symbol layers as stacked [`LineStroke`]s. A symbol layer RustGIS has no match for is drawn
+//! as near as it can (a pattern fill as a tint of its colour, a font or SVG marker as a circle in
+//! its colour) or left out, and noted.
+
+use roxmltree::Node;
+
+use super::{Report, color, points, prop, props};
+use crate::Rgba;
+use crate::symbology::{LineCap, LineJoin, LineStroke, MAX_STROKES, Marker, Symbol};
+
+/// A QGIS symbol in RustGIS's terms: the symbol, and a line's strokes bottom first (each simple
+/// line of it; empty for fills and markers, and for a line with none).
+#[derive(Clone, Debug, PartialEq)]
+pub(super) struct Converted {
+    pub symbol: Symbol,
+    pub strokes: Vec<LineStroke>,
+}
+
+impl Converted {
+    /// Whether the strokes say more than the symbol's single line does: more than one, or one
+    /// shifted sideways.
+    pub fn stacked(&self) -> bool {
+        self.strokes.len() > 1 || self.strokes.iter().any(|s| s.offset != 0.0)
+    }
+}
+
+/// Nothing drawn: QGIS's hidden categories and empty symbols.
+pub(super) fn hidden() -> Symbol {
+    let none = Rgba::new(0, 0, 0, 0);
+    Symbol { fill: none, stroke: none, stroke_width: 0.0, size: 0.0, marker: Marker::Circle }
+}
+
+/// The symbol `sym` (a `<symbol>` element), its sizes at the reference scale `reference` where
+/// they are in map units.
+pub(super) fn read(sym: Node, reference: Option<f64>, layer: &str, report: &mut Report) -> Converted {
+    let alpha = sym.attribute("alpha").and_then(|a| a.trim().parse::<f32>().ok()).filter(|a| a.is_finite()).unwrap_or(1.0).clamp(0.0, 1.0);
+    let fade = |c: Rgba| c.with_alpha((f32::from(c.a()) * alpha).round() as u8);
+    let layers: Vec<Node> = sym.children().filter(|c| c.has_tag_name("layer") && c.attribute("enabled") != Some("0")).take(64).collect();
+    for l in &layers {
+        data_defined(*l, layer, report);
+    }
+    let mut out = match sym.attribute("type") {
+        Some("fill") => fill(&layers, reference, layer, report),
+        Some("line") => line(&layers, reference, layer, report),
+        _ => marker(&layers, reference, layer, report),
+    };
+    out.symbol.fill = fade(out.symbol.fill);
+    out.symbol.stroke = fade(out.symbol.stroke);
+    for s in &mut out.strokes {
+        s.color = s.color.map(fade);
+    }
+    out
+}
+
+/// A size setting `k` (with its `k_unit`) of a symbol layer, in points.
+fn size(p: &[(String, String)], k: &str, reference: Option<f64>, layer: &str, report: &mut Report) -> Option<f32> {
+    let v = prop(p, k)?.trim().parse::<f64>().ok().filter(|v| v.is_finite())?;
+    let unit = prop(p, &format!("{k}_unit"));
+    Some(points(v, unit, reference, layer, report))
+}
+
+fn fill(layers: &[Node], reference: Option<f64>, layer: &str, report: &mut Report) -> Converted {
+    let none = Rgba::new(0, 0, 0, 0);
+    let (mut fill, mut stroke, mut width) = (None::<Rgba>, None::<Rgba>, 0.0f32);
+    for l in layers {
+        let p = props(*l);
+        match l.attribute("class").unwrap_or_default() {
+            "SimpleFill" => {
+                let c = prop(&p, "color").and_then(color).unwrap_or(none);
+                fill = Some(match prop(&p, "style").unwrap_or("solid") {
+                    "solid" => c,
+                    "no" => fill.unwrap_or(none),
+                    _ => {
+                        report.approximated(layer, "hatched fills, drawn as a light tint of their colour");
+                        tint(c)
+                    }
+                });
+                if prop(&p, "outline_style") != Some("no") {
+                    stroke = prop(&p, "outline_color").and_then(color).or(stroke);
+                    width = size(&p, "outline_width", reference, layer, report).unwrap_or(0.26 * 96.0 / 25.4);
+                }
+            }
+            "SimpleLine" => {
+                if prop(&p, "line_style") != Some("no") {
+                    stroke = prop(&p, "line_color").and_then(color).or(stroke);
+                    width = size(&p, "line_width", reference, layer, report).unwrap_or(width);
+                }
+            }
+            "GradientFill" | "ShapeburstFill" => {
+                report.approximated(layer, "gradient fills, drawn in their first colour");
+                fill = prop(&p, "color").or(prop(&p, "color1")).and_then(color).or(fill);
+            }
+            class @ ("LinePatternFill" | "PointPatternFill" | "SVGFill" | "RasterFill" | "RandomMarkerFill") => {
+                // The pattern's own symbol's colour, as a tint over what's below.
+                let sub = l.children().find(|c| c.has_tag_name("symbol")).map(|s| read(s, reference, layer, &mut Report::default()));
+                let c = sub.map(|s| if s.symbol.stroke.a() > 0 && s.symbol.fill.a() == 0 { s.symbol.stroke } else { s.symbol.fill });
+                if let Some(c) = c.or_else(|| prop(&p, "color").and_then(color)) {
+                    fill = Some(tint(c));
+                }
+                report.approximated(layer, format!("{} fills, drawn as a light tint of their colour", pattern_name(class)));
+            }
+            "CentroidFill" => report.skipped(layer, "markers at polygon centroids (centroid fills)"),
+            other => report.skipped(layer, format!("{other} symbol layers")),
+        }
+    }
+    let symbol =
+        Symbol { fill: fill.unwrap_or(none), stroke: stroke.unwrap_or(none), stroke_width: width, size: 0.0, marker: Marker::Circle };
+    Converted { symbol, strokes: Vec::new() }
+}
+
+fn line(layers: &[Node], reference: Option<f64>, layer: &str, report: &mut Report) -> Converted {
+    let mut strokes = Vec::new();
+    for l in layers {
+        let p = props(*l);
+        match l.attribute("class").unwrap_or_default() {
+            "SimpleLine" => {
+                let style = prop(&p, "line_style").unwrap_or("solid");
+                let Some(c) = prop(&p, "line_color").and_then(color) else { continue };
+                if style == "no" || c.a() == 0 {
+                    continue;
+                }
+                if style != "solid" || prop(&p, "use_custom_dash") == Some("1") {
+                    report.approximated(layer, "dashed lines, drawn solid");
+                }
+                let pass = l.attribute("pass").and_then(|v| v.trim().parse::<u8>().ok());
+                strokes.push(
+                    LineStroke {
+                        color: Some(c),
+                        width: Some(size(&p, "line_width", reference, layer, report).unwrap_or(0.26 * 96.0 / 25.4)),
+                        // Positive to the right of the line's direction on the screen, in both.
+                        offset: size(&p, "offset", reference, layer, report).unwrap_or(0.0),
+                        cap: match prop(&p, "capstyle") {
+                            Some("flat") => LineCap::Butt,
+                            Some("square") => LineCap::Square,
+                            _ => LineCap::Round,
+                        },
+                        join: match prop(&p, "joinstyle") {
+                            Some("miter") => LineJoin::Miter,
+                            Some("bevel") => LineJoin::Bevel,
+                            _ => LineJoin::Round,
+                        },
+                        level: pass,
+                        dash: None,
+                    }
+                    .clamped(),
+                );
+            }
+            "MarkerLine" | "HashLine" => report.skipped(layer, "markers and hash marks along lines"),
+            "ArrowLine" => report.skipped(layer, "arrow lines"),
+            other => report.skipped(layer, format!("{other} line symbol layers")),
+        }
+    }
+    if strokes.len() > MAX_STROKES {
+        report.skipped(layer, format!("line strokes past the first {MAX_STROKES}"));
+        strokes.truncate(MAX_STROKES);
+    }
+    // The symbol's line: the top stroke.
+    let top = strokes.last();
+    let symbol = match top {
+        Some(s) => {
+            let c = s.color.unwrap_or(Rgba::new(0, 0, 0, 0));
+            Symbol { fill: c, stroke: c, stroke_width: s.width.unwrap_or(1.0), size: 0.0, marker: Marker::Circle }
+        }
+        None => hidden(),
+    };
+    Converted { symbol, strokes }
+}
+
+fn marker(layers: &[Node], reference: Option<f64>, layer: &str, report: &mut Report) -> Converted {
+    let mut symbol = hidden();
+    for l in layers {
+        let p = props(*l);
+        let class = l.attribute("class").unwrap_or_default();
+        let fill = prop(&p, "color").and_then(color);
+        let outline = prop(&p, "outline_color").and_then(color);
+        let sz = size(&p, "size", reference, layer, report).unwrap_or(2.0 * 96.0 / 25.4);
+        let shape = match class {
+            "SimpleMarker" => {
+                let name = prop(&p, "name").unwrap_or("circle");
+                shape_of(name).unwrap_or_else(|| {
+                    report.approximated(layer, format!("{name} markers, drawn as circles"));
+                    Marker::Circle
+                })
+            }
+            "FontMarker" => {
+                report.approximated(layer, "font markers (characters of a symbol font), drawn as circles in their colour");
+                Marker::Circle
+            }
+            "SvgMarker" | "RasterMarker" | "EllipseMarker" | "FilledMarker" => {
+                report.approximated(layer, format!("{} markers, drawn as circles in their colour", marker_name(class)));
+                Marker::Circle
+            }
+            other => {
+                report.skipped(layer, format!("{other} marker symbol layers"));
+                continue;
+            }
+        };
+        if prop(&p, "angle").and_then(|a| a.trim().parse::<f32>().ok()).is_some_and(|a| a != 0.0) {
+            report.approximated(layer, "turned markers, drawn upright");
+        }
+        let fill = fill.unwrap_or(Rgba::new(0, 0, 0, 0));
+        // A font marker's character is all fill; an outline of no width draws none.
+        let width = if class == "FontMarker" { 0.0 } else { size(&p, "outline_width", reference, layer, report).unwrap_or(0.0) };
+        // Each layer drawn over the one before: the top one's look, the biggest size.
+        symbol = Symbol {
+            fill,
+            stroke: outline.unwrap_or(fill),
+            stroke_width: width,
+            size: sz.max(if symbol.size > 0.0 { symbol.size } else { 0.0 }).clamp(0.0, 200.0),
+            marker: shape,
+        };
+    }
+    Converted { symbol, strokes: Vec::new() }
+}
+
+/// QGIS's simple marker shapes RustGIS has.
+fn shape_of(name: &str) -> Option<Marker> {
+    Some(match name {
+        "circle" => Marker::Circle,
+        "square" | "rectangle" => Marker::Square,
+        "triangle" | "equilateral_triangle" => Marker::Triangle,
+        "diamond" => Marker::Diamond,
+        "star" | "regular_star" => Marker::Star,
+        _ => return None,
+    })
+}
+
+/// A light tint of `c`, standing in for a pattern of it.
+fn tint(c: Rgba) -> Rgba {
+    c.with_alpha((f32::from(c.a()) * 0.35).round() as u8)
+}
+
+fn pattern_name(class: &str) -> &'static str {
+    match class {
+        "LinePatternFill" => "line pattern",
+        "PointPatternFill" => "point pattern",
+        "SVGFill" => "SVG",
+        "RasterFill" => "raster image",
+        _ => "random marker",
+    }
+}
+
+fn marker_name(class: &str) -> &'static str {
+    match class {
+        "SvgMarker" => "SVG",
+        "RasterMarker" => "raster image",
+        "EllipseMarker" => "ellipse",
+        _ => "filled",
+    }
+}
+
+/// Notes a symbol layer's data-defined settings (from fields or expressions), which are left out.
+fn data_defined(l: Node, layer: &str, report: &mut Report) {
+    let Some(dd) = l.children().find(|c| c.has_tag_name("data_defined_properties")) else { return };
+    let active =
+        dd.descendants().any(|o| o.has_tag_name("Option") && o.attribute("name") == Some("active") && o.attribute("value") == Some("true"));
+    if active {
+        report.skipped(layer, "data-defined symbol settings (from fields or expressions)");
+    }
+}
diff --git a/crates/map/src/qgis/tests.rs b/crates/map/src/qgis/tests.rs
new file mode 100644
index 000000000..e09993afe
--- /dev/null
+++ b/crates/map/src/qgis/tests.rs
@@ -0,0 +1,239 @@
+//! A small QGIS project and style, written by hand in the shapes QGIS writes them.
+
+use super::*;
+use crate::symbology::{LabelPlacement, LineCap, Marker};
+
+const PROJECT: &str = r#"<!DOCTYPE qgis PUBLIC 'http://mrcc.com/qgis.dtd' 'SYSTEM'>
+<qgis projectname="Towns" version="3.42.0-Münster">
+  <title>Towns</title>
+  <projectCrs><spatialrefsys><authid>EPSG:2056</authid></spatialrefsys></projectCrs>
+  <layer-tree-group>
+    <layer-tree-layer id="towns_1" checked="Qt::Checked" name="Towns"/>
+    <layer-tree-group name="Base" checked="Qt::Unchecked">
+      <layer-tree-layer id="roads_1" checked="Qt::Checked" name="Roads"/>
+    </layer-tree-group>
+    <layer-tree-layer id="land_1" checked="Qt::Checked" name="Land"/>
+  </layer-tree-group>
+  <mapcanvas name="theMapCanvas">
+    <extent><xmin>2690000</xmin><ymin>1250000</ymin><xmax>2700000</xmax><ymax>1260000</ymax></extent>
+  </mapcanvas>
+  <projectlayers>
+    <maplayer type="vector" hasScaleBasedVisibilityFlag="1" minScale="100000" maxScale="1000" labelsEnabled="1">
+      <id>land_1</id>
+      <datasource>./data/base.gpkg|layername=land|subset="kind" &lt;&gt; 'sea'</datasource>
+      <layername>Land</layername>
+      <srs><spatialrefsys><authid>EPSG:2056</authid></spatialrefsys></srs>
+      <provider encoding="UTF-8">ogr</provider>
+      <renderer-v2 type="graduatedSymbol" attr="pop" referencescale="25000">
+        <ranges>
+          <range lower="0" upper="100" symbol="0" label="few" render="true"/>
+          <range lower="100" upper="1000" symbol="1" label="many" render="true"/>
+        </ranges>
+        <symbols>
+          <symbol type="fill" name="0" alpha="1"><layer class="SimpleFill" enabled="1" pass="0">
+            <Option type="Map"><Option name="color" type="QString" value="200,220,180,255,rgb:0.78,0.86,0.7,1"/><Option name="style" type="QString" value="solid"/>
+            <Option name="outline_color" type="QString" value="0,0,0,255"/><Option name="outline_width" type="QString" value="0.5"/><Option name="outline_width_unit" type="QString" value="MM"/></Option>
+          </layer></symbol>
+          <symbol type="fill" name="1" alpha="0.5"><layer class="LinePatternFill" enabled="1">
+            <Option type="Map"><Option name="distance" value="2"/></Option>
+            <symbol type="line" name="@1@0" alpha="1"><layer class="SimpleLine" enabled="1"><prop k="line_color" v="0,0,255,255"/><prop k="line_width" v="0.2"/></layer></symbol>
+          </layer></symbol>
+        </symbols>
+      </renderer-v2>
+      <layerOpacity>0.75</layerOpacity>
+      <blendMode>13</blendMode>
+      <labeling type="simple">
+        <settings><text-style fieldName="name" fontSize="12" fontSizeUnit="Point" textColor="20,40,60,255" namedStyle="Bold Italic" fontFamily="Liberation Sans Narrow">
+          <text-buffer bufferDraw="1"/></text-style><placement placement="1" quadOffset="2"/></settings>
+      </labeling>
+    </maplayer>
+    <maplayer type="vector" labelsEnabled="1">
+      <id>roads_1</id>
+      <datasource>/abs/roads.shp</datasource>
+      <layername>Roads</layername>
+      <provider>ogr</provider>
+      <renderer-v2 type="categorizedSymbol" attr="&quot;class&quot;" symbollevels="1">
+        <categories>
+          <category value="motorway" symbol="0" label="Motorway" render="true"/>
+          <category value="track" symbol="1" label="track" render="false"/>
+          <category value="" symbol="2" label="other" render="true"/>
+        </categories>
+        <symbols>
+          <symbol type="line" name="0" alpha="1">
+            <layer class="SimpleLine" enabled="1" pass="0"><prop k="line_color" v="90,40,20,255"/><prop k="line_width" v="1.2"/><prop k="capstyle" v="flat"/></layer>
+            <layer class="SimpleLine" enabled="1" pass="3"><prop k="line_color" v="240,140,40,255"/><prop k="line_width" v="0.8"/><prop k="use_custom_dash" v="1"/></layer>
+          </symbol>
+          <symbol type="line" name="1" alpha="1"><layer class="SimpleLine" enabled="1"><prop k="line_color" v="0,0,0,255"/></layer></symbol>
+          <symbol type="line" name="2" alpha="1"><layer class="MarkerLine" enabled="1"/></symbol>
+        </symbols>
+      </renderer-v2>
+      <labeling type="rule-based">
+        <rules key="root">
+          <rule key="a" filter="&quot;class&quot; = 'motorway'" description="Motorways">
+            <settings><text-style fieldName="ref" fontSize="9"/><placement placement="3"/></settings>
+          </rule>
+          <rule key="p" filter="&quot;lanes&quot; &gt; 1">
+            <rule key="b" filter="ELSE" description="Rest" scalemaxdenom="50000">
+              <settings><text-style fieldName="name" fontSize="7"/><placement placement="2"/></settings>
+            </rule>
+            <rule key="c" filter="&quot;kind&quot; = 'x'"><settings><text-style fieldName="name" fontSize="7"/></settings></rule>
+          </rule>
+          <rule key="d" filter="length(&quot;name&quot;) &gt; 3"><settings><text-style fieldName="name"/></settings></rule>
+        </rules>
+      </labeling>
+    </maplayer>
+    <maplayer type="vector">
+      <id>towns_1</id>
+      <datasource>type=xyz&amp;url=https://tile.example.org/%7Bz%7D/%7Bx%7D/%7By%7D.png&amp;zmax=19</datasource>
+      <layername>Towns</layername>
+      <provider>wms</provider>
+      <renderer-v2 type="RuleRenderer">
+        <rules key="r">
+          <rule key="1" filter="&quot;rank&quot; IN (1, 2)" symbol="0"/>
+          <rule key="2" filter="ELSE" symbol="1"/>
+        </rules>
+        <symbols>
+          <symbol type="marker" name="0" alpha="1"><layer class="SimpleMarker" enabled="1"><prop k="name" v="star"/><prop k="color" v="200,0,0,255"/><prop k="size" v="4"/></layer></symbol>
+          <symbol type="marker" name="1" alpha="1"><layer class="FontMarker" enabled="1"><prop k="color" v="0,0,0,255"/><prop k="chr" v="A"/></layer></symbol>
+        </symbols>
+      </renderer-v2>
+    </maplayer>
+  </projectlayers>
+</qgis>"#;
+
+#[test]
+fn a_project_reads_into_layers_in_tree_order_with_their_styles() {
+    let mut report = Report::default();
+    let p = read_project(PROJECT, "/maps", &mut report).unwrap();
+    assert_eq!(p.title, "Towns");
+    assert_eq!(p.crs.as_deref(), Some("EPSG:2056"));
+    assert_eq!(p.extent, Some([2_690_000.0, 1_250_000.0, 2_700_000.0, 1_260_000.0]));
+    let names: Vec<&str> = p.layers.iter().map(|l| l.name.as_str()).collect();
+    assert_eq!(names, ["Towns", "Roads", "Land"], "top first");
+    let visible: Vec<bool> = p.layers.iter().map(|l| l.visible).collect();
+    assert_eq!(visible, [true, false, true], "Roads is in an unchecked group");
+
+    // Land: a GeoPackage table, filtered; graduated; opacity, blending, scales, reference scale.
+    let land = &p.layers[2];
+    assert_eq!(
+        land.source,
+        Source::File { path: "/maps/data/base.gpkg".into(), layer: Some("land".into()), subset: Some("\"kind\" <> 'sea'".into()) }
+    );
+    assert_eq!(land.definition_query.as_deref(), Some("\"kind\" <> 'sea'"));
+    assert_eq!(land.crs.as_deref(), Some("EPSG:2056"));
+    let s = &land.style;
+    assert_eq!((s.transparency, s.blend), (Some(25.0), Some(Blend::Multiply)));
+    let (min, max) = (s.min_scale.flatten().unwrap(), s.max_scale.flatten().unwrap());
+    assert!((min - 100_000.0 * QGIS_SCALE).abs() < 1e-6 && (max - 1000.0 * QGIS_SCALE).abs() < 1e-6);
+    assert!((s.reference_scale.unwrap() - 25_000.0 * QGIS_SCALE).abs() < 1e-6);
+    let Some(Renderer::Graduated { field, breaks, symbols, min, class_labels, .. }) = &s.renderer else { panic!("{:?}", s.renderer) };
+    assert_eq!((field.as_str(), breaks.as_slice(), *min), ("pop", &[100.0, 1000.0][..], 0.0));
+    assert_eq!(symbols[0].fill, Rgba::rgb(200, 220, 180));
+    assert!((symbols[0].stroke_width - 0.5 * 96.0 / 25.4).abs() < 1e-4, "0.5 mm in points");
+    // The pattern fill: a tint of its line colour, at the symbol's alpha too.
+    assert_eq!((symbols[1].fill.b(), symbols[1].fill.a()), (255, 45));
+    assert_eq!(class_labels.get(&1).map(String::as_str), Some("many"));
+    let labels = s.labels.as_ref().unwrap();
+    let d = &labels.default;
+    assert!(labels.enabled && labels.classes.is_empty());
+    assert_eq!((d.field.as_str(), d.size, d.bold, d.italic, d.halo), ("name", 12.0, true, true, true));
+    assert_eq!((d.color, d.placement), (Rgba::rgb(20, 40, 60), LabelPlacement::AboveRight));
+
+    // Roads: categories with stacked strokes in levels, a hidden one and the rest.
+    let roads = &p.layers[1];
+    assert_eq!(roads.source, Source::File { path: "/abs/roads.shp".into(), layer: None, subset: None });
+    let s = &roads.style;
+    assert_eq!((s.stroke_levels, s.line_strokes.as_deref()), (Some(true), Some(&[][..])));
+    let Some(Renderer::Unique { field, classes, class_strokes, class_labels, other, .. }) = &s.renderer else { panic!() };
+    assert_eq!(field, "class");
+    assert_eq!(classes.iter().map(|c| c.0.as_str()).collect::<Vec<_>>(), ["motorway", "track"]);
+    assert_eq!(classes[1].1.stroke.a(), 0, "not rendered: hidden");
+    assert_eq!(other.stroke.a(), 0, "a marker line only: nothing RustGIS draws");
+    let motorway = &class_strokes["motorway"];
+    assert_eq!(motorway.len(), 2);
+    assert_eq!((motorway[0].cap, motorway[0].level, motorway[1].level), (LineCap::Butt, Some(0), Some(3)));
+    assert_eq!(class_labels.get("motorway").map(String::as_str), Some("Motorway"));
+    // Labels: a class per rule; the else rule takes what its sibling doesn't, under its parent.
+    let l = s.labels.as_ref().unwrap();
+    assert!(!l.default.visible);
+    let by = |n: &str| l.classes.iter().find(|c| c.name == n).unwrap();
+    assert_eq!((by("Motorways").where_.as_deref(), by("Motorways").placement), (Some("\"class\" = 'motorway'"), LabelPlacement::Curved));
+    let rest = by("Rest");
+    assert_eq!(rest.where_.as_deref(), Some("(\"lanes\" > 1) AND (NOT ((\"kind\" = 'x')))"));
+    assert_eq!(rest.placement, LabelPlacement::Parallel);
+    assert!((rest.min_scale.unwrap() - 50_000.0 * QGIS_SCALE).abs() < 1e-6);
+    assert_eq!(l.classes.len(), 3, "the function filter's rule is left out");
+
+    // Towns: XYZ tiles as the source; rules on one field read as categories.
+    let towns = &p.layers[0];
+    assert_eq!(
+        towns.source,
+        Source::Xyz { url: "https://tile.example.org/{z}/{x}/{y}.png".into(), zmin: None, zmax: Some(19), vector: false }
+    );
+    let Some(Renderer::Unique { field, classes, other, .. }) = &towns.style.renderer else { panic!() };
+    assert_eq!((field.as_str(), classes.len()), ("rank", 2));
+    assert_eq!((classes[0].1.marker, classes[0].1.fill), (Marker::Star, Rgba::rgb(200, 0, 0)));
+    assert_eq!((other.marker, other.fill), (Marker::Circle, Rgba::rgb(0, 0, 0)));
+
+    // What didn't carry over is said, once for each thing.
+    let said =
+        |layer: &str, kind: NoteKind, part: &str| report.notes.iter().any(|n| n.layer == layer && n.kind == kind && n.text.contains(part));
+    assert!(said("Land", NoteKind::Approximated, "line pattern"));
+    assert!(said("Land", NoteKind::Approximated, "Liberation Sans Narrow"));
+    assert!(said("Roads", NoteKind::Approximated, "dashed"));
+    assert!(said("Roads", NoteKind::Skipped, "markers and hash marks"));
+    assert!(said("Roads", NoteKind::Skipped, "length("));
+    assert!(said("Towns", NoteKind::Approximated, "font markers"));
+}
+
+#[test]
+fn a_style_file_reads_in_either_settings_format() {
+    // QGIS before 3.26 writes a symbol layer's settings as <prop k v>, after as <Option>.
+    let qml = |settings: &str| {
+        format!(
+            r#"<!DOCTYPE qgis><qgis version="3.10"><renderer-v2 type="singleSymbol"><symbols><symbol type="line" name="0" alpha="1"><layer class="SimpleLine" enabled="1">{settings}</layer></symbol></symbols></renderer-v2></qgis>"#
+        )
+    };
+    for settings in [
+        r#"<prop k="line_color" v="10,20,30,255"/><prop k="line_width" v="2"/><prop k="line_width_unit" v="Pixel"/>"#,
+        r#"<Option type="Map"><Option name="line_color" value="10,20,30,255"/><Option name="line_width" value="2"/><Option name="line_width_unit" value="Pixel"/></Option>"#,
+    ] {
+        let mut report = Report::default();
+        let s = read_style(&qml(settings), "Rivers", &mut report).unwrap();
+        let Some(Renderer::Single(sym)) = s.renderer else { panic!() };
+        assert_eq!((sym.stroke, sym.stroke_width), (Rgba::rgb(10, 20, 30), 2.0));
+        assert_eq!(s.line_strokes.as_deref(), Some(&[][..]), "one plain line: no stack");
+        assert!(report.notes.is_empty(), "{:?}", report.notes);
+    }
+    // Applied to a layer: its parts only.
+    let mut layer = crate::Layer::new(1, rustgis_data::Dataset::new("r", rustgis_data::GeometryType::Polyline, vec![]));
+    layer.transparency = 40.0;
+    let s = read_style(&qml(r#"<prop k="line_color" v="1,2,3,255"/>"#), "r", &mut Report::default()).unwrap();
+    s.apply(&mut layer);
+    assert_eq!((layer.transparency, matches!(layer.renderer, Renderer::Single(_))), (40.0, true));
+}
+
+#[test]
+fn hostile_files_are_refused_or_bounded() {
+    let mut r = Report::default();
+    assert!(read_project("not xml", "", &mut r).is_err());
+    assert!(read_project("<other/>", "", &mut r).is_err());
+    assert!(read_style("<qgis><renderer-v2 type=\"x\"", "", &mut r).is_err());
+    // An entity expansion bomb: no DTD is read.
+    let bomb = r#"<!DOCTYPE qgis [<!ENTITY a "aaaaaaaaaa"><!ENTITY b "&a;&a;&a;&a;&a;&a;&a;&a;">]><qgis><title>&b;</title></qgis>"#;
+    assert!(read_project(bomb, "", &mut r).is_err());
+    // Rules nested past any sensible depth, and nonsense values: read without a crash.
+    let deep = format!(
+        r#"<qgis><renderer-v2 type="RuleRenderer" referencescale="-5"><rules>{}{}</rules><symbols/></renderer-v2><layerOpacity>NaN</layerOpacity></qgis>"#,
+        "<rule filter=\"a = 1\">".repeat(200),
+        "</rule>".repeat(200)
+    );
+    let s = read_style(&deep, "x", &mut r).unwrap();
+    assert_eq!((s.reference_scale, s.transparency), (None, None));
+    // The same note many times is kept once, counted.
+    let mut r = Report::default();
+    for _ in 0..10_000 {
+        r.skipped("a", "the same");
+    }
+    assert_eq!((r.notes.len(), r.notes[0].count), (1, 10_000));
+}
diff --git a/crates/ui-egui/src/backstage.rs b/crates/ui-egui/src/backstage.rs
index 1c7c2caa0..124d7fbac 100644
--- a/crates/ui-egui/src/backstage.rs
+++ b/crates/ui-egui/src/backstage.rs
@@ -1,7 +1,7 @@
 //! The Project backstage: start a project (blank or from the sample), open, save and export.
 
 use egui::{Align2, CornerRadius, Rect, Sense, Stroke, Ui, pos2, vec2};
-use serde_json::Value;
+use serde_json::{Value, json};
 
 use crate::chrome::header_layout;
 use crate::theme::{BRAND, Tokens, regular, semibold};
@@ -119,6 +119,10 @@ fn start(app: &mut RustGisApp, ui: &mut Ui, t: &Tokens) {
         if card(ui, t, "Open…", "Open a .rgis project", "open") {
             let _ = app.run("ui.open", Value::Null);
         }
+        if card(ui, t, "QGIS Project…", "A .qgs or .qgz project as a map", "open") {
+            let _ = app.run("ui.openItem", json!({"kind": "qgisProject"}));
+            app.ui.backstage = false;
+        }
     });
     ui.add_space(28.0);
     ui.label(egui::RichText::new(tl!("Current Project")).font(semibold(15.0)));
diff --git a/crates/ui-egui/src/chrome.rs b/crates/ui-egui/src/chrome.rs
index 40ae019b9..a9ec8f7a3 100644
--- a/crates/ui-egui/src/chrome.rs
+++ b/crates/ui-egui/src/chrome.rs
@@ -714,6 +714,8 @@ fn search_action(id: &str) -> Option<SearchAction> {
         }
         "style.add" => OpenItem("styles"),
         "style.import" => OpenItem("importStyles"),
+        "style.importQgis" => OpenItem("qgisStyle"),
+        "project.importQgis" => OpenItem("qgisProject"),
         "style.save" => SaveItem("styles"),
         "ramp.add" => OpenItem("ramps"),
         "ramp.save" => SaveItem("ramps"),
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index becdadbd5..3a63af7af 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -2333,8 +2333,12 @@ impl RustGisApp {
                     self.ui.pending_open = None;
                     open("project");
                     self.ui.backstage = false;
-                } else if let Some(path) = dialogs::pick_open(&["rgis", "rgisx", "rgispkg"], tl!("RustGIS project")) {
-                    let r = self.run("project.open", json!({"path": path}));
+                } else if let Some(path) = dialogs::pick_open(&["rgis", "rgisx", "rgispkg", "qgs", "qgz"], tl!("Projects (RustGIS, QGIS)"))
+                {
+                    // A QGIS project opens as a new map of this one.
+                    let lower = path.to_ascii_lowercase();
+                    let cmd = if lower.ends_with(".qgs") || lower.ends_with(".qgz") { "project.importQgis" } else { "project.open" };
+                    let r = self.run(cmd, json!({"path": path}));
                     self.ui.backstage = false;
                     self.map.invalidate();
                     return r;
@@ -2479,6 +2483,8 @@ impl RustGisApp {
                     "styles" => ("style.add", &["rgisstyle"], "RustGIS styles"),
                     "ramps" => ("ramp.add", &["rgisramp", "xml", "qml", "txt", "clr", "cpt"], "Colour ramps (RustGIS, QGIS, GDAL, GMT)"),
                     "importStyles" => ("style.import", &["rgislyr", "rgismap", "rgis", "rgisx"], "RustGIS layers, maps and projects"),
+                    "qgisProject" => ("project.importQgis", &["qgs", "qgz"], "QGIS project"),
+                    "qgisStyle" => ("style.importQgis", &["qml"], "QGIS layer style"),
                     "template" => ("project.fromTemplate", &["rgistemplate"], "RustGIS project template"),
                     "task" => ("task.import", &["rgistask"], "RustGIS task"),
                     "bookmarks" => ("bookmark.import", &["rgisbookmarks"], "RustGIS bookmarks"),
diff --git a/crates/ui-egui/src/panes.rs b/crates/ui-egui/src/panes.rs
index f9d925844..c6004b926 100644
--- a/crates/ui-egui/src/panes.rs
+++ b/crates/ui-egui/src/panes.rs
@@ -3547,6 +3547,10 @@ fn symbology(app: &mut RustGisApp, ui: &mut Ui, t: &Tokens) {
     if !l.graphics {
         reference_scale_row(app, ui, &l);
     }
+    ui.add_space(6.0);
+    if ui.button(tl!("Import QGIS Style…")).on_hover_text(tl!("Style this layer as a QGIS layer style file (.qml) does")).clicked() {
+        let _ = app.run("ui.openItem", json!({"kind": "qgisStyle"}));
+    }
 }
 
 /// The scales the Reference scale picker offers, besides none and the map's own.
diff --git a/docs/comparison/qgis.md b/docs/comparison/qgis.md
index 00774698b..794e76e46 100644
--- a/docs/comparison/qgis.md
+++ b/docs/comparison/qgis.md
@@ -173,7 +173,7 @@ Most QGIS ideas have a counterpart under a different name:
 | Field Calculator | Calculate Field |
 | Print Layout, Atlas | Layouts, Map Series |
 | Plugin Manager | **Plugins › Plugin Manager** |
-| Project (`.qgz`) | Project (`.rgis`), or a package (`.rgispkg`) with its data inside |
+| Project (`.qgz`) | Project (`.rgis`), or a package (`.rgispkg`) with its data inside; a QGIS project opens as a map |
 
 The [User Guide](../user-guide/index.md) walks through the interface, and
 [Getting Started](../getting-started.md) is a short tour.
@@ -192,8 +192,11 @@ between them without conversion:
 - **Web maps**: MapLibre styles and OGC API Features collections exported from RustGIS can be
   served and opened anywhere, QGIS included.
 
-RustGIS does not open QGIS project files (`.qgz`) or full QGIS layer styles; move the data
-across and restyle it.
+- **Projects and layer styles**: RustGIS opens QGIS projects (`.qgs`, `.qgz`) as maps and
+  applies QGIS layer styles (`.qml`), carrying over the layers, their order and visibility,
+  renderers, symbols, labels and reference scales, and listing what it draws differently; see
+  [QGIS projects and styles](../user-guide/workspace.md#qgis-projects-and-styles). It doesn't
+  write them back.
 
 A common split is to do heavy editing, PROJ-dependent work and detailed cartography in QGIS,
 and use RustGIS where a light install, the browser, scripting by command id or the AI Assistant
diff --git a/docs/user-guide/workspace.md b/docs/user-guide/workspace.md
index ec46c3163..2815c0d1e 100644
--- a/docs/user-guide/workspace.md
+++ b/docs/user-guide/workspace.md
@@ -19,6 +19,47 @@ Saved layer addresses omit passwords, access keys, tokens and signatures. The op
 keeps them, but after restarting RustGIS a protected source may need you to sign in to its
 connection again or add it again with credentials.
 
+### QGIS projects and styles
+
+A QGIS project (`.qgs`, or a `.qgz` archive) opens as a new map of the current project: **Open**
+on the desktop, or **Project › New › QGIS Project…** (`project.importQgis={"path": "…/towns.qgs"}`).
+Its layers come in the layer tree's order, each from its file (GeoPackage, Shapefile, GeoJSON,
+GeoTIFF and the other formats RustGIS reads, relative paths from the project's folder), a CSV of
+points, XYZ tiles or a WMS layer, unchecked layers and groups hidden. The map takes the project's
+coordinate system and its saved view (or its layers' extent, when that view shows none of them),
+with no basemap and no graticule, as QGIS draws it. The import is one undo step.
+
+Each layer keeps its look:
+
+- **Renderers**: single symbol, categorized (as Unique Values, a category's merged values each a
+  class, its "all other values" category the rest), graduated (as Graduated Colors), and
+  rule-based where every rule picks values of one field (an else rule the rest); point cluster,
+  displacement and other renderers that wrap one are drawn by the one inside.
+- **Symbols**: simple fills, lines and markers with their colours, widths in any unit, offsets,
+  caps, joins and the symbol's opacity; a line's simple lines as stacked strokes, its rendering
+  passes as their levels when the renderer draws in symbol levels.
+- **Layer settings**: opacity, blending, visibility range, filter (subset string), and the
+  reference scale.
+- **Labels**: simple and rule-based, each rule a label class whose SQL clause is its filter and
+  its parents' (an else rule's: none of its siblings'), with the text's field, size, colour,
+  bold and italic, its buffer as a halo, its placement (Parallel and Curved along lines,
+  around and over points) and its scale range.
+
+QGIS expressions carry over where they are SQL: fields compared with values, `LIKE`, `IN`,
+`IS NULL`, joined by `AND`, `OR` and `NOT`. What RustGIS doesn't draw as QGIS does is drawn as
+near as it can, or left out, and said: the import's notes list, layer by layer, what was
+approximated (pattern fills drawn as a tint of their colour, font and SVG markers as circles,
+dashed lines solid, fonts other than RustGIS's label font) and what was skipped (marker lines,
+data-defined settings, labels from expressions, raster colouring, PostGIS, WFS and other sources
+RustGIS doesn't read). A database password in a project never reaches the notes.
+
+A QGIS layer style (`.qml`) styles the selected layer the same way: **Import QGIS Style…** in
+the Symbology pane (`style.importQgis={"layer": "Roads", "path": "…/roads.qml"}`).
+
+RustGIS works out a map's scale with the OGC's 0.28 mm screen pixel, QGIS at 96 pixels to the
+inch, so the same view is a larger scale in QGIS; scales from QGIS (reference scales, visibility
+ranges) are multiplied by 0.945 on the way in, so a layer shows at the same zoom in both.
+
 ## Panes and command search
 
 The left pane has tabs for **Layers**, **Browser** and **Data Sources**. Right-hand panes

From 8f8eed6c520f4e356324337f9028c9ab590f496c Mon Sep 17 00:00:00 2001
From: Dominik Strebel <dominik.strebel@gmail.com>
Date: Sat, 24 Oct 2026 17:36:11 +0200
Subject: [PATCH 2/5] fix(map): a QGIS web layer keeps its visibility and
 opacity, a style's fields are checked, and plugins can't run the import

- A WMS or XYZ layer gets its tile layer's visibility and opacity, and a scale range it can't have is noted.
- style.importQgis checks label fields and the renderer's field as project.importQgis does (one helper for both).
- project.importQgis is reserved to the user: a project names the files and web addresses its layers come from.
- Report notes are found by key rather than a scan; the unused Report::extend is gone; one labelsEnabled block.
- run_part sits above run's doc comment.
---
 crates/engine/src/cmd/plugins.rs |  3 ++
 crates/engine/src/cmd/qgis.rs    | 59 +++++++++++++++++++++++---------
 crates/engine/src/lib.rs         |  4 +--
 crates/engine/src/tests.rs       | 25 ++++++++++++++
 crates/map/src/qgis/mod.rs       | 38 +++++++++-----------
 crates/map/src/qgis/tests.rs     | 12 +++++++
 6 files changed, 101 insertions(+), 40 deletions(-)

diff --git a/crates/engine/src/cmd/plugins.rs b/crates/engine/src/cmd/plugins.rs
index 8e36722e9..9b79c610f 100644
--- a/crates/engine/src/cmd/plugins.rs
+++ b/crates/engine/src/cmd/plugins.rs
@@ -267,6 +267,9 @@ const NEVER: &[&str] = &[
     "project.openText",
     "project.sample",
     "project.fromTemplate",
+    // A QGIS project names the files and web addresses its layers come from, and the import
+    // adds them without each one passing a plugin's permissions.
+    "project.importQgis",
     "edit.undo",
     "edit.redo",
     // Credentials: a plugin never sets where the user's are sent.
diff --git a/crates/engine/src/cmd/qgis.rs b/crates/engine/src/cmd/qgis.rs
index 0c5857475..c95f61c31 100644
--- a/crates/engine/src/cmd/qgis.rs
+++ b/crates/engine/src/cmd/qgis.rs
@@ -129,15 +129,13 @@ fn add_layer(s: &mut Session, layer: &qgis::ProjectLayer, report: &mut Report) -
             if let Some(z) = zmax {
                 q["maxZoom"] = json!(z);
             }
-            s.run_part("map.addTiles", &q)?;
-            if !layer.visible {
-                // A tile layer has no visibility of its own: an invisible one isn't wanted.
-                report.approximated(name, "a hidden tile layer, added shown");
-            }
+            let added = s.run_part("map.addTiles", &q)?;
+            tile_settings(s, &added, layer, report);
             return Ok(Some(name.to_string()));
         }
         Source::Wms { url, layer: wms, .. } => {
-            s.run_part("service.add", &json!({"url": url, "type": "wms", "layer": wms, "name": name}))?;
+            let added = s.run_part("service.add", &json!({"url": url, "type": "wms", "layer": wms, "name": name}))?;
+            tile_settings(s, &added, layer, report);
             return Ok(Some(name.to_string()));
         }
         Source::Wfs { url, layer: typename } => {
@@ -174,13 +172,21 @@ fn add_layer(s: &mut Session, layer: &qgis::ProjectLayer, report: &mut Report) -
         return Ok(Some(added_name));
     }
     layer.style.apply(l);
-    // What reads only against the layer's fields: its definition query and its label clauses.
+    // What reads only against the layer's fields: its definition query, and what the style names.
     if let Some(q) = &layer.definition_query {
         match rustgis_data::query::parse(q, &l.dataset) {
             Ok(_) => l.definition_query = Some(q.clone()),
             Err(e) => report.skipped(name, format!("its filter `{q}` ({e})")),
         }
     }
+    check_fields(l, name, report);
+    Ok(Some(added_name))
+}
+
+/// Checks what a style names against the layer's fields: its label classes' clauses and fields
+/// (a class that can't label is switched off) and the field a Unique Values or Graduated Colors
+/// renderer classes by.
+fn check_fields(l: &mut rustgis_map::Layer, name: &str, report: &mut Report) {
     for c in std::iter::once(&mut l.labels.default).chain(l.labels.classes.iter_mut()) {
         if let Some(w) = c.where_.clone()
             && let Err(e) = rustgis_data::query::parse(&w, &l.dataset)
@@ -200,7 +206,35 @@ fn add_layer(s: &mut Session, layer: &qgis::ProjectLayer, report: &mut Report) -
     if let Some(f) = field.filter(|f| l.dataset.field_index(f).is_none()) {
         report.approximated(name, format!("classes by the field {f}, which the layer hasn't: every feature draws as the rest"));
     }
-    Ok(Some(added_name))
+}
+
+/// Gives the tile layer a QGIS web layer was added as (`added` is what `map.addTiles` or
+/// `service.add` answered) the layer's visibility and opacity. Tile layers have no scale range,
+/// so one is noted.
+fn tile_settings(s: &mut Session, added: &Value, layer: &qgis::ProjectLayer, report: &mut Report) {
+    let name = layer.name.as_str();
+    let st = &layer.style;
+    let transparency = st.transparency.filter(|t| t.is_finite() && *t > 0.0);
+    let index = added.get("index").and_then(Value::as_u64).and_then(|i| usize::try_from(i).ok());
+    match index.and_then(|i| s.map_mut().tiles.get_mut(i)) {
+        Some(t) => {
+            t.visible = layer.visible;
+            if let Some(tr) = transparency {
+                t.opacity = (1.0 - tr / 100.0).clamp(0.0, 1.0);
+            }
+        }
+        None => {
+            if !layer.visible {
+                report.approximated(name, "a hidden web layer, added shown");
+            }
+            if transparency.is_some() {
+                report.approximated(name, "its transparency: added opaque");
+            }
+        }
+    }
+    if st.min_scale.flatten().is_some() || st.max_scale.flatten().is_some() {
+        report.approximated(name, "its scale range: a web layer draws at every scale");
+    }
 }
 
 /// Goes to the project's saved view, or to its layers when that view shows none of them.
@@ -232,13 +266,6 @@ fn import_style(s: &mut Session, p: &Value) -> CmdResult {
     let style = qgis::read_style(&text, &name, &mut report)?;
     let l = s.map_mut().layer_mut(id).ok_or("no such layer")?;
     style.apply(l);
-    for c in std::iter::once(&mut l.labels.default).chain(l.labels.classes.iter_mut()) {
-        if let Some(w) = c.where_.clone()
-            && rustgis_data::query::parse(&w, &l.dataset).is_err()
-        {
-            report.skipped(&name, format!("the label class \"{}\", whose clause `{w}` doesn't fit the layer", c.name));
-            c.visible = false;
-        }
-    }
+    check_fields(l, &name, &mut report);
     Ok(json!({"notes": report.notes.iter().map(note_json).collect::<Vec<_>>()}))
 }
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index ada2bf854..0701d6a8b 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -835,8 +835,6 @@ impl Session {
         cmd::tiles::follow_style_view(self, web_time::Duration::ZERO)
     }
 
-    /// Runs a command by id. Mutating commands snapshot the project for undo; an error or a
-    /// panic restores it.
     /// Runs command `id` as a part of the one running now (a command made of others): its
     /// changes are in that command's one undo step, not a step of their own.
     pub(crate) fn run_part(&mut self, id: &str, params: &Value) -> CmdResult {
@@ -846,6 +844,8 @@ impl Session {
         res
     }
 
+    /// Runs a command by id. Mutating commands snapshot the project for undo; an error or a
+    /// panic restores it.
     pub fn run(&mut self, id: &str, params: &Value) -> CmdResult {
         // The merge key asked for ([`Session::merge_undo`]) goes to this command if it runs, and is
         // gone if it's refused first, so it can't merge a later command into the last step.
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 59c404b44..9470ae4d5 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -690,6 +690,29 @@ fn a_qgis_project_opens_as_a_map_and_a_qgis_style_styles_a_layer() {
     let rivers = s.map().layer_by_name("Rivers").unwrap();
     assert_eq!((rivers.line_strokes.len(), rivers.transparency), (2, 50.0));
     assert!(s.run("style.importQgis", &json!({"layer": "Rivers", "text": "<nonsense"})).is_err());
+    // A style saved from another layer: classes and labels by fields Rivers hasn't are noted, and
+    // the label class that has nothing to label from is switched off.
+    let qml = r#"<qgis version="3.22" labelsEnabled="1"><renderer-v2 type="categorizedSymbol" attr="nofield"><categories><category value="a" symbol="0" render="true"/></categories>
+        <symbols><symbol type="line" name="0" alpha="1"><layer class="SimpleLine" enabled="1"><prop k="line_color" v="0,0,0,255"/></layer></symbol></symbols></renderer-v2>
+        <labeling type="simple"><settings><text-style fieldName="nolabelfield"/></settings></labeling></qgis>"#;
+    let out = s.run("style.importQgis", &json!({"layer": "Rivers", "text": qml})).unwrap();
+    let text = serde_json::to_string(&out["notes"]).unwrap();
+    assert!(text.contains("nofield") && text.contains("nolabelfield"), "{text}");
+    let rivers = s.map().layer_by_name("Rivers").unwrap();
+    assert!(rivers.labels.classes.iter().chain(std::iter::once(&rivers.labels.default)).all(|c| c.field != "nolabelfield" || !c.visible));
+    // A project's web layer keeps its visibility and opacity; its scale range is noted.
+    let qgs = r#"<qgis version="3.42.0"><title>Web</title>
+  <layer-tree-group><layer-tree-layer id="x" checked="Qt::Unchecked"/></layer-tree-group>
+  <projectlayers><maplayer type="raster" hasScaleBasedVisibilityFlag="1" minScale="100000" maxScale="1000"><id>x</id><datasource>type=xyz&amp;url=https://tiles.example/%7Bz%7D/%7Bx%7D/%7By%7D.png&amp;zmax=19&amp;zmin=0</datasource><layername>Tiles</layername><provider>wms</provider>
+    <pipe><rasterrenderer opacity="0.25" type="singlebandcolordata"/></pipe></maplayer></projectlayers></qgis>"#;
+    let out = s.run("project.importQgis", &json!({"text": qgs})).unwrap();
+    let t = s.map().tiles.iter().find(|t| t.name == "Tiles").expect("the web layer is added");
+    assert!(!t.visible, "unchecked in the layer tree");
+    assert!((t.opacity - 0.25).abs() < 1e-6, "{}", t.opacity);
+    let text = serde_json::to_string(&out["notes"]).unwrap();
+    assert!(text.contains("scale range"), "{text}");
+    // Plugins can't run the import: a project names files and web addresses its layers come from.
+    assert!(crate::cmd::plugins::user_only("project.importQgis"));
     std::fs::remove_dir_all(&dir).ok();
 }
 
@@ -1428,6 +1451,8 @@ fn hostile_params_never_panic() {
         json!({"type": "albers", "lon_0": f64::MAX, "lat_1": "x", "lat_2": -1e308}),
         json!({"kind": "legend", "element": 1, "exclude": [null, 7, "", {"x": 1}]}),
         json!({"kind": "text", "element": 1, "font": {"family": "serif"}, "italic": [], "align": 7}),
+        // A QGIS project and style whose web layer and scale range are junk.
+        json!({"text": "<qgis><projectlayers><maplayer type=\"raster\" hasScaleBasedVisibilityFlag=\"1\" minScale=\"NaN\" maxScale=\"-1e308\"><datasource>type=xyz&amp;url=&amp;zmax=999</datasource><layername></layername><provider>wms</provider><pipe><rasterrenderer opacity=\"inf\"/></pipe></maplayer></projectlayers></qgis>"}),
         // A label class placed along lines, with junk the placement and style read after it.
         json!({"layer": "Countries", "position": "curved", "italic": "maybe", "size": -1e308}),
         // A publication sheet's style, accent and orientation, and a shape's rounded corners.
diff --git a/crates/map/src/qgis/mod.rs b/crates/map/src/qgis/mod.rs
index 3769f0123..1ba35efff 100644
--- a/crates/map/src/qgis/mod.rs
+++ b/crates/map/src/qgis/mod.rs
@@ -17,6 +17,8 @@ mod symbol;
 #[cfg(test)]
 mod tests;
 
+use std::collections::HashMap;
+
 use roxmltree::{Document, Node, ParsingOptions};
 use serde::Serialize;
 
@@ -42,7 +44,12 @@ pub const QGIS_SCALE: f64 = (25.4 / 96.0) / 0.28;
 /// What an import carried over only in part, or left out, layer by layer.
 #[derive(Clone, Debug, Default, PartialEq, Serialize)]
 pub struct Report {
+    /// Added to by [`Report::note`] only, which keeps `index` in step.
     pub notes: Vec<Note>,
+    /// Where each note is in `notes`, by layer, kind and text: a hostile project can make
+    /// thousands of different notes, and a repeat is found without going through them all.
+    #[serde(skip)]
+    index: HashMap<(String, NoteKind, String), usize>,
 }
 
 /// One thing an import couldn't carry over as QGIS has it.
@@ -56,7 +63,7 @@ pub struct Note {
     pub count: usize,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
 #[serde(rename_all = "lowercase")]
 pub enum NoteKind {
     /// Drawn, but not quite as QGIS draws it.
@@ -68,11 +75,13 @@ pub enum NoteKind {
 impl Report {
     /// Notes `text` about `layer`, counting a repeat rather than listing it again.
     pub fn note(&mut self, layer: &str, kind: NoteKind, text: impl Into<String>) {
-        let text = text.into();
-        if let Some(n) = self.notes.iter_mut().find(|n| n.layer == layer && n.kind == kind && n.text == text) {
+        let key = (layer.to_string(), kind, text.into());
+        if let Some(n) = self.index.get(&key).and_then(|&i| self.notes.get_mut(i)) {
             n.count = n.count.saturating_add(1);
         } else if self.notes.len() < MAX_NOTES {
-            self.notes.push(Note { layer: layer.to_string(), kind, text, count: 1 });
+            self.index.insert(key.clone(), self.notes.len());
+            let (layer, kind, text) = key;
+            self.notes.push(Note { layer, kind, text, count: 1 });
         }
     }
 
@@ -83,15 +92,6 @@ impl Report {
     pub fn skipped(&mut self, layer: &str, text: impl Into<String>) {
         self.note(layer, NoteKind::Skipped, text);
     }
-
-    /// Takes in another report's notes, on top of its own.
-    pub fn extend(&mut self, other: Report) {
-        for n in other.notes {
-            for _ in 0..n.count.min(MAX_NOTES) {
-                self.note(&n.layer, n.kind, n.text.clone());
-            }
-        }
-    }
 }
 
 /// A layer's look as a QGIS style has it, in RustGIS's terms. Each part is `None` (or empty) when
@@ -288,17 +288,11 @@ fn read_style_node(node: Node, layer: &str, report: &mut Report) -> Style {
         }
         report.skipped(layer, format!("its raster colouring ({} renderer)", r.attribute("type").unwrap_or("unknown")));
     }
-    if node.attribute("labelsEnabled") != Some("0")
-        && let Some(l) = child(node, "labeling")
-    {
-        style.labels = labels::read(l, layer, report);
-    }
-    if node.attribute("labelsEnabled") == Some("0")
-        && let Some(l) = child(node, "labeling")
-    {
+    if let Some(l) = child(node, "labeling") {
         // Set up but switched off: carried over, switched off.
+        let off = node.attribute("labelsEnabled") == Some("0");
         style.labels = labels::read(l, layer, report).map(|mut l| {
-            l.enabled = false;
+            l.enabled &= !off;
             l
         });
     }
diff --git a/crates/map/src/qgis/tests.rs b/crates/map/src/qgis/tests.rs
index e09993afe..a69a6645c 100644
--- a/crates/map/src/qgis/tests.rs
+++ b/crates/map/src/qgis/tests.rs
@@ -236,4 +236,16 @@ fn hostile_files_are_refused_or_bounded() {
         r.skipped("a", "the same");
     }
     assert_eq!((r.notes.len(), r.notes[0].count), (1, 10_000));
+    // Many different notes stop at the cap; the ones kept still count their repeats, each in its
+    // own place (layer, kind and text all tell notes apart).
+    for i in 0..(MAX_NOTES + 500) {
+        r.approximated("a", format!("note {i}"));
+    }
+    assert_eq!(r.notes.len(), MAX_NOTES);
+    r.approximated("a", "note 7");
+    r.approximated("b", "note 7");
+    r.skipped("a", "note 7");
+    let at = r.notes.iter().position(|n| n.text == "note 7").unwrap();
+    assert_eq!((r.notes[at].count, r.notes[at].kind), (2, NoteKind::Approximated));
+    assert!(!r.notes.iter().any(|n| n.layer == "b"), "past the cap, a new note isn't kept");
 }

From 112181f9677673a8e502cdf5726131ff14fb3010 Mon Sep 17 00:00:00 2001
From: Dominik Strebel <dominik.strebel@gmail.com>
Date: Sat, 24 Oct 2026 18:33:15 +0200
Subject: [PATCH 3/5] fix(map): QGIS web layers keep tree order and blending;
 text projects can't reach the working directory; payloads capped

- XYZ layers are added as overlays, as WMS layers are, so web layers keep the tree's order.
- A web layer takes the QGIS layer's blending mode (noted where it can't).
- A project given as text or data with no dir: a relative path is noted, not looked for in the working directory.
- text and data are refused past the file limit, and a .qgz inflates within it.
- The assistant's gate names what project.importQgis reaches; run_part's doc says what a failing part restores.
---
 crates/assistant/src/tests.rs |  3 +++
 crates/assistant/src/tools.rs |  3 +++
 crates/engine/src/cmd/qgis.rs | 33 +++++++++++++++++++++++++++------
 crates/engine/src/lib.rs      |  5 ++++-
 crates/engine/src/tests.rs    | 13 ++++++++++++-
 crates/map/src/qgis/mod.rs    |  2 +-
 crates/map/src/qgis/source.rs | 11 +++++++++--
 7 files changed, 59 insertions(+), 11 deletions(-)

diff --git a/crates/assistant/src/tests.rs b/crates/assistant/src/tests.rs
index 345df398c..67f9bcd65 100644
--- a/crates/assistant/src/tests.rs
+++ b/crates/assistant/src/tests.rs
@@ -264,6 +264,9 @@ fn gate_rules() {
     assert!(g("run_command", json!({"command": "edit.undo"})).is_none());
     assert!(g("run_command", json!({"command": "layer.addData", "params": {"path": "/etc/passwd"}})).is_some());
     assert!(g("run_command", json!({"command": "project.new"})).is_some());
+    // A QGIS project given as text names its files and addresses inside: asked, as with a path.
+    let qgis = g("run_command", json!({"command": "project.importQgis", "params": {"text": "<qgis/>"}}));
+    assert!(qgis.as_deref().is_some_and(|w| w.contains("QGIS project")), "{qgis:?}");
     assert!(g("run_command", json!({"command": "script.run", "params": {"script": "map.zoomFull {}"}})).is_some());
     assert!(g("run_command", json!({"command": "plugin.install", "params": {"path": "x.rgplugin"}})).is_some());
     assert!(g("run_command", json!({"command": "map.addTiles", "params": {"url": "https://tile.example/{z}/{x}/{y}.png"}})).is_some());
diff --git a/crates/assistant/src/tools.rs b/crates/assistant/src/tools.rs
index 6f7bc4332..811fa4879 100644
--- a/crates/assistant/src/tools.rs
+++ b/crates/assistant/src/tools.rs
@@ -186,6 +186,9 @@ pub fn gate(s: &Session, call: &ToolCall) -> Option<String> {
             "project.new" | "project.open" | "project.openText" | "project.sample" | "project.fromTemplate" => {
                 "it replaces the open project".into()
             }
+            // Whether given a path, text or data: the project names the files and web addresses
+            // its layers are added from.
+            "project.importQgis" => "it adds the files and web addresses a QGIS project names".into(),
             _ => "it is reserved to you (plugins, scripts, tasks, models and the GeoLibre runner)".into(),
         });
     }
diff --git a/crates/engine/src/cmd/qgis.rs b/crates/engine/src/cmd/qgis.rs
index c95f61c31..3a8ac41de 100644
--- a/crates/engine/src/cmd/qgis.rs
+++ b/crates/engine/src/cmd/qgis.rs
@@ -25,15 +25,20 @@ pub fn commands() -> Vec<C> {
 fn qgis_text(p: &Value) -> Result<String, String> {
     let bytes = match (ps(p, "data"), ps(p, "text"), ps(p, "path")) {
         (Some(d), ..) => {
+            // Base64 is 4 characters for 3 bytes: a payload past the file limit isn't decoded.
+            if d.len() as u64 > MAX_FILE / 3 * 4 + 4 {
+                return Err("data is too large for a QGIS file".into());
+            }
             use base64::Engine;
             base64::engine::general_purpose::STANDARD.decode(d.trim()).map_err(|_| "data must be base64".to_string())?
         }
+        (None, Some(t), _) if t.len() as u64 > MAX_FILE => return Err("text is too large for a QGIS file".into()),
         (None, Some(t), _) => return Ok(t.to_string()),
         (None, None, Some(path)) => read_file(path)?,
         _ => return Err("path, text or data is required".into()),
     };
     if bytes.starts_with(b"PK") {
-        let entries = rustgis_data::zip::read_matching(&bytes, |n| n.to_ascii_lowercase().ends_with(".qgs"))?;
+        let entries = rustgis_data::zip::read_matching_within(&bytes, |n| n.to_ascii_lowercase().ends_with(".qgs"), MAX_FILE as usize)?;
         let (_, qgs) = entries.into_iter().next().ok_or("the .qgz holds no .qgs project")?;
         return String::from_utf8(qgs).map_err(|_| "the .qgz's project isn't text".to_string());
     }
@@ -77,7 +82,7 @@ fn import_project(s: &mut Session, p: &Value) -> CmdResult {
     // Bottom first, so each is added on top of the ones below it.
     let mut added = Vec::new();
     for layer in project.layers.iter().rev() {
-        match add_layer(s, layer, &mut report) {
+        match add_layer(s, layer, dir.is_some(), &mut report) {
             Ok(Some(name)) => added.push(name),
             Ok(None) => {}
             Err(e) => report.skipped(&layer.name, format!("the layer: {e}")),
@@ -101,9 +106,18 @@ fn import_project(s: &mut Session, p: &Value) -> CmdResult {
 }
 
 /// Adds one QGIS layer to the active map with its style: `Ok(Some(name))` when added, `Ok(None)`
-/// when its source is one RustGIS doesn't read (noted).
-fn add_layer(s: &mut Session, layer: &qgis::ProjectLayer, report: &mut Report) -> Result<Option<String>, String> {
+/// when its source is one RustGIS doesn't read (noted). Without the project's folder (`has_dir`:
+/// a project given as text or data with no `dir`), a relative path has nothing to start from and
+/// is noted rather than looked for in the working directory.
+fn add_layer(s: &mut Session, layer: &qgis::ProjectLayer, has_dir: bool, report: &mut Report) -> Result<Option<String>, String> {
     let name = layer.name.as_str();
+    if let Source::File { path, .. } | Source::Csv { path, .. } = &layer.source
+        && !has_dir
+        && qgis::is_relative(path)
+    {
+        report.skipped(name, format!("the file {path}, relative to the project's folder, which the import wasn't given (pass dir)"));
+        return Ok(None);
+    }
     match &layer.source {
         Source::File { path, layer: table, .. } => {
             let mut q = json!({"path": path, "name": name});
@@ -122,7 +136,8 @@ fn add_layer(s: &mut Session, layer: &qgis::ProjectLayer, report: &mut Report) -
             s.run_part("layer.addData", &q)?;
         }
         Source::Xyz { url, zmin, zmax, vector } => {
-            let mut q = json!({"url": url, "name": name, "kind": if *vector { "vector" } else { "raster" }});
+            // An overlay, as a WMS layer is, so web layers keep the tree's order between them.
+            let mut q = json!({"url": url, "name": name, "kind": if *vector { "vector" } else { "raster" }, "overlay": true});
             if let Some(z) = zmin {
                 q["minZoom"] = json!(z);
             }
@@ -209,7 +224,7 @@ fn check_fields(l: &mut rustgis_map::Layer, name: &str, report: &mut Report) {
 }
 
 /// Gives the tile layer a QGIS web layer was added as (`added` is what `map.addTiles` or
-/// `service.add` answered) the layer's visibility and opacity. Tile layers have no scale range,
+/// `service.add` answered) the layer's visibility, opacity and blending mode. Tile layers have no scale range,
 /// so one is noted.
 fn tile_settings(s: &mut Session, added: &Value, layer: &qgis::ProjectLayer, report: &mut Report) {
     let name = layer.name.as_str();
@@ -219,6 +234,9 @@ fn tile_settings(s: &mut Session, added: &Value, layer: &qgis::ProjectLayer, rep
     match index.and_then(|i| s.map_mut().tiles.get_mut(i)) {
         Some(t) => {
             t.visible = layer.visible;
+            if let Some(blend) = st.blend {
+                t.blend = blend;
+            }
             if let Some(tr) = transparency {
                 t.opacity = (1.0 - tr / 100.0).clamp(0.0, 1.0);
             }
@@ -230,6 +248,9 @@ fn tile_settings(s: &mut Session, added: &Value, layer: &qgis::ProjectLayer, rep
             if transparency.is_some() {
                 report.approximated(name, "its transparency: added opaque");
             }
+            if st.blend.is_some_and(|b| b != rustgis_map::effects::Blend::default()) {
+                report.approximated(name, "its blending mode: added as normal");
+            }
         }
     }
     if st.min_scale.flatten().is_some() || st.max_scale.flatten().is_some() {
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 0701d6a8b..e3342d4fc 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -836,7 +836,10 @@ impl Session {
     }
 
     /// Runs command `id` as a part of the one running now (a command made of others): its
-    /// changes are in that command's one undo step, not a step of their own.
+    /// changes are in that command's one undo step, not a step of their own. A part that fails
+    /// (or panics) is undone by its own `run`, which restores what it started from; the parts
+    /// before it stay until the command made of them fails too, whose `run` restores the project
+    /// as the whole command found it. The stacks are put back on every return.
     pub(crate) fn run_part(&mut self, id: &str, params: &Value) -> CmdResult {
         let (undo, redo) = (std::mem::take(&mut self.undo), std::mem::take(&mut self.redo));
         let res = self.run(id, params);
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 9470ae4d5..723096870 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -704,13 +704,24 @@ fn a_qgis_project_opens_as_a_map_and_a_qgis_style_styles_a_layer() {
     let qgs = r#"<qgis version="3.42.0"><title>Web</title>
   <layer-tree-group><layer-tree-layer id="x" checked="Qt::Unchecked"/></layer-tree-group>
   <projectlayers><maplayer type="raster" hasScaleBasedVisibilityFlag="1" minScale="100000" maxScale="1000"><id>x</id><datasource>type=xyz&amp;url=https://tiles.example/%7Bz%7D/%7Bx%7D/%7By%7D.png&amp;zmax=19&amp;zmin=0</datasource><layername>Tiles</layername><provider>wms</provider>
-    <pipe><rasterrenderer opacity="0.25" type="singlebandcolordata"/></pipe></maplayer></projectlayers></qgis>"#;
+    <pipe><rasterrenderer opacity="0.25" type="singlebandcolordata"/></pipe><blendMode>13</blendMode></maplayer></projectlayers></qgis>"#;
     let out = s.run("project.importQgis", &json!({"text": qgs})).unwrap();
     let t = s.map().tiles.iter().find(|t| t.name == "Tiles").expect("the web layer is added");
     assert!(!t.visible, "unchecked in the layer tree");
     assert!((t.opacity - 0.25).abs() < 1e-6, "{}", t.opacity);
     let text = serde_json::to_string(&out["notes"]).unwrap();
     assert!(text.contains("scale range"), "{text}");
+    // Web layers are overlays, so they stay in the tree's order, and take the layer's blending.
+    let t = s.map().tiles.iter().find(|t| t.name == "Tiles").unwrap();
+    assert!(t.overlay);
+    assert_eq!(t.blend, rustgis_map::effects::Blend::Multiply);
+    // A project given as text with no folder: a relative path is noted, not looked for in the
+    // working directory.
+    let rel = r#"<qgis version="3.42.0"><projectlayers><maplayer type="vector"><id>a</id><datasource>./data/roads.geojson</datasource><layername>Rel</layername><provider>ogr</provider></maplayer></projectlayers></qgis>"#;
+    let out = s.run("project.importQgis", &json!({"text": rel})).unwrap();
+    assert!(out["layers"].as_array().unwrap().is_empty());
+    let text = serde_json::to_string(&out["notes"]).unwrap();
+    assert!(text.contains("pass dir"), "{text}");
     // Plugins can't run the import: a project names files and web addresses its layers come from.
     assert!(crate::cmd::plugins::user_only("project.importQgis"));
     std::fs::remove_dir_all(&dir).ok();
diff --git a/crates/map/src/qgis/mod.rs b/crates/map/src/qgis/mod.rs
index 1ba35efff..779b7d881 100644
--- a/crates/map/src/qgis/mod.rs
+++ b/crates/map/src/qgis/mod.rs
@@ -26,7 +26,7 @@ use crate::Rgba;
 use crate::effects::Blend;
 use crate::symbology::{Labeling, LineStroke, Renderer};
 pub use expr::to_sql;
-pub use source::Source;
+pub use source::{Source, is_relative};
 
 /// The most XML nodes a project or style is read with (a large project's file is some hundred
 /// thousand).
diff --git a/crates/map/src/qgis/source.rs b/crates/map/src/qgis/source.rs
index ed3709034..adf48a920 100644
--- a/crates/map/src/qgis/source.rs
+++ b/crates/map/src/qgis/source.rs
@@ -142,14 +142,21 @@ fn table_of(s: &str) -> Option<String> {
 /// `path` from the project's folder `dir`, unless it is absolute or a web address.
 fn absolute(path: &str, dir: &str) -> String {
     let path = path.trim();
-    let windows_drive = path.as_bytes().get(1) == Some(&b':') && path.as_bytes().first().is_some_and(u8::is_ascii_alphabetic);
-    if path.is_empty() || path.starts_with('/') || path.starts_with('\\') || windows_drive || path.contains("://") || dir.is_empty() {
+    if path.is_empty() || !is_relative(path) || dir.is_empty() {
         return path.to_string();
     }
     let rel = path.strip_prefix("./").unwrap_or(path);
     format!("{}/{}", dir.trim_end_matches(['/', '\\']), rel)
 }
 
+/// Whether `path` is relative to the project's folder: not absolute (`/…`, `\\…`, `C:…`) and not
+/// a web address.
+pub fn is_relative(path: &str) -> bool {
+    let path = path.trim();
+    let windows_drive = path.as_bytes().get(1) == Some(&b':') && path.as_bytes().first().is_some_and(u8::is_ascii_alphabetic);
+    !(path.starts_with('/') || path.starts_with('\\') || windows_drive || path.contains("://"))
+}
+
 /// Percent-decodes `s` (`%7B` to `{`); a broken escape is kept as it is.
 fn decode(s: &str) -> String {
     let b = s.as_bytes();

From 4443fb59de3ff714727ab04dfffb72a5ebe6d7f1 Mon Sep 17 00:00:00 2001
From: Dominik Strebel <dominik.strebel@gmail.com>
Date: Sat, 24 Oct 2026 19:34:13 +0200
Subject: [PATCH 4/5] fix(map): a QGIS web layer added as features or a
 coverage takes its settings; drive-relative and blank-folder paths are noted

- service.add can answer with a map layer (features, a coverage) rather than tiles: that layer takes the QGIS layer's visibility, opacity, blending and scale range.
- A blank dir is none, so relative paths don't start from the working directory; a file named without a folder starts from '.'.
- C:roads.gpkg (relative to a drive's working directory) is noted, not opened.
- A label class with no field isn't noted as labelling from a missing one.
- read_file reads at most MAX_FILE + 1 bytes instead of checking the size first.
---
 crates/engine/src/cmd/qgis.rs | 74 ++++++++++++++++++++++++++---------
 crates/engine/src/tests.rs    | 29 ++++++++++++--
 crates/map/src/qgis/mod.rs    |  2 +-
 crates/map/src/qgis/source.rs | 11 +++++-
 crates/map/src/qgis/tests.rs  | 11 ++++++
 5 files changed, 101 insertions(+), 26 deletions(-)

diff --git a/crates/engine/src/cmd/qgis.rs b/crates/engine/src/cmd/qgis.rs
index 3a8ac41de..1a9048614 100644
--- a/crates/engine/src/cmd/qgis.rs
+++ b/crates/engine/src/cmd/qgis.rs
@@ -48,19 +48,27 @@ fn qgis_text(p: &Value) -> Result<String, String> {
 /// The most bytes of a QGIS file read.
 const MAX_FILE: u64 = 256 << 20;
 
+/// Reads at most [`MAX_FILE`] bytes of `path` (natively: the web app passes `text` or `data`).
 fn read_file(path: &str) -> Result<Vec<u8>, String> {
-    let len = std::fs::metadata(path).map_err(|e| format!("{path}: {e}"))?.len();
-    if len > MAX_FILE {
+    use std::io::Read;
+    let mut bytes = Vec::new();
+    std::fs::File::open(path).and_then(|f| f.take(MAX_FILE + 1).read_to_end(&mut bytes)).map_err(|e| format!("{path}: {e}"))?;
+    if bytes.len() as u64 > MAX_FILE {
         return Err(format!("{path} is too large for a QGIS project"));
     }
-    std::fs::read(path).map_err(|e| format!("{path}: {e}"))
+    Ok(bytes)
 }
 
 fn import_project(s: &mut Session, p: &Value) -> CmdResult {
     let text = qgis_text(p)?;
-    let dir = ps(p, "dir")
-        .map(str::to_string)
-        .or_else(|| ps(p, "path").and_then(|path| std::path::Path::new(path).parent()).map(|d| d.to_string_lossy().into_owned()));
+    // The folder relative paths start from: `dir` (a blank one is none, so they don't start
+    // from the working directory), else the file's own (`.` for a file named without one).
+    let dir = ps(p, "dir").filter(|d| !d.trim().is_empty()).map(str::to_string).or_else(|| {
+        ps(p, "path").and_then(|path| std::path::Path::new(path).parent()).map(|d| match d.to_string_lossy() {
+            d if d.is_empty() => ".".to_string(),
+            d => d.into_owned(),
+        })
+    });
     let mut report = Report::default();
     let project = qgis::read_project(&text, dir.as_deref().unwrap_or_default(), &mut report)?;
     // A map of its own, named as the project.
@@ -111,12 +119,16 @@ fn import_project(s: &mut Session, p: &Value) -> CmdResult {
 /// is noted rather than looked for in the working directory.
 fn add_layer(s: &mut Session, layer: &qgis::ProjectLayer, has_dir: bool, report: &mut Report) -> Result<Option<String>, String> {
     let name = layer.name.as_str();
-    if let Source::File { path, .. } | Source::Csv { path, .. } = &layer.source
-        && !has_dir
-        && qgis::is_relative(path)
-    {
-        report.skipped(name, format!("the file {path}, relative to the project's folder, which the import wasn't given (pass dir)"));
-        return Ok(None);
+    if let Source::File { path, .. } | Source::Csv { path, .. } = &layer.source {
+        if !has_dir && qgis::is_relative(path) {
+            report.skipped(name, format!("the file {path}, relative to the project's folder, which the import wasn't given (pass dir)"));
+            return Ok(None);
+        }
+        // `C:roads.gpkg`: relative to the working directory on drive C, which no folder fixes.
+        if qgis::is_drive_relative(path) {
+            report.skipped(name, format!("the file {path}, relative to a drive's working directory (give a full path in QGIS)"));
+            return Ok(None);
+        }
     }
     match &layer.source {
         Source::File { path, layer: table, .. } => {
@@ -144,13 +156,15 @@ fn add_layer(s: &mut Session, layer: &qgis::ProjectLayer, has_dir: bool, report:
             if let Some(z) = zmax {
                 q["maxZoom"] = json!(z);
             }
+            let before = s.active_layer;
             let added = s.run_part("map.addTiles", &q)?;
-            tile_settings(s, &added, layer, report);
+            web_settings(s, &added, before, layer, report);
             return Ok(Some(name.to_string()));
         }
         Source::Wms { url, layer: wms, .. } => {
+            let before = s.active_layer;
             let added = s.run_part("service.add", &json!({"url": url, "type": "wms", "layer": wms, "name": name}))?;
-            tile_settings(s, &added, layer, report);
+            web_settings(s, &added, before, layer, report);
             return Ok(Some(name.to_string()));
         }
         Source::Wfs { url, layer: typename } => {
@@ -209,7 +223,8 @@ fn check_fields(l: &mut rustgis_map::Layer, name: &str, report: &mut Report) {
             report.skipped(name, format!("the label class \"{}\", whose clause `{w}` doesn't fit the layer ({e})", c.name));
             c.visible = false;
         }
-        if l.dataset.field_index(&c.field).is_none() && c.visible {
+        // (A class with no field set labels nothing, and isn't noted.)
+        if c.visible && !c.field.is_empty() && l.dataset.field_index(&c.field).is_none() {
             report.skipped(name, format!("labels from the field {}, which the layer hasn't", c.field));
             c.visible = false;
         }
@@ -223,14 +238,35 @@ fn check_fields(l: &mut rustgis_map::Layer, name: &str, report: &mut Report) {
     }
 }
 
-/// Gives the tile layer a QGIS web layer was added as (`added` is what `map.addTiles` or
-/// `service.add` answered) the layer's visibility, opacity and blending mode. Tile layers have no scale range,
-/// so one is noted.
-fn tile_settings(s: &mut Session, added: &Value, layer: &qgis::ProjectLayer, report: &mut Report) {
+/// Gives what a QGIS web layer was added as the layer's visibility, opacity and blending mode.
+/// `added` is what `map.addTiles` or `service.add` answered: a tile layer's `index`, or no index
+/// when the service offered the layer as features or a coverage, which come in as a map layer
+/// (the active one, if it isn't `before` any more), which takes the scale range too. A tile layer
+/// has no scale range, so one is noted.
+pub(crate) fn web_settings(s: &mut Session, added: &Value, before: Option<u32>, layer: &qgis::ProjectLayer, report: &mut Report) {
     let name = layer.name.as_str();
     let st = &layer.style;
     let transparency = st.transparency.filter(|t| t.is_finite() && *t > 0.0);
     let index = added.get("index").and_then(Value::as_u64).and_then(|i| usize::try_from(i).ok());
+    if index.is_none()
+        && let Some(id) = s.active_layer.filter(|id| Some(*id) != before)
+        && let Some(l) = s.map_mut().layer_mut(id)
+    {
+        l.visible = layer.visible;
+        if let Some(tr) = transparency {
+            l.transparency = tr.clamp(0.0, 100.0);
+        }
+        if let Some(blend) = st.blend {
+            l.blend = blend;
+        }
+        if let Some(m) = st.min_scale {
+            l.min_scale = m;
+        }
+        if let Some(m) = st.max_scale {
+            l.max_scale = m;
+        }
+        return;
+    }
     match index.and_then(|i| s.map_mut().tiles.get_mut(i)) {
         Some(t) => {
             t.visible = layer.visible;
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 723096870..375927498 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -718,10 +718,31 @@ fn a_qgis_project_opens_as_a_map_and_a_qgis_style_styles_a_layer() {
     // A project given as text with no folder: a relative path is noted, not looked for in the
     // working directory.
     let rel = r#"<qgis version="3.42.0"><projectlayers><maplayer type="vector"><id>a</id><datasource>./data/roads.geojson</datasource><layername>Rel</layername><provider>ogr</provider></maplayer></projectlayers></qgis>"#;
-    let out = s.run("project.importQgis", &json!({"text": rel})).unwrap();
-    assert!(out["layers"].as_array().unwrap().is_empty());
-    let text = serde_json::to_string(&out["notes"]).unwrap();
-    assert!(text.contains("pass dir"), "{text}");
+    for p in [json!({"text": rel}), json!({"text": rel, "dir": "  "})] {
+        let out = s.run("project.importQgis", &p).unwrap();
+        assert!(out["layers"].as_array().unwrap().is_empty(), "{p}");
+        let text = serde_json::to_string(&out["notes"]).unwrap();
+        assert!(text.contains("pass dir"), "{text}");
+    }
+    // A path relative to a drive's working directory is noted, with or without a folder.
+    let drive = rel.replace("./data/roads.geojson", "C:roads.geojson");
+    let out = s.run("project.importQgis", &json!({"text": drive, "dir": dir.display().to_string()})).unwrap();
+    assert!(serde_json::to_string(&out["notes"]).unwrap().contains("drive"), "{out}");
+    // A web layer a service offers as features or a coverage comes in as a map layer, which takes
+    // the QGIS layer's visibility, opacity, blending and scale range.
+    let web = r#"<qgis version="3.42.0"><layer-tree-group><layer-tree-layer id="w" checked="Qt::Unchecked"/></layer-tree-group><projectlayers>
+        <maplayer type="raster" hasScaleBasedVisibilityFlag="1" minScale="100000" maxScale="1000"><id>w</id><datasource>url=https://wms.example/wms&amp;layers=a</datasource><layername>Web</layername><provider>wms</provider>
+        <pipe><rasterrenderer opacity="0.5" type="singlebandcolordata"/></pipe><blendMode>13</blendMode></maplayer></projectlayers></qgis>"#;
+    let mut report = rustgis_map::qgis::Report::default();
+    let project = rustgis_map::qgis::read_project(web, "", &mut report).unwrap();
+    let mut w = world();
+    let before = w.active_layer;
+    w.active_layer = w.map().layers.iter().map(|l| l.id).find(|id| Some(*id) != before);
+    crate::cmd::qgis::web_settings(&mut w, &json!({"name": "Web"}), before, &project.layers[0], &mut report);
+    let l = w.map().layers.iter().find(|l| Some(l.id) == w.active_layer).unwrap();
+    assert!(!l.visible);
+    assert_eq!((l.transparency, l.blend), (50.0, rustgis_map::effects::Blend::Multiply));
+    assert!(l.min_scale.is_some() && l.max_scale.is_some());
     // Plugins can't run the import: a project names files and web addresses its layers come from.
     assert!(crate::cmd::plugins::user_only("project.importQgis"));
     std::fs::remove_dir_all(&dir).ok();
diff --git a/crates/map/src/qgis/mod.rs b/crates/map/src/qgis/mod.rs
index 779b7d881..44c1c0d10 100644
--- a/crates/map/src/qgis/mod.rs
+++ b/crates/map/src/qgis/mod.rs
@@ -26,7 +26,7 @@ use crate::Rgba;
 use crate::effects::Blend;
 use crate::symbology::{Labeling, LineStroke, Renderer};
 pub use expr::to_sql;
-pub use source::{Source, is_relative};
+pub use source::{Source, is_drive_relative, is_relative};
 
 /// The most XML nodes a project or style is read with (a large project's file is some hundred
 /// thousand).
diff --git a/crates/map/src/qgis/source.rs b/crates/map/src/qgis/source.rs
index adf48a920..f7649c6b8 100644
--- a/crates/map/src/qgis/source.rs
+++ b/crates/map/src/qgis/source.rs
@@ -149,8 +149,15 @@ fn absolute(path: &str, dir: &str) -> String {
     format!("{}/{}", dir.trim_end_matches(['/', '\\']), rel)
 }
 
-/// Whether `path` is relative to the project's folder: not absolute (`/…`, `\\…`, `C:…`) and not
-/// a web address.
+/// Whether `path` is relative to a Windows drive's working directory (`C:roads.gpkg`, not
+/// `C:\…` or `C:/…`): no project folder tells where that is.
+pub fn is_drive_relative(path: &str) -> bool {
+    let b = path.trim().as_bytes();
+    b.get(1) == Some(&b':') && b.first().is_some_and(u8::is_ascii_alphabetic) && !matches!(b.get(2), Some(b'/' | b'\\'))
+}
+
+/// Whether `path` is relative to the project's folder: not absolute (`/…`, `\…`, `C:\…`), not
+/// on a drive (`C:…`, see [`is_drive_relative`]) and not a web address.
 pub fn is_relative(path: &str) -> bool {
     let path = path.trim();
     let windows_drive = path.as_bytes().get(1) == Some(&b':') && path.as_bytes().first().is_some_and(u8::is_ascii_alphabetic);
diff --git a/crates/map/src/qgis/tests.rs b/crates/map/src/qgis/tests.rs
index a69a6645c..8b3e6ee4a 100644
--- a/crates/map/src/qgis/tests.rs
+++ b/crates/map/src/qgis/tests.rs
@@ -249,3 +249,14 @@ fn hostile_files_are_refused_or_bounded() {
     assert_eq!((r.notes[at].count, r.notes[at].kind), (2, NoteKind::Approximated));
     assert!(!r.notes.iter().any(|n| n.layer == "b"), "past the cap, a new note isn't kept");
 }
+
+#[test]
+fn paths_on_a_drive_are_told_apart_from_absolute_ones() {
+    for p in ["C:roads.gpkg", "d:data\\x.shp", "C:"] {
+        assert!(is_drive_relative(p) && !is_relative(p), "{p}");
+    }
+    for p in ["C:/gis/roads.gpkg", "C:\\gis\\roads.gpkg", "/srv/x.shp", "https://x.org/a.geojson"] {
+        assert!(!is_drive_relative(p) && !is_relative(p), "{p}");
+    }
+    assert!(is_relative("./data/x.shp") && is_relative("data/x.shp") && !is_drive_relative("data/x.shp"));
+}

From 1981d74d2c965ceb4e6a436c6813218976b11df8 Mon Sep 17 00:00:00 2001
From: Dominik Strebel <dominik.strebel@gmail.com>
Date: Sat, 24 Oct 2026 20:17:16 +0200
Subject: [PATCH 5/5] fix(map): QGIS project and style XML is parsed up to 64
 MiB

The file (or data) limit stays 256 MiB, as a .qgz can carry data beside its project; the XML a project or style parses into a tree several times its size is capped at 64 MiB, whether given as text, read as a file or inflated from a .qgz.
---
 crates/engine/src/cmd/qgis.rs | 12 +++++++++---
 crates/engine/src/tests.rs    |  2 ++
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/crates/engine/src/cmd/qgis.rs b/crates/engine/src/cmd/qgis.rs
index 1a9048614..dd6bcbbe3 100644
--- a/crates/engine/src/cmd/qgis.rs
+++ b/crates/engine/src/cmd/qgis.rs
@@ -32,21 +32,27 @@ fn qgis_text(p: &Value) -> Result<String, String> {
             use base64::Engine;
             base64::engine::general_purpose::STANDARD.decode(d.trim()).map_err(|_| "data must be base64".to_string())?
         }
-        (None, Some(t), _) if t.len() as u64 > MAX_FILE => return Err("text is too large for a QGIS file".into()),
+        (None, Some(t), _) if t.len() > MAX_XML => return Err("text is too large for a QGIS project or style".into()),
         (None, Some(t), _) => return Ok(t.to_string()),
         (None, None, Some(path)) => read_file(path)?,
         _ => return Err("path, text or data is required".into()),
     };
     if bytes.starts_with(b"PK") {
-        let entries = rustgis_data::zip::read_matching_within(&bytes, |n| n.to_ascii_lowercase().ends_with(".qgs"), MAX_FILE as usize)?;
+        let entries = rustgis_data::zip::read_matching_within(&bytes, |n| n.to_ascii_lowercase().ends_with(".qgs"), MAX_XML)?;
         let (_, qgs) = entries.into_iter().next().ok_or("the .qgz holds no .qgs project")?;
         return String::from_utf8(qgs).map_err(|_| "the .qgz's project isn't text".to_string());
     }
+    if bytes.len() > MAX_XML {
+        return Err("too large for a QGIS project or style".into());
+    }
     String::from_utf8(bytes).map_err(|_| "not a QGIS file (it isn't text)".to_string())
 }
 
-/// The most bytes of a QGIS file read.
+/// The most bytes of a QGIS file read (a `.qgz` can carry data files beside its project).
 const MAX_FILE: u64 = 256 << 20;
+/// The most bytes of a project's or style's XML parsed: its tree is several times larger than
+/// the text, and real ones are a few megabytes.
+const MAX_XML: usize = 64 << 20;
 
 /// Reads at most [`MAX_FILE`] bytes of `path` (natively: the web app passes `text` or `data`).
 fn read_file(path: &str) -> Result<Vec<u8>, String> {
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 375927498..b5f270460 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -724,6 +724,8 @@ fn a_qgis_project_opens_as_a_map_and_a_qgis_style_styles_a_layer() {
         let text = serde_json::to_string(&out["notes"]).unwrap();
         assert!(text.contains("pass dir"), "{text}");
     }
+    // XML past what's parsed (64 MiB) is refused before parsing.
+    assert!(s.run("project.importQgis", &json!({"text": " ".repeat((64 << 20) + 1)})).is_err());
     // A path relative to a drive's working directory is noted, with or without a folder.
     let drive = rel.replace("./data/roads.geojson", "C:roads.geojson");
     let out = s.run("project.importQgis", &json!({"text": drive, "dir": dir.display().to_string()})).unwrap();