Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

35.7 KB
Raw Blame
using System.Text;
using System.Linq;

namespace Aetheris.Kernel.Firmament.Tests;

public sealed class FirmamentBuildAndExportTests
{
    [Fact]
    public void Run_BoxBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/box_basic.firmament",
            "box_basic.step",
            "base",
            0,
            "primitive",
            "box");
    }

    [Fact]
    public void Run_CylinderBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/cylinder_basic.firmament",
            "cylinder_basic.step",
            "post",
            0,
            "primitive",
            "cylinder");
    }


    [Fact]
    public void Run_SphereBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/sphere_basic.firmament",
            "sphere_basic.step",
            "ball",
            0,
            "primitive",
            "sphere");
    }

    [Fact]
    public void Run_TorusBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/torus_basic.firmament",
            "torus_basic.step",
            "donut1",
            0,
            "primitive",
            "torus");
    }

    [Fact]
    public void Run_TriangularPrismBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/triangular_prism_basic.firmament",
            "triangular_prism_basic.step",
            "tri1",
            0,
            "primitive",
            "triangularprism");
    }

    [Fact]
    public void Run_HexagonalPrismBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/hexagonal_prism_basic.firmament",
            "hexagonal_prism_basic.step",
            "hex1",
            0,
            "primitive",
            "hexagonalprism");
    }

    [Fact]
    public void Run_StraightSlotBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/straight_slot_basic.firmament",
            "straight_slot_basic.step",
            "slot1",
            0,
            "primitive",
            "straightslot");
    }

    [Fact]
    public void Run_ConeFrustumBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/cone_frustum_basic.firmament",
            "cone_frustum_basic.step",
            "frustum1",
            0,
            "primitive",
            "cone");
    }

    [Fact]
    public void Run_ConePointedTopZeroExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/cone_pointed_top_zero.firmament",
            "cone_pointed_top_zero.step",
            "pointed1",
            0,
            "primitive",
            "cone");
    }

    [Fact]
    public void Run_BoxAddBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/box_add_basic.firmament",
            "box_add_basic.step",
            "joined",
            1,
            "boolean",
            "add");
    }

    [Fact]
    public void Run_BooleanAddBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/boolean_add_basic.firmament",
            "boolean_add_basic.step",
            "joined",
            2,
            "boolean",
            "add");
    }

    [Fact]
    public void Run_BooleanSubtractBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/boolean_subtract_basic.firmament",
            "boolean_subtract_basic.step",
            "carved",
            2,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_PrismFamilyTriangularSubtractFixture_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Corpus/valid/m3b-valid-box-subtract-triangular-prism.firmament",
            "m3b-valid-box-subtract-triangular-prism.step",
            "tri_cut",
            1,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_PrismFamilyHexagonalSubtractFixture_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Corpus/valid/m3b-valid-box-subtract-hexagonal-prism.firmament",
            "m3b-valid-box-subtract-hexagonal-prism.step",
            "hex_cut",
            1,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_PrismFamilyStraightSlotSubtractFixture_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Corpus/valid/m3b-valid-box-subtract-straight-slot.firmament",
            "m3b-valid-box-subtract-straight-slot.step",
            "slot_cut",
            1,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_BooleanIntersectBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/boolean_intersect_basic.firmament",
            "boolean_intersect_basic.step",
            "overlap",
            2,
            "boolean",
            "intersect");
    }

    [Fact]
    public void Run_M4DraftBoxBasicExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/m4_draft_box_basic.firmament",
            "m4_draft_box_basic.step",
            "drafted",
            1,
            "boolean",
            "draft");
    }

    [Fact]
    public void Run_M5aChamferBoxEdgeExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/m5a_chamfer_box_edge_basic.firmament",
            "m5a_chamfer_box_edge_basic.step",
            "edge_break",
            1,
            "boolean",
            "chamfer");
    }

    [Fact]
    public void Run_M5aChamferBoxCornerE2Example_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/m5a_chamfer_box_corner_e2_basic.firmament",
            "m5a_chamfer_box_corner_e2_basic.step",
            "corner_break",
            1,
            "boolean",
            "chamfer");
    }

    [Fact]
    public void Run_M5aChamferTriangularPrismCornerE4Example_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/m5a_chamfer_triangular_prism_corner_e4_basic.firmament",
            "m5a_chamfer_triangular_prism_corner_e4_basic.step",
            "corner_break",
            1,
            "boolean",
            "chamfer");
    }

    [Fact]
    public void Run_BooleanBoxCylinderHoleExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/boolean_box_cylinder_hole.firmament",
            "boolean_box_cylinder_hole.step",
            "hole",
            1,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_BooleanBoxConeThroughHoleExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/boolean_box_cone_throughhole_basic.firmament",
            "boolean_box_cone_throughhole_basic.step",
            "cut",
            1,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_BooleanTwoCylinderHolesExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/boolean_two_cylinder_holes_basic.firmament",
            "boolean_two_cylinder_holes_basic.step",
            "hole_b",
            2,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_BooleanCylinderConeHolesExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/boolean_cylinder_cone_holes_basic.firmament",
            "boolean_cylinder_cone_holes_basic.step",
            "cut_b",
            2,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_BooleanBoxSphereCavityExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/boolean_box_sphere_cavity_basic.firmament",
            "boolean_box_sphere_cavity_basic.step",
            "cavity",
            1,
            "boolean",
            "subtract");
    }


    [Fact]
    public void Run_W2CylinderRootBlindBoreSemanticExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/w2_cylinder_root_blind_bore_semantic.firmament",
            "w2_cylinder_root_blind_bore_semantic.step",
            "blind_bore",
            1,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_W2BoxSphereExteriorOpeningPocketSemanticExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/w2_box_sphere_exterior_opening_pocket_semantic.firmament",
            "w2_box_sphere_exterior_opening_pocket_semantic.step",
            "pocket",
            1,
            "boolean",
            "subtract");
    }
    [Fact]
    public void Run_RibbedSupportF1Example_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/ribbed_support_f1.firmament",
            "ribbed_support_f1.step",
            "wall",
            1,
            "boolean",
            "add");
    }

    [Fact]
    public void Run_F2FlangeCenterBoreExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/f2_flange_center_bore.firmament",
            "f2_flange_center_bore.step",
            "center_bore",
            1,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_P1BlindHoleOnFaceSemanticExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/p1_blind_hole_on_face_semantic.firmament",
            "p1_blind_hole_on_face_semantic.step",
            "blind_hole_tool",
            1,
            "primitive",
            "cylinder");
    }

    [Fact]
    public void Run_P1FlangeRadialHoleSemanticExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/p1_flange_radial_hole_semantic.firmament",
            "p1_flange_radial_hole_semantic.step",
            "radial_hole_tool",
            1,
            "primitive",
            "cylinder");
    }

    [Fact]
    public void Run_P2LinearHoleRowExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/p2_linear_hole_row.firmament",
            "p2_linear_hole_row.step",
            "hole_cut_1__lin3",
            4,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_P2FlangeBoltCirclePatternExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/p2_flange_bolt_circle_pattern.firmament",
            "p2_flange_bolt_circle_pattern.step",
            "bolt_hole_1__cir5",
            7,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_P2MirrorHolePairExample_Writes_Default_Export_Artifact()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Examples/p2_mirror_hole_pair.firmament",
            "p2_mirror_hole_pair.step",
            "hole_cut_left__mir_yz",
            2,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_FrictionLabBlindHoleMountBlock_NowBuildsAndExports()
    {
        var fullSourcePath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/blind-hole-mount-block/part.firmament");

        var first = FirmamentBuildAndExport.Run(fullSourcePath);
        var second = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(first.IsSuccess, string.Join(Environment.NewLine, first.Diagnostics.Select(d => d.Message)));
        Assert.True(second.IsSuccess, string.Join(Environment.NewLine, second.Diagnostics.Select(d => d.Message)));
        Assert.NotEmpty(first.Value.Export.StepText);
        Assert.Equal(first.Value.Export.StepText, second.Value.Export.StepText);
        Assert.Contains("MANIFOLD_SOLID_BREP", first.Value.Export.StepText, StringComparison.Ordinal);
        Assert.Contains("CYLINDRICAL_SURFACE", first.Value.Export.StepText, StringComparison.Ordinal);
    }

    [Fact]
    public void Run_FrictionLabBlindHoleMountBlock_ExportedStep_Has_TopFace_Opening_Not_ContainedVoidShell()
    {
        var fullSourcePath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/blind-hole-mount-block/part.firmament");
        var result = FirmamentBuildAndExport.Run(fullSourcePath);
        Assert.True(result.IsSuccess);

        var import = Aetheris.Kernel.Core.Step242.Step242Importer.ImportBody(result.Value.Export.StepText);
        Assert.True(import.IsSuccess);

        var body = import.Value;
        Assert.DoesNotContain("BREP_WITH_VOIDS", result.Value.Export.StepText, StringComparison.Ordinal);

        var topFace = body.Topology.Faces
            .Select(face =>
            {
                body.TryGetFaceSurfaceGeometry(face.Id, out var surface);
                return (face, surface);
            })
            .Where(entry => entry.surface?.Kind == Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.Plane)
            .Where(entry => entry.surface!.Plane!.Value.Normal.ToVector().Z > 0.5d)
            .OrderByDescending(entry => entry.surface!.Plane!.Value.Origin.Z)
            .First();

        Assert.Equal(2, topFace.face.LoopIds.Count);
    }


    [Fact]
    public void Run_FrictionLabCountersinkHole_NowBuildsAndExports()
    {
        var fullSourcePath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/countersink-hole/part.firmament");

        var first = FirmamentBuildAndExport.Run(fullSourcePath);
        var second = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(first.IsSuccess, string.Join(Environment.NewLine, first.Diagnostics.Select(d => d.Message)));
        Assert.True(second.IsSuccess, string.Join(Environment.NewLine, second.Diagnostics.Select(d => d.Message)));
        Assert.NotEmpty(first.Value.Export.StepText);
        Assert.Equal(first.Value.Export.StepText, second.Value.Export.StepText);
        Assert.Contains("MANIFOLD_SOLID_BREP", first.Value.Export.StepText, StringComparison.Ordinal);
        Assert.Contains("CONICAL_SURFACE", first.Value.Export.StepText, StringComparison.Ordinal);
        Assert.Contains("CYLINDRICAL_SURFACE", first.Value.Export.StepText, StringComparison.Ordinal);
        Assert.DoesNotContain("BREP_WITH_VOIDS", first.Value.Export.StepText, StringComparison.Ordinal);
    }

    [Fact]
    public void Run_FrictionLabCounterboreHole_NowBuildsAndExports()
    {
        var fullSourcePath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/counterbore-hole/part.firmament");

        var first = FirmamentBuildAndExport.Run(fullSourcePath);
        var second = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(first.IsSuccess);
        Assert.True(second.IsSuccess);
        Assert.NotEmpty(first.Value.Export.StepText);
        Assert.Equal(first.Value.Export.StepText, second.Value.Export.StepText);
        Assert.Contains("MANIFOLD_SOLID_BREP", first.Value.Export.StepText, StringComparison.Ordinal);
        Assert.Contains("CYLINDRICAL_SURFACE", first.Value.Export.StepText, StringComparison.Ordinal);
    }

    [Fact]
    public void Semantic_Placement_Build_Is_Deterministic()
    {
        var fullSourcePath = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Compatibility/LegacyV1/Examples/p1_flange_radial_hole_semantic.firmament");
        var first = FirmamentBuildAndExport.Run(fullSourcePath);
        var second = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(first.IsSuccess);
        Assert.True(second.IsSuccess);
        Assert.Equal(first.Value.Export.StepText, second.Value.Export.StepText);
    }

    [Fact]
    public void P2_CircularPattern_Build_Is_Deterministic()
    {
        var fullSourcePath = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Compatibility/LegacyV1/Examples/p2_flange_bolt_circle_pattern.firmament");
        var first = FirmamentBuildAndExport.Run(fullSourcePath);
        var second = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(first.IsSuccess);
        Assert.True(second.IsSuccess);
        Assert.Equal(first.Value.Export.StepText, second.Value.Export.StepText);
    }

    [Fact]
    public void Run_ContainedBoxWithCylinderHoleFixture_Builds_And_Writes_Export()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Corpus/deferred/m10h1-unsupported-box-with-cylinder-hole.firmament",
            "m10h1-unsupported-box-with-cylinder-hole.step",
            "hole",
            1,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_AddThenSubtract_ReentrySafeRootFixture_Builds_And_Writes_Export()
    {
        AssertExampleBuildAndExport(
            "fixtures/Compatibility/LegacyV1/Corpus/invalid/m13b-invalid-composed-reenter-safe-family.firmament",
            "m13b-invalid-composed-reenter-safe-family.step",
            "hole",
            2,
            "boolean",
            "subtract");
    }

    [Fact]
    public void Run_FrictionLabMountingBracketBasic_Builds_And_Exports_After_G8_IndependentHoleSupport()
    {
        var fullSourcePath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/mounting-bracket-basic/part.firmament");
        var result = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => d.Message)));
        Assert.Equal("upright_hole", result.Value.Export.ExportedFeatureId);
        Assert.Equal("boolean", result.Value.Export.ExportedBodyCategory);
        Assert.Equal("subtract", result.Value.Export.ExportedFeatureKind);
        Assert.Contains("MANIFOLD_SOLID_BREP", result.Value.Export.StepText, StringComparison.Ordinal);
    }

    [Fact]
    public void Run_FrictionLabSimpleBracket_NowBuildsAndExports()
    {
        var fullSourcePath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/simple-bracket/part.firmament");
        var result = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => d.Message)));
        Assert.Equal("bracket", result.Value.Export.ExportedFeatureId);
        Assert.Equal("boolean", result.Value.Export.ExportedBodyCategory);
        Assert.Equal("add", result.Value.Export.ExportedFeatureKind);
        Assert.Contains("MANIFOLD_SOLID_BREP", result.Value.Export.StepText, StringComparison.Ordinal);
    }

    [Fact]
    public void Run_FrictionLabSimpleBracket_ExportedStep_Matches_FL2i_Canonical_LShape_Constraints()
    {
        var fullSourcePath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/simple-bracket/part.firmament");
        var build = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(build.IsSuccess, string.Join(Environment.NewLine, build.Diagnostics.Select(d => d.Message)));
        Assert.Equal("bracket", build.Value.Export.ExportedFeatureId);
        Assert.Equal("boolean", build.Value.Export.ExportedBodyCategory);
        Assert.Equal("add", build.Value.Export.ExportedFeatureKind);

        Assert.DoesNotContain("TRIANGULATED_FACE_SET", build.Value.Export.StepText, StringComparison.Ordinal);
        Assert.Equal(10, CountOccurrences(build.Value.Export.StepText, "ADVANCED_FACE"));

        var sourceText = File.ReadAllText(fullSourcePath, Encoding.UTF8);
        Assert.Contains("ops[2]", sourceText, StringComparison.Ordinal);
        Assert.Contains(@"size[3]:
      60
      20
      10", sourceText, StringComparison.Ordinal);
        Assert.Contains(@"size[3]:
        10
        20
        60", sourceText, StringComparison.Ordinal);
        Assert.Contains(@"offset[3]:
        30
        10
        0", sourceText, StringComparison.Ordinal);
        Assert.Contains(@"offset[3]:
        5
        10
        0", sourceText, StringComparison.Ordinal);
        Assert.DoesNotContain("op: subtract", sourceText, StringComparison.Ordinal);

        var pointPattern = new System.Text.RegularExpressions.Regex(
            @"CARTESIAN_POINT\([^\)]*\(([-0-9.E+]+),([-0-9.E+]+),([-0-9.E+]+)\)\)",
            System.Text.RegularExpressions.RegexOptions.Compiled);
        var points = pointPattern.Matches(build.Value.Export.StepText)
            .Select(match => (
                X: double.Parse(match.Groups[1].Value, System.Globalization.CultureInfo.InvariantCulture),
                Y: double.Parse(match.Groups[2].Value, System.Globalization.CultureInfo.InvariantCulture),
                Z: double.Parse(match.Groups[3].Value, System.Globalization.CultureInfo.InvariantCulture)))
            .ToArray();
        Assert.NotEmpty(points);

        var minX = points.Min(p => p.X);
        var maxX = points.Max(p => p.X);
        var minY = points.Min(p => p.Y);
        var maxY = points.Max(p => p.Y);
        var minZ = points.Min(p => p.Z);
        var maxZ = points.Max(p => p.Z);

        Assert.Equal(60d, maxX - minX, 6);
        Assert.Equal(20d, maxY - minY, 6);
        Assert.Equal(60d, maxZ - minZ, 6);
        Assert.Equal(0d, minX, 6);
        Assert.Equal(60d, maxX, 6);
        Assert.Equal(0d, minY, 6);
        Assert.Equal(20d, maxY, 6);
        Assert.Equal(0d, minZ, 6);
        Assert.Equal(60d, maxZ, 6);
        Assert.DoesNotContain(points, p => ArePointWithinTolerance(p, 1d, 0d, 10d, 1e-6d));
        Assert.DoesNotContain(points, p => ArePointWithinTolerance(p, 0d, 20d, 1d, 1e-6d));

        Assert.DoesNotContain("B_SPLINE", build.Value.Export.StepText, StringComparison.Ordinal);
        Assert.DoesNotContain("TOROIDAL_SURFACE", build.Value.Export.StepText, StringComparison.Ordinal);
        Assert.DoesNotContain("CONICAL_SURFACE", build.Value.Export.StepText, StringComparison.Ordinal);
        Assert.DoesNotContain("SPHERICAL_SURFACE", build.Value.Export.StepText, StringComparison.Ordinal);
    }


    [Fact]
    public void Run_FrictionLabMountingBracketBasic_ContinuedRoot_SubtractPlacement_Uses_World_Frame()
    {
        var sourceText = File.ReadAllText(
            Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/mounting-bracket-basic/part.firmament"),
            Encoding.UTF8);
        var compiler = new FirmamentCompiler();
        var compilation = compiler.Compile(new FirmamentCompileRequest(new FirmamentSourceDocument(sourceText))).Compilation;

        Assert.True(compilation.IsSuccess, string.Join(Environment.NewLine, compilation.Diagnostics.Select(d => d.Message)));
        var finalBody = Assert.Single(compilation.Value.PrimitiveExecutionResult!.ExecutedBooleans, b => b.FeatureId == "upright_hole").Body;
        Assert.NotNull(finalBody.SafeBooleanComposition);
        var composition = finalBody.SafeBooleanComposition!;
        Assert.Equal(2, composition.Holes.Count);

        Assert.Contains(composition.Holes, hole => Math.Abs(hole.CenterX + 15d) < 1e-6d && Math.Abs(hole.CenterY) < 1e-6d);
        Assert.Contains(composition.Holes, hole => Math.Abs(hole.CenterX - 26d) < 1e-6d && Math.Abs(hole.CenterY) < 1e-6d);
    }

    [Fact]
    public void Run_FrictionLabMountingBracketBasic_ExportedStep_Holes_Are_At_Intended_X_Positions()
    {
        var fullSourcePath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/mounting-bracket-basic/part.firmament");
        var result = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => d.Message)));
        var import = Aetheris.Kernel.Core.Step242.Step242Importer.ImportBody(result.Value.Export.StepText);
        Assert.True(import.IsSuccess, string.Join(Environment.NewLine, import.Diagnostics.Select(d => d.Message)));

        var cylinderOriginsX = import.Value.Topology.Faces
            .Select(face =>
            {
                import.Value.TryGetFaceSurfaceGeometry(face.Id, out var surface);
                return surface;
            })
            .Where(surface => surface?.Kind == Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.Cylinder)
            .Select(surface => surface!.Cylinder!.Value.Origin.X)
            .Distinct()
            .OrderBy(x => x)
            .ToArray();

        Assert.Contains(cylinderOriginsX, x => Math.Abs(x + 15d) < 1e-6d);
        Assert.Contains(cylinderOriginsX, x => Math.Abs(x - 26d) < 1e-6d);
    }

    [Theory]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m10j-unsupported-box-add-cylinder.firmament", "m10j-unsupported-box-add-cylinder.step", "joined", "add")]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m10j-unsupported-box-intersect-cylinder.firmament", "m10j-unsupported-box-intersect-cylinder.step", "overlap", "intersect")]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m10l-unsupported-box-add-sphere.firmament", "m10l-unsupported-box-add-sphere.step", "joined", "add")]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m10l-unsupported-box-intersect-sphere.firmament", "m10l-unsupported-box-intersect-sphere.step", "overlap", "intersect")]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m10m-unsupported-box-subtract-cone.firmament", "m10m-unsupported-box-subtract-cone.step", "tapered_cut", "subtract")]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m10m-unsupported-box-add-cone.firmament", "m10m-unsupported-box-add-cone.step", "joined", "add")]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m10m-unsupported-box-intersect-cone.firmament", "m10m-unsupported-box-intersect-cone.step", "overlap", "intersect")]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m13a-unsupported-overlapping-composed-holes.firmament", "m13a-unsupported-overlapping-composed-holes.step", "hole_b", "subtract")]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m13a-unsupported-tangent-composed-holes.firmament", "m13a-unsupported-tangent-composed-holes.step", "hole_b", "subtract")]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m13a-unsupported-composed-add-ordering.firmament", "m13a-unsupported-composed-add-ordering.step", "joined", "add")]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m13a-unsupported-composed-subtract-sphere.firmament", "m13a-unsupported-composed-subtract-sphere.step", "cavity", "subtract")]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m13a-unsupported-composed-subtract-box.firmament", "m13a-unsupported-composed-subtract-box.step", "notch", "subtract")]
    [InlineData("fixtures/Compatibility/LegacyV1/Corpus/deferred/m13c-unsupported-cylinder-root-follow-on-hole.firmament", "m13c-unsupported-cylinder-root-follow-on-hole.step", "bolt_hole", "subtract")]
    public void Run_Unsupported_MixedPrimitive_Fixtures_Fail_And_Do_Not_Write_Fallback_Export(
        string sourcePath,
        string expectedFileName,
        string expectedFeatureId,
        string expectedKind)
    {
        AssertUnsupportedBuildAndExport(sourcePath, expectedFileName, expectedFeatureId, expectedKind);
    }

    [Fact]
    public void Run_FrictionLabShaftKeyway_SucceedsAndExports()
    {
        var fullSourcePath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/shaft-keyway/part.firmament");
        var result = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => d.Message)));
        Assert.Equal("keyway", result.Value.Export.ExportedFeatureId);
        Assert.Equal("boolean", result.Value.Export.ExportedBodyCategory);
        Assert.Equal("subtract", result.Value.Export.ExportedFeatureKind);
        Assert.Contains("CYLINDRICAL_SURFACE", result.Value.Export.StepText, StringComparison.Ordinal);
    }

    [Fact]
    public void Run_FrictionLabPocketedPlate_ExecutesBoundedOpenMouthPocketAndExports()
    {
        var fullSourcePath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/pocketed-plate/part.firmament");
        var existingOutputPath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/pocketed-plate/part.step");
        if (File.Exists(existingOutputPath))
        {
            File.Delete(existingOutputPath);
        }

        var result = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => d.Message)));
        Assert.Equal("pocket", result.Value.Export.ExportedFeatureId);
        Assert.Equal("boolean", result.Value.Export.ExportedBodyCategory);
        Assert.Equal("subtract", result.Value.Export.ExportedFeatureKind);
        Assert.True(File.Exists(result.Value.OutputPath));

        var stepText = result.Value.Export.StepText;
        Assert.True(CountOccurrences(stepText, "ADVANCED_FACE") > 6);
    }

    [Fact]
    public void Run_FrictionLabFlangeBoltCircle_RemovesOverlapBlocker_AndAdvancesPastSchemaVoidGate()
    {
        var fullSourcePath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/flange-bolt-circle/part.firmament");
        var expectedOutputPath = Path.GetFullPath(Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/flange-bolt-circle/part.step"));
        if (File.Exists(expectedOutputPath))
        {
            File.Delete(expectedOutputPath);
        }

        var result = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => d.Message)));
        Assert.True(File.Exists(result.Value.OutputPath));
        Assert.Equal(expectedOutputPath, result.Value.OutputPath);
        Assert.DoesNotContain(result.Diagnostics, diagnostic =>
            diagnostic.Message.Contains("overlapping cylinder-root hole chains are not supported", StringComparison.Ordinal));
        Assert.DoesNotContain(result.Diagnostics, diagnostic =>
            diagnostic.Message.Contains("[FIRM-SCHEMA-0006]", StringComparison.Ordinal));
        Assert.Contains("BREP_WITH_VOIDS", result.Value.Export.StepText, StringComparison.Ordinal);
    }

    [Fact]
    public void Run_BoundedPocketFixture_WithSealedCavity_RemainsExplicitlyRejected()
    {
        var fullSourcePath = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Compatibility/LegacyV1/Corpus/deferred/m13b-unsupported-sealed-pocket-box.firmament");
        var expectedOutputPath = Path.ChangeExtension(fullSourcePath, ".step");
        if (File.Exists(expectedOutputPath))
        {
            File.Delete(expectedOutputPath);
        }

        var result = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.False(result.IsSuccess);
        Assert.False(File.Exists(expectedOutputPath));
        Assert.Contains(result.Diagnostics, diagnostic =>
            diagnostic.Source == "BrepBoolean.RebuildResult"
            && diagnostic.Message.Contains("requires the subtract box to open to exactly one exterior root face", StringComparison.Ordinal));
    }

    private static void AssertExampleBuildAndExport(string sourcePath, string expectedFileName, string expectedFeatureId, int expectedOpIndex, string expectedBodyCategory, string expectedFeatureKind)
    {
        var fullSourcePath = FirmamentCorpusHarness.ResolveFixtureFullPath(sourcePath);
        var expectedOutputPath = Path.ChangeExtension(fullSourcePath, ".step");
        if (File.Exists(expectedOutputPath))
        {
            File.Delete(expectedOutputPath);
        }

        var result = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => d.Message)));
        Assert.Equal(fullSourcePath, result.Value.SourcePath);
        Assert.Equal(expectedOutputPath, result.Value.OutputPath);
        Assert.Equal(expectedFeatureId, result.Value.Export.ExportedFeatureId);
        Assert.Equal(expectedOpIndex, result.Value.Export.ExportedOpIndex);
        Assert.Equal(expectedBodyCategory, result.Value.Export.ExportedBodyCategory);
        Assert.Equal(expectedFeatureKind, result.Value.Export.ExportedFeatureKind);
        Assert.True(File.Exists(expectedOutputPath));
        Assert.Equal(result.Value.Export.StepText, File.ReadAllText(expectedOutputPath, Encoding.UTF8));
    }

    private static void AssertUnsupportedBuildAndExport(string sourcePath, string expectedFileName, string expectedFeatureId, string expectedKind)
    {
        var fullSourcePath = FirmamentCorpusHarness.ResolveFixtureFullPath(sourcePath);
        var expectedOutputPath = Path.ChangeExtension(fullSourcePath, ".step");
        if (File.Exists(expectedOutputPath))
        {
            File.Delete(expectedOutputPath);
        }

        var result = FirmamentBuildAndExport.Run(fullSourcePath);

        Assert.False(result.IsSuccess);
        Assert.False(File.Exists(expectedOutputPath));
        Assert.Contains(result.Diagnostics, diagnostic => diagnostic.Message.Contains($"Requested boolean feature '{expectedFeatureId}' ({expectedKind}) could not be executed.", StringComparison.Ordinal));
        Assert.Contains(result.Diagnostics, diagnostic => HasExpectedMixedPrimitiveFailure(diagnostic.Message));
    }

    private static bool HasExpectedMixedPrimitiveFailure(string message)
        => message.Contains("bounded boolean family only supports recognized axis-aligned boxes from BrepPrimitives.CreateBox(...).", StringComparison.Ordinal)
           || message.Contains("sequential safe composition only supports subtracting supported cylinder/cone analytic holes", StringComparison.Ordinal)
           || message.Contains("safe subtract", StringComparison.Ordinal)
           || message.Contains("unsupported follow-on tool kind", StringComparison.Ordinal)
           || message.Contains("Boolean feature", StringComparison.Ordinal)
           || message.Contains("analytic hole surface kind", StringComparison.Ordinal)
           || message.Contains("fully enclosed spherical cavity", StringComparison.Ordinal);

    private static int CountOccurrences(string value, string token)
    {
        var count = 0;
        var index = 0;
        while ((index = value.IndexOf(token, index, StringComparison.Ordinal)) >= 0)
        {
            count++;
            index += token.Length;
        }

        return count;
    }

    private static bool ArePointWithinTolerance((double X, double Y, double Z) point, double x, double y, double z, double tolerance)
        => Math.Abs(point.X - x) <= tolerance
           && Math.Abs(point.Y - y) <= tolerance
           && Math.Abs(point.Z - z) <= tolerance;
}