diff --git a/src/snap.rs b/src/snap.rs
index 515ee4278..9d0f9db90 100644
--- a/src/snap.rs
+++ b/src/snap.rs
@@ -8,6 +8,8 @@ use glam::{DVec3, Mat4, Vec3};
 use iced::time::Instant;
 use iced::{Point, Rectangle};
 
+use cadkernel::geom2d::Curve;
+
 use crate::command::TangentObject;
 use crate::scene::model::wire_model::{SnapHint, TangentGeom, WireModel};
 use crate::scene::pick::interaction_index::WireSource;
@@ -1367,6 +1369,35 @@ impl Snapper {
             && (local_segments.is_some() || allow_unindexed_pairwise)
         {
             if let Some(segments) = &local_segments {
+                // Curved pairs (circle/arc/ellipse, and a line paired with
+                // one) are solved exactly up front (bug #1052 — see
+                // `exact_curve_intersections`'s doc comment); the segment
+                // sweep below then skips any pair already resolved this
+                // way, so the stale tessellated approximation never
+                // competes with the true point as a candidate. Every
+                // distinct wire pair touching the cursor-local segment set
+                // is tried — cheap even for a plain line-vs-line pair,
+                // which `exact_curve_intersections` rejects immediately —
+                // rather than pre-filtering to "known curved" wires, so a
+                // line paired with a circle/arc/ellipse is covered too.
+                let mut local_wires: Vec<u32> = segments.iter().map(|s| s.wire).collect();
+                local_wires.sort_unstable();
+                local_wires.dedup();
+                let mut resolved_pairs: Vec<(u32, u32)> = Vec::new();
+                for (idx, &wi) in local_wires.iter().enumerate() {
+                    for &wj in &local_wires[idx + 1..] {
+                        let (Some(wire_i), Some(wire_j)) = (wires.source_wire(wi), wires.source_wire(wj)) else {
+                            continue;
+                        };
+                        if let Some(pts) = exact_curve_intersections(wire_i, wire_j) {
+                            for pt in pts {
+                                try_pt(pt, SnapType::Intersection);
+                            }
+                            resolved_pairs.push((wi, wj));
+                        }
+                    }
+                }
+
                 // Exact cursor-local sweep: never discard a valid intersection
                 // in dense geometry. Min-X ordering plus Y overlap avoids
                 // comparing segment pairs whose bounds cannot meet.
@@ -1382,6 +1413,9 @@ impl Snapper {
                             if a.wire == b.wire || a.max_y() < b.min_y() || a.min_y() > b.max_y() {
                                 continue;
                             }
+                            if resolved_pairs.contains(&(a.wire.min(b.wire), a.wire.max(b.wire))) {
+                                continue;
+                            }
                             if let Some(pt) = seg_intersect_3d(a.a, a.b, b.a, b.b) {
                                 let exact_cursor = dist2(
                                     world_to_screen(pt, view_rot, eye, bounds),
@@ -1410,6 +1444,14 @@ impl Snapper {
                         if !wire_in_range(wire_j) {
                             continue;
                         }
+                        // Curved pairs are solved exactly (bug #1052); see
+                        // `exact_curve_intersections`'s doc comment.
+                        if let Some(pts) = exact_curve_intersections(wire_i, wire_j) {
+                            for pt in pts {
+                                try_pt(pt, SnapType::Intersection);
+                            }
+                            continue;
+                        }
                         for ai in 0..wire_i.points.len().saturating_sub(1) {
                             // S: pre-convert outside inner loop
                             let a0 = wp_f64(wire_i, ai);
@@ -2301,6 +2343,422 @@ fn ray_segment_intersect_3d(
     ))
 }
 
+/// A full circle recovered from a wire's `tangent_geoms` — the entity's real
+/// definition, in world space — used to solve Intersection snap exactly for
+/// circle/arc pairs instead of falling back to `seg_intersect_3d` against
+/// their tessellated approximation.
+///
+/// Why this exists (GitHub discussion #1052): a chord of *any* tessellated
+/// circle sits strictly inside the true circle, so the "intersection" of two
+/// tessellated circles is never quite where the two real circles actually
+/// cross — the error is small but real, and does not shrink with zoom: the
+/// resident wire set OSNAP searches is built once per geometry edit with a
+/// fixed 48-segment tessellation for every circle regardless of radius, by
+/// design (`Scene::resident_wires_for`'s own doc comment: zoom-independent,
+/// so hit-testing/snap don't re-tessellate on every camera move). A r=100
+/// circle's chord sagitta at 48 segments is already ≈0.21 world units.
+struct WireCircle {
+    center: DVec3,
+    radius: f64,
+    /// Unit normal of the plane the circle lies in.
+    normal: DVec3,
+    /// `Some((axis_x, axis_y, start_angle, end_angle))` for an arc — used to
+    /// keep only the full circle's crossing points that actually fall
+    /// within the arc's own sweep. `None` for a full circle: every point
+    /// the circle-circle solve finds is valid. Angles follow this
+    /// codebase's own convention (`src/entities/arc.rs`): measured from
+    /// `axis_x` toward `axis_y`, equal start/end meaning a full turn.
+    arc_span: Option<(DVec3, DVec3, f64, f64)>,
+}
+
+/// The wire's underlying circle, if it's simple enough to have one: a single
+/// Circle or Arc entity as a whole, not a compound chain. Ellipses and lines
+/// return `None` here — they're handled by the more general
+/// `exact_curve_intersections` below, which this function's caller falls
+/// through to. A polyline with a bulge segment still goes through the
+/// tessellated sweep: it isn't a single recognized curve, and splitting it
+/// into per-segment exact geometry is a real follow-up, not a known-and-
+/// skipped case (there's no single closed form for "the rest of a compound
+/// chain" the way there is for one circle, arc, ellipse, or line).
+fn wire_circle(wire: &WireModel) -> Option<WireCircle> {
+    let [geom] = wire.tangent_geoms.as_slice() else {
+        return None;
+    };
+    match geom {
+        TangentGeom::PlanarCircle { center, axis_x, axis_y, radius } => {
+            let (axis_x, axis_y) = (DVec3::new(axis_x[0], axis_x[1], axis_x[2]), DVec3::new(axis_y[0], axis_y[1], axis_y[2]));
+            Some(WireCircle {
+                center: DVec3::new(center[0], center[1], center[2]),
+                radius: *radius,
+                normal: axis_x.cross(axis_y).normalize(),
+                arc_span: None,
+            })
+        }
+        TangentGeom::Circle { center, radius } => Some(WireCircle {
+            center: DVec3::new(center[0] as f64, center[1] as f64, center[2] as f64),
+            radius: *radius as f64,
+            normal: DVec3::Z,
+            arc_span: None,
+        }),
+        TangentGeom::Arc { center, axis_x, axis_y, radius, start_angle, end_angle } => {
+            let (axis_x, axis_y) = (DVec3::new(axis_x[0], axis_x[1], axis_x[2]), DVec3::new(axis_y[0], axis_y[1], axis_y[2]));
+            Some(WireCircle {
+                center: DVec3::new(center[0], center[1], center[2]),
+                radius: *radius,
+                normal: axis_x.cross(axis_y).normalize(),
+                arc_span: Some((axis_x, axis_y, *start_angle, *end_angle)),
+            })
+        }
+        TangentGeom::Line { .. } | TangentGeom::PlanarEllipse { .. } => None,
+    }
+}
+
+impl WireCircle {
+    /// Whether world point `p` — assumed already on this circle — falls
+    /// within the arc's actual angular sweep. Always true for a full circle.
+    fn contains_point(&self, p: DVec3) -> bool {
+        let Some((axis_x, axis_y, start, end)) = self.arc_span else {
+            return true;
+        };
+        let rel = p - self.center;
+        let tau = std::f64::consts::TAU;
+        let angle = rel.dot(axis_y).atan2(rel.dot(axis_x)).rem_euclid(tau);
+        let span = (end - start).rem_euclid(tau);
+        let from_start = (angle - start).rem_euclid(tau);
+        // Equal start/end means a full turn (this codebase's own Arc
+        // convention), not zero sweep.
+        span == 0.0 || from_start <= span + 1e-9
+    }
+}
+
+/// Exact circle/arc intersection for one wire pair, bypassing their
+/// tessellated approximation entirely. `None` when neither side is a circle
+/// or arc (the segment sweep is already exact for pure lines/polylines), the
+/// two aren't coplanar (a genuinely-3D case the sweep already handles no
+/// worse than before), or they don't actually meet — in every `None` case
+/// the caller falls back to the ordinary segment sweep unchanged.
+///
+/// Correct for any circle/arc-vs-circle/arc pair regardless of whether the
+/// two sides' own local frames agree in orientation: the candidate points
+/// come from a frame-agnostic 3D construction (`a.normal`/`dir`/`perp`
+/// below), and each side's `WireCircle::contains_point` then checks a
+/// candidate against *that side's own* axis_x/axis_y independently — there
+/// is no step that re-expresses one arc's angle range in the other's frame,
+/// so this handles arc-vs-arc (even two arcs with differently-rotated
+/// frames — see the test below) exactly as directly as circle-vs-circle.
+///
+/// Deliberately scoped to circle/arc pairs, not every curved type: a
+/// line-vs-circle/arc pair and anything involving an ellipse are left to
+/// the existing sweep for now — line-circle needs its own (simple, but
+/// separate) closed form, and an ellipse's parametrisation is genuinely
+/// orientation-sensitive in a way a circle's isn't, so it doesn't fall out
+/// of this same construction for free. Not silently dropped — a natural
+/// follow-up once this lands.
+fn exact_circle_intersections(wire_a: &WireModel, wire_b: &WireModel) -> Option<Vec<DVec3>> {
+    let a = wire_circle(wire_a)?;
+    let b = wire_circle(wire_b)?;
+
+    let d_vec = b.center - a.center;
+    let d = d_vec.length();
+    if d < 1e-9 {
+        return None; // concentric: coincident or no isolated crossing either way
+    }
+
+    // Coplanarity: both circles' planes must agree (normals parallel, up to
+    // sign), and the vector between centers must actually lie in that plane
+    // — otherwise this is a genuinely-3D case the tessellated sweep already
+    // handles (via `seg_intersect_3d`'s own height-match check) no worse
+    // than an exact-but-wrong-plane answer would.
+    const PLANE_TOL: f64 = 1e-7;
+    if a.normal.cross(b.normal).length() > PLANE_TOL {
+        return None;
+    }
+    if d_vec.dot(a.normal).abs() > PLANE_TOL * d.max(1.0) {
+        return None;
+    }
+
+    let (r1, r2) = (a.radius, b.radius);
+    if d > r1 + r2 + PLANE_TOL || d < (r1 - r2).abs() - PLANE_TOL {
+        return None; // circles don't meet
+    }
+
+    let dir = d_vec / d;
+    let a_dist = ((d * d + r1 * r1 - r2 * r2) / (2.0 * d)).clamp(-r1, r1);
+    let h = (r1 * r1 - a_dist * a_dist).max(0.0).sqrt();
+    let mid = a.center + dir * a_dist;
+    let perp = a.normal.cross(dir).normalize();
+
+    let candidates = if h < 1e-9 { vec![mid] } else { vec![mid + perp * h, mid - perp * h] };
+    let points: Vec<DVec3> = candidates.into_iter().filter(|&p| a.contains_point(p) && b.contains_point(p)).collect();
+
+    (!points.is_empty()).then_some(points)
+}
+
+/// A world-space working plane for embedding curves into
+/// `cadkernel::geom2d`'s 2D representation — the general-case fix for
+/// GitHub discussion #1052, covering every pairing `exact_circle_
+/// intersections`'s fast path doesn't: a line paired with a circle/arc/
+/// ellipse, and anything involving an ellipse (an ellipse's parametrisation
+/// is orientation-sensitive in a way a circle's isn't, so it doesn't fall
+/// out of that fast path's frame-independent construction for free).
+struct WirePlane {
+    origin: DVec3,
+    axis_x: DVec3,
+    axis_y: DVec3,
+    normal: DVec3,
+}
+
+impl WirePlane {
+    fn to_2d(&self, p: DVec3) -> [f64; 2] {
+        let rel = p - self.origin;
+        [rel.dot(self.axis_x), rel.dot(self.axis_y)]
+    }
+
+    /// Projects a *direction*, not a location — for re-expressing another
+    /// coplanar curve's own axis vector in this plane's 2D basis.
+    fn dir_to_2d(&self, d: DVec3) -> [f64; 2] {
+        [d.dot(self.axis_x), d.dot(self.axis_y)]
+    }
+
+    fn to_3d(&self, p: [f64; 2]) -> DVec3 {
+        self.origin + self.axis_x * p[0] + self.axis_y * p[1]
+    }
+
+    fn contains(&self, p: DVec3, tol: f64) -> bool {
+        (p - self.origin).dot(self.normal).abs() <= tol
+    }
+}
+
+/// A stable orthonormal in-plane basis for a given normal, used only to
+/// seed a shared working plane when neither wire's own native frame is
+/// preferred over the other's (both curved, or the "primary" role needs a
+/// deterministic pick) — the specific in-plane rotation chosen doesn't
+/// matter for correctness, only that both curves embed into the *same* one.
+fn stable_plane_basis(normal: DVec3) -> (DVec3, DVec3) {
+    let seed = if normal.x.abs() <= normal.y.abs() && normal.x.abs() <= normal.z.abs() {
+        DVec3::X
+    } else if normal.y.abs() <= normal.z.abs() {
+        DVec3::Y
+    } else {
+        DVec3::Z
+    };
+    let axis_x = (seed - normal * normal.dot(seed)).normalize();
+    let axis_y = normal.cross(axis_x);
+    (axis_x, axis_y)
+}
+
+/// A world point on an ellipse at native parameter `t`, using the ellipse's
+/// *own* normal for the minor-axis direction (not any externally-chosen
+/// plane's) — the correct, orientation-independent reference for computing
+/// where a boundary parameter actually sits in space, mirroring how
+/// `src/entities/curve.rs::ellipse_curve` already treats this convention as
+/// established (`normal` determines the minor-axis rotation sense).
+fn ellipse_world_point(center: DVec3, major_axis_world: DVec3, ell_normal: DVec3, minor_radius: f64, t: f64) -> DVec3 {
+    let major_radius = major_axis_world.length();
+    let major_unit = major_axis_world / major_radius;
+    let minor_unit = ell_normal.cross(major_unit);
+    center + major_unit * (major_radius * t.cos()) + minor_unit * (minor_radius * t.sin())
+}
+
+/// The parameter, in `frame`'s own 2D ellipse embedding (`major_axis_2d`
+/// already resolved there, `cadkernel`'s own "minor is major rotated 90°
+/// CCW in 2D" convention supplying the rest), that a world point already
+/// known to lie on the ellipse corresponds to. Inverting through the actual
+/// point — rather than assuming a native parameter value carries over
+/// unchanged — is what makes this correct even when the ellipse's own
+/// normal and `frame`'s normal are coplanar but *anti*-parallel (a plain
+/// "reuse start/end parameter" would silently pick the complementary arc in
+/// that case: 2D-CCW-in-`frame` and 2D-CCW-in-the-ellipse's-own-frame would
+/// disagree on which way is "forward").
+fn ellipse_param_in_frame(world_point: DVec3, centre: DVec3, major_axis_2d: [f64; 2], major_radius: f64, minor_radius: f64, frame: &WirePlane) -> f64 {
+    let rel = frame.to_2d(world_point);
+    let c = frame.to_2d(centre);
+    let d = [rel[0] - c[0], rel[1] - c[1]];
+    let minor_axis_2d = [-major_axis_2d[1], major_axis_2d[0]];
+    let cos_t = (d[0] * major_axis_2d[0] + d[1] * major_axis_2d[1]) / major_radius;
+    let sin_t = (d[0] * minor_axis_2d[0] + d[1] * minor_axis_2d[1]) / minor_radius;
+    sin_t.atan2(cos_t)
+}
+
+/// This wire's own natural working plane — only a Circle/PlanarCircle/Arc/
+/// PlanarEllipse has one; a line's two points don't define a unique plane,
+/// and a compound chain (a polyline with a bulge) isn't a single curve to
+/// begin with (out of scope for this pass, not because it's hard, but
+/// because a *chain* needs its own per-segment bookkeeping this pass
+/// doesn't add).
+fn wire_plane(wire: &WireModel) -> Option<WirePlane> {
+    let [geom] = wire.tangent_geoms.as_slice() else {
+        return None;
+    };
+    let (origin, axis_x, axis_y) = match geom {
+        TangentGeom::Circle { center, .. } => (DVec3::new(center[0] as f64, center[1] as f64, center[2] as f64), DVec3::X, DVec3::Y),
+        TangentGeom::PlanarCircle { center, axis_x, axis_y, .. } | TangentGeom::Arc { center, axis_x, axis_y, .. } => (
+            DVec3::new(center[0], center[1], center[2]),
+            DVec3::new(axis_x[0], axis_x[1], axis_x[2]),
+            DVec3::new(axis_y[0], axis_y[1], axis_y[2]),
+        ),
+        TangentGeom::PlanarEllipse { center, major_axis, normal, .. } => {
+            let origin = DVec3::new(center[0], center[1], center[2]);
+            let n = DVec3::new(normal[0], normal[1], normal[2]).normalize();
+            let major = DVec3::new(major_axis[0], major_axis[1], major_axis[2]);
+            if major.length() <= 1e-12 {
+                return None;
+            }
+            (origin, major.normalize(), n.cross(major.normalize()))
+        }
+        TangentGeom::Line { .. } => return None,
+    };
+    Some(WirePlane { origin, axis_x, axis_y, normal: axis_x.cross(axis_y).normalize() })
+}
+
+/// `wire`'s curve, expressed in `frame`'s 2D coordinates — `None` if `wire`
+/// isn't a single recognized curve (see `wire_plane`'s doc comment for what
+/// that excludes) or doesn't actually lie in `frame`'s plane. Correct
+/// regardless of whether `wire`'s own native frame agrees in orientation
+/// with `frame`: an Arc's/Ellipse's boundary parameters are re-derived from
+/// their actual world points (`ellipse_param_in_frame`, the closure below
+/// for Arc), never assumed to carry over unchanged.
+fn curve_in_frame(wire: &WireModel, frame: &WirePlane, tol: f64) -> Option<Curve> {
+    use cadkernel::geom2d::{Arc as KArc, Circle as KCircle, Ellipse as KEllipse, EllipseArc as KEllipseArc, Line as KLine};
+
+    if wire.tangent_geoms.is_empty() {
+        if wire.points.len() != 2 {
+            return None;
+        }
+        let (p0, p1) = (wp_f64(wire, 0), wp_f64(wire, 1));
+        return (frame.contains(p0, tol) && frame.contains(p1, tol)).then(|| Curve::Line(KLine { start: frame.to_2d(p0), end: frame.to_2d(p1) }));
+    }
+
+    let [geom] = wire.tangent_geoms.as_slice() else {
+        return None;
+    };
+    let angle_in_frame = |world_point: DVec3, centre: DVec3| {
+        let (p2, c2) = (frame.to_2d(world_point), frame.to_2d(centre));
+        (p2[1] - c2[1]).atan2(p2[0] - c2[0])
+    };
+
+    match geom {
+        TangentGeom::Line { p1, p2 } => {
+            let p1 = DVec3::new(p1[0] as f64, p1[1] as f64, p1[2] as f64);
+            let p2 = DVec3::new(p2[0] as f64, p2[1] as f64, p2[2] as f64);
+            (frame.contains(p1, tol) && frame.contains(p2, tol)).then(|| Curve::Line(KLine { start: frame.to_2d(p1), end: frame.to_2d(p2) }))
+        }
+        TangentGeom::Circle { center, radius } => {
+            let c = DVec3::new(center[0] as f64, center[1] as f64, center[2] as f64);
+            frame.contains(c, tol).then(|| Curve::Circle(KCircle { centre: frame.to_2d(c), radius: *radius as f64 }))
+        }
+        TangentGeom::PlanarCircle { center, axis_x, axis_y, radius } => {
+            let c = DVec3::new(center[0], center[1], center[2]);
+            let n = DVec3::new(axis_x[0], axis_x[1], axis_x[2]).cross(DVec3::new(axis_y[0], axis_y[1], axis_y[2])).normalize();
+            (n.cross(frame.normal).length() <= tol && frame.contains(c, tol)).then(|| Curve::Circle(KCircle { centre: frame.to_2d(c), radius: *radius }))
+        }
+        TangentGeom::Arc { center, axis_x, axis_y, radius, start_angle, end_angle } => {
+            let c = DVec3::new(center[0], center[1], center[2]);
+            let (ax, ay) = (DVec3::new(axis_x[0], axis_x[1], axis_x[2]), DVec3::new(axis_y[0], axis_y[1], axis_y[2]));
+            let n = ax.cross(ay).normalize();
+            if n.cross(frame.normal).length() > tol || !frame.contains(c, tol) {
+                return None;
+            }
+            let boundary = |angle: f64| c + *radius * (angle.cos() * ax + angle.sin() * ay);
+            let (raw_start, raw_end) = (angle_in_frame(boundary(*start_angle), c), angle_in_frame(boundary(*end_angle), c));
+            // The arc's own (ax, ay, n) frame and the target frame's (axis_x, axis_y, normal)
+            // agree on the plane but may disagree on which way is "up": when n is anti-parallel
+            // to frame.normal, mapping into the frame's basis is a reflection, which reverses
+            // the CCW sweep direction. Swap start/end so the swept range still traces the same
+            // physical arc instead of its complement.
+            let (start_angle, end_angle) = if n.dot(frame.normal) < 0.0 { (raw_end, raw_start) } else { (raw_start, raw_end) };
+            Some(Curve::Arc(KArc { centre: frame.to_2d(c), radius: *radius, start_angle, end_angle }))
+        }
+        TangentGeom::PlanarEllipse { center, major_axis, normal, minor_axis_ratio, start_param, end_param } => {
+            let c = DVec3::new(center[0], center[1], center[2]);
+            let ell_normal = DVec3::new(normal[0], normal[1], normal[2]).normalize();
+            if ell_normal.cross(frame.normal).length() > tol || !frame.contains(c, tol) {
+                return None;
+            }
+            let major = DVec3::new(major_axis[0], major_axis[1], major_axis[2]);
+            let major_radius = major.length();
+            if major_radius <= 1e-12 {
+                return None;
+            }
+            let minor_radius = major_radius * *minor_axis_ratio;
+            let dir2d = frame.dir_to_2d(major / major_radius);
+            let len = (dir2d[0] * dir2d[0] + dir2d[1] * dir2d[1]).sqrt();
+            if len <= 1e-12 {
+                return None;
+            }
+            let major_axis_2d = [dir2d[0] / len, dir2d[1] / len];
+            let world_at = |t: f64| ellipse_world_point(c, major, ell_normal, minor_radius, t);
+            let raw_start = ellipse_param_in_frame(world_at(*start_param), c, major_axis_2d, major_radius, minor_radius, frame);
+            let raw_end = ellipse_param_in_frame(world_at(*end_param), c, major_axis_2d, major_radius, minor_radius, frame);
+            // Same reflection issue as the Arc case above: the ellipse's own normal may be
+            // anti-parallel to the embedding frame's normal, which mirrors the parametrization
+            // and reverses the sweep direction — swap start/end to keep the same physical arc.
+            let (start_parameter, end_parameter) = if ell_normal.dot(frame.normal) < 0.0 { (raw_end, raw_start) } else { (raw_start, raw_end) };
+            Some(Curve::Ellipse(KEllipseArc {
+                ellipse: KEllipse { centre: frame.to_2d(c), major_radius, minor_radius, major_axis: major_axis_2d },
+                start_parameter,
+                end_parameter,
+            }))
+        }
+    }
+}
+
+/// Exact (or, where no closed form exists — an ellipse against another
+/// curved shape — properly tolerance-converged, via `cadkernel::geom2d::
+/// intersect`'s own subdivision-and-refinement fallback) intersection for
+/// one wire pair, bypassing their tessellated approximation entirely.
+/// Tries the fast, frame-independent circle/arc path first; the general
+/// embedding below only runs for a pair that path can't answer — a line
+/// paired with a circle/arc/ellipse, or anything involving an ellipse.
+/// `None` when neither side is a single recognized curve (both lines: the
+/// segment sweep is already exact), the two aren't coplanar, or they don't
+/// actually meet — in every `None` case the caller falls back to the
+/// ordinary segment sweep unchanged.
+fn exact_curve_intersections(wire_a: &WireModel, wire_b: &WireModel) -> Option<Vec<DVec3>> {
+    if let Some(pts) = exact_circle_intersections(wire_a, wire_b) {
+        return Some(pts);
+    }
+
+    // Prefer whichever side already has a natural working plane so a
+    // circle/arc paired with a line needs no reprojection of its own shape
+    // at all; when both are curved (at least one an ellipse, since a pure
+    // circle/arc pair would already have returned above) or neither is,
+    // fall back to a plane seeded from whichever side offers one.
+    let frame = wire_plane(wire_a).or_else(|| wire_plane(wire_b)).or_else(|| {
+        let normal = curve_normal_only(wire_a).or_else(|| curve_normal_only(wire_b))?;
+        let origin = wp_f64_first(wire_a).or_else(|| wp_f64_first(wire_b))?;
+        let (axis_x, axis_y) = stable_plane_basis(normal);
+        Some(WirePlane { origin, axis_x, axis_y, normal })
+    })?;
+
+    const PLANE_TOL: f64 = 1e-7;
+    let curve_a = curve_in_frame(wire_a, &frame, PLANE_TOL)?;
+    let curve_b = curve_in_frame(wire_b, &frame, PLANE_TOL)?;
+    // Two lines have nothing this path can improve on (the segment sweep is
+    // already exact for a straight pair); avoid the extra work.
+    if matches!(curve_a, Curve::Line(_)) && matches!(curve_b, Curve::Line(_)) {
+        return None;
+    }
+
+    let tolerance = cadkernel::geom2d::Tolerance::new(1e-9_f64.max(PLANE_TOL));
+    let crossings = cadkernel::geom2d::intersect(&curve_a, &curve_b, tolerance);
+    let points: Vec<DVec3> = crossings.into_iter().map(|c| frame.to_3d(c.point)).collect();
+    (!points.is_empty()).then_some(points)
+}
+
+/// Fallback plane-seeding helpers for `exact_curve_intersections`' rare
+/// "neither side has its own natural plane" branch (in practice: unreached
+/// today, since that only happens when both sides are lines, which returns
+/// `None` a step earlier — kept for robustness against a future caller that
+/// invokes `exact_curve_intersections` with weaker preconditions).
+fn curve_normal_only(wire: &WireModel) -> Option<DVec3> {
+    wire_plane(wire).map(|p| p.normal)
+}
+
+fn wp_f64_first(wire: &WireModel) -> Option<DVec3> {
+    (!wire.points.is_empty()).then(|| wp_f64(wire, 0))
+}
+
 /// XY-plane segment-segment intersection.  Returns `None` if parallel or outside.
 /// True 3D intersection of two segments: the point where their plan (XY)
 /// projections cross **and** both segments are at the same height there. Returns
@@ -2880,4 +3338,385 @@ mod ext_tests {
             hi.z
         );
     }
+
+    /// GitHub discussion #1052's own reproduction: a 3-unit base line, a
+    /// radius-4 circle at one end, a radius-5 circle at the other. The true
+    /// intersection is exactly (0, 4, 0) (a 3-4-5 right triangle) — the
+    /// tessellated segment sweep misses this by a small but real amount
+    /// (confirmed separately against `seg_intersect_3d` on the actual
+    /// tessellated wire); the exact solver must hit it exactly.
+    #[test]
+    fn exact_circle_intersections_matches_the_3_4_5_report() {
+        let c1 = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarCircle {
+                center: [0.0, 0.0, 0.0],
+                axis_x: [1.0, 0.0, 0.0],
+                axis_y: [0.0, 1.0, 0.0],
+                radius: 4.0,
+            }],
+            ..Default::default()
+        };
+        let c2 = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarCircle {
+                center: [3.0, 0.0, 0.0],
+                axis_x: [1.0, 0.0, 0.0],
+                axis_y: [0.0, 1.0, 0.0],
+                radius: 5.0,
+            }],
+            ..Default::default()
+        };
+        let pts = exact_circle_intersections(&c1, &c2).expect("two overlapping circles must intersect");
+        assert_eq!(pts.len(), 2, "two distinct circles crossing at two points");
+        let upper = pts.iter().copied().find(|p| p.y > 0.0).expect("an upper intersection");
+        assert!((upper - DVec3::new(0.0, 4.0, 0.0)).length() < 1e-9, "expected exactly (0,4,0), got {upper:?}");
+        for p in &pts {
+            assert!(((*p - DVec3::ZERO).length() - 4.0).abs() < 1e-9, "must be exactly radius 4 from c1's centre, got {p:?}");
+            assert!(((*p - DVec3::new(3.0, 0.0, 0.0)).length() - 5.0).abs() < 1e-9, "must be exactly radius 5 from c2's centre, got {p:?}");
+        }
+    }
+
+    #[test]
+    fn exact_circle_intersections_respects_an_arcs_own_sweep() {
+        // A quarter-circle arc from 0° to 90° (so it only covers the upper-
+        // right quadrant) against a full circle whose two true intersection
+        // points straddle that boundary: only the one actually on the arc's
+        // sweep should come back.
+        let arc = WireModel {
+            tangent_geoms: vec![TangentGeom::Arc {
+                center: [0.0, 0.0, 0.0],
+                axis_x: [1.0, 0.0, 0.0],
+                axis_y: [0.0, 1.0, 0.0],
+                radius: 4.0,
+                start_angle: 0.0,
+                end_angle: std::f64::consts::FRAC_PI_2,
+            }],
+            ..Default::default()
+        };
+        let circle = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarCircle {
+                center: [3.0, 0.0, 0.0],
+                axis_x: [1.0, 0.0, 0.0],
+                axis_y: [0.0, 1.0, 0.0],
+                radius: 5.0,
+            }],
+            ..Default::default()
+        };
+        // Full-circle math gives (0,4,0) [on the 0..90° arc] and (0,-4,0)
+        // [not on it].
+        let pts = exact_circle_intersections(&arc, &circle).expect("the circles still cross");
+        assert_eq!(pts.len(), 1, "only the point on the arc's own sweep");
+        assert!((pts[0] - DVec3::new(0.0, 4.0, 0.0)).length() < 1e-9);
+    }
+
+    #[test]
+    fn exact_circle_intersections_is_none_for_non_coplanar_circles() {
+        let flat = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarCircle {
+                center: [0.0, 0.0, 0.0],
+                axis_x: [1.0, 0.0, 0.0],
+                axis_y: [0.0, 1.0, 0.0],
+                radius: 4.0,
+            }],
+            ..Default::default()
+        };
+        let tilted = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarCircle {
+                center: [0.0, 0.0, 0.0],
+                axis_x: [1.0, 0.0, 0.0],
+                axis_y: [0.0, 0.0, 1.0],
+                radius: 4.0,
+            }],
+            ..Default::default()
+        };
+        assert!(
+            exact_circle_intersections(&flat, &tilted).is_none(),
+            "a genuinely-3D pair must fall back to the ordinary sweep, not guess a plane"
+        );
+    }
+
+    #[test]
+    fn exact_circle_intersections_is_none_when_circles_dont_meet() {
+        let near = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarCircle { center: [0.0, 0.0, 0.0], axis_x: [1.0, 0.0, 0.0], axis_y: [0.0, 1.0, 0.0], radius: 1.0 }],
+            ..Default::default()
+        };
+        let far = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarCircle { center: [100.0, 0.0, 0.0], axis_x: [1.0, 0.0, 0.0], axis_y: [0.0, 1.0, 0.0], radius: 1.0 }],
+            ..Default::default()
+        };
+        assert!(exact_circle_intersections(&near, &far).is_none());
+    }
+
+    #[test]
+    fn wire_circle_is_none_for_a_plain_line_wire() {
+        // A line wire carries no `TangentGeom::Circle`/`Arc` entry, so
+        // `wire_circle` (and the fast `exact_circle_intersections` path built
+        // on it) must not panic or, worse, silently misidentify a line as a
+        // circle — it should just decline, leaving the line-vs-circle case to
+        // the more general `exact_curve_intersections`, covered separately by
+        // `exact_curve_intersections_handles_a_line_against_a_circle`.
+        let line = WireModel {
+            points: vec![[0.0, 0.0, 0.0], [10.0, 0.0, 0.0]],
+            ..Default::default()
+        };
+        assert!(wire_circle(&line).is_none());
+        let circle = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarCircle { center: [0.0, 0.0, 0.0], axis_x: [1.0, 0.0, 0.0], axis_y: [0.0, 1.0, 0.0], radius: 4.0 }],
+            ..Default::default()
+        };
+        assert!(exact_circle_intersections(&line, &circle).is_none(), "line-vs-circle isn't this fast path's job — it's handled by exact_curve_intersections");
+    }
+
+    /// Each side's `contains_point` checks the candidate world point against
+    /// *that side's own* native axis_x/axis_y independently — there is no
+    /// step that re-expresses one arc's angle range in the other's frame —
+    /// so two arcs whose local frames are rotated relative to each other
+    /// must still resolve correctly, not just the common case where both
+    /// happen to share the same axis_x.
+    #[test]
+    fn exact_circle_intersections_handles_two_arcs_in_differently_rotated_frames() {
+        // Arc A: quarter circle 0..90°, axis_x along world +X.
+        let arc_a = WireModel {
+            tangent_geoms: vec![TangentGeom::Arc {
+                center: [0.0, 0.0, 0.0],
+                axis_x: [1.0, 0.0, 0.0],
+                axis_y: [0.0, 1.0, 0.0],
+                radius: 4.0,
+                start_angle: 0.0,
+                end_angle: std::f64::consts::FRAC_PI_2,
+            }],
+            ..Default::default()
+        };
+        // Arc B: same true geometry as the earlier "full circle" partner,
+        // but described in a frame rotated 90° from world axes (axis_x
+        // along world +Y, axis_y along world -X) — its own start/end angles
+        // are re-expressed accordingly so the arc still covers the same
+        // true half of the circle (the lower half, i.e. world angle
+        // 180..360°, which in this rotated frame is local angle 90..270°).
+        let arc_b = WireModel {
+            tangent_geoms: vec![TangentGeom::Arc {
+                center: [3.0, 0.0, 0.0],
+                axis_x: [0.0, 1.0, 0.0],
+                axis_y: [-1.0, 0.0, 0.0],
+                radius: 5.0,
+                start_angle: std::f64::consts::FRAC_PI_2,
+                end_angle: 3.0 * std::f64::consts::FRAC_PI_2,
+            }],
+            ..Default::default()
+        };
+        // True full-circle crossings are (0,4,0) [world angle 90° on B, so
+        // NOT on B's lower-half sweep] and (0,-4,0) [world angle 270°, IS on
+        // B's sweep, and also not on A's 0..90° sweep]. Independently
+        // filtering each side's own frame should therefore find nothing —
+        // proving the two arcs' angle checks aren't accidentally sharing or
+        // confusing each other's frame (a bug here would likely either
+        // wrongly accept one of the two points or wrongly accept both).
+        assert!(exact_circle_intersections(&arc_a, &arc_b).is_none());
+
+        // Flip A to cover the lower-right quadrant (270..360°) instead: now
+        // (0,-4,0) is on both A's and B's own sweep, independently checked
+        // in each one's own (differently rotated) frame.
+        let arc_a_lower = WireModel {
+            tangent_geoms: vec![TangentGeom::Arc {
+                center: [0.0, 0.0, 0.0],
+                axis_x: [1.0, 0.0, 0.0],
+                axis_y: [0.0, 1.0, 0.0],
+                radius: 4.0,
+                start_angle: 3.0 * std::f64::consts::FRAC_PI_2,
+                end_angle: std::f64::consts::TAU,
+            }],
+            ..Default::default()
+        };
+        let pts = exact_circle_intersections(&arc_a_lower, &arc_b).expect("both sweeps cover (0,-4,0)");
+        assert_eq!(pts.len(), 1);
+        assert!((pts[0] - DVec3::new(0.0, -4.0, 0.0)).length() < 1e-9, "got {:?}", pts[0]);
+    }
+
+    fn plain_line(a: [f64; 3], b: [f64; 3]) -> WireModel {
+        WireModel { points: vec![[a[0] as f32, a[1] as f32, a[2] as f32], [b[0] as f32, b[1] as f32, b[2] as f32]], points_low: vec![], ..Default::default() }
+    }
+
+    #[test]
+    fn exact_curve_intersections_handles_a_line_against_a_circle() {
+        let line = plain_line([-10.0, 0.0, 0.0], [10.0, 0.0, 0.0]);
+        let circle = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarCircle { center: [0.0, 0.0, 0.0], axis_x: [1.0, 0.0, 0.0], axis_y: [0.0, 1.0, 0.0], radius: 5.0 }],
+            ..Default::default()
+        };
+        let pts = exact_curve_intersections(&line, &circle).expect("a diameter line crosses its circle twice");
+        assert_eq!(pts.len(), 2);
+        let mut xs: Vec<f64> = pts.iter().map(|p| p.x).collect();
+        xs.sort_by(f64::total_cmp);
+        assert!((xs[0] - -5.0).abs() < 1e-9 && (xs[1] - 5.0).abs() < 1e-9, "expected x = -5 and +5, got {xs:?}");
+        for p in &pts {
+            assert!(p.y.abs() < 1e-9);
+        }
+    }
+
+    #[test]
+    fn exact_curve_intersections_handles_a_line_against_an_arcs_own_sweep() {
+        // Same arc as `exact_circle_intersections_respects_an_arcs_own_sweep`
+        // (0..90° of a radius-4 circle at the origin), crossed by a vertical
+        // line at x=0: the full circle would cross it at (0,4,0) and
+        // (0,-4,0), but only the first is on the arc's own sweep.
+        let arc = WireModel {
+            tangent_geoms: vec![TangentGeom::Arc {
+                center: [0.0, 0.0, 0.0],
+                axis_x: [1.0, 0.0, 0.0],
+                axis_y: [0.0, 1.0, 0.0],
+                radius: 4.0,
+                start_angle: 0.0,
+                end_angle: std::f64::consts::FRAC_PI_2,
+            }],
+            ..Default::default()
+        };
+        let line = plain_line([0.0, -10.0, 0.0], [0.0, 10.0, 0.0]);
+        let pts = exact_curve_intersections(&arc, &line).expect("the line crosses the arc's own sweep");
+        assert_eq!(pts.len(), 1);
+        assert!((pts[0] - DVec3::new(0.0, 4.0, 0.0)).length() < 1e-9);
+    }
+
+    #[test]
+    fn exact_curve_intersections_handles_a_line_against_an_ellipse() {
+        // x^2/16 + y^2/4 = 1 -- a vertical line at x=0 crosses it exactly at
+        // y = +-2.
+        let ellipse = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarEllipse {
+                center: [0.0, 0.0, 0.0],
+                major_axis: [4.0, 0.0, 0.0],
+                normal: [0.0, 0.0, 1.0],
+                minor_axis_ratio: 0.5,
+                start_param: 0.0,
+                end_param: std::f64::consts::TAU,
+            }],
+            ..Default::default()
+        };
+        let line = plain_line([0.0, -10.0, 0.0], [0.0, 10.0, 0.0]);
+        let pts = exact_curve_intersections(&ellipse, &line).expect("the line crosses the ellipse");
+        assert_eq!(pts.len(), 2);
+        for p in &pts {
+            assert!(p.x.abs() < 1e-9);
+            assert!((p.y.abs() - 2.0).abs() < 1e-9, "expected y = +-2, got {p:?}");
+        }
+    }
+
+    #[test]
+    fn exact_curve_intersections_handles_a_circle_against_a_full_ellipse() {
+        // x^2/25 + y^2/9 = 1 against a radius-3 circle at (6,0,0): computed
+        // independently (not via this module's own math) as crossing at
+        // exactly x = 3.75, y = +-sqrt(63)/4.
+        let ellipse = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarEllipse {
+                center: [0.0, 0.0, 0.0],
+                major_axis: [5.0, 0.0, 0.0],
+                normal: [0.0, 0.0, 1.0],
+                minor_axis_ratio: 0.6,
+                start_param: 0.0,
+                end_param: std::f64::consts::TAU,
+            }],
+            ..Default::default()
+        };
+        let circle = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarCircle { center: [6.0, 0.0, 0.0], axis_x: [1.0, 0.0, 0.0], axis_y: [0.0, 1.0, 0.0], radius: 3.0 }],
+            ..Default::default()
+        };
+        let pts = exact_curve_intersections(&ellipse, &circle).expect("the circle crosses the ellipse");
+        assert_eq!(pts.len(), 2);
+        let expected_y = (63.0_f64).sqrt() / 4.0;
+        for p in &pts {
+            assert!((p.x - 3.75).abs() < 1e-6, "expected x=3.75, got {p:?}");
+            assert!((p.y.abs() - expected_y).abs() < 1e-6, "expected y=+-{expected_y}, got {p:?}");
+        }
+    }
+
+    /// The critical case for `ellipse_param_in_frame`: two elliptical arcs
+    /// (here degenerate to circles via `minor_axis_ratio: 1.0`, so the
+    /// *expected* crossing angles are plain circle trigonometry, independently
+    /// computed) sharing the SAME numeric start/end parameter range but with
+    /// ANTI-PARALLEL normals. Reusing a native parameter value unchanged
+    /// across a normal flip would silently pick the mirror-image point
+    /// instead — this proves it doesn't.
+    #[test]
+    fn exact_curve_intersections_ellipse_arc_respects_normal_direction() {
+        // Full ellipse x^2/25 + y^2/9 = 1, and a radius-3 "ellipse" (ratio
+        // 1.0, i.e. a circle) at (6,0,0) — same pair as the full-ellipse
+        // test above, crossing at (3.75, +-1.9843...).
+        let ellipse = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarEllipse {
+                center: [0.0, 0.0, 0.0],
+                major_axis: [5.0, 0.0, 0.0],
+                normal: [0.0, 0.0, 1.0],
+                minor_axis_ratio: 0.6,
+                start_param: 0.0,
+                end_param: std::f64::consts::TAU,
+            }],
+            ..Default::default()
+        };
+        let deg = std::f64::consts::PI / 180.0;
+        let make_arc = |normal_z: f64| WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarEllipse {
+                center: [6.0, 0.0, 0.0],
+                major_axis: [3.0, 0.0, 0.0],
+                normal: [0.0, 0.0, normal_z],
+                minor_axis_ratio: 1.0,
+                start_param: 100.0 * deg,
+                end_param: 170.0 * deg,
+            }],
+            ..Default::default()
+        };
+
+        // normal=+Z: independently computed, param range [100,170]deg holds
+        // only the UPPER crossing's own angle (~138.59deg under +Z).
+        let plus = exact_curve_intersections(&ellipse, &make_arc(1.0)).expect("normal=+Z arc crosses the ellipse");
+        assert_eq!(plus.len(), 1);
+        assert!(plus[0].y > 0.0, "expected the upper point, got {:?}", plus[0]);
+        assert!((plus[0] - DVec3::new(3.75, (63.0_f64).sqrt() / 4.0, 0.0)).length() < 1e-6);
+
+        // normal=-Z, SAME numeric [100,170]deg range: independently computed
+        // to hold only the LOWER crossing's own angle under this flipped
+        // convention (~138.59deg under -Z maps to the lower world point).
+        let minus = exact_curve_intersections(&ellipse, &make_arc(-1.0)).expect("normal=-Z arc crosses the ellipse");
+        assert_eq!(minus.len(), 1);
+        assert!(minus[0].y < 0.0, "expected the lower point (normal flip must change which physical arc this is), got {:?}", minus[0]);
+        assert!((minus[0] - DVec3::new(3.75, -(63.0_f64).sqrt() / 4.0, 0.0)).length() < 1e-6);
+    }
+
+    /// Same reflection hazard as the ellipse test above, but for `curve_in_frame`'s
+    /// `TangentGeom::Arc` branch: this only runs when the *other* side of the pair
+    /// isn't itself a circle/arc (so `exact_circle_intersections`'s own, already
+    /// normal-agnostic `WireCircle` path doesn't intercept it first) — paired here
+    /// against the same full ellipse so the frame comes from the ellipse's plane
+    /// (normal = +Z) while the arc's own normal is anti-parallel to it.
+    #[test]
+    fn exact_curve_intersections_arc_respects_normal_direction_against_an_ellipse_frame() {
+        let ellipse = WireModel {
+            tangent_geoms: vec![TangentGeom::PlanarEllipse {
+                center: [0.0, 0.0, 0.0],
+                major_axis: [5.0, 0.0, 0.0],
+                normal: [0.0, 0.0, 1.0],
+                minor_axis_ratio: 0.6,
+                start_param: 0.0,
+                end_param: std::f64::consts::TAU,
+            }],
+            ..Default::default()
+        };
+        let deg = std::f64::consts::PI / 180.0;
+        // normal=-Z arc: axis_x/axis_y chosen so axis_x x axis_y = (0,0,-1),
+        // mirroring the ellipse test's make_arc(-1.0) exactly.
+        let arc_minus_z = WireModel {
+            tangent_geoms: vec![TangentGeom::Arc {
+                center: [6.0, 0.0, 0.0],
+                axis_x: [1.0, 0.0, 0.0],
+                axis_y: [0.0, -1.0, 0.0],
+                radius: 3.0,
+                start_angle: 100.0 * deg,
+                end_angle: 170.0 * deg,
+            }],
+            ..Default::default()
+        };
+        let pts = exact_curve_intersections(&ellipse, &arc_minus_z).expect("the arc crosses the ellipse");
+        assert_eq!(pts.len(), 1);
+        assert!(pts[0].y < 0.0, "expected the lower point (normal flip must change which physical arc this is), got {:?}", pts[0]);
+        assert!((pts[0] - DVec3::new(3.75, -(63.0_f64).sqrt() / 4.0, 0.0)).length() < 1e-6);
+    }
 }