rscad_core/

sketch.rs

//! 2D sketch data model: points, entities (lines, circles, arcs), and
//! constraints, plus closed-profile extraction for the CSG backends.
//!
//! A sketch lives in its node's local XZ plane: sketch coordinates `(x, y)`
//! map to local `(x, 0, y)`, matching how the mesh backends evaluate 2D
//! primitives. Constraint *solving* lives in the `rscad-sketch` crate (it
//! needs `std` + ezpz); this module only stores the data and derives closed
//! profile loops from it.

use glam::DVec2;

/// Stable identifier for sketch points and entities (one shared id space).
pub type SketchId = u32;

/// Default tessellation density (segments per full circle) used when a
/// consumer has no better setting.
pub const DEFAULT_ARC_SEGMENTS: usize = 32;

/// A free point in sketch coordinates.
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SketchPoint {
    pub id: SketchId,
    pub pos: [f64; 2],
}

/// Geometry carried by a sketch entity.
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SketchEntityKind {
    /// Segment between two points.
    Line { p0: SketchId, p1: SketchId },
    /// Full circle around a center point.
    Circle { center: SketchId, radius: f64 },
    /// Circular arc from `start` to `end`, counter-clockwise around `center`
    /// (ezpz's `DatumCircularArc` convention).
    Arc {
        center: SketchId,
        start: SketchId,
        end: SketchId,
    },
}

#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SketchEntity {
    pub id: SketchId,
    pub kind: SketchEntityKind,
    /// Reference-only geometry: participates in constraint solving but is
    /// excluded from profile extraction (and therefore all CSG backends).
    #[cfg_attr(feature = "serde", serde(default))]
    pub construction: bool,
}

/// Geometric constraints between sketch points and entities.
///
/// Point-valued fields hold point ids; `line`/`a`/`b` on the line constraints
/// and `entity` on `Radius`/`Tangent` hold entity ids.
#[derive(Clone, Copy, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SketchConstraint {
    /// Two points occupy the same location.
    Coincident {
        a: SketchId,
        b: SketchId,
    },
    /// Line is parallel to the sketch X axis.
    Horizontal {
        line: SketchId,
    },
    /// Line is parallel to the sketch Y axis.
    Vertical {
        line: SketchId,
    },
    Parallel {
        a: SketchId,
        b: SketchId,
    },
    Perpendicular {
        a: SketchId,
        b: SketchId,
    },
    /// Line entity tangent to a circle or arc entity.
    Tangent {
        line: SketchId,
        entity: SketchId,
    },
    /// Point lies on a circle or arc entity's perimeter.
    PointOnCurve {
        point: SketchId,
        entity: SketchId,
    },
    /// Distance between two points.
    Distance {
        a: SketchId,
        b: SketchId,
        d: f64,
    },
    /// Radius of a circle or arc entity.
    Radius {
        entity: SketchId,
        r: f64,
    },
    /// Point locked to a position.
    Fixed {
        point: SketchId,
        x: f64,
        y: f64,
    },
}

impl SketchConstraint {
    /// Short human-readable label for constraint list UIs.
    pub fn label(&self) -> &'static str {
        match self {
            Self::Coincident { .. } => "Coincident",
            Self::Horizontal { .. } => "Horizontal",
            Self::Vertical { .. } => "Vertical",
            Self::Parallel { .. } => "Parallel",
            Self::Perpendicular { .. } => "Perpendicular",
            Self::Tangent { .. } => "Tangent",
            Self::PointOnCurve { .. } => "On Curve",
            Self::Distance { .. } => "Distance",
            Self::Radius { .. } => "Radius",
            Self::Fixed { .. } => "Fixed",
        }
    }

    /// The editable scalar value, if this constraint kind has one.
    pub fn value(&self) -> Option<f64> {
        match self {
            Self::Distance { d, .. } => Some(*d),
            Self::Radius { r, .. } => Some(*r),
            _ => None,
        }
    }

    /// Set the editable scalar value, if this constraint kind has one.
    pub fn set_value(&mut self, value: f64) {
        match self {
            Self::Distance { d, .. } => *d = value,
            Self::Radius { r, .. } => *r = value,
            _ => {}
        }
    }
}

/// A 2D sketch: points, entities, and the constraints between them.
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SketchData {
    pub points: Vec<SketchPoint>,
    pub entities: Vec<SketchEntity>,
    pub constraints: Vec<SketchConstraint>,
    /// Next unallocated [`SketchId`].
    #[cfg_attr(feature = "serde", serde(default))]
    pub next_id: SketchId,
}

impl SketchData {
    fn alloc_id(&mut self) -> SketchId {
        // Heal `next_id` after deserializing files that omitted it.
        let floor = self
            .points
            .iter()
            .map(|p| p.id)
            .chain(self.entities.iter().map(|e| e.id))
            .max()
            .map_or(0, |m| m + 1);
        self.next_id = self.next_id.max(floor);
        let id = self.next_id;
        self.next_id += 1;
        id
    }

    pub fn point(&self, id: SketchId) -> Option<&SketchPoint> {
        self.points.iter().find(|p| p.id == id)
    }

    pub fn point_mut(&mut self, id: SketchId) -> Option<&mut SketchPoint> {
        self.points.iter_mut().find(|p| p.id == id)
    }

    pub fn point_pos(&self, id: SketchId) -> Option<DVec2> {
        self.point(id).map(|p| DVec2::from_array(p.pos))
    }

    pub fn entity(&self, id: SketchId) -> Option<&SketchEntity> {
        self.entities.iter().find(|e| e.id == id)
    }

    pub fn entity_mut(&mut self, id: SketchId) -> Option<&mut SketchEntity> {
        self.entities.iter_mut().find(|e| e.id == id)
    }

    /// Mark an entity as construction (or geometry again). Returns whether
    /// the entity was found.
    pub fn set_construction(&mut self, id: SketchId, construction: bool) -> bool {
        match self.entity_mut(id) {
            Some(e) => {
                e.construction = construction;
                true
            }
            None => false,
        }
    }

    // ── Construction ───────────────────────────────────────

    pub fn add_point(&mut self, pos: DVec2) -> SketchId {
        let id = self.alloc_id();
        self.points.push(SketchPoint {
            id,
            pos: pos.to_array(),
        });
        id
    }

    /// Add a line between two existing points.
    pub fn add_line(&mut self, p0: SketchId, p1: SketchId) -> SketchId {
        let id = self.alloc_id();
        self.entities.push(SketchEntity {
            id,
            kind: SketchEntityKind::Line { p0, p1 },
            construction: false,
        });
        id
    }

    pub fn add_circle(&mut self, center: DVec2, radius: f64) -> SketchId {
        let center = self.add_point(center);
        self.add_circle_with_center(center, radius)
    }

    /// Add a circle about an existing center point.
    pub fn add_circle_with_center(&mut self, center: SketchId, radius: f64) -> SketchId {
        let id = self.alloc_id();
        self.entities.push(SketchEntity {
            id,
            kind: SketchEntityKind::Circle { center, radius },
            construction: false,
        });
        id
    }

    /// Add a counter-clockwise arc through existing points.
    pub fn add_arc(&mut self, center: SketchId, start: SketchId, end: SketchId) -> SketchId {
        let id = self.alloc_id();
        self.entities.push(SketchEntity {
            id,
            kind: SketchEntityKind::Arc { center, start, end },
            construction: false,
        });
        id
    }

    /// Add an axis-aligned rectangle as 4 points + 4 lines with
    /// horizontal/vertical constraints (the standard sketcher decomposition).
    pub fn add_rect(&mut self, corner_a: DVec2, corner_b: DVec2) -> [SketchId; 4] {
        let (min, max) = (corner_a.min(corner_b), corner_a.max(corner_b));
        let p0 = self.add_point(min);
        let p1 = self.add_point(DVec2::new(max.x, min.y));
        let p2 = self.add_point(max);
        let p3 = self.add_point(DVec2::new(min.x, max.y));
        let bottom = self.add_line(p0, p1);
        let right = self.add_line(p1, p2);
        let top = self.add_line(p2, p3);
        let left = self.add_line(p3, p0);
        self.constraints
            .push(SketchConstraint::Horizontal { line: bottom });
        self.constraints
            .push(SketchConstraint::Horizontal { line: top });
        self.constraints
            .push(SketchConstraint::Vertical { line: right });
        self.constraints
            .push(SketchConstraint::Vertical { line: left });
        [bottom, right, top, left]
    }

    // ── Deletion ───────────────────────────────────────────

    /// Delete an entity, cascading to constraints that reference it and to
    /// points no longer used by any entity.
    pub fn delete_entity(&mut self, id: SketchId) {
        self.entities.retain(|e| e.id != id);
        self.constraints.retain(|c| match c {
            SketchConstraint::Horizontal { line } | SketchConstraint::Vertical { line } => {
                *line != id
            }
            SketchConstraint::Parallel { a, b } | SketchConstraint::Perpendicular { a, b } => {
                *a != id && *b != id
            }
            SketchConstraint::Tangent { line, entity } => *line != id && *entity != id,
            SketchConstraint::PointOnCurve { entity, .. } => *entity != id,
            SketchConstraint::Radius { entity, .. } => *entity != id,
            _ => true,
        });
        self.prune_orphan_points();
    }

    pub fn delete_constraint(&mut self, index: usize) {
        if index < self.constraints.len() {
            self.constraints.remove(index);
        }
    }

    /// Delete a point, cascading to entities that use it (as endpoint or
    /// center) and to constraints that reference it — the entity cascade in
    /// turn prunes any points and constraints it orphans.
    pub fn delete_point(&mut self, id: SketchId) {
        let uses: Vec<SketchId> = self
            .entities
            .iter()
            .filter(|e| match e.kind {
                SketchEntityKind::Line { p0, p1 } => p0 == id || p1 == id,
                SketchEntityKind::Circle { center, .. } => center == id,
                SketchEntityKind::Arc { center, start, end } => {
                    center == id || start == id || end == id
                }
            })
            .map(|e| e.id)
            .collect();
        for entity in uses {
            self.delete_entity(entity);
        }
        // A lone point has no entity cascade to prune it — drop it and its
        // constraints directly.
        self.points.retain(|p| p.id != id);
        self.constraints.retain(|c| match c {
            SketchConstraint::Coincident { a, b } | SketchConstraint::Distance { a, b, .. } => {
                *a != id && *b != id
            }
            SketchConstraint::Fixed { point, .. }
            | SketchConstraint::PointOnCurve { point, .. } => *point != id,
            _ => true,
        });
    }

    /// Drop points not referenced by any entity, plus constraints that
    /// referenced the dropped points.
    fn prune_orphan_points(&mut self) {
        let used = |id: SketchId, entities: &[SketchEntity]| {
            entities.iter().any(|e| match e.kind {
                SketchEntityKind::Line { p0, p1 } => p0 == id || p1 == id,
                SketchEntityKind::Circle { center, .. } => center == id,
                SketchEntityKind::Arc { center, start, end } => {
                    center == id || start == id || end == id
                }
            })
        };
        let entities = core::mem::take(&mut self.entities);
        self.points.retain(|p| used(p.id, &entities));
        self.entities = entities;

        let alive = |id: SketchId, points: &[SketchPoint]| points.iter().any(|p| p.id == id);
        let points = core::mem::take(&mut self.points);
        self.constraints.retain(|c| match c {
            SketchConstraint::Coincident { a, b } | SketchConstraint::Distance { a, b, .. } => {
                alive(*a, &points) && alive(*b, &points)
            }
            SketchConstraint::Fixed { point, .. }
            | SketchConstraint::PointOnCurve { point, .. } => alive(*point, &points),
            _ => true,
        });
        self.points = points;
    }

    // ── Connected components ───────────────────────────────

    /// Group entities into maximally connected shapes.
    ///
    /// Two entities belong to the same component when they share a point or
    /// their points are pinned together by a [`SketchConstraint::Coincident`]
    /// — the same reachability [`profile_loops`] chains through. Value
    /// constraints between shapes (`Distance`, `Parallel`, …) do *not* merge
    /// them. Components are returned in first-appearance order; each lists
    /// its entity ids in sketch order.
    pub fn connected_components(&self) -> Vec<Vec<SketchId>> {
        // Union-find over point ids (path-halving find).
        let index: std::collections::HashMap<SketchId, usize> = self
            .points
            .iter()
            .enumerate()
            .map(|(i, p)| (p.id, i))
            .collect();
        let mut parent: Vec<usize> = (0..self.points.len()).collect();
        let union = |parent: &mut [usize], a: SketchId, b: SketchId| {
            if let (Some(&i), Some(&j)) = (index.get(&a), index.get(&b)) {
                let (ri, rj) = (uf_find(parent, i), uf_find(parent, j));
                parent[ri] = rj;
            }
        };
        for entity in &self.entities {
            let pts = entity_point_ids(entity);
            for pair in pts.windows(2) {
                union(&mut parent, pair[0], pair[1]);
            }
        }
        for constraint in &self.constraints {
            if let SketchConstraint::Coincident { a, b } = constraint {
                union(&mut parent, *a, *b);
            }
        }

        // Group entities by the root of their first resolvable point.
        let mut components: Vec<Vec<SketchId>> = Vec::new();
        let mut root_to_component: std::collections::HashMap<usize, usize> =
            std::collections::HashMap::new();
        for entity in &self.entities {
            let root = entity_point_ids(entity)
                .iter()
                .find_map(|id| index.get(id).copied())
                .map(|i| uf_find(&mut parent, i));
            match root {
                Some(root) => {
                    let slot = *root_to_component.entry(root).or_insert_with(|| {
                        components.push(Vec::new());
                        components.len() - 1
                    });
                    components[slot].push(entity.id);
                }
                // Dangling entity (no live points): its own component.
                None => components.push(vec![entity.id]),
            }
        }
        components
    }

    /// Clone a profile-extraction view restricted to `entity_ids`: entities
    /// are filtered (sketch order kept); points, constraints and `next_id`
    /// are copied verbatim — unused ones are inert for [`profile_loops`].
    /// Not a real partition; see [`Self::split_off_entities`] for that.
    pub fn entity_subset(&self, entity_ids: &[SketchId]) -> SketchData {
        SketchData {
            points: self.points.clone(),
            entities: self
                .entities
                .iter()
                .filter(|e| entity_ids.contains(&e.id))
                .copied()
                .collect(),
            constraints: self.constraints.clone(),
            next_id: self.next_id,
        }
    }

    /// Group entities into geometrically independent shapes: the
    /// [connected components](Self::connected_components), merged
    /// (transitively) whenever their closed profile loops interact — one
    /// nested inside the other (it renders as a hole) or boundaries properly
    /// crossing (the profile is their union) — so extruding one shape never
    /// tears a hole off its outer. Components without closed loops (open
    /// chains) never merge. Groups are returned in first-appearance order,
    /// each listing its entity ids. Construction entities stay in their
    /// component's group (they travel with the shape they're attached to)
    /// but contribute no loops, so they never cause a merge on their own.
    pub fn geometric_components(&self, arc_segments: usize) -> Vec<Vec<SketchId>> {
        let components = self.connected_components();
        if components.len() <= 1 {
            return components;
        }
        let loops: Vec<Vec<Vec<DVec2>>> = components
            .iter()
            .map(|ids| profile_loops(&self.entity_subset(ids), arc_segments).loops)
            .collect();

        // Union-find over component indices.
        let mut parent: Vec<usize> = (0..components.len()).collect();
        for i in 0..components.len() {
            for j in (i + 1)..components.len() {
                let interact = loops[i]
                    .iter()
                    .any(|a| loops[j].iter().any(|b| loops_interact(a, b)));
                if interact {
                    let (ri, rj) = (uf_find(&mut parent, i), uf_find(&mut parent, j));
                    parent[ri] = rj;
                }
            }
        }

        // Regroup by root, keeping first-appearance order.
        let mut groups: Vec<Vec<SketchId>> = Vec::new();
        let mut root_to_group: std::collections::HashMap<usize, usize> =
            std::collections::HashMap::new();
        for (i, ids) in components.into_iter().enumerate() {
            let root = uf_find(&mut parent, i);
            let slot = *root_to_group.entry(root).or_insert_with(|| {
                groups.push(Vec::new());
                groups.len() - 1
            });
            groups[slot].extend(ids);
        }
        groups
    }

    /// Move the given entities — with their points and every constraint fully
    /// contained in the moved set — out of this sketch into a new one.
    ///
    /// Intended for whole components from [`connected_components`], where the
    /// halves share no points. Constraints referencing both halves (e.g. a
    /// `Distance` between two shapes) are dropped: they can live in neither.
    /// `next_id` is carried over so ids stay unique across both halves.
    pub fn split_off_entities(&mut self, entity_ids: &[SketchId]) -> SketchData {
        let (taken_entities, rest_entities): (Vec<_>, Vec<_>) = core::mem::take(&mut self.entities)
            .into_iter()
            .partition(|e| entity_ids.contains(&e.id));
        self.entities = rest_entities;

        let taken_point_ids: Vec<SketchId> =
            taken_entities.iter().flat_map(entity_point_ids).collect();
        let (taken_points, rest_points): (Vec<_>, Vec<_>) = core::mem::take(&mut self.points)
            .into_iter()
            .partition(|p| taken_point_ids.contains(&p.id));
        self.points = rest_points;

        let point_taken = |id: &SketchId| taken_points.iter().any(|p| p.id == *id);
        let point_rest = |id: &SketchId| self.points.iter().any(|p| p.id == *id);
        let entity_taken = |id: &SketchId| taken_entities.iter().any(|e| e.id == *id);
        let entity_rest = |id: &SketchId| self.entities.iter().any(|e| e.id == *id);
        let mut taken_constraints = Vec::new();
        let mut rest_constraints = Vec::new();
        for c in core::mem::take(&mut self.constraints) {
            let (points, entities) = constraint_refs(&c);
            if points.iter().all(point_taken) && entities.iter().all(entity_taken) {
                taken_constraints.push(c);
            } else if points.iter().all(point_rest) && entities.iter().all(entity_rest) {
                rest_constraints.push(c);
            }
            // else: spans both halves — dropped.
        }
        self.constraints = rest_constraints;

        SketchData {
            points: taken_points,
            entities: taken_entities,
            constraints: taken_constraints,
            next_id: self.next_id,
        }
    }
}

/// The point ids an entity references (center/endpoints).
fn entity_point_ids(entity: &SketchEntity) -> Vec<SketchId> {
    match entity.kind {
        SketchEntityKind::Line { p0, p1 } => vec![p0, p1],
        SketchEntityKind::Circle { center, .. } => vec![center],
        SketchEntityKind::Arc { center, start, end } => vec![center, start, end],
    }
}

/// The `(point ids, entity ids)` a constraint references.
fn constraint_refs(c: &SketchConstraint) -> (Vec<SketchId>, Vec<SketchId>) {
    match c {
        SketchConstraint::Coincident { a, b } | SketchConstraint::Distance { a, b, .. } => {
            (vec![*a, *b], vec![])
        }
        SketchConstraint::Horizontal { line } | SketchConstraint::Vertical { line } => {
            (vec![], vec![*line])
        }
        SketchConstraint::Parallel { a, b } | SketchConstraint::Perpendicular { a, b } => {
            (vec![], vec![*a, *b])
        }
        SketchConstraint::Tangent { line, entity } => (vec![], vec![*line, *entity]),
        SketchConstraint::PointOnCurve { point, entity } => (vec![*point], vec![*entity]),
        SketchConstraint::Radius { entity, .. } => (vec![], vec![*entity]),
        SketchConstraint::Fixed { point, .. } => (vec![*point], vec![]),
    }
}

/// Path-halving union-find lookup.
fn uf_find(parent: &mut [usize], mut i: usize) -> usize {
    while parent[i] != i {
        parent[i] = parent[parent[i]];
        i = parent[i];
    }
    i
}

// ── Profile extraction ──────────────────────────────────────────────────────

/// Closed profile loops extracted from a sketch, ready for the CSG backends.
///
/// Winding is normalized: outer boundaries are counter-clockwise, holes
/// clockwise (nesting depth decides which is which, even-odd style).
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Profile {
    pub loops: Vec<Vec<DVec2>>,
    /// Number of open/branching chains that could not close into loops.
    pub open_chains: usize,
}

impl Profile {
    /// `true` if at least one closed loop was found.
    pub fn has_loops(&self) -> bool {
        !self.loops.is_empty()
    }
}

/// Extract closed loops from the sketch's lines and arcs (chained through
/// shared or `Coincident` endpoints) plus standalone circles.
///
/// `arc_segments` is the tessellation density for a full circle; arcs get a
/// proportional share of it.
pub fn profile_loops(data: &SketchData, arc_segments: usize) -> Profile {
    let arc_segments = arc_segments.max(8);

    // Union-find over point ids, seeded by Coincident constraints.
    let mut canon: Vec<(SketchId, SketchId)> = data.points.iter().map(|p| (p.id, p.id)).collect();
    fn find(canon: &mut Vec<(SketchId, SketchId)>, id: SketchId) -> SketchId {
        let Some(idx) = canon.iter().position(|(k, _)| *k == id) else {
            return id;
        };
        let parent = canon[idx].1;
        if parent == id {
            return id;
        }
        let root = find(canon, parent);
        canon[idx].1 = root;
        root
    }
    for c in &data.constraints {
        if let SketchConstraint::Coincident { a, b } = c {
            let (ra, rb) = (find(&mut canon, *a), find(&mut canon, *b));
            if ra != rb
                && let Some(idx) = canon.iter().position(|(k, _)| *k == ra)
            {
                canon[idx].1 = rb;
            }
        }
    }

    // Edges between canonical endpoints; each edge knows how to emit its
    // polyline (start vertex first, end vertex excluded).
    struct Edge {
        a: SketchId,
        b: SketchId,
        entity: SketchId,
        used: bool,
    }
    let mut edges: Vec<Edge> = Vec::new();
    let mut loops: Vec<Vec<DVec2>> = Vec::new();

    for e in &data.entities {
        if e.construction {
            continue;
        }
        match e.kind {
            SketchEntityKind::Line { p0, p1 }
            | SketchEntityKind::Arc {
                start: p0, end: p1, ..
            } => {
                let (a, b) = (find(&mut canon, p0), find(&mut canon, p1));
                if a != b {
                    edges.push(Edge {
                        a,
                        b,
                        entity: e.id,
                        used: false,
                    });
                }
            }
            SketchEntityKind::Circle { center, radius } => {
                if let Some(c) = data.point_pos(center) {
                    loops.push(tessellate_circle(c, radius, arc_segments));
                }
            }
        }
    }

    // Degree per canonical vertex over the edges still in play; only
    // degree-2 vertices chain unambiguously.
    let degree = |id: SketchId, edges: &[Edge]| {
        edges
            .iter()
            .filter(|e| !e.used && (e.a == id || e.b == id))
            .count()
    };

    // A dangling run of edges (terminating at a degree-1 vertex) can never
    // close a loop, but it inflates the degree of the vertex it attaches to,
    // which would abort the chain walk through an otherwise closed loop — a
    // rectangle with a stub line at one corner would lose the rectangle.
    // Prune dangles to a fixpoint (removing a tip can expose the next edge),
    // then count each pruned connected run as one open chain.
    loop {
        let mut pruned = false;
        for idx in 0..edges.len() {
            if !edges[idx].used
                && (degree(edges[idx].a, &edges) == 1 || degree(edges[idx].b, &edges) == 1)
            {
                edges[idx].used = true;
                pruned = true;
            }
        }
        if !pruned {
            break;
        }
    }
    let mut open_chains = {
        let mut chain_canon: Vec<(SketchId, SketchId)> = Vec::new();
        for e in edges.iter().filter(|e| e.used) {
            for v in [e.a, e.b] {
                if !chain_canon.iter().any(|(k, _)| *k == v) {
                    chain_canon.push((v, v));
                }
            }
        }
        for e in edges.iter().filter(|e| e.used) {
            let (ra, rb) = (find(&mut chain_canon, e.a), find(&mut chain_canon, e.b));
            if ra != rb
                && let Some(i) = chain_canon.iter().position(|(k, _)| *k == ra)
            {
                chain_canon[i].1 = rb;
            }
        }
        let mut roots: Vec<SketchId> = Vec::new();
        for e in edges.iter().filter(|e| e.used) {
            let r = find(&mut chain_canon, e.a);
            if !roots.contains(&r) {
                roots.push(r);
            }
        }
        roots.len()
    };

    for start_idx in 0..edges.len() {
        if edges[start_idx].used {
            continue;
        }
        // Walk from this edge's `a` endpoint until we return or dead-end.
        let start_vertex = edges[start_idx].a;
        let mut chain: Vec<(usize, bool)> = Vec::new(); // (edge idx, forward?)
        let mut cursor = start_vertex;
        let mut ok = true;
        loop {
            let Some(next_idx) = edges.iter().position(|e| {
                !e.used
                    && !chain.iter().any(|(i, _)| edges[*i].entity == e.entity)
                    && (e.a == cursor || e.b == cursor)
            }) else {
                ok = false;
                break;
            };
            let forward = edges[next_idx].a == cursor;
            let far = if forward {
                edges[next_idx].b
            } else {
                edges[next_idx].a
            };
            chain.push((next_idx, forward));
            cursor = far;
            if cursor == start_vertex {
                break;
            }
            if degree(cursor, &edges) != 2 {
                ok = false;
                break;
            }
        }

        if !ok || chain.is_empty() {
            open_chains += 1;
            // Mark the dead chain used so we don't retry it from every edge.
            for (idx, _) in &chain {
                edges[*idx].used = true;
            }
            continue;
        }

        let mut poly: Vec<DVec2> = Vec::new();
        for (idx, forward) in &chain {
            edges[*idx].used = true;
            let entity = data.entity(edges[*idx].entity).expect("BUG: edge entity");
            emit_edge(data, entity, *forward, arc_segments, &mut poly);
        }
        if poly.len() >= 3 {
            loops.push(poly);
        }
    }

    normalize_windings(&mut loops);
    Profile { loops, open_chains }
}

/// Append an edge's polyline to `poly`: start vertex included, end excluded.
fn emit_edge(
    data: &SketchData,
    entity: &SketchEntity,
    forward: bool,
    arc_segments: usize,
    poly: &mut Vec<DVec2>,
) {
    match entity.kind {
        SketchEntityKind::Line { p0, p1 } => {
            let id = if forward { p0 } else { p1 };
            if let Some(p) = data.point_pos(id) {
                poly.push(p);
            }
        }
        SketchEntityKind::Arc { center, start, end } => {
            let (Some(c), Some(s), Some(e)) = (
                data.point_pos(center),
                data.point_pos(start),
                data.point_pos(end),
            ) else {
                return;
            };
            let pts = tessellate_arc(c, s, e, arc_segments);
            if forward {
                poly.extend(pts[..pts.len() - 1].iter().copied());
            } else {
                poly.extend(pts[1..].iter().rev().copied());
            }
        }
        SketchEntityKind::Circle { .. } => {}
    }
}

/// Tessellate a CCW arc from `start` to `end` around `center`, endpoints
/// included and placed exactly (chains stay watertight even if the two
/// radii disagree slightly).
fn tessellate_arc(center: DVec2, start: DVec2, end: DVec2, arc_segments: usize) -> Vec<DVec2> {
    let r0 = (start - center).length();
    let r1 = (end - center).length();
    let a0 = (start.y - center.y).atan2(start.x - center.x);
    let tau = core::f64::consts::TAU;
    let sweep = arc_sweep_angle(center, start, end);

    let n = ((arc_segments as f64 * sweep / tau).ceil() as usize).max(2);
    (0..=n)
        .map(|i| {
            let t = i as f64 / n as f64;
            match i {
                0 => start,
                _ if i == n => end,
                _ => {
                    let a = a0 + sweep * t;
                    let r = r0 + (r1 - r0) * t;
                    center + DVec2::new(a.cos(), a.sin()) * r
                }
            }
        })
        .collect()
}

fn tessellate_circle(center: DVec2, radius: f64, segments: usize) -> Vec<DVec2> {
    let n = segments.max(8);
    (0..n)
        .map(|i| {
            let a = core::f64::consts::TAU * i as f64 / n as f64;
            center + DVec2::new(a.cos(), a.sin()) * radius
        })
        .collect()
}

/// Signed loop area (positive = counter-clockwise = outer boundary after
/// [`profile_loops`] normalization).
pub fn signed_area(poly: &[DVec2]) -> f64 {
    signed_area_2x(poly) / 2.0
}

/// Twice the signed area (positive = counter-clockwise).
fn signed_area_2x(poly: &[DVec2]) -> f64 {
    poly.iter()
        .zip(poly.iter().cycle().skip(1))
        .map(|(a, b)| a.x * b.y - b.x * a.y)
        .take(poly.len())
        .sum()
}

fn point_in_polygon(p: DVec2, poly: &[DVec2]) -> bool {
    let mut inside = false;
    let n = poly.len();
    for i in 0..n {
        let (a, b) = (poly[i], poly[(i + 1) % n]);
        if (a.y > p.y) != (b.y > p.y) {
            let x = a.x + (p.y - a.y) / (b.y - a.y) * (b.x - a.x);
            if p.x < x {
                inside = !inside;
            }
        }
    }
    inside
}

/// `(min, max)` corners of a polyline's axis-aligned bounding box.
fn loop_aabb(poly: &[DVec2]) -> (DVec2, DVec2) {
    poly.iter().fold(
        (DVec2::splat(f64::INFINITY), DVec2::splat(f64::NEG_INFINITY)),
        |(min, max), p| (min.min(*p), max.max(*p)),
    )
}

/// Orientation sign of `c` relative to the directed segment `a -> b`
/// (positive = left of it).
fn orient(a: DVec2, b: DVec2, c: DVec2) -> f64 {
    (b - a).perp_dot(c - a)
}

/// Strict proper crossing: the segments' interiors intersect at a single
/// point. Any zero orientation — shared endpoints, T-junctions, tangency,
/// collinear overlap — is *not* a crossing, so touching boundaries keep the
/// containment treatment.
fn segments_properly_intersect(a0: DVec2, a1: DVec2, b0: DVec2, b1: DVec2) -> bool {
    orient(b0, b1, a0) * orient(b0, b1, a1) < 0.0 && orient(a0, a1, b0) * orient(a0, a1, b1) < 0.0
}

/// Whether two closed loops' boundaries properly cross anywhere.
fn loops_cross(a: &[DVec2], b: &[DVec2]) -> bool {
    let ((amin, amax), (bmin, bmax)) = (loop_aabb(a), loop_aabb(b));
    if amin.x > bmax.x || bmin.x > amax.x || amin.y > bmax.y || bmin.y > amax.y {
        return false;
    }
    (0..a.len()).any(|i| {
        let (a0, a1) = (a[i], a[(i + 1) % a.len()]);
        (0..b.len()).any(|j| segments_properly_intersect(a0, a1, b[j], b[(j + 1) % b.len()]))
    })
}

/// Whether two loops belong to one profile region: boundaries properly cross,
/// or one is nested in the other. Containment is all-or-nothing when the
/// boundaries don't cross, so the first vertex decides (an on-boundary first
/// vertex inherits the half-open [`point_in_polygon`] answer).
fn loops_interact(a: &[DVec2], b: &[DVec2]) -> bool {
    loops_cross(a, b) || point_in_polygon(a[0], b) || point_in_polygon(b[0], a)
}

/// Orient loops by nesting depth: even depth (outers) CCW, odd (holes) CW.
///
/// Depth counts only a loop's *non-crossing* containers, so a loop's role is
/// decided by the loops that fully enclose it:
/// - Two crossing top-level loops both stay CCW — positive-fill backends
///   render their union.
/// - Crossing loops nested at the same odd depth become one merged cutout.
/// - A loop nested in an outer while crossing that outer's hole stays a
///   cutout (the nested role wins; overlapping cutouts merge).
///
/// Arrangements without crossings behave as plain even-odd nesting.
fn normalize_windings(loops: &mut [Vec<DVec2>]) {
    let n = loops.len();
    let mut crosses = vec![false; n * n];
    for i in 0..n {
        for j in (i + 1)..n {
            if loops_cross(&loops[i], &loops[j]) {
                crosses[i * n + j] = true;
                crosses[j * n + i] = true;
            }
        }
    }
    let representatives: Vec<DVec2> = loops.iter().map(|l| l[0]).collect();
    let depths: Vec<usize> = representatives
        .iter()
        .enumerate()
        .map(|(i, &p)| {
            loops
                .iter()
                .enumerate()
                .filter(|(j, other)| *j != i && !crosses[i * n + j] && point_in_polygon(p, other))
                .count()
        })
        .collect();
    for (poly, depth) in loops.iter_mut().zip(depths) {
        let ccw = signed_area_2x(poly) > 0.0;
        let want_ccw = depth % 2 == 0;
        if ccw != want_ccw {
            poly.reverse();
        }
    }
}

// ── Splitting ───────────────────────────────────────────────────────────────

/// An intersection between two entities, as found by
/// [`SketchData::nearest_intersection`].
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SketchIntersection {
    pub a: SketchId,
    pub b: SketchId,
    pub pos: DVec2,
}

/// Proper-crossing point of two segments. Same policy as
/// [`segments_properly_intersect`]: interiors only — shared endpoints,
/// T-junctions, tangency and collinear overlap yield `None`.
fn segment_segment_intersection(a0: DVec2, a1: DVec2, b0: DVec2, b1: DVec2) -> Option<DVec2> {
    if !segments_properly_intersect(a0, a1, b0, b1) {
        return None;
    }
    // Proper crossing ⇒ not parallel ⇒ the denominator is non-zero.
    let t = (b0 - a0).perp_dot(b1 - b0) / (a1 - a0).perp_dot(b1 - b0);
    Some(a0 + (a1 - a0) * t)
}

/// Points where a segment's interior crosses a circle: quadratic roots with
/// `t` strictly inside `(0, 1)`, ordered by `t`. A grazing (tangent) contact
/// yields nothing, mirroring the proper-crossing policy for segments.
fn segment_circle_intersections(a0: DVec2, a1: DVec2, center: DVec2, radius: f64) -> Vec<DVec2> {
    let d = a1 - a0;
    let f = a0 - center;
    let a = d.length_squared();
    if a == 0.0 {
        return Vec::new();
    }
    let b = 2.0 * f.dot(d);
    let c = f.length_squared() - radius * radius;
    // World-space root separation is √disc / √a: require it to clear a
    // radius-scaled epsilon so a graze never counts as a crossing.
    let eps = 1e-9 * radius.max(1.0);
    let disc = b * b - 4.0 * a * c;
    if disc <= a * eps * eps {
        return Vec::new();
    }
    let sqrt_disc = disc.sqrt();
    [(-b - sqrt_disc) / (2.0 * a), (-b + sqrt_disc) / (2.0 * a)]
        .into_iter()
        .filter(|t| *t > 0.0 && *t < 1.0)
        .map(|t| a0 + d * t)
        .collect()
}

/// CCW sweep angle from `start` to `end` around `center`, in `(0, τ]`.
fn arc_sweep_angle(center: DVec2, start: DVec2, end: DVec2) -> f64 {
    let a0 = (start.y - center.y).atan2(start.x - center.x);
    let a1 = (end.y - center.y).atan2(end.x - center.x);
    let tau = core::f64::consts::TAU;
    let sweep = ((a1 - a0).rem_euclid(tau) + tau) % tau;
    if sweep == 0.0 { tau } else { sweep }
}

/// CCW angle of `p` past an arc's start, in `[0, τ)`.
fn arc_angle_offset(center: DVec2, start: DVec2, p: DVec2) -> f64 {
    let a0 = (start.y - center.y).atan2(start.x - center.x);
    let ap = (p.y - center.y).atan2(p.x - center.x);
    (ap - a0).rem_euclid(core::f64::consts::TAU)
}

/// Whether `p`'s angle around `center` lies strictly inside the CCW sweep
/// from `start` to `end` (hits at the arc's endpoints are excluded).
fn arc_contains_angle(center: DVec2, start: DVec2, end: DVec2, p: DVec2) -> bool {
    let off = arc_angle_offset(center, start, p);
    off > 0.0 && off < arc_sweep_angle(center, start, end)
}

/// Points where a segment's interior crosses an arc: circle roots at the
/// arc's mean radius, filtered to the CCW span, each re-projected onto the
/// radius-interpolated ring [`tessellate_arc`] draws.
fn segment_arc_intersections(
    a0: DVec2,
    a1: DVec2,
    center: DVec2,
    start: DVec2,
    end: DVec2,
) -> Vec<DVec2> {
    let r0 = (start - center).length();
    let r1 = (end - center).length();
    let sweep = arc_sweep_angle(center, start, end);
    segment_circle_intersections(a0, a1, center, (r0 + r1) * 0.5)
        .into_iter()
        .filter(|p| arc_contains_angle(center, start, end, *p))
        .map(|p| {
            let off = arc_angle_offset(center, start, p);
            let a = (start.y - center.y).atan2(start.x - center.x) + off;
            let r = r0 + (r1 - r0) * (off / sweep);
            center + DVec2::new(a.cos(), a.sin()) * r
        })
        .collect()
}

/// Distance from `p` to the segment `a`-`b`.
fn point_segment_distance(p: DVec2, a: DVec2, b: DVec2) -> f64 {
    let ab = b - a;
    let len_sq = ab.length_squared();
    if len_sq == 0.0 {
        return (p - a).length();
    }
    let t = ((p - a).dot(ab) / len_sq).clamp(0.0, 1.0);
    (a + ab * t - p).length()
}

/// What [`SketchData::split_at`] decided to do with the non-line entity.
enum OtherSplit {
    Line,
    Arc,
    /// The circle's second crossing with the line (a circle can only split
    /// into arcs at two points).
    Circle {
        xj: DVec2,
    },
}

impl SketchData {
    /// The supported-pair intersection nearest `cursor`, within `tolerance`.
    ///
    /// Supported pairs: line×line, line×circle, line×arc — construction
    /// entities included. O(pairs); sketches are small.
    pub fn nearest_intersection(
        &self,
        cursor: DVec2,
        tolerance: f64,
    ) -> Option<SketchIntersection> {
        let mut best: Option<SketchIntersection> = None;
        let mut best_d = tolerance;
        for (i, ea) in self.entities.iter().enumerate() {
            for eb in &self.entities[i + 1..] {
                for pos in self.pair_intersections(ea, eb) {
                    let d = (pos - cursor).length();
                    if d <= best_d {
                        best_d = d;
                        best = Some(SketchIntersection {
                            a: ea.id,
                            b: eb.id,
                            pos,
                        });
                    }
                }
            }
        }
        best
    }

    /// All crossing points between two entities; empty for unsupported pairs
    /// (anything without a line) and dangling point references.
    fn pair_intersections(&self, a: &SketchEntity, b: &SketchEntity) -> Vec<DVec2> {
        let (line, other) = match (a.kind, b.kind) {
            (SketchEntityKind::Line { .. }, _) => (a, b),
            (_, SketchEntityKind::Line { .. }) => (b, a),
            _ => return Vec::new(),
        };
        let SketchEntityKind::Line { p0, p1 } = line.kind else {
            return Vec::new();
        };
        let (Some(l0), Some(l1)) = (self.point_pos(p0), self.point_pos(p1)) else {
            return Vec::new();
        };
        match other.kind {
            SketchEntityKind::Line { p0, p1 } => {
                let (Some(m0), Some(m1)) = (self.point_pos(p0), self.point_pos(p1)) else {
                    return Vec::new();
                };
                segment_segment_intersection(l0, l1, m0, m1)
                    .into_iter()
                    .collect()
            }
            SketchEntityKind::Circle { center, radius } => {
                let Some(c) = self.point_pos(center) else {
                    return Vec::new();
                };
                segment_circle_intersections(l0, l1, c, radius)
            }
            SketchEntityKind::Arc { center, start, end } => {
                let (Some(c), Some(s), Some(e)) = (
                    self.point_pos(center),
                    self.point_pos(start),
                    self.point_pos(end),
                ) else {
                    return Vec::new();
                };
                segment_arc_intersections(l0, l1, c, s, e)
            }
        }
    }

    /// Split entities `a` and `b` at their intersection nearest `pos`.
    ///
    /// Exactly one shared point is created at the split, so the fragments
    /// stay joined. First fragments keep the original entity ids (constraint,
    /// selection and hover references stay valid); new fragments get fresh
    /// ids and inherit `construction`. A fragment shorter than `tolerance`
    /// is not created: that entity is left whole, while the other may still
    /// split. A circle needs the line to cross it twice (a secant); it
    /// becomes two arcs — one boundary per crossing — while the line still
    /// splits only at the crossing nearest `pos`. Constraints referencing a
    /// split entity are retargeted: direction/radius constraints are
    /// duplicated onto both fragments; `Tangent`/`PointOnCurve` move to the
    /// fragment nearest their referenced geometry.
    ///
    /// Returns the newly created entity ids; the sketch is untouched on
    /// `Err`.
    pub fn split_at(
        &mut self,
        a: SketchId,
        b: SketchId,
        pos: DVec2,
        tolerance: f64,
    ) -> Result<Vec<SketchId>, &'static str> {
        let ea = *self.entity(a).ok_or("unknown entity")?;
        let eb = *self.entity(b).ok_or("unknown entity")?;
        let (line_e, other_e) = match (ea.kind, eb.kind) {
            (SketchEntityKind::Line { .. }, _) => (ea, eb),
            (_, SketchEntityKind::Line { .. }) => (eb, ea),
            _ => return Err("unsupported entity pair"),
        };
        let SketchEntityKind::Line { p0: lp0, p1: lp1 } = line_e.kind else {
            return Err("unsupported entity pair");
        };

        let hits = self.pair_intersections(&line_e, &other_e);
        let xi = *hits
            .iter()
            .min_by(|p, q| (**p - pos).length().total_cmp(&(**q - pos).length()))
            .ok_or("no intersection")?;

        let far = |p: Option<DVec2>| p.is_some_and(|p| (xi - p).length() > tolerance);
        let line_splits = far(self.point_pos(lp0)) && far(self.point_pos(lp1));
        let other_plan = match other_e.kind {
            SketchEntityKind::Line { p0, p1 } => {
                (far(self.point_pos(p0)) && far(self.point_pos(p1))).then_some(OtherSplit::Line)
            }
            SketchEntityKind::Arc { start, end, .. } => {
                (far(self.point_pos(start)) && far(self.point_pos(end))).then_some(OtherSplit::Arc)
            }
            SketchEntityKind::Circle { .. } => {
                (hits.len() == 2 && (hits[0] - hits[1]).length() > tolerance).then(|| {
                    let xj = if (hits[0] - xi).length() < (hits[1] - xi).length() {
                        hits[1]
                    } else {
                        hits[0]
                    };
                    OtherSplit::Circle { xj }
                })
            }
        };
        if !line_splits && other_plan.is_none() {
            return Err("intersection too close to endpoints");
        }

        let x = self.add_point(xi);
        let mut new_ids = Vec::new();
        let mut splits: Vec<(SketchId, SketchId)> = Vec::new(); // (old, new)

        if line_splits {
            if let Some(e) = self.entity_mut(line_e.id) {
                e.kind = SketchEntityKind::Line { p0: lp0, p1: x };
            }
            let id = self.alloc_id();
            self.entities.push(SketchEntity {
                id,
                kind: SketchEntityKind::Line { p0: x, p1: lp1 },
                construction: line_e.construction,
            });
            new_ids.push(id);
            splits.push((line_e.id, id));
        }
        match (other_plan, other_e.kind) {
            (Some(OtherSplit::Line), SketchEntityKind::Line { p0, p1 }) => {
                if let Some(e) = self.entity_mut(other_e.id) {
                    e.kind = SketchEntityKind::Line { p0, p1: x };
                }
                let id = self.alloc_id();
                self.entities.push(SketchEntity {
                    id,
                    kind: SketchEntityKind::Line { p0: x, p1 },
                    construction: other_e.construction,
                });
                new_ids.push(id);
                splits.push((other_e.id, id));
            }
            (Some(OtherSplit::Arc), SketchEntityKind::Arc { center, start, end }) => {
                if let Some(e) = self.entity_mut(other_e.id) {
                    e.kind = SketchEntityKind::Arc {
                        center,
                        start,
                        end: x,
                    };
                }
                let id = self.alloc_id();
                self.entities.push(SketchEntity {
                    id,
                    kind: SketchEntityKind::Arc {
                        center,
                        start: x,
                        end,
                    },
                    construction: other_e.construction,
                });
                new_ids.push(id);
                splits.push((other_e.id, id));
            }
            (Some(OtherSplit::Circle { xj }), SketchEntityKind::Circle { center, .. }) => {
                let xj_id = self.add_point(xj);
                if let Some(e) = self.entity_mut(other_e.id) {
                    e.kind = SketchEntityKind::Arc {
                        center,
                        start: x,
                        end: xj_id,
                    };
                }
                let id = self.alloc_id();
                self.entities.push(SketchEntity {
                    id,
                    kind: SketchEntityKind::Arc {
                        center,
                        start: xj_id,
                        end: x,
                    },
                    construction: other_e.construction,
                });
                new_ids.push(id);
                splits.push((other_e.id, id));
            }
            _ => {}
        }

        for (old, new) in splits {
            self.retarget_split_constraints(old, new);
        }
        Ok(new_ids)
    }

    /// After `old` split into (`old`, `new`): duplicate direction/radius
    /// constraints onto both fragments and move locus constraints
    /// (`Tangent`, `PointOnCurve`) to the fragment nearest their referenced
    /// geometry.
    fn retarget_split_constraints(&mut self, old: SketchId, new: SketchId) {
        let mut constraints = core::mem::take(&mut self.constraints);
        let mut additions: Vec<SketchConstraint> = Vec::new();
        for c in &mut constraints {
            match c {
                SketchConstraint::Horizontal { line } if *line == old => {
                    additions.push(SketchConstraint::Horizontal { line: new });
                }
                SketchConstraint::Vertical { line } if *line == old => {
                    additions.push(SketchConstraint::Vertical { line: new });
                }
                SketchConstraint::Parallel { a, b } => {
                    if *a == old {
                        additions.push(SketchConstraint::Parallel { a: new, b: *b });
                    }
                    if *b == old {
                        additions.push(SketchConstraint::Parallel { a: *a, b: new });
                    }
                }
                SketchConstraint::Perpendicular { a, b } => {
                    if *a == old {
                        additions.push(SketchConstraint::Perpendicular { a: new, b: *b });
                    }
                    if *b == old {
                        additions.push(SketchConstraint::Perpendicular { a: *a, b: new });
                    }
                }
                SketchConstraint::Radius { entity, r } if *entity == old => {
                    additions.push(SketchConstraint::Radius { entity: new, r: *r });
                }
                SketchConstraint::Tangent { line, entity } => {
                    if *line == old
                        && let Some(target) = self.entity_center_pos(*entity)
                        && self.entity_distance_to(new, target)
                            < self.entity_distance_to(old, target)
                    {
                        *line = new;
                    }
                    if *entity == old
                        && let Some(target) = self.closest_point_on_line_entity(*line, old)
                        && self.entity_distance_to(new, target)
                            < self.entity_distance_to(old, target)
                    {
                        *entity = new;
                    }
                }
                SketchConstraint::PointOnCurve { point, entity } if *entity == old => {
                    if let Some(target) = self.point_pos(*point)
                        && self.entity_distance_to(new, target)
                            < self.entity_distance_to(old, target)
                    {
                        *entity = new;
                    }
                }
                _ => {}
            }
        }
        constraints.extend(additions);
        self.constraints = constraints;
    }

    /// Center position of a circle/arc entity (`None` for lines).
    fn entity_center_pos(&self, id: SketchId) -> Option<DVec2> {
        match self.entity(id)?.kind {
            SketchEntityKind::Circle { center, .. } | SketchEntityKind::Arc { center, .. } => {
                self.point_pos(center)
            }
            SketchEntityKind::Line { .. } => None,
        }
    }

    /// Closest point of a line entity's segment to the center of the given
    /// circle/arc entity — the natural tangency foot for retargeting.
    fn closest_point_on_line_entity(&self, line: SketchId, curve: SketchId) -> Option<DVec2> {
        let SketchEntityKind::Line { p0, p1 } = self.entity(line)?.kind else {
            return None;
        };
        let (a, b) = (self.point_pos(p0)?, self.point_pos(p1)?);
        let c = self.entity_center_pos(curve)?;
        let ab = b - a;
        let len_sq = ab.length_squared();
        if len_sq == 0.0 {
            return Some(a);
        }
        let t = ((c - a).dot(ab) / len_sq).clamp(0.0, 1.0);
        Some(a + ab * t)
    }

    /// Distance from `p` to an entity's curve (`f64::INFINITY` when the
    /// entity or its points are missing).
    fn entity_distance_to(&self, id: SketchId, p: DVec2) -> f64 {
        let Some(e) = self.entity(id) else {
            return f64::INFINITY;
        };
        match e.kind {
            SketchEntityKind::Line { p0, p1 } => match (self.point_pos(p0), self.point_pos(p1)) {
                (Some(a), Some(b)) => point_segment_distance(p, a, b),
                _ => f64::INFINITY,
            },
            SketchEntityKind::Circle { center, radius } => match self.point_pos(center) {
                Some(c) => ((p - c).length() - radius).abs(),
                None => f64::INFINITY,
            },
            SketchEntityKind::Arc { center, start, end } => {
                let (Some(c), Some(s), Some(e)) = (
                    self.point_pos(center),
                    self.point_pos(start),
                    self.point_pos(end),
                ) else {
                    return f64::INFINITY;
                };
                if arc_contains_angle(c, s, e, p) {
                    let r0 = (s - c).length();
                    let r1 = (e - c).length();
                    let t = arc_angle_offset(c, s, p) / arc_sweep_angle(c, s, e);
                    ((p - c).length() - (r0 + (r1 - r0) * t)).abs()
                } else {
                    (p - s).length().min((p - e).length())
                }
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn rect_sketch() -> SketchData {
        let mut data = SketchData::default();
        data.add_rect(DVec2::ZERO, DVec2::new(2.0, 1.0));
        data
    }

    #[test]
    fn rect_forms_one_ccw_loop() {
        let profile = profile_loops(&rect_sketch(), 32);
        assert_eq!(profile.loops.len(), 1);
        assert_eq!(profile.open_chains, 0);
        assert_eq!(profile.loops[0].len(), 4);
        assert!(signed_area_2x(&profile.loops[0]) > 0.0, "outer must be CCW");
        assert!((signed_area_2x(&profile.loops[0]).abs() / 2.0 - 2.0).abs() < 1e-9);
    }

    #[test]
    fn circle_inside_rect_becomes_cw_hole() {
        let mut data = rect_sketch();
        data.add_circle(DVec2::new(1.0, 0.5), 0.25);
        let profile = profile_loops(&data, 32);
        assert_eq!(profile.loops.len(), 2);
        let (outer, hole) = if profile.loops[0].len() == 4 {
            (&profile.loops[0], &profile.loops[1])
        } else {
            (&profile.loops[1], &profile.loops[0])
        };
        assert!(signed_area_2x(outer) > 0.0);
        assert!(signed_area_2x(hole) < 0.0, "hole must be CW");
    }

    #[test]
    fn open_chain_is_skipped_and_counted() {
        let mut data = SketchData::default();
        let a = data.add_point(DVec2::ZERO);
        let b = data.add_point(DVec2::new(1.0, 0.0));
        let c = data.add_point(DVec2::new(1.0, 1.0));
        data.add_line(a, b);
        data.add_line(b, c);
        let profile = profile_loops(&data, 32);
        assert!(profile.loops.is_empty());
        assert_eq!(profile.open_chains, 1);
    }

    #[test]
    fn delete_point_cascades_and_removes_orphans() {
        // A lone (orphan) point — e.g. the Line tool's first tap, abandoned —
        // deletes directly along with its constraints.
        let mut data = SketchData::default();
        let lone = data.add_point(DVec2::ZERO);
        data.constraints.push(SketchConstraint::Fixed {
            point: lone,
            x: 0.0,
            y: 0.0,
        });
        data.delete_point(lone);
        assert!(data.points.is_empty());
        assert!(data.constraints.is_empty());

        // An entity endpoint cascades: the line goes, its other endpoint
        // prunes, and constraints on both are dropped.
        let mut data = SketchData::default();
        let a = data.add_point(DVec2::ZERO);
        let b = data.add_point(DVec2::new(1.0, 0.0));
        let line = data.add_line(a, b);
        data.constraints.push(SketchConstraint::Horizontal { line });
        data.constraints
            .push(SketchConstraint::Distance { a, b, d: 1.0 });
        data.delete_point(a);
        assert!(data.points.is_empty());
        assert!(data.entities.is_empty());
        assert!(data.constraints.is_empty());

        // Unrelated geometry survives.
        let mut data = SketchData::default();
        let a = data.add_point(DVec2::ZERO);
        let b = data.add_point(DVec2::new(1.0, 0.0));
        data.add_line(a, b);
        let lone = data.add_point(DVec2::new(5.0, 5.0));
        data.delete_point(lone);
        assert_eq!(data.points.len(), 2);
        assert_eq!(data.entities.len(), 1);
    }

    #[test]
    fn loop_survives_dangling_line_at_any_corner() {
        // A dangling stub raises its corner's degree to 3; the rectangle
        // loop must still be found no matter which corner carries the stub.
        let corners = [
            DVec2::ZERO,
            DVec2::new(2.0, 0.0),
            DVec2::new(2.0, 1.0),
            DVec2::new(0.0, 1.0),
        ];
        for corner in 0..4 {
            let mut data = SketchData::default();
            let pts: Vec<SketchId> = corners.iter().map(|&c| data.add_point(c)).collect();
            for i in 0..4 {
                data.add_line(pts[i], pts[(i + 1) % 4]);
            }
            let tip = data.add_point(DVec2::new(3.0, 3.0));
            data.add_line(pts[corner], tip);
            let profile = profile_loops(&data, 32);
            assert_eq!(profile.loops.len(), 1, "corner {corner}");
            assert_eq!(profile.open_chains, 1, "corner {corner}");
            assert!((signed_area_2x(&profile.loops[0]).abs() / 2.0 - 2.0).abs() < 1e-9);
        }
    }

    #[test]
    fn loop_survives_multi_edge_dangle() {
        // A dangle of two chained segments: pruning must cascade inward
        // from the free tip.
        let mut data = SketchData::default();
        let corners = [
            DVec2::ZERO,
            DVec2::new(2.0, 0.0),
            DVec2::new(2.0, 1.0),
            DVec2::new(0.0, 1.0),
        ];
        let pts: Vec<SketchId> = corners.iter().map(|&c| data.add_point(c)).collect();
        for i in 0..4 {
            data.add_line(pts[i], pts[(i + 1) % 4]);
        }
        let mid = data.add_point(DVec2::new(3.0, 1.0));
        let tip = data.add_point(DVec2::new(4.0, 2.0));
        data.add_line(pts[2], mid);
        data.add_line(mid, tip);
        let profile = profile_loops(&data, 32);
        assert_eq!(profile.loops.len(), 1);
        assert_eq!(profile.open_chains, 1);
    }

    #[test]
    fn coincident_endpoints_close_a_loop() {
        let mut data = SketchData::default();
        // Triangle drawn as three disconnected segments, glued by Coincident.
        let a0 = data.add_point(DVec2::ZERO);
        let b0 = data.add_point(DVec2::new(2.0, 0.0));
        let b1 = data.add_point(DVec2::new(2.0, 0.0));
        let c0 = data.add_point(DVec2::new(1.0, 1.5));
        let c1 = data.add_point(DVec2::new(1.0, 1.5));
        let a1 = data.add_point(DVec2::ZERO);
        data.add_line(a0, b0);
        data.add_line(b1, c0);
        data.add_line(c1, a1);
        data.constraints
            .push(SketchConstraint::Coincident { a: b0, b: b1 });
        data.constraints
            .push(SketchConstraint::Coincident { a: c0, b: c1 });
        data.constraints
            .push(SketchConstraint::Coincident { a: a1, b: a0 });
        let profile = profile_loops(&data, 32);
        assert_eq!(profile.loops.len(), 1);
        assert_eq!(profile.open_chains, 0);
        assert_eq!(profile.loops[0].len(), 3);
    }

    #[test]
    fn arc_edges_tessellate_into_the_loop() {
        let mut data = SketchData::default();
        // Half-disc: line across the diameter + CCW arc back over the top.
        let a = data.add_point(DVec2::new(-1.0, 0.0));
        let b = data.add_point(DVec2::new(1.0, 0.0));
        let center = data.add_point(DVec2::ZERO);
        data.add_line(a, b);
        data.add_arc(center, b, a);
        let profile = profile_loops(&data, 32);
        assert_eq!(profile.loops.len(), 1);
        assert_eq!(profile.open_chains, 0);
        assert!(profile.loops[0].len() > 10, "arc should tessellate");
        // Area of a half-disc r=1 is π/2 ≈ 1.571.
        let area = signed_area_2x(&profile.loops[0]).abs() / 2.0;
        assert!((area - core::f64::consts::FRAC_PI_2).abs() < 0.05, "{area}");
    }

    #[test]
    fn connected_components_split_by_shared_points_and_coincidence() {
        let mut data = SketchData::default();
        // Shape 1: rect (4 lines sharing corner points).
        let rect = data.add_rect(DVec2::ZERO, DVec2::new(2.0, 1.0));
        // Shape 2: standalone circle.
        let circle = data.add_circle(DVec2::new(5.0, 5.0), 1.0);
        // Shape 3: two disjoint-point lines pinned together by Coincident.
        let a0 = data.add_point(DVec2::new(8.0, 0.0));
        let a1 = data.add_point(DVec2::new(9.0, 0.0));
        let b0 = data.add_point(DVec2::new(9.0, 0.0));
        let b1 = data.add_point(DVec2::new(9.0, 1.0));
        let la = data.add_line(a0, a1);
        let lb = data.add_line(b0, b1);
        data.constraints
            .push(SketchConstraint::Coincident { a: a1, b: b0 });
        // A cross-shape value constraint must NOT merge components.
        data.constraints.push(SketchConstraint::Distance {
            a: a0,
            b: data.points[0].id,
            d: 8.0,
        });

        let components = data.connected_components();
        assert_eq!(components.len(), 3);
        assert_eq!(components[0], rect.to_vec());
        assert_eq!(components[1], vec![circle]);
        assert_eq!(components[2], vec![la, lb]);
    }

    #[test]
    fn split_off_entities_moves_shape_and_drops_cross_constraints() {
        let mut data = SketchData::default();
        let rect = data.add_rect(DVec2::ZERO, DVec2::new(2.0, 1.0));
        let circle = data.add_circle(DVec2::new(5.0, 5.0), 1.0);
        // Cross-shape constraint: dropped by the split.
        data.constraints.push(SketchConstraint::Distance {
            a: data.points[0].id,
            b: data.points[4].id, // circle center
            d: 5.0,
        });
        let next_id = data.next_id;
        let n_constraints = data.constraints.len();

        let taken = data.split_off_entities(&rect);
        assert_eq!(taken.entities.len(), 4);
        assert_eq!(taken.points.len(), 4);
        // The rect's 4 H/V constraints moved with it.
        assert_eq!(taken.constraints.len(), 4);
        assert_eq!(taken.next_id, next_id);

        assert_eq!(data.entities.len(), 1);
        assert_eq!(data.entities[0].id, circle);
        assert_eq!(data.points.len(), 1);
        // Rest lost the rect constraints AND the cross-shape distance.
        assert_eq!(data.constraints.len(), n_constraints - 4 - 1);
        assert_eq!(data.next_id, next_id);

        // Both halves still produce their own closed profiles.
        assert_eq!(profile_loops(&taken, 16).loops.len(), 1);
        assert_eq!(profile_loops(&data, 16).loops.len(), 1);
    }

    #[test]
    fn delete_entity_cascades_points_and_constraints() {
        let mut data = SketchData::default();
        let lines = {
            let d = &mut data;
            d.add_rect(DVec2::ZERO, DVec2::new(1.0, 1.0))
        };
        let n_points = data.points.len();
        assert_eq!(n_points, 4);
        assert_eq!(data.constraints.len(), 4);
        data.delete_entity(lines[0]);
        assert_eq!(data.entities.len(), 3);
        // Both H constraints referenced other lines too; only bottom's went.
        assert_eq!(data.constraints.len(), 3);
        // All 4 points still used by the remaining 3 lines.
        assert_eq!(data.points.len(), 4);
        data.delete_entity(lines[1]);
        data.delete_entity(lines[2]);
        data.delete_entity(lines[3]);
        assert!(data.points.is_empty());
        assert!(data.constraints.is_empty());
    }

    #[test]
    fn segments_properly_intersect_policy() {
        let p = DVec2::new;
        // X-cross: interiors intersect.
        assert!(segments_properly_intersect(
            p(0.0, 0.0),
            p(2.0, 2.0),
            p(0.0, 2.0),
            p(2.0, 0.0)
        ));
        // Shared endpoint is not a crossing.
        assert!(!segments_properly_intersect(
            p(0.0, 0.0),
            p(2.0, 0.0),
            p(2.0, 0.0),
            p(3.0, 1.0)
        ));
        // T-junction (endpoint on interior) is not a crossing.
        assert!(!segments_properly_intersect(
            p(0.0, 0.0),
            p(2.0, 0.0),
            p(1.0, 0.0),
            p(1.0, 5.0)
        ));
        // Collinear overlap is not a crossing.
        assert!(!segments_properly_intersect(
            p(0.0, 0.0),
            p(2.0, 0.0),
            p(1.0, 0.0),
            p(3.0, 0.0)
        ));
        // Parallel disjoint.
        assert!(!segments_properly_intersect(
            p(0.0, 0.0),
            p(2.0, 0.0),
            p(0.0, 1.0),
            p(2.0, 1.0)
        ));
    }

    #[test]
    fn crossing_loops_normalize_both_ccw() {
        let mut data = SketchData::default();
        data.add_rect(DVec2::ZERO, DVec2::new(2.0, 2.0));
        data.add_rect(DVec2::new(1.0, 1.0), DVec2::new(3.0, 3.0));
        let profile = profile_loops(&data, 32);
        assert_eq!(profile.loops.len(), 2);
        for l in &profile.loops {
            assert!(
                signed_area_2x(l) > 0.0,
                "crossing loops must both stay CCW outers (union)"
            );
        }
    }

    #[test]
    fn three_level_nesting_alternates_windings() {
        let mut data = SketchData::default();
        data.add_rect(DVec2::ZERO, DVec2::new(8.0, 8.0));
        data.add_rect(DVec2::new(1.0, 1.0), DVec2::new(7.0, 7.0));
        data.add_rect(DVec2::new(2.0, 2.0), DVec2::new(6.0, 6.0));
        let profile = profile_loops(&data, 32);
        assert_eq!(profile.loops.len(), 3);
        let mut areas: Vec<f64> = profile.loops.iter().map(|l| signed_area(l)).collect();
        areas.sort_by(|a, b| a.abs().partial_cmp(&b.abs()).expect("BUG: NaN area"));
        // Inner island (16) CCW, middle hole (36) CW, outer (64) CCW.
        assert!(areas[0] > 0.0, "island must be CCW: {areas:?}");
        assert!(areas[1] < 0.0, "hole must be CW: {areas:?}");
        assert!(areas[2] > 0.0, "outer must be CCW: {areas:?}");
    }

    #[test]
    fn loop_crossing_a_hole_stays_a_cutout() {
        let mut data = SketchData::default();
        // Outer rect ⊃ { circle hole ⊗ small rect crossing it }.
        data.add_rect(DVec2::ZERO, DVec2::new(6.0, 6.0));
        data.add_circle(DVec2::new(3.0, 3.0), 1.5);
        data.add_rect(DVec2::new(2.75, 2.75), DVec2::new(3.25, 5.0));
        let profile = profile_loops(&data, 32);
        assert_eq!(profile.loops.len(), 3);
        let mut areas: Vec<f64> = profile.loops.iter().map(|l| signed_area(l)).collect();
        areas.sort_by(|a, b| a.abs().partial_cmp(&b.abs()).expect("BUG: NaN area"));
        // Small rect (1.125) and circle (~7.07) are cutouts, outer (36) fills:
        // the nested role wins over the crossing role.
        assert!(
            areas[0] < 0.0,
            "crossing rect must stay a cutout: {areas:?}"
        );
        assert!(areas[1] < 0.0, "circle hole must be CW: {areas:?}");
        assert!(areas[2] > 0.0, "outer must be CCW: {areas:?}");
    }

    #[test]
    fn geometric_components_merges_nested_circle_into_rect() {
        let mut data = rect_sketch();
        let circle = data.add_circle(DVec2::new(1.0, 0.5), 0.25);
        assert_eq!(data.connected_components().len(), 2);
        let groups = data.geometric_components(32);
        assert_eq!(groups.len(), 1);
        assert_eq!(groups[0].len(), 5);
        assert!(groups[0].contains(&circle));
    }

    #[test]
    fn geometric_components_merges_crossing_rects() {
        let mut data = SketchData::default();
        data.add_rect(DVec2::ZERO, DVec2::new(2.0, 2.0));
        data.add_rect(DVec2::new(1.0, 1.0), DVec2::new(3.0, 3.0));
        let groups = data.geometric_components(32);
        assert_eq!(groups.len(), 1);
        assert_eq!(groups[0].len(), 8);
    }

    #[test]
    fn geometric_components_three_level_nesting_single_group() {
        let mut data = SketchData::default();
        data.add_rect(DVec2::ZERO, DVec2::new(8.0, 8.0));
        data.add_rect(DVec2::new(1.0, 1.0), DVec2::new(7.0, 7.0));
        data.add_rect(DVec2::new(2.0, 2.0), DVec2::new(6.0, 6.0));
        let groups = data.geometric_components(32);
        assert_eq!(groups.len(), 1, "nesting must merge transitively");
        assert_eq!(groups[0].len(), 12);
    }

    #[test]
    fn geometric_components_nested_group_plus_far_shape() {
        let mut data = rect_sketch();
        let inner = data.add_circle(DVec2::new(1.0, 0.5), 0.25);
        let far = data.add_circle(DVec2::new(20.0, 20.0), 1.0);
        let groups = data.geometric_components(32);
        assert_eq!(groups.len(), 2);
        assert_eq!(groups[0].len(), 5, "rect + inner circle merge");
        assert!(groups[0].contains(&inner));
        assert_eq!(groups[1], vec![far]);
    }

    #[test]
    fn geometric_components_open_chain_never_merges() {
        let mut data = SketchData::default();
        data.add_rect(DVec2::ZERO, DVec2::new(4.0, 4.0));
        // Open chain fully inside the rect: no loops, so it never merges.
        let a = data.add_point(DVec2::new(1.0, 1.0));
        let b = data.add_point(DVec2::new(2.0, 1.0));
        let c = data.add_point(DVec2::new(2.0, 2.0));
        let la = data.add_line(a, b);
        let lb = data.add_line(b, c);
        let groups = data.geometric_components(32);
        assert_eq!(groups.len(), 2);
        assert_eq!(groups[1], vec![la, lb]);
    }

    #[test]
    fn geometric_components_identical_duplicate_shapes() {
        let mut data = SketchData::default();
        data.add_rect(DVec2::ZERO, DVec2::new(2.0, 1.0));
        data.add_rect(DVec2::ZERO, DVec2::new(2.0, 1.0));
        // Mutual half-open containment: merged, deterministic, no panic.
        let groups = data.geometric_components(32);
        assert_eq!(groups.len(), 1);
        assert_eq!(groups[0].len(), 8);
        // Degenerate but stable: each loop nests in its twin, so both flip CW.
        let profile = profile_loops(&data, 32);
        assert_eq!(profile.loops.len(), 2);
        for l in &profile.loops {
            assert!(signed_area_2x(l) < 0.0);
        }
    }

    #[cfg(feature = "serde")]
    #[test]
    fn sketch_data_roundtrips_ron() {
        let mut data = rect_sketch();
        let circle = data.add_circle(DVec2::new(1.0, 0.5), 0.25);
        data.set_construction(circle, true);
        data.constraints.push(SketchConstraint::Distance {
            a: data.points[0].id,
            b: data.points[1].id,
            d: 2.0,
        });
        let ron = ron::to_string(&data).expect("serialize");
        let back: SketchData = ron::from_str(&ron).expect("deserialize");
        assert_eq!(data, back);
    }

    #[cfg(feature = "serde")]
    #[test]
    fn construction_defaults_false_on_old_files() {
        // A pre-construction-field file: entities without the flag.
        let ron = "(points:[(id:0,pos:(0.0,0.0)),(id:1,pos:(2.0,0.0))],\
                   entities:[(id:2,kind:Line(p0:0,p1:1))],constraints:[],next_id:3)";
        let data: SketchData = ron::from_str(ron).expect("deserialize old file");
        assert!(!data.entities[0].construction);
    }

    // ── Construction geometry ──────────────────────────────

    #[test]
    fn construction_entities_excluded_from_profile() {
        let mut data = rect_sketch();
        // Construction diagonal between two rect corners: no open chain, no
        // effect on the loop.
        let diag = data.add_line(data.points[0].id, data.points[2].id);
        data.set_construction(diag, true);
        let profile = profile_loops(&data, 32);
        assert_eq!(profile.loops.len(), 1);
        assert_eq!(profile.open_chains, 0);

        // Construction circle inside the rect: no hole.
        let circle = data.add_circle(DVec2::new(1.0, 0.5), 0.25);
        data.set_construction(circle, true);
        let profile = profile_loops(&data, 32);
        assert_eq!(profile.loops.len(), 1);
    }

    #[test]
    fn geometric_components_ignore_construction_circle() {
        let mut data = rect_sketch();
        let circle = data.add_circle(DVec2::new(1.0, 0.5), 0.25);
        data.set_construction(circle, true);
        // Unlike geometric_components_merges_nested_circle_into_rect: the
        // construction circle produces no loop, so nothing merges.
        let groups = data.geometric_components(32);
        assert_eq!(groups.len(), 2);
        assert_eq!(groups[1], vec![circle]);
    }

    // ── Intersection math ──────────────────────────────────

    #[test]
    fn segment_segment_intersection_point_and_policy() {
        let p = DVec2::new;
        let x = segment_segment_intersection(p(0.0, 0.0), p(2.0, 2.0), p(0.0, 2.0), p(2.0, 0.0))
            .expect("X-cross");
        assert!((x - p(1.0, 1.0)).length() < 1e-12);
        // Shared endpoint, T-junction, collinear, parallel: all None.
        assert!(segment_segment_intersection(p(0., 0.), p(2., 0.), p(2., 0.), p(3., 1.)).is_none());
        assert!(segment_segment_intersection(p(0., 0.), p(2., 0.), p(1., 0.), p(1., 5.)).is_none());
        assert!(segment_segment_intersection(p(0., 0.), p(2., 0.), p(1., 0.), p(3., 0.)).is_none());
        assert!(segment_segment_intersection(p(0., 0.), p(2., 0.), p(0., 1.), p(2., 1.)).is_none());
    }

    #[test]
    fn segment_circle_intersections_secant_tangent_miss() {
        let p = DVec2::new;
        let c = p(0.0, 0.0);
        // Secant through the center: two roots ordered by t.
        let hits = segment_circle_intersections(p(-2.0, 0.0), p(2.0, 0.0), c, 1.0);
        assert_eq!(hits.len(), 2);
        assert!((hits[0] - p(-1.0, 0.0)).length() < 1e-9);
        assert!((hits[1] - p(1.0, 0.0)).length() < 1e-9);
        // Tangent graze: nothing.
        assert!(segment_circle_intersections(p(-2.0, 1.0), p(2.0, 1.0), c, 1.0).is_empty());
        // Miss: nothing.
        assert!(segment_circle_intersections(p(-2.0, 3.0), p(2.0, 3.0), c, 1.0).is_empty());
        // Segment ends inside the circle: only the entry root.
        let hits = segment_circle_intersections(p(-2.0, 0.0), p(0.0, 0.0), c, 1.0);
        assert_eq!(hits.len(), 1);
        assert!((hits[0] - p(-1.0, 0.0)).length() < 1e-9);
    }

    #[test]
    fn segment_arc_intersections_respect_sweep() {
        let p = DVec2::new;
        // Upper half-circle r=1 (CCW from (1,0) to (-1,0)).
        let (c, s, e) = (p(0.0, 0.0), p(1.0, 0.0), p(-1.0, 0.0));
        // Vertical chord at x=0 crosses the full circle twice, the upper arc once.
        let hits = segment_arc_intersections(p(0.0, -2.0), p(0.0, 2.0), c, s, e);
        assert_eq!(hits.len(), 1);
        assert!((hits[0] - p(0.0, 1.0)).length() < 1e-9);
        // A chord entirely under the arc's span: nothing.
        assert!(segment_arc_intersections(p(-2.0, -0.5), p(2.0, -0.5), c, s, e).is_empty());
    }

    #[test]
    fn nearest_intersection_picks_closest_within_tolerance() {
        let mut data = SketchData::default();
        let a0 = data.add_point(DVec2::new(-1.0, 0.0));
        let a1 = data.add_point(DVec2::new(1.0, 0.0));
        let h = data.add_line(a0, a1);
        let b0 = data.add_point(DVec2::new(-0.5, -1.0));
        let b1 = data.add_point(DVec2::new(-0.5, 1.0));
        let v1 = data.add_line(b0, b1);
        let c0 = data.add_point(DVec2::new(0.5, -1.0));
        let c1 = data.add_point(DVec2::new(0.5, 1.0));
        data.add_line(c0, c1);

        let hit = data
            .nearest_intersection(DVec2::new(-0.4, 0.1), 0.5)
            .expect("hit");
        assert_eq!((hit.a, hit.b), (h, v1));
        assert!((hit.pos - DVec2::new(-0.5, 0.0)).length() < 1e-12);
        // Beyond tolerance: nothing.
        assert!(
            data.nearest_intersection(DVec2::new(5.0, 5.0), 0.5)
                .is_none()
        );

        // Unsupported circle×circle pair: ignored.
        let mut data = SketchData::default();
        data.add_circle(DVec2::new(-0.5, 0.0), 1.0);
        data.add_circle(DVec2::new(0.5, 0.0), 1.0);
        assert!(
            data.nearest_intersection(DVec2::new(0.0, 0.8), 10.0)
                .is_none()
        );
    }

    // ── Splitting ──────────────────────────────────────────

    #[test]
    fn split_line_line_shares_one_point() {
        let mut data = SketchData::default();
        let a0 = data.add_point(DVec2::new(-1.0, 0.0));
        let a1 = data.add_point(DVec2::new(1.0, 0.0));
        let la = data.add_line(a0, a1);
        let b0 = data.add_point(DVec2::new(0.0, -1.0));
        let b1 = data.add_point(DVec2::new(0.0, 1.0));
        let lb = data.add_line(b0, b1);
        data.constraints
            .push(SketchConstraint::Horizontal { line: la });
        let n_points = data.points.len();

        let new_ids = data
            .split_at(la, lb, DVec2::new(0.05, 0.05), 1e-6)
            .expect("split");
        assert_eq!(new_ids.len(), 2);
        assert_eq!(data.entities.len(), 4);
        assert_eq!(data.points.len(), n_points + 1, "one shared point");
        let x = data.points.last().expect("split point");
        assert!((DVec2::from_array(x.pos) - DVec2::ZERO).length() < 1e-12);
        // All four fragments reference the shared point.
        let uses_x = data
            .entities
            .iter()
            .filter(|e| entity_point_ids(e).contains(&x.id))
            .count();
        assert_eq!(uses_x, 4);
        // Old ids kept by the first fragments.
        assert!(data.entity(la).is_some());
        assert!(data.entity(lb).is_some());
        // Horizontal duplicated onto la's new fragment.
        let horizontals = data
            .constraints
            .iter()
            .filter(|c| matches!(c, SketchConstraint::Horizontal { .. }))
            .count();
        assert_eq!(horizontals, 2);
    }

    #[test]
    fn split_line_arc_preserves_winding() {
        let mut data = SketchData::default();
        // Upper half-circle from (1,0) to (-1,0), r=1.
        let c = data.add_point(DVec2::ZERO);
        let s = data.add_point(DVec2::new(1.0, 0.0));
        let e = data.add_point(DVec2::new(-1.0, 0.0));
        let arc = data.add_arc(c, s, e);
        let l0 = data.add_point(DVec2::new(0.0, -2.0));
        let l1 = data.add_point(DVec2::new(0.0, 2.0));
        let line = data.add_line(l0, l1);

        let new_ids = data
            .split_at(line, arc, DVec2::new(0.0, 1.0), 1e-6)
            .expect("split");
        assert_eq!(new_ids.len(), 2);
        assert_eq!(data.entities.len(), 4);
        let sweeps: Vec<f64> = data
            .entities
            .iter()
            .filter_map(|ent| match ent.kind {
                SketchEntityKind::Arc { center, start, end } => Some(arc_sweep_angle(
                    data.point_pos(center).unwrap(),
                    data.point_pos(start).unwrap(),
                    data.point_pos(end).unwrap(),
                )),
                _ => None,
            })
            .collect();
        assert_eq!(sweeps.len(), 2);
        let total: f64 = sweeps.iter().sum();
        assert!(
            (total - core::f64::consts::PI).abs() < 1e-9,
            "fragment sweeps must sum to the original half-turn: {sweeps:?}"
        );
    }

    #[test]
    fn split_line_circle_makes_two_arcs() {
        let mut data = SketchData::default();
        let circle = data.add_circle(DVec2::ZERO, 1.0);
        let l0 = data.add_point(DVec2::new(-2.0, 0.0));
        let l1 = data.add_point(DVec2::new(2.0, 0.0));
        let line = data.add_line(l0, l1);
        data.constraints.push(SketchConstraint::Radius {
            entity: circle,
            r: 1.0,
        });
        let n_points = data.points.len();

        // Click near the right crossing (1, 0).
        let new_ids = data
            .split_at(line, circle, DVec2::new(0.9, 0.1), 1e-6)
            .expect("split");
        assert_eq!(new_ids.len(), 2);
        // Circle became two arcs; line split at the clicked root only.
        let arcs = data
            .entities
            .iter()
            .filter(|e| matches!(e.kind, SketchEntityKind::Arc { .. }))
            .count();
        let lines = data
            .entities
            .iter()
            .filter(|e| matches!(e.kind, SketchEntityKind::Line { .. }))
            .count();
        assert_eq!((arcs, lines), (2, 2));
        // Shared point at (1,0) + circle-only point at (-1,0).
        assert_eq!(data.points.len(), n_points + 2);
        // Radius duplicated onto both arcs.
        let radii = data
            .constraints
            .iter()
            .filter(|c| matches!(c, SketchConstraint::Radius { .. }))
            .count();
        assert_eq!(radii, 2);
        // Both fragments still cover the full circle.
        let total: f64 = data
            .entities
            .iter()
            .filter_map(|ent| match ent.kind {
                SketchEntityKind::Arc { center, start, end } => Some(arc_sweep_angle(
                    data.point_pos(center).unwrap(),
                    data.point_pos(start).unwrap(),
                    data.point_pos(end).unwrap(),
                )),
                _ => None,
            })
            .sum();
        assert!((total - core::f64::consts::TAU).abs() < 1e-9);
    }

    #[test]
    fn split_line_ending_inside_circle_splits_line_only() {
        let mut data = SketchData::default();
        let circle = data.add_circle(DVec2::ZERO, 1.0);
        let l0 = data.add_point(DVec2::new(-2.0, 0.0));
        let l1 = data.add_point(DVec2::ZERO); // ends at the center
        let line = data.add_line(l0, l1);

        let new_ids = data
            .split_at(line, circle, DVec2::new(-1.0, 0.0), 1e-6)
            .expect("split");
        assert_eq!(new_ids.len(), 1, "only the line splits");
        assert!(
            matches!(
                data.entity(circle).expect("circle").kind,
                SketchEntityKind::Circle { .. }
            ),
            "circle stays whole without a second crossing"
        );
    }

    #[test]
    fn split_skips_near_endpoints() {
        let mut data = SketchData::default();
        // Vertical line crossing a horizontal one right next to its start.
        let a0 = data.add_point(DVec2::new(0.0, 0.0));
        let a1 = data.add_point(DVec2::new(2.0, 0.0));
        let la = data.add_line(a0, a1);
        let b0 = data.add_point(DVec2::new(0.01, -1.0));
        let b1 = data.add_point(DVec2::new(0.01, 1.0));
        let lb = data.add_line(b0, b1);

        // Tolerance bigger than the 0.01 offset: la's fragment would be
        // degenerate, so only lb splits.
        let new_ids = data
            .split_at(la, lb, DVec2::new(0.01, 0.0), 0.05)
            .expect("split");
        assert_eq!(new_ids.len(), 1);
        assert_eq!(data.entities.len(), 3);

        // Both sides degenerate: Err, data untouched.
        let mut data = SketchData::default();
        let a0 = data.add_point(DVec2::new(0.0, 0.0));
        let a1 = data.add_point(DVec2::new(2.0, 0.0));
        let la = data.add_line(a0, a1);
        let b0 = data.add_point(DVec2::new(0.01, -0.02));
        let b1 = data.add_point(DVec2::new(0.01, 0.02));
        let lb = data.add_line(b0, b1);
        let before = data.clone();
        assert!(data.split_at(la, lb, DVec2::new(0.01, 0.0), 0.05).is_err());
        assert_eq!(data, before);
    }

    #[test]
    fn split_unsupported_pair_and_no_intersection_err() {
        let mut data = SketchData::default();
        let c1 = data.add_circle(DVec2::ZERO, 1.0);
        let c2 = data.add_circle(DVec2::new(1.0, 0.0), 1.0);
        assert_eq!(
            data.split_at(c1, c2, DVec2::ZERO, 1e-6),
            Err("unsupported entity pair")
        );
        let l0 = data.add_point(DVec2::new(5.0, 5.0));
        let l1 = data.add_point(DVec2::new(6.0, 5.0));
        let line = data.add_line(l0, l1);
        assert_eq!(
            data.split_at(line, c1, DVec2::ZERO, 1e-6),
            Err("no intersection")
        );
    }

    #[test]
    fn split_retargets_tangent_and_point_on_curve() {
        // Tangent{line}: line tangent to a circle sitting under its left half.
        let mut data = SketchData::default();
        let l0 = data.add_point(DVec2::new(-4.0, 1.0));
        let l1 = data.add_point(DVec2::new(4.0, 1.0));
        let line = data.add_line(l0, l1);
        let circle = data.add_circle(DVec2::new(-3.0, 0.0), 1.0);
        data.constraints.push(SketchConstraint::Tangent {
            line,
            entity: circle,
        });
        // Cross with a vertical line at x=2 and split there: the tangency
        // (foot at x=-3) stays with the LEFT fragment = old id.
        let v0 = data.add_point(DVec2::new(2.0, -1.0));
        let v1 = data.add_point(DVec2::new(2.0, 3.0));
        let vline = data.add_line(v0, v1);
        data.split_at(line, vline, DVec2::new(2.0, 1.0), 1e-6)
            .expect("split");
        assert!(
            data.constraints
                .iter()
                .any(|c| matches!(c, SketchConstraint::Tangent { line: l, .. } if *l == line)),
            "tangent stays on the fragment containing the foot"
        );

        // PointOnCurve{entity}: point on the left of a circle, split at the
        // right crossing → constraint follows the left arc fragment.
        let mut data = SketchData::default();
        let circle = data.add_circle(DVec2::ZERO, 1.0);
        let p = data.add_point(DVec2::new(-1.0, 0.0));
        data.constraints.push(SketchConstraint::PointOnCurve {
            point: p,
            entity: circle,
        });
        let l0 = data.add_point(DVec2::new(0.5, -2.0));
        let l1 = data.add_point(DVec2::new(0.5, 2.0));
        let line = data.add_line(l0, l1);
        data.split_at(line, circle, DVec2::new(0.5, 0.9), 1e-6)
            .expect("split");
        let target = data
            .constraints
            .iter()
            .find_map(|c| match c {
                SketchConstraint::PointOnCurve { entity, .. } => Some(*entity),
                _ => None,
            })
            .expect("constraint kept");
        let d_target = data.entity_distance_to(target, DVec2::new(-1.0, 0.0));
        assert!(
            d_target < 1e-6,
            "PointOnCurve must follow the fragment containing the point: {d_target}"
        );
    }

    #[test]
    fn split_inherits_construction_flag() {
        let mut data = SketchData::default();
        let a0 = data.add_point(DVec2::new(-1.0, 0.0));
        let a1 = data.add_point(DVec2::new(1.0, 0.0));
        let la = data.add_line(a0, a1);
        data.set_construction(la, true);
        let b0 = data.add_point(DVec2::new(0.0, -1.0));
        let b1 = data.add_point(DVec2::new(0.0, 1.0));
        let lb = data.add_line(b0, b1);

        let new_ids = data.split_at(la, lb, DVec2::ZERO, 1e-6).expect("split");
        let frag_of = |old: SketchId| {
            data.entities.iter().find(|e| {
                new_ids.contains(&e.id) && e.construction == data.entity(old).unwrap().construction
            })
        };
        assert!(data.entity(la).expect("la").construction);
        assert!(frag_of(la).expect("la fragment").construction);
        assert!(!data.entity(lb).expect("lb").construction);
    }
}