Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

89.4 KB
Raw Blame
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Geometry.Curves;
using Aetheris.Kernel.Core.Geometry.Surfaces;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Numerics;
using Aetheris.Kernel.Core.Results;
using Aetheris.Kernel.Core.Topology;
using Aetheris.Kernel.Core.Brep.Features;
using Aetheris.Kernel.Core.Brep.Recipes;
using Aetheris.Kernel.Core.Brep.Surgery;

namespace Aetheris.Kernel.Core.Brep.Boolean;

public static class BrepBooleanBoxCylinderHoleBuilder
{
    public static KernelResult<BrepBody> BuildAnalyticHole(AxisAlignedBoxExtents outer, AnalyticSurface surface, ToleranceContext tolerance)
    {
        var composition = new SafeBooleanComposition(outer, []);
        if (!BrepBooleanSafeComposition.TryAppend(composition, surface, tolerance, out var updatedComposition, out var diagnostic))
        {
            return KernelResult<BrepBody>.Failure([diagnostic!.ToKernelDiagnostic()]);
        }

        return BuildComposition(updatedComposition, tolerance);
    }

    public static KernelResult<BrepBody> BuildComposition(SafeBooleanComposition composition, ToleranceContext tolerance,
        Action<string, FaceId>? onConstructedHoleWall = null, Action<string, FaceId>? onConstructedHostFace = null)
    {
        ArgumentNullException.ThrowIfNull(composition);
        _ = tolerance;
        if (composition.RootDescriptor.Kind == SafeBooleanRootKind.Cylinder)
        {
            if (composition.OpenSlots is { Count: > 0 })
            {
                return BrepBooleanCylinderOpenSlotBuilder.Build(composition, tolerance);
            }

            return CreateBoundedCylinderRootHoleChainBody(composition, tolerance);
        }

        if (composition.RootDescriptor.Kind == SafeBooleanRootKind.Box
            && composition.Holes.Count == 1
            && composition.Holes[0].SpanKind == SupportedBooleanHoleSpanKind.Through
            && composition.Holes[0].Surface.Kind == AnalyticSurfaceKind.Cylinder)
        {
            return ThroughHoleConstructionRecipe.Execute(new(
                composition.RootDescriptor,
                composition.Holes[0],
                composition,
                tolerance));
        }

        if (composition.Holes.Count == 1
            && composition.Holes[0].Surface.Kind == AnalyticSurfaceKind.Sphere
            && composition.Holes[0].Surface.Sphere is RecognizedSphere sphere)
        {
            if (composition.Holes[0].SpanKind == SupportedBooleanHoleSpanKind.Contained)
            {
                return CreateComposedContainedSphereCavityBody(composition.OuterBox, sphere);
            }

            if (composition.Holes[0].SpanKind is SupportedBooleanHoleSpanKind.BlindFromTop or SupportedBooleanHoleSpanKind.BlindFromBottom)
            {
                return CreateComposedSphereOpeningCavityBody(composition.OuterBox, sphere, composition.Holes[0], composition);
            }

            return KernelResult<BrepBody>.Failure([
                new BooleanDiagnostic(
                    BooleanDiagnosticCode.UnsupportedAnalyticSurfaceKind,
                    new BooleanDiagnosticContext(BooleanOperation.Subtract).FormatMessage("bounded sphere subtract supports only contained or one-sided exterior-opening spherical cavities."),
                    "BrepBoolean.AnalyticHole.UnsupportedAnalyticSurfaceKind").ToKernelDiagnostic(),
            ]);
        }

        if (composition.Holes.Count == 1
            && composition.Holes[0].SpanKind == SupportedBooleanHoleSpanKind.Contained
            && composition.Holes[0].Surface.Kind == AnalyticSurfaceKind.Cylinder
            && composition.Holes[0].Surface.Cylinder is RecognizedCylinder containedCylinder)
        {
            return CreateComposedContainedCylinderCavityBody(composition.OuterBox, containedCylinder, composition);
        }

        if (composition.Holes.Any(hole => hole.Surface.Kind == AnalyticSurfaceKind.Sphere))
        {
            return KernelResult<BrepBody>.Failure([
                new BooleanDiagnostic(
                    BooleanDiagnosticCode.UnsupportedAnalyticSurfaceKind,
                    new BooleanDiagnosticContext(BooleanOperation.Subtract).FormatMessage("safe subtract composition supports exactly one spherical cavity operation and does not support mixed sphere continuation with other tools."),
                    "BrepBoolean.AnalyticHole.UnsupportedAnalyticSurfaceKind").ToKernelDiagnostic(),
            ]);
        }

        if (composition.Holes.Count == 2
            && composition.Holes.Any(h => h.IsBlind)
            && IsCoaxialHolePair(composition.Holes[0], composition.Holes[1], tolerance))
        {
            if (BrepBooleanCoaxialCountersinkSubtractFamily.TryClassifyPair(
                composition.OuterBox,
                composition.Holes[0],
                composition.Holes[1],
                tolerance,
                out var countersinkProfile,
                out var countersinkDiagnostic))
            {
                return CreateSteppedCoaxialCountersinkBody(composition, countersinkProfile);
            }

            if (countersinkDiagnostic is not null)
            {
                return KernelResult<BrepBody>.Failure([countersinkDiagnostic.ToKernelDiagnostic()]);
            }

            if (BrepBooleanCoaxialSubtractStackFamily.TryClassifyPair(
                composition.OuterBox,
                composition.Holes[0],
                composition.Holes[1],
                tolerance,
                out var steppedProfile,
                out var steppedDiagnostic))
            {
                return CreateSteppedCoaxialCylinderBody(composition, steppedProfile);
            }

            if (steppedDiagnostic is not null)
            {
                return KernelResult<BrepBody>.Failure([steppedDiagnostic.ToKernelDiagnostic()]);
            }
        }

        return CreateComposedThroughHoleBody(composition, tolerance, onConstructedHoleWall, onConstructedHostFace);
    }

    /// <summary>
    /// Recipe realization and rollback seam for the already-recognized canonical
    /// box/cylinder through-hole. This method performs no operand recognition.
    /// </summary>
    internal static KernelResult<BrepBody> BuildRecognizedThroughHoleTopology(
        SafeBooleanComposition composition,
        ToleranceContext tolerance)
        => CreateComposedThroughHoleBody(composition, tolerance);

    /// <summary>Pre-M4 callable path retained for byte/topology parity tests.</summary>
    internal static KernelResult<BrepBody> BuildRecognizedThroughHoleLegacy(
        SafeBooleanComposition composition,
        ToleranceContext tolerance)
        => CreateComposedThroughHoleBody(composition, tolerance);

    private static bool IsCoaxialHolePair(in SupportedBooleanHole first, in SupportedBooleanHole second, ToleranceContext tolerance)
    {
        var deltaX = first.CenterX - second.CenterX;
        var deltaY = first.CenterY - second.CenterY;
        return ToleranceMath.AlmostZero(deltaX, tolerance)
            && ToleranceMath.AlmostZero(deltaY, tolerance);
    }

    private static KernelResult<BrepBody> CreateBoundedCylinderRootHoleChainBody(SafeBooleanComposition composition, ToleranceContext tolerance)
    {
        if (composition.RootDescriptor.Cylinder is not RecognizedCylinder rootCylinder
            || composition.Holes.Count < 1
            || composition.Holes.Any(hole => hole.Surface.Kind != AnalyticSurfaceKind.Cylinder))
        {
            return KernelResult<BrepBody>.Failure([
                new BooleanDiagnostic(
                    BooleanDiagnosticCode.NotFullySpanning,
                    new BooleanDiagnosticContext(BooleanOperation.Subtract).FormatMessage("cylinder-root safe rebuild in F3 requires a through-hole cylinder chain."),
                    "BrepBoolean.AnalyticHole.CylinderRootUnsupportedComposition").ToKernelDiagnostic(),
            ]);
        }

        if (composition.Holes.Any(hole => hole.IsBlind))
        {
            var blindHoles = composition.Holes.Where(hole => hole.IsBlind).ToArray();
            if (blindHoles.Length != 1
                || composition.Holes.Count != 1
                || !ToleranceMath.AlmostZero(blindHoles[0].CenterX, tolerance)
                || !ToleranceMath.AlmostZero(blindHoles[0].CenterY, tolerance))
            {
                return KernelResult<BrepBody>.Failure([
                    new BooleanDiagnostic(
                        BooleanDiagnosticCode.HoleInterference,
                        new BooleanDiagnosticContext(BooleanOperation.Subtract).FormatMessage("bounded cylinder-root blind-bore rebuild supports only one coaxial blind bore in this milestone."),
                        "BrepBoolean.AnalyticHole.HoleInterference").ToKernelDiagnostic(),
                ]);
            }

            return CreateCylinderRootBlindBoreBody(rootCylinder, blindHoles[0], composition);
        }

        var rootCenter = new Point3D(
            (rootCylinder.MinCenter.X + rootCylinder.MaxCenter.X) * 0.5d,
            (rootCylinder.MinCenter.Y + rootCylinder.MaxCenter.Y) * 0.5d,
            (rootCylinder.MinCenter.Z + rootCylinder.MaxCenter.Z) * 0.5d);

        var outer = BrepPrimitives.CreateCylinder(rootCylinder.Radius, rootCylinder.Height);
        if (!outer.IsSuccess)
        {
            return KernelResult<BrepBody>.Failure(outer.Diagnostics);
        }

        var innerShells = new List<BrepBody>(composition.Holes.Count);
        foreach (var hole in composition.Holes)
        {
            var localCenter = new Point3D(hole.CenterX - rootCenter.X, hole.CenterY - rootCenter.Y, rootCylinder.Height * 0.5d);
            var holeShell = BrepPrimitives.CreateCylinder(hole.BottomRadius, rootCylinder.Height);
            if (!holeShell.IsSuccess)
            {
                return KernelResult<BrepBody>.Failure(holeShell.Diagnostics);
            }

            var transformedHoleShell = TranslateBody(holeShell.Value, new Vector3D(localCenter.X, localCenter.Y, localCenter.Z));
            innerShells.Add(transformedHoleShell);
        }

        var merged = MergeOuterAndInnerShells(outer.Value, innerShells);
        var bodyWithComposition = TranslateMergedBody(merged, rootCenter, composition);
        var validation = BrepBindingValidator.Validate(bodyWithComposition, requireAllEdgeAndFaceBindings: true);
        return validation.IsSuccess
            ? KernelResult<BrepBody>.Success(bodyWithComposition, validation.Diagnostics)
            : KernelResult<BrepBody>.Failure(validation.Diagnostics);
    }

    private static KernelResult<BrepBody> CreateCylinderRootBlindBoreBody(
        in RecognizedCylinder rootCylinder,
        in SupportedBooleanHole hole,
        SafeBooleanComposition composition)
    {
        var entryFromTop = hole.SpanKind == SupportedBooleanHoleSpanKind.BlindFromTop;
        var rootHeight = rootCylinder.Height;
        var halfHeight = rootHeight * 0.5d;
        var rootMinZ = System.Math.Min(rootCylinder.MinCenter.Z, rootCylinder.MaxCenter.Z);
        var rootMaxZ = System.Math.Max(rootCylinder.MinCenter.Z, rootCylinder.MaxCenter.Z);
        var rootCenterZ = (rootMinZ + rootMaxZ) * 0.5d;

        var entryZ = entryFromTop ? rootMaxZ : rootMinZ;
        var blindBottomZ = hole.EndZ;
        var entryLocalZ = entryZ - rootCenterZ;
        var blindBottomLocalZ = blindBottomZ - rootCenterZ;

        var builder = new TopologyBuilder();
        var seamStart = builder.AddVertex();
        var seamEnd = builder.AddVertex();
        var topVertex = builder.AddVertex();
        var bottomVertex = builder.AddVertex();
        var boreEntryVertex = builder.AddVertex();
        var boreBottomVertex = builder.AddVertex();
        var boreSeamEntry = builder.AddVertex();
        var boreSeamBottom = builder.AddVertex();

        var outerSeam = builder.AddEdge(seamStart, seamEnd);
        var topCircle = builder.AddEdge(topVertex, topVertex);
        var bottomCircle = builder.AddEdge(bottomVertex, bottomVertex);
        var boreEntryCircle = builder.AddEdge(boreEntryVertex, boreEntryVertex);
        var boreBottomCircle = builder.AddEdge(boreBottomVertex, boreBottomVertex);
        var boreSeam = builder.AddEdge(boreSeamEntry, boreSeamBottom);

        var outerSideFace = builder.AddFace([AddLoop(builder, [Forward(outerSeam), Forward(topCircle), Reversed(outerSeam), Reversed(bottomCircle)])]);
        var topFace = entryFromTop
            ? builder.AddFace([AddLoop(builder, [Reversed(topCircle)]), AddLoop(builder, [Forward(boreEntryCircle)])])
            : builder.AddFace([AddLoop(builder, [Reversed(topCircle)])]);
        var bottomFace = entryFromTop
            ? builder.AddFace([AddLoop(builder, [Forward(bottomCircle)])])
            : builder.AddFace([AddLoop(builder, [Forward(bottomCircle)]), AddLoop(builder, [Reversed(boreEntryCircle)])]);
        var boreWallFace = builder.AddFace([AddLoop(builder, [Forward(boreSeam), Reversed(boreEntryCircle), Reversed(boreSeam), Forward(boreBottomCircle)])]);
        var boreBottomFace = builder.AddFace([AddLoop(builder, [Forward(boreBottomCircle)])]);

        var shell = builder.AddShell([outerSideFace, topFace, bottomFace, boreWallFace, boreBottomFace]);
        builder.AddBody([shell]);

        var geometry = new BrepGeometryStore();
        var zAxis = Direction3D.Create(new Vector3D(0d, 0d, 1d));
        var xAxis = Direction3D.Create(new Vector3D(1d, 0d, 0d));
        var yAxis = Direction3D.Create(new Vector3D(0d, 1d, 0d));
        var downAxis = Direction3D.Create(new Vector3D(0d, 0d, -1d));

        geometry.AddCurve(new CurveGeometryId(1), CurveGeometry.FromLine(new Line3Curve(new Point3D(rootCylinder.Radius, 0d, -halfHeight), zAxis)));
        geometry.AddCurve(new CurveGeometryId(2), CurveGeometry.FromCircle(new Circle3Curve(new Point3D(0d, 0d, halfHeight), zAxis, rootCylinder.Radius, xAxis)));
        geometry.AddCurve(new CurveGeometryId(3), CurveGeometry.FromCircle(new Circle3Curve(new Point3D(0d, 0d, -halfHeight), zAxis, rootCylinder.Radius, xAxis)));
        geometry.AddCurve(new CurveGeometryId(4), CurveGeometry.FromCircle(new Circle3Curve(new Point3D(0d, 0d, entryLocalZ), zAxis, hole.BottomRadius, xAxis)));
        geometry.AddCurve(new CurveGeometryId(5), CurveGeometry.FromCircle(new Circle3Curve(new Point3D(0d, 0d, blindBottomLocalZ), zAxis, hole.BottomRadius, xAxis)));
        geometry.AddCurve(new CurveGeometryId(6), CurveGeometry.FromLine(new Line3Curve(new Point3D(hole.BottomRadius, 0d, System.Math.Min(entryLocalZ, blindBottomLocalZ)), zAxis)));

        geometry.AddSurface(new SurfaceGeometryId(1), SurfaceGeometry.FromCylinder(new CylinderSurface(new Point3D(0d, 0d, -halfHeight), zAxis, rootCylinder.Radius, xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(2), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, 0d, halfHeight), zAxis, xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(3), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, 0d, -halfHeight), downAxis, yAxis)));
        geometry.AddSurface(new SurfaceGeometryId(4), SurfaceGeometry.FromCylinder(new CylinderSurface(new Point3D(0d, 0d, System.Math.Min(entryLocalZ, blindBottomLocalZ)), zAxis, hole.BottomRadius, xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(5), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, 0d, blindBottomLocalZ), entryFromTop ? zAxis : downAxis, xAxis)));

        var bindings = new BrepBindingModel();
        bindings.AddEdgeBinding(new EdgeGeometryBinding(outerSeam, new CurveGeometryId(1), new ParameterInterval(0d, rootHeight)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(topCircle, new CurveGeometryId(2), new ParameterInterval(0d, 2d * double.Pi)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(bottomCircle, new CurveGeometryId(3), new ParameterInterval(0d, 2d * double.Pi)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(boreEntryCircle, new CurveGeometryId(4), new ParameterInterval(0d, 2d * double.Pi)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(boreBottomCircle, new CurveGeometryId(5), new ParameterInterval(0d, 2d * double.Pi)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(boreSeam, new CurveGeometryId(6), new ParameterInterval(0d, System.Math.Abs(entryLocalZ - blindBottomLocalZ))));

        bindings.AddFaceBinding(new FaceGeometryBinding(outerSideFace, new SurfaceGeometryId(1)));
        bindings.AddFaceBinding(new FaceGeometryBinding(topFace, new SurfaceGeometryId(2)));
        bindings.AddFaceBinding(new FaceGeometryBinding(bottomFace, new SurfaceGeometryId(3)));
        bindings.AddFaceBinding(new FaceGeometryBinding(boreWallFace, new SurfaceGeometryId(4)));
        bindings.AddFaceBinding(new FaceGeometryBinding(boreBottomFace, new SurfaceGeometryId(5)));

        var localBody = new BrepBody(builder.Model, geometry, bindings);
        var translated = TranslateBody(localBody, new Vector3D(0d, 0d, rootCenterZ));
        var bodyWithComposition = new BrepBody(
            translated.Topology,
            translated.Geometry,
            translated.Bindings,
            GetVertexPoints(translated),
            composition,
            translated.ShellRepresentation);
        var validation = BrepBindingValidator.Validate(bodyWithComposition, requireAllEdgeAndFaceBindings: true);
        return validation.IsSuccess
            ? KernelResult<BrepBody>.Success(bodyWithComposition, validation.Diagnostics)
            : KernelResult<BrepBody>.Failure(validation.Diagnostics);
    }

    private static KernelResult<BrepBody> CreateComposedContainedSphereCavityBody(AxisAlignedBoxExtents outerBox, in RecognizedSphere sphere)
    {
        var outer = BrepBooleanBoxRecognition.CreateBoxFromExtents(outerBox);
        if (!outer.IsSuccess)
        {
            return KernelResult<BrepBody>.Failure(outer.Diagnostics);
        }

        var innerResult = CreateSphereShell(sphere);
        if (!innerResult.IsSuccess)
        {
            return KernelResult<BrepBody>.Failure(innerResult.Diagnostics);
        }

        var merged = MergeOuterAndInnerShell(outer.Value, innerResult.Value);
        var validation = BrepBindingValidator.Validate(merged, requireAllEdgeAndFaceBindings: true);
        return validation.IsSuccess
            ? KernelResult<BrepBody>.Success(merged, validation.Diagnostics)
            : KernelResult<BrepBody>.Failure(validation.Diagnostics);
    }

    private static KernelResult<BrepBody> CreateComposedSphereOpeningCavityBody(
        AxisAlignedBoxExtents outerBox,
        in RecognizedSphere sphere,
        in SupportedBooleanHole hole,
        SafeBooleanComposition composition)
    {
        if (hole.SpanKind is not (SupportedBooleanHoleSpanKind.BlindFromTop or SupportedBooleanHoleSpanKind.BlindFromBottom))
        {
            return KernelResult<BrepBody>.Failure([
                new BooleanDiagnostic(
                    BooleanDiagnosticCode.UnsupportedAnalyticSurfaceKind,
                    new BooleanDiagnosticContext(BooleanOperation.Subtract).FormatMessage("sphere opening builder requires BlindFromTop or BlindFromBottom span classification."),
                    "BrepBoolean.AnalyticHole.UnsupportedAnalyticSurfaceKind").ToKernelDiagnostic(),
            ]);
        }

        var openingPlaneZ = hole.SpanKind == SupportedBooleanHoleSpanKind.BlindFromTop ? outerBox.MaxZ : outerBox.MinZ;
        var delta = openingPlaneZ - sphere.Center.Z;
        var openingRadius = System.Math.Sqrt(System.Math.Max(0d, (sphere.Radius * sphere.Radius) - (delta * delta)));

        var builder = new TopologyBuilder();
        var v1 = builder.AddVertex();
        var v2 = builder.AddVertex();
        var v3 = builder.AddVertex();
        var v4 = builder.AddVertex();
        var v5 = builder.AddVertex();
        var v6 = builder.AddVertex();
        var v7 = builder.AddVertex();
        var v8 = builder.AddVertex();
        var openingVertex = builder.AddVertex();

        var e1 = builder.AddEdge(v1, v2);
        var e2 = builder.AddEdge(v2, v3);
        var e3 = builder.AddEdge(v3, v4);
        var e4 = builder.AddEdge(v4, v1);
        var e5 = builder.AddEdge(v5, v6);
        var e6 = builder.AddEdge(v6, v7);
        var e7 = builder.AddEdge(v7, v8);
        var e8 = builder.AddEdge(v8, v5);
        var e9 = builder.AddEdge(v1, v5);
        var e10 = builder.AddEdge(v2, v6);
        var e11 = builder.AddEdge(v3, v7);
        var e12 = builder.AddEdge(v4, v8);
        var openingCircle = builder.AddEdge(openingVertex, openingVertex);

        var bottomLoops = new List<LoopId> { AddLoop(builder, [Forward(e1), Forward(e2), Forward(e3), Forward(e4)]) };
        var topLoops = new List<LoopId> { AddLoop(builder, [Forward(e5), Forward(e6), Forward(e7), Forward(e8)]) };
        if (hole.SpanKind == SupportedBooleanHoleSpanKind.BlindFromTop)
        {
            topLoops.Add(AddLoop(builder, [Forward(openingCircle)]));
        }
        else
        {
            bottomLoops.Add(AddLoop(builder, [Reversed(openingCircle)]));
        }

        var bottomFace = builder.AddFace(bottomLoops);
        var topFace = builder.AddFace(topLoops);
        var xMinFace = builder.AddFace([AddLoop(builder, [Forward(e1), Forward(e10), Reversed(e5), Reversed(e9)])]);
        var xMaxFace = builder.AddFace([AddLoop(builder, [Forward(e2), Forward(e11), Reversed(e6), Reversed(e10)])]);
        var yMaxFace = builder.AddFace([AddLoop(builder, [Forward(e3), Forward(e12), Reversed(e7), Reversed(e11)])]);
        var yMinFace = builder.AddFace([AddLoop(builder, [Forward(e4), Forward(e9), Reversed(e8), Reversed(e12)])]);
        var sphereFace = builder.AddFace([AddLoop(builder, [Forward(openingCircle)])]);

        var shell = builder.AddShell([bottomFace, topFace, xMinFace, xMaxFace, yMaxFace, yMinFace, sphereFace]);
        builder.AddBody([shell]);

        var geometry = new BrepGeometryStore();
        var p1 = new Point3D(outerBox.MinX, outerBox.MinY, outerBox.MinZ);
        var p2 = new Point3D(outerBox.MaxX, outerBox.MinY, outerBox.MinZ);
        var p3 = new Point3D(outerBox.MaxX, outerBox.MaxY, outerBox.MinZ);
        var p4 = new Point3D(outerBox.MinX, outerBox.MaxY, outerBox.MinZ);
        var p5 = new Point3D(outerBox.MinX, outerBox.MinY, outerBox.MaxZ);
        var p6 = new Point3D(outerBox.MaxX, outerBox.MinY, outerBox.MaxZ);
        var p7 = new Point3D(outerBox.MaxX, outerBox.MaxY, outerBox.MaxZ);
        var p8 = new Point3D(outerBox.MinX, outerBox.MaxY, outerBox.MaxZ);

        var zAxis = Direction3D.Create(new Vector3D(0d, 0d, 1d));
        var xAxis = Direction3D.Create(new Vector3D(1d, 0d, 0d));
        var yAxis = Direction3D.Create(new Vector3D(0d, 1d, 0d));
        var downAxis = Direction3D.Create(new Vector3D(0d, 0d, -1d));
        var width = outerBox.MaxX - outerBox.MinX;
        var depth = outerBox.MaxY - outerBox.MinY;
        var height = outerBox.MaxZ - outerBox.MinZ;

        var lineCurves = new[]
        {
            (p1, new Vector3D(width, 0d, 0d)), (p2, new Vector3D(0d, depth, 0d)), (p3, new Vector3D(-width, 0d, 0d)), (p4, new Vector3D(0d, -depth, 0d)),
            (p5, new Vector3D(width, 0d, 0d)), (p6, new Vector3D(0d, depth, 0d)), (p7, new Vector3D(-width, 0d, 0d)), (p8, new Vector3D(0d, -depth, 0d)),
            (p1, new Vector3D(0d, 0d, height)), (p2, new Vector3D(0d, 0d, height)), (p3, new Vector3D(0d, 0d, height)), (p4, new Vector3D(0d, 0d, height)),
        };
        for (var i = 0; i < lineCurves.Length; i++)
        {
            geometry.AddCurve(new CurveGeometryId(i + 1), CurveGeometry.FromLine(new Line3Curve(lineCurves[i].Item1, Direction3D.Create(lineCurves[i].Item2))));
        }

        geometry.AddCurve(new CurveGeometryId(13), CurveGeometry.FromCircle(new Circle3Curve(new Point3D(sphere.Center.X, sphere.Center.Y, openingPlaneZ), zAxis, openingRadius, xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(1), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, 0d, outerBox.MinZ), downAxis, xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(2), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, 0d, outerBox.MaxZ), zAxis, xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(3), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, outerBox.MinY, 0d), Direction3D.Create(new Vector3D(0d, -1d, 0d)), xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(4), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(outerBox.MaxX, 0d, 0d), Direction3D.Create(new Vector3D(1d, 0d, 0d)), yAxis)));
        geometry.AddSurface(new SurfaceGeometryId(5), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, outerBox.MaxY, 0d), Direction3D.Create(new Vector3D(0d, 1d, 0d)), Direction3D.Create(new Vector3D(-1d, 0d, 0d)))));
        geometry.AddSurface(new SurfaceGeometryId(6), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(outerBox.MinX, 0d, 0d), Direction3D.Create(new Vector3D(-1d, 0d, 0d)), yAxis)));
        geometry.AddSurface(new SurfaceGeometryId(7), SurfaceGeometry.FromSphere(new SphereSurface(sphere.Center, zAxis, sphere.Radius, xAxis)));

        var bindings = new BrepBindingModel();
        for (var i = 0; i < 12; i++)
        {
            bindings.AddEdgeBinding(new EdgeGeometryBinding(new EdgeId(i + 1), new CurveGeometryId(i + 1), new ParameterInterval(0d, 1d)));
        }

        bindings.AddEdgeBinding(new EdgeGeometryBinding(openingCircle, new CurveGeometryId(13), new ParameterInterval(0d, 2d * double.Pi)));
        bindings.AddFaceBinding(new FaceGeometryBinding(bottomFace, new SurfaceGeometryId(1)));
        bindings.AddFaceBinding(new FaceGeometryBinding(topFace, new SurfaceGeometryId(2)));
        bindings.AddFaceBinding(new FaceGeometryBinding(xMinFace, new SurfaceGeometryId(3)));
        bindings.AddFaceBinding(new FaceGeometryBinding(xMaxFace, new SurfaceGeometryId(4)));
        bindings.AddFaceBinding(new FaceGeometryBinding(yMaxFace, new SurfaceGeometryId(5)));
        bindings.AddFaceBinding(new FaceGeometryBinding(yMinFace, new SurfaceGeometryId(6)));
        bindings.AddFaceBinding(new FaceGeometryBinding(sphereFace, new SurfaceGeometryId(7)));

        var vertexPoints = new Dictionary<VertexId, Point3D>
        {
            [v1] = p1,
            [v2] = p2,
            [v3] = p3,
            [v4] = p4,
            [v5] = p5,
            [v6] = p6,
            [v7] = p7,
            [v8] = p8,
            [openingVertex] = new Point3D(sphere.Center.X + openingRadius, sphere.Center.Y, openingPlaneZ),
        };

        var body = new BrepBody(builder.Model, geometry, bindings, vertexPoints, composition);
        var validation = BrepBindingValidator.Validate(body, requireAllEdgeAndFaceBindings: true);
        return validation.IsSuccess
            ? KernelResult<BrepBody>.Success(body, validation.Diagnostics)
            : KernelResult<BrepBody>.Failure(validation.Diagnostics);
    }

    private static KernelResult<BrepBody> CreateComposedContainedCylinderCavityBody(
        AxisAlignedBoxExtents outerBox,
        in RecognizedCylinder cylinder,
        SafeBooleanComposition composition)
    {
        var outer = BrepBooleanBoxRecognition.CreateBoxFromExtents(outerBox);
        if (!outer.IsSuccess)
        {
            return KernelResult<BrepBody>.Failure(outer.Diagnostics);
        }

        var height = System.Math.Abs(cylinder.MaxAxisParameter - cylinder.MinAxisParameter);
        var innerResult = BrepPrimitives.CreateCylinder(cylinder.Radius, height);
        if (!innerResult.IsSuccess)
        {
            return KernelResult<BrepBody>.Failure(innerResult.Diagnostics);
        }

        var center = new Point3D(
            (cylinder.MinCenter.X + cylinder.MaxCenter.X) * 0.5d,
            (cylinder.MinCenter.Y + cylinder.MaxCenter.Y) * 0.5d,
            (cylinder.MinCenter.Z + cylinder.MaxCenter.Z) * 0.5d);
        var inner = TranslateBody(innerResult.Value, new Vector3D(center.X, center.Y, center.Z));
        var body = MergeOuterAndInnerShell(outer.Value, inner, composition);
        var validation = BrepBindingValidator.Validate(body, requireAllEdgeAndFaceBindings: true);
        return validation.IsSuccess
            ? KernelResult<BrepBody>.Success(body, validation.Diagnostics)
            : KernelResult<BrepBody>.Failure(validation.Diagnostics);
    }

    private static BrepBody MergeOuterAndInnerShell(BrepBody outer, BrepBody inner, SafeBooleanComposition? composition = null)
        => MergeOuterAndInnerShells(outer, [inner], composition);

    private static BrepBody MergeOuterAndInnerShells(BrepBody outer, IReadOnlyList<BrepBody> innerShells, SafeBooleanComposition? composition = null)
    {
        var topology = new TopologyModel();

        foreach (var vertex in outer.Topology.Vertices.OrderBy(v => v.Id.Value))
        {
            topology.AddVertex(vertex);
        }

        foreach (var edge in outer.Topology.Edges.OrderBy(e => e.Id.Value))
        {
            topology.AddEdge(edge);
        }

        foreach (var coedge in outer.Topology.Coedges.OrderBy(c => c.Id.Value))
        {
            topology.AddCoedge(coedge);
        }

        foreach (var loop in outer.Topology.Loops.OrderBy(l => l.Id.Value))
        {
            topology.AddLoop(loop);
        }

        foreach (var face in outer.Topology.Faces.OrderBy(f => f.Id.Value))
        {
            topology.AddFace(face);
        }

        foreach (var shell in outer.Topology.Shells.OrderBy(s => s.Id.Value))
        {
            topology.AddShell(shell);
        }

        var remappedInnerShellIds = new List<ShellId>(innerShells.Count);
        for (var innerIndex = 0; innerIndex < innerShells.Count; innerIndex++)
        {
            var inner = innerShells[innerIndex];
            var idOffset = 1000 * (innerIndex + 1);
            var innerVertexMap = inner.Topology.Vertices.ToDictionary(v => v.Id, v => new VertexId(v.Id.Value + idOffset));
            var innerEdgeMap = inner.Topology.Edges.ToDictionary(e => e.Id, e => new EdgeId(e.Id.Value + idOffset));
            var innerLoopMap = inner.Topology.Loops.ToDictionary(l => l.Id, l => new LoopId(l.Id.Value + idOffset));
            var innerCoedgeMap = inner.Topology.Coedges.ToDictionary(c => c.Id, c => new CoedgeId(c.Id.Value + idOffset));
            var innerFaceMap = inner.Topology.Faces.ToDictionary(f => f.Id, f => new FaceId(f.Id.Value + idOffset));
            var innerShellMap = inner.Topology.Shells.ToDictionary(s => s.Id, s => new ShellId(s.Id.Value + idOffset));

            foreach (var vertex in inner.Topology.Vertices.OrderBy(v => v.Id.Value))
            {
                topology.AddVertex(new Vertex(innerVertexMap[vertex.Id]));
            }

            foreach (var edge in inner.Topology.Edges.OrderBy(e => e.Id.Value))
            {
                topology.AddEdge(new Edge(innerEdgeMap[edge.Id], innerVertexMap[edge.StartVertexId], innerVertexMap[edge.EndVertexId]));
            }

            foreach (var coedge in inner.Topology.Coedges.OrderBy(c => c.Id.Value))
            {
                topology.AddCoedge(new Coedge(
                    innerCoedgeMap[coedge.Id],
                    innerEdgeMap[coedge.EdgeId],
                    innerLoopMap[coedge.LoopId],
                    innerCoedgeMap[coedge.NextCoedgeId],
                    innerCoedgeMap[coedge.PrevCoedgeId],
                    coedge.IsReversed));
            }

            foreach (var loop in inner.Topology.Loops.OrderBy(l => l.Id.Value))
            {
                topology.AddLoop(new Loop(innerLoopMap[loop.Id], loop.CoedgeIds.Select(id => innerCoedgeMap[id]).ToArray()));
            }

            foreach (var face in inner.Topology.Faces.OrderBy(f => f.Id.Value))
            {
                topology.AddFace(new Face(innerFaceMap[face.Id], face.LoopIds.Select(id => innerLoopMap[id]).ToArray()));
            }

            foreach (var shell in inner.Topology.Shells.OrderBy(s => s.Id.Value))
            {
                topology.AddShell(new Shell(innerShellMap[shell.Id], shell.FaceIds.Select(id => innerFaceMap[id]).ToArray()));
            }

            remappedInnerShellIds.Add(innerShellMap[AssertSingleShellId(inner.Topology)]);
        }

        var outerShellId = AssertSingleShellId(outer.Topology);
        topology.AddBody(new Body(new BodyId(1), [outerShellId, .. remappedInnerShellIds]));

        var geometry = new BrepGeometryStore();
        foreach (var curve in outer.Geometry.Curves)
        {
            geometry.AddCurve(curve.Key, curve.Value);
        }

        foreach (var surface in outer.Geometry.Surfaces)
        {
            geometry.AddSurface(surface.Key, surface.Value);
        }

        for (var innerIndex = 0; innerIndex < innerShells.Count; innerIndex++)
        {
            var inner = innerShells[innerIndex];
            var idOffset = 1000 * (innerIndex + 1);
            foreach (var curve in inner.Geometry.Curves)
            {
                geometry.AddCurve(new CurveGeometryId(curve.Key.Value + idOffset), curve.Value);
            }

            foreach (var surface in inner.Geometry.Surfaces)
            {
                geometry.AddSurface(new SurfaceGeometryId(surface.Key.Value + idOffset), surface.Value);
            }
        }

        var bindings = new BrepBindingModel();
        foreach (var edgeBinding in outer.Bindings.EdgeBindings.OrderBy(binding => binding.EdgeId.Value))
        {
            bindings.AddEdgeBinding(edgeBinding);
        }

        foreach (var faceBinding in outer.Bindings.FaceBindings.OrderBy(binding => binding.FaceId.Value))
        {
            bindings.AddFaceBinding(faceBinding);
        }

        for (var innerIndex = 0; innerIndex < innerShells.Count; innerIndex++)
        {
            var inner = innerShells[innerIndex];
            var idOffset = 1000 * (innerIndex + 1);
            var innerEdgeMap = inner.Topology.Edges.ToDictionary(e => e.Id, e => new EdgeId(e.Id.Value + idOffset));
            var innerFaceMap = inner.Topology.Faces.ToDictionary(f => f.Id, f => new FaceId(f.Id.Value + idOffset));

            foreach (var edgeBinding in inner.Bindings.EdgeBindings.OrderBy(binding => binding.EdgeId.Value))
            {
                bindings.AddEdgeBinding(edgeBinding with
                {
                    EdgeId = innerEdgeMap[edgeBinding.EdgeId],
                    CurveGeometryId = new CurveGeometryId(edgeBinding.CurveGeometryId.Value + idOffset),
                });
            }

            foreach (var faceBinding in inner.Bindings.FaceBindings.OrderBy(binding => binding.FaceId.Value))
            {
                bindings.AddFaceBinding(faceBinding with
                {
                    FaceId = innerFaceMap[faceBinding.FaceId],
                    SurfaceGeometryId = new SurfaceGeometryId(faceBinding.SurfaceGeometryId.Value + idOffset),
                });
            }
        }

        var vertexPoints = new Dictionary<VertexId, Point3D>();
        foreach (var vertex in outer.Topology.Vertices.OrderBy(v => v.Id.Value))
        {
            if (outer.TryGetVertexPoint(vertex.Id, out var point))
            {
                vertexPoints[vertex.Id] = point;
            }
        }

        for (var innerIndex = 0; innerIndex < innerShells.Count; innerIndex++)
        {
            var inner = innerShells[innerIndex];
            var idOffset = 1000 * (innerIndex + 1);
            foreach (var vertex in inner.Topology.Vertices.OrderBy(v => v.Id.Value))
            {
                if (inner.TryGetVertexPoint(vertex.Id, out var point))
                {
                    vertexPoints[new VertexId(vertex.Id.Value + idOffset)] = point;
                }
            }
        }

        return new BrepBody(
            topology,
            geometry,
            bindings,
            vertexPoints,
            safeBooleanComposition: composition,
            shellRepresentation: new BrepBodyShellRepresentation(outerShellId, remappedInnerShellIds));
    }

    private static ShellId AssertSingleShellId(TopologyModel topology)
        => topology.Bodies.Single().ShellIds.Single();

    private static KernelResult<BrepBody> CreateSphereShell(in RecognizedSphere sphere)
    {
        var builder = new TopologyBuilder();
        var sphereFace = builder.AddFace([]);
        var sphereShell = builder.AddShell([sphereFace]);
        builder.AddBody([sphereShell]);

        var geometry = new BrepGeometryStore();
        geometry.AddSurface(
            new SurfaceGeometryId(1),
            SurfaceGeometry.FromSphere(new SphereSurface(
                sphere.Center,
                Direction3D.Create(new Vector3D(0d, 0d, 1d)),
                sphere.Radius,
                Direction3D.Create(new Vector3D(1d, 0d, 0d)))));

        var bindings = new BrepBindingModel();
        bindings.AddFaceBinding(new FaceGeometryBinding(sphereFace, new SurfaceGeometryId(1)));

        var body = new BrepBody(builder.Model, geometry, bindings, vertexPoints: null, safeBooleanComposition: null);
        var validation = BrepBindingValidator.Validate(body, requireAllEdgeAndFaceBindings: true);
        return validation.IsSuccess
            ? KernelResult<BrepBody>.Success(body, validation.Diagnostics)
            : KernelResult<BrepBody>.Failure(validation.Diagnostics);
    }

    private static KernelResult<BrepBody> CreateComposedThroughHoleBody(SafeBooleanComposition composition, ToleranceContext tolerance,
        Action<string, FaceId>? onConstructedHoleWall = null, Action<string, FaceId>? onConstructedHostFace = null)
    {
        var box = composition.OuterBox;
        var holes = composition.Holes;
        if (holes.Count > 1
            && holes.Any(h => h.IsBlind)
            && !SupportsBoundedBlindContinuationOnRecognizedOrthogonalAdditiveRoot(composition, tolerance))
        {
            return KernelResult<BrepBody>.Failure([
                new BooleanDiagnostic(
                    BooleanDiagnosticCode.UnsupportedBlindHoleComposition,
                    new BooleanDiagnosticContext(BooleanOperation.Subtract).FormatMessage("blind-hole continuation exceeds bounded rebuild support; only recognized orthogonal additive roots (or simple box roots) with world-Z cylinder/cone hole chains are rebuildable in this milestone."),
                    "BrepBoolean.AnalyticHole.BlindContinuationOutsideBoundedFamily").ToKernelDiagnostic(),
            ]);
        }

        var builder = new TopologyBuilder();

        var v1 = builder.AddVertex();
        var v2 = builder.AddVertex();
        var v3 = builder.AddVertex();
        var v4 = builder.AddVertex();
        var v5 = builder.AddVertex();
        var v6 = builder.AddVertex();
        var v7 = builder.AddVertex();
        var v8 = builder.AddVertex();

        var e1 = builder.AddEdge(v1, v2);
        var e2 = builder.AddEdge(v2, v3);
        var e3 = builder.AddEdge(v3, v4);
        var e4 = builder.AddEdge(v4, v1);
        var e5 = builder.AddEdge(v5, v6);
        var e6 = builder.AddEdge(v6, v7);
        var e7 = builder.AddEdge(v7, v8);
        var e8 = builder.AddEdge(v8, v5);
        var e9 = builder.AddEdge(v1, v5);
        var e10 = builder.AddEdge(v2, v6);
        var e11 = builder.AddEdge(v3, v7);
        var e12 = builder.AddEdge(v4, v8);

        var holeTopology = new List<HoleTopology>(holes.Count);
        foreach (var hole in holes)
        {
            var topHoleVertex = builder.AddVertex();
            var bottomHoleVertex = builder.AddVertex();
            var seamTopVertex = builder.AddVertex();
            var seamBottomVertex = builder.AddVertex();

            var topCircle = builder.AddEdge(topHoleVertex, topHoleVertex);
            var bottomCircle = builder.AddEdge(bottomHoleVertex, bottomHoleVertex);
            var seam = builder.AddEdge(seamTopVertex, seamBottomVertex);

            holeTopology.Add(new HoleTopology(hole, topHoleVertex, bottomHoleVertex, seamTopVertex, seamBottomVertex, topCircle, bottomCircle, seam));
        }

        var bottomOuterLoop = AddSurgeryLoop(builder, [Forward(e1), Forward(e2), Forward(e3), Forward(e4)]);
        var topOuterLoop = AddSurgeryLoop(builder, [Forward(e5), Forward(e6), Forward(e7), Forward(e8)]);
        var bottomLoops = new List<LoopId>(holes.Count + 1) { bottomOuterLoop };
        var topLoops = new List<LoopId>(holes.Count + 1) { topOuterLoop };
        foreach (var hole in holeTopology)
        {
            if (hole.Hole.SpanKind == SupportedBooleanHoleSpanKind.Through)
            {
                topLoops.Add(AddSurgeryLoop(builder, [Forward(hole.TopCircle)]));
                bottomLoops.Add(AddSurgeryLoop(builder, [Reversed(hole.BottomCircle)]));
            }
            else if (hole.Hole.SpanKind == SupportedBooleanHoleSpanKind.BlindFromTop)
            {
                topLoops.Add(AddSurgeryLoop(builder, [Forward(hole.TopCircle)]));
            }
            else
            {
                bottomLoops.Add(AddSurgeryLoop(builder, [Reversed(hole.BottomCircle)]));
            }
        }

        // Recognition has already identified the support faces and loop roles.
        // Surgery realizes those exact ownership decisions; numerical
        // intersection is not topology authority here.
        var bottomFace = AddKnownFace(builder, bottomLoops);
        var topFace = AddKnownFace(builder, topLoops);
        onConstructedHostFace?.Invoke("-Z", bottomFace);
        onConstructedHostFace?.Invoke("+Z", topFace);
        var xMinFace = AddKnownFace(builder, [AddSurgeryLoop(builder, [Forward(e1), Forward(e10), Reversed(e5), Reversed(e9)])]);
        var xMaxFace = AddKnownFace(builder, [AddSurgeryLoop(builder, [Forward(e2), Forward(e11), Reversed(e6), Reversed(e10)])]);
        var yMaxFace = AddKnownFace(builder, [AddSurgeryLoop(builder, [Forward(e3), Forward(e12), Reversed(e7), Reversed(e11)])]);
        var yMinFace = AddKnownFace(builder, [AddSurgeryLoop(builder, [Forward(e4), Forward(e9), Reversed(e8), Reversed(e12)])]);

        var holeFaces = new List<FaceId>(holes.Count);
        foreach (var hole in holeTopology)
        {
            // A cylindrical wall must traverse from the top seam endpoint to
            // the bottom circle, back up the reversed seam, then the top
            // circle.  The previous top/bottom ordering was incidence-manifold
            // but disconnected in declared coedge traversal.
            var wallFace = AddKnownFace(builder, [
                AddSurgeryLoop(builder, [Forward(hole.Seam), Forward(hole.BottomCircle), Reversed(hole.Seam), Reversed(hole.TopCircle)])
            ]);
            holeFaces.Add(wallFace);
            if (hole.Hole.FeatureId is { } featureId) onConstructedHoleWall?.Invoke(featureId, wallFace);
        }

        var blindBottomFaces = new List<FaceId>();
        foreach (var hole in holeTopology.Where(h => h.Hole.IsBlind))
        {
            var terminationEdge = hole.Hole.SpanKind == SupportedBooleanHoleSpanKind.BlindFromTop ? hole.BottomCircle : hole.TopCircle;
            blindBottomFaces.Add(AddKnownFace(builder, [AddSurgeryLoop(builder, [Forward(terminationEdge)])]));
        }

        var shellFaces = new List<FaceId>(6 + holeFaces.Count)
        {
            bottomFace,
            topFace,
            xMinFace,
            xMaxFace,
            yMaxFace,
            yMinFace,
        };
        shellFaces.AddRange(holeFaces);
        shellFaces.AddRange(blindBottomFaces);

        var assembly = BrepShellAssembler.CreateClosedBody(builder, shellFaces);
        if (!assembly.IsSuccess)
        {
            return KernelResult<BrepBody>.Failure(assembly.Diagnostics);
        }

        var geometry = new BrepGeometryStore();
        var width = box.MaxX - box.MinX;
        var depth = box.MaxY - box.MinY;
        var height = box.MaxZ - box.MinZ;

        var p1 = new Point3D(box.MinX, box.MinY, box.MinZ);
        var p2 = new Point3D(box.MaxX, box.MinY, box.MinZ);
        var p3 = new Point3D(box.MaxX, box.MaxY, box.MinZ);
        var p4 = new Point3D(box.MinX, box.MaxY, box.MinZ);
        var p5 = new Point3D(box.MinX, box.MinY, box.MaxZ);
        var p6 = new Point3D(box.MaxX, box.MinY, box.MaxZ);
        var p7 = new Point3D(box.MaxX, box.MaxY, box.MaxZ);
        var p8 = new Point3D(box.MinX, box.MaxY, box.MaxZ);

        var zAxis = Direction3D.Create(new Vector3D(0d, 0d, 1d));
        var xAxis = Direction3D.Create(new Vector3D(1d, 0d, 0d));
        var yAxis = Direction3D.Create(new Vector3D(0d, 1d, 0d));

        var lineCurves = new[]
        {
            (p1, new Vector3D(width, 0d, 0d)),
            (p2, new Vector3D(0d, depth, 0d)),
            (p3, new Vector3D(-width, 0d, 0d)),
            (p4, new Vector3D(0d, -depth, 0d)),
            (p5, new Vector3D(width, 0d, 0d)),
            (p6, new Vector3D(0d, depth, 0d)),
            (p7, new Vector3D(-width, 0d, 0d)),
            (p8, new Vector3D(0d, -depth, 0d)),
            (p1, new Vector3D(0d, 0d, height)),
            (p2, new Vector3D(0d, 0d, height)),
            (p3, new Vector3D(0d, 0d, height)),
            (p4, new Vector3D(0d, 0d, height)),
        };

        for (var i = 0; i < lineCurves.Length; i++)
        {
            geometry.AddCurve(new CurveGeometryId(i + 1), CurveGeometry.FromLine(new Line3Curve(lineCurves[i].Item1, Direction3D.Create(lineCurves[i].Item2))));
        }

        geometry.AddSurface(new SurfaceGeometryId(1), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, 0d, box.MinZ), Direction3D.Create(new Vector3D(0d, 0d, -1d)), xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(2), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, 0d, box.MaxZ), zAxis, xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(3), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, box.MinY, 0d), Direction3D.Create(new Vector3D(0d, -1d, 0d)), xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(4), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(box.MaxX, 0d, 0d), Direction3D.Create(new Vector3D(1d, 0d, 0d)), yAxis)));
        geometry.AddSurface(new SurfaceGeometryId(5), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, box.MaxY, 0d), Direction3D.Create(new Vector3D(0d, 1d, 0d)), Direction3D.Create(new Vector3D(-1d, 0d, 0d)))));
        geometry.AddSurface(new SurfaceGeometryId(6), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(box.MinX, 0d, 0d), Direction3D.Create(new Vector3D(-1d, 0d, 0d)), yAxis)));

        var bindings = new BrepBindingModel();
        for (var i = 0; i < 12; i++)
        {
            bindings.AddEdgeBinding(new EdgeGeometryBinding(new EdgeId(i + 1), new CurveGeometryId(i + 1), new ParameterInterval(0d, lineCurves[i].Item2.Length)));
        }

        bindings.AddFaceBinding(new FaceGeometryBinding(bottomFace, new SurfaceGeometryId(1)));
        bindings.AddFaceBinding(new FaceGeometryBinding(topFace, new SurfaceGeometryId(2)));
        bindings.AddFaceBinding(new FaceGeometryBinding(xMinFace, new SurfaceGeometryId(3)));
        bindings.AddFaceBinding(new FaceGeometryBinding(xMaxFace, new SurfaceGeometryId(4)));
        bindings.AddFaceBinding(new FaceGeometryBinding(yMaxFace, new SurfaceGeometryId(5)));
        bindings.AddFaceBinding(new FaceGeometryBinding(yMinFace, new SurfaceGeometryId(6)));

        var vertexPoints = new Dictionary<VertexId, Point3D>
        {
            [v1] = p1,
            [v2] = p2,
            [v3] = p3,
            [v4] = p4,
            [v5] = p5,
            [v6] = p6,
            [v7] = p7,
            [v8] = p8,
        };

        var nextCurveId = 13;
        var nextSurfaceId = 7;
        var blindBottomFaceIndex = 0;
        for (var i = 0; i < holeTopology.Count; i++)
        {
            var topology = holeTopology[i];
            var geometryData = CreateHoleGeometry(topology.Hole, box, zAxis, xAxis);
            var topCurveId = new CurveGeometryId(nextCurveId++);
            var bottomCurveId = new CurveGeometryId(nextCurveId++);
            var seamCurveId = new CurveGeometryId(nextCurveId++);
            var surfaceId = new SurfaceGeometryId(nextSurfaceId++);

            geometry.AddCurve(topCurveId, geometryData.TopCircle);
            geometry.AddCurve(bottomCurveId, geometryData.BottomCircle);
            geometry.AddCurve(seamCurveId, geometryData.Seam);
            geometry.AddSurface(surfaceId, geometryData.Surface);

            bindings.AddEdgeBinding(new EdgeGeometryBinding(topology.TopCircle, topCurveId, new ParameterInterval(0d, 2d * double.Pi)));
            bindings.AddEdgeBinding(new EdgeGeometryBinding(topology.BottomCircle, bottomCurveId, new ParameterInterval(0d, 2d * double.Pi)));
            bindings.AddEdgeBinding(new EdgeGeometryBinding(topology.Seam, seamCurveId, new ParameterInterval(0d, geometryData.SeamLength)));
            // Subtraction walls face into the cavity, opposite the cylinder's
            // radial support normal. Do not rely on chart traversal to hide it.
            bindings.AddFaceBinding(new FaceGeometryBinding(holeFaces[i], surfaceId, IsAlignedWithSurface: false));

            if (topology.Hole.IsBlind)
            {
                var blindBottomCenter = topology.Hole.SpanKind == SupportedBooleanHoleSpanKind.BlindFromTop
                    ? geometryData.BottomCenter
                    : geometryData.TopCenter;
                var blindBottomSurfaceId = new SurfaceGeometryId(nextSurfaceId++);
                geometry.AddSurface(blindBottomSurfaceId, SurfaceGeometry.FromPlane(new PlaneSurface(
                    blindBottomCenter,
                    Direction3D.Create(topology.Hole.Axis.ToVector() * -1d),
                    topology.Hole.ReferenceAxis)));
                bindings.AddFaceBinding(new FaceGeometryBinding(blindBottomFaces[blindBottomFaceIndex++], blindBottomSurfaceId));
            }

            vertexPoints[topology.TopHoleVertex] = geometryData.SeamTopPoint;
            vertexPoints[topology.BottomHoleVertex] = geometryData.SeamBottomPoint;
            vertexPoints[topology.SeamTopVertex] = geometryData.SeamTopPoint;
            vertexPoints[topology.SeamBottomVertex] = geometryData.SeamBottomPoint;
        }

        var body = new BrepBody(builder.Model, geometry, bindings, vertexPoints, composition);
        var validation = BrepSurgeryValidation.ValidateBody(body, requireAllEdgeAndFaceBindings: true);
        return validation.IsSuccess
            ? KernelResult<BrepBody>.Success(body, validation.Diagnostics)
            : KernelResult<BrepBody>.Failure(validation.Diagnostics);
    }


    private static KernelResult<BrepBody> CreateSteppedCoaxialCountersinkBody(
        SafeBooleanComposition composition,
        in CoaxialCountersinkSubtractProfile countersinkProfile)
    {
        var box = composition.OuterBox;
        var builder = new TopologyBuilder();

        var v1 = builder.AddVertex();
        var v2 = builder.AddVertex();
        var v3 = builder.AddVertex();
        var v4 = builder.AddVertex();
        var v5 = builder.AddVertex();
        var v6 = builder.AddVertex();
        var v7 = builder.AddVertex();
        var v8 = builder.AddVertex();

        var e1 = builder.AddEdge(v1, v2);
        var e2 = builder.AddEdge(v2, v3);
        var e3 = builder.AddEdge(v3, v4);
        var e4 = builder.AddEdge(v4, v1);
        var e5 = builder.AddEdge(v5, v6);
        var e6 = builder.AddEdge(v6, v7);
        var e7 = builder.AddEdge(v7, v8);
        var e8 = builder.AddEdge(v8, v5);
        var e9 = builder.AddEdge(v1, v5);
        var e10 = builder.AddEdge(v2, v6);
        var e11 = builder.AddEdge(v3, v7);
        var e12 = builder.AddEdge(v4, v8);

        var entryVertex = builder.AddVertex();
        var transitionVertex = builder.AddVertex();
        var deepEndVertex = builder.AddVertex();

        var entryCircle = builder.AddEdge(entryVertex, entryVertex);
        var transitionCircle = builder.AddEdge(transitionVertex, transitionVertex);
        var deepEndCircle = builder.AddEdge(deepEndVertex, deepEndVertex);
        // A periodic face seam must meet the circular boundary at the same topological
        // vertex, not merely at a second vertex with coincident coordinates.  Separate
        // seam vertices produce disconnected EDGE_LOOP wires in STEP even though simple
        // edge-incidence checks still describe a closed shell.
        var coneSeam = builder.AddEdge(entryVertex, transitionVertex);
        var cylinderSeam = builder.AddEdge(transitionVertex, deepEndVertex);

        var bottomOuterLoop = AddLoop(builder, [Forward(e1), Forward(e2), Forward(e3), Forward(e4)]);
        var topOuterLoop = AddLoop(builder, [Forward(e5), Forward(e6), Forward(e7), Forward(e8)]);
        var bottomLoops = new List<LoopId>(2) { bottomOuterLoop };
        var topLoops = new List<LoopId>(2) { topOuterLoop };

        if (countersinkProfile.EntryFromTop)
        {
            topLoops.Add(AddLoop(builder, [Forward(entryCircle)]));
            if (countersinkProfile.ContinuationCylinder.SpanKind == SupportedBooleanHoleSpanKind.Through)
            {
                bottomLoops.Add(AddLoop(builder, [Reversed(deepEndCircle)]));
            }
        }
        else
        {
            bottomLoops.Add(AddLoop(builder, [Reversed(entryCircle)]));
            if (countersinkProfile.ContinuationCylinder.SpanKind == SupportedBooleanHoleSpanKind.Through)
            {
                topLoops.Add(AddLoop(builder, [Forward(deepEndCircle)]));
            }
        }

        var bottomFace = builder.AddFace(bottomLoops);
        var topFace = builder.AddFace(topLoops);
        var xMinFace = builder.AddFace([AddLoop(builder, [Forward(e1), Forward(e10), Reversed(e5), Reversed(e9)])]);
        var xMaxFace = builder.AddFace([AddLoop(builder, [Forward(e2), Forward(e11), Reversed(e6), Reversed(e10)])]);
        var yMaxFace = builder.AddFace([AddLoop(builder, [Forward(e3), Forward(e12), Reversed(e7), Reversed(e11)])]);
        var yMinFace = builder.AddFace([AddLoop(builder, [Forward(e4), Forward(e9), Reversed(e8), Reversed(e12)])]);

        var countersinkConeFace = builder.AddFace([
            AddLoop(builder, [Forward(coneSeam), Forward(transitionCircle), Reversed(coneSeam), Reversed(entryCircle)])
        ]);
        var continuationCylinderFace = builder.AddFace([
            AddLoop(builder, [Forward(cylinderSeam), Forward(deepEndCircle), Reversed(cylinderSeam), Reversed(transitionCircle)])
        ]);

        FaceId? deepBottomFace = null;
        if (countersinkProfile.ContinuationCylinder.IsBlind)
        {
            deepBottomFace = builder.AddFace([AddLoop(builder, [Forward(deepEndCircle)])]);
        }

        var shellFaces = new List<FaceId>
        {
            bottomFace,
            topFace,
            xMinFace,
            xMaxFace,
            yMaxFace,
            yMinFace,
            countersinkConeFace,
            continuationCylinderFace,
        };
        if (deepBottomFace is FaceId deepBottom)
        {
            shellFaces.Add(deepBottom);
        }

        var shell = builder.AddShell(shellFaces);
        builder.AddBody([shell]);

        var zAxis = Direction3D.Create(new Vector3D(0d, 0d, 1d));
        var xAxis = Direction3D.Create(new Vector3D(1d, 0d, 0d));
        var yAxis = Direction3D.Create(new Vector3D(0d, 1d, 0d));
        var width = box.MaxX - box.MinX;
        var depth = box.MaxY - box.MinY;
        var height = box.MaxZ - box.MinZ;
        var p1 = new Point3D(box.MinX, box.MinY, box.MinZ);
        var p2 = new Point3D(box.MaxX, box.MinY, box.MinZ);
        var p3 = new Point3D(box.MaxX, box.MaxY, box.MinZ);
        var p4 = new Point3D(box.MinX, box.MaxY, box.MinZ);
        var p5 = new Point3D(box.MinX, box.MinY, box.MaxZ);
        var p6 = new Point3D(box.MaxX, box.MinY, box.MaxZ);
        var p7 = new Point3D(box.MaxX, box.MaxY, box.MaxZ);
        var p8 = new Point3D(box.MinX, box.MaxY, box.MaxZ);

        var entryZ = countersinkProfile.EntryFromTop ? box.MaxZ : box.MinZ;
        var transitionZ = countersinkProfile.TransitionZ;
        var deepEndZ = countersinkProfile.ContinuationCylinder.SpanKind == SupportedBooleanHoleSpanKind.Through
            ? (countersinkProfile.EntryFromTop ? box.MinZ : box.MaxZ)
            : countersinkProfile.ContinuationEndZ;
        var center = new Point3D(countersinkProfile.EntryCone.CenterX, countersinkProfile.EntryCone.CenterY, 0d);
        var entryCenter = new Point3D(center.X, center.Y, entryZ);
        var transitionCenter = new Point3D(center.X, center.Y, transitionZ);
        var deepEndCenter = new Point3D(center.X, center.Y, deepEndZ);
        var seamAxis = countersinkProfile.EntryFromTop
            ? Direction3D.Create(new Vector3D(0d, 0d, -1d))
            : Direction3D.Create(new Vector3D(0d, 0d, 1d));
        var coneSeamStart = entryCenter + (xAxis.ToVector() * countersinkProfile.EntryRadius);
        var coneSeamEnd = transitionCenter + (xAxis.ToVector() * countersinkProfile.ContinuationRadius);
        var cylinderSeamStart = coneSeamEnd;
        var cylinderSeamEnd = deepEndCenter + (xAxis.ToVector() * countersinkProfile.ContinuationRadius);

        var geometry = new BrepGeometryStore();
        var lineCurves = new[]
        {
            (p1, new Vector3D(width, 0d, 0d)),
            (p2, new Vector3D(0d, depth, 0d)),
            (p3, new Vector3D(-width, 0d, 0d)),
            (p4, new Vector3D(0d, -depth, 0d)),
            (p5, new Vector3D(width, 0d, 0d)),
            (p6, new Vector3D(0d, depth, 0d)),
            (p7, new Vector3D(-width, 0d, 0d)),
            (p8, new Vector3D(0d, -depth, 0d)),
            (p1, new Vector3D(0d, 0d, height)),
            (p2, new Vector3D(0d, 0d, height)),
            (p3, new Vector3D(0d, 0d, height)),
            (p4, new Vector3D(0d, 0d, height)),
        };
        for (var i = 0; i < lineCurves.Length; i++)
        {
            geometry.AddCurve(new CurveGeometryId(i + 1), CurveGeometry.FromLine(new Line3Curve(lineCurves[i].Item1, Direction3D.Create(lineCurves[i].Item2))));
        }

        var entryCurveId = new CurveGeometryId(13);
        var transitionCurveId = new CurveGeometryId(14);
        var deepEndCurveId = new CurveGeometryId(15);
        var coneSeamCurveId = new CurveGeometryId(16);
        var cylinderSeamCurveId = new CurveGeometryId(17);
        geometry.AddCurve(entryCurveId, CurveGeometry.FromCircle(new Circle3Curve(entryCenter, zAxis, countersinkProfile.EntryRadius, xAxis)));
        geometry.AddCurve(transitionCurveId, CurveGeometry.FromCircle(new Circle3Curve(transitionCenter, zAxis, countersinkProfile.ContinuationRadius, xAxis)));
        geometry.AddCurve(deepEndCurveId, CurveGeometry.FromCircle(new Circle3Curve(deepEndCenter, zAxis, countersinkProfile.ContinuationRadius, xAxis)));
        geometry.AddCurve(coneSeamCurveId, CurveGeometry.FromLine(new Line3Curve(coneSeamStart, Direction3D.Create(coneSeamEnd - coneSeamStart))));
        geometry.AddCurve(cylinderSeamCurveId, CurveGeometry.FromLine(new Line3Curve(cylinderSeamStart, seamAxis)));

        geometry.AddSurface(new SurfaceGeometryId(1), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, 0d, box.MinZ), Direction3D.Create(new Vector3D(0d, 0d, -1d)), xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(2), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, 0d, box.MaxZ), zAxis, xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(3), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, box.MinY, 0d), Direction3D.Create(new Vector3D(0d, -1d, 0d)), xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(4), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(box.MaxX, 0d, 0d), Direction3D.Create(new Vector3D(1d, 0d, 0d)), yAxis)));
        geometry.AddSurface(new SurfaceGeometryId(5), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, box.MaxY, 0d), Direction3D.Create(new Vector3D(0d, 1d, 0d)), Direction3D.Create(new Vector3D(-1d, 0d, 0d)))));
        geometry.AddSurface(new SurfaceGeometryId(6), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(box.MinX, 0d, 0d), Direction3D.Create(new Vector3D(-1d, 0d, 0d)), yAxis)));

        // Construct the support cone directly from the admitted entry profile.  The
        // recognized subtract cone may carry an axis convention chosen for boolean
        // classification; reusing that convention here previously placed the STEP
        // cone at radius 3 on z=6 while its trim edge was at radius 4.
        var coneAxis = countersinkProfile.EntryFromTop ? zAxis : Direction3D.Create(new Vector3D(0d, 0d, -1d));
        geometry.AddSurface(new SurfaceGeometryId(7), SurfaceGeometry.FromCone(new ConeSurface(
            transitionCenter,
            coneAxis,
            countersinkProfile.ContinuationRadius,
            countersinkProfile.EntryCone.Surface.Cone!.Value.SemiAngleRadians,
            countersinkProfile.EntryCone.ReferenceAxis)));
        geometry.AddSurface(new SurfaceGeometryId(8), SurfaceGeometry.FromCylinder(new CylinderSurface(deepEndCenter, zAxis, countersinkProfile.ContinuationRadius, xAxis)));
        if (deepBottomFace is not null)
        {
            geometry.AddSurface(new SurfaceGeometryId(9), SurfaceGeometry.FromPlane(new PlaneSurface(deepEndCenter, Direction3D.Create(new Vector3D(0d, 0d, countersinkProfile.EntryFromTop ? -1d : 1d)), xAxis)));
        }

        var bindings = new BrepBindingModel();
        for (var i = 0; i < 12; i++)
        {
            bindings.AddEdgeBinding(new EdgeGeometryBinding(new EdgeId(i + 1), new CurveGeometryId(i + 1), new ParameterInterval(0d, 1d)));
        }

        bindings.AddEdgeBinding(new EdgeGeometryBinding(entryCircle, entryCurveId, new ParameterInterval(0d, 2d * double.Pi)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(transitionCircle, transitionCurveId, new ParameterInterval(0d, 2d * double.Pi)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(deepEndCircle, deepEndCurveId, new ParameterInterval(0d, 2d * double.Pi)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(coneSeam, coneSeamCurveId, new ParameterInterval(0d, (coneSeamEnd - coneSeamStart).Length)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(cylinderSeam, cylinderSeamCurveId, new ParameterInterval(0d, (cylinderSeamEnd - cylinderSeamStart).Length)));

        bindings.AddFaceBinding(new FaceGeometryBinding(bottomFace, new SurfaceGeometryId(1)));
        bindings.AddFaceBinding(new FaceGeometryBinding(topFace, new SurfaceGeometryId(2)));
        bindings.AddFaceBinding(new FaceGeometryBinding(xMinFace, new SurfaceGeometryId(3)));
        bindings.AddFaceBinding(new FaceGeometryBinding(xMaxFace, new SurfaceGeometryId(4)));
        bindings.AddFaceBinding(new FaceGeometryBinding(yMaxFace, new SurfaceGeometryId(5)));
        bindings.AddFaceBinding(new FaceGeometryBinding(yMinFace, new SurfaceGeometryId(6)));
        // The analytic cone/cylinder normals point radially away from the hole axis.
        // For an internal void the solid's outward normal points toward the axis, so
        // these faces must reverse the support-surface sense in STEP.
        bindings.AddFaceBinding(new FaceGeometryBinding(countersinkConeFace, new SurfaceGeometryId(7), IsAlignedWithSurface: false));
        bindings.AddFaceBinding(new FaceGeometryBinding(continuationCylinderFace, new SurfaceGeometryId(8), IsAlignedWithSurface: false));
        if (deepBottomFace is FaceId deepBottomBinding)
        {
            bindings.AddFaceBinding(new FaceGeometryBinding(deepBottomBinding, new SurfaceGeometryId(9)));
        }

        var vertexPoints = new Dictionary<VertexId, Point3D>
        {
            [v1] = p1,
            [v2] = p2,
            [v3] = p3,
            [v4] = p4,
            [v5] = p5,
            [v6] = p6,
            [v7] = p7,
            [v8] = p8,
            [entryVertex] = coneSeamStart,
            [transitionVertex] = coneSeamEnd,
            [deepEndVertex] = cylinderSeamEnd,
        };

        var body = new BrepBody(builder.Model, geometry, bindings, vertexPoints, composition);
        var validation = BrepBindingValidator.Validate(body, requireAllEdgeAndFaceBindings: true);
        return validation.IsSuccess
            ? KernelResult<BrepBody>.Success(body, validation.Diagnostics)
            : KernelResult<BrepBody>.Failure(validation.Diagnostics);
    }

    private static KernelResult<BrepBody> CreateSteppedCoaxialCylinderBody(
        SafeBooleanComposition composition,
        in CoaxialCylinderSubtractStackProfile steppedProfile)
    {
        var box = composition.OuterBox;
        var builder = new TopologyBuilder();

        var v1 = builder.AddVertex();
        var v2 = builder.AddVertex();
        var v3 = builder.AddVertex();
        var v4 = builder.AddVertex();
        var v5 = builder.AddVertex();
        var v6 = builder.AddVertex();
        var v7 = builder.AddVertex();
        var v8 = builder.AddVertex();

        var e1 = builder.AddEdge(v1, v2);
        var e2 = builder.AddEdge(v2, v3);
        var e3 = builder.AddEdge(v3, v4);
        var e4 = builder.AddEdge(v4, v1);
        var e5 = builder.AddEdge(v5, v6);
        var e6 = builder.AddEdge(v6, v7);
        var e7 = builder.AddEdge(v7, v8);
        var e8 = builder.AddEdge(v8, v5);
        var e9 = builder.AddEdge(v1, v5);
        var e10 = builder.AddEdge(v2, v6);
        var e11 = builder.AddEdge(v3, v7);
        var e12 = builder.AddEdge(v4, v8);

        var entryVertex = builder.AddVertex();
        var shoulderOuterVertex = builder.AddVertex();
        var shoulderInnerVertex = builder.AddVertex();
        var deepEndVertex = builder.AddVertex();
        var outerSeamStartVertex = builder.AddVertex();
        var outerSeamEndVertex = builder.AddVertex();
        var innerSeamStartVertex = builder.AddVertex();
        var innerSeamEndVertex = builder.AddVertex();

        var entryCircle = builder.AddEdge(entryVertex, entryVertex);
        var shoulderOuterCircle = builder.AddEdge(shoulderOuterVertex, shoulderOuterVertex);
        var shoulderInnerCircle = builder.AddEdge(shoulderInnerVertex, shoulderInnerVertex);
        var deepEndCircle = builder.AddEdge(deepEndVertex, deepEndVertex);
        var outerSeam = builder.AddEdge(outerSeamStartVertex, outerSeamEndVertex);
        var innerSeam = builder.AddEdge(innerSeamStartVertex, innerSeamEndVertex);

        var bottomOuterLoop = AddLoop(builder, [Forward(e1), Forward(e2), Forward(e3), Forward(e4)]);
        var topOuterLoop = AddLoop(builder, [Forward(e5), Forward(e6), Forward(e7), Forward(e8)]);
        var bottomLoops = new List<LoopId>(2) { bottomOuterLoop };
        var topLoops = new List<LoopId>(2) { topOuterLoop };
        if (steppedProfile.EntryFromTop)
        {
            topLoops.Add(AddLoop(builder, [Forward(entryCircle)]));
            if (steppedProfile.DeepHole.SpanKind == SupportedBooleanHoleSpanKind.Through)
            {
                bottomLoops.Add(AddLoop(builder, [Reversed(deepEndCircle)]));
            }
        }
        else
        {
            bottomLoops.Add(AddLoop(builder, [Reversed(entryCircle)]));
            if (steppedProfile.DeepHole.SpanKind == SupportedBooleanHoleSpanKind.Through)
            {
                topLoops.Add(AddLoop(builder, [Forward(deepEndCircle)]));
            }
        }

        var bottomFace = builder.AddFace(bottomLoops);
        var topFace = builder.AddFace(topLoops);
        var xMinFace = builder.AddFace([AddLoop(builder, [Forward(e1), Forward(e10), Reversed(e5), Reversed(e9)])]);
        var xMaxFace = builder.AddFace([AddLoop(builder, [Forward(e2), Forward(e11), Reversed(e6), Reversed(e10)])]);
        var yMaxFace = builder.AddFace([AddLoop(builder, [Forward(e3), Forward(e12), Reversed(e7), Reversed(e11)])]);
        var yMinFace = builder.AddFace([AddLoop(builder, [Forward(e4), Forward(e9), Reversed(e8), Reversed(e12)])]);

        var outerWallFace = builder.AddFace([
            AddLoop(builder, [Forward(outerSeam), Reversed(entryCircle), Reversed(outerSeam), Forward(shoulderOuterCircle)])
        ]);
        var shoulderFace = builder.AddFace([
            AddLoop(builder, [Forward(shoulderOuterCircle)]),
            AddLoop(builder, [Reversed(shoulderInnerCircle)])
        ]);
        var innerWallFace = builder.AddFace([
            AddLoop(builder, [Forward(innerSeam), Reversed(shoulderInnerCircle), Reversed(innerSeam), Forward(deepEndCircle)])
        ]);

        FaceId? deepBottomFace = null;
        if (steppedProfile.DeepHole.IsBlind)
        {
            deepBottomFace = builder.AddFace([AddLoop(builder, [Forward(deepEndCircle)])]);
        }

        var shellFaces = new List<FaceId>
        {
            bottomFace,
            topFace,
            xMinFace,
            xMaxFace,
            yMaxFace,
            yMinFace,
            outerWallFace,
            shoulderFace,
            innerWallFace,
        };
        if (deepBottomFace is FaceId deepBottom)
        {
            shellFaces.Add(deepBottom);
        }

        var shell = builder.AddShell(shellFaces);
        builder.AddBody([shell]);

        var zAxis = Direction3D.Create(new Vector3D(0d, 0d, 1d));
        var xAxis = Direction3D.Create(new Vector3D(1d, 0d, 0d));
        var yAxis = Direction3D.Create(new Vector3D(0d, 1d, 0d));
        var width = box.MaxX - box.MinX;
        var depth = box.MaxY - box.MinY;
        var height = box.MaxZ - box.MinZ;
        var p1 = new Point3D(box.MinX, box.MinY, box.MinZ);
        var p2 = new Point3D(box.MaxX, box.MinY, box.MinZ);
        var p3 = new Point3D(box.MaxX, box.MaxY, box.MinZ);
        var p4 = new Point3D(box.MinX, box.MaxY, box.MinZ);
        var p5 = new Point3D(box.MinX, box.MinY, box.MaxZ);
        var p6 = new Point3D(box.MaxX, box.MinY, box.MaxZ);
        var p7 = new Point3D(box.MaxX, box.MaxY, box.MaxZ);
        var p8 = new Point3D(box.MinX, box.MaxY, box.MaxZ);

        var entryZ = steppedProfile.EntryFromTop ? box.MaxZ : box.MinZ;
        var shoulderZ = steppedProfile.ShoulderZ;
        var deepEndZ = steppedProfile.DeepHole.SpanKind == SupportedBooleanHoleSpanKind.Through
            ? (steppedProfile.EntryFromTop ? box.MinZ : box.MaxZ)
            : steppedProfile.DeepHole.EndCenter.Z;
        var center = new Point3D(steppedProfile.EntryHole.CenterX, steppedProfile.EntryHole.CenterY, 0d);
        var entryCenter = new Point3D(center.X, center.Y, entryZ);
        var shoulderCenter = new Point3D(center.X, center.Y, shoulderZ);
        var deepEndCenter = new Point3D(center.X, center.Y, deepEndZ);
        var entryRadius = steppedProfile.EntryHole.BottomRadius;
        var deepRadius = steppedProfile.DeepHole.BottomRadius;
        var seamAxis = steppedProfile.EntryFromTop ? Direction3D.Create(new Vector3D(0d, 0d, -1d)) : Direction3D.Create(new Vector3D(0d, 0d, 1d));
        var outerSeamStart = entryCenter + (xAxis.ToVector() * entryRadius);
        var outerSeamEnd = shoulderCenter + (xAxis.ToVector() * entryRadius);
        var innerSeamStart = shoulderCenter + (xAxis.ToVector() * deepRadius);
        var innerSeamEnd = deepEndCenter + (xAxis.ToVector() * deepRadius);

        var geometry = new BrepGeometryStore();
        var lineCurves = new[]
        {
            (p1, new Vector3D(width, 0d, 0d)),
            (p2, new Vector3D(0d, depth, 0d)),
            (p3, new Vector3D(-width, 0d, 0d)),
            (p4, new Vector3D(0d, -depth, 0d)),
            (p5, new Vector3D(width, 0d, 0d)),
            (p6, new Vector3D(0d, depth, 0d)),
            (p7, new Vector3D(-width, 0d, 0d)),
            (p8, new Vector3D(0d, -depth, 0d)),
            (p1, new Vector3D(0d, 0d, height)),
            (p2, new Vector3D(0d, 0d, height)),
            (p3, new Vector3D(0d, 0d, height)),
            (p4, new Vector3D(0d, 0d, height)),
        };
        for (var i = 0; i < lineCurves.Length; i++)
        {
            geometry.AddCurve(new CurveGeometryId(i + 1), CurveGeometry.FromLine(new Line3Curve(lineCurves[i].Item1, Direction3D.Create(lineCurves[i].Item2))));
        }

        var entryCurveId = new CurveGeometryId(13);
        var shoulderOuterCurveId = new CurveGeometryId(14);
        var shoulderInnerCurveId = new CurveGeometryId(15);
        var deepEndCurveId = new CurveGeometryId(16);
        var outerSeamCurveId = new CurveGeometryId(17);
        var innerSeamCurveId = new CurveGeometryId(18);
        geometry.AddCurve(entryCurveId, CurveGeometry.FromCircle(new Circle3Curve(entryCenter, zAxis, entryRadius, xAxis)));
        geometry.AddCurve(shoulderOuterCurveId, CurveGeometry.FromCircle(new Circle3Curve(shoulderCenter, zAxis, entryRadius, xAxis)));
        geometry.AddCurve(shoulderInnerCurveId, CurveGeometry.FromCircle(new Circle3Curve(shoulderCenter, zAxis, deepRadius, xAxis)));
        geometry.AddCurve(deepEndCurveId, CurveGeometry.FromCircle(new Circle3Curve(deepEndCenter, zAxis, deepRadius, xAxis)));
        geometry.AddCurve(outerSeamCurveId, CurveGeometry.FromLine(new Line3Curve(outerSeamStart, seamAxis)));
        geometry.AddCurve(innerSeamCurveId, CurveGeometry.FromLine(new Line3Curve(innerSeamStart, seamAxis)));

        geometry.AddSurface(new SurfaceGeometryId(1), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, 0d, box.MinZ), Direction3D.Create(new Vector3D(0d, 0d, -1d)), xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(2), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, 0d, box.MaxZ), zAxis, xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(3), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, box.MinY, 0d), Direction3D.Create(new Vector3D(0d, -1d, 0d)), xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(4), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(box.MaxX, 0d, 0d), Direction3D.Create(new Vector3D(1d, 0d, 0d)), yAxis)));
        geometry.AddSurface(new SurfaceGeometryId(5), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(0d, box.MaxY, 0d), Direction3D.Create(new Vector3D(0d, 1d, 0d)), Direction3D.Create(new Vector3D(-1d, 0d, 0d)))));
        geometry.AddSurface(new SurfaceGeometryId(6), SurfaceGeometry.FromPlane(new PlaneSurface(new Point3D(box.MinX, 0d, 0d), Direction3D.Create(new Vector3D(-1d, 0d, 0d)), yAxis)));
        geometry.AddSurface(new SurfaceGeometryId(7), SurfaceGeometry.FromCylinder(new CylinderSurface(shoulderCenter, zAxis, entryRadius, xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(8), SurfaceGeometry.FromPlane(new PlaneSurface(shoulderCenter, Direction3D.Create(new Vector3D(0d, 0d, steppedProfile.EntryFromTop ? -1d : 1d)), xAxis)));
        geometry.AddSurface(new SurfaceGeometryId(9), SurfaceGeometry.FromCylinder(new CylinderSurface(deepEndCenter, zAxis, deepRadius, xAxis)));
        if (deepBottomFace is not null)
        {
            geometry.AddSurface(new SurfaceGeometryId(10), SurfaceGeometry.FromPlane(new PlaneSurface(deepEndCenter, Direction3D.Create(new Vector3D(0d, 0d, steppedProfile.EntryFromTop ? -1d : 1d)), xAxis)));
        }

        var bindings = new BrepBindingModel();
        for (var i = 0; i < 12; i++)
        {
            bindings.AddEdgeBinding(new EdgeGeometryBinding(new EdgeId(i + 1), new CurveGeometryId(i + 1), new ParameterInterval(0d, 1d)));
        }

        bindings.AddEdgeBinding(new EdgeGeometryBinding(entryCircle, entryCurveId, new ParameterInterval(0d, 2d * double.Pi)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(shoulderOuterCircle, shoulderOuterCurveId, new ParameterInterval(0d, 2d * double.Pi)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(shoulderInnerCircle, shoulderInnerCurveId, new ParameterInterval(0d, 2d * double.Pi)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(deepEndCircle, deepEndCurveId, new ParameterInterval(0d, 2d * double.Pi)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(outerSeam, outerSeamCurveId, new ParameterInterval(0d, (outerSeamEnd - outerSeamStart).Length)));
        bindings.AddEdgeBinding(new EdgeGeometryBinding(innerSeam, innerSeamCurveId, new ParameterInterval(0d, (innerSeamEnd - innerSeamStart).Length)));

        bindings.AddFaceBinding(new FaceGeometryBinding(bottomFace, new SurfaceGeometryId(1)));
        bindings.AddFaceBinding(new FaceGeometryBinding(topFace, new SurfaceGeometryId(2)));
        bindings.AddFaceBinding(new FaceGeometryBinding(xMinFace, new SurfaceGeometryId(3)));
        bindings.AddFaceBinding(new FaceGeometryBinding(xMaxFace, new SurfaceGeometryId(4)));
        bindings.AddFaceBinding(new FaceGeometryBinding(yMaxFace, new SurfaceGeometryId(5)));
        bindings.AddFaceBinding(new FaceGeometryBinding(yMinFace, new SurfaceGeometryId(6)));
        bindings.AddFaceBinding(new FaceGeometryBinding(outerWallFace, new SurfaceGeometryId(7)));
        bindings.AddFaceBinding(new FaceGeometryBinding(shoulderFace, new SurfaceGeometryId(8)));
        bindings.AddFaceBinding(new FaceGeometryBinding(innerWallFace, new SurfaceGeometryId(9)));
        if (deepBottomFace is FaceId deepBottomBinding)
        {
            bindings.AddFaceBinding(new FaceGeometryBinding(deepBottomBinding, new SurfaceGeometryId(10)));
        }

        var vertexPoints = new Dictionary<VertexId, Point3D>
        {
            [v1] = p1,
            [v2] = p2,
            [v3] = p3,
            [v4] = p4,
            [v5] = p5,
            [v6] = p6,
            [v7] = p7,
            [v8] = p8,
            [entryVertex] = outerSeamStart,
            [shoulderOuterVertex] = outerSeamEnd,
            [shoulderInnerVertex] = innerSeamStart,
            [deepEndVertex] = innerSeamEnd,
            [outerSeamStartVertex] = outerSeamStart,
            [outerSeamEndVertex] = outerSeamEnd,
            [innerSeamStartVertex] = innerSeamStart,
            [innerSeamEndVertex] = innerSeamEnd,
        };

        var body = new BrepBody(builder.Model, geometry, bindings, vertexPoints, composition);
        var validation = BrepBindingValidator.Validate(body, requireAllEdgeAndFaceBindings: true);
        return validation.IsSuccess
            ? KernelResult<BrepBody>.Success(body, validation.Diagnostics)
            : KernelResult<BrepBody>.Failure(validation.Diagnostics);
    }

    private static HoleGeometryData CreateHoleGeometry(SupportedBooleanHole hole, AxisAlignedBoxExtents box, Direction3D zAxis, Direction3D xAxis)
    {
        return hole.Surface.Kind switch
        { 
            AnalyticSurfaceKind.Cylinder when hole.Surface.Cylinder is RecognizedCylinder cylinder => CreateCylinderHoleGeometry(hole, xAxis, zAxis, cylinder),
            AnalyticSurfaceKind.Cone when hole.Surface.Cone is RecognizedCone cone => CreateConeHoleGeometry(hole, xAxis, zAxis, cone),
            _ => throw new InvalidOperationException($"Unsupported hole surface kind '{hole.Surface.Kind}'."),
        };
    }

    private static HoleGeometryData CreateCylinderHoleGeometry(SupportedBooleanHole hole, Direction3D xAxis, Direction3D zAxis, in RecognizedCylinder cylinder)
    {
        var topCenter = hole.StartCenter.Z >= hole.EndCenter.Z ? hole.StartCenter : hole.EndCenter;
        var bottomCenter = hole.StartCenter.Z < hole.EndCenter.Z ? hole.StartCenter : hole.EndCenter;
        var axis = hole.Axis;
        var referenceAxis = hole.ReferenceAxis;
        var topEllipse = hole.SpanKind != SupportedBooleanHoleSpanKind.BlindFromBottom;
        var bottomEllipse = hole.SpanKind != SupportedBooleanHoleSpanKind.BlindFromTop;
        var (topCurve, seamTopPoint) = CreateSectionCurve(topCenter, cylinder.Radius, axis, referenceAxis, topEllipse, zAxis);
        var (bottomCurve, seamBottomPoint) = CreateSectionCurve(bottomCenter, cylinder.Radius, axis, referenceAxis, bottomEllipse, zAxis);

        return new HoleGeometryData(
            topCurve,
            bottomCurve,
            CurveGeometry.FromLine(new Line3Curve(seamTopPoint, Direction3D.Create(seamBottomPoint - seamTopPoint))),
            SurfaceGeometry.FromCylinder(new CylinderSurface(bottomCenter, axis, cylinder.Radius, referenceAxis)),
            topCenter,
            bottomCenter,
            seamTopPoint,
            seamBottomPoint,
            (seamBottomPoint - seamTopPoint).Length);
    }

    private static HoleGeometryData CreateConeHoleGeometry(SupportedBooleanHole hole, Direction3D xAxis, Direction3D zAxis, in RecognizedCone cone)
    {
        var startIsTop = hole.StartCenter.Z >= hole.EndCenter.Z;
        var topCenter = startIsTop ? hole.StartCenter : hole.EndCenter;
        var bottomCenter = startIsTop ? hole.EndCenter : hole.StartCenter;
        var topRadius = startIsTop ? hole.BottomRadius : hole.TopRadius;
        var bottomRadius = startIsTop ? hole.TopRadius : hole.BottomRadius;
        var axis = hole.Axis;
        var referenceAxis = hole.ReferenceAxis;
        var topEllipse = hole.SpanKind != SupportedBooleanHoleSpanKind.BlindFromBottom;
        var bottomEllipse = hole.SpanKind != SupportedBooleanHoleSpanKind.BlindFromTop;
        var (topCurve, seamTopPoint) = CreateSectionCurve(topCenter, topRadius, axis, referenceAxis, topEllipse, zAxis);
        var (bottomCurve, seamBottomPoint) = CreateSectionCurve(bottomCenter, bottomRadius, axis, referenceAxis, bottomEllipse, zAxis);
        var innerMinCenter = cone.PointAtAxisParameter(System.Math.Min(cone.MinAxisParameter, cone.MaxAxisParameter));
        var innerMinRadius = cone.RadiusAtAxisParameter(System.Math.Min(cone.MinAxisParameter, cone.MaxAxisParameter));

        return new HoleGeometryData(
            topCurve,
            bottomCurve,
            CurveGeometry.FromLine(new Line3Curve(seamTopPoint, Direction3D.Create(seamBottomPoint - seamTopPoint))),
            SurfaceGeometry.FromCone(new ConeSurface(innerMinCenter, cone.Axis, innerMinRadius, cone.SemiAngleRadians, referenceAxis)),
            topCenter,
            bottomCenter,
            seamTopPoint,
            seamBottomPoint,
            (seamBottomPoint - seamTopPoint).Length);
    }

    private static (CurveGeometry Curve, Point3D SeamPoint) CreateSectionCurve(
        Point3D center,
        double radius,
        Direction3D axis,
        Direction3D referenceAxis,
        bool forceEllipse,
        Direction3D zAxis)
    {
        var axisDotZ = System.Math.Abs(axis.ToVector().Dot(zAxis.ToVector()));
        if (forceEllipse && axisDotZ < 0.999d)
        {
            var majorRadius = radius / axisDotZ;
            var projected = axis.ToVector() - (zAxis.ToVector() * axis.ToVector().Dot(zAxis.ToVector()));
            var majorAxis = Direction3D.Create(projected);
            var seamPoint = center + (majorAxis.ToVector() * majorRadius);
            return (CurveGeometry.FromEllipse(new Ellipse3Curve(center, zAxis, majorRadius, radius, majorAxis)), seamPoint);
        }

        var seam = center + (referenceAxis.ToVector() * radius);
        return (CurveGeometry.FromCircle(new Circle3Curve(center, axis, radius, referenceAxis)), seam);
    }

    private static double AxisParameterAtZ(in RecognizedCone cone, double z)
    {
        var axisZ = cone.Axis.ToVector().Z;
        return (z - cone.AxisOrigin.Z) / axisZ;
    }

    private static BrepBody TranslateMergedBody(BrepBody body, Point3D center, SafeBooleanComposition composition)
    {
        var translation = new Vector3D(center.X, center.Y, center.Z);
        if (translation == Vector3D.Zero)
        {
            return new BrepBody(body.Topology, body.Geometry, body.Bindings, vertexPoints: null, composition, body.ShellRepresentation);
        }

        var translatedGeometry = new BrepGeometryStore();
        foreach (var curveEntry in body.Geometry.Curves)
        {
            translatedGeometry.AddCurve(curveEntry.Key, curveEntry.Value.Kind switch
            {
                CurveGeometryKind.Line3 => CurveGeometry.FromLine(new Line3Curve(curveEntry.Value.Line3!.Value.Origin + translation, curveEntry.Value.Line3.Value.Direction)),
                CurveGeometryKind.Circle3 => CurveGeometry.FromCircle(new Circle3Curve(curveEntry.Value.Circle3!.Value.Center + translation, curveEntry.Value.Circle3.Value.Normal, curveEntry.Value.Circle3.Value.Radius, curveEntry.Value.Circle3.Value.XAxis)),
                _ => curveEntry.Value
            });
        }

        foreach (var surfaceEntry in body.Geometry.Surfaces)
        {
            translatedGeometry.AddSurface(surfaceEntry.Key, surfaceEntry.Value.Kind switch
            {
                SurfaceGeometryKind.Plane => SurfaceGeometry.FromPlane(new PlaneSurface(surfaceEntry.Value.Plane!.Value.Origin + translation, surfaceEntry.Value.Plane.Value.Normal, surfaceEntry.Value.Plane.Value.UAxis)),
                SurfaceGeometryKind.Cylinder => SurfaceGeometry.FromCylinder(new CylinderSurface(surfaceEntry.Value.Cylinder!.Value.Origin + translation, surfaceEntry.Value.Cylinder.Value.Axis, surfaceEntry.Value.Cylinder.Value.Radius, surfaceEntry.Value.Cylinder.Value.XAxis)),
                _ => surfaceEntry.Value
            });
        }

        var vertexPoints = new Dictionary<VertexId, Point3D>();
        foreach (var vertex in body.Topology.Vertices)
        {
            if (body.TryGetVertexPoint(vertex.Id, out var point))
            {
                vertexPoints[vertex.Id] = point + translation;
            }
        }

        return new BrepBody(body.Topology, translatedGeometry, body.Bindings, vertexPoints, composition, body.ShellRepresentation);
    }

    private static BrepBody TranslateBody(BrepBody body, Vector3D translation)
    {
        if (translation == Vector3D.Zero)
        {
            return body;
        }

        var translatedGeometry = new BrepGeometryStore();
        foreach (var curveEntry in body.Geometry.Curves)
        {
            translatedGeometry.AddCurve(curveEntry.Key, curveEntry.Value.Kind switch
            {
                CurveGeometryKind.Line3 => CurveGeometry.FromLine(new Line3Curve(curveEntry.Value.Line3!.Value.Origin + translation, curveEntry.Value.Line3.Value.Direction)),
                CurveGeometryKind.Circle3 => CurveGeometry.FromCircle(new Circle3Curve(curveEntry.Value.Circle3!.Value.Center + translation, curveEntry.Value.Circle3.Value.Normal, curveEntry.Value.Circle3.Value.Radius, curveEntry.Value.Circle3.Value.XAxis)),
                _ => curveEntry.Value
            });
        }

        foreach (var surfaceEntry in body.Geometry.Surfaces)
        {
            translatedGeometry.AddSurface(surfaceEntry.Key, surfaceEntry.Value.Kind switch
            {
                SurfaceGeometryKind.Plane => SurfaceGeometry.FromPlane(new PlaneSurface(surfaceEntry.Value.Plane!.Value.Origin + translation, surfaceEntry.Value.Plane.Value.Normal, surfaceEntry.Value.Plane.Value.UAxis)),
                SurfaceGeometryKind.Cylinder => SurfaceGeometry.FromCylinder(new CylinderSurface(surfaceEntry.Value.Cylinder!.Value.Origin + translation, surfaceEntry.Value.Cylinder.Value.Axis, surfaceEntry.Value.Cylinder.Value.Radius, surfaceEntry.Value.Cylinder.Value.XAxis)),
                _ => surfaceEntry.Value
            });
        }

        Dictionary<VertexId, Point3D>? vertexPoints = null;
        if (body.Topology.Vertices.Any())
        {
            vertexPoints = [];
            foreach (var vertex in body.Topology.Vertices)
            {
                if (body.TryGetVertexPoint(vertex.Id, out var point))
                {
                    vertexPoints[vertex.Id] = point + translation;
                }
            }
        }

        return new BrepBody(body.Topology, translatedGeometry, body.Bindings, vertexPoints, body.SafeBooleanComposition, body.ShellRepresentation);
    }

    private static IReadOnlyDictionary<VertexId, Point3D> GetVertexPoints(BrepBody body)
    {
        var points = new Dictionary<VertexId, Point3D>();
        foreach (var vertex in body.Topology.Vertices)
        {
            if (body.TryGetVertexPoint(vertex.Id, out var point))
            {
                points[vertex.Id] = point;
            }
        }

        return points;
    }

    private static LoopId AddLoop(TopologyBuilder builder, IReadOnlyList<EdgeUse> edgeUses)
    {
        var loopId = builder.AllocateLoopId();
        var coedgeIds = new CoedgeId[edgeUses.Count];

        for (var i = 0; i < edgeUses.Count; i++)
        {
            coedgeIds[i] = builder.AllocateCoedgeId();
        }

        for (var i = 0; i < edgeUses.Count; i++)
        {
            var next = coedgeIds[(i + 1) % edgeUses.Count];
            var prev = coedgeIds[(i + edgeUses.Count - 1) % edgeUses.Count];
            builder.AddCoedge(new Coedge(coedgeIds[i], edgeUses[i].EdgeId, loopId, next, prev, edgeUses[i].IsReversed));
        }

        builder.AddLoop(new Loop(loopId, coedgeIds));
        return loopId;
    }

    private static LoopId AddSurgeryLoop(TopologyBuilder builder, IReadOnlyList<EdgeUse> edgeUses)
    {
        // Periodic analytic faces use the seam twice; preserve the established
        // coedge senses at this explicitly named compatibility seam.
        return BrepLoopBuilder.CreateKnownLoopPreservingLegacySense(
            builder,
            edgeUses.Select(use => new BrepEdgeUse(use.EdgeId, use.IsReversed)).ToArray()).Value;
    }

    private static FaceId AddKnownFace(TopologyBuilder builder, IReadOnlyList<LoopId> loops)
        => BrepFaceBuilder.CreateKnownFaceFromLoops(builder, loops[0], loops.Skip(1).ToArray()).Value;

    private static bool SupportsBoundedBlindContinuationOnRecognizedOrthogonalAdditiveRoot(
        SafeBooleanComposition composition,
        ToleranceContext tolerance)
    {
        if ((composition.OccupiedCells is null || composition.OccupiedCells.Count < 2)
            && composition.RootDescriptor.Kind != SafeBooleanRootKind.Box)
        {
            return false;
        }

        foreach (var hole in composition.Holes.Where(h => h.IsBlind))
        {
            if (hole.Surface.Kind is not (AnalyticSurfaceKind.Cylinder or AnalyticSurfaceKind.Cone)
                || !IsAxisAlignedWithWorldZ(hole.Axis, tolerance))
            {
                return false;
            }
        }

        return true;
    }

    private static bool IsAxisAlignedWithWorldZ(Direction3D axis, ToleranceContext tolerance)
    {
        var v = axis.ToVector();
        return ToleranceMath.AlmostZero(v.X, tolerance)
            && ToleranceMath.AlmostZero(v.Y, tolerance)
            && ToleranceMath.AlmostEqual(System.Math.Abs(v.Z), 1d, tolerance);
    }

    private readonly record struct HoleTopology(
        SupportedBooleanHole Hole,
        VertexId TopHoleVertex,
        VertexId BottomHoleVertex,
        VertexId SeamTopVertex,
        VertexId SeamBottomVertex,
        EdgeId TopCircle,
        EdgeId BottomCircle,
        EdgeId Seam);

    private readonly record struct HoleGeometryData(
        CurveGeometry TopCircle,
        CurveGeometry BottomCircle,
        CurveGeometry Seam,
        SurfaceGeometry Surface,
        Point3D TopCenter,
        Point3D BottomCenter,
        Point3D SeamTopPoint,
        Point3D SeamBottomPoint,
        double SeamLength);

    private readonly record struct EdgeUse(EdgeId EdgeId, bool IsReversed);

    private static EdgeUse Forward(EdgeId edgeId) => new(edgeId, IsReversed: false);

    private static EdgeUse Reversed(EdgeId edgeId) => new(edgeId, IsReversed: true);
}