Skip to content

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.cs
new file mode 100644
index 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.cs
index 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 BrepBoundedChamfer
BrepBoundedChamferEdge 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 BrepBoundedChamfer
return 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 BrepBoundedChamfer
private 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 BrepBoundedChamferEdge
XMinYMin,
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.cs
new file mode 100644
index 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.cs
index 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.cs
index ffc1b2ae..ac41f877 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs
@@ -225,7 +225,7 @@ public sealed class FirmamentBooleanRequiredFieldValidationTests
distance: 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.cs
index 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.cs
index 54c6e2ca..ec369135 100644
--- a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
@@ -752,6 +752,25 @@ internal static class FirmamentPrimitiveExecutor
if (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.cs
index 13f6a3a1..a6669c8d 100644
--- a/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs
+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs
@@ -217,9 +217,10 @@ internal static class FirmamentBooleanRequiredFieldValidator
return 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");
}
}
else
diff --git a/testdata/firmament/fixtures/e7-invalid-chamfer-concave-lroot-not-implemented.firmament b/testdata/firmament/fixtures/e7-invalid-chamfer-concave-lroot-not-implemented.firmament
new file mode 100644
index 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