Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

33.4 KB
Raw Blame
using Aetheris.Kernel.Core.Step242;
using Aetheris.Kernel.Firmament.FirmamentV2;

namespace Aetheris.Kernel.Firmament.Tests;

public sealed class FirmamentV2InlineStepTests
{
    private const string FixturePath = "fixtures/Regression/InlineStep/valid/inline-step-v2-canonical-box-reexport-step-verified.valid.firmfixture";
    private const string InputStepPath = "testdata/firmament/inline-step/canonical-box-10x8x6.step";

    [Theory]
    [InlineData(false)]
    [InlineData(true)]
    public void ImportedPmi_PreservesFaceAssociationsAndGeometry(bool regions)
    {
        var repo = FindRepoRoot();
        var source = File.ReadAllText(Path.Combine(repo, "fixtures/Regression/InlineStep/valid/inline-step-v2-record-pmi-datum-diameter-step-verified.valid.firmfixture"))
            .Replace("../../../../testdata/", "testdata/").Replace("6.0mm tol 0.05mm", "2.0mm tol 0.1mm");
        if (!regions) source = source.Replace("part.region(\"baseFace\")", "part.face(\"#51\")")
            .Replace("part.region(\"mountHoleA\")", "part.face(\"#191\")");
        var baseline = FirmamentBuildAndExport.CompileSource(source[..source.IndexOf("    pmi {", StringComparison.Ordinal)] + "}", repo);
        var annotated = FirmamentBuildAndExport.CompileSource(source, repo);
        Assert.True(baseline.IsSuccess, string.Join("; ", baseline.Diagnostics));
        Assert.True(annotated.IsSuccess, string.Join("; ", annotated.Diagnostics));
        var inspection = Step242SemanticPmiInspector.Inspect(annotated.Value.StepText);
        Assert.True(inspection.Success);
        var datum = Assert.Single(inspection.Items, i => i.Kind == "Datum");
        var diameter = Assert.Single(inspection.Items, i => i.Kind == "Diameter");
        Assert.Single(datum.GeometricFaceEntityIds);
        Assert.Single(diameter.GeometricFaceEntityIds);
        Assert.NotEqual(datum.GeometricFaceEntityIds[0], diameter.GeometricFaceEntityIds[0]);
        Assert.Equal(2, diameter.Value);
        Assert.Equal(.1, diameter.TolerancePlus);
        Assert.Equal(.1, diameter.ToleranceMinus);
        var reimport = Step242Importer.ImportBody(annotated.Value.StepText).Value;
        Assert.Equal(Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.Plane, reimport.Geometry.GetSurface(
            reimport.Bindings.FaceBindings.Single(b => b.SourceStepEntityId == datum.GeometricFaceEntityIds[0]).SurfaceGeometryId).Kind);
        Assert.Equal(Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.Cylinder, reimport.Geometry.GetSurface(
            reimport.Bindings.FaceBindings.Single(b => b.SourceStepEntityId == diameter.GeometricFaceEntityIds[0]).SurfaceGeometryId).Kind);
        // All pre-existing entity records, including topology and geometry, survive verbatim.
        var before = System.Text.RegularExpressions.Regex.Matches(baseline.Value.StepText, @"(?m)^#\d+=[^\r\n]+;").Select(m => m.Value).ToArray();
        Assert.NotEmpty(before);
        Assert.All(before, record => Assert.Contains(record, annotated.Value.StepText, StringComparison.Ordinal));
    }

    [Theory]
    [InlineData("modify")]
    [InlineData("Modify")]
    [InlineData("MODIFY")]
    public void InlineStep_UnsupportedModification_IsRejectedRegardlessOfKeywordCase(string keyword)
    {
        var repo = FindRepoRoot();
        var source = "model Imported { units mm solid Body: InlineStep { path: \""
            + InputStepPath + "\" } " + keyword
            + " Body { Hole<Shaft> Bore { On: +Z; Center: [0mm,0mm]; Diameter: 4mm; End: ThroughAll } } }";
        var parsed = FirmamentV2Parser.Parse(source, repo);
        Assert.False(parsed.IsSuccess);
        Assert.Contains(FirmamentV2Parser.ModifyTargetNotSolid, parsed.Diagnostics);

        var exported = FirmamentBuildAndExport.CompileSource(source, repo);
        Assert.False(exported.IsSuccess);
        Assert.Contains(exported.Diagnostics, diagnostic => diagnostic.Message == FirmamentV2Parser.ModifyTargetNotSolid);
    }

    [Fact]
    public void InlineStep_CanonicalBox_ReexportsAndRoundTripsThroughAp242()
    {
        var repo = FindRepoRoot();
        var outputPath = Path.Combine(Path.GetTempPath(), $"aetheris-inline-step-x1-{Guid.NewGuid():N}.step");
        try
        {
            var result = FirmamentBuildAndExport.Run(Path.Combine(repo, FixturePath), outputPath);

            Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => $"{d.Source}: {d.Message}")));
            Assert.Contains(result.Diagnostics, d => d.Message.StartsWith("step-import-loop-order-recovered:", StringComparison.Ordinal));
            Assert.True(File.Exists(outputPath));
            Assert.Equal("inline-step", result.Value.Export.ExportedBodyCategory);
            Assert.Equal("aetheris-canonical-ap242", result.Value.Export.ExportedFeatureKind);

            var output = File.ReadAllText(outputPath);
            Assert.Contains("ADVANCED_FACE", output, StringComparison.Ordinal);
            Assert.Contains("VERTEX_POINT", output, StringComparison.Ordinal);
            Assert.True(Count(output, "ADVANCED_FACE") > 0);
            Assert.True(Count(output, "VERTEX_POINT") > 0);
            Assert.Contains("MANIFOLD_SOLID_BREP", output, StringComparison.Ordinal);
            Assert.DoesNotContain("trace-only", output, StringComparison.OrdinalIgnoreCase);
            Assert.NotEqual(File.ReadAllText(Path.Combine(repo, InputStepPath)), output);

            var import = Step242Importer.ImportBody(output);
            Assert.True(import.IsSuccess, string.Join(Environment.NewLine, import.Diagnostics.Select(d => $"{d.Source}: {d.Message}")));
            Assert.Equal(6, import.Value.Topology.Faces.Count());
            Assert.Equal(8, import.Value.Topology.Vertices.Count());
            Assert.Equal(12, import.Value.Topology.Edges.Count());
            Assert.Equal(480d, ComputeBoxVolume(import.Value), precision: 8);
        }
        finally
        {
            if (File.Exists(outputPath)) File.Delete(outputPath);
        }
    }


    public static TheoryData<string, string, string, double> InlinePmiCases => new()
    {
        { "inline-step-v2-datum-pmi-on-canonical-face-emits-in-step", "SHAPE_ASPECT('firmament-datum:A'", "PROPERTY_DEFINITION('datum:A:importedPart'", 480d },
        { "inline-step-v2-hole-diameter-pmi-on-canonical-face-emits-in-step", "SHAPE_DIMENSION_REPRESENTATION('diameter:importedPart.holeDiameter'", "PROPERTY_DEFINITION('diameter:importedPart.holeDiameter'", 480d - Math.PI * 1d * 1d * 6d },
        { "inline-step-v2-recognized-face-datum-pmi-emits-in-step", "SHAPE_ASPECT('firmament-datum:A'", "PROPERTY_DEFINITION('datum:A:importedPart'", 480d },
        { "inline-step-v2-recognized-hole-diameter-pmi-emits-in-step", "SHAPE_DIMENSION_REPRESENTATION('diameter:importedPart.mountHoleDiameter'", "PROPERTY_DEFINITION('diameter:importedPart.mountHoleDiameter'", 480d - Math.PI * 1d * 1d * 6d }
    };

    [Theory]
    [MemberData(nameof(InlinePmiCases))]
    public void InlineStep_SemanticPmiOnCanonicalFace_ExportsReimportsAndKeepsGeometry(string fixtureId, string primaryEvidence, string secondaryEvidence, double expectedVolume)
    {
        var repo = FindRepoRoot();
        var fixturePath = Path.Combine(repo, $"fixtures/Regression/InlineStep/valid/{fixtureId}.valid.firmfixture");
        var outputPath = Path.Combine(Path.GetTempPath(), $"aetheris-inline-step-x2-{Guid.NewGuid():N}.step");
        try
        {
            var result = FirmamentBuildAndExport.Run(fixturePath, outputPath);

            Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => $"{d.Source}: {d.Message}")));
            Assert.True(File.Exists(outputPath));
            Assert.Equal("inline-step", result.Value.Export.ExportedBodyCategory);

            var fixture = File.ReadAllText(fixturePath);
            Assert.Contains("canonical-input-required: true", fixture, StringComparison.Ordinal);
            Assert.Contains("semantic-pmi-required: true", fixture, StringComparison.Ordinal);
            Assert.Contains("graphical-pmi-required: false", fixture, StringComparison.Ordinal);

            var output = File.ReadAllText(outputPath);
            Assert.Contains("ADVANCED_FACE", output, StringComparison.Ordinal);
            Assert.Contains("VERTEX_POINT", output, StringComparison.Ordinal);
            Assert.Contains(primaryEvidence, output, StringComparison.Ordinal);
            Assert.Contains(secondaryEvidence, output, StringComparison.Ordinal);
            Assert.DoesNotContain("DRAUGHTING_CALLOUT", output, StringComparison.Ordinal);
            Assert.DoesNotContain("ANNOTATION_PLANE", output, StringComparison.Ordinal);

            var import = Step242Importer.ImportBody(output);
            Assert.True(import.IsSuccess, string.Join(Environment.NewLine, import.Diagnostics.Select(d => $"{d.Source}: {d.Message}")));
            Assert.True(import.Value.Topology.Faces.Count() > 0);
            Assert.True(expectedVolume > 0d);
        }
        finally
        {
            if (File.Exists(outputPath)) File.Delete(outputPath);
        }
    }


    [Fact]
    public void InlineStep_RecognizedRegion_ParsesAndStoresMetadata()
    {
        var repo = FindRepoRoot();
        var source = File.ReadAllText(Path.Combine(repo, "fixtures/Regression/InlineStep/valid/inline-step-v2-recognized-face-datum-pmi-emits-in-step.valid.firmfixture"));
        var parse = FirmamentV2Parser.Parse(source, Path.Combine(repo, "fixtures/Regression/InlineStep/valid"));

        Assert.True(parse.IsSuccess, string.Join(Environment.NewLine, parse.Diagnostics));
        var region = Assert.Single(parse.Document!.RecognizedRegions!);
        Assert.Equal("importedPart", region.BodyName);
        Assert.Equal("topFace", region.RegionName);
        Assert.Equal("datumPlane", region.Kind);
        Assert.Equal("#40", Assert.Single(region.FaceRefs));
        Assert.Equal("high", region.Confidence);
        Assert.Equal("importedPart.region(\"topFace\")", Assert.Single(parse.Document.Pmi!).Target);
    }

    [Theory]
    [InlineData("kind: bogus\n            faces: [\"#40\"]\n            confidence: high", FirmamentV2Parser.InvalidRecognitionKind)]
    [InlineData("kind: datumPlane\n            faces: [\"#40\"]\n            confidence: maybe", FirmamentV2Parser.InvalidRecognitionConfidence)]
    [InlineData("kind: datumPlane\n            faces: [\"#999999\"]\n            confidence: high", FirmamentV2Parser.UnknownRecognitionFace)]
    public void InlineStep_InvalidRecognitionMetadata_RejectsDeterministically(string regionBody, string diagnostic)
    {
        var source = $$"""
model BadRecognition { units mm solid importedPart: InlineStep { path: "../../../../testdata/firmament/inline-step/canonical-box-10x8x6.step" } recognize importedPart { region topFace { {{regionBody}} } } }
""";
        var parse = FirmamentV2Parser.Parse(source, Path.Combine(FindRepoRoot(), "fixtures/Regression/InlineStep/valid"));

        Assert.False(parse.IsSuccess);
        Assert.Contains(diagnostic, parse.Diagnostics);
    }

    [Theory]
    [InlineData("recognize missingPart { region topFace { kind: datumPlane faces: [\"#191\"] confidence: high } }", FirmamentV2Parser.UnknownRecognitionBody)]
    [InlineData("recognize importedPart { region topFace { kind: datumPlane faces: [\"#191\"] confidence: high } region topFace { kind: datumPlane faces: [\"#77\"] confidence: high } }", FirmamentV2Parser.DuplicateRegion)]
    [InlineData("recognize importedPart { region topFace { kind: datumPlane faces: [\"#191\"] confidence: high } } pmi { datum A { target: importedPart.region(\"missingRegion\") } }", FirmamentV2Parser.UnknownRecognitionRegion)]
    [InlineData("recognize importedPart { region mountHole { kind: holeShaft faces: [\"#40\"] confidence: high } } pmi { datum A { target: importedPart.region(\"mountHole\") } }", FirmamentV2Parser.PmiRecognizedRegionKindMismatch)]
    public void InlineStep_InvalidRecognizedTargets_RejectDeterministically(string tail, string diagnostic)
    {
        var source = $$"""
model BadRecognitionTarget { units mm solid importedPart: InlineStep { path: "../../../../testdata/firmament/inline-step/canonical-box-10x8x6.step" } {{tail}} }
""";
        var parse = FirmamentV2Parser.Parse(source, Path.Combine(FindRepoRoot(), "fixtures/Regression/InlineStep/valid"));

        Assert.False(parse.IsSuccess);
        Assert.Contains(diagnostic, parse.Diagnostics);
    }

    [Theory]
    [InlineData("inline-step-v2-pmi-unknown-body.invalid.firmfixture", FirmamentV2Parser.InlineStepUnknownBody)]
    [InlineData("inline-step-v2-pmi-unknown-face.invalid.firmfixture", FirmamentV2Parser.InlineStepUnknownFace)]
    [InlineData("inline-step-v2-pmi-invalid-diameter.invalid.firmfixture", FirmamentV2Parser.PmiDiameterInvalid)]
    public void InlineStep_InvalidImportedPmiTargets_RejectDeterministically(string fixtureName, string diagnostic)
    {
        var repo = FindRepoRoot();
        var source = File.ReadAllText(Path.Combine(repo, "fixtures/Compatibility/LegacyAliases/Invalid/InlineStep", fixtureName));
        var parse = FirmamentV2Parser.Parse(source, Path.Combine(repo, "fixtures/Compatibility/LegacyAliases/Invalid/InlineStep"));

        Assert.False(parse.IsSuccess);
        Assert.Contains(diagnostic, parse.Diagnostics);
    }


    [Fact]
    public void InlineStep_RecognizedRegion_ParsesEvidenceAndSemanticProposalMetadataOnly()
    {
        var repo = FindRepoRoot();
        var fixturePath = Path.Combine(repo, "fixtures/Regression/InlineStep/valid/inline-step-v2-recognized-hole-proposal-report.valid.firmfixture");
        var parse = FirmamentV2Parser.Parse(File.ReadAllText(fixturePath), Path.GetDirectoryName(fixturePath));

        Assert.True(parse.IsSuccess, string.Join(Environment.NewLine, parse.Diagnostics));
        var region = Assert.Single(parse.Document!.RecognizedRegions!);
        Assert.Equal("holeShaft", region.Kind);
        Assert.Equal("#191", Assert.Single(region.FaceRefs));
        Assert.NotNull(region.Evidence);
        Assert.Equal("cylindrical", Assert.Single(region.Evidence!.SurfaceFamilies));
        Assert.Equal(1d, region.Evidence.Radius);
        Assert.Equal("+Z", region.Evidence.Axis);
        Assert.True(region.Evidence.Through);
        Assert.NotNull(region.Proposal);
        Assert.Equal("holeShaft", region.Proposal!.ProposalKind);
        Assert.Equal("mountHole", region.Proposal.FeatureName);
        Assert.Equal("importedPart.face(\"#51\")", region.Proposal.PlacementTarget);
        Assert.Equal(1d, region.Proposal.Radius);
        Assert.Equal("throughAll", region.Proposal.EndCondition);
        Assert.Empty(parse.Document.Replacements!);
    }

    [Theory]
    [InlineData("evidence { surfaceFamily: cylindrical radius: -1mm axis: +Z through: true }", FirmamentV2Parser.RecognitionEvidenceRadiusInvalid)]
    [InlineData("evidence { surfaceFamily: spline radius: 1mm axis: +Z through: true }", FirmamentV2Parser.RecognitionEvidenceSurfaceFamilyUnknown)]
    [InlineData("evidence { surfaceFamily: cylindrical radius: 1mm axis: north through: true }", FirmamentV2Parser.RecognitionEvidenceAxisInvalid)]
    [InlineData("proposes datumPlane { radius: 1mm end: throughAll }", FirmamentV2Parser.SemanticProposalKindMismatch)]
    [InlineData("proposes hole<shaft> { radius: -1mm end: throughAll }", FirmamentV2Parser.SemanticProposalRadiusInvalid)]
    [InlineData("proposes hole<shaft> { on: importedPart.face(\"#999999\") radius: 1mm end: throughAll }", FirmamentV2Parser.SemanticProposalTargetUnresolved)]
    [InlineData("proposes hole<shaft> { radius: 1mm end: blind }", FirmamentV2Parser.SemanticProposalEndUnsupported)]
    public void InlineStep_InvalidEvidenceOrProposal_RejectsDeterministically(string metadata, string diagnostic)
    {
        var source = $$"""
model BadRecognitionProposal { units mm solid importedPart: InlineStep { path: "../../../../testdata/firmament/inline-step/canonical-through-hole.step" } recognize importedPart { region mountHole { kind: hole<shaft> faces: ["#191"] confidence: high {{metadata}} } } }
""";
        var parse = FirmamentV2Parser.Parse(source, Path.Combine(FindRepoRoot(), "fixtures/Regression/InlineStep/valid"));

        Assert.False(parse.IsSuccess);
        Assert.Contains(diagnostic, parse.Diagnostics);
    }



    [Fact]
    public void InlineStep_ReplacementAssist_ReadyHoleProposalProducesStableReplacementText()
    {
        var parse = ParseRecognizedHoleProposalFixture();
        var report = InlineStepReplacementAssistReportBuilder.Build(parse.Document!);

        Assert.Equal(1, report.ReadyCount);
        Assert.Equal(0, report.BlockedCount);
        var assist = Assert.Single(report.Assists);
        Assert.True(assist.ReplacementReady);
        Assert.Equal("holeShaft", assist.ProposalKind);
        Assert.NotNull(assist.SuggestedReplacementModel);
        Assert.Equal("replace importedPart.region(\"mountHole\") with hole<shaft> mountHole {" + Environment.NewLine +
            "    on: importedPart.face(\"#51\")" + Environment.NewLine +
            "    center: [0mm, 0mm]" + Environment.NewLine +
            "    radius: 1mm" + Environment.NewLine +
            "    end: throughAll" + Environment.NewLine +
            "}", assist.SuggestedReplacementText);
        Assert.Empty(parse.Document!.Replacements!);
    }

    [Theory]
    [InlineData("datumPlane", "holeShaft", InlineStepReplacementAssistReportBuilder.RegionProposalKindMismatch)]
    [InlineData("datumPlane", "datumPlane", InlineStepReplacementAssistReportBuilder.UnsupportedProposalKind)]
    public void InlineStep_ReplacementAssist_BlocksKindIncompatibility(string regionKind, string proposalKind, string reason)
    {
        var document = ReplacementAssistDocument(regionKind: regionKind, proposalKind: proposalKind);
        var assist = Assert.Single(InlineStepReplacementAssistReportBuilder.Build(document).Assists);
        Assert.False(assist.ReplacementReady);
        Assert.Contains(reason, assist.Reasons);
    }

    [Theory]
    [InlineData(null, InlineStepReplacementAssistReportBuilder.MissingPlacementTarget)]
    [InlineData("importedPart.face(\"#999999\")", InlineStepReplacementAssistReportBuilder.UnresolvedPlacementTarget)]
    public void InlineStep_ReplacementAssist_BlocksMissingOrUnresolvedPlacementFace(string? target, string reason)
    {
        var document = ReplacementAssistDocument(placementTarget: target);
        var assist = Assert.Single(InlineStepReplacementAssistReportBuilder.Build(document).Assists);
        Assert.False(assist.ReplacementReady);
        Assert.Contains(reason, assist.Reasons);
    }

    [Theory]
    [InlineData(0d, InlineStepReplacementAssistReportBuilder.InvalidRadius)]
    [InlineData(-1d, InlineStepReplacementAssistReportBuilder.InvalidRadius)]
    public void InlineStep_ReplacementAssist_BlocksInvalidRadius(double radius, string reason)
    {
        var document = ReplacementAssistDocument(radius: radius);
        var assist = Assert.Single(InlineStepReplacementAssistReportBuilder.Build(document).Assists);
        Assert.False(assist.ReplacementReady);
        Assert.Contains(reason, assist.Reasons);
    }

    [Fact]
    public void InlineStep_ReplacementAssist_BlocksUnsupportedEndCondition()
    {
        var assist = Assert.Single(InlineStepReplacementAssistReportBuilder.Build(ReplacementAssistDocument(endCondition: "blind")).Assists);
        Assert.False(assist.ReplacementReady);
        Assert.Contains(InlineStepReplacementAssistReportBuilder.UnsupportedEndCondition, assist.Reasons);
    }

    [Theory]
    [InlineData(false, "cylindrical", 1d, InlineStepReplacementAssistReportBuilder.EvidenceThroughFalse)]
    [InlineData(true, "planar", 1d, InlineStepReplacementAssistReportBuilder.EvidenceSurfaceNotCylindrical)]
    [InlineData(true, "cylindrical", 2d, InlineStepReplacementAssistReportBuilder.EvidenceRadiusMismatch)]
    public void InlineStep_ReplacementAssist_BlocksEvidenceIncompatibility(bool through, string surfaceFamily, double evidenceRadius, string reason)
    {
        var document = ReplacementAssistDocument(evidenceThrough: through, surfaceFamily: surfaceFamily, evidenceRadius: evidenceRadius);
        var assist = Assert.Single(InlineStepReplacementAssistReportBuilder.Build(document).Assists);
        Assert.False(assist.ReplacementReady);
        Assert.Contains(reason, assist.Reasons);
    }

    private static FirmamentV2ParseResult ParseRecognizedHoleProposalFixture()
    {
        var repo = FindRepoRoot();
        var fixturePath = Path.Combine(repo, "fixtures/Regression/InlineStep/valid/inline-step-v2-recognized-hole-proposal-report.valid.firmfixture");
        var parse = FirmamentV2Parser.Parse(File.ReadAllText(fixturePath), Path.GetDirectoryName(fixturePath));
        Assert.True(parse.IsSuccess, string.Join(Environment.NewLine, parse.Diagnostics));
        return parse;
    }

    private static FirmamentV2Document ReplacementAssistDocument(
        string regionKind = "holeShaft",
        string proposalKind = "holeShaft",
        string? placementTarget = "importedPart.face(\"#51\")",
        double radius = 1d,
        string endCondition = "throughAll",
        bool evidenceThrough = true,
        string surfaceFamily = "cylindrical",
        double evidenceRadius = 1d)
    {
        var map = new ImportedStepTopologyMap(new Dictionary<string, string> { ["#51"] = "face-51", ["#191"] = "face-191" }, new Dictionary<string, string>());
        var solid = new FirmamentV2SolidBinding("importedPart", "InlineStep", new FirmamentV2InlineStepRecord("canonical.step", "canonical.step", "hash", true, "canonical", map));
        var evidence = new FirmamentV2RecognitionEvidence([surfaceFamily], evidenceRadius, "+Z", null, evidenceThrough);
        var proposal = new FirmamentV2SemanticProposal(proposalKind, "mountHole", placementTarget, new FirmamentV2FaceLocalPoint2D(0d, 0d, FirmamentV2FaceLocalPoint2D.PlusZConvention), radius, endCondition);
        var region = new FirmamentV2RecognizedRegion("importedPart", "mountHole", regionKind, ["#191"], "high", evidence, proposal);
        return new FirmamentV2Document("AssistProbe", "mm", [solid], RecognizedRegions: [region], Replacements: []);
    }

    [Fact]
    public void InlineStep_ReplacementDeclaration_ParsesAndReferencesRecognizedRegion()
    {
        var repo = FindRepoRoot();
        var fixturePath = Path.Combine(repo, "fixtures/Regression/InlineStep/valid/inline-step-v2-replace-through-hole-step-verified.valid.firmfixture");
        var parse = FirmamentV2Parser.Parse(File.ReadAllText(fixturePath), Path.GetDirectoryName(fixturePath));

        Assert.True(parse.IsSuccess, string.Join(Environment.NewLine, parse.Diagnostics));
        var replacement = Assert.Single(parse.Document!.Replacements!);
        Assert.Equal("importedPart", replacement.ImportedBodyName);
        Assert.Equal("mountHole", replacement.RecognizedRegionName);
        Assert.Equal("holeShaft", replacement.ReplacementKind);
        Assert.Equal(1d, replacement.Radius);
        Assert.Equal("throughAll", replacement.EndCondition);
        Assert.Equal("importedPart.region(\"mountHole\")", replacement.TargetSource);
    }

    [Theory]
    [InlineData("replace missingPart.region(\"mountHole\") with hole<shaft> mountHole { on: importedPart.face(\"#191\") center: [0,0] radius: 1 end: throughAll hostSize: [10,8,6] }", FirmamentV2Parser.UnknownReplacementBody)]
    [InlineData("replace importedPart.region(\"missing\") with hole<shaft> mountHole { on: importedPart.face(\"#191\") center: [0,0] radius: 1 end: throughAll hostSize: [10,8,6] }", FirmamentV2Parser.UnknownReplacementRegion)]
    [InlineData("recognize importedPart { region mountHole { kind: datumPlane faces: [\"#191\"] confidence: high } } replace importedPart.region(\"mountHole\") with hole<shaft> mountHole { on: importedPart.face(\"#191\") center: [0,0] radius: 1 end: throughAll hostSize: [10,8,6] }", FirmamentV2Parser.ReplacementKindMismatch)]
    [InlineData("replace importedPart.region(\"mountHole\") with counterbore mountHole { on: importedPart.face(\"#191\") center: [0,0] radius: 1 end: throughAll hostSize: [10,8,6] }", FirmamentV2Parser.ReplacementUnsupportedKind)]
    [InlineData("replace importedPart.region(\"mountHole\") with hole<shaft> mountHole { on: importedPart.face(\"#999999\") center: [0,0] radius: 1 end: throughAll hostSize: [10,8,6] }", FirmamentV2Parser.ReplacementFaceUnresolved)]
    [InlineData("replace importedPart.region(\"mountHole\") with hole<shaft> mountHole { on: importedPart.face(\"#191\") center: [0,0] radius: -1 end: throughAll hostSize: [10,8,6] }", FirmamentV2Parser.ReplacementRadiusInvalid)]
    [InlineData("replace importedPart.region(\"mountHole\") with hole<shaft> mountHole { on: importedPart.face(\"#191\") center: [0,0] radius: 1 end: depth 2 hostSize: [10,8,6] }", FirmamentV2Parser.ReplacementEndUnsupported)]
    public void InlineStep_InvalidReplacement_RejectsDeterministically(string tail, string diagnostic)
    {
        var recognition = tail.Contains("recognize importedPart", StringComparison.Ordinal) ? string.Empty : "recognize importedPart { region mountHole { kind: holeShaft faces: [\"#191\"] confidence: high } }";
        var source = $$"""
model BadReplacement { units mm solid importedPart: InlineStep { path: "../../../../testdata/firmament/inline-step/canonical-through-hole.step" } {{recognition}} {{tail}} }
""";
        var parse = FirmamentV2Parser.Parse(source, Path.Combine(FindRepoRoot(), "fixtures/Regression/InlineStep/valid"));

        Assert.False(parse.IsSuccess);
        Assert.Contains(diagnostic, parse.Diagnostics);
    }

    [Fact]
    public void InlineStep_ReplacementFixture_ExportsReimportsAndKeepsSingleThroughHoleVolume()
    {
        var repo = FindRepoRoot();
        var fixturePath = Path.Combine(repo, "fixtures/Regression/InlineStep/valid/inline-step-v2-replace-through-hole-step-verified.valid.firmfixture");
        var outputPath = Path.Combine(Path.GetTempPath(), $"aetheris-inline-step-x4-{Guid.NewGuid():N}.step");
        try
        {
            var result = FirmamentBuildAndExport.Run(fixturePath, outputPath);
            Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => $"{d.Source}: {d.Message}")));
            Assert.Equal("inline-step-replacement", result.Value.Export.ExportedBodyCategory);
            var output = File.ReadAllText(outputPath);
            Assert.Contains("ADVANCED_FACE", output, StringComparison.Ordinal);
            Assert.DoesNotContain("trace-only", output, StringComparison.OrdinalIgnoreCase);
            var import = Step242Importer.ImportBody(output);
            Assert.True(import.IsSuccess, string.Join(Environment.NewLine, import.Diagnostics.Select(d => $"{d.Source}: {d.Message}")));
            Assert.Equal(1, import.Value.Geometry.Surfaces.Count(entry => entry.Value.Kind.ToString() == "Cylinder"));
        }
        finally
        {
            if (File.Exists(outputPath)) File.Delete(outputPath);
        }
    }

    [Fact]
    public void InlineStep_MigrationReport_RecognizedOnlyCountsResidualCoverage()
    {
        var repo = FindRepoRoot();
        var fixturePath = Path.Combine(repo, "fixtures/Regression/InlineStep/valid/inline-step-v2-recognized-face-datum-pmi-emits-in-step.valid.firmfixture");
        var parse = FirmamentV2Parser.Parse(File.ReadAllText(fixturePath), Path.GetDirectoryName(fixturePath));
        Assert.True(parse.IsSuccess, string.Join(Environment.NewLine, parse.Diagnostics));

        var report = InlineStepMigrationReportBuilder.Build(parse.Document!, parse.Document!.Solids.Single());

        Assert.Equal("importedPart", report.ImportedBodyName);
        Assert.Equal(6, report.OriginalTopology.FaceCount);
        Assert.Equal(1, report.Recognized.RegionCount);
        Assert.Equal(1, report.Recognized.ReferencedFaceCount);
        Assert.Equal(0, report.Replacements.ReplacedFaceCount);
        Assert.Equal(report.OriginalTopology.FaceCount, report.Residual.ResidualFaceCount);
        Assert.Equal(1d / 6d, report.Coverage.RecognizedFaceRatio, precision: 12);
        Assert.Equal(0d, report.Coverage.ReplacedFaceRatio);
        Assert.Contains("recognized", report.ReplacementStates);
        Assert.Contains("residual-emitted", report.ReplacementStates);
    }

    [Fact]
    public void InlineStep_MigrationReport_RecognizedProposalCountsDoNotReplace()
    {
        var repo = FindRepoRoot();
        var fixturePath = Path.Combine(repo, "fixtures/Regression/InlineStep/valid/inline-step-v2-recognized-hole-proposal-report.valid.firmfixture");
        var parse = FirmamentV2Parser.Parse(File.ReadAllText(fixturePath), Path.GetDirectoryName(fixturePath));
        Assert.True(parse.IsSuccess, string.Join(Environment.NewLine, parse.Diagnostics));

        var report = InlineStepMigrationReportBuilder.Build(parse.Document!, parse.Document!.Solids.Single());

        Assert.Equal(7, report.OriginalTopology.FaceCount);
        Assert.Equal(1, report.Recognized.RegionCount);
        Assert.Equal(1, report.Recognized.EvidenceCount);
        Assert.Equal(1, report.Recognized.ProposalCount);
        Assert.Equal(0, report.Recognized.ProposalVerifiedCount);
        Assert.Equal(1, report.Recognized.ProposalUnverifiedCount);
        Assert.Equal(0, report.Replacements.PlannedCount);
        Assert.Equal(0, report.Replacements.VerifiedCount);
        Assert.Equal(0, report.Replacements.EmittedCount);
        Assert.Equal(7, report.Residual.ResidualFaceCount);
        Assert.Equal("canonical-reexport", report.EmissionStrategy);
        Assert.False(report.ResidualSurgery);
    }

    [Fact]
    public void InlineStep_MigrationReport_VerifiedReplacementCountsReplacedFaces()
    {
        var repo = FindRepoRoot();
        var fixturePath = Path.Combine(repo, "fixtures/Regression/InlineStep/valid/inline-step-v2-replace-through-hole-step-verified.valid.firmfixture");
        var parse = FirmamentV2Parser.Parse(File.ReadAllText(fixturePath), Path.GetDirectoryName(fixturePath));
        Assert.True(parse.IsSuccess, string.Join(Environment.NewLine, parse.Diagnostics));

        var report = InlineStepMigrationReportBuilder.Build(parse.Document!, parse.Document!.Solids.Single(), replacementsVerified: true, replacementsEmitted: true, emissionStrategy: "holeShaft-bounded-rebuild");

        Assert.Equal(7, report.OriginalTopology.FaceCount);
        Assert.Equal(1, report.Recognized.RegionCount);
        Assert.Equal(1, report.Replacements.PlannedCount);
        Assert.Equal(1, report.Replacements.VerifiedCount);
        Assert.Equal(1, report.Replacements.EmittedCount);
        Assert.Equal(1, report.Replacements.ReplacedFaceCount);
        Assert.Equal(6, report.Residual.ResidualFaceCount);
        Assert.Equal("holeShaft-bounded-rebuild", report.EmissionStrategy);
        Assert.False(report.ResidualSurgery);
        Assert.Contains("hybrid-step-verified", report.ReplacementStates);
    }

    [Fact]
    public void InlineStep_MigrationReport_DuplicateAndUnresolvedFacesAreDeterministic()
    {
        var map = new ImportedStepTopologyMap(new Dictionary<string, string>(StringComparer.Ordinal) { ["#1"] = "f1", ["#2"] = "f2" }, new Dictionary<string, string>(StringComparer.Ordinal));
        var inlineStep = new FirmamentV2InlineStepRecord("part.step", "/tmp/part.step", "hash", true, "Aetheris-canonical", map);
        var solid = new FirmamentV2SolidBinding("importedPart", "InlineStep", inlineStep);
        var document = new FirmamentV2Document("MigrationProbe", "mm", [solid], RecognizedRegions: [
            new FirmamentV2RecognizedRegion("importedPart", "a", "holeShaft", ["#1", "#1"], "high"),
            new FirmamentV2RecognizedRegion("importedPart", "b", "holeShaft", ["#2", "#999"], "high")]);

        var report = InlineStepMigrationReportBuilder.Build(document, solid);

        Assert.Equal(2, report.OriginalTopology.FaceCount);
        Assert.Equal(2, report.Recognized.RegionCount);
        Assert.Equal(2, report.Recognized.ReferencedFaceCount);
        Assert.Equal(1, report.Recognized.DuplicateReferencedFaceCount);
        Assert.Equal(1, report.Recognized.UnresolvedReferenceCount);
        Assert.Equal(1d, report.Coverage.RecognizedFaceRatio);
        Assert.Contains("inline-step-migration-duplicate-face-reference:#1", report.Diagnostics);
        Assert.Contains("inline-step-migration-unresolved-face:#999", report.Diagnostics);
    }

    [Fact]
    public void InlineStep_NonCanonicalStep_IsRejectedWithDeterministicDiagnostic()
    {
        var source = """
model BadInlineStep {
    units mm

    solid importedPart: InlineStep {
        path: "../../../../testdata/step242/generated/v0-required/gen_box_v0.step"
    }
}
""";

        var parse = FirmamentV2Parser.Parse(source, Path.Combine(FindRepoRoot(), "fixtures/Regression/InlineStep/valid"));

        Assert.False(parse.IsSuccess);
        Assert.Contains(FirmamentV2Parser.InlineStepRequiresCanonical, parse.Diagnostics);
    }

    private static string FindRepoRoot()
    {
        var dir = new DirectoryInfo(AppContext.BaseDirectory);
        while (dir is not null && !File.Exists(Path.Combine(dir.FullName, "Aetheris.slnx"))) dir = dir.Parent;
        return dir?.FullName ?? throw new InvalidOperationException("Could not locate repository root.");
    }

    private static int Count(string text, string needle) => text.Split(needle, StringSplitOptions.None).Length - 1;

    private static double ComputeBoxVolume(Aetheris.Kernel.Core.Brep.BrepBody body)
    {
        var points = body.Topology.Vertices.Select(v => body.TryGetVertexPoint(v.Id, out var p) ? p : throw new InvalidOperationException("Missing vertex point.")).ToArray();
        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);
        return (maxX - minX) * (maxY - minY) * (maxZ - minZ);
    }
}