Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
E7: add bounded concave chamfer preflight and explicit contract rejection path
Yuechen Li06d8bbb5e9ca
diff --git a/Aetheris.Kernel.Core.Tests/Brep/EdgeFinishing/BrepBoundedConcaveChamferPreflightTests.cs b/Aetheris.Kernel.Core.Tests/Brep/EdgeFinishing/BrepBoundedConcaveChamferPreflightTests.csnew file mode 100644index 00000000..64065f07--- /dev/null+++ b/Aetheris.Kernel.Core.Tests/Brep/EdgeFinishing/BrepBoundedConcaveChamferPreflightTests.cs@@ -0,0 +1,75 @@+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Brep.Boolean;+using Aetheris.Kernel.Core.Brep.EdgeFinishing;++namespace Aetheris.Kernel.Core.Tests.Brep.EdgeFinishing;++public sealed class BrepBoundedConcaveChamferPreflightTests+{+ [Fact]+ public void ResolveInternalConcaveVerticalEdge_Succeeds_ForCanonicalLRoot_WithBoundedDistance()+ {+ var composition = CreateLRootComposition();++ var result = BrepBoundedConcaveChamferPreflight.ResolveInternalConcaveVerticalEdge(+ composition,+ BrepBoundedChamferEdge.InnerXMaxYMax,+ distance: 1d);++ Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => d.Message)));+ Assert.True(result.Value.MaxAllowedDistance > 1d);+ Assert.Equal(0d, result.Value.MinZ, 9);+ Assert.Equal(1d, result.Value.MaxZ, 9);+ }++ [Fact]+ public void ChamferTrustedPolyhedralSingleInternalConcaveEdge_UsesJudgmentAndReturnsExplicitConstructionBlocker()+ {+ var body = CreateLRootBody();++ var result = BrepBoundedChamfer.ChamferTrustedPolyhedralSingleInternalConcaveEdge(+ body,+ BrepBoundedChamferEdge.InnerXMaxYMax,+ distance: 1d);++ Assert.False(result.IsSuccess);+ Assert.Contains(result.Diagnostics, diagnostic =>+ diagnostic.Message.Contains("local loop rewrite construction is not yet implemented", StringComparison.Ordinal));+ }++ private static SafeBooleanComposition CreateLRootComposition()+ {+ var cells = new[]+ {+ new AxisAlignedBoxExtents(0d, 2d, 0d, 2d, 0d, 1d),+ new AxisAlignedBoxExtents(2d, 4d, 0d, 2d, 0d, 1d),+ new AxisAlignedBoxExtents(0d, 2d, 2d, 4d, 0d, 1d),+ };++ return new SafeBooleanComposition(+ new AxisAlignedBoxExtents(0d, 4d, 0d, 4d, 0d, 1d),+ [],+ SafeBooleanRootDescriptor.FromBox(new AxisAlignedBoxExtents(0d, 4d, 0d, 4d, 0d, 1d)),+ OccupiedCells: cells);+ }++ private static BrepBody CreateLRootBody()+ {+ var composition = CreateLRootComposition();+ var built = BrepBooleanOrthogonalUnionBuilder.BuildFromCells(composition.OccupiedCells!);+ Assert.True(built.IsSuccess);+ return new BrepBody(+ built.Value.Topology,+ built.Value.Geometry,+ built.Value.Bindings,+ built.Value.Topology.Vertices+ .Where(v => built.Value.TryGetVertexPoint(v.Id, out _))+ .ToDictionary(v => v.Id, v =>+ {+ built.Value.TryGetVertexPoint(v.Id, out var point);+ return point;+ }),+ composition,+ built.Value.ShellRepresentation);+ }+}diff --git a/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedChamfer.cs b/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedChamfer.csindex 9c8f4e4c..8aff4a0d 100644--- a/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedChamfer.cs+++ b/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedChamfer.cs@@ -95,6 +95,13 @@ public static class BrepBoundedChamferBrepBoundedChamferEdge edge,double distance){+ if (edge.IsInternalConcaveToken())+ {+ return KernelResult<BrepBody>.Failure([Failure(+ "Bounded chamfer box-edge mode supports only external convex edge tokens; internal concave edge tokens require trusted occupied-cell concave-edge mode.",+ "firmament.chamfer-bounded")]);+ }+if (!double.IsFinite(distance) || distance <= 0d){return KernelResult<BrepBody>.Failure([Failure("Bounded chamfer distance must be finite and greater than 0.", "firmament.chamfer-bounded")]);@@ -127,6 +134,42 @@ public static class BrepBoundedChamferreturn BrepExtrude.Create(profile, frame, sizeZ);}+ public static KernelResult<BrepBody> ChamferTrustedPolyhedralSingleInternalConcaveEdge(+ BrepBody sourceBody,+ BrepBoundedChamferEdge edge,+ double distance)+ {+ var preflight = BrepBoundedConcaveChamferPreflight.ResolveInternalConcaveVerticalEdge(sourceBody.SafeBooleanComposition, edge, distance);+ if (!preflight.IsSuccess)+ {+ return KernelResult<BrepBody>.Failure(preflight.Diagnostics);+ }++ var context = new BrepBoundedConcaveChamferContext(+ IsPlanarPolyhedralSource: sourceBody.Bindings.FaceBindings.All(binding =>+ {+ var surface = sourceBody.Geometry.GetSurface(binding.SurfaceGeometryId);+ return surface.Kind == SurfaceGeometryKind.Plane;+ }),+ IsSingleEdgeSelection: true,+ IsEqualDistance: true,+ IsBoundedDistance: distance < preflight.Value.MaxAllowedDistance);+ var engine = new JudgmentEngine<BrepBoundedConcaveChamferContext>();+ var judgment = engine.Evaluate(context, BuildInternalConcaveEdgeCandidates());+ var selected = judgment.Selection?.Candidate.Name ?? RejectCandidate;+ if (!judgment.IsSuccess || selected == RejectCandidate)+ {+ var reason = judgment.Rejections.Count == 0+ ? "No bounded internal concave edge candidate was admissible."+ : string.Join(" ", judgment.Rejections.Select(rejection => $"{rejection.CandidateName}: {rejection.Reason}."));+ return KernelResult<BrepBody>.Failure([Failure($"Bounded concave edge resolution rejected: {reason}", "firmament.chamfer-bounded")]);+ }++ return KernelResult<BrepBody>.Failure([Failure(+ "Bounded concave edge preflight succeeded, but local loop rewrite construction is not yet implemented for this milestone slice.",+ "firmament.chamfer-bounded")]);+ }+private static PolylineProfile2D BuildProfile(AxisAlignedBoxExtents box, BrepBoundedChamferEdge edge, double d)=> CreateProfile(edge switch{@@ -179,6 +222,31 @@ public static class BrepBoundedChamferprivate static KernelDiagnostic Failure(string message, string source)=> new(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, message, Source: source);+ private static IReadOnlyList<JudgmentCandidate<BrepBoundedConcaveChamferContext>> BuildInternalConcaveEdgeCandidates()+ {+ var boundedConcavePlanarGuard = When.All<BrepBoundedConcaveChamferContext>(+ context => context.IsPlanarPolyhedralSource,+ context => context.IsSingleEdgeSelection,+ context => context.IsEqualDistance,+ context => context.IsBoundedDistance);++ return+ [+ new JudgmentCandidate<BrepBoundedConcaveChamferContext>(+ Name: "planar_internal_concave_edge_cut",+ IsAdmissible: boundedConcavePlanarGuard,+ Score: _ => 100d,+ RejectionReason: _ => "requires planar trusted-polyhedral source with one bounded internal concave edge and equal distance",+ TieBreakerPriority: 0),+ new JudgmentCandidate<BrepBoundedConcaveChamferContext>(+ Name: RejectCandidate,+ IsAdmissible: _ => true,+ Score: _ => 0d,+ RejectionReason: _ => "fallback reject candidate",+ TieBreakerPriority: 99)+ ];+ }+private static IReadOnlyList<JudgmentCandidate<BrepBoundedChamferCornerContext>> BuildCornerCandidates(){var planarCornerGuard = When.All<BrepBoundedChamferCornerContext>(@@ -1381,7 +1449,20 @@ public enum BrepBoundedChamferEdgeXMinYMin,XMinYMax,XMaxYMin,- XMaxYMax+ XMaxYMax,+ InnerXMinYMin,+ InnerXMinYMax,+ InnerXMaxYMin,+ InnerXMaxYMax+}++public static class BrepBoundedChamferEdgeExtensions+{+ public static bool IsInternalConcaveToken(this BrepBoundedChamferEdge edge)+ => edge is BrepBoundedChamferEdge.InnerXMinYMin+ or BrepBoundedChamferEdge.InnerXMinYMax+ or BrepBoundedChamferEdge.InnerXMaxYMin+ or BrepBoundedChamferEdge.InnerXMaxYMax;}public enum BrepBoundedChamferCornerIncidentEdge@@ -1395,3 +1476,9 @@ public readonly record struct BrepBoundedChamferIncidentEdgePairSelector(BrepBoundedChamferCorner Corner,BrepBoundedChamferCornerIncidentEdge First,BrepBoundedChamferCornerIncidentEdge Second);++internal readonly record struct BrepBoundedConcaveChamferContext(+ bool IsPlanarPolyhedralSource,+ bool IsSingleEdgeSelection,+ bool IsEqualDistance,+ bool IsBoundedDistance);diff --git a/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedConcaveChamferPreflight.cs b/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedConcaveChamferPreflight.csnew file mode 100644index 00000000..119736c9--- /dev/null+++ b/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedConcaveChamferPreflight.cs@@ -0,0 +1,163 @@+using Aetheris.Kernel.Core.Brep.Boolean;+using Aetheris.Kernel.Core.Diagnostics;+using Aetheris.Kernel.Core.Results;++namespace Aetheris.Kernel.Core.Brep.EdgeFinishing;++/// <summary>+/// Bounded concave chamfer preflight for explicit internal concave planar-planar vertical edges on+/// full-height occupied-cell additive-root sources.+/// This stage resolves selector + distance bounds and intentionally does not perform geometry rewrite.+/// </summary>+public static class BrepBoundedConcaveChamferPreflight+{+ public static KernelResult<BoundedConcaveChamferSelection> ResolveInternalConcaveVerticalEdge(+ SafeBooleanComposition? composition,+ BrepBoundedChamferEdge edge,+ double distance)+ {+ if (!edge.IsInternalConcaveToken())+ {+ return KernelResult<BoundedConcaveChamferSelection>.Failure([Failure(+ "Bounded concave chamfer preflight requires an explicit internal concave edge token.",+ "firmament.chamfer-bounded")]);+ }++ if (!double.IsFinite(distance) || distance <= 0d)+ {+ return KernelResult<BoundedConcaveChamferSelection>.Failure([Failure(+ "Bounded chamfer distance must be finite and greater than 0.",+ "firmament.chamfer-bounded")]);+ }++ var cells = composition?.OccupiedCells;+ if (cells is null || cells.Count == 0)+ {+ return KernelResult<BoundedConcaveChamferSelection>.Failure([Failure(+ "Bounded concave chamfer requires occupied-cell additive-root metadata for internal-edge resolution.",+ "firmament.chamfer-bounded")]);+ }++ var minZ = cells[0].MinZ;+ var maxZ = cells[0].MaxZ;+ for (var i = 1; i < cells.Count; i++)+ {+ if (!NearlyEqual(cells[i].MinZ, minZ) || !NearlyEqual(cells[i].MaxZ, maxZ))+ {+ return KernelResult<BoundedConcaveChamferSelection>.Failure([Failure(+ "Bounded concave chamfer currently supports full-height prismatic occupied-cell roots only; mixed-Z occupied cells are outside this milestone.",+ "firmament.chamfer-bounded")]);+ }+ }++ var xCoords = cells.SelectMany(cell => new[] { cell.MinX, cell.MaxX }).Distinct().OrderBy(v => v).ToArray();+ var yCoords = cells.SelectMany(cell => new[] { cell.MinY, cell.MaxY }).Distinct().OrderBy(v => v).ToArray();+ if (xCoords.Length < 2 || yCoords.Length < 2)+ {+ return KernelResult<BoundedConcaveChamferSelection>.Failure([Failure(+ "Bounded concave chamfer preflight could not recover a usable XY cell grid.",+ "firmament.chamfer-bounded")]);+ }++ var occupied = new bool[xCoords.Length - 1, yCoords.Length - 1];+ for (var xi = 0; xi < xCoords.Length - 1; xi++)+ {+ for (var yi = 0; yi < yCoords.Length - 1; yi++)+ {+ var cx = 0.5d * (xCoords[xi] + xCoords[xi + 1]);+ var cy = 0.5d * (yCoords[yi] + yCoords[yi + 1]);+ occupied[xi, yi] = cells.Any(cell =>+ cx > cell.MinX && cx < cell.MaxX &&+ cy > cell.MinY && cy < cell.MaxY);+ }+ }++ var corners = new List<BoundedConcaveChamferCornerCandidate>();+ for (var xi = 1; xi < xCoords.Length - 1; xi++)+ {+ for (var yi = 1; yi < yCoords.Length - 1; yi++)+ {+ var sw = occupied[xi - 1, yi - 1];+ var se = occupied[xi, yi - 1];+ var nw = occupied[xi - 1, yi];+ var ne = occupied[xi, yi];+ var occupiedCount = (sw ? 1 : 0) + (se ? 1 : 0) + (nw ? 1 : 0) + (ne ? 1 : 0);+ if (occupiedCount != 3)+ {+ continue;+ }++ var maxDistance = System.Math.Min(+ System.Math.Min(xCoords[xi] - xCoords[xi - 1], xCoords[xi + 1] - xCoords[xi]),+ System.Math.Min(yCoords[yi] - yCoords[yi - 1], yCoords[yi + 1] - yCoords[yi]));+ if (maxDistance <= 0d || !double.IsFinite(maxDistance))+ {+ continue;+ }++ corners.Add(new BoundedConcaveChamferCornerCandidate(xCoords[xi], yCoords[yi], maxDistance));+ }+ }++ if (corners.Count == 0)+ {+ return KernelResult<BoundedConcaveChamferSelection>.Failure([Failure(+ "Bounded concave chamfer supports explicit internal concave planar-planar vertical edges only; no qualifying edge was found.",+ "firmament.chamfer-bounded")]);+ }++ var selected = SelectCorner(edge, corners);+ if (selected is null)+ {+ return KernelResult<BoundedConcaveChamferSelection>.Failure([Failure(+ "Bounded concave chamfer edge token did not resolve to a unique internal concave edge candidate on this source body.",+ "firmament.chamfer-bounded")]);+ }++ if (distance >= selected.Value.MaxAllowedDistance)+ {+ return KernelResult<BoundedConcaveChamferSelection>.Failure([Failure(+ "Bounded chamfer distance is too large for the selected internal concave edge; distance must be strictly less than the local bounded neighborhood extent.",+ "firmament.chamfer-bounded")]);+ }++ return KernelResult<BoundedConcaveChamferSelection>.Success(new BoundedConcaveChamferSelection(+ selected.Value.X,+ selected.Value.Y,+ minZ,+ maxZ,+ selected.Value.MaxAllowedDistance));+ }++ private static BoundedConcaveChamferCornerCandidate? SelectCorner(+ BrepBoundedChamferEdge edge,+ IReadOnlyList<BoundedConcaveChamferCornerCandidate> corners)+ {+ var orderedByXThenY = corners.OrderBy(c => c.X).ThenBy(c => c.Y).ToArray();+ var orderedByXThenYDesc = corners.OrderByDescending(c => c.X).ThenBy(c => c.Y).ToArray();++ return edge switch+ {+ BrepBoundedChamferEdge.InnerXMinYMin => orderedByXThenY.First(),+ BrepBoundedChamferEdge.InnerXMinYMax => orderedByXThenY.OrderByDescending(c => c.Y).First(),+ BrepBoundedChamferEdge.InnerXMaxYMin => orderedByXThenYDesc.First(),+ BrepBoundedChamferEdge.InnerXMaxYMax => orderedByXThenYDesc.OrderByDescending(c => c.Y).First(),+ _ => null+ };+ }++ private static bool NearlyEqual(double a, double b)+ => System.Math.Abs(a - b) <= 1e-9;++ private static KernelDiagnostic Failure(string message, string source)+ => new(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, message, Source: source);++ private readonly record struct BoundedConcaveChamferCornerCandidate(double X, double Y, double MaxAllowedDistance);+}++public readonly record struct BoundedConcaveChamferSelection(+ double EdgeX,+ double EdgeY,+ double MinZ,+ double MaxZ,+ double MaxAllowedDistance);diff --git a/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedEdgeFinishingToolParser.cs b/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedEdgeFinishingToolParser.csindex 2444ce68..b6445336 100644--- a/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedEdgeFinishingToolParser.cs+++ b/Aetheris.Kernel.Core/Brep/EdgeFinishing/BrepBoundedEdgeFinishingToolParser.cs@@ -179,12 +179,17 @@ public static class BrepBoundedEdgeFinishingToolParser"x_min_y_max" => BrepBoundedChamferEdge.XMinYMax,"x_max_y_min" => BrepBoundedChamferEdge.XMaxYMin,"x_max_y_max" => BrepBoundedChamferEdge.XMaxYMax,+ "inner_x_min_y_min" => BrepBoundedChamferEdge.InnerXMinYMin,+ "inner_x_min_y_max" => BrepBoundedChamferEdge.InnerXMinYMax,+ "inner_x_max_y_min" => BrepBoundedChamferEdge.InnerXMaxYMin,+ "inner_x_max_y_max" => BrepBoundedChamferEdge.InnerXMaxYMax,_ => default};- if (tokens[i] is not ("x_min_y_min" or "x_min_y_max" or "x_max_y_min" or "x_max_y_max"))+ if (tokens[i] is not ("x_min_y_min" or "x_min_y_max" or "x_max_y_min" or "x_max_y_max"+ or "inner_x_min_y_min" or "inner_x_min_y_max" or "inner_x_max_y_min" or "inner_x_max_y_max")){- error = "supported tokens are x_min_y_min, x_min_y_max, x_max_y_min, x_max_y_max";+ error = "supported tokens are x_min_y_min, x_min_y_max, x_max_y_min, x_max_y_max, inner_x_min_y_min, inner_x_min_y_max, inner_x_max_y_min, inner_x_max_y_max";return false;}}diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.csindex ffc1b2ae..ac41f877 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs@@ -225,7 +225,7 @@ public sealed class FirmamentBooleanRequiredFieldValidationTestsdistance: 1""",FirmamentDiagnosticCodes.BooleanInvalidFieldValue,- "Boolean op 'chamfer' at index 1 has invalid field 'edges'; supported bounded M5a edge tokens are x_min_y_min, x_min_y_max, x_max_y_min, x_max_y_max.");+ "Boolean op 'chamfer' at index 1 has invalid field 'edges'; supported bounded M5a edge tokens are x_min_y_min, x_min_y_max, x_max_y_min, x_max_y_max, inner_x_min_y_min, inner_x_min_y_max, inner_x_max_y_min, inner_x_max_y_max.");[Fact]public void Compiler_Rejects_ChamferCornerIncidentEdgeSelector_DuplicateEdgeToken() =>diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.csindex 544fb5f1..6facb0a0 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs@@ -381,6 +381,17 @@ public sealed class FirmamentPrimitiveExecutionTests|| diagnostic.Message.Contains("distance is too large", StringComparison.Ordinal));}+ [Fact]+ public void Compile_Rejects_BoundedConcaveChamfer_When_Source_Has_NoOccupiedCellMetadata()+ {+ var result = CompileFixture("testdata/firmament/fixtures/e7-invalid-chamfer-concave-lroot-not-implemented.firmament");++ Assert.False(result.Compilation.IsSuccess);+ Assert.Contains(result.Compilation.Diagnostics, diagnostic =>+ diagnostic.Source == "firmament.chamfer-bounded"+ && diagnostic.Message.Contains("occupied-cell additive-root metadata", StringComparison.Ordinal));+ }+[Fact]public void Compile_BoundedFilletCanonicalInternalCase_Reaches_Narrow_TruthfulRebuildBlocker(){diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.csindex 54c6e2ca..ec369135 100644--- a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs@@ -752,6 +752,25 @@ internal static class FirmamentPrimitiveExecutorif (edge.HasValue){+ if (edge.Value.IsInternalConcaveToken())+ {+ if (sourceState is not (FirmamentSafeSubtractFeatureGraphState.BoundedOrthogonalAdditiveSafeRoot+ or FirmamentSafeSubtractFeatureGraphState.BoundedOrthogonalAdditiveOutsideSafeRoot+ or FirmamentSafeSubtractFeatureGraphState.SafeSubtractComposition))+ {+ return KernelResult<BrepBody>.Failure(+ [+ new KernelDiagnostic(+ KernelDiagnosticCode.ValidationFailed,+ KernelDiagnosticSeverity.Error,+ $"Bounded concave chamfer edge mode requires a recognized occupied-cell additive or safe-subtract composition root input; '{boolean.PrimaryReferenceFeatureId}' is not eligible.",+ Source: "firmament.chamfer-bounded")+ ]);+ }++ return BrepBoundedChamfer.ChamferTrustedPolyhedralSingleInternalConcaveEdge(baseBody, edge.Value, distance);+ }+if (sourceState is not (FirmamentSafeSubtractFeatureGraphState.BoxRoot or FirmamentSafeSubtractFeatureGraphState.BoundedOrthogonalAdditiveSafeRoot)){return KernelResult<BrepBody>.Failure(diff --git a/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs b/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.csindex 13f6a3a1..a6669c8d 100644--- a/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs@@ -217,9 +217,10 @@ internal static class FirmamentBooleanRequiredFieldValidatorreturn InvalidFieldTypeOrShape("edges", opIndex, entry.OpName, "expected a single-item string array with one explicit edge token");}- if (edgeTokens.Any(token => token is not ("x_min_y_min" or "x_min_y_max" or "x_max_y_min" or "x_max_y_max")))+ if (edgeTokens.Any(token => token is not ("x_min_y_min" or "x_min_y_max" or "x_max_y_min" or "x_max_y_max"+ or "inner_x_min_y_min" or "inner_x_min_y_max" or "inner_x_max_y_min" or "inner_x_max_y_max"))){- return InvalidFieldValue("edges", opIndex, entry.OpName, "supported bounded M5a edge tokens are x_min_y_min, x_min_y_max, x_max_y_min, x_max_y_max");+ return InvalidFieldValue("edges", opIndex, entry.OpName, "supported bounded M5a edge tokens are x_min_y_min, x_min_y_max, x_max_y_min, x_max_y_max, inner_x_min_y_min, inner_x_min_y_max, inner_x_max_y_min, inner_x_max_y_max");}}elsediff --git a/testdata/firmament/fixtures/e7-invalid-chamfer-concave-lroot-not-implemented.firmament b/testdata/firmament/fixtures/e7-invalid-chamfer-concave-lroot-not-implemented.firmamentnew file mode 100644index 00000000..d6db8899--- /dev/null+++ b/testdata/firmament/fixtures/e7-invalid-chamfer-concave-lroot-not-implemented.firmament@@ -0,0 +1,38 @@+firmament:+ version: 1++model:+ name: e7_invalid_chamfer_concave_lroot_not_implemented+ units: mm++ops[3]:+ -+ op: box+ id: base+ size[3]:+ 30+ 20+ 10+ -+ op: add+ id: lroot+ to: base+ with:+ op: box+ size[3]:+ 10+ 10+ 10+ place:+ on: origin+ offset[3]:+ -10+ 0+ 0+ -+ op: chamfer+ id: inner_edge_break+ from: lroot+ edges[1]:+ inner_x_max_y_max+ distance: 1