fix(control): an undecodable request id is rejected

Cargo.toml

@@ -37,7 +37,7 @@ clap_mangen = { version = "0.3.3", features = ["env"] }
 thiserror = "2"
 same-file = "1"
 serde = { version = "1", features = ["derive", "rc"] }
-serde_json = { version = "1", features = ["float_roundtrip"] }
+serde_json = { version = "1", features = ["float_roundtrip", "raw_value"] }
 log = "0.4"
 # All date/time conversion goes through chrono (no hand-rolled calendar code beyond the 400-year range extension; AGENTS.md).
 chrono = { version = "0.4.45", default-features = false, features = ["std"] }

apps/cadcraft/src/control_server.rs

@@ -221,12 +221,17 @@ fn read_bounded_line(reader: &mut impl BufRead, buf: &mut Vec<u8>, max: usize, h
     }
 }
 
+/// Longest request `id` (it is copied into the reply).
+const MAX_ID_BYTES: usize = 4096;
+
 /// One request line, parsed.
-enum Line {
+enum Line<'a> {
     Request {
         id: Value,
         method: String,
-        params: Value,
+        /// Left as text until the token is checked: decoding it first would let an unauthenticated
+        /// peer turn a flat array into many owned JSON values.
+        params: Option<&'a serde_json::value::RawValue>,
         token: Option<String>,
     },
     Blank,
@@ -235,7 +240,7 @@ enum Line {
 }
 
 /// Parse a UTF-8 JSON request and its optional token, distinguishing blank lines from rejected input.
-fn parse_line(bytes: &[u8]) -> Line {
+fn parse_line(bytes: &[u8]) -> Line<'_> {
     let Ok(text) = std::str::from_utf8(bytes) else {
         return Line::Reject("not a control request (invalid UTF-8); closing the connection".into());
     };
@@ -246,23 +251,28 @@ fn parse_line(bytes: &[u8]) -> Line {
     if is_http_request_line(text) {
         return Line::Reject("HTTP is not served here: this port takes JSON lines; closing the connection".into());
     }
-    let msg = match serde_json::from_str::<Value>(text) {
-        Ok(v) => v,
-        Err(e) => return Line::Reject(format!("bad JSON ({e}); expected one JSON request object per line; closing the connection")),
-    };
-    let Value::Object(mut obj) = msg else {
+    // Checked without building values; then only the object's own keys are read, each value kept as text.
+    if let Err(e) = serde_json::from_str::<&serde_json::value::RawValue>(text) {
+        return Line::Reject(format!("bad JSON ({e}); expected one JSON request object per line; closing the connection"));
+    }
+    let Ok(mut obj) = serde_json::from_str::<std::collections::BTreeMap<String, &serde_json::value::RawValue>>(text) else {
         return Line::Reject("not a control request (expected a JSON object); closing the connection".into());
     };
-    let Some(Value::String(method)) = obj.remove("method") else {
+    // `method` and `token` are decoded as strings only (anything else is no string); `id` is echoed back
+    // in replies, so it is decoded but bounded.
+    let string = |v: Option<&serde_json::value::RawValue>| v.and_then(|r| serde_json::from_str::<String>(r.get()).ok());
+    let Some(method) = string(obj.remove("method")) else {
         return Line::Reject("not a control request (missing string `method`); closing the connection".into());
     };
-    // Moved out of the parsed object, not cloned: `params` can be most of the line.
-    Line::Request {
-        id: obj.remove("id").unwrap_or(Value::Null),
-        method,
-        params: obj.remove("params").unwrap_or(json!({})),
-        token: obj.remove("token").and_then(|t| if let Value::String(t) = t { Some(t) } else { None }),
-    }
+    let id = match obj.remove("id") {
+        None => Value::Null,
+        Some(r) if r.get().len() <= MAX_ID_BYTES => match serde_json::from_str(r.get()) {
+            Ok(v) => v,
+            Err(e) => return Line::Reject(format!("bad `id` ({e}); closing the connection")),
+        },
+        Some(_) => return Line::Reject(format!("`id` is longer than {MAX_ID_BYTES} bytes; closing the connection")),
+    };
+    Line::Request { id, method, params: obj.remove("params"), token: string(obj.remove("token")) }
 }
 
 /// An HTTP/1 request line (`POST / HTTP/1.1`) or the HTTP/2 preface (`PRI * HTTP/2.0`).
@@ -305,6 +315,16 @@ fn serve(stream: TcpStream, tx: &SyncSender<ControlRequest>, ctx: &egui::Context
                         let _ = writeln!(out, "{r}");
                         break;
                     }
+                    // Absent `params` is `{}`; ones that cannot be decoded (an unpaired surrogate escape) are an
+                    // error, not a request run with defaults.
+                    let params = match params.map(|r| serde_json::from_str::<Value>(r.get())) {
+                        None => json!({}),
+                        Some(Ok(v)) => v,
+                        Some(Err(e)) => {
+                            let _ = writeln!(out, "{}", json!({"ok": false, "error": format!("bad params ({e}); closing the connection"), "id": id}));
+                            break;
+                        }
+                    };
                     let (req, pending) = ControlRequest::new(method, params);
                     let mut r = match tx.try_send(req) {
                         Ok(()) => {
@@ -372,6 +392,22 @@ mod tests {
         assert_eq!(input.len(), 100 - 11, "the rest of the line is left unread");
     }
 
+    /// The parameters stay text until the token is checked, and a request decodes as before.
+    #[test]
+    fn params_are_decoded_only_as_text_by_the_parser() {
+        let line = br#"{"id":7,"method":"m","token":"t","params":[1,2,{"a":[3]}],"extra":null}"#;
+        let Line::Request { id, method, params, token } = parse_line(line) else { panic!("a request") };
+        assert_eq!((id, method.as_str(), token.as_deref()), (json!(7), "m", Some("t")));
+        assert_eq!(params.map(|p| p.get()), Some(r#"[1,2,{"a":[3]}]"#));
+        assert!(matches!(parse_line(b"[1,2,3]"), Line::Reject(e) if e.contains("expected a JSON object")));
+        assert!(matches!(parse_line(b"{\"method\":"), Line::Reject(e) if e.contains("bad JSON")));
+        assert!(matches!(parse_line(br#"{"id":[1],"method":5}"#), Line::Reject(e) if e.contains("missing string `method`")));
+        let long_id = format!(r#"{{"id":"{}","method":"m"}}"#, "x".repeat(MAX_ID_BYTES));
+        assert!(matches!(parse_line(long_id.as_bytes()), Line::Reject(e) if e.contains("`id` is longer")));
+        assert!(matches!(parse_line(br#"{"id":"\ud800","method":"m"}"#), Line::Reject(e) if e.contains("bad `id`")));
+        assert!(matches!(parse_line(br#"{"id":1}"#), Line::Reject(e) if e.contains("missing string `method`")));
+    }
+
     fn held() -> Held {
         Held::new(Budget::new(usize::MAX))
     }

crates/io/src/dxf_mline.rs

@@ -371,7 +371,16 @@ fn fill(store: &mut EntityStore, by_name: &HashMap<String, MLineStyle>) {
                 && let Some(st) = by_name.get(&key(&m.style))
                 && st.elements.len() == m.def.elements.len()
             {
-                m.def = st.clone();
+                // The description is the style table's; copying it into every multiline would multiply a long one.
+                m.def = MLineStyle {
+                    name: st.name.clone(),
+                    description: String::new(),
+                    elements: st.elements.clone(),
+                    start_caps: st.start_caps,
+                    end_caps: st.end_caps,
+                    joints: st.joints,
+                    fill: st.fill,
+                };
             }
         });
     }

crates/io/tests/it/mline_roundtrip.rs

@@ -59,7 +59,8 @@ fn mlines_and_styles_survive_save_and_reopen() {
     let back = cadcraft_io::read_dxf(saved.as_bytes()).unwrap();
     let [a, b] = mlines(&back).try_into().unwrap();
     // The geometry as drawn is the same, breaks included.
-    assert_eq!(a.def, wall());
+    // The description lives in the style table (checked below), not copied into every multiline.
+    assert_eq!(a.def, MLineStyle { description: String::new(), ..wall() });
     assert_eq!(
         (a.style.as_str(), a.justification, a.scale, a.closed, a.no_start_caps, a.no_end_caps),
         ("Wall", MLineJust::Zero, 2.0, false, false, true)
@@ -101,7 +102,7 @@ fn mlines_and_styles_survive_save_and_reopen() {
     // Saving again is stable.
     let again = cadcraft_io::read_dxf(cadcraft_io::write_dxf(&back).as_bytes()).unwrap();
     assert_eq!(mlines(&again).len(), 2);
-    assert_eq!(mlines(&again)[0].def, wall());
+    assert_eq!(mlines(&again)[0].def, MLineStyle { description: String::new(), ..wall() });
 }
 
 /// A multiline as another program writes it: style `Duo` (offsets 0.25 and -0.25, the first red)

crates/render/src/blocks.rs

@@ -12,17 +12,16 @@ pub(crate) fn sub_ctx<'a>(ctx: &Ctx<'a>, e: &Entity, m: Mat3) -> Ctx<'a> {
     };
     let lw = match e.common.lineweight {
         Lineweight::ByBlock => ctx.block_lw,
-        Lineweight::ByLayer => ctx.layer(layer.as_deref().unwrap_or("0")).map(|l| l.lineweight).unwrap_or(Lineweight::Default),
+        Lineweight::ByLayer => ctx.d.layer(layer.as_deref().unwrap_or("0")).map(|l| l.lineweight).unwrap_or(Lineweight::Default),
         x => x,
     };
     let lt = match e.common.linetype.to_ascii_lowercase().as_str() {
         "byblock" => ctx.block_ltype.clone(),
-        "bylayer" => ctx.layer(layer.as_deref().unwrap_or("0")).map(|l| l.linetype.clone()).unwrap_or_else(|| "Continuous".into()),
+        "bylayer" => ctx.d.layer(layer.as_deref().unwrap_or("0")).map(|l| l.linetype.clone()).unwrap_or_else(|| "Continuous".into()),
         _ => e.common.linetype.clone(),
     };
     Ctx {
         d: ctx.d,
-        layers: ctx.layers,
         xf: ctx.xf.then_before(m),
         block_color: color,
         block_layer: layer,

crates/render/src/clip.rs

@@ -256,16 +256,8 @@ pub struct PolyClip {
     band_h: f64,
     /// The region as triangles (for clipping fills), with each triangle's bounds.
     tris: Vec<([Vec2; 3], Bounds2)>,
-    /// Indices into `tris` of the triangles whose y range meets each band (at most
-    /// [`TRI_BAND_SPAN`] bands of it), so a fill triangle meets only the clip triangles near it.
-    tri_bands: Vec<Vec<u32>>,
-    /// Indices of the triangles spanning more bands than that: tested against every fill triangle.
-    tall_tris: Vec<u32>,
 }
 
-/// Most bands one clip triangle is registered in; a taller one goes to [`PolyClip::tall_tris`].
-const TRI_BAND_SPAN: usize = 8;
-
 impl PolyClip {
     /// A clip region for `poly` (see [`clean_polygon`]); `None` for a degenerate outline.
     pub fn new(poly: &[Vec2]) -> Option<PolyClip> {
@@ -274,15 +266,7 @@ impl PolyClip {
         let band_h = bounds.height() / BANDS as f64;
         let mut bands: Vec<Vec<u32>> = vec![Vec::new(); BANDS];
         let n = poly.len();
-        let mut clip = PolyClip {
-            poly: Vec::new(),
-            bounds,
-            bands: Vec::new(),
-            band_h,
-            tris: Vec::new(),
-            tri_bands: vec![Vec::new(); BANDS],
-            tall_tris: Vec::new(),
-        };
+        let mut clip = PolyClip { poly: Vec::new(), bounds, bands: Vec::new(), band_h, tris: Vec::new() };
         for i in 0..n {
             let (Some(a), Some(b)) = (poly.get(i), poly.get((i + 1) % n)) else { continue };
             let (lo, hi) = (clip.band(a.y.min(b.y)), clip.band(a.y.max(b.y)));
@@ -298,17 +282,6 @@ impl PolyClip {
             .map(|t| (*t, Bounds2::from_points(t.iter().copied())))
             .filter(|(_, b)| b.width() > 0.0 && b.height() > 0.0)
             .collect();
-        for k in 0..clip.tris.len() {
-            let Some((_, tb)) = clip.tris.get(k) else { continue };
-            let (lo, hi) = (clip.band(tb.min.y), clip.band(tb.max.y));
-            if hi - lo >= TRI_BAND_SPAN {
-                clip.tall_tris.push(k as u32);
-            } else {
-                for band in clip.tri_bands.iter_mut().take(hi + 1).skip(lo) {
-                    band.push(k as u32);
-                }
-            }
-        }
         clip.poly = poly;
         clip.bands = bands;
         Some(clip)
@@ -431,15 +404,7 @@ impl PolyClip {
                 out.extend_from_slice(t);
                 continue;
             }
-            // The clip triangles near `t`, in clip order (the same output as a scan of all of them).
-            let (lo, hi) = (self.band(tb.min.y), self.band(tb.max.y));
-            let mut near: Vec<u32> = self.tall_tris.clone();
-            for band in self.tri_bands.iter().take(hi + 1).skip(lo) {
-                near.extend_from_slice(band);
-            }
-            near.sort_unstable();
-            near.dedup();
-            for (c, cb) in near.iter().filter_map(|&k| self.tris.get(k as usize)) {
+            for (c, cb) in &self.tris {
                 if !cb.intersects(&tb) {
                     continue;
                 }
@@ -625,39 +590,6 @@ mod tests {
         assert!(t.iter().all(|p| !(p.x > 5.0 + 1e-9 && p.y > 5.0 + 1e-9)));
     }
 
-    /// A fill clipped through the band index equals the same fill against a plain scan of every clip
-    /// triangle (the unindexed result), for a boundary with tall and short triangles.
-    #[test]
-    fn indexed_triangle_clipping_equals_a_full_scan() {
-        // A comb: tall teeth over a base, so its triangles span many bands.
-        let mut poly = vec![Vec2::new(0.0, 0.0), Vec2::new(40.0, 0.0)];
-        for i in (0..20).rev() {
-            let x = i as f64 * 2.0;
-            poly.extend([
-                Vec2::new(x + 2.0, 20.0),
-                Vec2::new(x + 1.0, 20.0),
-                Vec2::new(x + 1.0, 2.0),
-                Vec2::new(x + 0.5, 2.0),
-                Vec2::new(x + 0.5, 20.0),
-                Vec2::new(x, 20.0),
-            ]);
-        }
-        let c = PolyClip::new(&poly).unwrap();
-        assert!(!c.tall_tris.is_empty());
-        let fill: Vec<Vec2> = (0..30)
-            .flat_map(|i| {
-                let (x, y) = (i as f64 * 1.3, (i % 7) as f64 * 2.5);
-                [Vec2::new(x, y), Vec2::new(x + 6.0, y), Vec2::new(x + 2.0, y + 9.0)]
-            })
-            .collect();
-        let got = c.clip_triangles(&fill);
-        let mut scan = c.clone();
-        scan.tri_bands = vec![(0..scan.tris.len() as u32).collect(); BANDS];
-        scan.tall_tris.clear();
-        assert_eq!(got, scan.clip_triangles(&fill));
-        assert!(!got.is_empty());
-    }
-
     #[test]
     fn degenerate_and_hostile_outlines() {
         assert!(PolyClip::new(&[Vec2::new(0.0, 0.0), Vec2::new(1.0, 1.0)]).is_none());

crates/render/src/dim_draw.rs

@@ -42,7 +42,7 @@ pub(crate) fn dimension(
     let dim_rgb = ink(style.dim_line_color, layer_color, own);
     let ext_rgb = ink(style.ext_line_color, layer_color, own);
     let txt_rgb = ink(style.text_color, layer_color, own);
-    let layer = ctx.layer(layer_name);
+    let layer = d.layer(layer_name);
     let weight = |v: i16| -> f32 {
         if !b.opts.lineweights {
             return 0.0;

crates/render/src/fill.rs

@@ -1,109 +1,40 @@
 //! Polygon filling: even-odd regions to triangles (slab decomposition), wide polylines.
 
 use cadcraft_doc::LwPolyline;
-use cadcraft_geom::{Bounds2, Polyline, Vec2};
+use cadcraft_geom::{Polyline, Vec2};
 
 /// Triangulate an even-odd region bounded by closed loops (holes allowed) by cutting it into
 /// horizontal slabs at every vertex y and emitting trapezoids. Two edges that cross inside a slab
 /// (a bowtie, two loops crossing each other) swap order there, so such a slab is cut again at the
 /// crossing and each part is paired on its own. Robust for any input; output size is
-/// O(slabs × crossings), capped for hostile inputs. Groups of loops whose bounding boxes are
-/// separated (by a vertical or a horizontal gap, recursively) cannot affect each other's even-odd
-/// parity, so each group is cut on its own: disjoint outlines do not multiply each other's slabs.
+/// O(slabs × crossings), capped for hostile inputs.
 pub fn triangulate_evenodd(loops: &[Vec<Vec2>]) -> Vec<Vec2> {
-    // (original index, bounds, edges) per loop.
-    let mut items: Vec<(usize, Bounds2, Vec<(Vec2, Vec2)>)> = Vec::new();
-    let mut total = 0usize;
-    for (k, l) in loops.iter().enumerate() {
+    let mut edges: Vec<(Vec2, Vec2)> = Vec::new();
+    for l in loops {
         let n = l.len();
         if n < 3 {
             continue;
         }
-        let mut edges = Vec::new();
         for i in 0..n {
             let (Some(&a), Some(&b)) = (l.get(i), l.get((i + 1) % n)) else { continue };
             if (a.y - b.y).abs() > 1e-15 && a.is_finite() && b.is_finite() {
                 edges.push(if a.y < b.y { (a, b) } else { (b, a) });
             }
         }
-        total += edges.len();
-        if total > 200_000 {
-            return Vec::new();
-        }
-        if !edges.is_empty() {
-            let bounds = Bounds2::from_points(edges.iter().flat_map(|(a, b)| [*a, *b]));
-            items.push((k, bounds, edges));
-        }
     }
-    let mut out = Vec::new();
-    // Slabs created by cutting at crossings, over the whole region; past this the remaining
-    // crossings are left unsplit rather than letting a hostile input run away.
-    let mut cuts_left = MAX_CROSSING_CUTS;
-    // Loop visits all the partitioning may make: an input that peels one loop off a big group at a
-    // time would rescan the rest each time, so past this a group is cut as it stands (as before partitioning existed).
-    let mut split_work = 64 * items.len() + 4_000_000;
-    let mut stack = vec![items];
-    while let Some(mut group) = stack.pop() {
-        if group.is_empty() {
-            continue;
-        }
-        let parts = match split_work.checked_sub(2 * group.len()) {
-            Some(rest) => {
-                split_work = rest;
-                let parts = split_groups(&mut group, true);
-                if parts.len() > 1 { parts } else { split_groups(&mut group, false) }
-            }
-            None => Vec::new(),
-        };
-        if parts.len() > 1 {
-            // Lowest-first when popped.
-            stack.extend(parts.into_iter().rev());
-            continue;
-        }
-        group.sort_by_key(|g| g.0);
-        let edges: Vec<(Vec2, Vec2)> = group.into_iter().flat_map(|g| g.2).collect();
-        if slabs(edges, &mut out, &mut cuts_left) {
-            break;
-        }
+    if edges.is_empty() || edges.len() > 200_000 {
+        return Vec::new();
     }
-    out
-}
-
-type Item = (usize, Bounds2, Vec<(Vec2, Vec2)>);
-
-/// `group` cut into the chains of loops whose extents along x (or y) overlap, in order along it;
-/// one chain when nothing separates them (then `group` is left as it was, but for its order).
-fn split_groups(group: &mut Vec<Item>, along_x: bool) -> Vec<Vec<Item>> {
-    let span = |b: &Bounds2| if along_x { (b.min.x, b.max.x) } else { (b.min.y, b.max.y) };
-    group.sort_by(|a, b| span(&a.1).0.total_cmp(&span(&b.1).0));
-    let mut parts: Vec<Vec<Item>> = Vec::new();
-    let mut reach = f64::NEG_INFINITY;
-    for item in std::mem::take(group) {
-        match parts.last_mut() {
-            Some(part) if span(&item.1).0 <= reach => {
-                reach = reach.max(span(&item.1).1);
-                part.push(item);
-            }
-            _ => {
-                reach = span(&item.1).1;
-                parts.push(vec![item]);
-            }
-        }
-    }
-    if parts.len() == 1 {
-        *group = parts.pop().unwrap_or_default();
-    }
-    parts
-}
-
-/// The slab decomposition of `edges` appended to `out`; true once `out` passes its cap.
-fn slabs(mut edges: Vec<(Vec2, Vec2)>, out: &mut Vec<Vec2>, cuts_left: &mut usize) -> bool {
     let mut ys: Vec<f64> = edges.iter().flat_map(|(a, b)| [a.y, b.y]).collect();
     ys.sort_by(f64::total_cmp);
     ys.dedup_by(|a, b| (*a - *b).abs() < 1e-12);
     edges.sort_by(|a, b| a.0.y.total_cmp(&b.0.y));
+    let mut out = Vec::new();
     let mut active: Vec<(Vec2, Vec2)> = Vec::new();
     let mut next = 0usize;
+    // Slabs created by cutting at crossings, over the whole region; past this the remaining
+    // crossings are left unsplit rather than letting a hostile input run away.
+    let mut cuts_left = MAX_CROSSING_CUTS;
     let mut pending: Vec<(f64, f64)> = Vec::new();
     for w in ys.windows(2) {
         let (Some(&y0), Some(&y1)) = (w.first(), w.get(1)) else { continue };
@@ -123,7 +54,7 @@ fn slabs(mut edges: Vec<(Vec2, Vec2)>, out: &mut Vec<Vec2>, cuts_left: &mut usiz
             let ymid = (ya + yb) / 2.0;
             let mut xs: Vec<(f64, f64, f64)> = active.iter().map(|e| (x_at(e, ymid), x_at(e, ya), x_at(e, yb))).collect();
             xs.sort_by(|a, b| a.0.total_cmp(&b.0));
-            if *cuts_left > 0 {
+            if cuts_left > 0 {
                 let mut cuts: Vec<f64> = Vec::new();
                 for pair in xs.windows(2) {
                     let (Some(l), Some(r)) = (pair.first(), pair.get(1)) else { continue };
@@ -134,8 +65,8 @@ fn slabs(mut edges: Vec<(Vec2, Vec2)>, out: &mut Vec<Vec2>, cuts_left: &mut usiz
                 if !cuts.is_empty() {
                     cuts.sort_by(f64::total_cmp);
                     cuts.dedup_by(|a, b| (*a - *b).abs() < 1e-12);
-                    cuts.truncate(*cuts_left);
-                    *cuts_left -= cuts.len();
+                    cuts.truncate(cuts_left);
+                    cuts_left -= cuts.len();
                     // Push the parts top-down so the lowest is processed first.
                     let mut top = yb;
                     for &c in cuts.iter().rev() {
@@ -153,11 +84,11 @@ fn slabs(mut edges: Vec<(Vec2, Vec2)>, out: &mut Vec<Vec2>, cuts_left: &mut usiz
                 }
             }
             if out.len() > 6_000_000 {
-                return true;
+                return out;
             }
         }
     }
-    false
+    out
 }
 
 /// How many extra slab boundaries crossings may add over one region.
@@ -233,40 +164,6 @@ mod tests {
         assert!((area(&t) - 96.0).abs() < 1e-9);
     }
 
-    /// A thousand disjoint squares side by side (every slab of one would otherwise be cut at the
-    /// vertex heights of all the others) triangulate in linear output.
-    #[test]
-    fn disjoint_outlines_do_not_multiply_each_others_slabs() {
-        let n = 1_000;
-        let loops: Vec<Vec<Vec2>> = (0..n)
-            .map(|i| {
-                let (x, jitter) = (i as f64 * 3.0, i as f64 * 0.001);
-                vec![Vec2::new(x, jitter), Vec2::new(x + 2.0, jitter), Vec2::new(x + 2.0, 2.0 + jitter), Vec2::new(x, 2.0 + jitter)]
-            })
-            .collect();
-        let t = triangulate_evenodd(&loops);
-        assert!((area(&t) - 4.0 * n as f64).abs() < 1e-6);
-        // Two triangles per square: no slab was cut at another square's height.
-        assert_eq!(t.len(), 6 * n);
-    }
-
-    /// Rectangles that peel off one at a time along alternating axes (each split isolates a single loop
-    /// from a large group) still triangulate correctly, with the partition work bounded.
-    #[test]
-    fn alternating_peeling_is_bounded_and_correct() {
-        let m = 1_000;
-        let (mf, mut loops) = (m as f64, Vec::new());
-        let rect = |x0: f64, x1: f64, y0: f64, y1: f64| vec![Vec2::new(x0, y0), Vec2::new(x1, y0), Vec2::new(x1, y1), Vec2::new(x0, y1)];
-        for i in 0..m {
-            let i = i as f64;
-            loops.push(rect(2.0 * i, 2.0 * i + 1.0, 2.0 * i, 2.0 * mf));
-            loops.push(rect(2.0 * i + 2.0, 2.0 * mf + 1.0, 2.0 * i, 2.0 * i + 1.0));
-        }
-        let expected: f64 = (0..m).map(|i| (2.0 * mf - 2.0 * i as f64) + (2.0 * mf - 2.0 * i as f64 - 1.0)).sum();
-        let t = triangulate_evenodd(&loops);
-        assert!((area(&t) - expected).abs() < 1e-6 * expected, "{} vs {expected}", area(&t));
-    }
-
     #[test]
     fn triangle_area() {
         let t = triangulate_evenodd(&[vec![Vec2::new(0.0, 0.0), Vec2::new(4.0, 0.0), Vec2::new(0.0, 3.0)]]);

crates/render/src/lib.rs

@@ -78,32 +78,10 @@ fn max_scale(m: &Mat3) -> f64 {
     if s.is_finite() { s } else { 0.0 }
 }
 
-/// A drawing's layers by lower-cased name (the first of a duplicated name wins, as the table's own
-/// search does), built once per display list: a lookup per object over the layer vector multiplies
-/// the object count by the layer count.
-struct LayerIndex(Option<std::collections::HashMap<String, usize>>);
-
-impl LayerIndex {
-    fn new(d: &Drawing) -> Self {
-        let mut m = std::collections::HashMap::with_capacity(d.layers.len());
-        for (i, l) in d.layers.iter().enumerate() {
-            m.entry(l.name.to_ascii_lowercase()).or_insert(i);
-        }
-        LayerIndex(Some(m))
-    }
-
-    /// No index: lookups scan the layer vector, as `Drawing::layer` does. For a few objects (a
-    /// rubber band redrawn at every pointer move), where building an index would cost more.
-    fn linear() -> Self {
-        LayerIndex(None)
-    }
-}
-
 /// Graphics state inherited through block references.
 #[derive(Clone)]
 struct Ctx<'a> {
     d: &'a Drawing,
-    layers: &'a LayerIndex,
     xf: Mat3,
     block_color: Color,
     block_layer: Option<String>,
@@ -125,19 +103,12 @@ struct Ctx<'a> {
 }
 
 impl Ctx<'_> {
-    /// The layer called `name` (any case), as [`Drawing::layer`] finds it.
-    fn layer(&self, name: &str) -> Option<&cadcraft_doc::Layer> {
-        let Some(map) = &self.layers.0 else { return self.d.layer(name) };
-        let i = if name.bytes().any(|b| b.is_ascii_uppercase()) { map.get(&name.to_ascii_lowercase()) } else { map.get(name) };
-        i.and_then(|i| self.d.layers.get(*i))
-    }
-
     /// A layer's colour, honouring the viewport's override.
     fn layer_color(&self, name: &str) -> Option<Color> {
         if let Some((_, c)) = self.vp_colors.iter().find(|(n, _)| n.eq_ignore_ascii_case(name)) {
             return Some(*c);
         }
-        self.layer(name).map(|l| l.color)
+        self.d.layer(name).map(|l| l.color)
     }
 }
 
@@ -154,8 +125,6 @@ struct Builder<'a> {
     shared_budget: Option<&'a std::sync::atomic::AtomicUsize>,
     /// Transparency (percent) of the entity being drawn.
     transparency: u8,
-    /// The drawing's layers by name.
-    layers: &'a LayerIndex,
 }
 
 /// Upper bound on the block contents drawn per display list (each block reference, MINSERT copy
@@ -371,7 +340,6 @@ impl<'a> Builder<'a> {
             named: self.named,
             shared_budget: self.shared_budget,
             transparency: self.transparency,
-            layers: self.layers,
         }
     }
     /// Take one unit of the block-expansion budget; false once it is spent.

crates/render/src/pipeline.rs

@@ -3,9 +3,7 @@ use super::display::append;
 use super::display::{DisplayList, Kind, NO_LAYER, PlotText, VIEWPORT_CONTENT};
 use super::draw::entity;
 use super::viewports::{MAX_VIEWPORTS, viewport};
-use super::{
-    Bounds2, Builder, Color, Ctx, Drawing, Entity, EntityKind, Handle, LayerIndex, Lineweight, Mat3, Space, Vec2, paper, pen, plotstyle, point,
-};
+use super::{Bounds2, Builder, Color, Ctx, Drawing, Entity, EntityKind, Handle, Lineweight, Mat3, Space, Vec2, paper, pen, plotstyle, point};
 
 /// Build options.
 #[derive(Clone, Debug)]
@@ -82,17 +80,9 @@ pub fn build_plot(d: &Drawing, space: &Space, opts: &Options) -> DisplayList {
     build_space(d, space, opts, true)
 }
 
-pub(crate) fn top_ctx<'a>(
-    d: &'a Drawing,
-    layers: &'a LayerIndex,
-    xf: Mat3,
-    top: Handle,
-    frozen: &'a [String],
-    vp_colors: &'a [(String, Color)],
-) -> Ctx<'a> {
+pub(crate) fn top_ctx<'a>(d: &'a Drawing, xf: Mat3, top: Handle, frozen: &'a [String], vp_colors: &'a [(String, Color)]) -> Ctx<'a> {
     Ctx {
         d,
-        layers,
         xf,
         block_color: Color::Index(7),
         block_layer: None,
@@ -111,17 +101,7 @@ pub(crate) fn top_ctx<'a>(
 fn build_space(d: &Drawing, space: &Space, opts: &Options, plotting: bool) -> DisplayList {
     let opts = &with_point_view(d, space, opts);
     let styler = style_table(d, space, opts, plotting).map(|t| plotstyle::Styler::new(d, t));
-    let layers = LayerIndex::new(d);
-    let mut b = Builder {
-        list: DisplayList::default(),
-        opts,
-        plotting,
-        styles: styler.as_ref(),
-        named: None,
-        shared_budget: None,
-        transparency: 0,
-        layers: &layers,
-    };
+    let mut b = Builder { list: DisplayList::default(), opts, plotting, styles: styler.as_ref(), named: None, shared_budget: None, transparency: 0 };
     if let Space::Paper(name) = space {
         b.list.sheet = paper::sheet(d, name);
     }
@@ -144,7 +124,7 @@ fn build_space(d: &Drawing, space: &Space, opts: &Options, plotting: bool) -> Di
                 }
                 continue;
             }
-            entity(&mut b, &top_ctx(d, &layers, Mat3::IDENTITY, e.handle, &[], &[]), e);
+            entity(&mut b, &top_ctx(d, Mat3::IDENTITY, e.handle, &[], &[]), e);
         }
     }
     // A layout is drawn in paper units, so its pens become geometry now.
@@ -168,22 +148,14 @@ fn build_parallel(b: &mut Builder, d: &Drawing, store: &cadcraft_doc::EntityStor
     use rayon::prelude::*;
     let ents: Vec<&std::sync::Arc<Entity>> = store.iter().collect();
     let budget = std::sync::atomic::AtomicUsize::new(0);
-    let (opts, plotting, layers) = (b.opts, b.plotting, b.layers);
+    let (opts, plotting) = (b.opts, b.plotting);
     let parts: Vec<DisplayList> = ents
         .par_chunks(PARALLEL_CHUNK)
         .map(|chunk| {
-            let mut part = Builder {
-                list: DisplayList::default(),
-                opts,
-                plotting,
-                styles: None,
-                named: None,
-                shared_budget: Some(&budget),
-                transparency: 0,
-                layers,
-            };
+            let mut part =
+                Builder { list: DisplayList::default(), opts, plotting, styles: None, named: None, shared_budget: Some(&budget), transparency: 0 };
             for e in chunk {
-                entity(&mut part, &top_ctx(d, layers, Mat3::IDENTITY, e.handle, &[], &[]), e);
+                entity(&mut part, &top_ctx(d, Mat3::IDENTITY, e.handle, &[], &[]), e);
             }
             part.list
         })
@@ -222,10 +194,6 @@ pub(crate) fn with_point_view(d: &Drawing, space: &Space, opts: &Options) -> Opt
     o
 }
 
-/// Loose entity lists shorter than this, with no block reference (whose contents expand to many
-/// objects), look layers up by scanning rather than building an index.
-const SMALL_LIST: usize = 64;
-
 /// Build the display list for a set of loose entities (previews, rubber bands).
 pub fn build_entities<'a, I: IntoIterator<Item = &'a Entity>>(d: &Drawing, ents: I, opts: &Options) -> DisplayList {
     let ents: Vec<&Entity> = ents.into_iter().collect();
@@ -237,23 +205,9 @@ pub fn build_entities<'a, I: IntoIterator<Item = &'a Entity>>(d: &Drawing, ents:
     } else {
         opts
     };
-    let layers = if ents.len() < SMALL_LIST && !ents.iter().any(|e| matches!(e.kind, EntityKind::Insert(_))) {
-        LayerIndex::linear()
-    } else {
-        LayerIndex::new(d)
-    };
-    let mut b = Builder {
-        list: DisplayList::default(),
-        opts,
-        plotting: false,
-        styles: None,
-        named: None,
-        shared_budget: None,
-        transparency: 0,
-        layers: &layers,
-    };
+    let mut b = Builder { list: DisplayList::default(), opts, plotting: false, styles: None, named: None, shared_budget: None, transparency: 0 };
     for e in ents {
-        entity(&mut b, &top_ctx(d, &layers, Mat3::IDENTITY, e.handle, &[], &[]), e);
+        entity(&mut b, &top_ctx(d, Mat3::IDENTITY, e.handle, &[], &[]), e);
     }
     b.list
 }

crates/render/src/plotstyle.rs

@@ -59,7 +59,7 @@ impl Styler {
         let normal = || by_name(cadcraft_doc::NORMAL_STYLE);
         let p = c.plot_style.trim();
         if p.is_empty() || p.eq_ignore_ascii_case("bylayer") {
-            ctx.layer(layer_name).and_then(|l| by_name(&l.plot_style)).or_else(normal)
+            ctx.d.layer(layer_name).and_then(|l| by_name(&l.plot_style)).or_else(normal)
         } else if p.eq_ignore_ascii_case("byblock") {
             ctx.block_pstyle.or_else(normal)
         } else {

crates/render/src/props.rs

@@ -14,7 +14,7 @@ pub(crate) fn resolve_common(ctx: &Ctx, c: &cadcraft_doc::Common, plotting: bool
     let d = ctx.d;
     // Layer "0" inside a block takes the insert's layer.
     let layer_name = if c.layer == "0" { ctx.block_layer.as_deref().unwrap_or("0") } else { c.layer.as_str() };
-    let layer = ctx.layer(layer_name);
+    let layer = d.layer(layer_name);
     let visible =
         c.visible && layer.is_none_or(|l| l.visible() && (!plotting || l.plot)) && !ctx.frozen.iter().any(|f| f.eq_ignore_ascii_case(layer_name));
     let layer_color = ctx.layer_color(layer_name).unwrap_or(Color::Index(7));

crates/render/src/tests.rs

@@ -1217,20 +1217,3 @@ fn rotated_and_reversed_copies_of_a_curved_loop_fill_once() {
     });
     assert_eq!(loops_of(&h).len(), 2);
 }
-
-/// The per-list layer index finds what `Drawing::layer` finds: any case, the first of a duplicate.
-#[test]
-fn the_layer_index_agrees_with_the_layer_table() {
-    let mut d = Drawing::new_imperial();
-    let mut first = cadcraft_doc::Layer::new("Walls");
-    first.color = Color::Index(1);
-    let mut dup = cadcraft_doc::Layer::new("WALLS");
-    dup.color = Color::Index(2);
-    d.layers.extend([first, dup, cadcraft_doc::Layer::new("Doors")]);
-    for index in [LayerIndex::new(&d), LayerIndex::linear()] {
-        let top = crate::pipeline::top_ctx(&d, &index, cadcraft_geom::Mat3::IDENTITY, cadcraft_doc::Handle(1), &[], &[]);
-        for name in ["Walls", "walls", "WALLS", "doors", "0", "Missing"] {
-            assert_eq!(top.layer(name).map(|l| (&l.name, l.color)), d.layer(name).map(|l| (&l.name, l.color)), "{name}");
-        }
-    }
-}

crates/render/src/viewports.rs

@@ -5,9 +5,7 @@ use super::draw::entity;
 #[cfg(not(target_arch = "wasm32"))]
 use super::pipeline::PARALLEL_CHUNK;
 use super::pipeline::{Options, style_table, top_ctx, with_point_view};
-use super::{
-    Bounds2, Builder, Ctx, Drawing, Entity, EntityKind, Handle, LayerIndex, MAX_BLOCK_EXPANSION, Mat3, Pen, Space, Vec2, clip, paper, pen, plotstyle,
-};
+use super::{Bounds2, Builder, Ctx, Drawing, Entity, EntityKind, Handle, MAX_BLOCK_EXPANSION, Mat3, Pen, Space, Vec2, clip, paper, pen, plotstyle};
 
 /// Upper bound on viewports drawn per layout (hostile files).
 pub(crate) const MAX_VIEWPORTS: usize = 256;
@@ -23,7 +21,7 @@ pub(crate) fn viewport(b: &mut Builder, d: &Drawing, e: &Entity, vp: &cadcraft_d
     let poly = viewport_clip(d, e.handle, vp);
     // Border (on the viewport's layer; layer off hides only the border).
     if poly.is_none() {
-        entity(b, &top_ctx(d, b.layers, Mat3::IDENTITY, e.handle, &[], &[]), e);
+        entity(b, &top_ctx(d, Mat3::IDENTITY, e.handle, &[], &[]), e);
     }
     if b.opts.skip_viewport == Some(e.handle) {
         return;
@@ -69,17 +67,8 @@ pub fn viewport_content(d: &Drawing, space: &Space, handle: Handle, area: Bounds
     }
     let opts = &with_point_view(d, space, opts);
     let styler = style_table(d, space, opts, false).map(|t| plotstyle::Styler::new(d, t));
-    let layers = LayerIndex::new(d);
-    let mut b = Builder {
-        list: DisplayList::default(),
-        opts,
-        plotting: false,
-        styles: styler.as_ref(),
-        named: None,
-        shared_budget: None,
-        transparency: 0,
-        layers: &layers,
-    };
+    let mut b =
+        Builder { list: DisplayList::default(), opts, plotting: false, styles: styler.as_ref(), named: None, shared_budget: None, transparency: 0 };
     contents(&mut b, d, vp, area, &Clip::Rect(area), paper::unit_mm_of(d, handle));
     b.list
 }
@@ -108,8 +97,7 @@ fn contents(b: &mut Builder, d: &Drawing, vp: &cadcraft_doc::Viewport, area: Bou
     // PSLTSCALE on: model-space dashes are scaled so they measure the same on paper as in
     // paper space, whatever the viewport scale.
     let lt_factor = if d.header.i64("PSLTSCALE", 1) != 0 { 1.0 / s } else { 1.0 };
-    let layers = b.layers;
-    let ctx = || Ctx { lt_factor, ..top_ctx(d, layers, xf, VIEWPORT_CONTENT, &vp.frozen_layers, &vp.layer_colors) };
+    let ctx = || Ctx { lt_factor, ..top_ctx(d, xf, VIEWPORT_CONTENT, &vp.frozen_layers, &vp.layer_colors) };
     let seen = |me: &Entity| {
         if matches!(me.kind, EntityKind::Viewport(_)) {
             return false;
@@ -132,7 +120,6 @@ fn contents(b: &mut Builder, d: &Drawing, vp: &cadcraft_doc::Viewport, area: Bou
         named: None,
         shared_budget: Some(&budget),
         transparency: 0,
-        layers,
     };
     #[cfg(not(target_arch = "wasm32"))]
     let parallel = !b.plotting && b.styles.is_none() && d.model.len() >= 2 * PARALLEL_CHUNK;
@@ -156,7 +143,6 @@ fn contents(b: &mut Builder, d: &Drawing, vp: &cadcraft_doc::Viewport, area: Bou
                         named: None,
                         shared_budget: Some(&budget),
                         transparency: 0,
-                        layers,
                     };
                     let c = ctx();
                     for me in chunk.iter().filter(|me| seen(me)) {