address review: correct tessellate_within doc

Polyline::tessellate sampled every arc segment (up to 4096 points each) with no total limit, and hatch boundary preparation did this for every loop, so compact curved vertices expanded into gigabytes. tessellate_within takes a point budget; once spent, remaining arcs are drawn as chords. Hatch loops share one budget.

apps/cadcraft/src/logging.rs

@@ -148,20 +148,7 @@ pub fn rotate(dir: &Path) -> std::io::Result<(PathBuf, File)> {
 /// One formatted log line: `<timestamp> <LEVEL> [<thread>] <target>: <message>\n`.
 pub fn format_line(ts: &str, level: log::Level, thread: &str, target: &str, message: &str) -> String {
     let message = message.strip_suffix('\n').unwrap_or(message);
-    // A message can carry text from a file (a code page name, a path), so it must not be able to
-    // start what looks like another record: control characters other than tab and line feed are
-    // shown escaped, and every continuation line is indented, so only this function's own
-    // timestamp is ever at the start of a line.
-    let mut safe = String::with_capacity(message.len());
-    for c in message.chars() {
-        match c {
-            '\n' => safe.push_str("\n    "),
-            '\t' => safe.push('\t'),
-            c if c.is_control() => safe.extend(c.escape_default()),
-            c => safe.push(c),
-        }
-    }
-    format!("{ts} {level:<5} [{thread}] {target}: {safe}\n")
+    format!("{ts} {level:<5} [{thread}] {target}: {message}\n")
 }
 
 /// Where formatted lines go besides standard error: kept in memory until a file is attached,
@@ -454,14 +441,8 @@ mod tests {
             format_line("2026-10-08T07:59:17.728Z", log::Level::Warn, "main", "cadcraft", "app icon: invalid PNG signature"),
             "2026-10-08T07:59:17.728Z WARN  [main] cadcraft: app icon: invalid PNG signature\n"
         );
-        // A multi-line message keeps its lines, indented so they can't pass for records; the
-        // record still ends in exactly one newline.
-        assert!(format_line("t", log::Level::Error, "w", "x", "a\nb\n").ends_with("x: a\n    b\n"));
-        // Control characters in a message (from a file) can't forge a record.
-        let forged = format_line("t", log::Level::Warn, "w", "x", "page\r\n2026-01-01T00:00:00Z ERROR [main] x: fake\u{1b}[0m");
-        assert_eq!(forged.lines().count(), 2);
-        assert!(forged.lines().skip(1).all(|l| l.starts_with("    ")));
-        assert!(!forged.contains('\r') && !forged.contains('\u{1b}'));
+        // A multi-line message keeps its lines; the record still ends in exactly one newline.
+        assert!(format_line("t", log::Level::Error, "w", "x", "a\nb\n").ends_with("x: a\nb\n"));
     }
 
     #[test]

crates/constraints/src/dof.rs

@@ -138,9 +138,7 @@ pub fn dof(d: &Drawing, handles: &[Handle]) -> Result<DofReport, SolveError> {
     let cons: Vec<&Constraint> = d.constraints.iter().take(MAX_CONSTRAINTS).collect();
     let mut prep = Prep::new(crate::model::MAX_RIGID_WORK);
     let (comps, _) = build_with(d, &cons, &SolveOptions::default(), &mut prep)?;
-    // The selection as a set, built once: a scan of the list per slot multiplied the two sizes.
-    let selected: HashSet<Handle> = handles.iter().copied().collect();
-    let want = |h: Handle| handles.is_empty() || selected.contains(&h);
+    let want = |h: Handle| handles.is_empty() || handles.contains(&h);
     let mut objects = Vec::new();
     let mut seen = HashSet::new();
     let mut total = Some(0usize);

crates/engine/src/cmd/qselect.rs

@@ -175,14 +175,8 @@ pub fn compare(prop: &Value, op: Op, value: &Value) -> bool {
             if ptxt.eq_ignore_ascii_case(vtxt.trim()) {
                 return true;
             }
-            // Colours: `red` = `1` = `Red`; `bylayer` = `ByLayer`. No colour spelling is long, so a
-            // long text (a layer name from a file) isn't parsed, copied and split per entity.
-            const MAX_COLOR_TEXT: usize = 64;
-            let (pc, vc) = (ptxt.trim(), vtxt.trim());
-            if pc.len() > MAX_COLOR_TEXT || vc.len() > MAX_COLOR_TEXT {
-                return false;
-            }
-            match (Color::parse(pc), Color::parse(vc)) {
+            // Colours: `red` = `1` = `Red`; `bylayer` = `ByLayer`.
+            match (Color::parse(&ptxt), Color::parse(vtxt.trim())) {
                 (Some(a), Some(b)) => a == b,
                 _ => false,
             }
@@ -406,26 +400,3 @@ mod tests {
         assert!(!wildcard(&"*a".repeat(500), &"b".repeat(4000)));
     }
 }
-
-#[cfg(test)]
-mod long_text_tests {
-    use super::*;
-
-    /// A long string property is compared as text only, and a colour name still equals its index.
-    #[test]
-    fn long_values_skip_colour_parsing() {
-        let long = Value::String("x".repeat(100_000));
-        assert!(compare(&long, Op::Eq, &long));
-        assert!(!compare(&long, Op::Eq, &Value::String("red".into())));
-        assert!(compare(&Value::String("red".into()), Op::Eq, &Value::String("1".into())));
-    }
-
-    /// Padding is trimmed before the length limit, so a padded colour still matches.
-    #[test]
-    fn padded_colours_still_match() {
-        let padded = |c: &str| Value::String(format!("{}{c}{}", " ".repeat(100), " ".repeat(100)));
-        assert!(compare(&padded("red"), Op::Eq, &Value::String("1".into())));
-        assert!(compare(&Value::String("red".into()), Op::Eq, &padded("1")));
-        assert!(!compare(&padded("red"), Op::Ne, &padded("1")));
-    }
-}

crates/geom/src/curve.rs

@@ -484,6 +484,9 @@ pub struct Polyline {
     pub closed: bool,
 }
 
+/// Sampled points one [`Polyline::tessellate`] call produces before arcs become chords.
+pub const MAX_TESSELLATED_POINTS: usize = 4_000_000;
+
 impl Polyline {
     pub fn from_points(pts: &[Vec2], closed: bool) -> Self {
         Polyline { vertices: pts.iter().map(|p| PolyVertex::new(*p)).collect(), closed }
@@ -516,10 +519,24 @@ impl Polyline {
         b
     }
     pub fn tessellate(&self, tol: f64) -> Vec<Vec2> {
+        let mut budget = MAX_TESSELLATED_POINTS;
+        self.tessellate_within(tol, &mut budget)
+    }
+    /// [`Polyline::tessellate`] spending about `budget` sampled points (shared by the caller
+    /// across many polylines). The budget is checked before each segment, so the last segment
+    /// started may overshoot it by that one segment's samples. Once it is spent, the remaining arcs are drawn as chords, so the
+    /// output stays proportional to the input vertices. Each arc can sample thousands of points,
+    /// so a compact polyline could otherwise expand into gigabytes (CWE-400).
+    pub fn tessellate_within(&self, tol: f64, budget: &mut usize) -> Vec<Vec2> {
         let mut out: Vec<Vec2> = Vec::new();
         for s in self.segments() {
             let mut pts = Vec::new();
-            s.tessellate(tol, &mut pts);
+            if *budget > 0 {
+                s.tessellate(tol, &mut pts);
+                *budget = budget.saturating_sub(pts.len());
+            } else {
+                pts.extend([s.start(), s.end()]);
+            }
             let skip = usize::from(out.last().is_some_and(|l| pts.first().is_some_and(|f| l.near(*f, 1e-9))));
             out.extend(pts.into_iter().skip(skip));
         }

crates/geom/src/lib.rs

@@ -20,7 +20,8 @@ mod vec;
 
 pub use bounds::Bounds2;
 pub use curve::{
-    Arc, Circle, Ellipse, Line, PolyVertex, Polyline, Segment, arc_to_bulge, bulge_to_arc, point_in_polygon, polygon_centroid, shoelace,
+    Arc, Circle, Ellipse, Line, MAX_TESSELLATED_POINTS, PolyVertex, Polyline, Segment, arc_to_bulge, bulge_to_arc, point_in_polygon,
+    polygon_centroid, shoelace,
 };
 pub use fillet::{CornerFit, TanCurve, tangent_circles};
 pub use intersect::{circle_circle, intersect_ext, intersect_segments, line_circle, line_line, line_line_infinite};

crates/geom/src/tests.rs

@@ -221,6 +221,18 @@ fn segment_offset() {
     assert!(s.offset(6.0).is_none());
 }
 
+/// A polyline of many fine arcs samples at most the point budget, then draws chords.
+#[test]
+fn polyline_tessellation_is_bounded() {
+    let vertices: Vec<PolyVertex> = (0..3000).map(|i| PolyVertex { bulge: 1.0, ..PolyVertex::new(Vec2::new(f64::from(i) * 1e6, 0.0)) }).collect();
+    let pl = Polyline { vertices, closed: false };
+    let pts = pl.tessellate(1e-9);
+    assert!(pts.len() <= MAX_TESSELLATED_POINTS + 2 * 3000 + 4096, "{}", pts.len());
+    assert!(pts.len() > 3000);
+    let mut budget = 10;
+    assert!(pl.tessellate_within(1e-9, &mut budget).len() <= 4096 + 2 * 3000);
+}
+
 #[test]
 fn arc_segments_bounded() {
     assert_eq!(arc_segments(0.0, 1.0, 0.1), 1);

crates/render/src/hatch.rs

@@ -128,7 +128,10 @@ const MAX_DEDUP_COMPARISONS: u64 = 50_000_000;
 /// within islands alternate), 1 outer keeps the outermost loops and their first islands, 2
 /// ignore keeps only the outermost loops. Nesting depth = how many other loops enclose a loop.
 pub fn fill_loops(h: &Hatch, tol: f64) -> Vec<Vec<Vec2>> {
-    let mut loops: Vec<Vec<Vec2>> = h.loops.iter().map(|l| Polyline { vertices: l.vertices.clone(), closed: true }.tessellate(tol)).collect();
+    // One point budget for all the loops: many short arcs across loops must not add up unbounded.
+    let mut budget = cadcraft_geom::MAX_TESSELLATED_POINTS;
+    let mut loops: Vec<Vec<Vec2>> =
+        h.loops.iter().map(|l| Polyline { vertices: l.vertices.clone(), closed: true }.tessellate_within(tol, &mut budget)).collect();
     dedup_polygons(&mut loops);
     let max_depth = match h.style {
         1 => 1,

crates/ui-egui/src/xrefs.rs

@@ -78,16 +78,10 @@ fn rows(app: &CadApp, ui: &egui::Ui) -> Vec<Row> {
     let xrefs: Vec<_> = d.blocks.values().filter(|b| b.xref_path.is_some() && !b.name.contains('|')).collect();
     let mut counts = vec![0usize; xrefs.len()];
     if !xrefs.is_empty() {
-        // Xref name (ASCII-upper-cased) → its row, the first of names that differ only in case, so
-        // each INSERT is one lookup instead of a scan of the xref list.
-        let mut index: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
-        for (k, b) in xrefs.iter().enumerate() {
-            index.entry(b.name.to_ascii_uppercase()).or_insert(k);
-        }
         let mut count = |store: &cadcraft_engine::doc::EntityStore| {
             for e in store.iter() {
                 if let cadcraft_engine::doc::EntityKind::Insert(i) = &e.kind
-                    && let Some(&k) = index.get(&i.block.to_ascii_uppercase())
+                    && let Some(k) = xrefs.iter().position(|b| b.name.eq_ignore_ascii_case(&i.block))
                     && let Some(c) = counts.get_mut(k)
                 {
                     *c += 1;