Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

201 KB
Raw Blame
using Aetheris.Kernel.Core.Diagnostics;
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.Results;
using Aetheris.Kernel.Core.Topology;

namespace Aetheris.Kernel.Core.Brep.Tessellation;

public static class BrepDisplayTessellator
{
    private const double LoopEndpointTolerance = 1e-6d;
    private const string PlanarCurveFlatteningUnsupportedSource = "Viewer.Tessellation.PlanarCurveFlatteningUnsupported";
    private const string PlanarCurveFlatteningFailedSource = "Viewer.Tessellation.PlanarCurveFlatteningFailed";
    private const string CircleTrimResolveFailedSource = "Viewer.Tessellation.CircleTrimResolveFailed";
    private const string CircleTrimAmbiguousUsedShorterArcSource = "Viewer.Tessellation.CircleTrimAmbiguousUsedShorterArc";
    private const string CylinderTrimUnsupportedSource = "Viewer.Tessellation.CylinderTrimUnsupported";
    private const string CylinderTrimDegenerateSource = "Viewer.Tessellation.CylinderTrimDegenerate";
    private const string CylinderTrimAxialSpanDegenerateSource = "Viewer.Tessellation.CylinderTrimAxialSpanDegenerate";
    private const string CylinderTrimAxialSpanDegenerateSingleCoedgeNearFullWrapSource = "Viewer.Tessellation.CylinderTrimAxialSpanDegenerate.SingleCoedgeNearFullWrap";
    private const string CylinderTrimAxialSpanDegenerateSingleCoedgeSource = "Viewer.Tessellation.CylinderTrimAxialSpanDegenerate.SingleCoedge";
    private const string CylinderTrimAxialSpanDegenerateMultiCoedgeSource = "Viewer.Tessellation.CylinderTrimAxialSpanDegenerate.MultiCoedge";
    private const string CylinderTrimAxialSpanDegenerateSingleCoedgeNearFullWrapBridgeSource = "Viewer.Tessellation.CylinderTrimAxialSpanDegenerate.SingleCoedgeNearFullWrapBridge";
    private const string CylinderTrimAmbiguousUsedShorterSpanSource = "Viewer.Tessellation.CylinderTrimAmbiguousUsedShorterSpan";
    private const string CylinderTrimDualSingleCoedgeClosedCircleSource = "Viewer.Tessellation.CylinderTrim.DualSingleCoedgeClosedCircle";
    private const string CurvedTopologyUnsupportedSource = "Viewer.Tessellation.CurvedTopologyUnsupported";
    private const string BSplineSurfaceTrimUnsupportedSource = "Viewer.Tessellation.BSplineSurfaceTrimUnsupported";
    private const string PlanarMultiLoopTriangulationSkippedSource = "Viewer.Tessellation.PlanarMultiLoopTriangulationSkipped";
    private const string TrimEvaluationFailedSource = "Viewer.Tessellation.TrimEvaluationFailed";

    public static KernelResult<DisplayTessellationResult> Tessellate(BrepBody body, DisplayTessellationOptions? options = null)
        => TessellateCore(body, options, null);

    /// <summary>Migration oracle used by focused comparisons; it is not the default display route.</summary>
    internal static KernelResult<DisplayTessellationResult> TessellateLegacyForComparison(BrepBody body, DisplayTessellationOptions? options = null)
        => TessellateCore(body, options, null);

    /// <summary>Explicit M3 SurfaceMeshIR route; unsupported trim families are reported rather than silently downgraded.</summary>
    public static KernelResult<DisplayTessellationResult> TessellateSurfaceMeshIr(BrepBody body, DisplayTessellationOptions? options = null)
    {
        var effectiveOptions = options ?? DisplayTessellationOptions.Default;
        return SurfaceMeshIrTessellator.TryTessellate(body, effectiveOptions, out var result)
            ? KernelResult<DisplayTessellationResult>.Success(result)
            : KernelResult<DisplayTessellationResult>.Failure([CreateNotImplemented("SurfaceMeshIR supports admitted planar/conic bands, closed sphere charts, bounded convex sphere/ellipsoid trims and admitted torus patches. General arbitrary trimmed-patch remeshing remains unsupported by this route.", "Viewer.SurfaceMeshIr.Unsupported")]);
    }

    public static KernelResult<DisplayTessellationResult> TessellateBounded(
        BrepBody body,
        DisplayTessellationOptions? options = null,
        TimeSpan? executionTimeout = null)
        => TessellateCore(body, options, new DisplayTessellationExecutionBudget(executionTimeout ?? TimeSpan.FromSeconds(5)));


    public static DisplayTessellationResult TessellateBoundedPartial(
        BrepBody body,
        DisplayTessellationOptions? options = null,
        TimeSpan? executionTimeout = null)
    {
        var effectiveOptions = options ?? DisplayTessellationOptions.Default;
        var executionBudget = new DisplayTessellationExecutionBudget(executionTimeout ?? TimeSpan.FromSeconds(5));
        var facePatches = new List<DisplayFaceMeshPatch>();
        var faceDiagnostics = new List<DisplayFaceMaterializationDiagnostic>();

        foreach (var face in body.Topology.Faces.OrderBy(f => f.Id.Value))
        {
            var surfaceKind = TryGetSurfaceKind(body, face.Id);
            try
            {
                executionBudget.ThrowIfExpired("FaceDispatch", face.Id, surfaceKind);
                var faceResult = ExecuteWithinOptionalBudget(
                    () => TessellateFace(body, face.Id, effectiveOptions, executionBudget),
                    executionBudget,
                    "FaceTessellation",
                    face.Id,
                    surfaceKind,
                    executionBudget.Remaining + TimeSpan.FromMilliseconds(250));

                foreach (var diagnostic in faceResult.Diagnostics)
                {
                    faceDiagnostics.Add(new DisplayFaceMaterializationDiagnostic(
                        face.Id,
                        surfaceKind?.ToString(),
                        ExtractPhase(diagnostic.Message),
                        diagnostic.Source ?? diagnostic.Code.ToString(),
                        diagnostic.Message));
                }
                // A successful partial result can be an empty patch with a trim
                // rejection warning. Keep that warning alongside the retained mesh.
                if (faceResult.IsSuccess)
                    facePatches.Add(faceResult.Value);
            }
            catch (DisplayTessellationTimeoutException ex)
            {
                faceDiagnostics.Add(new DisplayFaceMaterializationDiagnostic(
                    ex.FaceId ?? face.Id,
                    ex.SurfaceKind?.ToString() ?? surfaceKind?.ToString(),
                    ex.Phase,
                    "Viewer.Tessellation.Timeout",
                    ex.Message));
            }
        }

        var edgePolylines = new List<DisplayEdgePolyline>();
        foreach (var edge in body.Topology.Edges.OrderBy(e => e.Id.Value))
        {
            try
            {
                var edgeResult = TessellateEdge(body, edge.Id, effectiveOptions);
                if (edgeResult.IsSuccess)
                {
                    edgePolylines.Add(edgeResult.Value);
                }
            }
            catch (DisplayTessellationTimeoutException)
            {
                break;
            }
        }

        return new DisplayTessellationResult(facePatches, edgePolylines, faceDiagnostics);
    }

    private static string ExtractPhase(string message)
    {
        const string marker = "during phase '";
        var start = message.IndexOf(marker, StringComparison.Ordinal);
        if (start < 0) return "FaceTessellation";
        start += marker.Length;
        var end = message.IndexOf('\'', start);
        return end > start ? message[start..end] : "FaceTessellation";
    }

    private static KernelResult<DisplayTessellationResult> TessellateCore(
        BrepBody body,
        DisplayTessellationOptions? options,
        DisplayTessellationExecutionBudget? executionBudget)
    {
        if (body is null)
        {
            return KernelResult<DisplayTessellationResult>.Failure([CreateInvalidArgument("body must be provided.")]);
        }

        var effectiveOptions = options ?? DisplayTessellationOptions.Default;
        var optionDiagnostics = effectiveOptions.Validate();
        if (optionDiagnostics.Count > 0)
        {
            return KernelResult<DisplayTessellationResult>.Failure(optionDiagnostics);
        }

        var accumulatedDiagnostics = new List<KernelDiagnostic>();

        var facePatches = new List<DisplayFaceMeshPatch>();
        try
        {
            var facePhase = BuildPerfTrace.Phase("tessellation.faces");
            foreach (var face in body.Topology.Faces.OrderBy(f => f.Id.Value))
            {
                executionBudget?.ThrowIfExpired("FaceDispatch", face.Id);
                var faceResult = ExecuteWithinOptionalBudget(
                    () => TessellateFace(body, face.Id, effectiveOptions, executionBudget),
                    executionBudget,
                    "FaceTessellation",
                    face.Id,
                    TryGetSurfaceKind(body, face.Id),
                    executionBudget is null ? null : executionBudget.Remaining + TimeSpan.FromMilliseconds(250));
                if (!faceResult.IsSuccess)
                {
                    return KernelResult<DisplayTessellationResult>.Failure(faceResult.Diagnostics);
                }

                facePatches.Add(faceResult.Value);
                accumulatedDiagnostics.AddRange(faceResult.Diagnostics);
            }
            facePhase.Dispose();

            var edgePolylines = new List<DisplayEdgePolyline>();
            var edgePhase = BuildPerfTrace.Phase("tessellation.display-edges");
            foreach (var edge in body.Topology.Edges.OrderBy(e => e.Id.Value))
            {
                executionBudget?.ThrowIfExpired("EdgeDispatch");
                var edgeResult = ExecuteWithinOptionalBudget(
                    () => TessellateEdge(body, edge.Id, effectiveOptions),
                    executionBudget,
                    "EdgeTessellation");
                if (!edgeResult.IsSuccess)
                {
                    return KernelResult<DisplayTessellationResult>.Failure(edgeResult.Diagnostics);
                }

                edgePolylines.Add(edgeResult.Value);
                accumulatedDiagnostics.AddRange(edgeResult.Diagnostics);
            }
            edgePhase.Dispose();

            return KernelResult<DisplayTessellationResult>.Success(new DisplayTessellationResult(facePatches, edgePolylines), accumulatedDiagnostics);
        }
        catch (DisplayTessellationTimeoutException ex)
        {
            return KernelResult<DisplayTessellationResult>.Failure([CreateValidationError(ex.Message, "Viewer.Tessellation.Timeout")]);
        }
    }

    private static KernelResult<T> ExecuteWithinBudget<T>(
        Func<KernelResult<T>> action,
        DisplayTessellationExecutionBudget executionBudget,
        string phase,
        FaceId? faceId = null,
        SurfaceGeometryKind? surfaceKind = null,
        TimeSpan? timeoutOverride = null)
    {
        try
        {
            return Task.Run(action)
                .WaitAsync(timeoutOverride ?? executionBudget.Remaining)
                .GetAwaiter()
                .GetResult();
        }
        catch (TimeoutException)
        {
            throw new DisplayTessellationTimeoutException(phase, executionBudget.Elapsed, faceId, surfaceKind);
        }
    }

    private static KernelResult<T> ExecuteWithinOptionalBudget<T>(
        Func<KernelResult<T>> action,
        DisplayTessellationExecutionBudget? executionBudget,
        string phase,
        FaceId? faceId = null,
        SurfaceGeometryKind? surfaceKind = null,
        TimeSpan? timeoutOverride = null)
        => executionBudget is null
            ? action()
            : ExecuteWithinBudget(action, executionBudget, phase, faceId, surfaceKind, timeoutOverride);

    private static SurfaceGeometryKind? TryGetSurfaceKind(BrepBody body, FaceId faceId)
    {
        if (!body.TryGetFaceSurfaceGeometry(faceId, out var surface) || surface is null)
        {
            return null;
        }

        return surface.Kind;
    }

    private static KernelResult<DisplayFaceMeshPatch> TessellateFace(BrepBody body, FaceId faceId, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
    {
        if (!body.TryGetFaceSurfaceGeometry(faceId, out var surface) || surface is null)
        {
            return KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} is missing bound surface geometry.")]);
        }

        executionBudget?.ThrowIfExpired("FaceSurfaceDispatch", faceId, surface.Kind);

        // Every surface kind is tessellated in its own parameterization, whose normal is the support's, not the
        // face's. Projecting the face sense here - once, at the only place face patches are produced - is what makes
        // a body's display mesh consistently outward-oriented instead of per-face arbitrary.
        var patch = TessellateFaceSupport(body, faceId, surface, options, executionBudget);
        return patch.IsSuccess
            ? KernelResult<DisplayFaceMeshPatch>.Success(DisplayMeshOrientation.ProjectCanonicalOrientation(body, patch.Value), patch.Diagnostics)
            : patch;
    }

    private static KernelResult<DisplayFaceMeshPatch> TessellateFaceSupport(BrepBody body, FaceId faceId, SurfaceGeometry surface, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget)
    {
        return surface.Kind switch
        {
            SurfaceGeometryKind.Plane => TessellatePlanarFaceWithSamplingRetry(body, faceId, surface.Plane!.Value, options, executionBudget),
            SurfaceGeometryKind.Cylinder => TessellateCylinderFace(body, faceId, surface.Cylinder!.Value, options, executionBudget),
            SurfaceGeometryKind.Cone => TessellateConeFace(body, faceId, surface.Cone!.Value, options, executionBudget),
            SurfaceGeometryKind.Sphere => TessellateSphereFace(body, faceId, surface.Sphere!.Value, options, executionBudget),
            SurfaceGeometryKind.Ellipsoid => TessellateEllipsoidFace(body, faceId, surface.Ellipsoid!, options, executionBudget),
            SurfaceGeometryKind.Torus => TessellateTorusFace(body, faceId, surface.Torus!.Value, options, executionBudget),
            SurfaceGeometryKind.BSplineSurfaceWithKnots => TessellateBSplineSurfaceFace(body, faceId, surface.BSplineSurfaceWithKnots!, options, executionBudget),
            SurfaceGeometryKind.LinearExtrusion when surface.LinearExtrusion!.Value.Directrix.Ellipse3.HasValue
                => TessellateEllipticExtrusionFace(body, faceId, surface.LinearExtrusion.Value, options, executionBudget),
            SurfaceGeometryKind.LinearExtrusion when surface.LinearExtrusion!.Value.Directrix.BSpline3 is { } curve
                => TessellateBSplineSurfaceFace(body, faceId, new BSplineSurfaceWithKnots(
                    curve.Degree, 1,
                    curve.ControlPoints.Select(p => (IReadOnlyList<Point3D>)new[] { p, p + surface.LinearExtrusion.Value.ExtrusionVector }).ToArray(),
                    "RULED_SURF", curve.ClosedCurve, false, curve.SelfIntersect,
                    curve.KnotMultiplicities, [2, 2], curve.KnotValues, [0d, 1d], curve.KnotSpec), options, executionBudget),
            _ => KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} has unsupported surface kind '{surface.Kind}'.")]),
        };
    }

    private static KernelResult<DisplayFaceMeshPatch> TessellateEllipticExtrusionFace(BrepBody body, FaceId faceId,
        LinearExtrusionSurface surface, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? budget)
    {
        var ellipse = surface.Directrix.Ellipse3!.Value;
        var vector = surface.ExtrusionVector;
        var height = vector.Dot(ellipse.Normal.ToVector());
        if (double.Abs(height) <= 1e-12 * vector.Length)
            return KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} has a degenerate in-plane elliptic extrusion.")]);
        var loops = body.GetLoopIds(faceId).Where(id => body.Topology.GetLoop(id).Kind == LoopKind.Edge).ToArray();
        if (loops.Length == 0)
            return KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} elliptic extrusion requires explicit trim loops.")]);
        (double U, double V)? Project(Point3D point)
        {
            var v = (point - ellipse.Center).Dot(ellipse.Normal.ToVector()) / height;
            var radial = point - (ellipse.Center + vector * v);
            var u = double.Atan2(radial.Dot(ellipse.YAxis.ToVector()) / ellipse.MinorRadius,
                radial.Dot(ellipse.XAxis.ToVector()) / ellipse.MajorRadius);
            var residual = point - (ellipse.Evaluate(u) + vector * v);
            return residual.Length <= 1e-6 ? (u, v) : null;
        }
        var trim = TryBuildPeriodicTrimmedSurfaceUvLoops(body, faceId, loops, Project, options, budget, SurfaceGeometryKind.LinearExtrusion);
        if (!trim.IsSuccess) return KernelResult<DisplayFaceMeshPatch>.Failure(trim.Diagnostics);
        var patch = TrimmedSurfaceTessellator.Tessellate(faceId, trim.Value,
            (u, v) => ellipse.Evaluate(u) + vector * v,
            (u, _) => Direction3D.Create((ellipse.XAxis.ToVector() * (-ellipse.MajorRadius * double.Sin(u))
                + ellipse.YAxis.ToVector() * (ellipse.MinorRadius * double.Cos(u))).Cross(vector)).ToVector(),
            options, double.NegativeInfinity, double.PositiveInfinity, double.NegativeInfinity, double.PositiveInfinity,
            CreateValidationWarning, budget, SurfaceGeometryKind.LinearExtrusion);
        return patch.IsSuccess && patch.Value.TriangleIndices.Count == 0
            ? KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} elliptic extrusion trim produced no display triangles.")])
            : patch;
    }

    private static KernelResult<DisplayFaceMeshPatch> TessellatePlanarFaceWithSamplingRetry(BrepBody body, FaceId faceId,
        PlaneSurface plane, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? budget)
    {
        var patch = TessellatePlanarFace(body, faceId, plane, options, budget);
        if (options.ChordTolerance <= DisplayTessellationOptions.Default.ChordTolerance
            || patch.IsSuccess && patch.Value.TriangleIndices.Count > 0) return patch;
        // Coarse display chords can cross a narrow valid trim. One bounded retry
        // samples the same authoritative curves more finely; it does not heal loops.
        return TessellatePlanarFace(body, faceId, plane, options with {
            ChordTolerance = DisplayTessellationOptions.Default.ChordTolerance
        }, budget);
    }

    private static KernelResult<DisplayFaceMeshPatch> TessellatePlanarFace(BrepBody body, FaceId faceId, PlaneSurface plane, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
    {
        var loopIds = body.GetLoopIds(faceId)
            .Where(loopId => body.Topology.GetLoop(loopId).Kind == LoopKind.Edge)
            .ToArray();
        if (loopIds.Length == 0)
        {
            return KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} planar tessellation requires at least one loop.")]);
        }

        if (loopIds.Length == 1)
        {
            var simpleLoopPoints = ExecuteWithinOptionalBudget(
                () => FlattenPlanarLoop(body, faceId, plane, options, loopIds[0]),
                executionBudget,
                "PlanarLoopFlattening",
                faceId,
                SurfaceGeometryKind.Plane);
            if (!simpleLoopPoints.IsSuccess)
            {
                return KernelResult<DisplayFaceMeshPatch>.Failure(simpleLoopPoints.Diagnostics);
            }

            return ExecuteWithinOptionalBudget(
                () => TriangulatePlanarPatch(faceId, plane, simpleLoopPoints.Value),
                executionBudget,
                "PlanarTriangulation",
                faceId,
                SurfaceGeometryKind.Plane);
        }

        var flattenedLoops = new Dictionary<LoopId, IReadOnlyList<Point3D>>();
        foreach (var loopId in loopIds.OrderBy(id => id.Value))
        {
            var flattenedLoop = ExecuteWithinOptionalBudget(
                () => FlattenPlanarLoop(body, faceId, plane, options, loopId),
                executionBudget,
                "PlanarLoopFlattening",
                faceId,
                SurfaceGeometryKind.Plane);
            if (!flattenedLoop.IsSuccess)
            {
                return KernelResult<DisplayFaceMeshPatch>.Failure(flattenedLoop.Diagnostics);
            }

            flattenedLoops[loopId] = flattenedLoop.Value;
        }

        var loopClassification = ExecuteWithinOptionalBudget(
            () => KernelResult<IReadOnlyList<PlanarLoopClassification>>.Success(new PlanarDisplayLoopClassifier().Classify(
                faceId.Value,
                loopIds.OrderBy(id => id.Value).Select(id => (id.Value, flattenedLoops[id])).ToArray())),
            executionBudget,
            "PlanarLoopClassification",
            faceId,
            SurfaceGeometryKind.Plane);
        if (!loopClassification.IsSuccess)
        {
            return KernelResult<DisplayFaceMeshPatch>.Failure(loopClassification.Diagnostics);
        }

        var classifications = loopClassification.Value;
        var unsupported = classifications.FirstOrDefault(item => item.Role is PlanarDisplayLoopRole.Degenerate or PlanarDisplayLoopRole.UnsupportedNested or PlanarDisplayLoopRole.Island or PlanarDisplayLoopRole.Unknown);
        if (unsupported is not null)
        {
            var code = unsupported.Role == PlanarDisplayLoopRole.Degenerate
                ? "Viewer.PlanarTriangulation.DegenerateLoop"
                : unsupported.Role is PlanarDisplayLoopRole.UnsupportedNested or PlanarDisplayLoopRole.Island
                    ? "Viewer.PlanarTriangulation.UnsupportedNesting"
                    : "Viewer.PlanarTriangulation.InvalidLoop";
            return KernelResult<DisplayFaceMeshPatch>.Success(
                CreateEmptyPlanarPatch(faceId),
                [CreateValidationWarning($"Face {faceId.Value} planar loop {unsupported.Loop.LoopId} classified as {unsupported.Role}; reasons=[{string.Join(",", unsupported.Reasons)}].", code)]);
        }

        var outer = classifications.SingleOrDefault(item => item.Role == PlanarDisplayLoopRole.Outer);
        if (outer is null)
        {
            return KernelResult<DisplayFaceMeshPatch>.Success(
                CreateEmptyPlanarPatch(faceId),
                [CreateValidationWarning($"Face {faceId.Value} planar multi-loop tessellation could not select a unique outer loop.", "Viewer.PlanarTriangulation.InvalidLoop")]);
        }

        var outerLoop = outer.Loop.Points3D;
        var holes = classifications
            .Where(item => item.Role == PlanarDisplayLoopRole.Hole)
            .OrderBy(item => item.Loop.LoopId)
            .Select(item => item.Loop.Points3D)
            .ToArray();

        var triangulationResult = ExecuteWithinOptionalBudget(
            () =>
            {
                // The hole-bridging triangulator is super-linear in the number of holes and can exhaust the whole
                // display budget on a plate with dozens of holes; earcut handles those directly and cheaply.
                if (holes.Length >= ManyHolesEarCutThreshold
                    && TryEarCutPlanarLoops(plane, outerLoop, holes, out var manyHolesPoints, out var manyHolesIndices))
                {
                    return KernelResult<(IReadOnlyList<Point3D> Points, IReadOnlyList<int> Indices, PlanarPolygonTriangulationFailure? Failure)>.Success((manyHolesPoints, manyHolesIndices, null));
                }

                if (!PlanarPolygonTriangulator.TryTriangulateWithHoles(
                        outerLoop,
                        holes,
                        plane.Normal.ToVector(),
                        out var triangulationPoints,
                        out var indices,
                        out var failure))
                {
                    // The primary triangulator declines some long, finely sampled but simple loops; earcut is the second opinion.
                    if (failure == PlanarPolygonTriangulationFailure.TriangulationFailed
                        && TryEarCutPlanarLoops(plane, outerLoop, holes, out var earCutPoints, out var earCutIndices))
                    {
                        return KernelResult<(IReadOnlyList<Point3D> Points, IReadOnlyList<int> Indices, PlanarPolygonTriangulationFailure? Failure)>.Success((earCutPoints, earCutIndices, null));
                    }

                    return KernelResult<(IReadOnlyList<Point3D> Points, IReadOnlyList<int> Indices, PlanarPolygonTriangulationFailure? Failure)>.Failure([
                        CreateValidationWarning(
                            $"Face {faceId.Value} planar multi-loop tessellation could not be resolved ({failure?.ToString() ?? "Unknown"}); skipping face patch to avoid misleading filled geometry.",
                            PlanarMultiLoopTriangulationSkippedSource)]);
                }

                return KernelResult<(IReadOnlyList<Point3D> Points, IReadOnlyList<int> Indices, PlanarPolygonTriangulationFailure? Failure)>.Success((triangulationPoints, indices, null));
            },
            executionBudget,
            "PlanarTriangulationWithHoles",
            faceId,
            SurfaceGeometryKind.Plane);

        if (!triangulationResult.IsSuccess)
        {
            if (triangulationResult.Diagnostics.Any(diagnostic => string.Equals(diagnostic.Source, "Viewer.Tessellation.Timeout", StringComparison.Ordinal)))
            {
                return KernelResult<DisplayFaceMeshPatch>.Failure(triangulationResult.Diagnostics);
            }

            return KernelResult<DisplayFaceMeshPatch>.Success(CreateEmptyPlanarPatch(faceId), triangulationResult.Diagnostics.Where(diagnostic => diagnostic.Severity != KernelDiagnosticSeverity.Error));
        }

        return KernelResult<DisplayFaceMeshPatch>.Success(CreatePlanarPatch(faceId, triangulationResult.Value.Points, plane.Normal.ToVector(), triangulationResult.Value.Indices));
    }

    private const int ManyHolesEarCutThreshold = 8;

    internal static bool TryEarCutPlanarLoops(
        PlaneSurface plane,
        IReadOnlyList<Point3D> outerLoop,
        IReadOnlyList<IReadOnlyList<Point3D>> holes,
        out IReadOnlyList<Point3D> points,
        out IReadOnlyList<int> indices)
    {
        points = Array.Empty<Point3D>();
        indices = Array.Empty<int>();
        var uAxis = plane.UAxis.ToVector();
        var vAxis = plane.VAxis.ToVector();
        var origin = plane.Origin;
        (double X, double Y) Project(Point3D point)
        {
            var offset = point - origin;
            return (offset.Dot(uAxis), offset.Dot(vAxis));
        }

        var outer2d = outerLoop.Select(Project).ToList();
        var holes2d = holes.Select(hole => (IReadOnlyList<(double X, double Y)>)hole.Select(Project).ToList()).ToList();
        if (!EarCutTriangulator.TryTriangulate(outer2d, holes2d, out var points2d, out var earCutIndices))
        {
            return false;
        }

        var points3d = outerLoop.Concat(holes.SelectMany(hole => hole)).ToArray();
        if (points3d.Length != points2d.Count)
        {
            return false;
        }

        // Emit every triangle counter-clockwise about the plane normal.
        var oriented = new List<int>(earCutIndices.Count);
        for (var i = 0; i + 2 < earCutIndices.Count; i += 3)
        {
            var a = points2d[earCutIndices[i]];
            var b = points2d[earCutIndices[i + 1]];
            var c = points2d[earCutIndices[i + 2]];
            var cross = ((b.X - a.X) * (c.Y - a.Y)) - ((b.Y - a.Y) * (c.X - a.X));
            if (cross >= 0d)
            {
                oriented.Add(earCutIndices[i]);
                oriented.Add(earCutIndices[i + 1]);
                oriented.Add(earCutIndices[i + 2]);
            }
            else
            {
                oriented.Add(earCutIndices[i]);
                oriented.Add(earCutIndices[i + 2]);
                oriented.Add(earCutIndices[i + 1]);
            }
        }

        points = points3d;
        indices = oriented;
        return true;
    }

    private static KernelResult<DisplayFaceMeshPatch> TriangulatePlanarPatch(FaceId faceId, PlaneSurface plane, IReadOnlyList<Point3D> polygonPoints)
    {
        if (!PlanarPolygonTriangulator.TryTriangulate(polygonPoints, plane.Normal.ToVector(), out var indices, out var failure))
        {
            return failure switch
            {
                PlanarPolygonTriangulationFailure.Degenerate => KernelResult<DisplayFaceMeshPatch>.Failure([
                    CreateInvalidArgument($"Face {faceId.Value} planar loop is degenerate and cannot be triangulated.", "Viewer.Tessellation.PlanarPolygonDegenerate")]),
                PlanarPolygonTriangulationFailure.NonSimple => KernelResult<DisplayFaceMeshPatch>.Failure([
                    CreateNotImplemented($"Face {faceId.Value} planar loop triangulation failed because the polygon is not simple.", "Viewer.Tessellation.PlanarNonConvexTriangulationFailed")]),
                _ => KernelResult<DisplayFaceMeshPatch>.Failure([
                    CreateNotImplemented($"Face {faceId.Value} planar loop triangulation failed.", "Viewer.Tessellation.PlanarNonConvexTriangulationFailed")]),
            };
        }

        return KernelResult<DisplayFaceMeshPatch>.Success(CreatePlanarPatch(faceId, polygonPoints, plane.Normal.ToVector(), indices));
    }

    private static KernelResult<IReadOnlyList<Point3D>> FlattenPlanarLoop(
        BrepBody body,
        FaceId faceId,
        PlaneSurface plane,
        DisplayTessellationOptions options,
        LoopId loopId)
    {
        var coedges = body.GetCoedgeIds(loopId)
            .Select(id => body.Topology.GetCoedge(id))
            .ToArray();

        var polygonPointsResult = BuildFlattenedPlanarLoopPoints(body, coedges, faceId, plane, options);
        if (!polygonPointsResult.IsSuccess)
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure(polygonPointsResult.Diagnostics);
        }

        var polygonPoints = polygonPointsResult.Value;
        if (polygonPoints.Count < 3)
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure([
                CreateInvalidArgument($"Face {faceId.Value} planar loop flattening produced fewer than three unique points.", PlanarCurveFlatteningFailedSource)]);
        }

        return KernelResult<IReadOnlyList<Point3D>>.Success(polygonPoints);
    }

    private static LoopId SelectPlanarPrimaryLoop(BrepBody body, FaceId faceId, PlaneSurface plane, IReadOnlyList<LoopId> loopIds)
    {
        if (loopIds.Count <= 1)
        {
            return loopIds[0];
        }

        var lineOnlyLoopCandidates = loopIds.Where(loopId => IsAllLine3Loop(body, loopId)).ToArray();
        if (TrySelectLargestViablePlanarLoop(body, faceId, plane, lineOnlyLoopCandidates, out var selectedLineLoop))
        {
            return selectedLineLoop;
        }

        if (TrySelectLargestViablePlanarLoop(body, faceId, plane, loopIds, out var selectedMixedLoop))
        {
            return selectedMixedLoop;
        }

        return loopIds[0];
    }

    private static bool TrySelectLargestViablePlanarLoop(
        BrepBody body,
        FaceId faceId,
        PlaneSurface plane,
        IReadOnlyList<LoopId> candidateLoopIds,
        out LoopId bestLoop)
    {
        bestLoop = default;
        var bestArea = double.NegativeInfinity;

        foreach (var loopId in candidateLoopIds)
        {
            var coedges = body.GetCoedgeIds(loopId)
                .Select(id => body.Topology.GetCoedge(id))
                .ToArray();

            var pointsResult = BuildFlattenedPlanarLoopPoints(body, coedges, faceId, plane, DisplayTessellationOptions.Default);
            if (!pointsResult.IsSuccess)
            {
                continue;
            }

            var polygonPoints = pointsResult.Value;
            if (polygonPoints.Count < 3)
            {
                continue;
            }

            if (!PlanarPolygonTriangulator.TryTriangulate(polygonPoints, plane.Normal.ToVector(), out _, out _))
            {
                continue;
            }

            var area = double.Abs(ComputeSignedPlanarArea(polygonPoints, plane));
            if (area > bestArea || (System.Math.Abs(area - bestArea) <= 1e-12d && loopId.Value < bestLoop.Value))
            {
                bestArea = area;
                bestLoop = loopId;
            }
        }

        return bestArea > double.NegativeInfinity;
    }

    private static bool IsAllLine3Loop(BrepBody body, LoopId loopId)
    {
        var coedgeIds = body.GetCoedgeIds(loopId);
        for (var i = 0; i < coedgeIds.Count; i++)
        {
            var edgeId = body.Topology.GetCoedge(coedgeIds[i]).EdgeId;
            if (body.GetEdgeCurve(edgeId).Kind != CurveGeometryKind.Line3)
            {
                return false;
            }
        }

        return true;
    }

    private static double ComputeSignedPlanarArea(IReadOnlyList<Point3D> polygonPoints, PlaneSurface plane)
    {
        var uAxis = plane.UAxis.ToVector();
        var vAxis = plane.VAxis.ToVector();
        var area = 0d;

        for (var i = 0; i < polygonPoints.Count; i++)
        {
            var current = polygonPoints[i] - plane.Origin;
            var next = polygonPoints[(i + 1) % polygonPoints.Count] - plane.Origin;
            var currentU = current.Dot(uAxis);
            var currentV = current.Dot(vAxis);
            var nextU = next.Dot(uAxis);
            var nextV = next.Dot(vAxis);
            area += (currentU * nextV) - (nextU * currentV);
        }

        return area * 0.5d;
    }

    private static KernelResult<DisplayFaceMeshPatch> TessellatePlanarCircleFace(BrepBody body, FaceId faceId, Coedge coedge, PlaneSurface plane, DisplayTessellationOptions options)
    {
        var edge = TessellateEdge(body, coedge.EdgeId, options);
        if (!edge.IsSuccess)
        {
            return KernelResult<DisplayFaceMeshPatch>.Failure(edge.Diagnostics);
        }

        var edgePoints = edge.Value.Points;
        if (edgePoints.Count < 4)
        {
            return KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} circular planar tessellation requires at least three perimeter samples.")]);
        }

        var center = new Point3D(
            edgePoints.Take(edgePoints.Count - 1).Average(p => p.X),
            edgePoints.Take(edgePoints.Count - 1).Average(p => p.Y),
            edgePoints.Take(edgePoints.Count - 1).Average(p => p.Z));

        var positions = new List<Point3D> { center };
        positions.AddRange(edgePoints.Take(edgePoints.Count - 1));

        var normal = plane.Normal.ToVector();
        if (coedge.IsReversed)
        {
            normal = -normal;
        }

        var normals = Enumerable.Repeat(normal, positions.Count).ToArray();
        var indices = new List<int>((positions.Count - 2) * 3);
        for (var i = 1; i < positions.Count - 1; i++)
        {
            indices.Add(0);
            indices.Add(i);
            indices.Add(i + 1);
        }

        indices.Add(0);
        indices.Add(positions.Count - 1);
        indices.Add(1);

        return KernelResult<DisplayFaceMeshPatch>.Success(new DisplayFaceMeshPatch(faceId, positions, normals, indices));
    }

    private static KernelResult<DisplayFaceMeshPatch> TessellateCylinderFace(BrepBody body, FaceId faceId, CylinderSurface cylinder, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
    {
        var loopIds = body.GetLoopIds(faceId)
            .Where(loopId => body.Topology.GetLoop(loopId).Kind == LoopKind.Edge)
            .ToArray();
        var recoveryAllowance = body.GetLoopIds(faceId).SelectMany(body.GetCoedgeIds)
            .Select(id => body.GetEdgeCurve(body.Topology.GetCoedge(id).EdgeId).RecoveryProvenance)
            .Where(p => p is not null)
            .Select(p => double.Min(options.ChordTolerance,
                double.Min(p!.RecoveryToleranceMillimetres, p.MeasuredMaxDeviationMillimetres)))
            .DefaultIfEmpty(0d).Max();
        // Intersecting cylindrical fillet rolls terminate on elliptical miter
        // curves. Their axial extent varies with angle; a rectangular UV
        // bounding patch protrudes past the retained face at the corners.
        var ellipticalBoundary = loopIds.Length == 1 && body.GetCoedgeIds(loopIds[0])
            .Any(id => body.GetEdgeCurve(body.Topology.GetCoedge(id).EdgeId).Kind == CurveGeometryKind.Ellipse3);
        // A bounded one-loop face can be a helical strip, a toothed skirt, or a
        // narrow rectangular sector. Its bounding cylinder is not the trim.
        // Prefer the complete bound parameter trace, retaining legacy dispatch
        // for closed-circle/seam families without a polygonal pcurve boundary.
        if (loopIds.Length == 1 && (ellipticalBoundary || body.GetCoedgeIds(loopIds[0]).Count >= 3
            && body.GetCoedgeIds(loopIds[0]).Select(id => body.Topology.GetCoedge(id).EdgeId).Distinct().Count() == body.GetCoedgeIds(loopIds[0]).Count
            && body.GetCoedgeIds(loopIds[0]).All(id => body.Bindings.TryGetPcurveBinding(id, out var pc) && pc.FaceId == faceId)
            || body.GetCoedgeIds(loopIds[0]).Any(id =>
        {
            if (!body.Bindings.TryGetPcurveBinding(id, out var binding) || binding.FaceId != faceId)
                return false;
            var domain = binding.Pcurve.Domain;
            var start = binding.Pcurve.Evaluate(domain.Start);
            var end = binding.Pcurve.Evaluate(domain.End);
            return double.Abs(end.U - start.U) > 1e-8d && double.Abs(end.V - start.V) > 1e-8d;
        })))
        {
            var uvLoops = ellipticalBoundary
                ? TryBuildPeriodicTrimmedSurfaceUvLoops(body, faceId, loopIds,
                    point => TryProjectPointToCylinderUv(cylinder, point, recoveryAllowance), options, executionBudget, SurfaceGeometryKind.Cylinder)
                : TryBuildTrimmedSurfaceUvLoops(body, faceId, loopIds,
                    point => TryProjectPointToCylinderUv(cylinder, point, recoveryAllowance), options, executionBudget, SurfaceGeometryKind.Cylinder);
            if (!uvLoops.IsSuccess)
                return KernelResult<DisplayFaceMeshPatch>.Failure(uvLoops.Diagnostics);
            return TrimmedSurfaceTessellator.Tessellate(faceId, uvLoops.Value,
                (u, v) => cylinder.Evaluate(u, v),
                (u, _) => cylinder.Normal(u).ToVector(), options,
                double.NegativeInfinity, double.PositiveInfinity,
                double.NegativeInfinity, double.PositiveInfinity,
                CreateValidationWarning, executionBudget, SurfaceGeometryKind.Cylinder);
        }
        if (loopIds.Length == 2
            && TryResolveDualSingleCoedgeClosedCircleCylinderTrimPatch(body, faceId, cylinder, loopIds, cylinder.Axis.ToVector(), 1e-8d).IsSuccess)
        {
            // A seamless cylindrical band (hole wall or boss) is bounded by two full circles. In UV those are two
            // zero-area lines, not an outer loop plus a hole, so the generic multi-loop trim path derives a degenerate
            // domain and drops the face. The dedicated dual-circle resolution knows the band is the strip between them.
            return TessellateLegacyCylinderFace(body, faceId, cylinder, options);
        }

        if (loopIds.Length > 1)
        {
            var uvLoopsResult = TryBuildPeriodicTrimmedSurfaceUvLoops(body, faceId, loopIds, point => TryProjectPointToCylinderUv(cylinder, point, recoveryAllowance), options, executionBudget, SurfaceGeometryKind.Cylinder);
            if (!uvLoopsResult.IsSuccess)
            {
                return KernelResult<DisplayFaceMeshPatch>.Success(
                    CreateEmptyPlanarPatch(faceId),
                    [CreateValidationWarning(
                        $"Face {faceId.Value} cylinder trim evaluation failed; skipping face patch to avoid misleading untrimmed geometry. Cause: {uvLoopsResult.Diagnostics.FirstOrDefault()?.Message}",
                        TrimEvaluationFailedSource)]);
            }

            return TrimmedSurfaceTessellator.Tessellate(
                faceId,
                StitchWrappingLoops(uvLoopsResult.Value),
                (u, v) => cylinder.Evaluate(u, v),
                (u, _) => cylinder.Normal(u).ToVector(),
                options,
                double.NegativeInfinity,
                double.PositiveInfinity,
                double.NegativeInfinity,
                double.PositiveInfinity,
                CreateValidationWarning,
                executionBudget,
                SurfaceGeometryKind.Cylinder);
        }

        return TessellateLegacyCylinderFace(body, faceId, cylinder, options);
    }

    private static KernelResult<DisplayFaceMeshPatch> TessellateConeFace(BrepBody body, FaceId faceId, ConeSurface cone, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
    {
        // A cone-apex VERTEX_LOOP is a preserved zero-dimensional boundary, not an
        // area-trim curve. Only edge loops participate in UV polygon tessellation.
        var loopIds = body.GetLoopIds(faceId)
            .Where(loopId => body.Topology.GetLoop(loopId).Kind == LoopKind.Edge)
            .ToArray();
        if (TryResolveFullPeriodicConeBetweenCircularTrimLoops(body, faceId, loopIds, cone, options, out var fullFrustumPatch, out var fullFrustumDiagnostics))
        {
            return KernelResult<DisplayFaceMeshPatch>.Success(fullFrustumPatch, fullFrustumDiagnostics);
        }

        if (loopIds.Length > 0)
        {
            var uvLoopsResult = TryBuildPeriodicTrimmedSurfaceUvLoops(body, faceId, loopIds, point => TryProjectPointToConeUv(cone, point), options, executionBudget, SurfaceGeometryKind.Cone);
            if (!uvLoopsResult.IsSuccess)
            {
                return KernelResult<DisplayFaceMeshPatch>.Success(
                    CreateEmptyPlanarPatch(faceId),
                    [CreateValidationWarning(
                        $"Face {faceId.Value} cone trim evaluation failed; skipping face patch to avoid misleading untrimmed geometry. Cause: {uvLoopsResult.Diagnostics.FirstOrDefault()?.Message}",
                        TrimEvaluationFailedSource)]);
            }

            if (loopIds.Length == 1 && UsesFullPeriodicAngularSpan(uvLoopsResult.Value) && UsesSimpleAnalyticRevolvedLoopTopology(body, loopIds[0]))
            {
                return TessellateLegacyConeFace(body, faceId, cone, options);
            }

            return TrimmedSurfaceTessellator.Tessellate(
                faceId,
                StitchWrappingLoops(uvLoopsResult.Value),
                (u, v) => cone.Evaluate(u, v),
                (u, _) => cone.Normal(u).ToVector(),
                options,
                double.NegativeInfinity,
                double.PositiveInfinity,
                double.NegativeInfinity,
                double.PositiveInfinity,
                CreateValidationWarning,
                executionBudget,
                SurfaceGeometryKind.Cone);
        }

        return TessellateLegacyConeFace(body, faceId, cone, options);
    }

    /// <summary>
    /// Resolves the deliberately narrow full-frustum cone family used by hollow frusta:
    /// two separate closed circular trim loops are the lower and upper generator bounds,
    /// not an outer loop plus a hole.  The generic UV trim path represents each full
    /// circle as a periodic ring; treating the second ring as a hole cancels the entire
    /// periodic domain and used to yield zero triangles for both material cone faces.
    /// </summary>
    private static bool TryResolveFullPeriodicConeBetweenCircularTrimLoops(
        BrepBody body,
        FaceId faceId,
        IReadOnlyList<LoopId> loopIds,
        ConeSurface cone,
        DisplayTessellationOptions options,
        out DisplayFaceMeshPatch patch,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        patch = default!;
        diagnostics = [];
        if (loopIds.Count != 2)
        {
            return false;
        }

        var trimLevels = new List<(double Axial, double Radius)>();
        var tolerance = System.Math.Max(1e-6d, options.ChordTolerance * 1e-3d);
        var axis = cone.Axis.ToVector();
        foreach (var loopId in loopIds.OrderBy(id => id.Value))
        {
            var coedgeIds = body.GetCoedgeIds(loopId);
            if (coedgeIds.Count != 1)
            {
                return false;
            }

            var coedge = body.Topology.GetCoedge(coedgeIds[0]);
            var edge = body.Topology.GetEdge(coedge.EdgeId);
            if (edge.StartVertexId != edge.EndVertexId
                || !body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var edgeBinding)
                || edgeBinding.TrimInterval is not { } trim
                || System.Math.Abs((trim.End - trim.Start) - (2d * double.Pi)) > 1e-5d
                || body.GetEdgeCurve(coedge.EdgeId).Circle3 is not { } circle)
            {
                return false;
            }

            // A full circular trim must be coaxial with the support and lie on its
            // equation.  Sampling four quadrants makes the authority explicit: these
            // levels come from BRep trim topology, never fixture dimensions.
            if (System.Math.Abs(circle.Normal.ToVector().Dot(axis)) < (1d - 1e-6d))
            {
                return false;
            }

            var centerOffset = circle.Center - cone.Apex;
            var axial = centerOffset.Dot(axis);
            var axisResidual = (centerOffset - (axis * axial)).Length;
            var expectedRadius = axial * double.Tan(cone.SemiAngleRadians);
            var supportTolerance = System.Math.Max(tolerance, System.Math.Max(circle.Radius, expectedRadius) * 1e-6d);
            if (axial <= supportTolerance
                || axisResidual > supportTolerance
                || System.Math.Abs(circle.Radius - expectedRadius) > supportTolerance)
            {
                return false;
            }

            for (var sample = 0; sample < 4; sample++)
            {
                var point = circle.Evaluate(sample * (double.Pi / 2d));
                if (TryProjectPointToConeUv(cone, point) is null)
                {
                    return false;
                }
            }

            trimLevels.Add((axial, circle.Radius));
        }

        var ordered = trimLevels.OrderBy(level => level.Axial).ToArray();
        if (ordered[1].Axial - ordered[0].Axial <= tolerance)
        {
            return false;
        }

        var angularSegments = CalculateSegmentCount(2d * double.Pi, ordered.Max(level => level.Radius), options);
        // Cone generators are straight and the normal is constant along them: one row of quads is exact.
        var axialSegments = 1;
        patch = CreatePeriodicGridPatch(
            faceId,
            angularSegments,
            axialSegments,
            (u, v) => cone.Evaluate(u, v),
            (u, _) => cone.Normal(u).ToVector(),
            ordered[0].Axial,
            ordered[1].Axial);
        diagnostics = [new KernelDiagnostic(
            KernelDiagnosticCode.Unknown,
            KernelDiagnosticSeverity.Info,
            $"Face {faceId.Value} tessellated as a topology-derived full-period cone strip: angularSegments={angularSegments}, generatorSegments={axialSegments}, trimAxial=[{ordered[0].Axial:R},{ordered[1].Axial:R}].",
            "Viewer.Cone.FullPeriodicCircularTrims")];
        return true;
    }


    private static KernelResult<DisplayFaceMeshPatch> TessellateLegacyCylinderFace(BrepBody body, FaceId faceId, CylinderSurface cylinder, DisplayTessellationOptions options)
    {
        var trimPatch = TryResolveCylinderTrimPatch(body, faceId, cylinder);
        if (!trimPatch.IsSuccess)
        {
            return KernelResult<DisplayFaceMeshPatch>.Failure(trimPatch.Diagnostics);
        }

        var angularSpan = trimPatch.Value.UEnd - trimPatch.Value.UStart;
        var axialSpan = trimPatch.Value.VEnd - trimPatch.Value.VStart;
        var nearFullPeriodicSpan = (2d * double.Pi) - 0.25d;
        if (angularSpan >= nearFullPeriodicSpan)
        {
            var periodicParameters = GetRevolvedFaceParameters(
                body,
                faceId,
                options,
                radiusHint: cylinder.Radius,
                allowThreeCoedgeConeTopology: false,
                axialParameterFromPoint: point => (point - cylinder.Origin).Dot(cylinder.Axis.ToVector()));
            if (periodicParameters.IsSuccess)
            {
                // Cylinder generators are straight: axial subdivision adds triangles but no accuracy.
                return KernelResult<DisplayFaceMeshPatch>.Success(CreatePeriodicGridPatch(
                    faceId,
                    periodicParameters.Value.AngularSegments,
                    1,
                    (u, v) => cylinder.Evaluate(u, v),
                    (u, _) => cylinder.Normal(u).ToVector(),
                    periodicParameters.Value.VStart,
                    periodicParameters.Value.VEnd),
                    periodicParameters.Diagnostics);
            }
        }

        var angularSegments = CalculateSegmentCount(angularSpan, System.Math.Max(1e-6d, cylinder.Radius), options);
        const int axialSegments = 1;

        return KernelResult<DisplayFaceMeshPatch>.Success(CreateBoundedGridPatch(
            faceId,
            angularSegments,
            axialSegments,
            (u, v) => cylinder.Evaluate(u, v),
            (u, _) => cylinder.Normal(u).ToVector(),
            trimPatch.Value.UStart,
            trimPatch.Value.UEnd,
            trimPatch.Value.VStart,
            trimPatch.Value.VEnd),
            trimPatch.Diagnostics);
    }

    private static KernelResult<DisplayFaceMeshPatch> TessellateLegacyConeFace(BrepBody body, FaceId faceId, ConeSurface cone, DisplayTessellationOptions options)
    {
        var parameters = GetRevolvedFaceParameters(
            body,
            faceId,
            options,
            radiusHint: 1d,
            allowThreeCoedgeConeTopology: true,
            axialParameterFromPoint: cone.AxialParameterFromPoint);
        if (!parameters.IsSuccess)
        {
            return KernelResult<DisplayFaceMeshPatch>.Failure(parameters.Diagnostics);
        }

        return KernelResult<DisplayFaceMeshPatch>.Success(CreatePeriodicGridPatch(
            faceId,
            parameters.Value.AngularSegments,
            1,
            (u, v) => cone.Evaluate(u, v),
            (u, _) => cone.Normal(u).ToVector(),
            parameters.Value.VStart,
            parameters.Value.VEnd));
    }

    private static bool UsesSimpleAnalyticRevolvedLoopTopology(BrepBody body, LoopId loopId)
    {
        var coedges = body.GetCoedgeIds(loopId).Select(id => body.Topology.GetCoedge(id)).ToArray();
        if (coedges.Length == 0 || coedges.Length > 4)
        {
            return false;
        }

        return coedges
            .Select(coedge => body.GetEdgeCurve(coedge.EdgeId).Kind)
            .All(kind => kind is CurveGeometryKind.Line3 or CurveGeometryKind.Circle3);
    }

    private static bool UsesFullPeriodicAngularSpan(IReadOnlyList<IReadOnlyList<(double U, double V)>> uvLoops)
    {
        if (uvLoops.Count == 0)
        {
            return false;
        }

        var outerLoop = uvLoops
            .Select(NormalizePeriodicLoop)
            .OrderByDescending(loop => System.Math.Abs(ComputePeriodicLoopSignedArea(loop)))
            .First();
        if (outerLoop.Count == 0)
        {
            return false;
        }

        var span = outerLoop.Max(point => point.U) - outerLoop.Min(point => point.U);
        return span >= ((2d * double.Pi) - 0.25d);
    }

    private static List<(double U, double V)> NormalizePeriodicLoop(IReadOnlyList<(double U, double V)> loop)
    {
        var normalized = new List<(double U, double V)>(loop.Count);
        foreach (var point in loop)
        {
            if (normalized.Count == 0 || System.Math.Abs(normalized[^1].U - point.U) > 1e-9d || System.Math.Abs(normalized[^1].V - point.V) > 1e-9d)
            {
                normalized.Add(point);
            }
        }

        if (normalized.Count > 1
            && System.Math.Abs(normalized[0].U - normalized[^1].U) <= 1e-9d
            && System.Math.Abs(normalized[0].V - normalized[^1].V) <= 1e-9d)
        {
            normalized.RemoveAt(normalized.Count - 1);
        }

        return normalized;
    }

    private static double ComputePeriodicLoopSignedArea(IReadOnlyList<(double U, double V)> loop)
    {
        var area = 0d;
        for (var i = 0; i < loop.Count; i++)
        {
            var current = loop[i];
            var next = loop[(i + 1) % loop.Count];
            area += (current.U * next.V) - (next.U * current.V);
        }

        return area * 0.5d;
    }

    private static KernelResult<DisplayFaceMeshPatch> TessellateBSplineSurfaceFace(BrepBody body, FaceId faceId, BSplineSurfaceWithKnots surface, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
    {
        executionBudget?.ThrowIfExpired("BSplineSurface.Start", faceId, SurfaceGeometryKind.BSplineSurfaceWithKnots);
        var loopIds = body.GetLoopIds(faceId)
            .Where(loopId => body.Topology.GetLoop(loopId).Kind == LoopKind.Edge)
            .ToArray();
        if (loopIds.Length == 0)
        {
            return KernelResult<DisplayFaceMeshPatch>.Success(CreateBoundedGridPatch(
                faceId,
                options.MinimumSegments,
                options.MinimumSegments,
                (u, v) => surface.Evaluate(u, v),
                (u, v) => EvaluateBSplineNormal(surface, u, v),
                surface.DomainStartU,
                surface.DomainEndU,
                surface.DomainStartV,
                surface.DomainEndV));
        }

        var projector = new BSplineUvProjector(surface);
        var uvLoopsResult = BuildSplineDisplayTrim(body, faceId, loopIds, projector, options, executionBudget);
        if (!uvLoopsResult.IsSuccess)
        {
            return KernelResult<DisplayFaceMeshPatch>.Success(
                CreateEmptyPlanarPatch(faceId),
                [CreateValidationWarning(
                    $"Face {faceId.Value} BSpline trim evaluation failed ({string.Join(" | ", uvLoopsResult.Diagnostics.Select(diagnostic => diagnostic.Message))}); projection residual={projector.LastResidual:R} mm, candidate UV={projector.LastCandidate}, native domain=[{surface.DomainStartU:R},{surface.DomainEndU:R}]x[{surface.DomainStartV:R},{surface.DomainEndV:R}]; skipping face patch to avoid misleading untrimmed geometry.",
                    TrimEvaluationFailedSource)]);
        }

        return TrimmedSurfaceTessellator.Tessellate(
            faceId,
            NormalizeClosedSplineLoops(surface, uvLoopsResult.Value),
            (u, v) => surface.Evaluate(u, v),
            (u, v) => EvaluateBSplineNormal(surface, u, v),
            options,
            surface.DomainStartU,
            surface.DomainEndU,
            surface.DomainStartV,
            surface.DomainEndV,
            CreateValidationWarning,
            executionBudget,
            SurfaceGeometryKind.BSplineSurfaceWithKnots,
            splineSupport: surface);
    }

    /// <summary>Display projection reuses the qualified pcurve inverter, with a separate display budget.</summary>
    internal static KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>> InspectSplineTrim(BrepBody body, FaceId faceId)
    {
        body.TryGetFaceSurface(faceId, out var surface);
        var support = surface?.BSplineSurfaceWithKnots
            ?? throw new ArgumentException("Face is not spline-supported.", nameof(faceId));
        var input = BuildSplineDisplayTrim(body, faceId,
            body.GetLoopIds(faceId).Where(id => body.Topology.GetLoop(id).Kind == LoopKind.Edge).ToArray(),
            new BSplineUvProjector(support), DisplayTessellationOptions.ForViewport(body), null);
        return input.IsSuccess ? KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Success(
            NormalizeClosedSplineLoops(support, input.Value)) : input;
    }

    private static KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>> BuildSplineDisplayTrim(
        BrepBody body, FaceId faceId, IReadOnlyList<LoopId> loopIds, BSplineUvProjector projector,
        DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget)
    {
        var input = TryBuildTrimmedSurfaceUvLoops(body, faceId, loopIds, projector.Project,
            options, executionBudget, SurfaceGeometryKind.BSplineSurfaceWithKnots);
        if (!input.IsSuccess || !input.Value.Any(IsCollapsedSplineLoop)
            || !loopIds.SelectMany(body.GetCoedgeIds).All(id =>
                body.Bindings.TryGetPcurveBinding(id, out var binding)
                && binding.Qualification?.Origin == PcurveBindingOrigin.RecoveredSpline)) return input;
        // A recovered parameter trace may flatten a feature smaller than its lift
        // budget. Display samples the actual bounded edges onto the existing support;
        // retained source pcurves, BRep bindings and export remain unchanged.
        return TryBuildTrimmedSurfaceUvLoops(body, faceId, loopIds, projector.Project, options with {
            MinimumSegments = System.Math.Min(options.MaximumSegments, System.Math.Max(64, options.MinimumSegments))
        }, executionBudget, SurfaceGeometryKind.BSplineSurfaceWithKnots, preferBoundPcurves: false);
    }

    private static bool IsCollapsedSplineLoop(IReadOnlyList<(double U, double V)> loop)
    {
        if (loop.Count < 3) return true;
        var width = loop.Max(p => p.U) - loop.Min(p => p.U);
        var height = loop.Max(p => p.V) - loop.Min(p => p.V);
        var origin = loop[0];
        var twiceArea = 0d;
        for (var i = 0; i < loop.Count; i++)
        {
            var a = loop[i]; var b = loop[(i + 1) % loop.Count];
            twiceArea += (a.U - origin.U) * (b.V - origin.V) - (b.U - origin.U) * (a.V - origin.V);
        }
        return width <= 0d || height <= 0d || double.Abs(twiceArea) <= width * height * 1e-10d;
    }

    internal static IReadOnlyList<IReadOnlyList<(double U, double V)>> NormalizeClosedSplineLoops(
        BSplineSurfaceWithKnots surface, IReadOnlyList<IReadOnlyList<(double U, double V)>> loops)
    {
        return loops.Select(loop =>
        {
            var points = loop.ToArray();
            Normalize(surface.UClosed, surface.DomainStartU, surface.DomainEndU, true);
            Normalize(surface.VClosed, surface.DomainStartV, surface.DomainEndV, false);
            return (IReadOnlyList<(double U, double V)>)points;

            void Normalize(bool closed, double start, double end, bool alongU)
            {
                if (!closed || points.Length == 0) return;
                var period = end - start;
                for (var i = 1; i < points.Length; i++)
                {
                    var p = points[i];
                    points[i] = alongU
                        ? (BrepPcurveRecovery.UnwrapNear(p.U, points[i - 1].U, period), p.V)
                        : (p.U, BrepPcurveRecovery.UnwrapNear(p.V, points[i - 1].V, period));
                }
                var minimum = points.Min(p => alongU ? p.U : p.V);
                var shift = double.Floor((minimum - start + period * 1e-8d) / period) * period;
                for (var i = 0; i < points.Length; i++)
                    points[i] = alongU ? (points[i].U - shift, points[i].V) : (points[i].U, points[i].V - shift);
            }
        }).ToArray();
    }

    private sealed class BSplineUvProjector
    {
        private readonly BSplineSurfaceWithKnots _surface;
        private readonly double _tolerance;
        private SurfaceParameterPoint? _last;
        public double LastResidual { get; private set; }
        public (double U, double V) LastCandidate { get; private set; }

        public BSplineUvProjector(BSplineSurfaceWithKnots surface)
        {
            _surface = surface;
            _tolerance = ComputeBSplineProjectionTolerance(surface);
        }

        public (double U, double V)? Project(Point3D point)
        {
            var result = BrepPcurveRecovery.ProjectSplinePoint(_surface, point, _last, _tolerance);
            if (!result.Success && _last is not null)
                result = BrepPcurveRecovery.ProjectSplinePoint(_surface, point, null, _tolerance);
            LastResidual = result.Residual;
            LastCandidate = (result.Uv.U, result.Uv.V);
            if (!result.Success) return null;
            _last = result.Uv;
            return LastCandidate;
        }
    }

    private static KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>> TryBuildDoublyPeriodicTrimmedSurfaceUvLoops(
        BrepBody body,
        FaceId faceId,
        IReadOnlyList<LoopId> loopIds,
        Func<Point3D, (double U, double V)?> projectPointToUv,
        DisplayTessellationOptions options,
        DisplayTessellationExecutionBudget? executionBudget = null,
        SurfaceGeometryKind? surfaceKind = null)
    {
        var uvLoops = new List<IReadOnlyList<(double U, double V)>>(loopIds.Count);
        foreach (var loopId in loopIds.OrderBy(id => id.Value))
        {
            executionBudget?.ThrowIfExpired("DoublyPeriodicTrimLoopDispatch", faceId, surfaceKind);
            var uvLoop = TryBuildDoublyPeriodicTrimmedSurfaceUvLoop(body, faceId, loopId, projectPointToUv, options, executionBudget, surfaceKind);
            if (!uvLoop.IsSuccess)
            {
                return KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Failure(uvLoop.Diagnostics);
            }

            uvLoops.Add(uvLoop.Value);
        }

        return KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Success(uvLoops);
    }

    private static KernelResult<IReadOnlyList<(double U, double V)>> TryBuildDoublyPeriodicTrimmedSurfaceUvLoop(
        BrepBody body,
        FaceId faceId,
        LoopId loopId,
        Func<Point3D, (double U, double V)?> projectPointToUv,
        DisplayTessellationOptions options,
        DisplayTessellationExecutionBudget? executionBudget = null,
        SurfaceGeometryKind? surfaceKind = null)
    {
        var coedges = body.GetCoedgeIds(loopId).Select(id => body.Topology.GetCoedge(id)).ToArray();
        if (coedges.Length < 1)
        {
            return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
                CreateNotImplemented(
                    $"Face {faceId.Value} periodic trim loop must contain at least one coedge.",
                    TrimEvaluationFailedSource)]);
        }

        var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
        if (!vertexPointsResult.IsSuccess)
        {
            return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(vertexPointsResult.Diagnostics);
        }

        var uvPoints = new List<(double U, double V)>();
        double? previousWrappedU = null;
        double? previousWrappedV = null;
        double currentUOffset = 0d;
        double currentVOffset = 0d;

        foreach (var coedge in coedges)
        {
            executionBudget?.ThrowIfExpired("DoublyPeriodicTrimLoopSampling", faceId, surfaceKind);
            var sampledCurve = TrySampleCoedgeForTrimEvaluation(body, faceId, coedge, vertexPointsResult.Value, options, executionBudget, surfaceKind);
            if (!sampledCurve.IsSuccess)
            {
                return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(sampledCurve.Diagnostics);
            }

            foreach (var point in sampledCurve.Value)
            {
                var uv = projectPointToUv(point);
                if (!uv.HasValue)
                {
                    return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
                        CreateNotImplemented(
                            $"Face {faceId.Value} periodic trim tessellation could not project loop samples into the native torus parameter domain.",
                            TrimEvaluationFailedSource)]);
                }

                var unwrapResult = TryUnwrapDoublyPeriodicUvPoint(
                    uvPoints,
                    uv.Value,
                    ref previousWrappedU,
                    ref currentUOffset,
                    ref previousWrappedV,
                    ref currentVOffset,
                    faceId);
                if (!unwrapResult.IsSuccess)
                {
                    return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(unwrapResult.Diagnostics);
                }
            }
        }

        if (uvPoints.Count > 1 && UvPointsAlmostEqual(uvPoints[0], uvPoints[^1]))
        {
            uvPoints.RemoveAt(uvPoints.Count - 1);
        }

        return KernelResult<IReadOnlyList<(double U, double V)>>.Success(uvPoints);
    }

    /// <summary>
    /// Two loops that each run once round a periodic surface bound the band between them. In the unrolled chart each is
    /// an open polyline one period long, so treated as polygons they enclose only what lies between each polyline and
    /// its own closing chord: a wavy loop (a slot cut into a bore's end) keeps only its notch and loses the band. The
    /// band is one polygon: one loop over a period from a common seam, then the other back along it.
    /// </summary>
    internal static IReadOnlyList<IReadOnlyList<(double U, double V)>> StitchWrappingLoops(IReadOnlyList<IReadOnlyList<(double U, double V)>> loops)
    {
        const double period = 2d * double.Pi;
        static double Turn(IReadOnlyList<(double U, double V)> loop) => loop.Count < 2 ? 0d : loop[^1].U - loop[0].U;
        var wrapping = Enumerable.Range(0, loops.Count)
            .Where(i => loops[i].Count >= 2 && double.Abs(double.Abs(Turn(loops[i])) - period) < 1e-3d)
            .ToArray();
        if (wrapping.Length != 2) return loops;
        // A period of each loop running +u from where it first crosses the seam; the seam avoids every vertex, so each
        // crossing is a proper one.
        var seam = loops[wrapping[0]][0].U + 1e-3d * double.Pi;
        List<(double U, double V)>? Period(IReadOnlyList<(double U, double V)> loop)
        {
            var forward = Turn(loop) > 0d ? loop.ToList() : loop.Reverse().ToList();
            var shift = double.Floor((seam - forward[0].U) / period) * period;
            var extended = new List<(double U, double V)>();
            for (var k = 0; k < 3; k++) extended.AddRange(forward.Skip(k == 0 ? 0 : 1).Select(p => (U: p.U + shift + k * period, p.V)));
            for (var i = 0; i + 1 < extended.Count; i++)
            {
                var (a, b) = (extended[i], extended[i + 1]);
                if (!(a.U <= seam && b.U > seam)) continue;
                var t = (seam - a.U) / (b.U - a.U);
                (double U, double V) start = (seam, a.V + t * (b.V - a.V));
                var result = new List<(double U, double V)> { start };
                for (var j = i + 1; j + 1 < extended.Count; j++)
                {
                    var (c, d) = (extended[j], extended[j + 1]);
                    result.Add(c);
                    if (c.U < seam + period && d.U >= seam + period)
                    {
                        var s = (seam + period - c.U) / (d.U - c.U);
                        result.Add((seam + period, c.V + s * (d.V - c.V)));
                        return result;
                    }
                }
                return null;
            }
            return null;
        }
        var lower = Period(loops[wrapping[0]]);
        var upper = Period(loops[wrapping[1]]);
        if (lower is null || upper is null) return loops;
        upper.Reverse();
        var band = lower.Concat(upper).ToList();
        var stitched = new List<IReadOnlyList<(double U, double V)>> { band };
        stitched.AddRange(Enumerable.Range(0, loops.Count).Where(i => !wrapping.Contains(i)).Select(i => loops[i]));
        return stitched;
    }

    private static KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>> TryBuildPeriodicTrimmedSurfaceUvLoops(
        BrepBody body,
        FaceId faceId,
        IReadOnlyList<LoopId> loopIds,
        Func<Point3D, (double U, double V)?> projectPointToUv,
        DisplayTessellationOptions options,
        DisplayTessellationExecutionBudget? executionBudget = null,
        SurfaceGeometryKind? surfaceKind = null)
    {
        var uvLoops = new List<IReadOnlyList<(double U, double V)>>(loopIds.Count);
        foreach (var loopId in loopIds.OrderBy(id => id.Value))
        {
            executionBudget?.ThrowIfExpired("PeriodicTrimLoopDispatch", faceId, surfaceKind);
            var uvLoop = TryBuildPeriodicTrimmedSurfaceUvLoop(body, faceId, loopId, projectPointToUv, options, executionBudget, surfaceKind);
            if (!uvLoop.IsSuccess)
            {
                return KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Failure(uvLoop.Diagnostics);
            }

            uvLoops.Add(uvLoop.Value);
        }

        return KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Success(uvLoops);
    }

    private static KernelResult<IReadOnlyList<(double U, double V)>> TryBuildPeriodicTrimmedSurfaceUvLoop(
        BrepBody body,
        FaceId faceId,
        LoopId loopId,
        Func<Point3D, (double U, double V)?> projectPointToUv,
        DisplayTessellationOptions options,
        DisplayTessellationExecutionBudget? executionBudget = null,
        SurfaceGeometryKind? surfaceKind = null)
    {
        var coedges = body.GetCoedgeIds(loopId).Select(id => body.Topology.GetCoedge(id)).ToArray();
        if (coedges.Length < 1)
        {
            return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
                CreateNotImplemented(
                    $"Face {faceId.Value} periodic trim loop must contain at least one coedge.",
                    TrimEvaluationFailedSource)]);
        }

        var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
        if (!vertexPointsResult.IsSuccess)
        {
            return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(vertexPointsResult.Diagnostics);
        }

        var uvPoints = new List<(double U, double V)>();
        double? previousWrappedU = null;
        double currentUOffset = 0d;
        var wrappedSpanTolerance = double.Pi + 1e-6d;
        foreach (var coedge in coedges)
        {
            executionBudget?.ThrowIfExpired("PeriodicTrimLoopSampling", faceId, surfaceKind);
            var sampledCurve = TrySampleCoedgeForTrimEvaluation(body, faceId, coedge, vertexPointsResult.Value, options, executionBudget, surfaceKind);
            if (!sampledCurve.IsSuccess)
            {
                return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(sampledCurve.Diagnostics);
            }

            foreach (var point in sampledCurve.Value)
            {
                var uv = projectPointToUv(point);
                if (!uv.HasValue)
                {
                    return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
                        CreateNotImplemented(
                            $"Face {faceId.Value} periodic trim tessellation could not project loop samples into the native parameter domain.",
                            TrimEvaluationFailedSource)]);
                }

                var wrappedU = uv.Value.U;
                if (previousWrappedU.HasValue)
                {
                    var delta = wrappedU - previousWrappedU.Value;
                    if (delta > double.Pi)
                    {
                        currentUOffset -= 2d * double.Pi;
                    }
                    else if (delta < -double.Pi)
                    {
                        currentUOffset += 2d * double.Pi;
                    }

                    var adjustedDelta = (wrappedU + currentUOffset) - uvPoints[^1].U;
                    if (double.Abs(adjustedDelta) > wrappedSpanTolerance)
                    {
                        return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
                            CreateNotImplemented(
                                $"Face {faceId.Value} periodic trim loop crossed the angular seam ambiguously and could not be normalized deterministically.",
                                TrimEvaluationFailedSource)]);
                    }
                }

                AppendUniqueUvPoint(uvPoints, (wrappedU + currentUOffset, uv.Value.V));
                previousWrappedU = wrappedU;
            }
        }

        if (uvPoints.Count > 1 && UvPointsAlmostEqual(uvPoints[0], uvPoints[^1]))
        {
            uvPoints.RemoveAt(uvPoints.Count - 1);
        }

        return KernelResult<IReadOnlyList<(double U, double V)>>.Success(uvPoints);
    }

    private static KernelResult<bool> TryUnwrapDoublyPeriodicUvPoint(
        List<(double U, double V)> uvPoints,
        (double U, double V) wrappedUv,
        ref double? previousWrappedU,
        ref double currentUOffset,
        ref double? previousWrappedV,
        ref double currentVOffset,
        FaceId faceId)
    {
        var unwrappedUResult = TryUnwrapPeriodicCoordinate(wrappedUv.U, uvPoints, isUCoordinate: true, ref previousWrappedU, ref currentUOffset, faceId);
        if (!unwrappedUResult.IsSuccess)
        {
            return KernelResult<bool>.Failure(unwrappedUResult.Diagnostics);
        }

        var unwrappedVResult = TryUnwrapPeriodicCoordinate(wrappedUv.V, uvPoints, isUCoordinate: false, ref previousWrappedV, ref currentVOffset, faceId);
        if (!unwrappedVResult.IsSuccess)
        {
            return KernelResult<bool>.Failure(unwrappedVResult.Diagnostics);
        }

        AppendUniqueUvPoint(uvPoints, (unwrappedUResult.Value, unwrappedVResult.Value));
        return KernelResult<bool>.Success(true);
    }

    private static KernelResult<double> TryUnwrapPeriodicCoordinate(
        double wrappedValue,
        IReadOnlyList<(double U, double V)> uvPoints,
        bool isUCoordinate,
        ref double? previousWrappedValue,
        ref double currentOffset,
        FaceId faceId)
    {
        var wrappedSpanTolerance = double.Pi + 1e-6d;
        if (previousWrappedValue.HasValue)
        {
            var delta = wrappedValue - previousWrappedValue.Value;
            if (delta > double.Pi)
            {
                currentOffset -= 2d * double.Pi;
            }
            else if (delta < -double.Pi)
            {
                currentOffset += 2d * double.Pi;
            }

            if (uvPoints.Count > 0)
            {
                var adjustedValue = wrappedValue + currentOffset;
                var previousValue = isUCoordinate ? uvPoints[^1].U : uvPoints[^1].V;
                if (double.Abs(adjustedValue - previousValue) > wrappedSpanTolerance)
                {
                    var coordinateName = isUCoordinate ? "major" : "minor";
                    return KernelResult<double>.Failure([
                        CreateNotImplemented(
                            $"Face {faceId.Value} torus trim loop crossed the {coordinateName} angular seam ambiguously and could not be normalized deterministically.",
                            TrimEvaluationFailedSource)]);
                }
            }
        }

        previousWrappedValue = wrappedValue;
        return KernelResult<double>.Success(wrappedValue + currentOffset);
    }

    /// <summary>
    /// Recognizes a torus face bounded by exactly two single-edge full-circle loops that are coaxial with the torus
    /// (constant minor angle v). The band between them is the shorter tube arc; a face wider than half the tube is
    /// ambiguous without orientation analysis and is left to the generic path.
    /// </summary>
    private static bool TryResolveCoaxialCirclePairTorusBand(BrepBody body, TorusSurface torus, IReadOnlyList<LoopId> loopIds, out double vStart, out double vEnd)
    {
        vStart = 0d;
        vEnd = 0d;
        var angles = new double[2];
        for (var i = 0; i < 2; i++)
        {
            var coedgeIds = body.GetCoedgeIds(loopIds[i]);
            if (coedgeIds.Count != 1)
            {
                return false;
            }

            var edge = body.Topology.GetCoedge(coedgeIds[0]).EdgeId;
            var curve = body.GetEdgeCurve(edge);
            if (curve.Kind != CurveGeometryKind.Circle3 || curve.Circle3 is not { } circle)
            {
                return false;
            }

            var axis = torus.Axis.ToVector();
            var offset = circle.Center - torus.Center;
            var alongAxis = offset.Dot(axis);
            var offAxis = (offset - (axis * alongAxis)).Length;
            if (offAxis > 1e-6d || double.Abs(circle.Normal.ToVector().Dot(axis)) < 1d - 1e-9d)
            {
                return false;
            }

            angles[i] = TorusMinorAngleOf(torus, circle.Evaluate(0d));
        }

        var delta = angles[1] - angles[0];
        delta -= 2d * double.Pi * double.Round(delta / (2d * double.Pi));
        if (double.Abs(delta) < 1e-9d || double.Abs(delta) > double.Pi - 1e-6d)
        {
            return false;
        }

        vStart = delta > 0d ? angles[0] : angles[1];
        vEnd = vStart + double.Abs(delta);
        return true;
    }

    private static (double U, double V)? TryProjectPointToTorusUv(TorusSurface torus, Point3D point)
    {
        var axis = torus.Axis.ToVector();
        var xAxis = torus.XAxis.ToVector();
        var yAxis = torus.YAxis.ToVector();
        var offset = point - torus.Center;
        var axial = offset.Dot(axis);
        var planar = offset - (axis * axial);
        var planarLength = planar.Length;
        if (!double.IsFinite(planarLength))
        {
            return null;
        }

        // A bounded horn-torus patch may legitimately end at its single
        // collapsed inner-circle point.  That point has no unique major angle,
        // but (u=0,v=pi) evaluates exactly to it and permits deterministic
        // trimmed-face tessellation; it does not relax projection for ordinary
        // torus points away from the horn singularity.
        if (planarLength <= 1e-9d)
        {
            if (double.Abs(torus.MajorRadius - torus.MinorRadius) <= 1e-9d && double.Abs(axial) <= 1e-9d)
            {
                return (0d, double.Pi);
            }
            return null;
        }

        var u = NormalizeToZeroTwoPi(double.Atan2(planar.Dot(yAxis), planar.Dot(xAxis)));
        var radialFromMajor = planarLength - torus.MajorRadius;
        var v = NormalizeToZeroTwoPi(double.Atan2(axial, radialFromMajor));

        var residual = torus.Evaluate(u, v) - point;
        var residualDistance = System.Math.Sqrt(residual.Dot(residual));
        // Boundary curves of fillet/blend faces are frequently B-spline approximations of the true intersection and
        // sit up to ~1e-3 mm off the analytic torus; this is a display projection, so accept deviations well below
        // visual resolution instead of dropping the face.
        var tolerance = System.Math.Max(AnalyticProjectionDeviationFloor, System.Math.Max(System.Math.Max(torus.MajorRadius, torus.MinorRadius) * 1e-4d, torus.MinorRadius * 1e-2d));
        if (!double.IsFinite(residualDistance) || residualDistance > tolerance)
        {
            return null;
        }

        return (u, v);
    }

    // Boundary edges of fillet/blend faces are often B-spline approximations of the true intersection and sit a few
    // 1e-3 mm off the analytic surface. UV projection here is for display, so accept anything below visual resolution.
    private const double AnalyticProjectionDeviationFloor = 1e-2d;

    private static (double U, double V)? TryProjectPointToCylinderUv(CylinderSurface cylinder, Point3D point, double recoveryAllowance = 0d)
    {
        var axis = cylinder.Axis.ToVector();
        var xAxis = cylinder.XAxis.ToVector();
        var yAxis = cylinder.YAxis.ToVector();
        var offset = point - cylinder.Origin;
        var axial = offset.Dot(axis);
        var radial = offset - (axis * axial);
        var radialLength = radial.Length;
        // A measured recovered edge can depart from its exact cylindrical support by more than
        // the analytic floor. Bound this face-local display projection by its recorded recovery
        // deviation and the display chord budget; pcurve and kernel budgets remain independent.
        var tolerance = System.Math.Max(recoveryAllowance, System.Math.Max(AnalyticProjectionDeviationFloor, cylinder.Radius * 1e-4d));
        if (!double.IsFinite(radialLength) || System.Math.Abs(radialLength - cylinder.Radius) > tolerance)
        {
            return null;
        }

        var angle = NormalizeToZeroTwoPi(double.Atan2(radial.Dot(yAxis), radial.Dot(xAxis)));
        return (angle, axial);
    }

    private static (double U, double V)? TryProjectPointToConeUv(ConeSurface cone, Point3D point)
    {
        var axis = cone.Axis.ToVector();
        var xAxis = cone.ReferenceAxis.ToVector();
        var projectedX = xAxis - (axis * xAxis.Dot(axis));
        if (!Direction3D.TryCreate(projectedX, out var coneXAxis))
        {
            return null;
        }

        if (!Direction3D.TryCreate(axis.Cross(coneXAxis.ToVector()), out var coneYAxis))
        {
            return null;
        }

        var offset = point - cone.Apex;
        var axial = offset.Dot(axis);
        if (!double.IsFinite(axial) || axial < -1e-6d)
        {
            return null;
        }

        var radial = offset - (axis * axial);
        var radialLength = radial.Length;
        var expectedRadius = axial * double.Tan(cone.SemiAngleRadians);
        var tolerance = System.Math.Max(AnalyticProjectionDeviationFloor, expectedRadius * 1e-4d);
        if (System.Math.Abs(radialLength - expectedRadius) > tolerance)
        {
            return null;
        }

        var angle = radialLength <= 1e-9d
            ? 0d
            : NormalizeToZeroTwoPi(double.Atan2(radial.Dot(coneYAxis.ToVector()), radial.Dot(coneXAxis.ToVector())));
        return (angle, axial);
    }

    private static KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>> TryBuildTrimmedSurfaceUvLoops(
        BrepBody body,
        FaceId faceId,
        IReadOnlyList<LoopId> loopIds,
        Func<Point3D, (double U, double V)?> projectPointToUv,
        DisplayTessellationOptions options,
        DisplayTessellationExecutionBudget? executionBudget = null,
        SurfaceGeometryKind? surfaceKind = null,
        bool preferBoundPcurves = true)
    {
        var uvLoops = new List<IReadOnlyList<(double U, double V)>>(loopIds.Count);
        foreach (var loopId in loopIds.OrderBy(id => id.Value))
        {
            executionBudget?.ThrowIfExpired("TrimLoopDispatch", faceId, surfaceKind);
            var uvLoop = TryBuildTrimmedSurfaceUvLoop(body, faceId, loopId, projectPointToUv, options, executionBudget, surfaceKind, preferBoundPcurves);
            if (!uvLoop.IsSuccess)
            {
                return KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Failure(uvLoop.Diagnostics);
            }

            uvLoops.Add(uvLoop.Value);
        }

        return KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Success(uvLoops);
    }

    private static KernelResult<IReadOnlyList<(double U, double V)>> TryBuildTrimmedSurfaceUvLoop(
        BrepBody body,
        FaceId faceId,
        LoopId loopId,
        Func<Point3D, (double U, double V)?> projectPointToUv,
        DisplayTessellationOptions options,
        DisplayTessellationExecutionBudget? executionBudget = null,
        SurfaceGeometryKind? surfaceKind = null,
        bool preferBoundPcurves = true)
    {
        var coedges = body.GetCoedgeIds(loopId).Select(id => body.Topology.GetCoedge(id)).ToArray();
        if (coedges.Length == 0)
        {
            return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
                CreateNotImplemented(
                    $"Face {faceId.Value} parametric trim loop has no coedges.",
                    BSplineSurfaceTrimUnsupportedSource)]);
        }

        var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
        if (!vertexPointsResult.IsSuccess)
        {
            return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(vertexPointsResult.Diagnostics);
        }

        var uvPoints = new List<(double U, double V)>();
        foreach (var coedge in coedges)
        {
            executionBudget?.ThrowIfExpired("TrimLoopSampling", faceId, surfaceKind);
            // Consume the bound face-space authority when available. Numerical 3D
            // reprojection is only the legacy fallback for bodies without pcurves.
            if (preferBoundPcurves && body.Bindings.TryGetPcurveBinding(coedge.Id, out var pc) && pc.FaceId == faceId)
            {
                var edge = body.Bindings.GetEdgeBinding(coedge.EdgeId);
                var reversed = coedge.IsReversed ^ !edge.OrientedEdgeSense ^ !pc.SameSense;
                var segments = pc.Pcurve.Kind == PcurveGeometryKind.Line ? 2 : System.Math.Max(32, options.MinimumSegments);
                // Imported analytic pcurves may use different equivalent angular
                // charts on neighbouring edges. Translate the whole coedge by an
                // integral turn at its join; preserve its authored sweep internally.
                // Pointwise wrapping would erase legitimate multi-turn helices.
                var angularOffset = 0d;
                if (uvPoints.Count > 0 && surfaceKind is SurfaceGeometryKind.Cylinder or SurfaceGeometryKind.Cone)
                {
                    var first = pc.Pcurve.Evaluate(reversed ? pc.Pcurve.Domain.End : pc.Pcurve.Domain.Start);
                    angularOffset = 2d * double.Pi * double.Round((uvPoints[^1].U - first.U) / (2d * double.Pi));
                }
                for (var i = 0; i <= segments; i++)
                {
                    var fraction = (double)i / segments;
                    if (reversed) fraction = 1 - fraction;
                    var uv = pc.Pcurve.Evaluate(pc.Pcurve.Domain.Start + fraction * (pc.Pcurve.Domain.End - pc.Pcurve.Domain.Start));
                    AppendUniqueUvPoint(uvPoints, (uv.U + angularOffset, uv.V));
                }
                continue;
            }
            var sampledCurve = TrySampleCoedgeForTrimEvaluation(body, faceId, coedge, vertexPointsResult.Value, options, executionBudget, surfaceKind);
            if (!sampledCurve.IsSuccess)
            {
                return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(sampledCurve.Diagnostics);
            }

            foreach (var point in sampledCurve.Value)
            {
                var uv = projectPointToUv(point);
                if (!uv.HasValue)
                {
                    return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
                        CreateNotImplemented(
                            $"Face {faceId.Value} parametric trim tessellation could not project loop samples into the parametric domain.",
                            BSplineSurfaceTrimUnsupportedSource)]);
                }

                AppendUniqueUvPoint(uvPoints, uv.Value);
            }
        }

        if (uvPoints.Count > 1 && UvPointsAlmostEqual(uvPoints[0], uvPoints[^1]))
        {
            uvPoints.RemoveAt(uvPoints.Count - 1);
        }

        return KernelResult<IReadOnlyList<(double U, double V)>>.Success(uvPoints);
    }

    private static KernelResult<IReadOnlyList<Point3D>> TrySampleCoedgeForTrimEvaluation(
        BrepBody body,
        FaceId faceId,
        Coedge coedge,
        IReadOnlyDictionary<VertexId, Point3D> vertexPoints,
        DisplayTessellationOptions options,
        DisplayTessellationExecutionBudget? executionBudget = null,
        SurfaceGeometryKind? surfaceKind = null)
    {
        executionBudget?.ThrowIfExpired("TrimCoedgeSampling", faceId, surfaceKind);
        var endpoints = GetEdgeEndpoints(body, coedge.EdgeId, coedge.IsReversed, vertexPoints);
        if (!endpoints.IsSuccess)
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure(endpoints.Diagnostics);
        }

        var polylineResult = TessellateEdge(body, coedge.EdgeId, options);
        if (!polylineResult.IsSuccess)
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure(polylineResult.Diagnostics);
        }

        var sampled = polylineResult.Value.Points.ToArray();
        if (sampled.Length < 2)
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure([
                CreateNotImplemented($"Face {faceId.Value} trim edge {coedge.EdgeId.Value} did not produce enough samples.", BSplineSurfaceTrimUnsupportedSource)]);
        }

        var directDistance = DistanceSquared(sampled[0], endpoints.Value.Start) + DistanceSquared(sampled[^1], endpoints.Value.End);
        var reversedDistance = DistanceSquared(sampled[0], endpoints.Value.End) + DistanceSquared(sampled[^1], endpoints.Value.Start);
        if (reversedDistance < directDistance)
        {
            Array.Reverse(sampled);
        }

        sampled[0] = endpoints.Value.Start;
        sampled[^1] = endpoints.Value.End;
        return KernelResult<IReadOnlyList<Point3D>>.Success(sampled);
    }

    private static void AppendUniqueUvPoint(List<(double U, double V)> points, (double U, double V) point)
    {
        if (points.Count == 0 || !UvPointsAlmostEqual(points[^1], point))
        {
            points.Add(point);
        }
    }

    private static bool UvPointsAlmostEqual((double U, double V) left, (double U, double V) right)
        => System.Math.Abs(left.U - right.U) <= LoopEndpointTolerance
            && System.Math.Abs(left.V - right.V) <= LoopEndpointTolerance;

    private static double DistanceSquared(Point3D left, Point3D right)
    {
        var delta = left - right;
        return delta.Dot(delta);
    }

    private static double ComputeBSplineProjectionTolerance(BSplineSurfaceWithKnots surface)
    {
        var points = surface.ControlPoints.SelectMany(row => row).ToArray();
        if (points.Length == 0)
        {
            return 1e-4d;
        }

        var minX = points.Min(point => point.X);
        var minY = points.Min(point => point.Y);
        var minZ = points.Min(point => point.Z);
        var maxX = points.Max(point => point.X);
        var maxY = points.Max(point => point.Y);
        var maxZ = points.Max(point => point.Z);
        var diagonal = new Vector3D(maxX - minX, maxY - minY, maxZ - minZ).Length;
        // Vendor STEP files carry edge curves that only agree with their face surfaces to the exporting CAD
        // system's accuracy; measured on a McMaster bevel pinion the worst edge-to-surface gap is about 7 microns.
        // Loop samples that close to a surface are still unambiguously on it, so the tolerance has a 50 micron
        // floor (model units are mm after import normalization). NIST rational patches sit up to ~20 microns off
        // their boundary edges even with exact NURBS evaluation.
        return System.Math.Max(5e-2d, diagonal * 1e-4d);
    }

    private static Vector3D EvaluateBSplineNormal(BSplineSurfaceWithKnots surface, double u, double v)
    {
        var du = System.Math.Max((surface.DomainEndU - surface.DomainStartU) * 1e-4d, 1e-6d);
        var dv = System.Math.Max((surface.DomainEndV - surface.DomainStartV) * 1e-4d, 1e-6d);

        var uMinus = System.Math.Clamp(u - du, surface.DomainStartU, surface.DomainEndU);
        var uPlus = System.Math.Clamp(u + du, surface.DomainStartU, surface.DomainEndU);
        var vMinus = System.Math.Clamp(v - dv, surface.DomainStartV, surface.DomainEndV);
        var vPlus = System.Math.Clamp(v + dv, surface.DomainStartV, surface.DomainEndV);

        var tangentU = surface.Evaluate(uPlus, v) - surface.Evaluate(uMinus, v);
        var tangentV = surface.Evaluate(u, vPlus) - surface.Evaluate(u, vMinus);
        // Finite-difference lengths depend on parameter scale. Rescale before
        // the cross product so a regular, small ruled face is not mistaken for
        // a singularity (notably near an involute's zero-speed base endpoint).
        static Vector3D Rescale(Vector3D t)
        {
            var scale = System.Math.Max(System.Math.Abs(t.X), System.Math.Max(System.Math.Abs(t.Y), System.Math.Abs(t.Z)));
            // Component division is intentional: Vector3D's geometric division
            // guard treats small physical lengths as zero; this scale is relative.
            return scale > 0 && double.IsFinite(scale) ? new(t.X / scale, t.Y / scale, t.Z / scale) : t;
        }
        tangentU = Rescale(tangentU);
        tangentV = Rescale(tangentV);
        var normal = tangentU.Cross(tangentV);
        if (!normal.TryNormalize(out var normalized))
        {
            return new Vector3D(0d, 0d, 1d);
        }

        return normalized;
    }

    private static KernelResult<DisplayFaceMeshPatch> TessellateEllipsoidFace(BrepBody body, FaceId faceId,
        EllipsoidSurface ellipsoid, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? budget)
    {
        // Affine pullback to the existing spherical trim authority. Refinement's
        // unit-sphere chord bound is tightened by the largest singular value.
        var loops = new List<IReadOnlyList<Point3D>>();
        foreach (var loop in body.GetLoopIds(faceId))
        {
            var coedges = body.GetCoedgeIds(loop).Select(body.Topology.GetCoedge).ToArray();
            var lookup = BuildLoopVertexPointLookup(body, coedges, faceId);
            if (!lookup.IsSuccess) return KernelResult<DisplayFaceMeshPatch>.Failure(lookup.Diagnostics);
            var points = new List<Point3D>();
            foreach (var use in coedges)
            {
                var samples = TrySampleCoedgeForTrimEvaluation(body, faceId, use, lookup.Value, options, budget, SurfaceGeometryKind.Ellipsoid);
                if (!samples.IsSuccess) return KernelResult<DisplayFaceMeshPatch>.Failure(samples.Diagnostics);
                points.AddRange(samples.Value.Skip(points.Count > 0 ? 1 : 0).Select(p => Point3D.Origin + ellipsoid.UnitCoordinates(p)));
            }
            loops.Add(points);
        }
        var unit = new SphereSurface(Point3D.Origin, Direction3D.Create(new Vector3D(0, 0, 1)), 1, Direction3D.Create(new Vector3D(1, 0, 0)));
        var mesh = SphericalTrimTessellator.Tessellate(faceId, unit, loops, 0,
            body.Bindings.GetFaceBinding(faceId).Orientation.IsAlignedWithSurface,
            options with { ChordTolerance = options.ChordTolerance / double.Max(ellipsoid.RadiusX, double.Max(ellipsoid.RadiusY, ellipsoid.RadiusZ)) }, budget);
        if (!mesh.IsSuccess) return mesh;
        var positions = mesh.Value.Positions.Select(ellipsoid.FromUnit).ToArray();
        return KernelResult<DisplayFaceMeshPatch>.Success(mesh.Value with
        { Positions = positions, Normals = positions.Select(ellipsoid.Normal).ToArray() }, mesh.Diagnostics);
    }

    private static KernelResult<DisplayFaceMeshPatch> TessellateSphereFace(BrepBody body, FaceId faceId, SphereSurface sphere, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
    {
        var edgeLoops = body.GetLoopIds(faceId).Where(id => body.Topology.GetLoop(id).Kind == LoopKind.Edge).ToArray();
        if (edgeLoops.Length > 0)
        {
            var sampledLoops = new List<(LoopId Id, IReadOnlyList<Point3D> Points)>();
            foreach (var loopId in edgeLoops)
            {
                var coedges = body.GetCoedgeIds(loopId).Select(body.Topology.GetCoedge).ToArray();
                var vertices = BuildLoopVertexPointLookup(body, coedges, faceId);
                if (!vertices.IsSuccess) return KernelResult<DisplayFaceMeshPatch>.Failure(vertices.Diagnostics);
                var points = new List<Point3D>();
                foreach (var coedge in coedges)
                {
                    var sampled = TrySampleCoedgeForTrimEvaluation(body, faceId, coedge, vertices.Value, options, executionBudget, SurfaceGeometryKind.Sphere);
                    if (!sampled.IsSuccess) return KernelResult<DisplayFaceMeshPatch>.Failure(sampled.Diagnostics);
                    var boundarySamples = sampled.Value;
                    var edge = body.Topology.GetEdge(coedge.EdgeId);
                    if (body.Bindings.TryGetPcurveBinding(coedge.Id, out var pc) && pc.FaceId == faceId)
                    {
                        var binding = body.Bindings.GetEdgeBinding(edge.Id);
                        var reversed = coedge.IsReversed ^ !binding.OrientedEdgeSense ^ !pc.SameSense;
                        var count = System.Math.Max(32, boundarySamples.Count - 1);
                        boundarySamples = Enumerable.Range(0, count + 1).Select(i =>
                        {
                            var t = reversed ? 1d - (double)i / count : (double)i / count;
                            var uv = pc.Pcurve.Evaluate(pc.Pcurve.Domain.Start + t * (pc.Pcurve.Domain.End - pc.Pcurve.Domain.Start));
                            return sphere.Evaluate(uv.U, uv.V);
                        }).ToArray();
                    }
                    // Endpoint matching cannot determine a closed edge's direction.
                    // The spherical chart needs directed winding to choose the cap;
                    // consume the existing coedge/curve sense for that singular case.
                    else if (edge.StartVertexId == edge.EndVertexId && (coedge.IsReversed ^ !body.Bindings.GetEdgeBinding(edge.Id).OrientedEdgeSense))
                        boundarySamples = boundarySamples.Reverse().ToArray();
                    points.AddRange(boundarySamples.Skip(points.Count > 0 ? 1 : 0));
                }
                sampledLoops.Add((loopId, points));
            }
            var outerIndex = Array.FindIndex(edgeLoops, id => body.Bindings.TryGetFaceBoundaryRoleBinding(id, out var role) && role.Role == FaceBoundaryRole.Outer);
            return SphericalTrimTessellator.Tessellate(faceId, sphere, sampledLoops.Select(l => l.Points).ToArray(),
                outerIndex < 0 ? 0 : outerIndex, body.Bindings.GetFaceBinding(faceId).Orientation.IsAlignedWithSurface,
                options, executionBudget);
        }
        // With no edge boundary, retained vertex loops are zero-dimensional punctures of the support.
        var angularSegments = CalculateSegmentCount(2d * double.Pi, sphere.Radius, options);
        var elevationSegments = System.Math.Max(2, System.Math.Clamp(angularSegments / 2, options.MinimumSegments / 2, options.MaximumSegments));

        return KernelResult<DisplayFaceMeshPatch>.Success(CreateBoundedGridPatch(
            faceId,
            angularSegments,
            elevationSegments,
            (u, v) => sphere.Evaluate(u, v),
            (u, v) => sphere.Normal(u, v).ToVector(),
            0d,
            2d * double.Pi,
            -double.Pi / 2d,
            double.Pi / 2d));
    }


    private static KernelResult<DisplayFaceMeshPatch> TessellateTorusFace(BrepBody body, FaceId faceId, TorusSurface torus, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
    {
        var loopIds = body.GetLoopIds(faceId)
            .Where(loopId => body.Topology.GetLoop(loopId).Kind == LoopKind.Edge)
            .ToArray();
        if (loopIds.Length == 2 && TryResolveCoaxialCirclePairTorusBand(body, torus, loopIds, out var bandVStart, out var bandVEnd))
        {
            // Two full parallel circles bound a band of the tube: the generic trim path sees two degenerate
            // (zero-area) loops in UV, so tessellate the band directly as a periodic grid.
            return KernelResult<DisplayFaceMeshPatch>.Success(CreatePeriodicGridPatch(
                faceId,
                CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, torus.MajorRadius + torus.MinorRadius), options),
                CalculateSegmentCount(bandVEnd - bandVStart, System.Math.Max(1e-6d, torus.MinorRadius), options),
                (u, v) => torus.Evaluate(u, v),
                (u, v) => torus.Normal(u, v).ToVector(),
                bandVStart,
                bandVEnd));
        }

        if (loopIds.Length > 0)
        {
            var uvLoopsResult = TryBuildDoublyPeriodicTrimmedSurfaceUvLoops(body, faceId, loopIds, point => TryProjectPointToTorusUv(torus, point), options, executionBudget, SurfaceGeometryKind.Torus);
            if (!uvLoopsResult.IsSuccess)
            {
                return KernelResult<DisplayFaceMeshPatch>.Success(
                    CreateEmptyPlanarPatch(faceId),
                    [CreateValidationWarning(
                        $"Face {faceId.Value} torus trim evaluation failed; skipping face patch to avoid misleading untrimmed geometry. Cause: {uvLoopsResult.Diagnostics.FirstOrDefault()?.Message}",
                        TrimEvaluationFailedSource)]);
            }

            return TrimmedSurfaceTessellator.Tessellate(
                faceId,
                uvLoopsResult.Value,
                (u, v) => torus.Evaluate(u, v),
                (u, v) => torus.Normal(u, v).ToVector(),
                options,
                double.NegativeInfinity,
                double.PositiveInfinity,
                double.NegativeInfinity,
                double.PositiveInfinity,
                CreateValidationWarning,
                executionBudget,
                SurfaceGeometryKind.Torus);
        }

        var parameters = GetRevolvedFaceParameters(body, faceId, options, radiusHint: torus.MajorRadius + torus.MinorRadius, allowThreeCoedgeConeTopology: false, axialParameterFromPoint: point => TorusMinorAngleOf(torus, point));
        if (!parameters.IsSuccess)
        {
            return KernelResult<DisplayFaceMeshPatch>.Failure(parameters.Diagnostics);
        }

        return KernelResult<DisplayFaceMeshPatch>.Success(CreatePeriodicGridPatch(
            faceId,
            parameters.Value.AngularSegments,
            CalculateSegmentCount(parameters.Value.VEnd - parameters.Value.VStart, System.Math.Max(1e-6d, torus.MinorRadius), options),
            (u, v) => torus.Evaluate(u, v),
            (u, v) => torus.Normal(u, v).ToVector(),
            parameters.Value.VStart,
            parameters.Value.VEnd));
    }

    private static KernelResult<(double VStart, double VEnd, int AngularSegments, int AxialSegments)> GetRevolvedFaceParameters(
        BrepBody body,
        FaceId faceId,
        DisplayTessellationOptions options,
        double radiusHint,
        bool allowThreeCoedgeConeTopology,
        Func<Point3D, double>? axialParameterFromPoint = null)
    {
        var coedgesResult = TryGetSupportedRevolvedCoedges(body, faceId);
        if (!coedgesResult.IsSuccess)
        {
            return KernelResult<(double, double, int, int)>.Failure(coedgesResult.Diagnostics);
        }

        var coedges = coedgesResult.Value;

        var lineCoedges = coedges.Where(c => body.GetEdgeCurve(c.EdgeId).Kind == CurveGeometryKind.Line3).ToArray();
        var circleCoedges = coedges.Where(c => body.GetEdgeCurve(c.EdgeId).Kind == CurveGeometryKind.Circle3).ToArray();
        var bSplineCoedges = coedges.Where(c => body.GetEdgeCurve(c.EdgeId).Kind == CurveGeometryKind.BSpline3).ToArray();

        if (TryResolveFourUseMixedRevolvedLoop(body, coedges, lineCoedges, circleCoedges, axialParameterFromPoint, faceId, out var mixedRevolvedParameters, out var mixedRevolvedDiagnostics))
        {
            return KernelResult<(double, double, int, int)>.Success((
                mixedRevolvedParameters.VStart,
                mixedRevolvedParameters.VEnd,
                CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
                CalculateAxialSegments(mixedRevolvedParameters.VStart, mixedRevolvedParameters.VEnd, options)), mixedRevolvedDiagnostics);
        }

        if (TryResolveFourUseCircleBsplineRevolvedLoop(body, coedges, circleCoedges, bSplineCoedges, axialParameterFromPoint, faceId, out var circleBsplineParameters, out var circleBsplineDiagnostics))
        {
            return KernelResult<(double, double, int, int)>.Success((
                circleBsplineParameters.VStart,
                circleBsplineParameters.VEnd,
                CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
                CalculateAxialSegments(circleBsplineParameters.VStart, circleBsplineParameters.VEnd, options)), circleBsplineDiagnostics);
        }

        if (TryResolveFourCoedgeSingleCircleThreeBsplineRevolvedLoop(body, coedges, circleCoedges, bSplineCoedges, axialParameterFromPoint, faceId, out var fourCoedgeSingleCircleParameters, out var fourCoedgeSingleCircleDiagnostics))
        {
            return KernelResult<(double, double, int, int)>.Success((
                fourCoedgeSingleCircleParameters.VStart,
                fourCoedgeSingleCircleParameters.VEnd,
                CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
                CalculateAxialSegments(fourCoedgeSingleCircleParameters.VStart, fourCoedgeSingleCircleParameters.VEnd, options)), fourCoedgeSingleCircleDiagnostics);
        }

        if (TryResolveFourCoedgeThreeCircleSingleBsplineRevolvedLoop(body, coedges, circleCoedges, bSplineCoedges, axialParameterFromPoint, faceId, out var fourCoedgeThreeCircleParameters, out var fourCoedgeThreeCircleDiagnostics))
        {
            return KernelResult<(double, double, int, int)>.Success((
                fourCoedgeThreeCircleParameters.VStart,
                fourCoedgeThreeCircleParameters.VEnd,
                CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
                CalculateAxialSegments(fourCoedgeThreeCircleParameters.VStart, fourCoedgeThreeCircleParameters.VEnd, options)), fourCoedgeThreeCircleDiagnostics);
        }

        if (TryResolveFourUseBsplineOnlyRevolvedLoop(body, coedges, bSplineCoedges, axialParameterFromPoint, faceId, out var bsplineOnlyParameters, out var bsplineOnlyDiagnostics))
        {
            return KernelResult<(double, double, int, int)>.Success((
                bsplineOnlyParameters.VStart,
                bsplineOnlyParameters.VEnd,
                CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
                CalculateAxialSegments(bsplineOnlyParameters.VStart, bsplineOnlyParameters.VEnd, options)), bsplineOnlyDiagnostics);
        }

        if (TryResolveRepeatedCircleBsplineRevolvedLoop(body, coedges, circleCoedges, bSplineCoedges, axialParameterFromPoint, faceId, out var repeatedCircleBsplineParameters, out var repeatedCircleBsplineDiagnostics))
        {
            return KernelResult<(double, double, int, int)>.Success((
                repeatedCircleBsplineParameters.VStart,
                repeatedCircleBsplineParameters.VEnd,
                CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
                CalculateAxialSegments(repeatedCircleBsplineParameters.VStart, repeatedCircleBsplineParameters.VEnd, options)), repeatedCircleBsplineDiagnostics);
        }

        if (TryResolveSixCoedgeSingleCircleFiveBsplineRevolvedLoop(body, coedges, circleCoedges, bSplineCoedges, axialParameterFromPoint, faceId, out var sixCoedgeSingleCircleParameters, out var sixCoedgeSingleCircleDiagnostics))
        {
            return KernelResult<(double, double, int, int)>.Success((
                sixCoedgeSingleCircleParameters.VStart,
                sixCoedgeSingleCircleParameters.VEnd,
                CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
                CalculateAxialSegments(sixCoedgeSingleCircleParameters.VStart, sixCoedgeSingleCircleParameters.VEnd, options)), sixCoedgeSingleCircleDiagnostics);
        }

        if (TryResolveSixUseBsplineOnlyRevolvedLoop(body, coedges, bSplineCoedges, axialParameterFromPoint, faceId, out var sixUseBsplineOnlyParameters, out var sixUseBsplineOnlyDiagnostics))
        {
            return KernelResult<(double, double, int, int)>.Success((
                sixUseBsplineOnlyParameters.VStart,
                sixUseBsplineOnlyParameters.VEnd,
                CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
                CalculateAxialSegments(sixUseBsplineOnlyParameters.VStart, sixUseBsplineOnlyParameters.VEnd, options)), sixUseBsplineOnlyDiagnostics);
        }

        if (TryResolveDualSeamCircleRevolvedLoop(body, coedges, lineCoedges, circleCoedges, axialParameterFromPoint, faceId, out var dualSeamCircleParameters, out var dualSeamCircleDiagnostics))
        {
            return KernelResult<(double, double, int, int)>.Success((
                dualSeamCircleParameters.VStart,
                dualSeamCircleParameters.VEnd,
                CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
                CalculateAxialSegments(dualSeamCircleParameters.VStart, dualSeamCircleParameters.VEnd, options)), dualSeamCircleDiagnostics);
        }

        if (TryResolveRepeatedMixedRevolvedLoop(body, coedges, lineCoedges, circleCoedges, axialParameterFromPoint, faceId, out var repeatedMixedParameters, out var repeatedMixedDiagnostics))
        {
            return KernelResult<(double, double, int, int)>.Success((
                repeatedMixedParameters.VStart,
                repeatedMixedParameters.VEnd,
                CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
                CalculateAxialSegments(repeatedMixedParameters.VStart, repeatedMixedParameters.VEnd, options)), repeatedMixedDiagnostics);
        }

        if (allowThreeCoedgeConeTopology && TryResolveThreeCoedgeBsplineConeLoop(body, coedges, bSplineCoedges, axialParameterFromPoint, faceId, out var threeCoedgeBsplineParameters, out var threeCoedgeBsplineDiagnostics))
        {
            var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
            var axialSegments = CalculateAxialSegments(threeCoedgeBsplineParameters.VStart, threeCoedgeBsplineParameters.VEnd, options);
            return KernelResult<(double, double, int, int)>.Success((threeCoedgeBsplineParameters.VStart, threeCoedgeBsplineParameters.VEnd, angularSegments, axialSegments), threeCoedgeBsplineDiagnostics);
        }

        if (allowThreeCoedgeConeTopology && TryResolveThreeCoedgeMixedCircleBsplineConeLoop(body, coedges, circleCoedges, bSplineCoedges, axialParameterFromPoint, faceId, out var threeCoedgeMixedCircleBsplineParameters, out var threeCoedgeMixedCircleBsplineDiagnostics))
        {
            var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
            var axialSegments = CalculateAxialSegments(threeCoedgeMixedCircleBsplineParameters.VStart, threeCoedgeMixedCircleBsplineParameters.VEnd, options);
            return KernelResult<(double, double, int, int)>.Success((threeCoedgeMixedCircleBsplineParameters.VStart, threeCoedgeMixedCircleBsplineParameters.VEnd, angularSegments, axialSegments), threeCoedgeMixedCircleBsplineDiagnostics);
        }

        if (allowThreeCoedgeConeTopology && TryResolveConeRevolvedLoop(body, coedges, lineCoedges, circleCoedges, axialParameterFromPoint, faceId, out var coneRevolvedParameters, out var coneRevolvedDiagnostics))
        {
            var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
            var axialSegments = CalculateAxialSegments(coneRevolvedParameters.VStart, coneRevolvedParameters.VEnd, options);
            return KernelResult<(double, double, int, int)>.Success((coneRevolvedParameters.VStart, coneRevolvedParameters.VEnd, angularSegments, axialSegments), coneRevolvedDiagnostics);
        }

        if (allowThreeCoedgeConeTopology && TryResolveSingleCoedgeCircleSeamReusedConeLoop(body, coedges, lineCoedges, circleCoedges, axialParameterFromPoint, faceId, out var singleCoedgeCircleSeamReusedConeParameters, out var singleCoedgeCircleSeamReusedConeDiagnostics))
        {
            var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
            var axialSegments = CalculateAxialSegments(singleCoedgeCircleSeamReusedConeParameters.VStart, singleCoedgeCircleSeamReusedConeParameters.VEnd, options);
            return KernelResult<(double, double, int, int)>.Success((singleCoedgeCircleSeamReusedConeParameters.VStart, singleCoedgeCircleSeamReusedConeParameters.VEnd, angularSegments, axialSegments), singleCoedgeCircleSeamReusedConeDiagnostics);
        }

        if (TryResolveFourUseCircleOnlyNonSeamRevolvedLoop(body, coedges, lineCoedges, circleCoedges, axialParameterFromPoint, faceId, out var fourUseCircleOnlyNonSeamParameters, out var fourUseCircleOnlyNonSeamDiagnostics))
        {
            var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
            var axialSegments = CalculateAxialSegments(fourUseCircleOnlyNonSeamParameters.VStart, fourUseCircleOnlyNonSeamParameters.VEnd, options);
            return KernelResult<(double, double, int, int)>.Success((fourUseCircleOnlyNonSeamParameters.VStart, fourUseCircleOnlyNonSeamParameters.VEnd, angularSegments, axialSegments), fourUseCircleOnlyNonSeamDiagnostics);
        }

        var uniqueEdgeIds = coedges
            .Select(c => c.EdgeId)
            .Distinct()
            .ToArray();
        var allEdgeCurvesAreCircles = uniqueEdgeIds
            .Select(id => body.GetEdgeCurve(id).Kind)
            .All(kind => kind == CurveGeometryKind.Circle3);

        if (lineCoedges.Length == 0 && circleCoedges.Length >= 4 && uniqueEdgeIds.Length == 2 && allEdgeCurvesAreCircles)
        {
            var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
            var axialSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
            return KernelResult<(double, double, int, int)>.Success((0d, 2d * double.Pi, angularSegments, axialSegments));
        }

        if (axialParameterFromPoint is not null)
        {
            var projectedVertexBounds = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
            if (projectedVertexBounds.IsSuccess)
            {
                var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
                var axialSegments = CalculateAxialSegments(projectedVertexBounds.Value.VStart, projectedVertexBounds.Value.VEnd, options);
                return KernelResult<(double, double, int, int)>.Success((projectedVertexBounds.Value.VStart, projectedVertexBounds.Value.VEnd, angularSegments, axialSegments));
            }
        }

        var topologyFamily = allowThreeCoedgeConeTopology ? "cone/revolved" : "torus/revolved";
        var observedFamily = ClassifyRevolvedTopologyFamily(body, coedges, lineCoedges, circleCoedges, bSplineCoedges);
        return KernelResult<(double, double, int, int)>.Failure([CreateNotImplemented($"Face {faceId.Value} curved tessellation supports selected repeated {topologyFamily} boundary subfamilies; unsupported subfamily '{observedFamily}'. Observed: {DescribeRevolvedLoopTopology(body, coedges)}")]);
    }

    private static KernelResult<IReadOnlyList<Coedge>> TryGetSupportedRevolvedCoedges(BrepBody body, FaceId faceId)
    {
        var loopIds = body.GetLoopIds(faceId)
            .Where(loopId => body.Topology.GetLoop(loopId).Kind == LoopKind.Edge)
            .ToArray();
        if (loopIds.Length == 1)
        {
            var singleLoopCoedges = body.GetCoedgeIds(loopIds[0])
                .Select(id => body.Topology.GetCoedge(id))
                .ToArray();
            return KernelResult<IReadOnlyList<Coedge>>.Success(singleLoopCoedges);
        }

        if (TryResolvePreservedPeriodicDualSeamCircleLoopFamily(body, loopIds, out var preservedFamilyCoedges))
        {
            return KernelResult<IReadOnlyList<Coedge>>.Success(preservedFamilyCoedges);
        }

        return KernelResult<IReadOnlyList<Coedge>>.Failure([
            CreateNotImplemented($"Face {faceId.Value} curved tessellation supports exactly one loop or the preserved periodic dual single-coedge seam-circle loop family. Observed: {DescribeRevolvedFaceTopology(body, loopIds)}", CurvedTopologyUnsupportedSource)
        ]);
    }

    private static bool TryResolvePreservedPeriodicDualSeamCircleLoopFamily(
        BrepBody body,
        IReadOnlyList<LoopId> loopIds,
        out IReadOnlyList<Coedge> coedges)
    {
        coedges = [];
        if (loopIds.Count != 2)
        {
            return false;
        }

        var resolved = new List<Coedge>(2);
        foreach (var loopId in loopIds)
        {
            var coedgeIds = body.GetCoedgeIds(loopId);
            if (coedgeIds.Count != 1)
            {
                return false;
            }

            var coedge = body.Topology.GetCoedge(coedgeIds[0]);
            if (body.GetEdgeCurve(coedge.EdgeId).Kind != CurveGeometryKind.Circle3)
            {
                return false;
            }

            var edge = body.Topology.GetEdge(coedge.EdgeId);
            if (edge.StartVertexId != edge.EndVertexId)
            {
                return false;
            }

            resolved.Add(coedge);
        }

        coedges = resolved;
        return true;
    }


    private static bool TryResolveRepeatedCircleBsplineRevolvedLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> circleCoedges,
        IReadOnlyList<Coedge> bSplineCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        if (coedges.Count < 5 || circleCoedges.Count < 2 || bSplineCoedges.Count < 1 || axialParameterFromPoint is null)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static bool TryResolveFourUseCircleOnlyNonSeamRevolvedLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> lineCoedges,
        IReadOnlyList<Coedge> circleCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        if (axialParameterFromPoint is null || coedges.Count != 4 || lineCoedges.Count != 0 || circleCoedges.Count != 4)
        {
            return false;
        }

        var uniqueEdgeIds = coedges.Select(c => c.EdgeId).Distinct().ToArray();
        if (uniqueEdgeIds.Length != 4)
        {
            return false;
        }

        var seamUses = coedges.Count(c =>
        {
            var edge = body.Topology.GetEdge(c.EdgeId);
            return edge.StartVertexId == edge.EndVertexId;
        });
        if (seamUses != 0)
        {
            return false;
        }

        var allEdgeCurvesAreCircles = uniqueEdgeIds
            .Select(id => body.GetEdgeCurve(id).Kind)
            .All(kind => kind == CurveGeometryKind.Circle3);
        if (!allEdgeCurvesAreCircles)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }


    private static bool TryResolveDualSeamCircleRevolvedLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> lineCoedges,
        IReadOnlyList<Coedge> circleCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];

        if (axialParameterFromPoint is null || coedges.Count != 2 || lineCoedges.Count != 0 || circleCoedges.Count != 2)
        {
            return false;
        }

        var seamUses = coedges.Count(c =>
        {
            var edge = body.Topology.GetEdge(c.EdgeId);
            return edge.StartVertexId == edge.EndVertexId;
        });

        if (seamUses != 2 || coedges.Select(c => c.EdgeId).Distinct().Count() != 2)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static bool TryResolveSingleCoedgeCircleSeamReusedConeLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> lineCoedges,
        IReadOnlyList<Coedge> circleCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];

        if (axialParameterFromPoint is null || coedges.Count != 1 || lineCoedges.Count != 0 || circleCoedges.Count != 1)
        {
            return false;
        }

        var coedge = coedges[0];
        var edge = body.Topology.GetEdge(coedge.EdgeId);
        if (edge.StartVertexId != edge.EndVertexId)
        {
            return false;
        }

        if (body.GetEdgeCurve(coedge.EdgeId).Kind != CurveGeometryKind.Circle3)
        {
            return false;
        }

        var vertexPoint = GetVertexPoint(body, edge.StartVertexId);
        if (!vertexPoint.IsSuccess)
        {
            diagnostics = vertexPoint.Diagnostics;
            return false;
        }

        var trimV = axialParameterFromPoint(vertexPoint.Value);
        if (!double.IsFinite(trimV) || trimV <= 1e-8d)
        {
            diagnostics =
            [
                CreateNotImplemented($"Face {faceId.Value} curved tessellation could not derive finite non-degenerate axial bounds for single-coedge seam-reused circle cone topology. Observed: {DescribeRevolvedLoopTopology(body, coedges)}", CurvedTopologyUnsupportedSource)
            ];
            return false;
        }

        parameters = (0d, trimV);
        return true;
    }

    private static bool TryResolveRepeatedMixedRevolvedLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> lineCoedges,
        IReadOnlyList<Coedge> circleCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        if (coedges.Count < 5 || lineCoedges.Count < 2 || circleCoedges.Count < 2)
        {
            return false;
        }

        var lineEdgeIds = lineCoedges.Select(c => c.EdgeId).Distinct().ToArray();
        if (lineEdgeIds.Length == 0)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromLines(body, coedges, lineEdgeIds, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static bool TryResolveSixCoedgeSingleCircleFiveBsplineRevolvedLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> circleCoedges,
        IReadOnlyList<Coedge> bSplineCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        var uniqueEdgeCount = coedges.Select(c => c.EdgeId).Distinct().Count();
        if (coedges.Count != 6 || uniqueEdgeCount != 6 || circleCoedges.Count != 1 || bSplineCoedges.Count != 5 || axialParameterFromPoint is null)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static bool TryResolveFourUseMixedRevolvedLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> lineCoedges,
        IReadOnlyList<Coedge> circleCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        if (coedges.Count != 4 || lineCoedges.Count != 2 || circleCoedges.Count != 2)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromLines(body, coedges, lineCoedges.Select(c => c.EdgeId).Distinct().ToArray(), axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static bool TryResolveFourUseCircleBsplineRevolvedLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> circleCoedges,
        IReadOnlyList<Coedge> bSplineCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        if (coedges.Count != 4 || circleCoedges.Count != 2 || bSplineCoedges.Count != 2 || axialParameterFromPoint is null)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static bool TryResolveFourUseBsplineOnlyRevolvedLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> bSplineCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        if (coedges.Count != 4 || bSplineCoedges.Count != 4 || axialParameterFromPoint is null)
        {
            return false;
        }

        var uniqueEdgeCount = coedges
            .Select(c => c.EdgeId)
            .Distinct()
            .Count();
        if (uniqueEdgeCount != 4)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static bool TryResolveSixUseBsplineOnlyRevolvedLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> bSplineCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        if (coedges.Count != 6 || bSplineCoedges.Count != 6 || axialParameterFromPoint is null)
        {
            return false;
        }

        var uniqueEdgeCount = coedges
            .Select(c => c.EdgeId)
            .Distinct()
            .Count();
        if (uniqueEdgeCount != 6)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static bool TryResolveFourCoedgeSingleCircleThreeBsplineRevolvedLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> circleCoedges,
        IReadOnlyList<Coedge> bSplineCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        if (coedges.Count != 4 || circleCoedges.Count != 1 || bSplineCoedges.Count != 3 || axialParameterFromPoint is null)
        {
            return false;
        }

        var uniqueEdgeCount = coedges
            .Select(c => c.EdgeId)
            .Distinct()
            .Count();
        if (uniqueEdgeCount < 3)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static bool TryResolveFourCoedgeThreeCircleSingleBsplineRevolvedLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> circleCoedges,
        IReadOnlyList<Coedge> bSplineCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        if (coedges.Count != 4 || circleCoedges.Count != 3 || bSplineCoedges.Count != 1 || axialParameterFromPoint is null)
        {
            return false;
        }

        var uniqueEdgeCount = coedges
            .Select(c => c.EdgeId)
            .Distinct()
            .Count();
        if (uniqueEdgeCount != 4)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static bool TryResolveConeRevolvedLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> lineCoedges,
        IReadOnlyList<Coedge> circleCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        if (coedges.Count < 3 || lineCoedges.Count < 2 || circleCoedges.Count < 1)
        {
            return false;
        }

        var lineEdgeIds = lineCoedges.Select(c => c.EdgeId).Distinct().ToArray();
        var result = TryResolveAxialBoundsFromLines(body, coedges, lineEdgeIds, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static bool TryResolveThreeCoedgeMixedCircleBsplineConeLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> circleCoedges,
        IReadOnlyList<Coedge> bSplineCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        if (coedges.Count != 3 || circleCoedges.Count != 1 || bSplineCoedges.Count != 2 || axialParameterFromPoint is null)
        {
            return false;
        }

        var uniqueEdgeCount = coedges
            .Select(c => c.EdgeId)
            .Distinct()
            .Count();
        if (uniqueEdgeCount != 3)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static bool TryResolveThreeCoedgeBsplineConeLoop(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> bSplineCoedges,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId,
        out (double VStart, double VEnd) parameters,
        out IReadOnlyList<KernelDiagnostic> diagnostics)
    {
        parameters = default;
        diagnostics = [];
        if (coedges.Count != 3 || bSplineCoedges.Count != 3 || axialParameterFromPoint is null)
        {
            return false;
        }

        var uniqueEdgeCount = coedges
            .Select(c => c.EdgeId)
            .Distinct()
            .Count();
        if (uniqueEdgeCount != 3)
        {
            return false;
        }

        var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
        if (!result.IsSuccess)
        {
            diagnostics = result.Diagnostics;
            return false;
        }

        parameters = result.Value;
        diagnostics = result.Diagnostics;
        return true;
    }

    private static KernelResult<(double VStart, double VEnd)> TryResolveAxialBoundsFromLines(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<EdgeId> lineEdgeIds,
        Func<Point3D, double>? axialParameterFromPoint,
        FaceId faceId)
    {
        if (lineEdgeIds.Count == 0)
        {
            return KernelResult<(double VStart, double VEnd)>.Failure([CreateNotImplemented($"Face {faceId.Value} curved tessellation expected line trim edges for revolved topology. Observed: {DescribeRevolvedLoopTopology(body, coedges)}", CurvedTopologyUnsupportedSource)]);
        }

        var intervals = new List<ParameterInterval>(lineEdgeIds.Count);
        foreach (var lineEdgeId in lineEdgeIds)
        {
            if (!body.Bindings.TryGetEdgeBinding(lineEdgeId, out var lineTrimBinding))
            {
                return KernelResult<(double VStart, double VEnd)>.Failure([CreateNotImplemented($"Face {faceId.Value} line trim edge is missing curve trim binding.")]);
            }

            intervals.Add(lineTrimBinding.TrimInterval ?? new ParameterInterval(0d, 1d));
        }

        var vMin = intervals.Min(i => System.Math.Min(i.Start, i.End));
        var vMax = intervals.Max(i => System.Math.Max(i.Start, i.End));
        var increasing = intervals[0].End >= intervals[0].Start;
        var vStart = increasing ? vMin : vMax;
        var vEnd = increasing ? vMax : vMin;

        if (axialParameterFromPoint is not null)
        {
            var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
            if (!vertexPointsResult.IsSuccess)
            {
                return KernelResult<(double VStart, double VEnd)>.Failure(vertexPointsResult.Diagnostics);
            }

            var projected = vertexPointsResult.Value.Values
                .Select(axialParameterFromPoint)
                .Where(double.IsFinite)
                .ToArray();

            if (projected.Length != 0)
            {
                var projectedMin = projected.Min();
                var projectedMax = projected.Max();
                vStart = increasing ? projectedMin : projectedMax;
                vEnd = increasing ? projectedMax : projectedMin;
            }
        }

        return KernelResult<(double VStart, double VEnd)>.Success((vStart, vEnd));
    }


    private static KernelResult<(double VStart, double VEnd)> TryResolveAxialBoundsFromProjectedLoopVertices(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        Func<Point3D, double> axialParameterFromPoint,
        FaceId faceId)
    {
        var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
        if (!vertexPointsResult.IsSuccess)
        {
            return KernelResult<(double VStart, double VEnd)>.Failure(vertexPointsResult.Diagnostics);
        }

        var projected = vertexPointsResult.Value.Values
            .Select(axialParameterFromPoint)
            .Where(double.IsFinite)
            .ToArray();

        if (projected.Length < 2)
        {
            return KernelResult<(double VStart, double VEnd)>.Failure([
                CreateNotImplemented($"Face {faceId.Value} curved tessellation could not derive axial bounds from projected loop vertices. Observed: {DescribeRevolvedLoopTopology(body, coedges)}", CurvedTopologyUnsupportedSource)]);
        }

        var vStart = projected.Min();
        var vEnd = projected.Max();
        if (double.Abs(vEnd - vStart) <= 1e-9d)
        {
            return KernelResult<(double VStart, double VEnd)>.Failure([
                CreateNotImplemented($"Face {faceId.Value} curved tessellation derived a degenerate projected axial span. Observed: {DescribeRevolvedLoopTopology(body, coedges)}", CurvedTopologyUnsupportedSource)]);
        }

        return KernelResult<(double VStart, double VEnd)>.Success((vStart, vEnd));
    }

    private static int CalculateAxialSegments(double vStart, double vEnd, DisplayTessellationOptions options)
    {
        var axialSpan = double.Abs(vEnd - vStart);
        return System.Math.Max(1, System.Math.Clamp((int)double.Ceiling(axialSpan / options.ChordTolerance), 1, options.MaximumSegments));
    }

    private static string DescribeRevolvedLoopTopology(BrepBody body, IReadOnlyList<Coedge> coedges, int loopCount = 1)
    {
        var lineUseCount = 0;
        var circleUseCount = 0;
        var ellipseUseCount = 0;
        var bSplineUseCount = 0;
        var seamUseCount = 0;

        foreach (var coedge in coedges)
        {
            var curve = body.GetEdgeCurve(coedge.EdgeId);
            if (curve.Kind == CurveGeometryKind.Line3)
            {
                lineUseCount++;
            }
            else if (curve.Kind == CurveGeometryKind.Circle3)
            {
                circleUseCount++;
            }
            else if (curve.Kind == CurveGeometryKind.Ellipse3)
            {
                ellipseUseCount++;
            }
            else if (curve.Kind == CurveGeometryKind.BSpline3)
            {
                bSplineUseCount++;
            }

            var edge = body.Topology.GetEdge(coedge.EdgeId);
            if (edge.StartVertexId == edge.EndVertexId)
            {
                seamUseCount++;
            }
        }

        var edgeFamilies = coedges
            .Select(c => $"{c.EdgeId.Value}:{body.GetEdgeCurve(c.EdgeId).Kind}")
            .ToArray();

        return $"loops={loopCount} coedges={coedges.Count} lineUses={lineUseCount} circleUses={circleUseCount} ellipseUses={ellipseUseCount} bSplineUses={bSplineUseCount} seamEdgeUses={seamUseCount} edgeFamilies=[{string.Join(", ", edgeFamilies)}]";
    }

    private static string DescribeRevolvedFaceTopology(BrepBody body, IReadOnlyList<LoopId> loopIds)
    {
        var loopDescriptions = new List<string>(loopIds.Count);
        var aggregateCoedges = new List<Coedge>();

        foreach (var loopId in loopIds)
        {
            var coedges = body.GetCoedgeIds(loopId)
                .Select(id => body.Topology.GetCoedge(id))
                .ToArray();
            aggregateCoedges.AddRange(coedges);

            var uniqueEdges = coedges.Select(c => c.EdgeId).Distinct().Count();
            var circleUses = coedges.Count(c => body.GetEdgeCurve(c.EdgeId).Kind == CurveGeometryKind.Circle3);
            var seamUses = coedges.Count(c =>
            {
                var edge = body.Topology.GetEdge(c.EdgeId);
                return edge.StartVertexId == edge.EndVertexId;
            });

            loopDescriptions.Add($"{loopId.Value}:coedges={coedges.Length}:uniqueEdges={uniqueEdges}:circleUses={circleUses}:seamUses={seamUses}");
        }

        return $"{DescribeRevolvedLoopTopology(body, aggregateCoedges, loopIds.Count)} loopFamilies=[{string.Join(", ", loopDescriptions)}]";
    }

    private static string ClassifyRevolvedTopologyFamily(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        IReadOnlyList<Coedge> lineCoedges,
        IReadOnlyList<Coedge> circleCoedges,
        IReadOnlyList<Coedge> bSplineCoedges)
    {
        var uniqueEdgeIds = coedges.Select(c => c.EdgeId).Distinct().ToArray();
        var seamUses = coedges.Count(c =>
        {
            var edge = body.Topology.GetEdge(c.EdgeId);
            return edge.StartVertexId == edge.EndVertexId;
        });

        var evidence = new LoopPatternEvidence(
            coedges.Count,
            uniqueEdgeIds.Length,
            lineCoedges.Count,
            circleCoedges.Count,
            bSplineCoedges.Count,
            seamUses);
        return new LoopPatternClassifier().Classify(evidence).Label;
    }

    private static DisplayFaceMeshPatch CreatePeriodicGridPatch(
        FaceId faceId,
        int angularSegments,
        int axialSegments,
        Func<double, double, Point3D> evaluate,
        Func<double, double, Vector3D> evaluateNormal,
        double vStart,
        double vEnd)
    {
        var positions = new List<Point3D>((angularSegments + 1) * (axialSegments + 1));
        var normals = new List<Vector3D>((angularSegments + 1) * (axialSegments + 1));
        var indices = new List<int>(angularSegments * axialSegments * 6);

        for (var v = 0; v <= axialSegments; v++)
        {
            var tv = (double)v / axialSegments;
            var vv = vStart + ((vEnd - vStart) * tv);

            for (var u = 0; u <= angularSegments; u++)
            {
                var tu = (double)u / angularSegments;
                var uu = tu * 2d * double.Pi;
                positions.Add(evaluate(uu, vv));
                normals.Add(evaluateNormal(uu, vv));
            }
        }

        var rowWidth = angularSegments + 1;
        for (var v = 0; v < axialSegments; v++)
        {
            for (var u = 0; u < angularSegments; u++)
            {
                var i0 = (v * rowWidth) + u;
                var i1 = i0 + 1;
                var i2 = i0 + rowWidth;
                var i3 = i2 + 1;

                indices.Add(i0);
                indices.Add(i2);
                indices.Add(i1);

                indices.Add(i1);
                indices.Add(i2);
                indices.Add(i3);
            }
        }

        return new DisplayFaceMeshPatch(faceId, positions, normals, indices);
    }

    private static DisplayFaceMeshPatch CreateBoundedGridPatch(
        FaceId faceId,
        int angularSegments,
        int axialSegments,
        Func<double, double, Point3D> evaluate,
        Func<double, double, Vector3D> evaluateNormal,
        double uStart,
        double uEnd,
        double vStart,
        double vEnd)
    {
        var positions = new List<Point3D>((angularSegments + 1) * (axialSegments + 1));
        var normals = new List<Vector3D>((angularSegments + 1) * (axialSegments + 1));
        var indices = new List<int>(angularSegments * axialSegments * 6);

        for (var v = 0; v <= axialSegments; v++)
        {
            var tv = (double)v / axialSegments;
            var vv = vStart + ((vEnd - vStart) * tv);

            for (var u = 0; u <= angularSegments; u++)
            {
                var tu = (double)u / angularSegments;
                var uu = uStart + ((uEnd - uStart) * tu);
                positions.Add(evaluate(uu, vv));
                normals.Add(evaluateNormal(uu, vv));
            }
        }

        var rowWidth = angularSegments + 1;
        for (var v = 0; v < axialSegments; v++)
        {
            for (var u = 0; u < angularSegments; u++)
            {
                var i0 = (v * rowWidth) + u;
                var i1 = i0 + 1;
                var i2 = i0 + rowWidth;
                var i3 = i2 + 1;

                indices.Add(i0);
                indices.Add(i2);
                indices.Add(i1);

                indices.Add(i1);
                indices.Add(i2);
                indices.Add(i3);
            }
        }

        return new DisplayFaceMeshPatch(faceId, positions, normals, indices);
    }

    private static KernelResult<(double UStart, double UEnd, double VStart, double VEnd)> TryResolveCylinderTrimPatch(
        BrepBody body,
        FaceId faceId,
        CylinderSurface cylinder)
    {
        const double minSpan = 1e-8d;
        const double nearFullWrapThreshold = 2d * double.Pi * 0.95d;
        const double bridgeSeamGapMin = 8d * (double.Pi / 180d);
        const double bridgeSeamGapMax = 12d * (double.Pi / 180d);
        var loopIds = body.GetLoopIds(faceId);
        if (loopIds.Count == 0)
        {
            return KernelResult<(double, double, double, double)>.Failure([
                CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
        }

        var axis = cylinder.Axis.ToVector();
        var xAxis = cylinder.XAxis.ToVector();
        var yAxis = cylinder.YAxis.ToVector();

        (double UStart, double USpan, double VStart, double VEnd, bool UsedAmbiguousShorterSpanResolution)? best = null;
        (LoopId LoopId, int CoedgeCount, double AngularStart, double AngularSpan, double AxialSpan, bool IsNearFullWrap, bool AngularResolved, bool IsSingleCoedgeClosed, double VStart, bool HasBridgeTwin, SurfaceGeometryKind? TwinSurfaceKind)? bestAxialSpanDegenerate = null;

        foreach (var loopId in loopIds)
        {
            var coedges = body.GetCoedgeIds(loopId).Select(id => body.Topology.GetCoedge(id)).ToArray();

            var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
            if (!vertexPointsResult.IsSuccess)
            {
                continue;
            }

            var allAngles = new List<double>();
            var allAxials = new List<double>();
            foreach (var coedge in coedges)
            {
                var endpoints = GetEdgeEndpoints(body, coedge.EdgeId, coedge.IsReversed, vertexPointsResult.Value);
                if (!endpoints.IsSuccess)
                {
                    allAngles.Clear();
                    break;
                }

                var start = endpoints.Value.Start;
                var end = endpoints.Value.End;
                allAngles.Add(CylinderAngleOf(cylinder, start, xAxis, yAxis, axis));
                allAngles.Add(CylinderAngleOf(cylinder, end, xAxis, yAxis, axis));
                allAxials.Add((start - cylinder.Origin).Dot(axis));
                allAxials.Add((end - cylinder.Origin).Dot(axis));

                var edgePolyline = TessellateEdge(body, coedge.EdgeId, DisplayTessellationOptions.Default);
                if (!edgePolyline.IsSuccess)
                {
                    continue;
                }

                var edgePoints = coedge.IsReversed
                    ? edgePolyline.Value.Points.Reverse().ToArray()
                    : edgePolyline.Value.Points;

                foreach (var point in edgePoints)
                {
                    allAngles.Add(CylinderAngleOf(cylinder, point, xAxis, yAxis, axis));
                    allAxials.Add((point - cylinder.Origin).Dot(axis));
                }
            }

            if (allAxials.Count == 0 || allAngles.Count == 0)
            {
                continue;
            }

            var vStart = allAxials.Min();
            var vEnd = allAxials.Max();
            var axialSpan = vEnd - vStart;
            var angularBounds = ResolveAngularBounds(allAngles);
            var angularSpan = (angularBounds.IsSuccess && angularBounds.Value.Span > minSpan) ? angularBounds.Value.Span : 0d;

            if (axialSpan <= minSpan)
            {
                var isSingleCoedgeClosed = false;
                var hasBridgeTwin = false;
                SurfaceGeometryKind? twinSurfaceKind = null;
                if (coedges.Length == 1 && body.TryGetEdgeVertices(coedges[0].EdgeId, out var edgeStart, out var edgeEnd))
                {
                    isSingleCoedgeClosed = edgeStart == edgeEnd;
                    hasBridgeTwin = TryResolveBridgeTwinSurfaceKind(body, faceId, coedges[0].EdgeId, out twinSurfaceKind);
                }

                var degenerateCandidate = (
                    LoopId: loopId,
                    CoedgeCount: coedges.Length,
                    AngularStart: angularBounds.IsSuccess ? angularBounds.Value.Start : 0d,
                    AngularSpan: angularSpan,
                    AxialSpan: axialSpan,
                    IsNearFullWrap: angularBounds.IsSuccess && angularBounds.Value.Span >= nearFullWrapThreshold,
                    AngularResolved: angularBounds.IsSuccess && angularBounds.Value.Span > minSpan,
                    IsSingleCoedgeClosed: isSingleCoedgeClosed,
                    VStart: vStart,
                    HasBridgeTwin: hasBridgeTwin,
                    TwinSurfaceKind: twinSurfaceKind);
                if (!bestAxialSpanDegenerate.HasValue ||
                    degenerateCandidate.AngularSpan > bestAxialSpanDegenerate.Value.AngularSpan ||
                    (System.Math.Abs(degenerateCandidate.AngularSpan - bestAxialSpanDegenerate.Value.AngularSpan) <= minSpan &&
                        degenerateCandidate.CoedgeCount > bestAxialSpanDegenerate.Value.CoedgeCount))
                {
                    bestAxialSpanDegenerate = degenerateCandidate;
                }

                continue;
            }

            if (!angularBounds.IsSuccess || angularBounds.Value.Span <= minSpan)
            {
                continue;
            }

            var candidate = (UStart: angularBounds.Value.Start, USpan: angularBounds.Value.Span, VStart: vStart, VEnd: vEnd, angularBounds.Value.UsedAmbiguousShorterSpanResolution);
            var candidateScore = candidate.USpan * (candidate.VEnd - candidate.VStart);
            var bestScore = best.HasValue ? best.Value.USpan * (best.Value.VEnd - best.Value.VStart) : double.NegativeInfinity;
            if (!best.HasValue || candidateScore > bestScore)
            {
                best = candidate;
            }
        }

        if (!best.HasValue)
        {
            var dualCirclePatch = TryResolveDualSingleCoedgeClosedCircleCylinderTrimPatch(body, faceId, cylinder, loopIds, axis, minSpan);
            if (dualCirclePatch.IsSuccess)
            {
                return dualCirclePatch;
            }

            if (bestAxialSpanDegenerate.HasValue && loopIds.Count == 1)
            {
                var isSingleCoedge = bestAxialSpanDegenerate.Value.CoedgeCount == 1;
                var seamGap = (2d * double.Pi) - bestAxialSpanDegenerate.Value.AngularSpan;
                var isBridgeFamily =
                    isSingleCoedge
                    && bestAxialSpanDegenerate.Value.IsNearFullWrap
                    && bestAxialSpanDegenerate.Value.AngularResolved
                    && bestAxialSpanDegenerate.Value.AxialSpan <= minSpan
                    && bestAxialSpanDegenerate.Value.IsSingleCoedgeClosed
                    && seamGap >= bridgeSeamGapMin
                    && seamGap <= bridgeSeamGapMax
                    && bestAxialSpanDegenerate.Value.HasBridgeTwin
                    && bestAxialSpanDegenerate.Value.TwinSurfaceKind is SurfaceGeometryKind.Plane or SurfaceGeometryKind.Cone or SurfaceGeometryKind.Torus;

                if (isBridgeFamily)
                {
                    return KernelResult<(double, double, double, double)>.Success(
                        (
                            bestAxialSpanDegenerate.Value.AngularStart,
                            bestAxialSpanDegenerate.Value.AngularStart + bestAxialSpanDegenerate.Value.AngularSpan,
                            bestAxialSpanDegenerate.Value.VStart,
                            bestAxialSpanDegenerate.Value.VStart),
                        [CreateValidationWarning(
                            $"Face {faceId.Value} cylindrical trim treated as zero-width bridge limit (loop {bestAxialSpanDegenerate.Value.LoopId.Value}, seam gap {seamGap * (180d / double.Pi):F3} deg, twin {bestAxialSpanDegenerate.Value.TwinSurfaceKind}).",
                            CylinderTrimAxialSpanDegenerateSingleCoedgeNearFullWrapBridgeSource)]);
                }

                var classification = bestAxialSpanDegenerate.Value.IsNearFullWrap
                    ? isSingleCoedge
                        ? bestAxialSpanDegenerate.Value.IsSingleCoedgeClosed
                            ? "single-coedge closed ring-like near-full-wrap boundary with collapsed axial span"
                            : "single-coedge near-full-wrap boundary with collapsed axial span"
                        : "multi-coedge ring-like near-full-wrap boundary with collapsed axial span"
                    : bestAxialSpanDegenerate.Value.AngularResolved
                        ? isSingleCoedge
                            ? "single-coedge trimmed cylindrical loop with collapsed axial span"
                            : "multi-coedge trimmed cylindrical loop with collapsed axial span"
                        : "axial-span-collapsed loop without resolvable angular extent";

                var diagnosticSource = bestAxialSpanDegenerate.Value.IsNearFullWrap
                    ? isSingleCoedge
                        ? CylinderTrimAxialSpanDegenerateSingleCoedgeNearFullWrapSource
                        : CylinderTrimAxialSpanDegenerateMultiCoedgeSource
                    : isSingleCoedge
                        ? CylinderTrimAxialSpanDegenerateSingleCoedgeSource
                        : CylinderTrimAxialSpanDegenerateMultiCoedgeSource;
                return KernelResult<(double, double, double, double)>.Failure([
                    CreateInvalidArgument(
                        $"Face {faceId.Value} cylindrical trim loop {bestAxialSpanDegenerate.Value.LoopId.Value} has {bestAxialSpanDegenerate.Value.CoedgeCount} coedges, angular span {bestAxialSpanDegenerate.Value.AngularSpan:R}, axial span {bestAxialSpanDegenerate.Value.AxialSpan:R}, loop count {loopIds.Count}; classified as {classification} and treated as degenerate.",
                        diagnosticSource)]);
            }

            return KernelResult<(double, double, double, double)>.Failure([
                CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
        }

        var diagnostics = new List<KernelDiagnostic>();
        if (best.Value.UsedAmbiguousShorterSpanResolution)
        {
            diagnostics.Add(CreateValidationWarning(
                "Cylindrical face tessellation resolved ambiguous trim by choosing the shorter angular span.",
                CylinderTrimAmbiguousUsedShorterSpanSource));
        }

        return KernelResult<(double, double, double, double)>.Success(
            (best.Value.UStart, best.Value.UStart + best.Value.USpan, best.Value.VStart, best.Value.VEnd),
            diagnostics);
    }

    private static KernelResult<(double UStart, double UEnd, double VStart, double VEnd)> TryResolveDualSingleCoedgeClosedCircleCylinderTrimPatch(
        BrepBody body,
        FaceId faceId,
        CylinderSurface cylinder,
        IReadOnlyList<LoopId> loopIds,
        Vector3D axis,
        double minSpan)
    {
        const double fullWrapTolerance = 1e-3d;
        const double axisAlignmentTolerance = 1e-4d;
        const double centerAxisOffsetTolerance = 1e-4d;
        const double radiusTolerance = 1e-4d;

        if (loopIds.Count != 2)
        {
            return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
        }

        var loops = new List<(LoopId LoopId, EdgeId EdgeId, double AxialCenter)>();
        foreach (var loopId in loopIds)
        {
            var coedgeIds = body.GetCoedgeIds(loopId);
            if (coedgeIds.Count != 1)
            {
                return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
            }

            var coedge = body.Topology.GetCoedge(coedgeIds[0]);
            var curve = body.GetEdgeCurve(coedge.EdgeId);
            if (curve.Kind != CurveGeometryKind.Circle3)
            {
                return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
            }

            if (!body.TryGetEdgeVertices(coedge.EdgeId, out var startVertexId, out var endVertexId) || startVertexId != endVertexId)
            {
                return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
            }

            if (!body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var edgeBinding)
                || edgeBinding.TrimInterval is not ParameterInterval trimInterval
                || !double.IsFinite(trimInterval.Start)
                || !double.IsFinite(trimInterval.End)
                || double.Abs((trimInterval.End - trimInterval.Start) - (2d * double.Pi)) > fullWrapTolerance)
            {
                return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
            }

            var circle = curve.Circle3!.Value;
            var axisDot = circle.Normal.ToVector().Dot(cylinder.Axis.ToVector());
            if (double.Abs(double.Abs(axisDot) - 1d) > axisAlignmentTolerance)
            {
                return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
            }

            var centerOffset = circle.Center - cylinder.Origin;
            var axialCenter = centerOffset.Dot(axis);
            var radialOffset = (centerOffset - (axis * axialCenter)).Length;
            if (radialOffset > (cylinder.Radius * centerAxisOffsetTolerance))
            {
                return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
            }

            if (double.Abs(circle.Radius - cylinder.Radius) > (cylinder.Radius * radiusTolerance))
            {
                return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
            }

            loops.Add((loopId, coedge.EdgeId, axialCenter));
        }

        var first = loops[0];
        var second = loops[1];
        var vStart = System.Math.Min(first.AxialCenter, second.AxialCenter);
        var vEnd = System.Math.Max(first.AxialCenter, second.AxialCenter);
        var axialSpan = vEnd - vStart;
        if (axialSpan <= minSpan)
        {
            return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
        }

        return KernelResult<(double, double, double, double)>.Success(
            (0d, 2d * double.Pi, vStart, vEnd),
            [CreateValidationWarning(
                $"Face {faceId.Value} cylindrical trim classified as dual single-coedge closed-circle loops with zero per-loop axial span and center axial separation {axialSpan:R} (loops {first.LoopId.Value}/{second.LoopId.Value}, edges {first.EdgeId.Value}/{second.EdgeId.Value}).",
                CylinderTrimDualSingleCoedgeClosedCircleSource)]);
    }

    private static bool TryResolveBridgeTwinSurfaceKind(BrepBody body, FaceId sourceFaceId, EdgeId edgeId, out SurfaceGeometryKind? twinSurfaceKind)
    {
        twinSurfaceKind = null;
        var uses = new HashSet<FaceId>();

        foreach (var face in body.Topology.Faces)
        {
            foreach (var loopId in face.LoopIds)
            {
                var coedgeIds = body.GetCoedgeIds(loopId);
                foreach (var coedgeId in coedgeIds)
                {
                    var coedge = body.Topology.GetCoedge(coedgeId);
                    if (coedge.EdgeId == edgeId)
                    {
                        uses.Add(face.Id);
                        break;
                    }
                }
            }
        }

        if (uses.Count != 2)
        {
            return false;
        }

        var useArray = uses.ToArray();
        var twinFaceId = useArray[0] == sourceFaceId ? useArray[1] : useArray[0];
        if (twinFaceId == sourceFaceId)
        {
            return false;
        }

        if (!body.TryGetFaceSurfaceGeometry(twinFaceId, out var twinSurface) || twinSurface is null)
        {
            return false;
        }

        twinSurfaceKind = twinSurface.Kind;
        return true;
    }

    private static double CylinderAngleOf(CylinderSurface cylinder, Point3D point, Vector3D xAxis, Vector3D yAxis, Vector3D axis)
    {
        var offset = point - cylinder.Origin;
        var axial = axis * offset.Dot(axis);
        var radial = offset - axial;
        return NormalizeToZeroTwoPi(double.Atan2(radial.Dot(yAxis), radial.Dot(xAxis)));
    }

    private static KernelResult<(double Start, double Span, bool UsedAmbiguousShorterSpanResolution)> ResolveAngularBounds(IReadOnlyList<double> rawAngles)
    {
        const double epsilon = 1e-8d;

        var angles = rawAngles
            .Select(NormalizeToZeroTwoPi)
            .OrderBy(a => a)
            .ToArray();

        if (angles.Length == 0)
        {
            return KernelResult<(double, double, bool)>.Failure([CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
        }

        var largestGap = -1d;
        var largestGapIndex = -1;
        for (var i = 0; i < angles.Length; i++)
        {
            var current = angles[i];
            var next = i == angles.Length - 1 ? angles[0] + (2d * double.Pi) : angles[i + 1];
            var gap = next - current;
            if (gap > largestGap + epsilon)
            {
                largestGap = gap;
                largestGapIndex = i;
            }
        }

        if (largestGapIndex < 0)
        {
            return KernelResult<(double, double, bool)>.Failure([CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
        }

        var usedAmbiguous = largestGap <= epsilon;
        var start = angles[(largestGapIndex + 1) % angles.Length];
        var span = (2d * double.Pi) - largestGap;
        return KernelResult<(double, double, bool)>.Success((start, span, usedAmbiguous));
    }

    private static DisplayFaceMeshPatch CreatePlanarPatch(FaceId faceId, IReadOnlyList<Point3D> polygonPoints, Vector3D normal, IReadOnlyList<int> triangleIndices)
    {
        var normals = Enumerable.Repeat(normal, polygonPoints.Count).ToArray();
        return new DisplayFaceMeshPatch(faceId, polygonPoints.ToArray(), normals, triangleIndices.ToArray());
    }

    private static DisplayFaceMeshPatch CreateEmptyPlanarPatch(FaceId faceId)
        => new(faceId, Array.Empty<Point3D>(), Array.Empty<Vector3D>(), Array.Empty<int>());

    private static KernelResult<IReadOnlyList<Point3D>> BuildFlattenedPlanarLoopPoints(
        BrepBody body,
        IReadOnlyList<Coedge> coedges,
        FaceId faceId,
        PlaneSurface plane,
        DisplayTessellationOptions options)
    {
        var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
        if (!vertexPointsResult.IsSuccess)
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure(vertexPointsResult.Diagnostics);
        }

        var vertexPoints = vertexPointsResult.Value;
        var orientedEndpoints = new List<(Point3D Start, Point3D End)>(coedges.Count);
        foreach (var coedge in coedges)
        {
            var endpoints = GetEdgeEndpoints(body, coedge.EdgeId, coedge.IsReversed, vertexPoints);
            if (!endpoints.IsSuccess)
            {
                return KernelResult<IReadOnlyList<Point3D>>.Failure(endpoints.Diagnostics);
            }

            orientedEndpoints.Add(endpoints.Value);
        }

        var orderedIndices = new List<int>(coedges.Count) { 0 };
        var chainedEndpoints = new List<(Point3D Start, Point3D End)>(coedges.Count) { orientedEndpoints[0] };
        var traversalSwapped = new List<bool>(coedges.Count) { false };
        var used = new bool[coedges.Count];
        used[0] = true;
        var currentEnd = orientedEndpoints[0].End;

        for (var step = 1; step < coedges.Count; step++)
        {
            var nextIndex = FindNextCoedgeIndex(orientedEndpoints, used, currentEnd, out var nextStart, out var nextEnd, out var swapped);
            if (nextIndex < 0)
            {
                return KernelResult<IReadOnlyList<Point3D>>.Failure([CreateInvalidArgument($"Face {faceId.Value} planar loop coedges do not form a contiguous chain.", PlanarCurveFlatteningFailedSource)]);
            }

            used[nextIndex] = true;
            orderedIndices.Add(nextIndex);
            chainedEndpoints.Add((nextStart, nextEnd));
            traversalSwapped.Add(swapped);
            currentEnd = nextEnd;
        }

        if (!PointsAlmostEqual(chainedEndpoints[0].Start, currentEnd))
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure([CreateInvalidArgument($"Face {faceId.Value} planar loop coedges did not close after chaining.", PlanarCurveFlatteningFailedSource)]);
        }

        var flattened = new List<Point3D>();
        AppendUniquePoint(flattened, chainedEndpoints[0].Start);

        for (var chainIndex = 0; chainIndex < orderedIndices.Count; chainIndex++)
        {
            var index = orderedIndices[chainIndex];
            var coedge = coedges[index];
            var (segmentStart, segmentEnd) = chainedEndpoints[chainIndex];
            var isTraversalSwapped = traversalSwapped[chainIndex];
            var curve = body.GetEdgeCurve(coedge.EdgeId);

            switch (curve.Kind)
            {
                case CurveGeometryKind.Line3:
                    AppendUniquePoint(flattened, segmentEnd);
                    break;
                case CurveGeometryKind.Circle3:
                    var arcPointsResult = SampleCircleArc(body, coedge, isTraversalSwapped, curve.Circle3!.Value, segmentStart, segmentEnd, plane, faceId, options);
                    if (!arcPointsResult.IsSuccess)
                    {
                        return KernelResult<IReadOnlyList<Point3D>>.Failure(arcPointsResult.Diagnostics);
                    }

                    foreach (var point in arcPointsResult.Value)
                    {
                        AppendUniquePoint(flattened, point);
                    }

                    break;
                case CurveGeometryKind.BSpline3:
                    var splinePointsResult = SamplePlanarBSpline(body, coedge, isTraversalSwapped, curve.BSpline3!.Value, segmentStart, segmentEnd);
                    if (!splinePointsResult.IsSuccess)
                    {
                        return KernelResult<IReadOnlyList<Point3D>>.Failure(splinePointsResult.Diagnostics);
                    }

                    foreach (var point in splinePointsResult.Value)
                    {
                        AppendUniquePoint(flattened, point);
                    }

                    break;
                case CurveGeometryKind.Ellipse3:
                    var ellipsePointsResult = SamplePlanarEllipse(body, coedge, isTraversalSwapped, curve.Ellipse3!.Value, segmentStart, segmentEnd, plane, faceId, options);
                    if (!ellipsePointsResult.IsSuccess)
                    {
                        return KernelResult<IReadOnlyList<Point3D>>.Failure(ellipsePointsResult.Diagnostics);
                    }

                    foreach (var point in ellipsePointsResult.Value)
                    {
                        AppendUniquePoint(flattened, point);
                    }

                    break;
                case CurveGeometryKind.Hyperbola3:
                    var hyperbolaPointsResult = SamplePlanarHyperbola(body, coedge, isTraversalSwapped, curve.Hyperbola3!.Value, segmentStart, segmentEnd, plane, faceId, options);
                    if (!hyperbolaPointsResult.IsSuccess)
                    {
                        return KernelResult<IReadOnlyList<Point3D>>.Failure(hyperbolaPointsResult.Diagnostics);
                    }

                    foreach (var point in hyperbolaPointsResult.Value)
                    {
                        AppendUniquePoint(flattened, point);
                    }

                    break;
                default:
                    var curveKind = curve.UnsupportedKind ?? curve.Kind.ToString();
                    return KernelResult<IReadOnlyList<Point3D>>.Failure([
                        CreateNotImplemented($"Face {faceId.Value} planar curve flattening does not support curve kind '{curveKind}'.", PlanarCurveFlatteningUnsupportedSource)]);
            }
        }

        if (flattened.Count > 1 && PointsAlmostEqual(flattened[0], flattened[^1]))
        {
            flattened.RemoveAt(flattened.Count - 1);
        }

        return KernelResult<IReadOnlyList<Point3D>>.Success(flattened);
    }

    private static KernelResult<IReadOnlyList<Point3D>> SampleCircleArc(
        BrepBody body,
        Coedge coedge,
        bool traversalSwapped,
        Circle3Curve circle,
        Point3D start,
        Point3D end,
        PlaneSurface plane,
        FaceId faceId,
        DisplayTessellationOptions options)
    {
        var effectiveIsReversed = coedge.IsReversed ^ traversalSwapped;
        if (body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var binding)
            && CurveSampler.TrySampleTrimmedCircleArc(
                circle,
                start,
                end,
                effectiveIsReversed ? !binding.OrientedEdgeSense : binding.OrientedEdgeSense,
                out var sampledPoints,
                out var isClosed,
                out var usedShorterArcFallback,
                options))
        {
            var points = new List<Point3D>(sampledPoints.Count - 1);
            for (var i = 1; i < sampledPoints.Count; i++)
            {
                points.Add(sampledPoints[i]);
            }

            if (!isClosed)
            {
                points[^1] = end;
            }

            if (usedShorterArcFallback)
            {
                return KernelResult<IReadOnlyList<Point3D>>.Success(
                    points,
                    [CreateValidationWarning($"Face {faceId.Value} edge {coedge.EdgeId.Value} circular planar trim was ambiguous; using shorter arc.", CircleTrimAmbiguousUsedShorterArcSource)]);
            }

            return KernelResult<IReadOnlyList<Point3D>>.Success(points);
        }

        var deltaResult = ResolveArcDelta(body, coedge, traversalSwapped, circle, start, end, plane, faceId);
        if (!deltaResult.IsSuccess)
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure(deltaResult.Diagnostics);
        }

        var (startAngle, delta) = deltaResult.Value;
        var samples = CurveSampler.SampleCircleArc(circle, startAngle, delta, options);
        var pointsFallback = new List<Point3D>(samples.Count - 1);
        for (var i = 1; i < samples.Count; i++)
        {
            pointsFallback.Add(samples[i]);
        }

        return KernelResult<IReadOnlyList<Point3D>>.Success(pointsFallback);
    }

    /// <summary>
    /// Cuts an open sampled polyline at the points nearest to <paramref name="start"/> and <paramref name="end"/>,
    /// returning the portion between them in start-to-end order, or null when that is ambiguous or degenerate.
    /// </summary>
    private static Point3D[]? TrimPolylineBetween(Point3D[] samples, Point3D start, Point3D end)
    {
        if (samples.Length < 2)
        {
            return null;
        }

        static (int Segment, double T, double Distance) Locate(Point3D[] points, Point3D target)
        {
            var best = (Segment: 0, T: 0d, Distance: double.PositiveInfinity);
            for (var i = 0; i + 1 < points.Length; i++)
            {
                var edge = points[i + 1] - points[i];
                var lengthSquared = edge.Dot(edge);
                var t = lengthSquared <= 0d ? 0d : double.Clamp((target - points[i]).Dot(edge) / lengthSquared, 0d, 1d);
                var closest = points[i] + (edge * t);
                var distance = (target - closest).Length;
                if (distance < best.Distance)
                {
                    best = (i, t, distance);
                }
            }

            return best;
        }

        var startLocation = Locate(samples, start);
        var endLocation = Locate(samples, end);
        const double locateTolerance = 5e-2d;
        if (startLocation.Distance > locateTolerance || endLocation.Distance > locateTolerance)
        {
            return null;
        }

        var startPosition = startLocation.Segment + startLocation.T;
        var endPosition = endLocation.Segment + endLocation.T;
        if (double.Abs(endPosition - startPosition) < 1e-9d)
        {
            return null;
        }

        var forward = startPosition < endPosition;
        var lowPosition = forward ? startPosition : endPosition;
        var highPosition = forward ? endPosition : startPosition;
        var slice = new List<Point3D>();
        var firstWhole = (int)double.Floor(lowPosition) + 1;
        var lastWhole = (int)double.Ceiling(highPosition) - 1;
        for (var i = firstWhole; i <= lastWhole && i < samples.Length; i++)
        {
            slice.Add(samples[i]);
        }

        slice.Insert(0, start);
        slice.Add(end);
        if (!forward)
        {
            // slice is currently [start, interior (ascending), end]; interior must run from start toward end.
            var interior = slice.Skip(1).Take(slice.Count - 2).Reverse().ToList();
            slice = [start, .. interior, end];
        }

        return slice.Count >= 2 ? slice.ToArray() : null;
    }

    private static KernelResult<IReadOnlyList<Point3D>> SamplePlanarBSpline(
        BrepBody body,
        Coedge coedge,
        bool traversalSwapped,
        BSpline3Curve spline,
        Point3D start,
        Point3D end)
    {
        var interval = new ParameterInterval(spline.DomainStart, spline.DomainEnd);
        var reverseSampleOrder = false;
        var effectiveIsReversed = coedge.IsReversed ^ traversalSwapped;
        if (body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var binding) && binding.TrimInterval is ParameterInterval trim)
        {
            interval = trim;
            reverseSampleOrder = effectiveIsReversed ^ !binding.OrientedEdgeSense;
        }
        else
        {
            reverseSampleOrder = effectiveIsReversed;
        }

        var sampled = CurveSampler.SampleBSpline(spline, interval).ToArray();
        if (reverseSampleOrder)
        {
            Array.Reverse(sampled);
        }

        if (sampled.Length < 2)
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure([
                CreateInvalidArgument($"Edge {coedge.EdgeId.Value} planar BSpline flattening produced an invalid sample set.", PlanarCurveFlatteningFailedSource)]);
        }

        // Orientation flags (coedge sense, edge sense, chain swap) can disagree with the curve's own parameter
        // direction. The snap below would then pin the wrong ends and leave a spike that self-intersects the loop,
        // so let the geometry have the last word for open curves.
        var forwardMisfit = (sampled[0] - start).Length + (sampled[^1] - end).Length;
        var reversedMisfit = (sampled[^1] - start).Length + (sampled[0] - end).Length;
        if (reversedMisfit + 1e-9d < forwardMisfit)
        {
            Array.Reverse(sampled);
        }

        if (System.Math.Min(forwardMisfit, reversedMisfit) > 1e-3d
            && TrimPolylineBetween(sampled, start, end) is { } trimmed)
        {
            // The edge only covers part of its B-spline curve and no trim interval was recorded, so sampling the
            // whole domain and snapping the ends would spike across the loop. Cut the polyline at the vertices.
            sampled = trimmed;
        }

        sampled[0] = start;
        sampled[^1] = end;

        var points = new List<Point3D>(sampled.Length - 1);
        for (var i = 1; i < sampled.Length; i++)
        {
            points.Add(sampled[i]);
        }

        return KernelResult<IReadOnlyList<Point3D>>.Success(points);
    }

    private static KernelResult<IReadOnlyList<Point3D>> SamplePlanarEllipse(
        BrepBody body,
        Coedge coedge,
        bool traversalSwapped,
        Ellipse3Curve ellipse,
        Point3D start,
        Point3D end,
        PlaneSurface plane,
        FaceId faceId,
        DisplayTessellationOptions options)
    {
        const double planeContainmentTolerance = 1e-7d;
        var normalAlignment = double.Abs(ellipse.Normal.ToVector().Dot(plane.Normal.ToVector()));
        var centerOffset = double.Abs((ellipse.Center - plane.Origin).Dot(plane.Normal.ToVector()));

        if (normalAlignment < 1d - 1e-7d || centerOffset > planeContainmentTolerance)
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure([
                CreateNotImplemented($"Face {faceId.Value} edge {coedge.EdgeId.Value} planar ellipse flattening requires the ellipse plane to match the face plane.", PlanarCurveFlatteningUnsupportedSource)]);
        }

        var trimResult = ResolvePlanarEllipseTrim(body, coedge, traversalSwapped, ellipse, start, end, plane, faceId);
        if (!trimResult.IsSuccess)
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure(trimResult.Diagnostics);
        }

        var (trimStart, trimDelta) = trimResult.Value;
        var segmentCount = ComputeEllipseSegmentCount(ellipse, trimStart, trimStart + trimDelta, options);
        var sampled = Enumerable.Range(0, segmentCount + 1)
            .Select(i => ellipse.Evaluate(trimStart + trimDelta * i / segmentCount)).ToArray();
        sampled[0] = start;
        sampled[^1] = end;

        var points = new List<Point3D>(sampled.Length - 1);
        for (var i = 1; i < sampled.Length; i++)
        {
            points.Add(sampled[i]);
        }

        return KernelResult<IReadOnlyList<Point3D>>.Success(points);
    }

    // A start parameter and a signed sweep, as for planar circles: a coedge used against its edge
    // walks the trim backwards, which an increasing ParameterInterval cannot express.
    private static KernelResult<(double Start, double Delta)> ResolvePlanarEllipseTrim(
        BrepBody body,
        Coedge coedge,
        bool traversalSwapped,
        Ellipse3Curve ellipse,
        Point3D start,
        Point3D end,
        PlaneSurface plane,
        FaceId faceId)
    {
        if (body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var binding) && binding.TrimInterval is ParameterInterval trim)
        {
            var effectiveIsReversed = coedge.IsReversed ^ traversalSwapped ^ !binding.OrientedEdgeSense;
            var trimStart = effectiveIsReversed ? trim.End : trim.Start;
            var trimDelta = (effectiveIsReversed ? trim.Start : trim.End) - trimStart;
            if (double.IsFinite(trimDelta) && double.Abs(trimDelta) > 1e-9d)
                return KernelResult<(double, double)>.Success((trimStart, trimDelta));
        }

        var startAngle = AngleOnEllipse(ellipse, start);
        var endAngle = AngleOnEllipse(ellipse, end);
        var delta = NormalizeToSignedPi(endAngle - startAngle);
        if (double.Abs(delta) < 1e-9d)
        {
            return KernelResult<(double, double)>.Failure([
                CreateInvalidArgument($"Face {faceId.Value} planar ellipse flattening detected a degenerate ellipse trim.", PlanarCurveFlatteningFailedSource)]);
        }

        var orientation = ellipse.Normal.ToVector().Dot(plane.Normal.ToVector());
        if (orientation < 0d)
        {
            delta = -delta;
        }

        return KernelResult<(double, double)>.Success((startAngle, delta));
    }

    private static KernelResult<(double StartAngle, double Delta)> ResolveArcDelta(
        BrepBody body,
        Coedge coedge,
        bool traversalSwapped,
        Circle3Curve circle,
        Point3D start,
        Point3D end,
        PlaneSurface plane,
        FaceId faceId)
    {
        var startAngle = AngleOnCircle(circle, start);
        var endAngle = AngleOnCircle(circle, end);

        if (body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var binding) && binding.TrimInterval is ParameterInterval trim)
        {
            var effectiveIsReversed = coedge.IsReversed ^ traversalSwapped ^ !binding.OrientedEdgeSense;
            var trimStart = effectiveIsReversed ? trim.End : trim.Start;
            var trimEnd = effectiveIsReversed ? trim.Start : trim.End;
            var trimDelta = trimEnd - trimStart;
            if (double.IsFinite(trimDelta) && double.Abs(trimDelta) > 1e-9d)
            {
                return KernelResult<(double, double)>.Success((trimStart, trimDelta));
            }
        }

        var delta = NormalizeToSignedPi(endAngle - startAngle);
        if (double.Abs(delta) < 1e-9d)
        {
            return KernelResult<(double, double)>.Failure([
                CreateInvalidArgument($"Face {faceId.Value} planar arc flattening detected a degenerate circle arc.", PlanarCurveFlatteningFailedSource)]);
        }

        var orientation = circle.Normal.ToVector().Dot(plane.Normal.ToVector());
        if (orientation < 0d)
        {
            delta = -delta;
        }

        return KernelResult<(double, double)>.Success((startAngle, delta));
    }

    private static double AngleOnCircle(Circle3Curve circle, Point3D point)
    {
        var offset = point - circle.Center;
        var x = offset.Dot(circle.XAxis.ToVector());
        var y = offset.Dot(circle.YAxis.ToVector());
        return double.Atan2(y, x);
    }

    private static double AngleOnEllipse(Ellipse3Curve ellipse, Point3D point)
    {
        var offset = point - ellipse.Center;
        var x = offset.Dot(ellipse.XAxis.ToVector()) / ellipse.MajorRadius;
        var y = offset.Dot(ellipse.YAxis.ToVector()) / ellipse.MinorRadius;
        return double.Atan2(y, x);
    }

    private static double NormalizeToSignedPi(double angle)
    {
        while (angle <= -double.Pi)
        {
            angle += 2d * double.Pi;
        }

        while (angle > double.Pi)
        {
            angle -= 2d * double.Pi;
        }

        return angle;
    }


    private static double TorusMinorAngleOf(TorusSurface torus, Point3D point)
    {
        var offset = point - torus.Center;
        var x = offset.Dot(torus.XAxis.ToVector());
        var y = offset.Dot(torus.YAxis.ToVector());
        var u = NormalizeToZeroTwoPi(double.Atan2(y, x));

        var majorDirection = (torus.XAxis.ToVector() * double.Cos(u)) + (torus.YAxis.ToVector() * double.Sin(u));
        var radialFromMajorCircle = offset.Dot(majorDirection) - torus.MajorRadius;
        var axial = offset.Dot(torus.Axis.ToVector());
        return NormalizeToZeroTwoPi(double.Atan2(axial, radialFromMajorCircle));
    }

    private static double NormalizeToZeroTwoPi(double angle)
    {
        var twoPi = 2d * double.Pi;
        var normalized = angle % twoPi;
        if (normalized < 0d)
        {
            normalized += twoPi;
        }

        return normalized;
    }

    private static int FindNextCoedgeIndex(
        IReadOnlyList<(Point3D Start, Point3D End)> endpoints,
        IReadOnlyList<bool> used,
        Point3D currentEnd,
        out Point3D nextStart,
        out Point3D nextEnd,
        out bool swapped)
    {
        var matchIndex = -1;
        nextStart = default;
        nextEnd = default;
        swapped = false;

        for (var i = 0; i < endpoints.Count; i++)
        {
            if (used[i])
            {
                continue;
            }

            var (start, end) = endpoints[i];
            if (PointsAlmostEqual(start, currentEnd))
            {
                matchIndex = i;
                nextStart = start;
                nextEnd = end;
                swapped = false;
                break;
            }

            if (PointsAlmostEqual(end, currentEnd))
            {
                matchIndex = i;
                nextStart = end;
                nextEnd = start;
                swapped = true;
                break;
            }
        }

        return matchIndex;
    }

    private static void AppendUniquePoint(List<Point3D> points, Point3D point)
    {
        if (points.Count == 0)
        {
            points.Add(point);
            return;
        }

        if (!PointsAlmostEqual(points[^1], point))
        {
            points.Add(point);
        }
    }

    private static bool PointsAlmostEqual(Point3D left, Point3D right)
        => (left - right).LengthSquared <= (LoopEndpointTolerance * LoopEndpointTolerance);

    private static KernelResult<DisplayEdgePolyline> TessellateEdge(BrepBody body, EdgeId edgeId, DisplayTessellationOptions options)
    {
        if (!body.TryGetEdgeCurveGeometry(edgeId, out var curve) || curve is null)
        {
            return KernelResult<DisplayEdgePolyline>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing bound curve geometry.")]);
        }

        if (!body.Bindings.TryGetEdgeBinding(edgeId, out var binding))
        {
            return KernelResult<DisplayEdgePolyline>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing curve binding.")]);
        }

        var interval = binding.TrimInterval ?? new ParameterInterval(0d, 1d);

        switch (curve.Kind)
        {
            case CurveGeometryKind.Line3:
                var line = curve.Line3!.Value;
                return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(
                    edgeId,
                    CurveSampler.SampleLine(line, interval),
                    IsClosed: false));

            case CurveGeometryKind.Circle3:
                var circle = curve.Circle3!.Value;
                var startPointResult = EvaluateEdgeEndpoint(body, edgeId, useStart: true);
                if (!startPointResult.IsSuccess)
                {
                    return KernelResult<DisplayEdgePolyline>.Failure(startPointResult.Diagnostics);
                }

                var endPointResult = EvaluateEdgeEndpoint(body, edgeId, useStart: false);
                if (!endPointResult.IsSuccess)
                {
                    return KernelResult<DisplayEdgePolyline>.Failure(endPointResult.Diagnostics);
                }

                if (!CurveSampler.TrySampleTrimmedCircleArc(
                        circle,
                        startPointResult.Value,
                        endPointResult.Value,
                        binding.OrientedEdgeSense,
                        out var points,
                        out var isClosed,
                        out var usedShorterArcFallback))
                {
                    return KernelResult<DisplayEdgePolyline>.Failure([
                        CreateInvalidArgument($"Edge {edgeId.Value} failed to resolve circle trim from edge endpoints.", CircleTrimResolveFailedSource)]);
                }

                if (usedShorterArcFallback)
                {
                    return KernelResult<DisplayEdgePolyline>.Success(
                        new DisplayEdgePolyline(edgeId, points, isClosed),
                        [CreateValidationWarning($"Edge {edgeId.Value} circular trim was ambiguous; using shorter arc.", CircleTrimAmbiguousUsedShorterArcSource)]);
                }

                return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(edgeId, points, isClosed));

            case CurveGeometryKind.BSpline3:
                var spline = curve.BSpline3!.Value;
                return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(
                    edgeId,
                    CurveSampler.SampleBSpline(spline, interval),
                    IsClosed: false));

            case CurveGeometryKind.Ellipse3:
                var ellipse = curve.Ellipse3!.Value;
                var segments = ComputeEllipseSegmentCount(ellipse, interval.Start, interval.End, options);
                return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(
                    edgeId,
                    SampleEllipseCurve(ellipse, interval, segments),
                    IsClosed: false));

            case CurveGeometryKind.Hyperbola3:
                var hyperbola = curve.Hyperbola3!.Value;
                return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(
                    edgeId,
                    SampleHyperbolaCurve(hyperbola, interval, options),
                    IsClosed: false));

            default:
                return KernelResult<DisplayEdgePolyline>.Failure([CreateNotImplemented($"Edge {edgeId.Value} has unsupported curve kind '{curve.Kind}'.")]);
        }
    }

    private static KernelResult<Dictionary<VertexId, Point3D>> BuildLoopVertexPointLookup(BrepBody body, IReadOnlyList<Coedge> coedges, FaceId faceId)
    {
        var requiredVertexIds = new HashSet<VertexId>();
        foreach (var coedge in coedges)
        {
            if (!body.TryGetEdgeVertices(coedge.EdgeId, out var startVertexId, out var endVertexId))
            {
                return KernelResult<Dictionary<VertexId, Point3D>>.Failure([CreateNotImplemented($"Face {faceId.Value} references missing edge topology for edge {coedge.EdgeId.Value}.")]);
            }

            requiredVertexIds.Add(startVertexId);
            requiredVertexIds.Add(endVertexId);
        }

        var vertexPoints = new Dictionary<VertexId, Point3D>();
        foreach (var vertexId in requiredVertexIds.OrderBy(v => v.Value))
        {
            var pointResult = GetVertexPoint(body, vertexId);
            if (!pointResult.IsSuccess)
            {
                return KernelResult<Dictionary<VertexId, Point3D>>.Failure(pointResult.Diagnostics);
            }

            vertexPoints[vertexId] = pointResult.Value;
        }

        return KernelResult<Dictionary<VertexId, Point3D>>.Success(vertexPoints);
    }

    private static KernelResult<Point3D> GetVertexPoint(BrepBody body, VertexId vertexId)
    {
        if (body.TryGetVertexPoint(vertexId, out var point))
        {
            return KernelResult<Point3D>.Success(point);
        }

        foreach (var edge in body.Topology.Edges.OrderBy(e => e.Id.Value))
        {
            if (edge.StartVertexId != vertexId)
            {
                continue;
            }

            var edgePoint = EvaluateEdgeEndpointFromTopologyTrim(body, edge.Id, useStart: true);
            if (edgePoint.IsSuccess)
            {
                return KernelResult<Point3D>.Success(edgePoint.Value);
            }
        }

        foreach (var edge in body.Topology.Edges.OrderBy(e => e.Id.Value))
        {
            if (edge.EndVertexId != vertexId)
            {
                continue;
            }

            var edgePoint = EvaluateEdgeEndpointFromTopologyTrim(body, edge.Id, useStart: false);
            if (edgePoint.IsSuccess)
            {
                return KernelResult<Point3D>.Success(edgePoint.Value);
            }
        }

        return KernelResult<Point3D>.Failure([CreateNotImplemented($"Vertex {vertexId.Value} cannot be resolved to a geometric point for tessellation.")]);
    }

    private static KernelResult<Point3D> EvaluateEdgeEndpointFromTopologyTrim(BrepBody body, EdgeId edgeId, bool useStart)
    {
        if (!body.TryGetEdgeCurveGeometry(edgeId, out var curve) || curve is null)
        {
            return KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing bound curve geometry.")]);
        }

        if (!body.Bindings.TryGetEdgeBinding(edgeId, out var binding))
        {
            return KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing curve binding.")]);
        }

        var interval = binding.TrimInterval ?? new ParameterInterval(0d, 1d);
        var parameter = useStart ? interval.Start : interval.End;
        return curve.Kind switch
        {
            CurveGeometryKind.Line3 => KernelResult<Point3D>.Success(curve.Line3!.Value.Evaluate(parameter)),
            CurveGeometryKind.Circle3 => KernelResult<Point3D>.Success(curve.Circle3!.Value.Evaluate(parameter)),
            CurveGeometryKind.BSpline3 => KernelResult<Point3D>.Success(curve.BSpline3!.Value.Evaluate(parameter)),
            CurveGeometryKind.Ellipse3 => KernelResult<Point3D>.Success(curve.Ellipse3!.Value.Evaluate(parameter)),
            CurveGeometryKind.Hyperbola3 => KernelResult<Point3D>.Success(curve.Hyperbola3!.Value.Evaluate(parameter)),
            _ => KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} endpoint evaluation does not support curve kind '{curve.UnsupportedKind ?? curve.Kind.ToString()}'.", PlanarCurveFlatteningUnsupportedSource)]),
        };
    }

    private static KernelResult<Point3D> EvaluateEdgeEndpoint(BrepBody body, EdgeId edgeId, bool useStart)
    {
        if (!body.TryGetEdgeCurveGeometry(edgeId, out var curve) || curve is null)
        {
            return KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing bound curve geometry.")]);
        }

        if (!body.Bindings.TryGetEdgeBinding(edgeId, out var binding))
        {
            return KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing curve binding.")]);
        }

        var interval = binding.TrimInterval ?? new ParameterInterval(0d, 1d);
        var useTrimStart = useStart == binding.OrientedEdgeSense;
        var parameter = useTrimStart ? interval.Start : interval.End;
        return curve.Kind switch
        {
            CurveGeometryKind.Line3 => KernelResult<Point3D>.Success(curve.Line3!.Value.Evaluate(parameter)),
            CurveGeometryKind.Circle3 => KernelResult<Point3D>.Success(curve.Circle3!.Value.Evaluate(parameter)),
            CurveGeometryKind.BSpline3 => KernelResult<Point3D>.Success(curve.BSpline3!.Value.Evaluate(parameter)),
            CurveGeometryKind.Ellipse3 => KernelResult<Point3D>.Success(curve.Ellipse3!.Value.Evaluate(parameter)),
            CurveGeometryKind.Hyperbola3 => KernelResult<Point3D>.Success(curve.Hyperbola3!.Value.Evaluate(parameter)),
            _ => KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} endpoint evaluation does not support curve kind '{curve.UnsupportedKind ?? curve.Kind.ToString()}'.", PlanarCurveFlatteningUnsupportedSource)]),
        };
    }

    private static KernelResult<(Point3D Start, Point3D End)> GetEdgeEndpoints(
        BrepBody body,
        EdgeId edgeId,
        bool reversed,
        IReadOnlyDictionary<VertexId, Point3D> vertexPoints)
    {
        if (!body.TryGetEdgeVertices(edgeId, out var startVertexId, out var endVertexId))
        {
            return KernelResult<(Point3D, Point3D)>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing topology endpoints.")]);
        }

        if (!vertexPoints.TryGetValue(startVertexId, out var start) || !vertexPoints.TryGetValue(endVertexId, out var end))
        {
            return KernelResult<(Point3D, Point3D)>.Failure([CreateNotImplemented($"Edge {edgeId.Value} references unresolved vertex points.")]);
        }

        return KernelResult<(Point3D, Point3D)>.Success(reversed ? (end, start) : (start, end));
    }

    private static IReadOnlyList<Point3D> SampleEllipseCurve(Ellipse3Curve ellipse, ParameterInterval trim, int segmentCount)
    {
        var points = new List<Point3D>(segmentCount + 1);
        var step = (trim.End - trim.Start) / segmentCount;
        for (var i = 0; i <= segmentCount; i++)
        {
            points.Add(ellipse.Evaluate(trim.Start + (step * i)));
        }

        return points;
    }

    private static int ComputeEllipseSegmentCount(Ellipse3Curve ellipse, double start, double end, DisplayTessellationOptions options)
    {
        // An ellipse is an affine image of the unit circle. Its major radius
        // bounds chord sag; a/b bounds tangent turning per parameter radian.
        // The old fixed 45-degree step ignored both caller budgets and left
        // only two chords on a quarter-ellipse fillet miter.
        return CalculateSegmentCount(double.Abs(end - start), ellipse.MajorRadius,
            options with { AngularToleranceRadians = options.AngularToleranceRadians * ellipse.MinorRadius / ellipse.MajorRadius });
    }

    private static KernelResult<IReadOnlyList<Point3D>> SamplePlanarHyperbola(
        BrepBody body,
        Coedge coedge,
        bool traversalSwapped,
        Hyperbola3Curve hyperbola,
        Point3D start,
        Point3D end,
        PlaneSurface plane,
        FaceId faceId,
        DisplayTessellationOptions options)
    {
        const double planeContainmentTolerance = 1e-7d;
        var normalAlignment = double.Abs(hyperbola.PlaneNormal.ToVector().Dot(plane.Normal.ToVector()));
        var centerOffset = double.Abs((hyperbola.Center - plane.Origin).Dot(plane.Normal.ToVector()));
        if (normalAlignment < 1d - 1e-7d || centerOffset > planeContainmentTolerance)
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure([
                CreateNotImplemented($"Face {faceId.Value} edge {coedge.EdgeId.Value} planar hyperbola flattening requires the hyperbola plane to match the face plane.", PlanarCurveFlatteningUnsupportedSource)]);
        }

        if (!body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var binding) || binding.TrimInterval is not ParameterInterval trim)
        {
            return KernelResult<IReadOnlyList<Point3D>>.Failure([
                CreateInvalidArgument($"Face {faceId.Value} edge {coedge.EdgeId.Value} requires a bounded hyperbola trim.", PlanarCurveFlatteningFailedSource)]);
        }

        var sampled = SampleHyperbolaCurve(hyperbola, trim, options).ToList();
        if (coedge.IsReversed ^ traversalSwapped ^ !binding.OrientedEdgeSense)
        {
            sampled.Reverse();
        }
        sampled[0] = start;
        sampled[^1] = end;
        return KernelResult<IReadOnlyList<Point3D>>.Success(sampled.Skip(1).ToArray());
    }

    private static IReadOnlyList<Point3D> SampleHyperbolaCurve(Hyperbola3Curve hyperbola, ParameterInterval trim, DisplayTessellationOptions options)
    {
        // This is a display/M8 carrier only.  It adaptively controls the exact
        // midpoint-to-chord deviation and tangent turn, while preserving the exact
        // bounded support endpoints.  The B-rep still owns Hyperbola3Curve.
        var points = new List<Point3D> { hyperbola.Evaluate(trim.Start) };
        AppendHyperbolaSegment(hyperbola, trim.Start, trim.End, hyperbola.Evaluate(trim.Start), hyperbola.Evaluate(trim.End), options, points, 0);
        return points;
    }

    private static void AppendHyperbolaSegment(Hyperbola3Curve hyperbola, double start, double end, Point3D startPoint, Point3D endPoint, DisplayTessellationOptions options, List<Point3D> points, int depth)
    {
        var middle = start + ((end - start) * 0.5d);
        var middlePoint = hyperbola.Evaluate(middle);
        var chord = endPoint - startPoint;
        var chordLength = chord.Length;
        var midpointDeviation = chordLength <= 1e-14d
            ? (middlePoint - startPoint).Length
            : ((middlePoint - startPoint).Cross(chord).Length / chordLength);
        var tangentTurn = double.Acos(System.Math.Clamp(
            hyperbola.Tangent(start).ToVector().Dot(hyperbola.Tangent(end).ToVector()), -1d, 1d));
        var canSplit = depth < 32 && points.Count < options.MaximumSegments;
        if (canSplit && (midpointDeviation > options.ChordTolerance || tangentTurn > options.AngularToleranceRadians))
        {
            AppendHyperbolaSegment(hyperbola, start, middle, startPoint, middlePoint, options, points, depth + 1);
            AppendHyperbolaSegment(hyperbola, middle, end, middlePoint, endPoint, options, points, depth + 1);
            return;
        }
        if ((endPoint - points[^1]).LengthSquared > 1e-24d) points.Add(endPoint);
    }

    private static int CalculateSegmentCount(double angleSpan, double radius, DisplayTessellationOptions options)
    {
        var byAngle = (int)double.Ceiling(angleSpan / options.AngularToleranceRadians);

        var byChord = 1;
        if (radius > 0d)
        {
            var ratio = 1d - (options.ChordTolerance / radius);
            ratio = System.Math.Clamp(ratio, -1d, 1d);
            var halfStep = double.Acos(ratio);
            if (halfStep > 0d)
            {
                byChord = (int)double.Ceiling(angleSpan / (2d * halfStep));
            }
        }

        var segments = System.Math.Max(options.MinimumSegments, System.Math.Max(byAngle, byChord));
        return System.Math.Clamp(segments, options.MinimumSegments, options.MaximumSegments);
    }

    private static KernelDiagnostic CreateInvalidArgument(string message, string? source = null)
        => new(KernelDiagnosticCode.InvalidArgument, KernelDiagnosticSeverity.Error, message, source);

    private static KernelDiagnostic CreateNotImplemented(string message, string? source = null)
        => new(KernelDiagnosticCode.NotImplemented, KernelDiagnosticSeverity.Error, message, source);

    private static KernelDiagnostic CreateValidationError(string message, string source)
        => new(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, message, source);

    private static KernelDiagnostic CreateValidationWarning(string message, string source)
        => new(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Warning, message, source);
}