forgekernel 0.9.2__tar.gz → 0.9.4__tar.gz

{forgekernel-0.9.2/src/forgekernel.egg-info → forgekernel-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgekernel
-Version: 0.9.2
+Version: 0.9.4
 Summary: Exact-arithmetic B-rep CAD kernel
 Author-email: Dan Willis <danielcwillis@gmail.com>
 Maintainer-email: Dan Willis <danielcwillis@gmail.com>

{forgekernel-0.9.2 → forgekernel-0.9.4}/src/forgekernel/__init__.py

@@ -4,4 +4,4 @@ Exact rational arithmetic for every topological decision; approximation
 only with tracked error bounds. See README for the three-oracle chain.
 """
 
-__version__ = "0.9.2"
+__version__ = "0.9.4"

{forgekernel-0.9.2 → forgekernel-0.9.4}/src/forgekernel/quadric.py

@@ -93,6 +93,35 @@ class Cyl:
         return lathe(profile, deflection, float(self.cx), float(self.cy))
 
 
+def _xy_inside_footprint(solid: Solid, px, py) -> bool:
+    """Exact: is (px, py) inside the solid's xy footprint?
+
+    The footprint boundary is the xy projection of the lateral (non-horizontal)
+    faces. Ray parity along +x with the half-open upward-crossing rule — all
+    rational, no tolerance. Needed because "the bore does not CROSS a lateral
+    wall" does not distinguish a bore strictly inside from one entirely
+    outside: neither crosses anything."""
+    segs = set()
+    for p in solid.polys:
+        n = p.plane.n
+        if n[0] == 0 and n[1] == 0:
+            continue                           # horizontal face: no footprint edge
+        m = len(p.verts)
+        for i in range(m):
+            a, b = p.verts[i], p.verts[(i + 1) % m]
+            if a[0] == b[0] and a[1] == b[1]:
+                continue                       # vertical edge: projects to a point
+            key = ((a[0], a[1]), (b[0], b[1]))
+            segs.add(key if key[0] <= key[1] else (key[1], key[0]))
+    inside = False
+    for (x1, y1), (x2, y2) in segs:
+        if (y1 > py) != (y2 > py):
+            xc = x1 + (py - y1) * (x2 - x1) / (y2 - y1)
+            if px < xc:
+                inside = not inside
+    return inside
+
+
 def _dist2_point_seg(px, py, ax, ay, bx, by) -> Fraction:
     """Exact squared distance from point to segment (all rational)."""
     dx, dy = bx - ax, by - ay
@@ -140,6 +169,12 @@ class DrilledSolid:
                     raise ValueError(
                         "bore crosses a lateral wall — general quadric "
                         "booleans arrive at K2.1")
+        # The wall check above proves the bore straddles no wall; it does NOT
+        # say which side it is on. Without this, a bore placed entirely outside
+        # the footprint is recorded as a phantom hole and its volume silently
+        # subtracted from a solid it never touches.
+        if not _xy_inside_footprint(self.base, c.cx, c.cy):
+            raise ValueError("bore misses the solid in xy (nothing to drill)")
         for o in self.bores:
             if o.cx == c.cx and o.cy == c.cy:
                 continue                       # coaxial stack (counterbore)
@@ -616,17 +651,23 @@ class AxisStack:
 
 class RevolveSolid:
     """A closed line-segment profile in the (r, z) half-plane revolved
-    360 degrees about the z axis. Green gives exact metrics:
-    V = pi * contour_integral(r^2 dz), each edge contributing
-    (z2-z1)(r1^2 + r1 r2 + r2^2)/3."""
+    360 degrees about a z-parallel axis through ``(cx, cy)``. Green gives
+    exact metrics: V = pi * contour_integral(r^2 dz), each edge contributing
+    (z2-z1)(r1^2 + r1 r2 + r2^2)/3. The profile need not touch r = 0 — an
+    annular loop is a tube (a bored cylinder), still exact."""
 
-    def __init__(self, loop_rz: list) -> None:
+    def __init__(self, loop_rz: list, cx=0, cy=0) -> None:
         self.loop = [(F(r), F(z)) for r, z in loop_rz]
+        self.cx, self.cy = F(cx), F(cy)
         if any(r < 0 for r, _ in self.loop):
             raise ValueError("revolve profile must stay at r >= 0")
         if self._v3() < 0:
             self.loop = list(reversed(self.loop))
 
+    def translated(self, x, y, z) -> "RevolveSolid":
+        return RevolveSolid([(r, zz + F(z)) for r, zz in self.loop],
+                            self.cx + F(x), self.cy + F(y))
+
     def _edges(self):
         n = len(self.loop)
         for i in range(n):
@@ -648,18 +689,53 @@ class RevolveSolid:
             num += dz * (z1 * (3 * r1 * r1 + 2 * r1 * r2 + r2 * r2)
                          + z2 * (r1 * r1 + 2 * r1 * r2 + 3 * r2 * r2)) / 12
         v3 = self._v3()
-        return (0.0, 0.0, float(num / v3 * 3) if v3 else 0.0)
+        return (float(self.cx), float(self.cy),
+                float(num / v3 * 3) if v3 else 0.0)
 
     def bbox(self):
         rmax = max(r for r, _ in self.loop)
         zs = [z for _, z in self.loop]
-        return ((-float(rmax), -float(rmax), float(min(zs))),
-                (float(rmax), float(rmax), float(max(zs))))
+        cx, cy = float(self.cx), float(self.cy)
+        return ((cx - float(rmax), cy - float(rmax), float(min(zs))),
+                (cx + float(rmax), cy + float(rmax), float(max(zs))))
 
     def tessellate(self, deflection: float = 0.2) -> dict:
         from forgekernel.tess import lathe
 
-        return lathe([(float(r), float(z)) for r, z in self.loop], deflection)
+        return lathe([(float(r), float(z)) for r, z in self.loop], deflection,
+                     float(self.cx), float(self.cy))
+
+
+def bore_cyl(cyl: "Cyl", bore: "Cyl") -> object:
+    """Cut a COAXIAL bore out of a z-cylinder, exactly.
+
+    A cylinder minus a coaxial cylindrical bore is still a solid of
+    revolution, so the result is a ``RevolveSolid`` whose (r, z) profile is
+    the cylinder's rectangle minus the bore's — exact in ℚ, with the volume
+    following in ℚ[π] from Green's theorem. Returns ``cyl`` unchanged when
+    the bore misses it in z. Raises ValueError for the cases that are not a
+    single revolved region (a bore floating strictly inside — a closed
+    cavity — or one that consumes the whole cylinder)."""
+    if bore.cx != cyl.cx or bore.cy != cyl.cy:
+        raise ValueError("bore is not coaxial with the cylinder — K2.3")
+    if bore.r >= cyl.r:
+        raise ValueError("bore is not narrower than the cylinder — K2.3")
+    z0, z1 = cyl.z0, cyl.z1
+    b0, b1 = max(bore.z0, z0), min(bore.z1, z1)
+    if b1 <= b0:
+        return cyl                              # bore misses in z: unchanged
+    R, rb = cyl.r, bore.r
+    if b0 <= z0 and b1 >= z1:                   # through bore -> annulus
+        loop = [(rb, z0), (R, z0), (R, z1), (rb, z1)]
+    elif b0 <= z0:                              # blind from the bottom
+        loop = [(rb, z0), (R, z0), (R, z1), (0, z1), (0, b1), (rb, b1)]
+    elif b1 >= z1:                              # blind from the top
+        loop = [(0, z0), (R, z0), (R, z1), (rb, z1), (rb, b0), (0, b0)]
+    else:
+        raise ValueError(
+            "bore floats strictly inside the cylinder (a closed cavity) — "
+            "general quadric booleans arrive at K2.3")
+    return RevolveSolid(loop, cyl.cx, cyl.cy)
 
 
 def _member_volume(m):
@@ -696,6 +772,59 @@ class DisjointUnion:
             _classify_pair(m, other)
         return DisjointUnion(self.members + [other])
 
+    def tessellate(self, deflection: float = 0.2) -> dict:
+        """Display mesh = the members' meshes merged. Valid as one mesh
+        because the members are disjoint (at most tangent), so the shells
+        never interpenetrate."""
+        verts: list = []
+        tris: list = []
+        for m in self.members:
+            if not hasattr(m, "tessellate"):    # bare Sphere/Cone: via a stack
+                m = AxisStack(m.cx, m.cy, [m])
+            try:
+                sub = m.tessellate(deflection)
+            except TypeError:                   # planar Solid: meshes exactly
+                sub = m.tessellate()
+            off = len(verts)
+            verts.extend(sub["vertices"])
+            tris.extend([a + off, b + off, c + off] for a, b, c in sub["triangles"])
+        return {"vertices": verts, "triangles": tris}
+
+    @classmethod
+    def _unchecked(cls, members: list) -> "DisjointUnion":
+        """Build without re-running the pairwise predicates — for members
+        derived from an already-validated union by an operation that can only
+        SHRINK them (see ``cut``)."""
+        u = cls.__new__(cls)
+        u.members = list(members)
+        return u
+
+    def cut(self, tool) -> "DisjointUnion":
+        """Subtract ``tool`` from every member: (A ∪ B) ∖ C = (A∖C) ∪ (B∖C).
+        Members that the tool misses come back unchanged. Disjointness is
+        preserved because cutting only shrinks a member — (A∖C) ∩ (B∖C) ⊆
+        A ∩ B, already proven measure-zero — so the result needs no
+        re-validation (and its members may now be other exact types)."""
+        from forgekernel.brep import Solid
+
+        out = []
+        for m in self.members:
+            if isinstance(m, Cyl) and isinstance(tool, Cyl):
+                out.append(bore_cyl(m, tool))
+            elif isinstance(m, (Solid, DrilledSolid)) and isinstance(tool, Cyl):
+                base = DrilledSolid(m, []) if isinstance(m, Solid) else m
+                try:
+                    out.append(base.cut(tool))
+                except ValueError as exc:
+                    if "misses the solid in" not in str(exc):
+                        raise                   # a real precondition violation
+                    out.append(m)               # tool misses this member (z or xy)
+            else:
+                raise ValueError(
+                    f"cut of {type(m).__name__} by {type(tool).__name__} in a "
+                    "disjoint union arrives at K2.3")
+        return DisjointUnion._unchecked(out)
+
     def volume(self) -> "PiVal":
         total = PiVal(0, 0)
         for m in self.members:
@@ -748,10 +877,12 @@ def _classify_pair(a, b) -> None:
         if za[1] <= zb[0] or zb[1] <= za[0]:
             return                            # disjoint in z
         d2 = (a.cx - b.cx) ** 2 + (a.cy - b.cy) ** 2
-        outer = (a.r + b.r) ** 2
-        inner = (a.r - b.r) ** 2
-        if d2 >= outer or d2 <= inner:
-            return                            # externally/internally clear
+        if d2 >= (a.r + b.r) ** 2:
+            return                            # externally clear (or tangent)
+        # NOTE: d2 <= (ra−rb)² is CONTAINMENT, not separation — these are solid
+        # cylinders, not tubes, so a nested one overlaps with positive measure
+        # (identical cylinders land here too, at d2 = 0). Treating it as clear
+        # silently doubled the volume; it must refuse.
         raise ValueError(
             "overlapping cylinders — general quadric booleans arrive at K2.3")
     # sphere / planar Solid
@@ -761,11 +892,20 @@ def _classify_pair(a, b) -> None:
     if isinstance(b, Sphere) and isinstance(a, Solid):
         _sphere_solid(b, a)
         return
+    # z-cylinder / planar Solid (a mounting boss standing on a face)
+    if isinstance(a, Cyl) and isinstance(b, Solid):
+        _cyl_solid(a, b)
+        return
+    if isinstance(b, Cyl) and isinstance(a, Solid):
+        _cyl_solid(b, a)
+        return
     # sphere / sphere
     if isinstance(a, Sphere) and isinstance(b, Sphere):
         d2 = (a.cx - b.cx) ** 2 + (a.cy - b.cy) ** 2 + (a.cz - b.cz) ** 2
-        if d2 >= (a.r + b.r) ** 2 or d2 <= (a.r - b.r) ** 2:
-            return
+        if d2 >= (a.r + b.r) ** 2:
+            return                            # externally clear (or tangent)
+        # containment (d2 ≤ (ra−rb)²) is an overlap, not a separation — see the
+        # cylinder note above; SphereOverlap already rejects it as "nesting".
         raise ValueError(
             "overlapping spheres — general quadric booleans arrive at K2.3")
     raise ValueError(
@@ -773,6 +913,28 @@ def _classify_pair(a, b) -> None:
         "at K2.3")
 
 
+def _require_convex(solid: "Solid", what: str) -> None:
+    """Raise unless every vertex is on the inward side of every face plane.
+
+    The separating-plane predicates below are sound ONLY for a convex solid: a
+    convex body is the intersection of its face half-spaces, so "outside one
+    face plane" implies "outside the solid". For a non-convex solid that
+    implication fails — a bore sitting inside an L-bracket's arm is outside the
+    plane of the other arm's face — and accepting it would silently double-count
+    the overlap. Exact (rational comparisons); refuses rather than guesses."""
+    planes, verts = {}, set()
+    for p in solid.polys:
+        planes.setdefault(p.plane.canonical(), (p.plane.n, p.plane.d))
+        verts.update(p.verts)
+    for n, dpl in planes.values():
+        for v in verts:
+            if dot(n, v) - dpl > 0:
+                raise ValueError(
+                    f"{what} against a non-convex solid — the separating-plane "
+                    "test is not sound there; general quadric booleans arrive "
+                    "at K2.3")
+
+
 def _sphere_solid(s: "Sphere", solid: "Solid") -> None:
     """Disjoint/tangent iff the sphere center lies on the far side of (or
     exactly on) some face plane by at least the radius — exact, sqrt-free:
@@ -780,6 +942,7 @@ def _sphere_solid(s: "Sphere", solid: "Solid") -> None:
     g² ≥ r²·(n·n) (both sides squared, exact). Convex-solid sufficient
     condition; a sphere separated from a convex solid is separated by one
     of its face planes."""
+    _require_convex(solid, "sphere")
     c = (s.cx, s.cy, s.cz)
     seen = set()
     for p in solid.polys:
@@ -795,6 +958,35 @@ def _sphere_solid(s: "Sphere", solid: "Solid") -> None:
         "sphere overlaps the solid — general quadric booleans arrive at K2.3")
 
 
+def _cyl_solid(c: "Cyl", solid: "Solid") -> None:
+    """Disjoint/tangent iff some face plane of the solid separates the
+    z-cylinder — exact and sqrt-free. For outward plane n·x = d, the
+    cylinder's minimum of n·x is
+
+        n_x·cx + n_y·cy + min(n_z·z0, n_z·z1) − r·√(n_x² + n_y²),
+
+    so the cylinder is clear of that plane iff A ≥ r·√(n_x²+n_y²) where
+    A = n_x·cx + n_y·cy + min(n_z·z0, n_z·z1) − d. Both sides are squared
+    (A ≥ 0 and A² ≥ r²·(n_x²+n_y²)) to stay in ℚ. A mounting boss standing
+    ON a face gives A = 0 exactly — tangent, measure-zero, admitted.
+    Sufficient for a convex solid (separating-plane argument); for a
+    non-convex one it is conservative, so it refuses rather than guesses."""
+    _require_convex(solid, "cylinder")
+    seen = set()
+    for p in solid.polys:
+        key = p.plane.canonical()
+        if key in seen:
+            continue
+        seen.add(key)
+        n, dpl = p.plane.n, p.plane.d
+        a = (n[0] * c.cx + n[1] * c.cy
+             + min(n[2] * c.z0, n[2] * c.z1) - dpl)
+        if a >= 0 and a * a >= c.r * c.r * (n[0] * n[0] + n[1] * n[1]):
+            return                            # separated by this face plane
+    raise ValueError(
+        "cylinder overlaps the solid — general quadric booleans arrive at K2.3")
+
+
 class RoundedBox:
     """An axis-aligned box with ALL edges and corners filleted radius r —
     the Minkowski sum of the inner core box (a-2r)x(b-2r)x(c-2r) with a

{forgekernel-0.9.2 → forgekernel-0.9.4/src/forgekernel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgekernel
-Version: 0.9.2
+Version: 0.9.4
 Summary: Exact-arithmetic B-rep CAD kernel
 Author-email: Dan Willis <danielcwillis@gmail.com>
 Maintainer-email: Dan Willis <danielcwillis@gmail.com>

{forgekernel-0.9.2 → forgekernel-0.9.4}/src/forgekernel.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ src/forgekernel.egg-info/SOURCES.txt
 src/forgekernel.egg-info/dependency_links.txt
 src/forgekernel.egg-info/requires.txt
 src/forgekernel.egg-info/top_level.txt
+tests/test_boss.py
 tests/test_hlr.py
 tests/test_k1_exact.py
 tests/test_k37_loft.py

forgekernel-0.9.4/tests/test_boss.py

@@ -0,0 +1,134 @@
+"""Bosses and bored cylinders — a z-cylinder standing on a planar face
+(tangent, measure-zero) and coaxial bores through solids of revolution.
+
+A cylinder minus a coaxial bore is still a solid of revolution, so the result
+stays an exact ℚ[π] object rather than degrading to a mesh.
+"""
+
+from __future__ import annotations
+
+import math
+from collections import defaultdict
+
+import pytest
+
+from forgekernel.brep import Solid
+from forgekernel.quadric import Cyl, DisjointUnion, RevolveSolid, bore_cyl
+
+
+def _nonmanifold(mesh):
+    ec = defaultdict(int)
+    for a, b, c in mesh["triangles"]:
+        for e in ((a, b), (b, c), (c, a)):
+            ec[tuple(sorted(e))] += 1
+    return sum(1 for n in ec.values() if n != 2)
+
+
+def test_boss_standing_on_a_plate_is_a_tangent_union() -> None:
+    # the cylinder's base sits EXACTLY on the plate's top face: contact is
+    # measure-zero, so the union volume is exactly the sum.
+    plate = Solid.box(30, 30, 3)
+    boss = Cyl(15, 15, 4, 3, 9)
+    u = DisjointUnion([plate, boss])
+    assert float(u.volume()) == pytest.approx(30 * 30 * 3 + math.pi * 16 * 6)
+
+
+def test_boss_sunk_into_the_plate_is_refused() -> None:
+    plate = Solid.box(30, 30, 3)
+    with pytest.raises(ValueError, match="overlaps the solid"):
+        DisjointUnion([plate, Cyl(15, 15, 4, 2, 9)])     # base below the top face
+
+
+def test_cylinder_beside_the_plate_is_separated_by_a_side_face() -> None:
+    plate = Solid.box(10, 10, 10)
+    DisjointUnion([plate, Cyl(20, 5, 3, 0, 10)])         # clear in x: no raise
+
+
+def test_non_convex_solids_refuse_rather_than_double_count() -> None:
+    """SOUNDNESS: the separating-plane test only holds for a convex solid.
+
+    In an L-prism, a bore buried in one arm lies outside the plane of the
+    OTHER arm's face — so a plane-only test would call it disjoint and silently
+    add its volume twice. Both predicates must refuse instead."""
+    from forgekernel import kernel as fk
+    from forgekernel.quadric import Sphere
+
+    ell = fk.prism([(0, 0), (10, 0), (10, 4), (4, 4), (4, 10), (0, 10)], 5)
+    for buried in (Cyl(2, 7, 1, 1, 4), Sphere(2, 7, 2, 1)):
+        with pytest.raises(ValueError, match="non-convex"):
+            DisjointUnion([ell, buried])
+
+
+def test_a_bore_outside_the_footprint_is_not_a_phantom_hole() -> None:
+    """SOUNDNESS: "the bore crosses no lateral wall" does not mean "the bore is
+    inside" — a bore entirely OUTSIDE the footprint crosses nothing either. It
+    used to be recorded as a hole, silently deleting volume from a solid the
+    tool never touched (a Ø4 tool 40 mm away removed 125.66 mm³ from a box)."""
+    from forgekernel.quadric import DrilledSolid
+
+    box = Solid.box(10, 10, 10)
+    with pytest.raises(ValueError, match="misses the solid in xy"):
+        DrilledSolid(box, []).cut(Cyl(50, 50, 2, 0, 10))
+    inside = DrilledSolid(box, []).cut(Cyl(5, 5, 2, 0, 10))     # a real hole
+    assert float(inside.volume()) == pytest.approx(1000 - math.pi * 4 * 10)
+
+
+def test_cut_leaves_members_the_tool_misses_untouched() -> None:
+    # a post standing 50 mm clear of a plate; boring the POST must not shrink
+    # the plate (the tool never enters it in xy).
+    plate, post = Solid.box(100, 100, 10), Cyl(150, 50, 8, 0, 20)
+    out = DisjointUnion([plate, post]).cut(Cyl(150, 50, 4, 0, 20))
+    assert float(out.volume()) == pytest.approx(100000 + (64 - 16) * 20 * math.pi)
+
+
+def test_coaxial_bore_of_a_cylinder_is_an_exact_revolve() -> None:
+    cyl = Cyl(0, 0, 10, 0, 2)
+    washer = bore_cyl(cyl, Cyl(0, 0, 4, 0, 2))           # through bore: annulus
+    assert isinstance(washer, RevolveSolid)
+    assert float(washer.volume()) == pytest.approx(math.pi * (100 - 16) * 2)
+    mesh = washer.tessellate(0.05)
+    assert _nonmanifold(mesh) == 0                       # watertight tube
+
+    blind = bore_cyl(Cyl(0, 0, 4, 3, 9), Cyl(0, 0, 1, 4, 9))   # blind from top
+    assert float(blind.volume()) == pytest.approx(math.pi * 16 * 6 - math.pi * 1 * 5)
+
+    up = bore_cyl(Cyl(0, 0, 4, 0, 6), Cyl(0, 0, 1, -5, 2))     # blind from below
+    assert float(up.volume()) == pytest.approx(math.pi * 16 * 6 - math.pi * 1 * 2)
+
+
+def test_bore_that_misses_in_z_leaves_the_cylinder_unchanged() -> None:
+    cyl = Cyl(0, 0, 4, 0, 6)
+    assert bore_cyl(cyl, Cyl(0, 0, 1, 10, 12)) is cyl
+
+
+def test_non_representable_bores_refuse() -> None:
+    cyl = Cyl(0, 0, 4, 0, 6)
+    with pytest.raises(ValueError, match="not coaxial"):
+        bore_cyl(cyl, Cyl(1, 0, 1, 0, 6))
+    with pytest.raises(ValueError, match="not narrower"):
+        bore_cyl(cyl, Cyl(0, 0, 4, 0, 6))
+    with pytest.raises(ValueError, match="closed cavity"):
+        bore_cyl(cyl, Cyl(0, 0, 1, 2, 4))                # floats strictly inside
+
+
+def test_cut_distributes_over_a_disjoint_union() -> None:
+    # the boss + pilot: (plate ∪ boss) ∖ pilot, pilot blind in the boss only
+    plate = Solid.box(30, 30, 3)
+    u = DisjointUnion([plate, Cyl(15, 15, 4, 3, 9)])
+    out = u.cut(Cyl(15, 15, 1, 4, 9))
+    expect = 30 * 30 * 3 + math.pi * 16 * 6 - math.pi * 1 * 5
+    assert float(out.volume()) == pytest.approx(expect)
+    # the plate member is untouched (the tool misses it in z)
+    assert any(isinstance(m, Solid) for m in out.members)
+    assert _nonmanifold(out.tessellate(0.05)) == 0
+
+
+def test_revolve_solid_can_sit_off_axis() -> None:
+    loop = [(0, 0), (2, 0), (2, 5), (0, 5)]              # a plain cylinder r=2
+    at_origin, moved = RevolveSolid(loop), RevolveSolid(loop, 7, -3)
+    assert float(at_origin.volume()) == float(moved.volume())
+    assert moved.centroid_f()[0] == pytest.approx(7.0)
+    assert moved.centroid_f()[1] == pytest.approx(-3.0)
+    lo, hi = moved.bbox()
+    assert (lo[0], hi[0]) == pytest.approx((5.0, 9.0))
+    assert (lo[1], hi[1]) == pytest.approx((-5.0, -1.0))

{forgekernel-0.9.2 → forgekernel-0.9.4}/tests/test_k1_exact.py

@@ -270,11 +270,26 @@ def test_disjoint_in_z_passes_despite_close_axes() -> None:
     assert u.volume() == PiVal(0, 1000)
 
 
-def test_internally_tangent_cylinders_exact() -> None:
+def test_internally_tangent_cylinders_are_an_overlap_not_a_union() -> None:
+    """INTERNAL tangency of two SOLID cylinders is containment, not disjointness.
+
+    r=10 at the origin and r=4 at (6,0): d² = 36 = (10−4)², so they touch at
+    (10,0) — but the small cylinder lies wholly INSIDE the big one (its farthest
+    point is 6+4 = 10 = the big radius) and their z-ranges coincide. The union is
+    therefore just the big cylinder, 800π — NOT 928π. An earlier version of this
+    test asserted 928π, and that is what let ``_classify_pair`` admit nested
+    cylinders into a DisjointUnion and silently double-count the overlap. Only
+    EXTERNAL separation (d² ≥ (ra+rb)²) certifies disjointness.
+    """
+    import pytest
+
     from forgekernel.quadric import Cyl, DisjointUnion, PiVal
 
-    # r=10 and r=4, centers 6 apart: d^2 = 36 = (10-4)^2 internally tangent
-    u = DisjointUnion([Cyl.make(10, 8), Cyl.make(4, 8).translated(6, 0, 0)])
+    with pytest.raises(ValueError, match="overlapping cylinders"):
+        DisjointUnion([Cyl.make(10, 8), Cyl.make(4, 8).translated(6, 0, 0)])
+
+    # externally tangent (d² = (ra+rb)²) IS measure-zero contact: exact sum
+    u = DisjointUnion([Cyl.make(10, 8), Cyl.make(4, 8).translated(14, 0, 0)])
     assert u.volume() == PiVal(0, (100 + 16) * 8)