refactor: split complex fillet, model, dimstyle and rectangle code into helpers

Pure extraction, no behaviour change: same order of side effects, same
early returns and error values. Clears cognitive-complexity findings on
tangent_circles, Model::build_budgeted, DimStyle::apply_fields and
run_rectang2 (S3776), and replaces a redundant closure with a method
reference in menus.rs (S1612).

crates/constraints/src/model.rs

@@ -191,6 +191,77 @@ impl Model {
         Self::build_budgeted(d, handles, &mut members_left)
     }
 
+    /// Add the parameters of one supported entity to `m`, and return its shape; `None` when it is
+    /// left out (too large, degenerate or unsupported).
+    fn add_params(m: &mut Model, d: &Drawing, h: Handle, kind: &EntityKind, off: usize, members_left: &mut usize) -> Option<Shape> {
+        let shape = match kind {
+            EntityKind::Line(l) => {
+                m.x0.extend([l.a.x, l.a.y, l.b.x, l.b.y]);
+                Shape::Line
+            }
+            EntityKind::Circle(c) => {
+                m.x0.extend([c.center.x, c.center.y, c.radius]);
+                Shape::Circle
+            }
+            EntityKind::Arc(a) => {
+                m.x0.extend([a.center.x, a.center.y, a.radius, a.start, a.end]);
+                Shape::Arc
+            }
+            EntityKind::LwPolyline(p) => {
+                if p.vertices.len() < 2 || off + p.vertices.len() * 2 > MAX_PARAMS {
+                    return None;
+                }
+                for v in &p.vertices {
+                    m.x0.extend([v.p.x, v.p.y]);
+                }
+                Shape::Poly { n: p.vertices.len(), closed: p.closed }
+            }
+            EntityKind::Point(p) => {
+                m.x0.extend([p.p.x, p.p.y]);
+                Shape::Point
+            }
+            EntityKind::Ellipse(el) => {
+                let ell = cadcraft_geom::Ellipse { center: el.center.xy(), major: el.major.xy(), ratio: el.ratio, start: el.start, end: el.end };
+                let arc = !ell.is_full();
+                m.x0.extend([el.center.x, el.center.y, el.major.x, el.major.y, el.ratio]);
+                if arc {
+                    m.x0.extend([el.start, el.end]);
+                }
+                Shape::Ellipse { arc }
+            }
+            EntityKind::Spline(sp) => {
+                let fit = fit_mode(sp);
+                let pts = if fit { &sp.fit } else { &sp.control };
+                let n = pts.len();
+                if !(2..=MAX_SPLINE_POINTS).contains(&n) || off + n * 2 > MAX_PARAMS || (!fit && !sp.is_valid()) {
+                    return None;
+                }
+                for p in pts {
+                    m.x0.extend([p.x, p.y]);
+                }
+                // Fit points interpolate exactly, so the curve's ends are the first and last
+                // fit point; a control polygon's ends are its first and last points when the
+                // knots are clamped.
+                let ends = !sp.closed && (fit || (clamped(sp, false) && clamped(sp, true)));
+                // Missing weights default to 1 in eval; only excess weights are unused.
+                let mut kept = sp.clone();
+                kept.weights.truncate(kept.control.len());
+                m.splines.insert(h, kept);
+                Shape::Spline { n, fit, ends }
+            }
+            EntityKind::Insert(ins) => {
+                let base = Vec2::new(ins.insert.x, ins.insert.y);
+                let pts: Vec<Vec2> = rigid_points_budgeted(d, ins, members_left).into_iter().map(|p| (p - base).rotate(-ins.rotation)).collect();
+                m.x0.extend([ins.insert.x, ins.insert.y, ins.rotation]);
+                let n = pts.len();
+                m.rigid.insert(h, pts);
+                Shape::Insert { n }
+            }
+            _ => return None,
+        };
+        Some(shape)
+    }
+
     /// Build solver parameters for supported entities while sharing rigid-member sampling work with other models.
     pub(crate) fn build_budgeted(d: &Drawing, handles: &[Handle], members_left: &mut usize) -> Model {
         let mut m = Model::default();
@@ -200,71 +271,7 @@ impl Model {
             }
             let Some(e) = d.entity(h) else { continue };
             let off = m.x0.len();
-            let shape = match &e.kind {
-                EntityKind::Line(l) => {
-                    m.x0.extend([l.a.x, l.a.y, l.b.x, l.b.y]);
-                    Shape::Line
-                }
-                EntityKind::Circle(c) => {
-                    m.x0.extend([c.center.x, c.center.y, c.radius]);
-                    Shape::Circle
-                }
-                EntityKind::Arc(a) => {
-                    m.x0.extend([a.center.x, a.center.y, a.radius, a.start, a.end]);
-                    Shape::Arc
-                }
-                EntityKind::LwPolyline(p) => {
-                    if p.vertices.len() < 2 || off + p.vertices.len() * 2 > MAX_PARAMS {
-                        continue;
-                    }
-                    for v in &p.vertices {
-                        m.x0.extend([v.p.x, v.p.y]);
-                    }
-                    Shape::Poly { n: p.vertices.len(), closed: p.closed }
-                }
-                EntityKind::Point(p) => {
-                    m.x0.extend([p.p.x, p.p.y]);
-                    Shape::Point
-                }
-                EntityKind::Ellipse(el) => {
-                    let ell = cadcraft_geom::Ellipse { center: el.center.xy(), major: el.major.xy(), ratio: el.ratio, start: el.start, end: el.end };
-                    let arc = !ell.is_full();
-                    m.x0.extend([el.center.x, el.center.y, el.major.x, el.major.y, el.ratio]);
-                    if arc {
-                        m.x0.extend([el.start, el.end]);
-                    }
-                    Shape::Ellipse { arc }
-                }
-                EntityKind::Spline(sp) => {
-                    let fit = fit_mode(sp);
-                    let pts = if fit { &sp.fit } else { &sp.control };
-                    let n = pts.len();
-                    if !(2..=MAX_SPLINE_POINTS).contains(&n) || off + n * 2 > MAX_PARAMS || (!fit && !sp.is_valid()) {
-                        continue;
-                    }
-                    for p in pts {
-                        m.x0.extend([p.x, p.y]);
-                    }
-                    // Fit points interpolate exactly, so the curve's ends are the first and last
-                    // fit point; a control polygon's ends are its first and last points when the
-                    // knots are clamped.
-                    let ends = !sp.closed && (fit || (clamped(sp, false) && clamped(sp, true)));
-                    // Missing weights default to 1 in eval; only excess weights are unused.
-                    let mut kept = sp.clone();
-                    kept.weights.truncate(kept.control.len());
-                    m.splines.insert(h, kept);
-                    Shape::Spline { n, fit, ends }
-                }
-                EntityKind::Insert(ins) => {
-                    let base = Vec2::new(ins.insert.x, ins.insert.y);
-                    let pts: Vec<Vec2> = rigid_points_budgeted(d, ins, members_left).into_iter().map(|p| (p - base).rotate(-ins.rotation)).collect();
-                    m.x0.extend([ins.insert.x, ins.insert.y, ins.rotation]);
-                    let n = pts.len();
-                    m.rigid.insert(h, pts);
-                    Shape::Insert { n }
-                }
-                _ => continue,
-            };
+            let Some(shape) = Self::add_params(&mut m, d, h, &e.kind, off, members_left) else { continue };
             if m.x0.len() > MAX_PARAMS || m.x0.get(off..).unwrap_or(&[]).iter().any(|v| !v.is_finite()) {
                 m.x0.truncate(off);
                 continue;

crates/doc/src/tables.rs

@@ -441,6 +441,49 @@ impl DimStyle {
             .or_else(|| ["name", "annotative"].into_iter().find(|f| f.eq_ignore_ascii_case(name)))
     }
 
+    /// The value `v` takes for a field whose current value is `old`: coerced to the field's type where
+    /// the text or number can be read as it.
+    fn coerce_value(old: &serde_json::Value, v: &serde_json::Value, field: &str) -> serde_json::Value {
+        use serde_json::Value;
+        match (old, v) {
+            (Value::Bool(_), Value::Number(n)) => Value::Bool(n.as_f64().is_some_and(|x| x != 0.0)),
+            (Value::Bool(_), Value::String(t)) => Value::Bool(matches!(t.to_ascii_lowercase().as_str(), "1" | "on" | "true" | "yes")),
+            (Value::Number(_), Value::String(t)) => match t.trim().parse::<f64>() {
+                Ok(x) => serde_json::json!(x),
+                // Lineweight names.
+                Err(_) if matches!(field, "dimLineweight" | "extLineweight") => match t.trim().to_ascii_lowercase().as_str() {
+                    "bylayer" => serde_json::json!(-1),
+                    "byblock" => serde_json::json!(-2),
+                    "default" => serde_json::json!(-3),
+                    _ => v.clone(),
+                },
+                Err(_) => v.clone(),
+            },
+            (Value::Number(_), Value::Bool(b)) => serde_json::json!(u8::from(*b)),
+            (Value::String(_), Value::Number(n)) => Value::String(n.to_string()),
+            (Value::Object(_), Value::Number(n)) => {
+                let c = n.as_i64().and_then(|i| i16::try_from(i).ok()).map(Color::from_aci);
+                c.and_then(|c| serde_json::to_value(c).ok()).unwrap_or_else(|| v.clone())
+            }
+            (Value::Object(_), Value::String(t)) => Color::parse(t).and_then(|c| serde_json::to_value(c).ok()).unwrap_or_else(|| v.clone()),
+            _ => v.clone(),
+        }
+    }
+
+    /// Whether `coerced` is outside the range its `field` can take.
+    fn out_of_range(field: &str, coerced: &serde_json::Value) -> bool {
+        let x = coerced.as_f64();
+        match field {
+            "textHeight" | "tolScale" => x.is_some_and(|x| x <= 0.0),
+            "scale" | "arrowSize" | "tickSize" | "fixedExtLength" => x.is_some_and(|x| x < 0.0),
+            "fit" | "angularZeroSuppression" => x.is_some_and(|x| x > 3.0),
+            "textMove" | "tolJust" | "arcSymbol" | "textFill" => x.is_some_and(|x| x > 2.0),
+            "dimLineweight" | "extLineweight" => x.is_some_and(|x| !(-3.0..=211.0).contains(&x)),
+            "jogAngle" => x.is_some_and(|x| !(5.0..=90.0).contains(&x)),
+            _ => false,
+        }
+    }
+
     /// Set fields from a JSON object of field or DIM* variable names (numbers, booleans as
     /// 0/1, colours as ACI numbers or names). Returns the names that were not recognised or
     /// had unusable values.
@@ -458,29 +501,7 @@ impl DimStyle {
                 rejected.push(k.clone());
                 continue;
             };
-            let coerced = match (&old, v) {
-                (Value::Bool(_), Value::Number(n)) => Value::Bool(n.as_f64().is_some_and(|x| x != 0.0)),
-                (Value::Bool(_), Value::String(t)) => Value::Bool(matches!(t.to_ascii_lowercase().as_str(), "1" | "on" | "true" | "yes")),
-                (Value::Number(_), Value::String(t)) => match t.trim().parse::<f64>() {
-                    Ok(x) => serde_json::json!(x),
-                    // Lineweight names.
-                    Err(_) if matches!(field, "dimLineweight" | "extLineweight") => match t.trim().to_ascii_lowercase().as_str() {
-                        "bylayer" => serde_json::json!(-1),
-                        "byblock" => serde_json::json!(-2),
-                        "default" => serde_json::json!(-3),
-                        _ => v.clone(),
-                    },
-                    Err(_) => v.clone(),
-                },
-                (Value::Number(_), Value::Bool(b)) => serde_json::json!(u8::from(*b)),
-                (Value::String(_), Value::Number(n)) => Value::String(n.to_string()),
-                (Value::Object(_), Value::Number(n)) => {
-                    let c = n.as_i64().and_then(|i| i16::try_from(i).ok()).map(Color::from_aci);
-                    c.and_then(|c| serde_json::to_value(c).ok()).unwrap_or_else(|| v.clone())
-                }
-                (Value::Object(_), Value::String(t)) => Color::parse(t).and_then(|c| serde_json::to_value(c).ok()).unwrap_or_else(|| v.clone()),
-                _ => v.clone(),
-            };
+            let coerced = Self::coerce_value(&old, v, field);
             // Integers stored in u8 fields: round floats.
             let coerced = match (&old, &coerced) {
                 // Lineweights (i16): whole hundredths of a mm or -1/-2/-3.
@@ -502,16 +523,7 @@ impl DimStyle {
                 _ => coerced,
             };
             // Sizes that can't be negative (text height and tolerance scale: not zero either).
-            let x = coerced.as_f64();
-            let out_of_range = match field {
-                "textHeight" | "tolScale" => x.is_some_and(|x| x <= 0.0),
-                "scale" | "arrowSize" | "tickSize" | "fixedExtLength" => x.is_some_and(|x| x < 0.0),
-                "fit" | "angularZeroSuppression" => x.is_some_and(|x| x > 3.0),
-                "textMove" | "tolJust" | "arcSymbol" | "textFill" => x.is_some_and(|x| x > 2.0),
-                "dimLineweight" | "extLineweight" => x.is_some_and(|x| !(-3.0..=211.0).contains(&x)),
-                "jogAngle" => x.is_some_and(|x| !(5.0..=90.0).contains(&x)),
-                _ => false,
-            };
+            let out_of_range = Self::out_of_range(field, &coerced);
             if out_of_range {
                 rejected.push(k.clone());
                 continue;

crates/engine/src/cmd/draw2.rs

@@ -1585,25 +1585,10 @@ fn rect_kind(first: Vec2, (w, h): (f64, f64), rot: f64, fillet: f64, chamfer: (f
     k
 }
 
-/// Draws a rectangle from the JSON form: `p1` is a corner, or the centre when `center` is
-/// true, and the size comes from `p2`, `dimensions` or `area` plus `length`/`breadth`.
-pub(crate) fn run_rectang2(s: &mut Session, p: &Value) -> Result<Value> {
-    let a = point_req("rectang", p, "p1")?;
-    // Centre mode: `p1` is the rectangle's centre, so the rectangle spans it evenly.
-    let centered = bool_or(p, "center", false);
-    let rot = f64_or(p, "rotation", 0.0).to_radians();
-    let ch = p
-        .get("chamfer")
-        .and_then(Value::as_array)
-        .map(|c| (c.first().and_then(Value::as_f64).unwrap_or(0.0), c.get(1).and_then(Value::as_f64).unwrap_or(0.0)))
-        .map(|(x, y)| (if x.is_finite() { x } else { 0.0 }, if y.is_finite() { y } else { 0.0 }))
-        .unwrap_or((0.0, 0.0));
-    if ch.0 < 0.0 || ch.1 < 0.0 {
-        return Err(bad("rectang", "`chamfer` distances must be zero or positive"));
-    }
-    let fillet = size_param("rectang", p, "fillet", true)?.unwrap_or(0.0);
-    let width = size_param("rectang", p, "width", true)?.unwrap_or(0.0);
-    let (w, h) = if let Some(d) = p.get("dimensions").and_then(Value::as_array) {
+/// The width and height of a rectangle from its `dimensions`, its `p2` corner, its `area` with
+/// `length` or `breadth`, or its second corner `p2`, rotated by `rot` about `a`.
+fn rect_size(p: &Value, a: Vec2, rot: f64, centered: bool) -> Result<(f64, f64)> {
+    Ok(if let Some(d) = p.get("dimensions").and_then(Value::as_array) {
         let l = d.first().and_then(Value::as_f64).filter(|v| v.is_finite()).ok_or_else(|| bad("rectang", "dimensions: [length, width]"))?;
         let wd = d.get(1).and_then(Value::as_f64).filter(|v| v.is_finite()).ok_or_else(|| bad("rectang", "dimensions: [length, width]"))?;
         let (sx, sy) = match point_param(p, "p2") {
@@ -1628,7 +1613,28 @@ pub(crate) fn run_rectang2(s: &mut Session, p: &Value) -> Result<Value> {
         let loc = (b - a).rotate(-rot);
         // In centre mode the picked point is one corner, mirrored across the centre.
         if centered { (2.0 * loc.x, 2.0 * loc.y) } else { (loc.x, loc.y) }
-    };
+    })
+}
+
+/// Draws a rectangle from the JSON form: `p1` is a corner, or the centre when `center` is
+/// true, and the size comes from `p2`, `dimensions` or `area` plus `length`/`breadth`.
+pub(crate) fn run_rectang2(s: &mut Session, p: &Value) -> Result<Value> {
+    let a = point_req("rectang", p, "p1")?;
+    // Centre mode: `p1` is the rectangle's centre, so the rectangle spans it evenly.
+    let centered = bool_or(p, "center", false);
+    let rot = f64_or(p, "rotation", 0.0).to_radians();
+    let ch = p
+        .get("chamfer")
+        .and_then(Value::as_array)
+        .map(|c| (c.first().and_then(Value::as_f64).unwrap_or(0.0), c.get(1).and_then(Value::as_f64).unwrap_or(0.0)))
+        .map(|(x, y)| (if x.is_finite() { x } else { 0.0 }, if y.is_finite() { y } else { 0.0 }))
+        .unwrap_or((0.0, 0.0));
+    if ch.0 < 0.0 || ch.1 < 0.0 {
+        return Err(bad("rectang", "`chamfer` distances must be zero or positive"));
+    }
+    let fillet = size_param("rectang", p, "fillet", true)?.unwrap_or(0.0);
+    let width = size_param("rectang", p, "width", true)?.unwrap_or(0.0);
+    let (w, h) = rect_size(p, a, rot, centered)?;
     if w.abs() < 1e-12 || h.abs() < 1e-12 || !w.is_finite() || !h.is_finite() {
         return Err(bad("rectang", "rectangle has no area"));
     }

crates/geom/src/fillet.rs

@@ -236,6 +236,46 @@ pub fn tangent_circles(c1: &TanCurve, c2: &TanCurve, r: f64, near: &[Vec2]) -> V
     if !(r.is_finite() && r >= 0.0) {
         return Vec::new();
     }
+    let Some(win) = search_window(c1, c2, near) else { return Vec::new() };
+    let size = win.width().max(win.height()).max(r).max(1e-9);
+    let win = win.expand(2.0 * r + 0.25 * size);
+    let tol = 1e-9 * size.max(1.0);
+    let (Some(r1), Some(r2)) = (c1.range(&win), c2.range(&win)) else { return Vec::new() };
+    let signs: &[(f64, f64)] = if r > 0.0 { &[(1.0, 1.0), (1.0, -1.0), (-1.0, 1.0), (-1.0, -1.0)] } else { &[(0.0, 0.0)] };
+    let mut out: Vec<CornerFit> = Vec::new();
+    let mut work = 16_000_000usize;
+    for (s1, s2) in signs {
+        let (d1, d2) = (s1 * r, s2 * r);
+        let (o1, o2) = (sample(c1, &r1, d1), sample(c2, &r2, d2));
+        let search = TanSearch { c1, r1: &r1, d1, c2, r2: &r2, d2, tol };
+        // Refine each pair before visiting the next: raw duplicate seeds in an early run must
+        // not consume all candidate slots. A separate request-wide budget bounds actual work.
+        for a in &o1 {
+            for b in &o2 {
+                if !refine_pair(&search, a, b, &mut work, &mut out) {
+                    return out;
+                }
+            }
+        }
+    }
+    out
+}
+
+/// The two curves of one tangent search for one sign choice: their ranges and offsets, and the
+/// tolerance.
+struct TanSearch<'a> {
+    c1: &'a TanCurve,
+    r1: &'a Range,
+    d1: f64,
+    c2: &'a TanCurve,
+    r2: &'a Range,
+    d2: f64,
+    tol: f64,
+}
+
+/// The window the tangent search looks in: the pick points and the extents of the curves that
+/// are not lines. `None` when it is empty or not finite.
+fn search_window(c1: &TanCurve, c2: &TanCurve, near: &[Vec2]) -> Option<Bounds2> {
     let mut win = Bounds2::from_points(near.iter().copied().filter(|p| p.is_finite()));
     for c in [c1, c2] {
         match c {
@@ -251,47 +291,34 @@ pub fn tangent_circles(c1: &TanCurve, c2: &TanCurve, r: f64, near: &[Vec2]) -> V
         }
     }
     if win.is_empty() || !(win.width().is_finite() && win.height().is_finite()) {
-        return Vec::new();
+        return None;
     }
-    let size = win.width().max(win.height()).max(r).max(1e-9);
-    let win = win.expand(2.0 * r + 0.25 * size);
-    let tol = 1e-9 * size.max(1.0);
-    let (Some(r1), Some(r2)) = (c1.range(&win), c2.range(&win)) else { return Vec::new() };
-    let signs: &[(f64, f64)] = if r > 0.0 { &[(1.0, 1.0), (1.0, -1.0), (-1.0, 1.0), (-1.0, -1.0)] } else { &[(0.0, 0.0)] };
-    let mut out: Vec<CornerFit> = Vec::new();
-    let mut work = 16_000_000usize;
-    for (s1, s2) in signs {
-        let (d1, d2) = (s1 * r, s2 * r);
-        let (o1, o2) = (sample(c1, &r1, d1), sample(c2, &r2, d2));
-        // Refine each pair before visiting the next: raw duplicate seeds in an early run must
-        // not consume all candidate slots. A separate request-wide budget bounds actual work.
-        for a in &o1 {
-            for b in &o2 {
-                let mut seeds = Vec::new();
-                crossings(a, b, &mut seeds, &mut work);
-                seeds.sort_by(|x, y| x.0.total_cmp(&y.0).then(x.1.total_cmp(&y.1)));
-                seeds.dedup_by(|x, y| (x.0 - y.0).abs() < 1e-9 && (x.1 - y.1).abs() < 1e-9);
-                for seed in seeds {
-                    // Newton refinement has a fixed iteration cap and several curve evaluations.
-                    let Some(left) = work.checked_sub(128) else { return out };
-                    work = left;
-                    let Some((t1, t2)) = refine(c1, &r1, d1, c2, &r2, d2, seed, tol) else { continue };
-                    let (Some(center), p1, p2) = (c1.offset(t1, d1), c1.point(t1), c2.point(t2)) else { continue };
-                    let near_dup = |f: &CornerFit| f.center.near(center, tol * 1e3) && f.p1.near(p1, tol * 1e3) && f.p2.near(p2, tol * 1e3);
-                    if !out.iter().any(near_dup) {
-                        out.push(CornerFit { t1, t2, p1, p2, center });
-                    }
-                    if out.len() >= MAX_SOLUTIONS {
-                        return out;
-                    }
-                }
-                if work == 0 {
-                    return out;
-                }
-            }
+    Some(win)
+}
+
+/// Refine the crossings of the samples `a` and `b` into circles, adding the distinct ones to
+/// `out`. `false` when the work budget or the solution cap ends the search.
+fn refine_pair(search: &TanSearch, a: &[(f64, Vec2)], b: &[(f64, Vec2)], work: &mut usize, out: &mut Vec<CornerFit>) -> bool {
+    let mut seeds = Vec::new();
+    crossings(a, b, &mut seeds, work);
+    seeds.sort_by(|x, y| x.0.total_cmp(&y.0).then(x.1.total_cmp(&y.1)));
+    seeds.dedup_by(|x, y| (x.0 - y.0).abs() < 1e-9 && (x.1 - y.1).abs() < 1e-9);
+    for seed in seeds {
+        // Newton refinement has a fixed iteration cap and several curve evaluations.
+        let Some(left) = work.checked_sub(128) else { return false };
+        *work = left;
+        let TanSearch { c1, r1, d1, c2, r2, d2, tol } = *search;
+        let Some((t1, t2)) = refine(c1, r1, d1, c2, r2, d2, seed, tol) else { continue };
+        let (Some(center), p1, p2) = (c1.offset(t1, d1), c1.point(t1), c2.point(t2)) else { continue };
+        let near_dup = |f: &CornerFit| f.center.near(center, tol * 1e3) && f.p1.near(p1, tol * 1e3) && f.p2.near(p2, tol * 1e3);
+        if !out.iter().any(near_dup) {
+            out.push(CornerFit { t1, t2, p1, p2, center });
+        }
+        if out.len() >= MAX_SOLUTIONS {
+            return false;
         }
     }
-    out
+    *work != 0
 }
 
 #[cfg(test)]

crates/io/src/dxf_read.rs

@@ -249,130 +249,6 @@ fn entity(kind: &str, tags: &[Tag]) -> Option<(Common, EntityKind)> {
 }
 
 /// Parse one entity while charging materialized table cells to the caller's shared import budget.
-/// An ARC, with its angles run the other way in a mirrored OCS.
-fn arc(c: &Common, t: &T) -> Arc {
-    let mut a = Arc { center: ocs(c, t.p(10)), radius: t.fd(40, 1.0).abs(), start: t.fd(50, 0.0).to_radians(), end: t.fd(51, 360.0).to_radians() };
-    if c.extrusion.z < 0.0 {
-        // Mirrored OCS: angles run the other way.
-        let (s, e) = (std::f64::consts::PI - a.end, std::f64::consts::PI - a.start);
-        a.start = cadcraft_geom::norm_angle(s);
-        a.end = cadcraft_geom::norm_angle(e);
-    }
-    a
-}
-
-fn ellipse(c: &Common, t: &T) -> Ellipse {
-    let mut e = Ellipse {
-        center: t.p(10),
-        major: t.p(11),
-        ratio: t.fd(40, 1.0).clamp(1e-9, 1.0),
-        start: t.fd(41, 0.0),
-        end: t.fd(42, std::f64::consts::TAU),
-    };
-    if c.extrusion.z < 0.0 && (cadcraft_geom::ccw_sweep(e.start, e.end) - std::f64::consts::TAU).abs() > 1e-9 {
-        // Centre and major axis are WCS, but the minor axis is extrusion × major: with (0,0,-1)
-        // it points the other way, so parameter t lands where -t does in the XY plane. A full
-        // ellipse is symmetric and stays as it is.
-        let (s, e2) = (-e.end, -e.start);
-        e.start = cadcraft_geom::norm_angle(s);
-        e.end = cadcraft_geom::norm_angle(e2);
-    }
-    e
-}
-
-/// A LWPOLYLINE, or the region CADCraft wrote as one.
-fn lwpolyline(tags: &[Tag], c: &Common, t: &T) -> Option<EntityKind> {
-    let mut verts = Vec::new();
-    let mut cur: Option<PolyVertex> = None;
-    for tg in tags {
-        match tg.code {
-            10 => {
-                if let Some(v) = cur.take() {
-                    verts.push(v);
-                }
-                cur = Some(PolyVertex { p: Vec2::new(tg.f64(), 0.0), ..Default::default() });
-            }
-            20 => {
-                if let Some(v) = cur.as_mut() {
-                    v.p.y = tg.f64();
-                }
-            }
-            40 => {
-                if let Some(v) = cur.as_mut() {
-                    v.start_width = tg.f64();
-                }
-            }
-            41 => {
-                if let Some(v) = cur.as_mut() {
-                    v.end_width = tg.f64();
-                }
-            }
-            42 => {
-                if let Some(v) = cur.as_mut() {
-                    v.bulge = tg.f64();
-                }
-            }
-            _ => {}
-        }
-    }
-    verts.extend(cur);
-    let flags = t.i(70).unwrap_or(0);
-    if c.extrusion.z < 0.0 {
-        for v in &mut verts {
-            v.p.x = -v.p.x;
-            v.bulge = -v.bulge;
-        }
-    }
-    let pl = LwPolyline { vertices: verts, closed: flags & 1 != 0, const_width: t.fd(43, 0.0), elevation: t.fd(38, 0.0), plinegen: flags & 128 != 0 };
-    // A region CADCraft wrote as polylines (`dxf_region`).
-    crate::dxf_region::from_polyline(tags, pl)
-}
-
-fn spline(t: &T) -> Spline {
-    let degree = t.i(71).unwrap_or(3).clamp(1, 10) as usize;
-    let knots = t.all_f(40);
-    let control = t.pts(10);
-    let weights = t.all_f(41);
-    let fit = t.pts(11);
-    let tangent = |c: i32| t.f(c).map(|_| t.p(c).xy());
-    let fit_opts =
-        cadcraft_geom::FitOptions { knots: Default::default(), start_tangent: tangent(12), end_tangent: tangent(13), tolerance: t.fd(44, 0.0) }
-            .sanitized();
-    let closed = t.i(70).unwrap_or(0) & 1 != 0;
-    let mut sp = Spline { degree, knots, control, weights, fit: fit.clone(), closed, fit_opts };
-    if !sp.is_valid() && fit.len() >= 2 {
-        sp = Spline::fit_with(&fit, sp.closed, fit_opts);
-    } else if !sp.is_valid() && sp.control.len() >= 2 {
-        sp = Spline::from_control(sp.control.clone(), degree);
-    } else if fit.len() >= 3 {
-        // DXF keeps the knots, not how they were spaced: recover it for later refits.
-        sp.fit_opts.knots = sp.infer_knot_param();
-    }
-    sp
-}
-
-/// An ATTDEF, whose multiline text is embedded MTEXT after its own groups.
-fn attdef(tags: &[Tag], c: &Common) -> Attrib {
-    // A multiline definition has its text as embedded MTEXT after its own groups.
-    let (own, embedded) = split_embedded(tags);
-    let multiline = multiline_attrib(embedded, c);
-    let own = T(own);
-    let mut text = text_from(&own);
-    if let Some(m) = &multiline {
-        text.value.clone_from(&m.read_as);
-    }
-    Attrib {
-        tag: own.s(2).unwrap_or_default(),
-        text,
-        invisible: own.i(70).unwrap_or(0) & 1 != 0,
-        constant: own.i(70).unwrap_or(0) & 2 != 0,
-        prompt: own.s(3).unwrap_or_default(),
-        props: Default::default(),
-        multiline,
-        modes: attrib_modes(own.0),
-    }
-}
-
 fn entity_with_table_budget(kind: &str, tags: &[Tag], table_cells_left: &mut usize) -> Option<(Common, EntityKind)> {
     // The paper-space viewport our writer adds (dxf_write::paper_view) stays implicit.
     if kind == "VIEWPORT" && crate::dxf_ext::is_paper_view(tags) {
@@ -384,16 +260,138 @@ fn entity_with_table_budget(kind: &str, tags: &[Tag], table_cells_left: &mut usi
         "LINE" => EntityKind::Line(Line { a: t.p(10), b: t.p(11) }),
         "POINT" => EntityKind::Point(Point { p: t.p(10), angle: t.fd(50, 0.0).to_radians() }),
         "CIRCLE" => EntityKind::Circle(Circle { center: ocs(&c, t.p(10)), radius: t.fd(40, 1.0).abs() }),
-        "ARC" => EntityKind::Arc(arc(&c, &t)),
-        "ELLIPSE" => EntityKind::Ellipse(ellipse(&c, &t)),
-        "LWPOLYLINE" => lwpolyline(tags, &c, &t)?,
-        "SPLINE" => EntityKind::Spline(spline(&t)),
+        "ARC" => {
+            let mut a =
+                Arc { center: ocs(&c, t.p(10)), radius: t.fd(40, 1.0).abs(), start: t.fd(50, 0.0).to_radians(), end: t.fd(51, 360.0).to_radians() };
+            if c.extrusion.z < 0.0 {
+                // Mirrored OCS: angles run the other way.
+                let (s, e) = (std::f64::consts::PI - a.end, std::f64::consts::PI - a.start);
+                a.start = cadcraft_geom::norm_angle(s);
+                a.end = cadcraft_geom::norm_angle(e);
+            }
+            EntityKind::Arc(a)
+        }
+        "ELLIPSE" => {
+            let mut e = Ellipse {
+                center: t.p(10),
+                major: t.p(11),
+                ratio: t.fd(40, 1.0).clamp(1e-9, 1.0),
+                start: t.fd(41, 0.0),
+                end: t.fd(42, std::f64::consts::TAU),
+            };
+            if c.extrusion.z < 0.0 && (cadcraft_geom::ccw_sweep(e.start, e.end) - std::f64::consts::TAU).abs() > 1e-9 {
+                // Centre and major axis are WCS, but the minor axis is extrusion × major: with (0,0,-1)
+                // it points the other way, so parameter t lands where -t does in the XY plane. A full
+                // ellipse is symmetric and stays as it is.
+                let (s, e2) = (-e.end, -e.start);
+                e.start = cadcraft_geom::norm_angle(s);
+                e.end = cadcraft_geom::norm_angle(e2);
+            }
+            EntityKind::Ellipse(e)
+        }
+        "LWPOLYLINE" => {
+            let mut verts = Vec::new();
+            let mut cur: Option<PolyVertex> = None;
+            for tg in tags {
+                match tg.code {
+                    10 => {
+                        if let Some(v) = cur.take() {
+                            verts.push(v);
+                        }
+                        cur = Some(PolyVertex { p: Vec2::new(tg.f64(), 0.0), ..Default::default() });
+                    }
+                    20 => {
+                        if let Some(v) = cur.as_mut() {
+                            v.p.y = tg.f64();
+                        }
+                    }
+                    40 => {
+                        if let Some(v) = cur.as_mut() {
+                            v.start_width = tg.f64();
+                        }
+                    }
+                    41 => {
+                        if let Some(v) = cur.as_mut() {
+                            v.end_width = tg.f64();
+                        }
+                    }
+                    42 => {
+                        if let Some(v) = cur.as_mut() {
+                            v.bulge = tg.f64();
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            verts.extend(cur);
+            let flags = t.i(70).unwrap_or(0);
+            if c.extrusion.z < 0.0 {
+                for v in &mut verts {
+                    v.p.x = -v.p.x;
+                    v.bulge = -v.bulge;
+                }
+            }
+            let pl = LwPolyline {
+                vertices: verts,
+                closed: flags & 1 != 0,
+                const_width: t.fd(43, 0.0),
+                elevation: t.fd(38, 0.0),
+                plinegen: flags & 128 != 0,
+            };
+            // A region CADCraft wrote as polylines (`dxf_region`).
+            crate::dxf_region::from_polyline(tags, pl)?
+        }
+        "SPLINE" => {
+            let degree = t.i(71).unwrap_or(3).clamp(1, 10) as usize;
+            let knots = t.all_f(40);
+            let control = t.pts(10);
+            let weights = t.all_f(41);
+            let fit = t.pts(11);
+            let tangent = |c: i32| t.f(c).map(|_| t.p(c).xy());
+            let fit_opts = cadcraft_geom::FitOptions {
+                knots: Default::default(),
+                start_tangent: tangent(12),
+                end_tangent: tangent(13),
+                tolerance: t.fd(44, 0.0),
+            }
+            .sanitized();
+            let closed = t.i(70).unwrap_or(0) & 1 != 0;
+            let mut sp = Spline { degree, knots, control, weights, fit: fit.clone(), closed, fit_opts };
+            if !sp.is_valid() && fit.len() >= 2 {
+                sp = Spline::fit_with(&fit, sp.closed, fit_opts);
+            } else if !sp.is_valid() && sp.control.len() >= 2 {
+                sp = Spline::from_control(sp.control.clone(), degree);
+            } else if fit.len() >= 3 {
+                // DXF keeps the knots, not how they were spaced: recover it for later refits.
+                sp.fit_opts.knots = sp.infer_knot_param();
+            }
+            EntityKind::Spline(sp)
+        }
         "HELIX" => EntityKind::Helix(helix(tags)),
         "RAY" => EntityKind::Ray(RayLine { base: t.p(10), dir: t.p(11) }),
         "XLINE" => EntityKind::XLine(RayLine { base: t.p(10), dir: t.p(11) }),
         "TEXT" => EntityKind::Text(text_from(&t)),
         "MTEXT" => EntityKind::MText(mtext_from(tags, &c)),
-        "ATTDEF" => EntityKind::AttDef(attdef(tags, &c)),
+        "ATTDEF" => {
+            // A multiline definition has its text as embedded MTEXT after its own groups.
+            let (own, embedded) = split_embedded(tags);
+            let multiline = multiline_attrib(embedded, &c);
+            let own = T(own);
+            let mut text = text_from(&own);
+            if let Some(m) = &multiline {
+                text.value.clone_from(&m.read_as);
+            }
+            EntityKind::AttDef(Attrib {
+                tag: own.s(2).unwrap_or_default(),
+                text,
+                invisible: own.i(70).unwrap_or(0) & 1 != 0,
+                constant: own.i(70).unwrap_or(0) & 2 != 0,
+                prompt: own.s(3).unwrap_or_default(),
+                props: Default::default(),
+                multiline,
+                modes: attrib_modes(own.0),
+            })
+        }
         "INSERT" => {
             // A mirrored block reference comes with extrusion (0,0,-1): its insertion point, scale,
             // rotation and column spacing are in that OCS, where x runs the other way. In the WCS that
@@ -1111,91 +1109,6 @@ fn entity_extras(kind: &str, tags: &[Tag], h: Handle, k: &mut EntityKind, rx: &m
 
 /// Parse a run of entity records (ENTITIES section or a block's body) into entities. Records that
 /// can't be placed are counted in `skipped`.
-/// The entity of a POLYLINE, with its mesh faces (advancing `i` past its VERTEX records). `None`
-/// for a mesh without faces.
-fn polyline_entity(recs: &[(String, Vec<Tag>)], i: &mut usize, t: &T) -> Option<(Common, EntityKind, Vec<EntityKind>)> {
-    let flags = t.i(70).unwrap_or(0);
-    let mut pts: Vec<(Vec3, f64, f64, f64)> = Vec::new();
-    // Polyface face records (VERTEX 70 bit 128 without 64): vertex indices 71–74.
-    let mut faces: Vec<[i64; 4]> = Vec::new();
-    while let Some((k2, t2)) = recs.get(*i) {
-        if k2 == "VERTEX" {
-            let tt = T(t2);
-            let vflags = tt.i(70).unwrap_or(0);
-            if vflags & 128 != 0 && vflags & 64 == 0 {
-                faces.push([71, 72, 73, 74].map(|c| tt.i(c).unwrap_or(0)));
-            } else if vflags & 16 == 0 {
-                pts.push((tt.p(10), tt.fd(42, 0.0), tt.fd(40, 0.0), tt.fd(41, 0.0)));
-            }
-            *i += 1;
-        } else {
-            if k2 == "SEQEND" {
-                *i += 1;
-            }
-            break;
-        }
-    }
-    let c = common(t);
-    let mut extra: Vec<EntityKind> = Vec::new();
-    let k = if flags & (16 | 64) != 0 {
-        // Polyface (64) and polygon (16) meshes become 3D faces; the first takes the
-        // polyline's place.
-        let verts: Vec<Vec3> = pts.iter().map(|p| p.0).collect();
-        let mut fs = if flags & 64 != 0 { polyface_faces(&verts, &faces) } else { mesh_faces(&verts, t, flags) }.into_iter().map(EntityKind::Face3d);
-        let first = fs.next()?;
-        extra.extend(fs);
-        first
-    } else if flags & 8 != 0 {
-        EntityKind::Polyline3d(Polyline3d { points: pts.iter().map(|p| p.0).collect(), closed: flags & 1 != 0 })
-    } else {
-        // A 2D polyline's vertices are in its OCS: mirrored like LWPOLYLINE.
-        let m = if c.extrusion.z < 0.0 { -1.0 } else { 1.0 };
-        EntityKind::LwPolyline(LwPolyline {
-            vertices: pts.iter().map(|p| PolyVertex { p: Vec2::new(m * p.0.x, p.0.y), bulge: m * p.1, start_width: p.2, end_width: p.3 }).collect(),
-            closed: flags & 1 != 0,
-            const_width: t.fd(40, 0.0).min(t.fd(41, 0.0)).max(0.0),
-            elevation: t.p(10).z,
-            plinegen: flags & 128 != 0,
-        })
-    };
-    Some((c, k, extra))
-}
-
-/// The ATTRIB records after an INSERT, advancing `i` past them and their SEQEND.
-fn insert_attribs(recs: &[(String, Vec<Tag>)], i: &mut usize, ins_layer: &str) -> Vec<Attrib> {
-    let mut attribs = Vec::new();
-    while let Some((k2, t2)) = recs.get(*i) {
-        if k2 == "ATTRIB" {
-            let tt = T(t2);
-            // A multiline attribute has its text as embedded MTEXT after its own groups.
-            let (own, embedded) = split_embedded(t2);
-            let multiline = multiline_attrib(embedded, &common(&tt));
-            let own = T(own);
-            let mut text = text_from(&own);
-            if let Some(m) = &multiline {
-                text.value.clone_from(&m.read_as);
-            }
-            attribs.push(Attrib {
-                tag: own.s(2).unwrap_or_default(),
-                text,
-                invisible: own.i(70).unwrap_or(0) & 1 != 0,
-                constant: false,
-                prompt: String::new(),
-                props: attrib_props(&tt, ins_layer),
-                multiline,
-                modes: attrib_modes(own.0),
-            });
-            *i += 1;
-        } else {
-            if k2 == "SEQEND" {
-                *i += 1;
-            }
-            break;
-        }
-    }
-    attribs
-}
-
 fn parse_entities(
     recs: &[(String, Vec<Tag>)],
     d: &mut Drawing,
@@ -1221,17 +1134,92 @@ fn parse_entities(
         i += 1;
         match kind.as_str() {
             "POLYLINE" => {
-                let Some((c, k, more)) = polyline_entity(recs, &mut i, &t) else {
-                    *skipped = skipped.saturating_add(1);
-                    continue;
+                let flags = t.i(70).unwrap_or(0);
+                let mut pts: Vec<(Vec3, f64, f64, f64)> = Vec::new();
+                // Polyface face records (VERTEX 70 bit 128 without 64): vertex indices 71–74.
+                let mut faces: Vec<[i64; 4]> = Vec::new();
+                while let Some((k2, t2)) = recs.get(i) {
+                    if k2 == "VERTEX" {
+                        let tt = T(t2);
+                        let vflags = tt.i(70).unwrap_or(0);
+                        if vflags & 128 != 0 && vflags & 64 == 0 {
+                            faces.push([71, 72, 73, 74].map(|c| tt.i(c).unwrap_or(0)));
+                        } else if vflags & 16 == 0 {
+                            pts.push((tt.p(10), tt.fd(42, 0.0), tt.fd(40, 0.0), tt.fd(41, 0.0)));
+                        }
+                        i += 1;
+                    } else {
+                        if k2 == "SEQEND" {
+                            i += 1;
+                        }
+                        break;
+                    }
+                }
+                let c = common(&t);
+                let k = if flags & (16 | 64) != 0 {
+                    // Polyface (64) and polygon (16) meshes become 3D faces; the first takes the
+                    // polyline's place.
+                    let verts: Vec<Vec3> = pts.iter().map(|p| p.0).collect();
+                    let mut fs = if flags & 64 != 0 { polyface_faces(&verts, &faces) } else { mesh_faces(&verts, &t, flags) }
+                        .into_iter()
+                        .map(EntityKind::Face3d);
+                    let Some(first) = fs.next() else {
+                        *skipped = skipped.saturating_add(1);
+                        continue;
+                    };
+                    extra.extend(fs);
+                    first
+                } else if flags & 8 != 0 {
+                    EntityKind::Polyline3d(Polyline3d { points: pts.iter().map(|p| p.0).collect(), closed: flags & 1 != 0 })
+                } else {
+                    // A 2D polyline's vertices are in its OCS: mirrored like LWPOLYLINE.
+                    let m = if c.extrusion.z < 0.0 { -1.0 } else { 1.0 };
+                    EntityKind::LwPolyline(LwPolyline {
+                        vertices: pts
+                            .iter()
+                            .map(|p| PolyVertex { p: Vec2::new(m * p.0.x, p.0.y), bulge: m * p.1, start_width: p.2, end_width: p.3 })
+                            .collect(),
+                        closed: flags & 1 != 0,
+                        const_width: t.fd(40, 0.0).min(t.fd(41, 0.0)).max(0.0),
+                        elevation: t.p(10).z,
+                        plinegen: flags & 128 != 0,
+                    })
                 };
-                extra = more;
                 kindent = Some((c, k));
             }
             "INSERT" => {
                 if t.i(66) == Some(1) {
+                    let mut attribs = Vec::new();
                     let ins_layer = kindent.as_ref().map(|(c, _)| c.layer.clone()).unwrap_or_default();
-                    let attribs = insert_attribs(recs, &mut i, &ins_layer);
+                    while let Some((k2, t2)) = recs.get(i) {
+                        if k2 == "ATTRIB" {
+                            let tt = T(t2);
+                            // A multiline attribute has its text as embedded MTEXT after its own groups.
+                            let (own, embedded) = split_embedded(t2);
+                            let multiline = multiline_attrib(embedded, &common(&tt));
+                            let own = T(own);
+                            let mut text = text_from(&own);
+                            if let Some(m) = &multiline {
+                                text.value.clone_from(&m.read_as);
+                            }
+                            attribs.push(Attrib {
+                                tag: own.s(2).unwrap_or_default(),
+                                text,
+                                invisible: own.i(70).unwrap_or(0) & 1 != 0,
+                                constant: false,
+                                prompt: String::new(),
+                                props: attrib_props(&tt, &ins_layer),
+                                multiline,
+                                modes: attrib_modes(own.0),
+                            });
+                            i += 1;
+                        } else {
+                            if k2 == "SEQEND" {
+                                i += 1;
+                            }
+                            break;
+                        }
+                    }
                     if let Some((_, EntityKind::Insert(ins))) = kindent.as_mut() {
                         ins.attribs = attribs;
                     }
@@ -1700,13 +1688,6 @@ pub fn read(bytes: &[u8]) -> Result<Drawing> {
     read_budgeted(bytes, 4_000_000)
 }
 
-/// A block definition read from BLOCKS: name, base point, description, entities (owner, paper
-/// flag, entity) and block flags.
-type BlockDef = (String, Vec3, String, Vec<(Option<String>, bool, Entity)>, i64);
-
-/// A layout read from OBJECTS: name, tab order, paper block handle and page setup.
-type LayoutDef = (String, u32, String, PageSetup);
-
 /// Import DXF sections while sharing one materialized-table-cell budget across blocks and entity sections.
 fn read_budgeted(bytes: &[u8], mut table_cells_left: usize) -> Result<Drawing> {
     let tags = cadcraft_dxf::parse(bytes).map_err(|e| IoError::Format(e.to_string()))?;
@@ -1719,8 +1700,8 @@ fn read_budgeted(bytes: &[u8], mut table_cells_left: usize) -> Result<Drawing> {
     // A file without $INSUNITS declares no units (#1209); only new drawings take the template's.
     d.header.set_i64("INSUNITS", 0);
     let mut rx = Rx { pstyles: plot_style_names(&secs), ..Rx::default() };
-    let mut blocks: Vec<BlockDef> = Vec::new();
-    let mut layout_objs: Vec<LayoutDef> = Vec::new();
+    let mut blocks: Vec<(String, Vec3, String, Vec<(Option<String>, bool, Entity)>, i64)> = Vec::new();
+    let mut layout_objs: Vec<(String, u32, String, PageSetup)> = Vec::new();
     let mut entities = Vec::new();
     let mut objs = Objects::default();
     // Every handle another program's file already uses is taken before anything gets a new one:
@@ -1740,109 +1721,73 @@ fn read_budgeted(bytes: &[u8], mut table_cells_left: usize) -> Result<Drawing> {
         match s.name.as_str() {
             "HEADER" => header(&s.tags, &mut d),
             "TABLES" => tables(&s.tags, &mut d, &mut rx),
-            "BLOCKS" => blocks.extend(read_blocks(&s.tags, &mut d, &mut rx, &mut table_cells_left, &mut skipped)),
+            "BLOCKS" => {
+                let recs = records(&s.tags);
+                for (k, tg) in &recs {
+                    let t = T(tg);
+                    if k == "BLOCK" && t.i(70).unwrap_or(0) & 4 != 0 {
+                        rx.xref_paths.insert(t.s(2).unwrap_or_default().to_ascii_uppercase(), t.s(1).unwrap_or_default());
+                    }
+                }
+                let mut n = 0;
+                let mut i = 0;
+                while let Some((k, tg)) = recs.get(i) {
+                    if k == "BLOCK" {
+                        let t = T(tg);
+                        let name = t.s(2).unwrap_or_default();
+                        let base = t.p(10);
+                        let description = t.s(4).unwrap_or_default();
+                        // Block flags: 4 xref, 8 overlay.
+                        let xref = t.i(70).unwrap_or(0) & 12;
+                        let mut j = i + 1;
+                        while recs.get(j).is_some_and(|(k, _)| k != "ENDBLK") {
+                            j += 1;
+                        }
+                        let body = recs.get(i + 1..j).unwrap_or(&[]);
+                        let ents = parse_entities(body, &mut d, &mut rx, &mut n, &mut table_cells_left);
+                        blocks.push((name, base, description, ents, xref));
+                        i = j + 1;
+                    } else {
+                        // A record outside any BLOCK ... ENDBLK pair.
+                        if k != "ENDBLK" {
+                            n = n.saturating_add(1);
+                        }
+                        i += 1;
+                    }
+                }
+                count_skipped(&mut skipped, "BLOCKS", n);
+            }
             // A damaged file may split its entities over several ENTITIES sections (#865).
             "ENTITIES" => {
                 let mut n = 0;
                 entities.extend(parse_entities(&records(&s.tags), &mut d, &mut rx, &mut n, &mut table_cells_left));
                 count_skipped(&mut skipped, "ENTITIES", n);
             }
-            "OBJECTS" => read_objects(&s.tags, &mut objs, &mut layout_objs),
+            "OBJECTS" => {
+                for (k, tg) in records(&s.tags) {
+                    objs.add(&k, &tg);
+                    if k == "LAYOUT" {
+                        // Fields after the AcDbLayout marker (AcDbPlotSettings also has a code 1).
+                        let start = tg.iter().position(|x| x.code == 100 && x.str() == "AcDbLayout").unwrap_or(0);
+                        let tail = tg.get(start..).unwrap_or(&[]);
+                        let t = T(tail);
+                        // LAYOUT has two 330s: owner dict and the block record; take the last.
+                        let br = tg.iter().rfind(|x| x.code == 330).map(Tag::str).unwrap_or_default();
+                        let plot = T(tg.get(..start).unwrap_or(&[]));
+                        layout_objs.push((t.s(1).unwrap_or_default(), t.i(71).unwrap_or(0) as u32, br.to_ascii_uppercase(), page_setup(&plot)));
+                    }
+                }
+            }
             _ => {}
         }
     }
     // A file CADCraft wrote names its own next handle (#495): its table records and objects
     // are numbered above it and rebuilt on save, so following $HANDSEED would drift every save.
     let own_seed = objs.xrecord_text(crate::dxf_ext::HANDSEED_KEY).and_then(|t| Handle::parse_hex(t.trim()));
-    let (paper_block_for, first_layout) = setup_layouts(&mut d, &mut layout_objs, &rx);
-    place_blocks(&mut d, blocks, &mut rx, &paper_block_for, &first_layout);
-    place_entities(&mut d, entities, &rx, &paper_block_for, &first_layout);
-    apply_sortents(&mut d, &objs.sortents, &rx.brs, &paper_block_for, &first_layout);
-    objs.apply(&mut d, &rx);
-    crate::dxf_image::resolve(&secs, &mut d);
-    crate::dxf_mline::resolve(&secs, &mut d);
-    // Keep handles unique against the header's seed.
-    let seed = d.header.str("HANDSEED", "");
-    if let Some(h) = own_seed.or_else(|| Handle::parse_hex(&seed)) {
-        d.bump_handseed(Handle(h.0.saturating_sub(1)));
-    }
-    if d.layer("0").is_none() {
-        d.layers.insert(0, Layer::default());
-    }
-    crate::dxf_raw::read(&secs, &mut d);
-    d.skipped_records = skipped;
-    Ok(d)
-}
-
-/// Read the BLOCKS section: the xref paths of external blocks, then each block's entities.
-fn read_blocks(
-    tags: &[Tag],
-    d: &mut Drawing,
-    rx: &mut Rx,
-    table_cells_left: &mut usize,
-    skipped: &mut std::collections::BTreeMap<String, usize>,
-) -> Vec<BlockDef> {
-    let recs = records(tags);
-    for (k, tg) in &recs {
-        let t = T(tg);
-        if k == "BLOCK" && t.i(70).unwrap_or(0) & 4 != 0 {
-            rx.xref_paths.insert(t.s(2).unwrap_or_default().to_ascii_uppercase(), t.s(1).unwrap_or_default());
-        }
-    }
-    let mut blocks = Vec::new();
-    let mut n = 0;
-    let mut i = 0;
-    while let Some((k, tg)) = recs.get(i) {
-        if k == "BLOCK" {
-            let t = T(tg);
-            let name = t.s(2).unwrap_or_default();
-            let base = t.p(10);
-            let description = t.s(4).unwrap_or_default();
-            // Block flags: 4 xref, 8 overlay.
-            let xref = t.i(70).unwrap_or(0) & 12;
-            let mut j = i + 1;
-            while recs.get(j).is_some_and(|(k, _)| k != "ENDBLK") {
-                j += 1;
-            }
-            let body = recs.get(i + 1..j).unwrap_or(&[]);
-            let ents = parse_entities(body, d, rx, &mut n, table_cells_left);
-            blocks.push((name, base, description, ents, xref));
-            i = j + 1;
-        } else {
-            // A record outside any BLOCK ... ENDBLK pair.
-            if k != "ENDBLK" {
-                n = n.saturating_add(1);
-            }
-            i += 1;
-        }
-    }
-    count_skipped(skipped, "BLOCKS", n);
-    blocks
-}
-
-/// Read the OBJECTS section into `objs`, and each LAYOUT into `layout_objs`.
-fn read_objects(tags: &[Tag], objs: &mut Objects, layout_objs: &mut Vec<LayoutDef>) {
-    for (k, tg) in records(tags) {
-        objs.add(&k, &tg);
-        if k == "LAYOUT" {
-            // Fields after the AcDbLayout marker (AcDbPlotSettings also has a code 1).
-            let start = tg.iter().position(|x| x.code == 100 && x.str() == "AcDbLayout").unwrap_or(0);
-            let tail = tg.get(start..).unwrap_or(&[]);
-            let t = T(tail);
-            // LAYOUT has two 330s: owner dict and the block record; take the last.
-            let br = tg.iter().rfind(|x| x.code == 330).map(Tag::str).unwrap_or_default();
-            let plot = T(tg.get(..start).unwrap_or(&[]));
-            layout_objs.push((t.s(1).unwrap_or_default(), t.i(71).unwrap_or(0) as u32, br.to_ascii_uppercase(), page_setup(&plot)));
-        }
-    }
-}
-
-/// Add the drawing's layouts, and return the layout each paper-space block belongs to, and the
-/// layout that takes paper-space entities without an owner.
-fn setup_layouts(d: &mut Drawing, layout_objs: &mut [LayoutDef], rx: &Rx) -> (HashMap<String, String>, String) {
+    // Layouts.
     let mut paper_block_for: HashMap<String, String> = HashMap::new();
     layout_objs.sort_by_key(|l| l.1);
-    for (name, order, br, page) in layout_objs.iter() {
+    for (name, order, br, page) in &layout_objs {
         if name.eq_ignore_ascii_case("Model") {
             continue;
         }
@@ -1861,12 +1806,7 @@ fn setup_layouts(d: &mut Drawing, layout_objs: &mut [LayoutDef], rx: &Rx) -> (Ha
     let first_tab = d.layouts.iter().min_by_key(|l| l.tab_order).map(|l| l.name.clone());
     d.active_layout = active.clone().filter(|a| Some(a) != first_tab.as_ref());
     let first_layout = active.or_else(|| d.layouts.first().map(|l| l.name.clone())).unwrap_or_else(|| "Layout1".into());
-    (paper_block_for, first_layout)
-}
-
-/// Place the BLOCKS entities: model and paper space blocks go to their space, the rest become
-/// block definitions.
-fn place_blocks(d: &mut Drawing, blocks: Vec<BlockDef>, rx: &mut Rx, paper_block_for: &HashMap<String, String>, first_layout: &str) {
+    // Blocks: model/paper space blocks hold entities in newer files.
     for (name, base, description, ents, xref) in blocks {
         let up = name.to_ascii_uppercase();
         if up == "*MODEL_SPACE" {
@@ -1877,7 +1817,7 @@ fn place_blocks(d: &mut Drawing, blocks: Vec<BlockDef>, rx: &mut Rx, paper_block
             continue;
         }
         if up.starts_with("*PAPER_SPACE") {
-            let lname = paper_block_for.get(&up).cloned().unwrap_or_else(|| first_layout.to_string());
+            let lname = paper_block_for.get(&up).cloned().unwrap_or_else(|| first_layout.clone());
             if let Some(l) = d.layouts.iter_mut().find(|l| l.name == lname) {
                 for (_, _, e) in ents {
                     l.entities.push(e);
@@ -1917,22 +1857,13 @@ fn place_blocks(d: &mut Drawing, blocks: Vec<BlockDef>, rx: &mut Rx, paper_block
         }
         d.blocks.insert(name, std::sync::Arc::new(b));
     }
-}
-
-/// Place the ENTITIES section: model space, or paper space when flagged (67=1).
-fn place_entities(
-    d: &mut Drawing,
-    entities: Vec<(Option<String>, bool, Entity)>,
-    rx: &Rx,
-    paper_block_for: &HashMap<String, String>,
-    first_layout: &str,
-) {
+    // ENTITIES section: model space, or paper space when flagged (67=1).
     for (owner, paper, e) in entities {
         d.ensure_layer(&e.common.layer);
         let owner_name = owner.and_then(|o| rx.brs.get(&o.trim().to_ascii_uppercase()).cloned()).map(|n| n.to_ascii_uppercase());
         let to_paper = paper || owner_name.as_deref().is_some_and(|n| n.starts_with("*PAPER_SPACE"));
         if to_paper {
-            let lname = owner_name.and_then(|n| paper_block_for.get(&n).cloned()).unwrap_or_else(|| first_layout.to_string());
+            let lname = owner_name.and_then(|n| paper_block_for.get(&n).cloned()).unwrap_or_else(|| first_layout.clone());
             if let Some(l) = d.layouts.iter_mut().find(|l| l.name == lname) {
                 l.entities.push(e);
             }
@@ -1940,6 +1871,21 @@ fn place_entities(
             d.model.push(e);
         }
     }
+    apply_sortents(&mut d, &objs.sortents, &rx.brs, &paper_block_for, &first_layout);
+    objs.apply(&mut d, &rx);
+    crate::dxf_image::resolve(&secs, &mut d);
+    crate::dxf_mline::resolve(&secs, &mut d);
+    // Keep handles unique against the header's seed.
+    let seed = d.header.str("HANDSEED", "");
+    if let Some(h) = own_seed.or_else(|| Handle::parse_hex(&seed)) {
+        d.bump_handseed(Handle(h.0.saturating_sub(1)));
+    }
+    if d.layer("0").is_none() {
+        d.layers.insert(0, Layer::default());
+    }
+    crate::dxf_raw::read(&secs, &mut d);
+    d.skipped_records = skipped;
+    Ok(d)
 }
 
 fn count_skipped(skipped: &mut std::collections::BTreeMap<String, usize>, section: &str, n: usize) {
@@ -2108,7 +2054,13 @@ impl Objects {
         Some(text)
     }
 
-    fn apply_table_styles(&self, d: &mut Drawing) {
+    fn apply(self, d: &mut Drawing, rx: &Rx) {
+        if let Some(v) = self.wipeout_frame {
+            d.header.set_i64("WIPEOUTFRAME", v);
+        }
+        if let Some(style) = self.xrecord_text(crate::dxf_ext::MLEADER_STYLE_KEY).filter(|s| !s.trim().is_empty()) {
+            d.header.set_str("CMLEADERSTYLE", &style);
+        }
         // Table styles (named by their ACAD_TABLESTYLE dictionary entries).
         for (h, tags) in &self.table_styles {
             let Some(name) = self.names.get(h).filter(|n| !n.is_empty()) else { continue };
@@ -2118,9 +2070,6 @@ impl Objects {
                 None => d.table_styles.push(st),
             }
         }
-    }
-
-    fn apply_table_style_fixes(&self, d: &mut Drawing, rx: &Rx) {
         for (h, sh) in &rx.table_style_fix {
             let name = self.names.get(sh).cloned();
             // A table from another writer has no scale of its own: its text height is its
@@ -2141,61 +2090,6 @@ impl Objects {
                 }
             });
         }
-    }
-
-    fn apply_mleader_styles(&self, d: &mut Drawing, rx: &Rx) {
-        // Multileader styles (named by their ACAD_MLEADERSTYLE dictionary entries).
-        for (h, tags) in &self.mleader_styles {
-            let Some(name) = self.names.get(h).filter(|n| !n.is_empty()) else { continue };
-            let t = T(tags);
-            let def = MLeaderStyle::default();
-            let num = |code: i32, d: f64, min: f64| t.f(code).filter(|v| v.is_finite() && *v >= min).unwrap_or(d);
-            let text_style = t.s(342).and_then(|sh| rx.styles.get(&sh.trim().to_ascii_uppercase()).cloned()).filter(|n| !n.is_empty());
-            let st = MLeaderStyle {
-                name: name.clone(),
-                arrow_size: num(44, def.arrow_size, 0.0),
-                text_height: t.f(45).filter(|v| v.is_finite() && *v > 0.0).unwrap_or(def.text_height),
-                landing_gap: num(42, def.landing_gap, 0.0),
-                dogleg: num(43, def.dogleg, 0.0),
-                text_style: text_style.unwrap_or(def.text_style),
-                annotative: t.i(296).unwrap_or(0) != 0,
-            };
-            match d.mleader_styles.iter_mut().find(|s| s.name.eq_ignore_ascii_case(name)) {
-                Some(x) => *x = st,
-                None => d.mleader_styles.push(st),
-            }
-        }
-    }
-
-    fn apply_groups(&self, d: &mut Drawing) {
-        // Groups (named by their ACAD_GROUP dictionary entries); members that exist.
-        for (h, tags) in &self.groups {
-            let Some(name) = self.names.get(h).filter(|n| !n.is_empty()) else { continue };
-            let t = T(tags);
-            let members: Vec<Handle> = tags
-                .iter()
-                .filter(|x| x.code == 340)
-                .filter_map(|x| Handle::parse_hex(&x.str()))
-                .filter(|m| d.entity(*m).is_some())
-                .take(MAX_OBJECTS)
-                .collect();
-            let g = Group { name: name.clone(), description: t.s(300).unwrap_or_default(), selectable: t.i(71).unwrap_or(1) != 0, members };
-            match d.groups.iter_mut().find(|x| x.name.eq_ignore_ascii_case(name)) {
-                Some(x) => *x = g,
-                None => d.groups.push(g),
-            }
-        }
-    }
-
-    fn apply(self, d: &mut Drawing, rx: &Rx) {
-        if let Some(v) = self.wipeout_frame {
-            d.header.set_i64("WIPEOUTFRAME", v);
-        }
-        if let Some(style) = self.xrecord_text(crate::dxf_ext::MLEADER_STYLE_KEY).filter(|s| !s.trim().is_empty()) {
-            d.header.set_str("CMLEADERSTYLE", &style);
-        }
-        self.apply_table_styles(d);
-        self.apply_table_style_fixes(d, rx);
         // Parametric constraints and parameters.
         if let Some((c, p)) = self.xrecord_text(crate::dxf_ext::CONSTRAINTS_KEY).and_then(|t| crate::dxf_ext::parse_constraints(&t)) {
             d.constraints = c;
@@ -2219,14 +2113,50 @@ impl Objects {
         if let Some(tables) = self.xrecord_text(crate::dxf_ext::PLOT_STYLES_KEY).and_then(|t| crate::dxf_ext::parse_plot_styles(&t)) {
             d.plot_style_tables = tables;
         }
-        self.apply_mleader_styles(d, rx);
+        // Multileader styles (named by their ACAD_MLEADERSTYLE dictionary entries).
+        for (h, tags) in &self.mleader_styles {
+            let Some(name) = self.names.get(h).filter(|n| !n.is_empty()) else { continue };
+            let t = T(tags);
+            let def = MLeaderStyle::default();
+            let num = |code: i32, d: f64, min: f64| t.f(code).filter(|v| v.is_finite() && *v >= min).unwrap_or(d);
+            let text_style = t.s(342).and_then(|sh| rx.styles.get(&sh.trim().to_ascii_uppercase()).cloned()).filter(|n| !n.is_empty());
+            let st = MLeaderStyle {
+                name: name.clone(),
+                arrow_size: num(44, def.arrow_size, 0.0),
+                text_height: t.f(45).filter(|v| v.is_finite() && *v > 0.0).unwrap_or(def.text_height),
+                landing_gap: num(42, def.landing_gap, 0.0),
+                dogleg: num(43, def.dogleg, 0.0),
+                text_style: text_style.unwrap_or(def.text_style),
+                annotative: t.i(296).unwrap_or(0) != 0,
+            };
+            match d.mleader_styles.iter_mut().find(|s| s.name.eq_ignore_ascii_case(name)) {
+                Some(x) => *x = st,
+                None => d.mleader_styles.push(st),
+            }
+        }
         crate::dxf_mleader::apply(d, &rx.mleader_fix, &self.names);
         for (name, view) in &self.layout_views {
             if let Some(l) = d.layouts.iter_mut().find(|l| l.name == *name) {
                 l.view = Some(*view);
             }
         }
-        self.apply_groups(d);
+        // Groups (named by their ACAD_GROUP dictionary entries); members that exist.
+        for (h, tags) in &self.groups {
+            let Some(name) = self.names.get(h).filter(|n| !n.is_empty()) else { continue };
+            let t = T(tags);
+            let members: Vec<Handle> = tags
+                .iter()
+                .filter(|x| x.code == 340)
+                .filter_map(|x| Handle::parse_hex(&x.str()))
+                .filter(|m| d.entity(*m).is_some())
+                .take(MAX_OBJECTS)
+                .collect();
+            let g = Group { name: name.clone(), description: t.s(300).unwrap_or_default(), selectable: t.i(71).unwrap_or(1) != 0, members };
+            match d.groups.iter_mut().find(|x| x.name.eq_ignore_ascii_case(name)) {
+                Some(x) => *x = g,
+                None => d.groups.push(g),
+            }
+        }
         // Standard associativity, for dimensions without CADCraft's exact links.
         for tags in &self.dimassocs {
             dimassoc(d, tags);

crates/io/src/pdf.rs

@@ -17,7 +17,7 @@ use std::fmt::Write as _;
 use cadcraft_color::Rgb;
 use cadcraft_doc::{Drawing, Handle, PageSetup, Space};
 use cadcraft_geom::{Bounds2, Vec2};
-use cadcraft_render::{DPrim, Kind, Sheet, clip, paper};
+use cadcraft_render::{Kind, Sheet, clip, paper};
 use serde_json::Value;
 
 use craft_pdf::write::backend as kr;
@@ -808,7 +808,7 @@ fn krilla_failure(e: KrillaError) -> Failure {
 /// as text instead: the glyph at font size 1 under its glyph matrix (the matrix axes are one
 /// em).
 fn marks(s: &mut Surface<'_>, p: &SheetPage, groups: &Groups, fonts: &mut fonts::Fonts) -> std::result::Result<(), Failure> {
-    let list = &p.list;
+    let (list, map) = (&p.list, &p.map);
     let texts = fonts::texts(list);
     let white = Rgb(255, 255, 255);
     let mut batch: Option<(StrokeStyle, PathBuilder)> = None;
@@ -829,126 +829,100 @@ fn marks(s: &mut Surface<'_>, p: &SheetPage, groups: &Groups, fonts: &mut fonts:
         let t = if prim.kind == Kind::Mask { 0 } else { prim.transparency.min(cadcraft_render::MAX_TRANSPARENCY) };
         let w = f64::from(prim.lw) * PT_PER_MM;
         let w = if w.is_finite() && w > 0.0 { w.min(100.0) } else { 0.0 };
-        let m = Mark { rgb, t, w };
         match prim.kind {
-            Kind::Polyline | Kind::Infinite { .. } => polyline(s, &mut batch, p, prim, raw, m),
+            Kind::Polyline | Kind::Infinite { .. } => {
+                let pts: Vec<Vec2> = match prim.kind {
+                    Kind::Infinite { ray } => match (raw.first(), raw.get(1)) {
+                        (Some(base), Some(dir)) => {
+                            let a = map.pt(*base);
+                            let dir_pt = map.pt(*base + *dir) - a;
+                            match clip::clip_infinite(a, dir_pt, ray, &p.clip_pt) {
+                                Some((x, y)) => vec![x, y],
+                                None => continue,
+                            }
+                        }
+                        _ => continue,
+                    },
+                    _ => raw.iter().map(|q| map.pt(*q)).collect(),
+                };
+                if pts.len() < 2 {
+                    continue;
+                }
+                // With a vertex out of range, keep the pieces inside the plot area, widened so
+                // a wide stroke just outside it still shows its edge.
+                let runs = if pts.iter().all(|q| coord(*q).is_some()) { vec![pts] } else { clip::clip_polyline(&pts, &p.clip_pt.expand(w + 1.0)) };
+                let style = StrokeStyle { rgb, width: w as f32, transparency: t };
+                if t > 0 || batch.as_ref().is_some_and(|(b, _)| *b != style) {
+                    flush(s, &mut batch);
+                }
+                for run in runs {
+                    let Some(pts) = run.iter().map(|q| coord(*q)).collect::<Option<Vec<_>>>() else { continue };
+                    // The writer leaves out a path without extent, so a zero-length line is
+                    // painted as the round-cap dot its stroke would make.
+                    if let Some(&(x, y)) = pts.first()
+                        && pts.iter().all(|q| *q == (x, y))
+                    {
+                        flush(s, &mut batch);
+                        let d = if w > 0.0 { w as f32 } else { HAIRLINE_DOT_PT };
+                        if let Some(path) = circle_path(x, y, d / 2.0) {
+                            fill_path(s, &path, rgb, t);
+                        }
+                        continue;
+                    }
+                    let (_, pb) = batch.get_or_insert_with(|| (style, PathBuilder::new()));
+                    for (j, (x, y)) in pts.iter().enumerate() {
+                        if j == 0 {
+                            pb.move_to(*x, *y);
+                        } else {
+                            pb.line_to(*x, *y);
+                        }
+                    }
+                }
+            }
             Kind::Tris | Kind::Mask => {
                 flush(s, &mut batch);
                 // A wipeout's mask is paper white.
-                let m = if prim.kind == Kind::Mask { Mark { rgb: white, ..m } } else { m };
-                let text_font =
-                    u32::try_from(i).ok().and_then(|i| texts.get(&i).copied()).and_then(|text| fonts.font(&text.glyph.face).map(|font| (text, font)));
-                match text_font {
-                    Some((text, font)) => glyph(s, font, text, &p.map, m.rgb, m.t),
-                    None => fill_tris(s, p, raw, m.rgb, m.t),
+                let rgb = if prim.kind == Kind::Mask { white } else { rgb };
+                if let Some(text) = u32::try_from(i).ok().and_then(|i| texts.get(&i))
+                    && let Some(font) = fonts.font(&text.glyph.face)
+                {
+                    glyph(s, font, text, map, rgb, t);
+                    continue;
+                }
+                let mapped: Vec<Vec2> = raw.iter().map(|q| map.pt(*q)).collect();
+                // With a vertex out of range, keep the parts inside the plot area.
+                let tris = if mapped.iter().all(|q| coord(*q).is_some()) { mapped } else { clip::clip_triangles(&mapped, &p.clip_pt) };
+                let mut pb = PathBuilder::new();
+                for tri in tris.as_chunks::<3>().0 {
+                    let Some(v) = tri.iter().map(|q| coord(*q)).collect::<Option<Vec<_>>>() else { continue };
+                    for (j, (x, y)) in v.iter().enumerate() {
+                        if j == 0 {
+                            pb.move_to(*x, *y);
+                        } else {
+                            pb.line_to(*x, *y);
+                        }
+                    }
+                    pb.close();
+                }
+                if let Some(path) = pb.finish() {
+                    fill_path(s, &path, rgb, t);
+                }
+            }
+            Kind::Point => {
+                let Some(q) = raw.first() else { continue };
+                flush(s, &mut batch);
+                let half = (w.max(0.5)) / 2.0;
+                let c = map.pt(*q);
+                if let Some(path) = rect_path(c - Vec2::new(half, half), c + Vec2::new(half, half)) {
+                    fill_path(s, &path, rgb, t);
                 }
             }
-            Kind::Point => point(s, &mut batch, &p.map, raw, m),
         }
     }
     flush(s, &mut batch);
     layer_changed(s, layer, None)
 }
 
-/// How a primitive is painted: colour, transparency (percent) and lineweight (points).
-#[derive(Clone, Copy)]
-struct Mark {
-    rgb: Rgb,
-    t: u8,
-    w: f64,
-}
-
-/// Stroke a polyline or infinite line, clipped to the plot area, into the open batch.
-fn polyline(s: &mut Surface<'_>, batch: &mut Option<(StrokeStyle, PathBuilder)>, p: &SheetPage, prim: &DPrim, raw: &[Vec2], m: Mark) {
-    let Some(pts) = polyline_points(prim, raw, &p.map, &p.clip_pt) else { return };
-    if pts.len() < 2 {
-        return;
-    }
-    // With a vertex out of range, keep the pieces inside the plot area, widened so
-    // a wide stroke just outside it still shows its edge.
-    let runs = if pts.iter().all(|q| coord(*q).is_some()) { vec![pts] } else { clip::clip_polyline(&pts, &p.clip_pt.expand(m.w + 1.0)) };
-    let style = StrokeStyle { rgb: m.rgb, width: m.w as f32, transparency: m.t };
-    if m.t > 0 || batch.as_ref().is_some_and(|(b, _)| *b != style) {
-        flush(s, batch);
-    }
-    for run in runs {
-        stroke_run(s, batch, &run, style, m);
-    }
-}
-
-/// The page points of a polyline, or of an infinite line clipped to the plot area; `None` when
-/// there is nothing to draw.
-fn polyline_points(prim: &DPrim, raw: &[Vec2], map: &Map, clip_pt: &Bounds2) -> Option<Vec<Vec2>> {
-    match prim.kind {
-        Kind::Infinite { ray } => {
-            let (Some(base), Some(dir)) = (raw.first(), raw.get(1)) else { return None };
-            let a = map.pt(*base);
-            let dir_pt = map.pt(*base + *dir) - a;
-            let (x, y) = clip::clip_infinite(a, dir_pt, ray, clip_pt)?;
-            Some(vec![x, y])
-        }
-        _ => Some(raw.iter().map(|q| map.pt(*q)).collect()),
-    }
-}
-
-/// Add one run of a polyline to the batch, or paint it as a dot when it has no extent.
-fn stroke_run(s: &mut Surface<'_>, batch: &mut Option<(StrokeStyle, PathBuilder)>, run: &[Vec2], style: StrokeStyle, m: Mark) {
-    let Some(pts) = run.iter().map(|q| coord(*q)).collect::<Option<Vec<_>>>() else { return };
-    // The writer leaves out a path without extent, so a zero-length line is
-    // painted as the round-cap dot its stroke would make.
-    if let Some(&(x, y)) = pts.first()
-        && pts.iter().all(|q| *q == (x, y))
-    {
-        flush(s, batch);
-        let d = if m.w > 0.0 { m.w as f32 } else { HAIRLINE_DOT_PT };
-        if let Some(path) = circle_path(x, y, d / 2.0) {
-            fill_path(s, &path, m.rgb, m.t);
-        }
-        return;
-    }
-    let (_, pb) = batch.get_or_insert_with(|| (style, PathBuilder::new()));
-    for (j, (x, y)) in pts.iter().enumerate() {
-        if j == 0 {
-            pb.move_to(*x, *y);
-        } else {
-            pb.line_to(*x, *y);
-        }
-    }
-}
-
-/// Fill a set of triangles, clipped to the plot area.
-fn fill_tris(s: &mut Surface<'_>, p: &SheetPage, raw: &[Vec2], rgb: Rgb, t: u8) {
-    let mapped: Vec<Vec2> = raw.iter().map(|q| p.map.pt(*q)).collect();
-    // With a vertex out of range, keep the parts inside the plot area.
-    let tris = if mapped.iter().all(|q| coord(*q).is_some()) { mapped } else { clip::clip_triangles(&mapped, &p.clip_pt) };
-    let mut pb = PathBuilder::new();
-    for tri in tris.as_chunks::<3>().0 {
-        let Some(v) = tri.iter().map(|q| coord(*q)).collect::<Option<Vec<_>>>() else { continue };
-        for (j, (x, y)) in v.iter().enumerate() {
-            if j == 0 {
-                pb.move_to(*x, *y);
-            } else {
-                pb.line_to(*x, *y);
-            }
-        }
-        pb.close();
-    }
-    if let Some(path) = pb.finish() {
-        fill_path(s, &path, rgb, t);
-    }
-}
-
-/// Paint a point marker: a small square at the point.
-fn point(s: &mut Surface<'_>, batch: &mut Option<(StrokeStyle, PathBuilder)>, map: &Map, raw: &[Vec2], m: Mark) {
-    let Some(q) = raw.first() else { return };
-    flush(s, batch);
-    let half = (m.w.max(0.5)) / 2.0;
-    let c = map.pt(*q);
-    if let Some(path) = rect_path(c - Vec2::new(half, half), c + Vec2::new(half, half)) {
-        fill_path(s, &path, m.rgb, m.t);
-    }
-}
-
 /// Write one glyph as text in its embedded font: font size 1, placed by the glyph's matrix (one
 /// em along each axis). A glyph whose matrix is out of range or collapses is left out.
 fn glyph(s: &mut Surface<'_>, font: kr::text::Font, t: &cadcraft_render::PlotText, map: &Map, rgb: Rgb, transparency: u8) {

crates/ui-egui/src/menus.rs

@@ -172,7 +172,7 @@ fn run_ui_command_inner(app: &mut CadApp, id: &str, params: &Value) -> Option<Re
             let pick = app.services.pick_lisp.as_ref()?;
             let dir = app.ui.last_lisp_dir.clone().unwrap_or_default();
             let Some(path) = pick(&dir) else { return Some(Ok(Value::Null)) };
-            if let Some(dir) = std::path::Path::new(&path).parent().and_then(|p| p.to_str()).filter(|d| !d.is_empty()) {
+            if let Some(dir) = std::path::Path::new(&path).parent().and_then(std::path::Path::to_str).filter(|d| !d.is_empty()) {
                 app.ui.last_lisp_dir = Some(dir.to_string());
             }
             if let Err(e) = app.session.start("appload") {