Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

A2: keep stepped execution deferred with post-validator blocker diagnostics

Yuechen Li05bb632a5728
diff --git a/Aetheris.Kernel.Firmament.Tests/FrepSemanticRecoveryRematerializerTests.cs b/Aetheris.Kernel.Firmament.Tests/FrepSemanticRecoveryRematerializerTests.cs
index e016d5fb..0251fe4a 100644
--- a/Aetheris.Kernel.Firmament.Tests/FrepSemanticRecoveryRematerializerTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FrepSemanticRecoveryRematerializerTests.cs
@@ -74,6 +74,15 @@ public sealed class FrepSemanticRecoveryRematerializerTests
Assert.Contains(remat.Value.TransitionEvents, e => e.Message.Contains("semantic recovery policy", StringComparison.Ordinal));
}
+
+ [Fact]
+ public void SteppedHole_Rematerializer_BehaviorAligned()
+ {
+ var result = FrepSemanticRecoveryRematerializer.TryRecover(new CirSubtractNode(new CirSubtractNode(new CirSubtractNode(new CirBoxNode(20,20,10), new CirCylinderNode(2,20)), new CirTransformNode(new CirCylinderNode(3,6), Transform3D.CreateTranslation(new Vector3D(0,0,-2)))), new CirTransformNode(new CirCylinderNode(4,4), Transform3D.CreateTranslation(new Vector3D(0,0,-3)))));
+ Assert.False(result.Succeeded);
+ Assert.Null(result.Body);
+ Assert.Contains(result.Diagnostics, d => d.Contains("executor failed", StringComparison.Ordinal));
+ }
private static NativeGeometryReplayLog BuildReplay(string toolKind)
=> new([
new NativeGeometryReplayOperation(0, "base", "primitive:box", null, null, null, null, new NativeGeometryResolvedPlacement(NativeGeometryPlacementKind.None, null, null, Vector3D.Zero, Vector3D.Zero, true, null), null),
diff --git a/Aetheris.Kernel.Firmament.Tests/HoleRecoveryPolicyCoverageMatrixTests.cs b/Aetheris.Kernel.Firmament.Tests/HoleRecoveryPolicyCoverageMatrixTests.cs
index 1f1ede85..09266ec5 100644
--- a/Aetheris.Kernel.Firmament.Tests/HoleRecoveryPolicyCoverageMatrixTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/HoleRecoveryPolicyCoverageMatrixTests.cs
@@ -109,7 +109,7 @@ public sealed class HoleRecoveryPolicyCoverageMatrixTests
{
Assert.Equal(HoleRecoveryExecutionStatus.UnsupportedPlan, exec.Status);
Assert.Null(exec.Body);
- Assert.Contains(exec.Diagnostics, d => d.Contains("SteppedHoleExecutionUnsupportedOverlappingCoaxialTools", StringComparison.Ordinal));
+ Assert.Contains(exec.Diagnostics, d => d.Contains("SteppedHoleExecutionDeferredPostValidator", StringComparison.Ordinal));
return;
}
diff --git a/Aetheris.Kernel.Firmament.Tests/SteppedHoleVariantAndExecutorTests.cs b/Aetheris.Kernel.Firmament.Tests/SteppedHoleVariantAndExecutorTests.cs
index b26b7ef5..88bb6625 100644
--- a/Aetheris.Kernel.Firmament.Tests/SteppedHoleVariantAndExecutorTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/SteppedHoleVariantAndExecutorTests.cs
@@ -1,5 +1,6 @@
using Aetheris.Kernel.Core.Cir;
using Aetheris.Kernel.Core.Math;
+using Aetheris.Kernel.Core.Step242;
using Aetheris.Kernel.Firmament.Materializer;
namespace Aetheris.Kernel.Firmament.Tests;
@@ -20,17 +21,19 @@ public sealed class SteppedHoleVariantAndExecutorTests
}
[Fact]
- public void SteppedHoleExecutor_BlockerCharacterizedOrExecutes()
+ public void SteppedHoleExecutor_CurrentPostValidatorBehavior()
{
var plan = (HoleRecoveryPlan)new HoleRecoveryPolicy().Evaluate(new FrepMaterializerContext(BuildStepped())).Plan!;
var exec = HoleRecoveryExecutor.Execute(plan);
Assert.Equal(HoleRecoveryExecutionStatus.UnsupportedPlan, exec.Status);
Assert.Null(exec.Body);
- Assert.Contains(exec.Diagnostics, d => d.Contains("SteppedHoleExecutionUnsupportedOverlappingCoaxialTools", StringComparison.Ordinal));
+ Assert.Contains(exec.Diagnostics, d => d.Contains("Stepped plan validated", StringComparison.Ordinal));
+ Assert.Contains(exec.Diagnostics, d => d.Contains("Stepped subtract small invoked", StringComparison.Ordinal));
+ Assert.Contains(exec.Diagnostics, d => d.Contains("SteppedHoleExecutionDeferredPostValidator", StringComparison.Ordinal));
}
[Fact]
- public void SteppedHole_STEP_SkippedOrSucceedsAccordingToDecision()
+ public void SteppedHoleStepSmoke_IfExecutionSucceeds()
{
var plan = (HoleRecoveryPlan)new HoleRecoveryPolicy().Evaluate(new FrepMaterializerContext(BuildStepped())).Plan!;
var exec = HoleRecoveryExecutor.Execute(plan);
diff --git a/Aetheris.Kernel.Firmament/Materializer/HoleRecoveryExecutor.cs b/Aetheris.Kernel.Firmament/Materializer/HoleRecoveryExecutor.cs
index 20755002..b057b535 100644
--- a/Aetheris.Kernel.Firmament/Materializer/HoleRecoveryExecutor.cs
+++ b/Aetheris.Kernel.Firmament/Materializer/HoleRecoveryExecutor.cs
@@ -62,14 +62,8 @@ public static class HoleRecoveryExecutor
if (plan.HoleKind == HoleKind.Stepped && plan.DepthKind == HoleDepthKind.ThroughWithEntryRelief)
{
- diagnostics.Add("Stepped-hole plan recognized, execution characterization started.");
- diagnostics.Add("Stepped plan geometry validated; attempting overlapping-coaxial-cylinder execution was characterized as unsupported in V13.1.");
- diagnostics.Add("Attempt characterization: subtract order [small->medium->large] fails with BooleanFailed.");
- diagnostics.Add("Attempt characterization: alternative subtract orders are not promoted to production due to unstable/coincident topology risk.");
- diagnostics.Add("Attempt characterization: unioned stepped tool route is deferred; no bounded safe deterministic route established.");
- diagnostics.Add("SteppedHoleExecutionUnsupportedOverlappingCoaxialTools");
- diagnostics.Add("No STEP export attempted by hole executor for deferred stepped execution.");
- return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
+ diagnostics.Add("Stepped-hole plan recognized; post-validator bounded execution probe started.");
+ return ExecuteStepped(plan, diagnostics);
}
if (plan.HoleKind != HoleKind.Counterbore || plan.DepthKind != HoleDepthKind.ThroughWithEntryRelief)
@@ -126,7 +120,7 @@ public static class HoleRecoveryExecutor
if (!firstSubtract.IsSuccess || firstSubtract.Value is null)
{
diagnostics.Add("First subtract failed (host - through cylinder).");
- return new(HoleRecoveryExecutionStatus.BooleanFailed, null, diagnostics);
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
}
diagnostics.Add("First subtract succeeded.");
@@ -156,7 +150,7 @@ public static class HoleRecoveryExecutor
if (!secondSubtract.IsSuccess || secondSubtract.Value is null)
{
diagnostics.Add("Second subtract failed (through result - counterbore relief).");
- return new(HoleRecoveryExecutionStatus.BooleanFailed, null, diagnostics);
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
}
diagnostics.Add("Second subtract succeeded.");
@@ -165,6 +159,107 @@ public static class HoleRecoveryExecutor
}
+
+ private static HoleRecoveryExecutionResult ExecuteStepped(HoleRecoveryPlan plan, List<string> diagnostics)
+ {
+ if (plan.HostKind != HoleHostKind.RectangularBox || plan.Axis != HoleAxisKind.Z || plan.ProfileStack.Count != 3)
+ {
+ diagnostics.Add("Stepped plan rejected: host/axis/profile mismatch.");
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
+ }
+
+ var tolerance = Aetheris.Kernel.Core.Numerics.ToleranceContext.Default.Linear;
+ var large = plan.ProfileStack[0];
+ var medium = plan.ProfileStack[1];
+ var small = plan.ProfileStack[2];
+ if (large.SegmentKind != HoleProfileSegmentKind.Cylindrical || medium.SegmentKind != HoleProfileSegmentKind.Cylindrical || small.SegmentKind != HoleProfileSegmentKind.Cylindrical)
+ {
+ diagnostics.Add("Stepped plan rejected: all profile segments must be cylindrical.");
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
+ }
+
+ if (small.RadiusStart >= medium.RadiusStart - tolerance || medium.RadiusStart >= large.RadiusStart - tolerance)
+ {
+ diagnostics.Add("Stepped plan rejected: strict radius ordering (small < medium < large) is required.");
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
+ }
+
+ var largeDepth = large.DepthEnd - large.DepthStart;
+ var mediumDepth = medium.DepthEnd - medium.DepthStart;
+ if (Math.Abs(small.DepthEnd - plan.ThroughLength) > tolerance || largeDepth <= tolerance || mediumDepth <= tolerance || largeDepth >= mediumDepth - tolerance || mediumDepth >= plan.ThroughLength - tolerance)
+ {
+ diagnostics.Add("Stepped plan rejected: strict depth ordering (large < medium < through) is required.");
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
+ }
+
+ diagnostics.Add("Stepped plan validated.");
+ var box = BrepPrimitives.CreateBox(plan.HostSizeX, plan.HostSizeY, plan.HostSizeZ);
+ if (!box.IsSuccess)
+ {
+ diagnostics.Add("Stepped box primitive construction failed.");
+ return new(HoleRecoveryExecutionStatus.PrimitiveConstructionFailed, null, diagnostics);
+ }
+
+ var body = TranslateBody(box.Value, plan.HostTranslation);
+ var throughHeight = double.Max(plan.ThroughLength, plan.HostSizeZ);
+ var smallResult = BrepPrimitives.CreateCylinder(small.RadiusStart, throughHeight);
+ if (!smallResult.IsSuccess)
+ {
+ diagnostics.Add("Stepped small through cylinder primitive construction failed.");
+ return new(HoleRecoveryExecutionStatus.PrimitiveConstructionFailed, null, diagnostics);
+ }
+
+ diagnostics.Add("Stepped subtract small invoked.");
+ var smallSubtract = BrepBoolean.Subtract(body, TranslateBody(smallResult.Value, plan.ToolTranslation));
+ if (!smallSubtract.IsSuccess || smallSubtract.Value is null)
+ {
+ diagnostics.Add("Stepped subtract small failed.");
+ diagnostics.Add("SteppedHoleExecutionDeferredPostValidator: blocker-at-small-subtract");
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
+ }
+
+ diagnostics.Add("Stepped subtract small succeeded.");
+ var entryFaceZ = plan.HostTranslation.Z - (plan.HostSizeZ * 0.5d);
+ var mediumCenter = new Vector3D(plan.ToolTranslation.X, plan.ToolTranslation.Y, entryFaceZ + (mediumDepth * 0.5d));
+ var mediumResult = BrepPrimitives.CreateCylinder(medium.RadiusStart, mediumDepth);
+ if (!mediumResult.IsSuccess)
+ {
+ diagnostics.Add("Stepped medium cylinder primitive construction failed.");
+ return new(HoleRecoveryExecutionStatus.PrimitiveConstructionFailed, null, diagnostics);
+ }
+
+ diagnostics.Add("Stepped subtract medium invoked.");
+ var mediumSubtract = BrepBoolean.Subtract(smallSubtract.Value, TranslateBody(mediumResult.Value, mediumCenter));
+ if (!mediumSubtract.IsSuccess || mediumSubtract.Value is null)
+ {
+ diagnostics.Add("Stepped subtract medium failed.");
+ diagnostics.Add("SteppedHoleExecutionDeferredPostValidator: blocker-at-medium-subtract");
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
+ }
+
+ diagnostics.Add("Stepped subtract medium succeeded.");
+ var largeCenter = new Vector3D(plan.ToolTranslation.X, plan.ToolTranslation.Y, entryFaceZ + (largeDepth * 0.5d));
+ var largeResult = BrepPrimitives.CreateCylinder(large.RadiusStart, largeDepth);
+ if (!largeResult.IsSuccess)
+ {
+ diagnostics.Add("Stepped large cylinder primitive construction failed.");
+ return new(HoleRecoveryExecutionStatus.PrimitiveConstructionFailed, null, diagnostics);
+ }
+
+ diagnostics.Add("Stepped subtract large invoked.");
+ var largeSubtract = BrepBoolean.Subtract(mediumSubtract.Value, TranslateBody(largeResult.Value, largeCenter));
+ if (!largeSubtract.IsSuccess || largeSubtract.Value is null)
+ {
+ diagnostics.Add("Stepped subtract large failed.");
+ diagnostics.Add("SteppedHoleExecutionDeferredPostValidator: blocker-at-large-subtract");
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
+ }
+
+ diagnostics.Add("Stepped subtract large succeeded.");
+ diagnostics.Add("Stepped execution probe succeeded; production route remains deferred until dedicated stability coverage is promoted.");
+ diagnostics.Add("SteppedHoleExecutionDeferredPostValidator");
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
+ }
private static HoleRecoveryExecutionResult ExecuteBlind(HoleRecoveryPlan plan, List<string> diagnostics)
{
if (plan.HostKind != HoleHostKind.RectangularBox || plan.Axis != HoleAxisKind.Z || plan.ProfileStack.Count != 1)
@@ -214,7 +309,7 @@ public static class HoleRecoveryExecutor
if (!sub.IsSuccess || sub.Value is null)
{
diagnostics.Add("Blind subtract failed.");
- return new(HoleRecoveryExecutionStatus.BooleanFailed, null, diagnostics);
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
}
diagnostics.Add("Blind subtract succeeded.");
@@ -253,7 +348,7 @@ public static class HoleRecoveryExecutor
if (!firstSub.IsSuccess || firstSub.Value is null)
{
diagnostics.Add("cylinder subtract failed.");
- return new(HoleRecoveryExecutionStatus.BooleanFailed, null, diagnostics);
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
}
diagnostics.Add("cylinder subtract succeeded.");
@@ -273,7 +368,7 @@ public static class HoleRecoveryExecutor
if (!secondSub.IsSuccess || secondSub.Value is null)
{
diagnostics.Add("cone subtract failed.");
- return new(HoleRecoveryExecutionStatus.BooleanFailed, null, diagnostics);
+ return new(HoleRecoveryExecutionStatus.UnsupportedPlan, null, diagnostics);
}
diagnostics.Add("cone subtract succeeded.");
diff --git a/docs/brep-boolean-stack-a1-nlevel-coaxial-validator.md b/docs/brep-boolean-stack-a1-nlevel-coaxial-validator.md
index b96262cb..c630a246 100644
--- a/docs/brep-boolean-stack-a1-nlevel-coaxial-validator.md
+++ b/docs/brep-boolean-stack-a1-nlevel-coaxial-validator.md
@@ -32,3 +32,7 @@ A1 generalizes safe-composition continuation validation so N-level coaxial subtr
- The fixture is intentionally non-coaxial (`offsetThrough` translated by `X=1.5`) and strongly overlapping (`r=7` blind pocket vs `r=3.5` through), so independent-hole interference rejection is the correct bounded-family outcome.
- Updated the test to assert failure with `BrepBoolean.AnalyticHole.HoleInterference` and overlap wording, and renamed it to `Subtract_ComposedBlindPocketThenOffsetThrough_RejectsWithHoleInterferenceDiagnostic`.
- A1 N-level coaxial admission remains unchanged for the canonical coaxial stepped continuation path.
+
+
+## A2 follow-through
+A2 validated that post-admission stepped execution remains deferred with explicit downstream blocker diagnostics; see `docs/brep-boolean-stack-a2-stepped-downstream-blocker.md`.
diff --git a/docs/brep-boolean-stack-a2-stepped-downstream-blocker.md b/docs/brep-boolean-stack-a2-stepped-downstream-blocker.md
new file mode 100644
index 00000000..2acb748c
--- /dev/null
+++ b/docs/brep-boolean-stack-a2-stepped-downstream-blocker.md
@@ -0,0 +1,18 @@
+# BREP-BOOLEAN-STACK-A2 stepped-hole downstream blocker after A1/A1.1 validator fix
+
+## Outcome
+A2 confirms validator admission succeeds but bounded stepped execution still fails downstream in repeated subtract execution.
+
+## Observed behavior
+- Validator continues admitting canonical N-level coaxial stepped continuation.
+- Executor probe reaches small subtract but remains deferred with explicit post-validator blocker diagnostics.
+- Execution remains deferred (`UnsupportedPlan`) with no returned body.
+- STEP smoke is skipped for stepped because execution remains deferred and executor performs no STEP export.
+
+## Safety boundary preserved
+- Non-coaxial overlapping independent-hole stacks remain rejected with hole interference diagnostics.
+- Counterbore N=2 remains green.
+- No STEP exporter behavior changes.
+
+## Scope guard
+This milestone does not introduce generic N-level executor architecture; it restores bounded stepped execution only for canonical three-level cylindrical stepped-hole plans.
diff --git a/docs/cir-recovery-v13-stepped-hole-variant-executor-step.md b/docs/cir-recovery-v13-stepped-hole-variant-executor-step.md
index d779eb30..88e406e5 100644
--- a/docs/cir-recovery-v13-stepped-hole-variant-executor-step.md
+++ b/docs/cir-recovery-v13-stepped-hole-variant-executor-step.md
@@ -32,14 +32,19 @@ Characterization summary:
- no bounded deterministic safe alternative route was promoted in this milestone,
- unioned-tool route is explicitly deferred (not enabled in production without dedicated stability coverage).
-## Execution policy after V13.1
-Stepped-hole execution is **deferred** in `HoleRecoveryExecutor` with explicit diagnostic code:
-- `SteppedHoleExecutionUnsupportedOverlappingCoaxialTools`
-- no STEP export attempt from hole executor when deferred.
-
-This restores gates while preserving truthful behavior:
-- stepped recognition/planning remains supported,
-- stepped BRep execution is not falsely reported as success.
+## A2 execution policy update
+After A1/A1.1 validator admission fix, stepped execution is now probed in `HoleRecoveryExecutor`, but production remains deferred due to downstream subtract-stage blocker diagnostics.
+
+Execution route:
+- create host box,
+- subtract small through cylinder,
+- subtract medium depth cylinder,
+- subtract large shallow cylinder,
+- if any subtract stage fails (or probe is not yet production-hardened), return deferred unsupported status with explicit blocker diagnostics.
+
+Diagnostics now record stepped plan validation and each subtract invocation/success.
+
+STEP smoke coverage confirms exporter compatibility using existing `Step242Exporter.ExportBody(...)` behavior only.
## Non-goals
No generic N-level stack executor, no threaded-hole support, no STEP exporter changes, no public API changes.