Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

74.2 KB
Raw Blame
using Aetheris.Kernel.Core.Air;
using Aetheris.Kernel.Firmament;
using Aetheris.Kernel.Firmament.FirmamentV2;

namespace Aetheris.Kernel.Firmament.Tests;

public sealed class FirmamentV2ParserTests
{
    [Fact]
    public void FirmamentV2Parser_Box_ParsesModelUnitsAndSolid()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/Primitive/valid/box-v2.valid.firmfixture"));
        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        Assert.NotNull(result.Document);
        var document = result.Document!;
        Assert.Equal("BoxExample", document.ModelName);
        Assert.Equal("mm", document.Units);
        Assert.Equal("base", document.Solid.Name);
        Assert.Equal("Box", document.Solid.RecordType);
        Assert.Equal([10, 8, 6], Box(document.Solid).Size);
    }

    [Fact]
    public void FirmamentV2Parser_Box_LowersToFeatureAir()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/Primitive/valid/box-v2.valid.firmfixture"));
        Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
        Assert.Equal("FirmamentV2Parser", result.ParserName);
        Assert.Equal("feature-air", result.FrontendStageReached);
        Assert.NotNull(result.FeatureAir);
        Assert.Equal("CreateBox", result.FeatureAir!.FeatureAirNodeKind);
        Assert.Null(result.ConstructiveAir);
    }

    [Fact]
    public void FirmamentV2Parser_MissingUnits_IsDiagnostic()
    {
        var result = FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Primitive/box-v2-missing-units.invalid.firmfixture"));
        Assert.False(result.IsSuccess);
        Assert.Contains(FirmamentV2Parser.MissingUnits, result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_NegativeSize_IsDegenerateDimension()
    {
        var result = FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Primitive/box-v2-negative-size.invalid.firmfixture"));
        Assert.False(result.IsSuccess);
        Assert.Contains(FirmamentV2Parser.DegenerateDimension, result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_UnknownRecord_IsDiagnostic()
    {
        var result = FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Primitive/box-v2-unknown-record.invalid.firmfixture"));
        Assert.False(result.IsSuccess);
        Assert.Contains(FirmamentV2Parser.UnknownRecordType, result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_DoesNotUseV1Parser()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/Primitive/valid/box-v2.valid.firmfixture"));
        Assert.Equal("FirmamentV2Parser", result.ParserName);
        Assert.Contains("firmament-v2-no-v1-parser", result.Diagnostics);
        Assert.DoesNotContain(result.Diagnostics, d => d.Contains("FirmamentTopLevelParser", StringComparison.Ordinal));
    }

    [Fact]
    public void FirmamentV2Parser_WithBox_ParsesBaseAndDerivedSolid()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/RecordDerivation/valid/box-with-size-variant-v2.valid.firmfixture"));
        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var document = result.Document!;
        Assert.Equal("BoxVariant", document.ModelName);
        Assert.Equal("mm", document.Units);
        Assert.Equal(2, document.Solids.Count);
        Assert.Equal("base", document.Solids[0].Name);
        Assert.Equal("Box", document.Solids[0].RecordType);
        Assert.Equal([10, 8, 6], Box(document.Solids[0]).Size);
        Assert.Equal("tall", document.Solids[1].Name);
        Assert.Equal("base", document.Solids[1].DerivedFrom);
        Assert.Equal([10, 8, 12], document.Solids[1].Overrides!["size"]);
    }

    [Fact]
    public void FirmamentV2Parser_WithBox_LowersDerivedToFeatureAir()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/RecordDerivation/valid/box-with-size-variant-v2.valid.firmfixture"));
        Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
        Assert.Equal("FirmamentV2Parser", result.ParserName);
        Assert.Equal("CreateBox", result.FeatureAir!.FeatureAirNodeKind);
        Assert.Equal(10, result.FeatureAir.SourceDimensions!.Width);
        Assert.Equal(8, result.FeatureAir.SourceDimensions.Depth);
        Assert.Equal(12, result.FeatureAir.SourceDimensions.Height);
        Assert.Equal("tall", result.FirmamentV2!.SolidName);
    }

    [Fact]
    public void FirmamentV2Parser_WithBox_BaseRemainsUnchanged()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/RecordDerivation/valid/box-with-size-variant-v2.valid.firmfixture"));
        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var document = Assert.IsType<FirmamentV2Document>(result.Document);
        Assert.Equal([10, 8, 6], Box(document.Solids.Single(s => s.Name == "base")).Size);
        Assert.Equal([10, 8, 12], Box(document.Solids.Single(s => s.Name == "tall")).Size);
    }


    [Fact]
    public void FirmamentV2Parser_WithBox_ChainedTwiceLowersWithoutStaleDimensions()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/RecordDerivation/valid/derivation-v2-with-chained-twice-step-verified.valid.firmfixture"));
        Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
        Assert.Equal("CreateBox", result.FeatureAir!.FeatureAirNodeKind);
        Assert.Equal(12, result.FeatureAir.SourceDimensions!.Width);
        Assert.Equal(8, result.FeatureAir.SourceDimensions.Depth);
        Assert.Equal(7, result.FeatureAir.SourceDimensions.Height);
        Assert.Equal("taller", result.FirmamentV2!.SolidName);

        var parse = FirmamentV2Parser.Parse(Source("Regression/RecordDerivation/valid/derivation-v2-with-chained-twice-step-verified.valid.firmfixture"));
        Assert.True(parse.IsSuccess, string.Join(", ", parse.Diagnostics));
        Assert.Equal([10, 8, 6], parse.Document!.Solids.Single(s => s.Name == "base").Box!.Size);
        Assert.Equal([12, 8, 6], parse.Document.Solids.Single(s => s.Name == "wider").Box!.Size);
        Assert.Equal([12, 8, 7], parse.Document.Solids.Single(s => s.Name == "taller").Box!.Size);
    }


    [Fact]
    public void FirmamentV2Parser_CompositeMultipleHoles_ParseAndLowerAsDistinctAirHoleFeatures()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/Composite/valid/composite-v2-two-independent-holes-step-verified.valid.firmfixture"));
        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var holes = Assert.Single(result.Document!.ModifyBlocks!).SemanticHoles;
        Assert.Equal(["leftMount", "rightMount"], holes.Select(h => h.Name).ToArray());
        Assert.All(holes, h => Assert.Equal(FirmamentV2SemanticHoleVariant.Shaft, h.Variant));

        var lowered = FirmamentV2SemanticHoleLowering.LowerSemanticHoles(result.Document);
        Assert.Equal(2, lowered.Count);
        Assert.Equal(["base.leftMount", "base.rightMount"], lowered.Select(h => h.FeatureId).ToArray());
        Assert.All(lowered, h => Assert.Equal(AirHoleStackKind.SimpleShaft, h.Stack.Kind));
    }
    [Fact]
    public void FirmamentV2Parser_DerivedCompositeHole_LowersSelectedDerivedSolidAndAirHoleFeature()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/Composite/valid/composite-v2-hole-plus-derived-variant-step-verified.valid.firmfixture"));
        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var document = result.Document!;
        Assert.Equal([10, 8, 6], document.Solids.Single(s => s.Name == "base").Box!.Size);
        Assert.Equal([12, 8, 6], document.Solids.Single(s => s.Name == "wider").Box!.Size);
        Assert.Equal("wider", document.Solid.Name);

        var modify = Assert.Single(document.ModifyBlocks!);
        Assert.Equal("wider", modify.TargetSolid);
        var hole = Assert.Single(modify.SemanticHoles);
        Assert.Equal(FirmamentV2SemanticHoleVariant.Shaft, hole.Variant);
        Assert.Equal(2, hole.ShaftDiameter);

        var lowered = Assert.Single(FirmamentV2SemanticHoleLowering.LowerSemanticHoles(document));
        Assert.Equal("wider.mount", lowered.FeatureId);
        Assert.Equal("wider", lowered.TargetBodyId);
        Assert.Equal(AirHoleStackKind.SimpleShaft, lowered.Stack.Kind);
        Assert.Equal(nameof(AirHoleFeature), lowered.Provenance.RouteName);
        Assert.Contains("target-solid:wider", lowered.Provenance.Notes);
    }


    [Fact]
    public void FirmamentV2Parser_SemanticFaceAlias_ResolvesBeforeHoleLowering()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/SemanticRefs/valid/semanticref-v2-expose-face-alias-resolves-in-step.valid.firmfixture"));
        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var hole = Assert.Single(Assert.Single(result.Document!.ModifyBlocks!).SemanticHoles);
        Assert.Equal("top", hole.EntryFace.Source);
        Assert.Equal("Alias", hole.EntryFace.Kind);
        Assert.Equal("+Z", hole.EntryFace.Axis);
        Assert.Equal("face(+Z)", hole.EntryFace.ResolvedSelector);
        Assert.Equal(FirmamentV2SemanticHoleVariant.Shaft, hole.Variant);
    }

    [Fact]
    public void FirmamentV2Parser_SemanticFaceAliasFailure_IsDeterministicDiagnostic()
    {
        const string source = """
model AliasFailure {
    units mm
    solid base: Box {
        size: [10, 8, 6]
        expose { face(+Z) => top }
    }
    modify base {
        hole<shaft> mount {
            on: missingAlias
            center: [0, 0]
            diameter: 2
            end: throughAll
        }
    }
}
""";
        var result = FirmamentV2Parser.Parse(source);
        Assert.False(result.IsSuccess);
        Assert.Contains(FirmamentV2Parser.AliasUnresolved, result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_WithBox_DegenerateDerivedSize_IsDiagnostic()
    {
        var result = FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/RecordDerivation/with-degenerate-box-v2.invalid.firmfixture"));
        Assert.False(result.IsSuccess);
        Assert.Contains(FirmamentV2Parser.DegenerateDimension, result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_WithBox_UnknownField_IsDiagnostic()
    {
        var result = FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/RecordDerivation/with-unknown-field-v2.invalid.firmfixture"));
        Assert.False(result.IsSuccess);
        Assert.Contains(FirmamentV2Parser.WithFieldNotFound, result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_WithBox_UndefinedBase_IsDiagnostic()
    {
        var result = FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/RecordDerivation/with-undefined-base-v2.invalid.firmfixture"));
        Assert.False(result.IsSuccess);
        Assert.Contains(FirmamentV2Parser.NameUnresolved, result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_WithBox_DuplicateName_IsDiagnostic()
    {
        var result = FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/RecordDerivation/with-duplicate-solid-name-v2.invalid.firmfixture"));
        Assert.False(result.IsSuccess);
        Assert.Contains(FirmamentV2Parser.DuplicateName, result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_WithBox_DoesNotUseV1Parser()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/RecordDerivation/valid/box-with-size-variant-v2.valid.firmfixture"));
        Assert.Equal("FirmamentV2Parser", result.ParserName);
        Assert.Contains("firmament-v2-no-v1-parser", result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_ExposeBoxFaces_ParsesAliases()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/SemanticRefs/valid/named-box-faces-v2.valid.firmfixture"));
        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var exposures = Box(Assert.IsType<FirmamentV2Document>(result.Document).Solid).Exposures;
        Assert.Equal(4, exposures.Count);
        Assert.Equal(["top", "bottom", "right", "topRim"], exposures.Select(e => e.Alias).ToArray());
        Assert.Equal("FaceRef", exposures.Single(e => e.Alias == "top").RefType);
        Assert.Equal("LoopRef", exposures.Single(e => e.Alias == "topRim").RefType);
    }

    [Fact]
    public void FirmamentV2Parser_ExposeBoxFaces_LowersBoxToFeatureAir()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/SemanticRefs/valid/named-box-faces-v2.valid.firmfixture"));
        Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
        Assert.Equal("CreateBox", result.FeatureAir!.FeatureAirNodeKind);
        Assert.Equal(10, result.FeatureAir.SourceDimensions!.Width);
        Assert.Equal(8, result.FeatureAir.SourceDimensions.Depth);
        Assert.Equal(6, result.FeatureAir.SourceDimensions.Height);
        Assert.Equal(4, result.FirmamentV2!.Solids.Single().Exposures.Count);
    }

    [Fact]
    public void FirmamentV2Parser_ExposeBoxFaces_Diagnostics()
    {
        Assert.Contains(FirmamentV2Parser.ExposeAliasDuplicate, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/SemanticRefs/duplicate-expose-alias-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SelectorAxisInvalid, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/SemanticRefs/invalid-face-axis-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.RawBackendIdReferenceForbidden, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/SemanticRefs/raw-brep-id-reference-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.FatArrowOutsideExpose, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/SemanticRefs/fat-arrow-outside-expose-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SelectorUnsupported, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/SemanticRefs/unsupported-selector-edge-v2.invalid.firmfixture")).Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_ExposeBoxFaces_DoesNotUseV1Parser()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/SemanticRefs/valid/named-box-faces-v2.valid.firmfixture"));
        Assert.Equal("FirmamentV2Parser", result.ParserName);
        Assert.Contains("firmament-v2-no-v1-parser", result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_SideHole_ParsesRegionCutCylinder()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-v2.valid.firmfixture"));
        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var document = result.Document!;
        Assert.Equal("SideHoleV2", document.ModelName);
        Assert.Equal("mm", document.Units);
        Assert.Equal("base", document.Solid.Name);
        Assert.Equal([10, 8, 6], Box(document.Solid).Size);
        var modify = Assert.Single(document.ModifyBlocks!);
        Assert.Equal("base", modify.TargetSolid);
        var region = Assert.Single(modify.Regions);
        Assert.Equal("sideHole", region.Name);
        Assert.Equal("+X", region.Attachment.Axis);
        Assert.Equal("Cut", region.Cut.OperationKind);
        Assert.Equal("Cylinder", region.Cut.Tool.ToolType);
        Assert.Equal(1, region.Cut.Tool.Radius);
        Assert.Equal("-X", region.Cut.Tool.Through.Axis);
    }

    [Fact]
    public void FirmamentV2Parser_SideHole_ProducesSemanticIntent()
    {
        var intent = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-v2.valid.firmfixture")).Document!.SideHoleIntent;
        Assert.NotNull(intent);
        Assert.Equal("base", intent!.TargetSolid);
        Assert.Equal("sideHole", intent.RegionName);
        Assert.Equal("+X", intent.AttachFace);
        Assert.Equal("-X", intent.ThroughFace);
        Assert.Equal("Cylinder", intent.Tool);
        Assert.Equal(1, intent.Radius);
        Assert.Equal("mm", intent.Units);
    }

    [Fact]
    public void FirmamentV2Parser_SideHole_LoweringOutcomeIsTruthful()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/Region/valid/side-hole-v2.valid.firmfixture"));
        Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
        Assert.Equal("region-parent-integrated", result.FrontendStageReached);
        Assert.NotNull(result.FirmamentV2!.SemanticIntent);
        Assert.Null(result.FirmamentV2.Blocker);
    }

    [Fact]
    public void FirmamentV2Parser_SideHole_GoldenPathIfReached()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/Region/valid/side-hole-v2.valid.firmfixture"));
        Assert.Equal("Integrated", result.FirmamentV2!.ParentIntegration);
        Assert.Equal("Closed", result.FirmamentV2.ShellClosure);
        Assert.Equal("Succeeded", result.FirmamentV2.StepSmoke);
    }



    [Fact]
    public void FirmamentV2SideHoleCenter_ParsesCenterOffsets()
    {
        foreach (var (fixture, u, v) in new[] { ("Regression/Region/valid/side-hole-center-y1-v2.valid.firmfixture", 1d, 0d), ("Regression/Region/valid/side-hole-center-z1-v2.valid.firmfixture", 0d, 1d), ("Regression/Region/valid/side-hole-center-y1-z1-v2.valid.firmfixture", 1d, 1d) })
        {
            var intent = FirmamentV2Parser.Parse(Source(fixture)).Document!.SideHoleIntent!;
            Assert.Equal(u, intent.CenterU);
            Assert.Equal(v, intent.CenterV);
            Assert.True(intent.CenterExplicit);
            Assert.Equal("face(+X):u=+Y,v=+Z", intent.CenterSelectorFrame);
        }
    }

    [Fact]
    public void FirmamentV2SideHoleCenter_DefaultsToZeroWhenOmitted()
    {
        var intent = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-v2.valid.firmfixture")).Document!.SideHoleIntent!;
        Assert.Equal(0, intent.CenterU);
        Assert.Equal(0, intent.CenterV);
        Assert.False(intent.CenterExplicit);
    }

    [Fact]
    public void FirmamentV2SideHoleCenter_ValidOffsetsReachGoldenPath()
    {
        foreach (var fixture in new[] { "Regression/Region/valid/side-hole-center-y1-v2.valid.firmfixture", "Regression/Region/valid/side-hole-center-z1-v2.valid.firmfixture", "Regression/Region/valid/side-hole-center-y1-z1-v2.valid.firmfixture" })
        {
            var result = FirmamentFrontendTraceProbe.ParseV2Only(Source(fixture));
            Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
            Assert.Equal("region-parent-integrated", result.FirmamentV2!.StageReached);
            Assert.Equal("Integrated", result.FirmamentV2.ParentIntegration);
            Assert.Equal("Closed", result.FirmamentV2.ShellClosure);
            Assert.Equal("Succeeded", result.FirmamentV2.StepSmoke);
            Assert.Null(result.FirmamentV2.Blocker);
        }
    }

    [Fact]
    public void FirmamentV2SideHoleCenter_InvalidDiagnostics()
    {
        Assert.Contains(FirmamentV2Parser.SideHoleCenterExceedsClearance, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-center-y-boundary-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleCenterExceedsClearance, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-center-z-boundary-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.CylinderCenterArityInvalid, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-center-arity-one-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.CylinderCenterArityInvalid, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-center-arity-three-v2.invalid.firmfixture")).Diagnostics);
    }

    [Fact]
    public void FirmamentV2SideHoleRadius_ParsesRadiusVariations()
    {
        Assert.Equal(0.5, FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-radius-0_5-v2.valid.firmfixture")).Document!.SideHoleIntent!.Radius);
        Assert.Equal(1.5, FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-radius-1_5-v2.valid.firmfixture")).Document!.SideHoleIntent!.Radius);
    }

    [Fact]
    public void FirmamentV2SideHoleRadius_ValidVariationsReachGoldenPath()
    {
        foreach (var fixture in new[] { "Regression/Region/valid/side-hole-radius-0_5-v2.valid.firmfixture", "Regression/Region/valid/side-hole-radius-1_5-v2.valid.firmfixture" })
        {
            var result = FirmamentFrontendTraceProbe.ParseV2Only(Source(fixture));
            Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
            Assert.Equal("region-parent-integrated", result.FirmamentV2!.StageReached);
            Assert.Equal("Integrated", result.FirmamentV2.ParentIntegration);
            Assert.Equal("Closed", result.FirmamentV2.ShellClosure);
            Assert.Equal("Succeeded", result.FirmamentV2.StepSmoke);
            Assert.Null(result.FirmamentV2.Blocker);
        }
    }

    [Fact]
    public void FirmamentV2SideHoleRadius_InvalidRadiusDiagnostics()
    {
        Assert.Contains(FirmamentV2Parser.CylinderRadiusInvalid, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-radius-zero-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.CylinderRadiusInvalid, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-radius-negative-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleRadiusExceedsClearance, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-radius-too-large-v2.invalid.firmfixture")).Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_SideHole_InvalidAttachFaceDiagnostic()
    {
        Assert.Contains(FirmamentV2Parser.SideHoleOnlyPlusXMinusXSupported, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-invalid-attach-v2.invalid.firmfixture")).Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_SideHole_InvalidThroughFaceDiagnostic()
    {
        Assert.Contains(FirmamentV2Parser.SideHoleOnlyPlusXMinusXSupported, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-invalid-through-v2.invalid.firmfixture")).Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_SideHole_InvalidRadiusDiagnostic()
    {
        Assert.Contains(FirmamentV2Parser.CylinderRadiusInvalid, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-invalid-radius-v2.invalid.firmfixture")).Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_SideHole_UnknownModifyTargetDiagnostic()
    {
        Assert.Contains(FirmamentV2Parser.ModifyTargetUnresolved, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-unknown-modify-target-v2.invalid.firmfixture")).Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_SideHole_DoesNotUseV1Parser()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/Region/valid/side-hole-v2.valid.firmfixture"));
        Assert.Equal("FirmamentV2Parser", result.ParserName);
        Assert.Contains("firmament-v2-no-v1-parser", result.Diagnostics);
    }


    [Fact]
    public void FirmamentV2SideHoleReverseX_ParsesDirectReverseRoute()
    {
        var intent = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-reverse-x-v2.valid.firmfixture")).Document!.SideHoleIntent!;
        Assert.Equal("face(-X)", intent.AttachTargetSource);
        Assert.Equal("DirectSelector", intent.AttachTargetKind);
        Assert.Equal("-X", intent.AttachFace);
        Assert.Equal("face(+X)", intent.ThroughTargetSource);
        Assert.Equal("DirectSelector", intent.ThroughTargetKind);
        Assert.Equal("+X", intent.ThroughFace);
        Assert.Equal("-X->+X", intent.Route);
        Assert.Equal("face(-X):u=+Y,v=+Z", intent.CenterSelectorFrame);
    }

    [Fact]
    public void FirmamentV2SideHoleReverseX_DirectReachesGoldenPath()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/Region/valid/side-hole-reverse-x-v2.valid.firmfixture"));
        Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
        Assert.Equal("region-parent-integrated", result.FirmamentV2!.StageReached);
        Assert.Equal("Integrated", result.FirmamentV2.ParentIntegration);
        Assert.Equal("Closed", result.FirmamentV2.ShellClosure);
        Assert.Equal("Succeeded", result.FirmamentV2.StepSmoke);
        Assert.Null(result.FirmamentV2.Blocker);
    }

    [Fact]
    public void FirmamentV2SideHoleReverseX_ParsesAliasReverseRoute()
    {
        var doc = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-aliases-reverse-x-v2.valid.firmfixture")).Document!;
        Assert.Contains(Box(doc.Solid).Exposures, e => e.Alias == "left" && e.Selector == "face(-X)");
        Assert.Contains(Box(doc.Solid).Exposures, e => e.Alias == "right" && e.Selector == "face(+X)");
        var region = Assert.Single(Assert.Single(doc.ModifyBlocks!).Regions);
        Assert.Equal("left", region.Attachment.Source);
        Assert.Equal("face(-X)", region.Attachment.ResolvedSelector);
        Assert.Equal("right", region.Cut.Tool.Through.Source);
        Assert.Equal("face(+X)", region.Cut.Tool.Through.ResolvedSelector);
        Assert.Equal("-X->+X", doc.SideHoleIntent!.Route);
    }

    [Fact]
    public void FirmamentV2SideHoleReverseX_AliasReachesGoldenPath()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/Region/valid/side-hole-aliases-reverse-x-v2.valid.firmfixture"));
        Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
        Assert.Equal("region-parent-integrated", result.FirmamentV2!.StageReached);
        Assert.Equal("Integrated", result.FirmamentV2.ParentIntegration);
        Assert.Equal("Closed", result.FirmamentV2.ShellClosure);
        Assert.Equal("Succeeded", result.FirmamentV2.StepSmoke);
        Assert.Null(result.FirmamentV2.Blocker);
    }

    [Fact]
    public void FirmamentV2SideHoleReverseX_InvalidRoutesRejected()
    {
        Assert.Contains(FirmamentV2Parser.SideHoleSameFaceUnsupported, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-same-face-x-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleRouteUnsupported, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-mixed-axis-x-to-y-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleRouteUnsupported, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-mixed-axis-z-to-x-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleRouteUnsupported, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-alias-reverse-x-wrong-through-v2.invalid.firmfixture")).Diagnostics);
    }


    [Fact]
    public void FirmamentV2SideHoleAliases_ParsesExposeAndAliasTargets()
    {
        var doc = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-aliases-v2.valid.firmfixture")).Document!;
        Assert.Contains(Box(doc.Solid).Exposures, e => e.Alias == "right" && e.Selector == "face(+X)");
        Assert.Contains(Box(doc.Solid).Exposures, e => e.Alias == "left" && e.Selector == "face(-X)");
        var region = Assert.Single(Assert.Single(doc.ModifyBlocks!).Regions);
        Assert.Equal("right", region.Attachment.Source);
        Assert.Equal("Alias", region.Attachment.Kind);
        Assert.Equal("left", region.Cut.Tool.Through.Source);
        Assert.Equal("Alias", region.Cut.Tool.Through.Kind);
    }

    [Fact]
    public void FirmamentV2SideHoleAliases_ResolvesAliasesToFaceSelectors()
    {
        var region = Assert.Single(Assert.Single(FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-aliases-v2.valid.firmfixture")).Document!.ModifyBlocks!).Regions);
        Assert.Equal("face(+X)", region.Attachment.ResolvedSelector);
        Assert.Equal("+X", region.Attachment.Axis);
        Assert.Equal("FaceRef", region.Attachment.RefType);
        Assert.Equal("face(-X)", region.Cut.Tool.Through.ResolvedSelector);
        Assert.Equal("-X", region.Cut.Tool.Through.Axis);
        Assert.Equal("FaceRef", region.Cut.Tool.Through.RefType);
    }

    [Fact]
    public void FirmamentV2SideHoleAliases_ProducesSemanticIntent()
    {
        var intent = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-aliases-v2.valid.firmfixture")).Document!.SideHoleIntent!;
        Assert.Equal("right", intent.AttachTargetSource);
        Assert.Equal("Alias", intent.AttachTargetKind);
        Assert.Equal("+X", intent.AttachFace);
        Assert.Equal("left", intent.ThroughTargetSource);
        Assert.Equal("Alias", intent.ThroughTargetKind);
        Assert.Equal("-X", intent.ThroughFace);
        Assert.Equal(1, intent.Radius);
        Assert.Equal(1, intent.CenterU);
        Assert.Equal(0, intent.CenterV);
    }

    [Fact]
    public void FirmamentV2SideHoleAliases_ReachGoldenPath()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/Region/valid/side-hole-aliases-v2.valid.firmfixture"));
        Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
        Assert.Equal("region-parent-integrated", result.FirmamentV2!.StageReached);
        Assert.Equal("Integrated", result.FirmamentV2.ParentIntegration);
        Assert.Equal("Closed", result.FirmamentV2.ShellClosure);
        Assert.Equal("Succeeded", result.FirmamentV2.StepSmoke);
        Assert.Null(result.FirmamentV2.Blocker);
    }

    [Fact]
    public void FirmamentV2SideHoleAliases_InvalidDiagnostics()
    {
        Assert.Contains(FirmamentV2Parser.AliasUnresolved, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-alias-unknown-on-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.AliasUnresolved, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-alias-unknown-through-v2.invalid.firmfixture")).Diagnostics);
        var loopDiagnostics = FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-alias-loopref-on-v2.invalid.firmfixture")).Diagnostics;
        Assert.Contains(FirmamentV2Parser.SideHoleAliasMustResolveToFace, loopDiagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleAliasResolvesToUnsupportedFace, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-alias-wrong-face-v2.invalid.firmfixture")).Diagnostics);
    }

    [Fact]
    public void FirmamentV2SideHoleYAxis_ParsesDirectYRoute()
    {
        var intent = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-y-axis-v2.valid.firmfixture")).Document!.SideHoleIntent!;
        Assert.Equal("+Y", intent.AttachFace);
        Assert.Equal("-Y", intent.ThroughFace);
        Assert.Equal("+Y->-Y", intent.Route);
        Assert.Equal("Y", intent.RouteEvidence.Axis);
        Assert.Equal("face(+Y):u=+X,v=+Z", intent.CenterSelectorFrame);
    }

    [Fact]
    public void FirmamentV2SideHoleYAxis_DirectYReachesGoldenPath()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/Region/valid/side-hole-y-axis-v2.valid.firmfixture"));
        Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
        Assert.Equal("region-parent-integrated", result.FirmamentV2!.StageReached);
        Assert.Equal("Integrated", result.FirmamentV2.ParentIntegration);
        Assert.Equal("Closed", result.FirmamentV2.ShellClosure);
        Assert.Equal("Succeeded", result.FirmamentV2.StepSmoke);
        Assert.Null(result.FirmamentV2.Blocker);
    }

    [Fact]
    public void FirmamentV2SideHoleYAxis_ParsesReverseYRoute()
    {
        var intent = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-reverse-y-v2.valid.firmfixture")).Document!.SideHoleIntent!;
        Assert.Equal("-Y", intent.AttachFace);
        Assert.Equal("+Y", intent.ThroughFace);
        Assert.Equal("-Y->+Y", intent.Route);
        Assert.Equal("face(-Y):u=+X,v=+Z", intent.CenterSelectorFrame);
    }

    [Fact]
    public void FirmamentV2SideHoleYAxis_ParsesAliasYRoute()
    {
        var doc = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-aliases-y-axis-v2.valid.firmfixture")).Document!;
        Assert.Contains(Box(doc.Solid).Exposures, e => e.Alias == "front" && e.Selector == "face(+Y)");
        Assert.Contains(Box(doc.Solid).Exposures, e => e.Alias == "back" && e.Selector == "face(-Y)");
        var intent = doc.SideHoleIntent!;
        Assert.Equal("front", intent.AttachTargetSource);
        Assert.Equal("back", intent.ThroughTargetSource);
        Assert.Equal("+Y->-Y", intent.Route);
    }

    [Fact]
    public void FirmamentV2SideHoleYAxis_InvalidRoutesRejected()
    {
        Assert.Contains(FirmamentV2Parser.SideHoleRouteUnsupported, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-mixed-axis-z-to-x-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleRouteUnsupported, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-mixed-axis-y-to-x-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleCenterExceedsClearance, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-y-center-x-boundary-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleCenterExceedsClearance, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-y-center-z-boundary-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleRouteUnsupported, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-alias-y-wrong-through-v2.invalid.firmfixture")).Diagnostics);
    }

    [Fact]
    public void FirmamentV2SideHoleZAxis_ParsesDirectZRoute()
    {
        var intent = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-z-axis-v2.valid.firmfixture")).Document!.SideHoleIntent!;
        Assert.Equal("+Z", intent.AttachFace);
        Assert.Equal("-Z", intent.ThroughFace);
        Assert.Equal("+Z->-Z", intent.Route);
        Assert.Equal("Z", intent.RouteEvidence.Axis);
        Assert.Equal("face(+Z):u=+X,v=+Y", intent.CenterSelectorFrame);
    }

    [Fact]
    public void FirmamentV2SideHoleZAxis_DirectZReachesGoldenPath()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/Region/valid/side-hole-z-axis-v2.valid.firmfixture"));
        Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
        Assert.Equal("region-parent-integrated", result.FirmamentV2!.StageReached);
        Assert.Equal("Integrated", result.FirmamentV2.ParentIntegration);
        Assert.Equal("Closed", result.FirmamentV2.ShellClosure);
        Assert.Equal("Succeeded", result.FirmamentV2.StepSmoke);
        Assert.Null(result.FirmamentV2.Blocker);
    }

    [Fact]
    public void FirmamentV2SideHoleZAxis_ParsesReverseZRoute()
    {
        var intent = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-reverse-z-v2.valid.firmfixture")).Document!.SideHoleIntent!;
        Assert.Equal("-Z", intent.AttachFace);
        Assert.Equal("+Z", intent.ThroughFace);
        Assert.Equal("-Z->+Z", intent.Route);
        Assert.Equal("face(-Z):u=+X,v=+Y", intent.CenterSelectorFrame);
    }

    [Fact]
    public void FirmamentV2SideHoleZAxis_ReverseZReachesGoldenPath()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/Region/valid/side-hole-reverse-z-v2.valid.firmfixture"));
        Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
        Assert.Equal("region-parent-integrated", result.FirmamentV2!.StageReached);
        Assert.Equal("Integrated", result.FirmamentV2.ParentIntegration);
        Assert.Equal("Closed", result.FirmamentV2.ShellClosure);
        Assert.Equal("Succeeded", result.FirmamentV2.StepSmoke);
        Assert.Null(result.FirmamentV2.Blocker);
    }

    [Fact]
    public void FirmamentV2SideHoleZAxis_ParsesAliasZRoute()
    {
        var doc = FirmamentV2Parser.Parse(Source("Regression/Region/valid/side-hole-aliases-z-axis-v2.valid.firmfixture")).Document!;
        Assert.Contains(Box(doc.Solid).Exposures, e => e.Alias == "top" && e.Selector == "face(+Z)");
        Assert.Contains(Box(doc.Solid).Exposures, e => e.Alias == "bottom" && e.Selector == "face(-Z)");
        var region = Assert.Single(Assert.Single(doc.ModifyBlocks!).Regions);
        Assert.Equal("top", region.Attachment.Source);
        Assert.Equal("face(+Z)", region.Attachment.ResolvedSelector);
        Assert.Equal("bottom", region.Cut.Tool.Through.Source);
        Assert.Equal("face(-Z)", region.Cut.Tool.Through.ResolvedSelector);
    }

    [Fact]
    public void FirmamentV2SideHoleZAxis_AliasZReachesGoldenPath()
    {
        var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("Regression/Region/valid/side-hole-aliases-z-axis-v2.valid.firmfixture"));
        Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));
        Assert.Equal("region-parent-integrated", result.FirmamentV2!.StageReached);
        Assert.Equal("Integrated", result.FirmamentV2.ParentIntegration);
        Assert.Equal("Closed", result.FirmamentV2.ShellClosure);
        Assert.Equal("Succeeded", result.FirmamentV2.StepSmoke);
        Assert.Null(result.FirmamentV2.Blocker);
    }

    [Fact]
    public void FirmamentV2SideHoleZAxis_InvalidRoutesAndClearanceRejected()
    {
        Assert.Contains(FirmamentV2Parser.SideHoleRouteUnsupported, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-mixed-axis-z-to-x-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleCenterExceedsClearance, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-z-center-x-boundary-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleCenterExceedsClearance, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-z-center-y-boundary-v2.invalid.firmfixture")).Diagnostics);
        Assert.Contains(FirmamentV2Parser.SideHoleRouteUnsupported, FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/Region/side-hole-alias-z-wrong-through-v2.invalid.firmfixture")).Diagnostics);
    }


    [Fact]
    public void FirmamentV2SideHoleRoutePolicy_AllSixRoutesAreSupported()
    {
        var size = new double[] { 10, 8, 6 };
        foreach (var (attach, through) in new[] { ("+X", "-X"), ("-X", "+X"), ("+Y", "-Y"), ("-Y", "+Y"), ("+Z", "-Z"), ("-Z", "+Z") })
        {
            var result = FirmamentV2SideHoleRoutePolicy.Resolve(attach, through, size, radius: 1);
            Assert.True(result.IsSupported, $"{attach}->{through}: {result.Diagnostic}");
            Assert.Equal($"{attach}->{through}", result.Route!.Direction);
        }
    }

    [Fact]
    public void FirmamentV2SideHoleRoutePolicy_RouteFramesAreCorrect()
    {
        var size = new double[] { 10, 8, 6 };
        Assert.Equal(("+Y", "+Z", "face(+X):u=+Y,v=+Z"), Frame("+X", "-X"));
        Assert.Equal(("+Y", "+Z", "face(-X):u=+Y,v=+Z"), Frame("-X", "+X"));
        Assert.Equal(("+X", "+Z", "face(+Y):u=+X,v=+Z"), Frame("+Y", "-Y"));
        Assert.Equal(("+X", "+Z", "face(-Y):u=+X,v=+Z"), Frame("-Y", "+Y"));
        Assert.Equal(("+X", "+Y", "face(+Z):u=+X,v=+Y"), Frame("+Z", "-Z"));
        Assert.Equal(("+X", "+Y", "face(-Z):u=+X,v=+Y"), Frame("-Z", "+Z"));

        (string U, string V, string CenterFrame) Frame(string attach, string through)
        {
            var route = FirmamentV2SideHoleRoutePolicy.Resolve(attach, through, size, radius: 1).Route!;
            return (route.UAxis, route.VAxis, route.CenterFrame);
        }
    }

    [Fact]
    public void FirmamentV2SideHoleRoutePolicy_ClearanceUsesCorrectHalfExtents()
    {
        var size = new double[] { 10, 8, 6 };
        Assert.Equal((4, 3), Extents("+X", "-X"));
        Assert.Equal((4, 3), Extents("-X", "+X"));
        Assert.Equal((5, 3), Extents("+Y", "-Y"));
        Assert.Equal((5, 3), Extents("-Y", "+Y"));
        Assert.Equal((5, 4), Extents("+Z", "-Z"));
        Assert.Equal((5, 4), Extents("-Z", "+Z"));

        (double U, double V) Extents(string attach, string through)
        {
            var route = FirmamentV2SideHoleRoutePolicy.Resolve(attach, through, size, radius: 1).Route!;
            return (route.UHalfExtent, route.VHalfExtent);
        }
    }

    [Fact]
    public void FirmamentV2SideHoleRoutePolicy_RejectsSameFace()
    {
        var result = FirmamentV2SideHoleRoutePolicy.Resolve("+X", "+X", new double[] { 10, 8, 6 }, radius: 1);
        Assert.False(result.IsSupported);
        Assert.Equal(FirmamentV2Parser.SideHoleSameFaceUnsupported, result.Diagnostic);
    }

    [Fact]
    public void FirmamentV2SideHoleRoutePolicy_RejectsMixedAxis()
    {
        var result = FirmamentV2SideHoleRoutePolicy.Resolve("+Z", "+X", new double[] { 10, 8, 6 }, radius: 1);
        Assert.False(result.IsSupported);
        Assert.Equal(FirmamentV2Parser.SideHoleRouteUnsupported, result.Diagnostic);
    }

    [Fact]
    public void FirmamentV2SideHoleRoutePolicy_RejectsCenterBoundary()
    {
        var result = FirmamentV2SideHoleRoutePolicy.Resolve("+Z", "-Z", new double[] { 10, 8, 6 }, radius: 1, centerU: 4, centerV: 0);
        Assert.False(result.IsSupported);
        Assert.Equal(FirmamentV2Parser.SideHoleCenterExceedsClearance, result.Diagnostic);
    }

    [Fact]
    public void FirmamentV2SideHoleRoutePolicy_DirectFixturesStillGreen()
    {
        foreach (var fixture in new[] { "Regression/Region/valid/side-hole-v2.valid.firmfixture", "Regression/Region/valid/side-hole-y-axis-v2.valid.firmfixture", "Regression/Region/valid/side-hole-z-axis-v2.valid.firmfixture" })
        {
            var result = FirmamentFrontendTraceProbe.ParseV2Only(Source(fixture));
            Assert.True(result.ParseSucceeded, fixture + ": " + string.Join(", ", result.Diagnostics));
            Assert.Equal("Integrated", result.FirmamentV2!.ParentIntegration);
            Assert.Equal("Closed", result.FirmamentV2.ShellClosure);
            Assert.Equal("Succeeded", result.FirmamentV2.StepSmoke);
        }
    }

    [Fact]
    public void FirmamentV2SideHoleRoutePolicy_AliasFixturesStillGreen()
    {
        foreach (var fixture in new[] { "Regression/Region/valid/side-hole-aliases-v2.valid.firmfixture", "Regression/Region/valid/side-hole-aliases-y-axis-v2.valid.firmfixture", "Regression/Region/valid/side-hole-aliases-z-axis-v2.valid.firmfixture" })
        {
            var result = FirmamentFrontendTraceProbe.ParseV2Only(Source(fixture));
            Assert.True(result.ParseSucceeded, fixture + ": " + string.Join(", ", result.Diagnostics));
            Assert.Equal("Integrated", result.FirmamentV2!.ParentIntegration);
            Assert.Equal("Closed", result.FirmamentV2.ShellClosure);
            Assert.Equal("Succeeded", result.FirmamentV2.StepSmoke);
        }
    }

    [Fact]
    public void FirmamentV2_AllPriorSideHoleMilestonesRemainGreen()
    {
        foreach (var fixture in Directory.EnumerateFiles(Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../fixtures/Regression/Region/valid")), "side-hole*.valid.firmfixture"))
        {
            var lines = File.ReadAllLines(fixture);
            var bodyStart = Array.FindIndex(lines, line => !string.IsNullOrWhiteSpace(line) && !line.TrimStart().StartsWith("//", StringComparison.Ordinal));
            var result = FirmamentFrontendTraceProbe.ParseV2Only(string.Join(Environment.NewLine, lines.Skip(Math.Max(0, bodyStart))));
            Assert.True(result.ParseSucceeded, Path.GetFileName(fixture) + ": " + string.Join(", ", result.Diagnostics));
        }
    }


    [Fact]
    public void FirmamentV2Parser_SemanticPmi_ParsesHoleDiameterAndDatumPlane()
    {
        var hole = FirmamentV2Parser.Parse(Source("Regression/PMI/valid/pmi-v2-hole-diameter-callout-emits-in-step.valid.firmfixture"));
        Assert.True(hole.IsSuccess, string.Join(", ", hole.Diagnostics));
        var holePmi = Assert.Single(hole.Document!.Pmi!);
        Assert.Equal(FirmamentV2PmiKind.HoleDiameter, holePmi.Kind);
        Assert.Equal("mountDiameter", holePmi.Name);
        Assert.Equal("mount", holePmi.Target);
        Assert.Equal(2d, holePmi.Value);

        var datum = FirmamentV2Parser.Parse(Source("Regression/PMI/valid/pmi-v2-datum-plane-emits-in-step.valid.firmfixture"));
        Assert.True(datum.IsSuccess, string.Join(", ", datum.Diagnostics));
        var datumPmi = Assert.Single(datum.Document!.Pmi!);
        Assert.Equal(FirmamentV2PmiKind.DatumPlane, datumPmi.Kind);
        Assert.Equal("A", datumPmi.Name);
        Assert.Equal("top", datumPmi.Target);
    }

    [Fact]
    public void FirmamentV2Parser_SemanticPmi_InvalidTargetAndDiameterAreDeterministicDiagnostics()
    {
        var unknown = FirmamentV2Parser.Parse("""
model BadPmiTarget {
  units mm
  solid base: Box { size: [10, 8, 6] }
  pmi { diameter bad { target: missing value: 2mm } }
}
""");
        Assert.Contains(FirmamentV2Parser.PmiTargetUnresolved, unknown.Diagnostics);

        var invalidDiameter = FirmamentV2Parser.Parse("""
model BadPmiDiameter {
  units mm
  solid base: Box { size: [10, 8, 6] }
  modify base { hole<shaft> mount { on: face(+Z) center: [0, 0] diameter: 2 end: throughAll } }
  pmi { diameter bad { target: mount value: 2deg } }
}
""");
        Assert.Contains(FirmamentV2Parser.PmiDiameterInvalid, invalidDiameter.Diagnostics);
    }


    [Fact]
    public void FirmamentV2Parser_RecordPmiDatumDiameter_BindsTolerancedDimensionAndTargets()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/InlineStep/valid/inline-step-v2-record-pmi-datum-diameter-step-verified.valid.firmfixture"),
            Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../fixtures/Regression/InlineStep/valid")));

        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var bound = result.Document!.BoundPmi!;
        var datum = Assert.Single(bound.Datums);
        Assert.Equal(FirmamentV2PmiKind.DatumPlane, datum.Kind);
        Assert.Equal("A", datum.Name);
        Assert.Equal("part.region(\"baseFace\")", Assert.Single(datum.Targets));

        var diameter = Assert.Single(bound.Dimensions);
        Assert.Equal(FirmamentV2PmiKind.HoleDiameter, diameter.Kind);
        Assert.Equal("mountHoleADiameter", diameter.Name);
        Assert.Equal("part.region(\"mountHoleA\")", Assert.Single(diameter.Targets));
        Assert.Equal(6.0d, diameter.DimensionValue!.NumericValue);
        Assert.NotNull(diameter.DimensionTolerance);
        Assert.Equal(0.05d, diameter.DimensionTolerance!.Plus);
        Assert.Equal(0.05d, diameter.DimensionTolerance.Minus);
    }

    [Fact]
    public void FirmamentV2P2_RecordPmiDatumDiameter_ExportsAp242EvidenceAndReimports()
    {
        var fixture = FixturePath("Regression/InlineStep/valid/inline-step-v2-record-pmi-datum-diameter-step-verified.valid.firmfixture");
        var output = Path.Combine(Path.GetTempPath(), "aetheris-p2-record-pmi-" + Guid.NewGuid().ToString("N") + ".step");

        var build = FirmamentBuildAndExport.Run(fixture, output);

        Assert.True(build.IsSuccess, string.Join(", ", build.Diagnostics.Select(d => d.Message)));
        Assert.True(File.Exists(output));
        var step = File.ReadAllText(output);
        Assert.Contains("SHAPE_ASPECT('firmament-datum:A'", step, StringComparison.Ordinal);
        Assert.Contains("PROPERTY_DEFINITION('datum:A:part'", step, StringComparison.Ordinal);
        Assert.Contains("SHAPE_DIMENSION_REPRESENTATION('diameter:part.mountHoleADiameter'", step, StringComparison.Ordinal);
        Assert.Contains("PROPERTY_DEFINITION('diameter:part.mountHoleADiameter'", step, StringComparison.Ordinal);
        Assert.Contains("SHAPE_DIMENSION_REPRESENTATION('diameter_tolerance:part.mountHoleADiameter'", step, StringComparison.Ordinal);
        Assert.Contains("'tolerance_plus'", step, StringComparison.Ordinal);
        Assert.Contains("'tolerance_minus'", step, StringComparison.Ordinal);

        var reimport = Aetheris.Kernel.Core.Step242.Step242Importer.ImportBody(step);
        Assert.True(reimport.IsSuccess, string.Join(", ", reimport.Diagnostics.Select(d => d.Message)));
        Assert.Single(build.Value.Export.DatumInspection!);
        Assert.Single(build.Value.Export.DimensionInspection!);
    }

    [Fact]
    public void FirmamentV2P2_RecordPmiDiameterDimensionWithoutTolerance_IsRejected()
    {
        var result = FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Invalid/InlineStep/inline-step-v2-record-pmi-diameter-missing-tolerance.invalid.firmfixture"),
            Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../fixtures/Compatibility/LegacyAliases/Invalid/InlineStep")));

        Assert.False(result.IsSuccess);
        Assert.Contains(FirmamentV2Parser.PmiDimensionMissingTolerance, result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_RecognizesMalformedConceptStructSource_WithoutV1FallbackAdmission()
    {
        var result = FirmamentV2Parser.Parse(Source("Invalid/Language/concept-struct-diagnostic-routing-x1.invalid.firmfixture"));

        Assert.False(result.IsSuccess);
        Assert.Equal(FirmamentV2ParseDisposition.RecognizedInvalid, result.Disposition);
        Assert.Contains(result.Diagnostics, diagnostic => diagnostic.StartsWith("firmament-concept-structural-conformance-failed", StringComparison.Ordinal));
        Assert.Contains(result.Diagnostics, diagnostic => diagnostic.StartsWith("firmament-concept-missing-member:", StringComparison.Ordinal));
    }

    [Fact]
    public void FirmamentV2Parser_LeavesLegacyToonAndArbitraryText_Unrecognized()
    {
        var legacy = FirmamentV2Parser.Parse("""
firmament:
  version: 1
model:
  name: legacy
""");
        var arbitrary = FirmamentV2Parser.Parse("this is not Firmament source");

        Assert.Equal(FirmamentV2ParseDisposition.NotRecognized, legacy.Disposition);
        Assert.Equal(FirmamentV2ParseDisposition.NotRecognized, arbitrary.Disposition);
    }

    [Fact]
    public void FirmamentV2_ImportedFlatness_IsAdmittedAndEmitted()
    {
        var fixture = FixturePath("Compatibility/LegacyAliases/Valid/InlineStep/inline-step-v2-record-pmi-flatness.valid.firmfixture");
        var parse = FirmamentV2Parser.Parse(Source("Compatibility/LegacyAliases/Valid/InlineStep/inline-step-v2-record-pmi-flatness.valid.firmfixture"), Path.GetDirectoryName(fixture));
        var report = FirmamentV2ValidationReportBuilder.Build(parse, fixture);

        var pmi = Assert.Single(report.Pmi);
        Assert.Equal("flatness", pmi.Kind);
        Assert.Equal("supported", pmi.ExportSupport);
        Assert.Equal("valid", pmi.Status);

        var build = FirmamentBuildAndExport.CompileSource(Source("Compatibility/LegacyAliases/Valid/InlineStep/inline-step-v2-record-pmi-flatness.valid.firmfixture"), Path.GetDirectoryName(fixture));
        Assert.True(build.IsSuccess, string.Join(";", build.Diagnostics.Select(d => d.Message)));
        Assert.Contains(Aetheris.Kernel.Core.Step242.Step242SemanticPmiInspector.Inspect(build.Value.StepText).Items, item => item.Kind == "Flatness");
    }

    [Fact]
    public void FirmamentV2Parser_StaticFactFlowsThroughHoleRequireAndProjectedPmi()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/CanonicalGeometry/pmi-projected-hole-diameter-asymmetric-tolerance.firmament"));
        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var document = Assert.IsType<FirmamentV2Document>(result.Document);
        var constraint = Assert.Single(document.StaticAuthoring!.SemanticConstraints!);
        Assert.True(constraint.ValidationSucceeded);
        Assert.Equal("Mount", constraint.Subject);
        Assert.Equal("MountSpecs[0].Diameter", constraint.ExpectedProvenance);
        var pmi = Assert.Single(document.PmiBlock!.Records);
        Assert.Equal("MountDiameterConstraint", pmi.Projection!.SourceRequireId);
        Assert.Equal(8d, Assert.Single(document.BoundPmi!.Dimensions).DimensionValue!.NumericValue);
    }

    [Fact]
    public void FirmamentV2Parser_ManualAndProjectedHoleDiameterHaveEquivalentPmiSemantics()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/CanonicalGeometry/pmi-manual-vs-projected-equivalence.firmament"));
        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var dimensions = result.Document!.BoundPmi!.Dimensions.OrderBy(record => record.Name, StringComparer.Ordinal).ToArray();
        var manual = Assert.Single(dimensions, record => record.Name == "ManualCallout");
        var projected = Assert.Single(dimensions, record => record.Name == "ProjectedCallout");
        Assert.Equal(manual.Kind, projected.Kind);
        Assert.Equal(manual.DimensionValue!.NumericValue, projected.DimensionValue!.NumericValue);
        Assert.Equal(manual.DimensionTolerance, projected.DimensionTolerance);
        Assert.Equal(manual.DatumRefs, projected.DatumRefs);
        Assert.Equal("ProjectedDiameter", projected.ProjectionSource);
    }

    private static string Source(string relative)
    {
        var path = FixturePath(relative);
        var lines = File.ReadAllLines(path);
        var bodyStart = Array.FindIndex(lines, line => !string.IsNullOrWhiteSpace(line) && !line.TrimStart().StartsWith("//", StringComparison.Ordinal));
        return string.Join(Environment.NewLine, lines.Skip(Math.Max(0, bodyStart)));
    }

    private static string FixturePath(string relative) => Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../fixtures", relative));

    [Fact]
    public void FirmamentV2Parser_LetPrimitiveLiterals_ParsesAndBinds()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/Language/valid/let-primitive-literals.valid.firmfixture"));

        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var lets = result.Document!.Lets!;
        var boundLets = result.Document!.BoundLets!;
        Assert.Equal(6, lets.Count);
        Assert.Equal(6, boundLets.Count);
        AssertLet(boundLets[0], "holeCount", FirmamentV2PrimitiveType.Int, 4, null);
        AssertLet(boundLets[1], "scale", FirmamentV2PrimitiveType.Float, 1.25d, null);
        AssertLet(boundLets[2], "holeDiameter", FirmamentV2PrimitiveType.Length, 6.0d, "mm");
        AssertLet(boundLets[3], "draftAngle", FirmamentV2PrimitiveType.Angle, 3.0d, "deg");
        AssertLet(boundLets[4], "materialName", FirmamentV2PrimitiveType.String, "Aluminum6061", null);
        AssertLet(boundLets[5], "inspectionRequired", FirmamentV2PrimitiveType.Bool, true, null);
    }

    [Theory]
    [InlineData("let holeCount: int = 4.0", FirmamentV2Parser.LetTypeMismatch)]
    [InlineData("let holeDiameter: length = 6.0", FirmamentV2Parser.LetTypeMismatch)]
    [InlineData("let draftAngle: angle = 3mm", FirmamentV2Parser.LetUnitMismatch)]
    [InlineData("let scale: float = 1.25mm", FirmamentV2Parser.LetUnitMismatch)]
    [InlineData("let unknownThing: banana = 1", FirmamentV2Parser.LetUnknownType)]
    [InlineData("let radius: length = holeDiameter / 2", FirmamentV2Parser.ExpressionUnknownSymbol)]
    public void FirmamentV2Parser_LetPrimitiveLiterals_InvalidCasesAreDiagnostics(string letSource, string expectedDiagnostic)
    {
        var result = FirmamentV2Parser.Parse($$"""
            model LetInvalidExample {
                units mm
                solid base: Box {
                    size: [10, 8, 6]
                }
                {{letSource}}
            }
            """);

        Assert.False(result.IsSuccess);
        Assert.Contains(expectedDiagnostic, result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_LetPrimitiveLiterals_DuplicateNameIsDiagnostic()
    {
        var result = FirmamentV2Parser.Parse("""
            model LetDuplicateExample {
                units mm
                solid base: Box {
                    size: [10, 8, 6]
                }
                let holeCount: int = 4
                let holeCount: int = 5
            }
            """);

        Assert.False(result.IsSuccess);
        Assert.Contains(FirmamentV2Parser.LetDuplicateName, result.Diagnostics);
    }


    [Fact]
    public void FirmamentV2Parser_LetRecordGroups_ParseAndBindFields()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/Language/valid/let-record-groups.valid.firmfixture"));

        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var record = Assert.Single(result.Document!.LetRecords!);
        Assert.Equal("MountingPattern", record.Name);
        Assert.Equal(6, record.Fields.Count);
        var bound = Assert.Single(result.Document!.BoundLetRecords!);
        Assert.Equal("MountingPattern", bound.Name);
        AssertLet(bound.Fields["holeDiameter"], "holeDiameter", FirmamentV2PrimitiveType.Length, 6.0d, "mm");
        AssertLet(bound.Fields["holeSpacingX"], "holeSpacingX", FirmamentV2PrimitiveType.Length, 80.0d, "mm");
        AssertLet(bound.Fields["holeSpacingY"], "holeSpacingY", FirmamentV2PrimitiveType.Length, 40.0d, "mm");
        AssertLet(bound.Fields["holeCount"], "holeCount", FirmamentV2PrimitiveType.Int, 4, null);
        AssertLet(bound.Fields["label"], "label", FirmamentV2PrimitiveType.String, "M6 mount group", null);
        AssertLet(bound.Fields["inspectionRequired"], "inspectionRequired", FirmamentV2PrimitiveType.Bool, true, null);
    }

    [Fact]
    public void FirmamentV2Parser_LetRecordGroups_AllowSameFieldNameAcrossRecords()
    {
        var result = FirmamentV2Parser.Parse("""
            model MultipleRecords {
                units mm
                solid base: Box { size: [10, 8, 6] }
                let MountingPattern { holeDiameter: length = 6.0mm }
                let InspectionPattern { holeDiameter: length = 6.1mm }
            }
            """);

        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        Assert.Equal(2, result.Document!.BoundLetRecords!.Count);
    }

    [Fact]
    public void FirmamentV2Parser_DottedReferenceScalarLet_ResolvesRecordFieldValue()
    {
        var result = FirmamentV2Parser.Parse("""
            model DottedReference {
                units mm
                solid base: Box { size: [10, 8, 6] }
                let MountingPattern { holeDiameter: length = 6.0mm }
                let exportedHoleDiameter: length = MountingPattern.holeDiameter
            }
            """);

        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        AssertLet(Assert.Single(result.Document!.BoundLets!), "exportedHoleDiameter", FirmamentV2PrimitiveType.Length, 6.0d, "mm");
    }


    [Fact]
    public void FirmamentV2Parser_TolerancedValues_ParseBilateralAsymmetricAndRecordFields()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/Language/valid/let-toleranced-values.valid.firmfixture"));

        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var lets = result.Document!.BoundLets!.ToDictionary(l => l.Name);
        AssertLet(lets["holeDiameter"], "holeDiameter", FirmamentV2PrimitiveType.Length, 6.0d, "mm");
        AssertTolerance(lets["holeDiameter"].Tolerance, FirmamentV2ToleranceKind.Bilateral, 0.05d, 0.05d, "mm");
        AssertTolerance(lets["slotWidth"].Tolerance, FirmamentV2ToleranceKind.Asymmetric, 0.10d, 0.05d, "mm");
        AssertTolerance(lets["draftAngle"].Tolerance, FirmamentV2ToleranceKind.Bilateral, 0.5d, 0.5d, "deg");

        var fields = Assert.Single(result.Document!.BoundLetRecords!).Fields;
        AssertTolerance(fields["holeDiameter"].Tolerance, FirmamentV2ToleranceKind.Bilateral, 0.05d, 0.05d, "mm");
        AssertTolerance(fields["holeSpacingX"].Tolerance, FirmamentV2ToleranceKind.Asymmetric, 0.10d, 0.05d, "mm");
    }

    [Fact]
    public void FirmamentV2Parser_TolerancedExpressions_ExplicitToleranceAndAliasesBehaveDeterministically()
    {
        var result = FirmamentV2Parser.Parse("""
            model TolerancedExpressions {
                units mm
                solid base: Box { size: [10, 8, 6] }
                let holeDiameter: length = 6.0mm tol 0.05mm
                let clearance: length = 0.25mm
                let drill: length = holeDiameter + clearance tol 0.05mm
                let radius: length = holeDiameter / 2
                let exportedHoleDiameter: length = holeDiameter
                let MountingPattern { fieldDiameter: length = 7.0mm tol 0.1mm }
                let exportedFieldDiameter: length = MountingPattern.fieldDiameter
            }
            """);

        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        Assert.Contains(FirmamentV2Parser.ToleranceDroppedThroughArithmetic, result.Diagnostics);
        var lets = result.Document!.BoundLets!.ToDictionary(l => l.Name);
        AssertLet(lets["drill"], "drill", FirmamentV2PrimitiveType.Length, 6.25d, "mm");
        AssertTolerance(lets["drill"].Tolerance, FirmamentV2ToleranceKind.Bilateral, 0.05d, 0.05d, "mm");
        AssertLet(lets["radius"], "radius", FirmamentV2PrimitiveType.Length, 3.0d, "mm");
        Assert.Null(lets["radius"].Tolerance);
        AssertTolerance(lets["exportedHoleDiameter"].Tolerance, FirmamentV2ToleranceKind.Bilateral, 0.05d, 0.05d, "mm");
        AssertTolerance(lets["exportedFieldDiameter"].Tolerance, FirmamentV2ToleranceKind.Bilateral, 0.1d, 0.1d, "mm");
    }

    [Theory]
    [InlineData("let holeCount: int = 4 tol 1", FirmamentV2Parser.ToleranceInvalidType)]
    [InlineData("let scale: float = 1.25 tol 0.01", FirmamentV2Parser.ToleranceInvalidType)]
    [InlineData("let name: string = \"Aluminum\" tol 1", FirmamentV2Parser.ToleranceInvalidType)]
    [InlineData("let flag: bool = true tol 1", FirmamentV2Parser.ToleranceInvalidType)]
    [InlineData("let holeDiameter: length = 6.0mm tol 0.5deg", FirmamentV2Parser.ToleranceUnitMismatch)]
    [InlineData("let draftAngle: angle = 3deg tol 0.1mm", FirmamentV2Parser.ToleranceUnitMismatch)]
    [InlineData("let x: length = 1.0mm tol +0.1mm", FirmamentV2Parser.ToleranceMissingMinus)]
    [InlineData("let x: length = 1.0mm tol -0.1mm", FirmamentV2Parser.ToleranceNegativeBilateral)]
    [InlineData("let x: length = 1.0mm tol +0.1mm +0.2mm", FirmamentV2Parser.ToleranceMissingMinus)]
    [InlineData("let x: length = 1.0mm tol -0.1mm +0.2mm", FirmamentV2Parser.ToleranceMissingPlus)]
    [InlineData("let x: length = 1.0mm tol 0.1", FirmamentV2Parser.ToleranceInvalidLiteral)]
    [InlineData("let bad: length = (6.0mm tol 0.05mm) + 1.0mm", FirmamentV2Parser.ToleranceUnsupported)]
    public void FirmamentV2Parser_TolerancedValues_InvalidCasesAreDiagnostics(string letSource, string expectedDiagnostic)
    {
        var result = FirmamentV2Parser.Parse($$"""
            model InvalidTolerance {
                units mm
                solid base: Box { size: [10, 8, 6] }
                {{letSource}}
            }
            """);

        Assert.False(result.IsSuccess);
        Assert.Contains(expectedDiagnostic, result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_LetArithmeticExpressions_EvaluateStrictTypedGraph()
    {
        var result = FirmamentV2Parser.Parse(Source("Regression/Language/valid/let-arithmetic-expressions.valid.firmfixture"));

        Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
        var bound = result.Document!.BoundLets!.ToDictionary(l => l.Name);
        AssertLet(bound["radius"], "radius", FirmamentV2PrimitiveType.Length, 3.0d, "mm");
        AssertLet(bound["drill"], "drill", FirmamentV2PrimitiveType.Length, 6.25d, "mm");
        AssertLet(bound["doubled"], "doubled", FirmamentV2PrimitiveType.Int, 8, null);
        AssertLet(bound["ratio"], "ratio", FirmamentV2PrimitiveType.Float, 2.0d, null);
        AssertLet(bound["halfAngle"], "halfAngle", FirmamentV2PrimitiveType.Angle, 45.0d, "deg");
        AssertLet(bound["scaled"], "scaled", FirmamentV2PrimitiveType.Length, 7.5d, "mm");
        Assert.Contains("diameter", bound["radius"].Dependencies!);
    }

    [Theory]
    [InlineData("let diameter: length = 6.0mm\nlet bad: length = diameter + 2", FirmamentV2Parser.ExpressionInvalidOperator)]
    [InlineData("let diameter: length = 6.0mm\nlet draftAngle: angle = 90deg\nlet bad: length = diameter + draftAngle", FirmamentV2Parser.ExpressionInvalidOperator)]
    [InlineData("let name: string = \"Aluminum6061\"\nlet bad: string = name + name", FirmamentV2Parser.ExpressionInvalidOperator)]
    [InlineData("let flag: bool = true\nlet bad: bool = flag * 2", FirmamentV2Parser.ExpressionInvalidOperator)]
    [InlineData("let diameter: length = 6.0mm\nlet bad: length = diameter / diameter", FirmamentV2Parser.ExpressionTypeMismatch)]
    [InlineData("let bad: float = 1.0 / 0.0", FirmamentV2Parser.ExpressionDivisionByZero)]
    [InlineData("let badLength: length = 6.0mm / 0", FirmamentV2Parser.ExpressionDivisionByZero)]
    [InlineData("let a: length = b + 1.0mm\nlet b: length = a + 1.0mm", FirmamentV2Parser.ExpressionCycle)]
    [InlineData("let x: length = if true { 1.0mm } else { 2.0mm }", "firmament-syntax-control-flow-unsupported")]
    [InlineData("let x: length = foo(1.0mm)", FirmamentV2Parser.ExpressionUnsupported)]
    public void FirmamentV2Parser_LetArithmeticExpressions_InvalidCasesAreDiagnostics(string letSource, string expectedDiagnostic)
    {
        var result = FirmamentV2Parser.Parse($$"""
            model InvalidArithmetic {
                units mm
                solid base: Box { size: [10, 8, 6] }
                {{letSource}}
            }
            """);

        Assert.False(result.IsSuccess);
        Assert.Contains(expectedDiagnostic, result.Diagnostics);
    }

    [Theory]
    [InlineData("let MountingPattern { holeDiameter: length = 6.0mm holeDiameter: length = 7.0mm }", FirmamentV2Parser.LetInvalidLiteral)]
    [InlineData("let MountingPattern { radius: length = holeDiameter / 2 }", FirmamentV2Parser.LetLiteralOnly)]
    [InlineData("let Process { Tooling { minimumRadius: length = 1.5mm } }", FirmamentV2Parser.LetInvalidLiteral)]
    public void FirmamentV2Parser_LetRecordGroups_InvalidRecordBodiesAreDiagnostics(string recordSource, string expectedDiagnostic)
    {
        var result = FirmamentV2Parser.Parse($$"""
            model InvalidRecord {
                units mm
                solid base: Box { size: [10, 8, 6] }
                {{recordSource}}
            }
            """);

        Assert.False(result.IsSuccess);
        Assert.Contains(expectedDiagnostic, result.Diagnostics);
    }


    [Fact]
    public void FirmamentV2Parser_LetRecordGroups_DuplicateFieldAndTopLevelNamesAreDiagnostics()
    {
        var duplicateField = FirmamentV2Parser.Parse("""
            model DuplicateRecordField {
                units mm
                solid base: Box { size: [10, 8, 6] }
                let MountingPattern {
                    holeDiameter: length = 6.0mm
                    holeDiameter: length = 7.0mm
                }
            }
            """);
        Assert.False(duplicateField.IsSuccess);
        Assert.Contains(FirmamentV2Parser.LetRecordDuplicateField, duplicateField.Diagnostics);

        var duplicateTopLevel = FirmamentV2Parser.Parse("""
            model DuplicateTopLevel {
                units mm
                solid base: Box { size: [10, 8, 6] }
                let holeDiameter: length = 6.0mm
                let holeDiameter { value: length = 6.0mm }
            }
            """);
        Assert.False(duplicateTopLevel.IsSuccess);
        Assert.Contains(FirmamentV2Parser.LetDuplicateName, duplicateTopLevel.Diagnostics);
    }

    [Theory]
    [InlineData("let exportedHoleDiameter: length = MissingPattern.holeDiameter", FirmamentV2Parser.LetReferenceUnknownRecord)]
    [InlineData("let MountingPattern { holeDiameter: length = 6.0mm }\nlet exportedHoleDiameter: length = MountingPattern.missingField", FirmamentV2Parser.LetReferenceUnknownField)]
    [InlineData("let holeDiameter: length = 6.0mm\nlet exported: length = holeDiameter.value", FirmamentV2Parser.LetReferenceNonRecord)]
    [InlineData("let MountingPattern { holeCount: int = 4 }\nlet exportedHoleDiameter: length = MountingPattern.holeCount", FirmamentV2Parser.LetTypeMismatch)]
    [InlineData("let MountingPattern { holeDiameter: length = 6.0mm }\nlet exportedHoleDiameter: length = MountingPattern", FirmamentV2Parser.LetReferenceRecordUsedAsValue)]
    public void FirmamentV2Parser_DottedReference_InvalidReferencesAreDiagnostics(string letSource, string expectedDiagnostic)
    {
        var result = FirmamentV2Parser.Parse($$"""
            model InvalidReference {
                units mm
                solid base: Box { size: [10, 8, 6] }
                {{letSource}}
            }
            """);

        Assert.False(result.IsSuccess);
        Assert.Contains(expectedDiagnostic, result.Diagnostics);
    }


    [Fact]
    public void FirmamentV2Parser_RecordShapedPmi_DatumDiameterAndRelationsBind()
    {
        var result = FirmamentV2Parser.Parse("""
            model PmiRecordShaped {
                units mm
                let MountingPattern {
                    holeDiameter: length = 6.0mm tol 0.05mm
                    holeSpacingX: length = 80.0mm tol +0.10mm -0.05mm
                }
                solid part: Box { size: [100, 60, 10] }
                pmi {
                    datum A {
                        target: part.region("baseFace")
                    }
                    diameter mountHoleADiameter {
                        target: part.region("mountHoleA")
                        dimension: MountingPattern.holeDiameter
                    }
                    distance mountHoleSpacingX {
                        targetA: part.region("mountHoleA")
                        targetB: part.region("mountHoleB")
                        dimension: MountingPattern.holeSpacingX
                    }
                    flatness baseFlatness {
                        target: part.region("baseFace")
                        tolerance: 0.03mm
                    }
                    coplanar topToDatumA {
                        target: part.region("topFace")
                        datum: A
                        tolerance: 0.05mm
                    }
                    perpendicular sideToDatumA {
                        target: part.region("sideFace")
                        datum: A
                        tolerance: 0.05mm
                    }
                    parallel topParallelToDatumA {
                        target: part.region("topFace")
                        datum: A
                        tolerance: 0.05mm
                    }
                }
            }
            """);

        Assert.True(result.IsSuccess, string.Join(",", result.Diagnostics));
        var bound = result.Document!.BoundPmi!;
        Assert.Single(bound.Datums);
        Assert.Equal("A", bound.Datums[0].Name);
        var diameter = Assert.Single(bound.Dimensions, d => d.Kind == FirmamentV2PmiKind.HoleDiameter);
        Assert.Equal(6.0d, diameter.DimensionValue!.NumericValue);
        AssertTolerance(diameter.DimensionTolerance, FirmamentV2ToleranceKind.Bilateral, 0.05d, 0.05d, "mm");
        Assert.Contains(bound.Controls, c => c.Kind == FirmamentV2PmiKind.Flatness && c.ControlTolerance!.NumericValue!.Value == 0.03d);
        Assert.Contains(bound.Controls, c => c.Kind == FirmamentV2PmiKind.Coplanar && c.DatumRefs.Single() == "A");
    }

    [Fact]
    public void FirmamentV2Parser_RecordShapedPmi_RejectsDimensionWithoutTolerance()
    {
        var result = FirmamentV2Parser.Parse("""
            model PmiMissingTolerance {
                units mm
                let holeDiameter: length = 6.0mm
                solid part: Box { size: [100, 60, 10] }
                pmi {
                    diameter mountHoleADiameter {
                        target: part.region("mountHoleA")
                        dimension: holeDiameter
                    }
                }
            }
            """);

        Assert.False(result.IsSuccess);
        Assert.Contains(FirmamentV2Parser.PmiDimensionMissingTolerance, result.Diagnostics);
    }

    [Fact]
    public void FirmamentV2Parser_RecordShapedPmi_RejectsTypeMismatchUnknownDatumAndDuplicates()
    {
        var typeMismatch = FirmamentV2Parser.Parse("""
            model PmiBadType {
                units mm
                let holeCount: int = 4
                solid part: Box { size: [10, 8, 6] }
                pmi { diameter badDiameter {
                    target: part.region("mountHoleA")
                    dimension: holeCount
                } }
            }
            """);
        Assert.False(typeMismatch.IsSuccess);
        Assert.Contains(FirmamentV2Parser.PmiDimensionTypeMismatch, typeMismatch.Diagnostics);

        var unknownDatum = FirmamentV2Parser.Parse("""
            model PmiUnknownDatum {
                units mm
                solid part: Box { size: [10, 8, 6] }
                pmi { coplanar topToDatumA {
                    target: part.region("topFace")
                    datum: A
                    tolerance: 0.05mm
                } }
            }
            """);
        Assert.False(unknownDatum.IsSuccess);
        Assert.Contains(FirmamentV2Parser.PmiUnknownDatum, unknownDatum.Diagnostics);

        var duplicate = FirmamentV2Parser.Parse("""
            model PmiDuplicateDatum {
                units mm
                solid part: Box { size: [10, 8, 6] }
                pmi {
                    datum A { target: part.region("baseFace") }
                    datum A { target: part.region("topFace") }
                }
            }
            """);
        Assert.False(duplicate.IsSuccess);
        Assert.Contains(FirmamentV2Parser.PmiDuplicateRecord, duplicate.Diagnostics);
        Assert.Contains(FirmamentV2Parser.PmiDuplicateDatum, duplicate.Diagnostics);
    }

    private static FirmamentV2BoxRecord Box(FirmamentV2SolidBinding solid) => Assert.IsType<FirmamentV2BoxRecord>(solid.Box);

    private static void AssertLet(FirmamentV2BoundLet actual, string name, FirmamentV2PrimitiveType type, object value, string? unit)
    {
        Assert.Equal(name, actual.Name);
        Assert.Equal(type, actual.Type);
        Assert.Equal(value, actual.Value.Value);
        Assert.Equal(unit, actual.Value.Unit);
    }

    private static void AssertTolerance(FirmamentV2Tolerance? actual, FirmamentV2ToleranceKind kind, double plus, double minus, string unit)
    {
        Assert.NotNull(actual);
        Assert.Equal(kind, actual.Kind);
        Assert.Equal(plus, actual.Plus);
        Assert.Equal(minus, actual.Minus);
        Assert.Equal(unit, actual.Unit);
    }

}