Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

AIR-V2B stabilize: defer blind AIR emission and tighten diagnostics/tests

Yuechen Lid50ae0615bee
diff --git a/Aetheris.Kernel.Firmament.Tests/AirProfileStackExtrudeTests.cs b/Aetheris.Kernel.Firmament.Tests/AirProfileStackExtrudeTests.cs
index bf953a44..461a71be 100644
--- a/Aetheris.Kernel.Firmament.Tests/AirProfileStackExtrudeTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/AirProfileStackExtrudeTests.cs
@@ -41,23 +41,25 @@ public sealed class AirProfileStackExtrudeTests
}
[Fact]
- public void BlindHole_AirV2A_FinalRouteStatus()
+ public void BlindHole_AirV2B_FinalRouteStatus()
{
var plan = (HoleRecoveryPlan)new HoleRecoveryPolicy().Evaluate(new FrepMaterializerContext(new CirSubtractNode(new CirBoxNode(20,20,10), new CirTransformNode(new CirCylinderNode(2,4), Transform3D.CreateTranslation(new Vector3D(0,0,3)))))).Plan!;
Assert.False(AirProfileStackExtrudeAdapter.TryFromHoleRecoveryPlan(plan, out _, out var d));
- Assert.Contains(d, x => x.Contains("air-profile-stack-v1-blind-deferred", StringComparison.Ordinal));
+ Assert.Contains(d, x => x.Contains("air-profile-stack-v2b-blind-solid-interval-recognized", StringComparison.Ordinal));
+ Assert.Contains(d, x => x.Contains("air-profile-stack-v2b-blind-emitter-deferred", StringComparison.Ordinal));
var exec = HoleRecoveryExecutor.Execute(plan);
Assert.Equal(HoleRecoveryExecutionStatus.Succeeded, exec.Status);
+ Assert.Contains(exec.Diagnostics, x => x.Contains("air-profile-stack-v2b-fallback-legacy-blind", StringComparison.Ordinal));
Assert.Contains(exec.Diagnostics, x => x.Contains("Blind subtract succeeded", StringComparison.Ordinal));
}
[Fact]
- public void Counterbore_AirV2A_FinalRouteStatus()
+ public void Counterbore_AirV2B_FinalRouteStatus()
{
var root = new CirSubtractNode(new CirSubtractNode(new CirBoxNode(20,20,10), new CirCylinderNode(2,20)), new CirTransformNode(new CirCylinderNode(4,4), Transform3D.CreateTranslation(new Vector3D(0,0,3))));
var plan = (HoleRecoveryPlan)new HoleRecoveryPolicy().Evaluate(new FrepMaterializerContext(root)).Plan!;
- Assert.False(AirProfileStackExtrudeAdapter.TryFromHoleRecoveryPlan(plan, out _, out var d));
- Assert.Contains(d, x => x.Contains("air-profile-stack-v1-counterbore-deferred", StringComparison.Ordinal));
+ Assert.True(AirProfileStackExtrudeAdapter.TryFromHoleRecoveryPlan(plan, out _, out var d));
+ Assert.Contains(d, x => x.Contains("air-profile-stack-v2b-counterbore-contiguous-accepted", StringComparison.Ordinal));
var exec = HoleRecoveryExecutor.Execute(plan);
Assert.Equal(HoleRecoveryExecutionStatus.Succeeded, exec.Status);
Assert.Contains(exec.Diagnostics, x => x.Contains("Second subtract succeeded", StringComparison.Ordinal));
@@ -77,11 +79,21 @@ public sealed class AirProfileStackExtrudeTests
public void NoHoleLayer_CurrentExpectedBehavior()
{
var air = new AirProfileStackExtrude([
- new AirProfileStackLayer(-5,0,new AirProfileRegion2D(new AirRectangleProfile(20,20),new AirCenteredCircleLoop(2),"a",[]),"a",[]),
- new AirProfileStackLayer(1,5,new AirProfileRegion2D(new AirRectangleProfile(20,20),new AirCenteredCircleLoop(3),"b",[]),"b",[])
+ new AirProfileStackLayer(-5,0,new AirProfileRegion2D(new AirRectangleProfile(20,20),new AirCenteredCircleLoop(2),AirProfileStackLayerKind.CircularCutInterval,"a",[]),"a",[]),
+ new AirProfileStackLayer(1,5,new AirProfileRegion2D(new AirRectangleProfile(20,20),new AirCenteredCircleLoop(3),AirProfileStackLayerKind.CircularCutInterval,"b",[]),"b",[])
],-5,5,[],[]);
Assert.False(AirProfileStackExtrudeAdapter.TryToProfileStackSpec(air, out _, out _));
}
+ [Fact]
+ public void SolidLayer_WithInnerLoop_IsDeterministicallyInvalid()
+ {
+ var air = new AirProfileStackExtrude([
+ new AirProfileStackLayer(-5,5,new AirProfileRegion2D(new AirRectangleProfile(20,20),new AirCenteredCircleLoop(2),AirProfileStackLayerKind.SolidInterval,"bad",[]),"bad",[])
+ ],-5,5,[],[]);
+ Assert.False(AirProfileStackExtrudeAdapter.TryValidate(air, out var d));
+ Assert.Contains(d, x => x.Contains("air-validation-failed-solid-interval-has-inner-loop", StringComparison.Ordinal));
+ }
+
private static CirNode BuildStepped() => 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))));
}
diff --git a/Aetheris.Kernel.Firmament.Tests/HoleRecoveryExecutorPlacementDrivenTests.cs b/Aetheris.Kernel.Firmament.Tests/HoleRecoveryExecutorPlacementDrivenTests.cs
index 847ea452..30fd930a 100644
--- a/Aetheris.Kernel.Firmament.Tests/HoleRecoveryExecutorPlacementDrivenTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/HoleRecoveryExecutorPlacementDrivenTests.cs
@@ -20,6 +20,7 @@ public sealed class HoleRecoveryExecutorPlacementDrivenTests
var result = HoleRecoveryExecutor.Execute(plan);
Assert.Equal(HoleRecoveryExecutionStatus.Succeeded, result.Status);
+ Assert.Contains(result.Diagnostics, d => d.Contains("air-profile-stack-v2b-fallback-legacy-blind", StringComparison.Ordinal));
Assert.Contains(result.Diagnostics, d => d.Contains("placement-driven segment=blind-cylinder", StringComparison.Ordinal));
}
diff --git a/Aetheris.Kernel.Firmament.Tests/ProfileStackExtrudeHoleFamilyMigrationTests.cs b/Aetheris.Kernel.Firmament.Tests/ProfileStackExtrudeHoleFamilyMigrationTests.cs
index f10f4e31..3b0c57f1 100644
--- a/Aetheris.Kernel.Firmament.Tests/ProfileStackExtrudeHoleFamilyMigrationTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/ProfileStackExtrudeHoleFamilyMigrationTests.cs
@@ -25,7 +25,9 @@ public sealed class ProfileStackExtrudeHoleFamilyMigrationTests
var plan = (HoleRecoveryPlan)new HoleRecoveryPolicy().Evaluate(new FrepMaterializerContext(root)).Plan!;
var result = HoleRecoveryExecutor.Execute(plan);
Assert.Equal(HoleRecoveryExecutionStatus.Succeeded, result.Status);
- Assert.Contains(result.Diagnostics, d => d.Contains("air-profile-stack-v1-blind-deferred", StringComparison.OrdinalIgnoreCase));
+ Assert.Contains(result.Diagnostics, d => d.Contains("air-profile-stack-v2b-blind-solid-interval-recognized", StringComparison.OrdinalIgnoreCase));
+ Assert.Contains(result.Diagnostics, d => d.Contains("air-profile-stack-v2b-blind-emitter-deferred", StringComparison.OrdinalIgnoreCase));
+ Assert.Contains(result.Diagnostics, d => d.Contains("air-profile-stack-v2b-fallback-legacy-blind", StringComparison.OrdinalIgnoreCase));
Assert.Contains(result.Diagnostics, d => d.Contains("Blind subtract succeeded", StringComparison.OrdinalIgnoreCase));
}
@@ -36,8 +38,8 @@ public sealed class ProfileStackExtrudeHoleFamilyMigrationTests
var plan = (HoleRecoveryPlan)new HoleRecoveryPolicy().Evaluate(new FrepMaterializerContext(root)).Plan!;
var result = HoleRecoveryExecutor.Execute(plan);
Assert.Equal(HoleRecoveryExecutionStatus.Succeeded, result.Status);
- Assert.Contains(result.Diagnostics, d => d.Contains("air-profile-stack-v1-counterbore-deferred", StringComparison.OrdinalIgnoreCase));
- Assert.Contains(result.Diagnostics, d => d.Contains("Second subtract succeeded", StringComparison.OrdinalIgnoreCase));
+ Assert.Contains(result.Diagnostics, d => d.Contains("air-profile-stack-v2b-counterbore-contiguous-accepted", StringComparison.OrdinalIgnoreCase));
+ Assert.Contains(result.Diagnostics, d => d.Contains("hole-family executor route: profile-stack-extrude via AIR", StringComparison.OrdinalIgnoreCase));
}
[Fact]
diff --git a/Aetheris.Kernel.Firmament/Materializer/AirProfileStackExtrude.cs b/Aetheris.Kernel.Firmament/Materializer/AirProfileStackExtrude.cs
index 846be6ef..f9243df6 100644
--- a/Aetheris.Kernel.Firmament/Materializer/AirProfileStackExtrude.cs
+++ b/Aetheris.Kernel.Firmament/Materializer/AirProfileStackExtrude.cs
@@ -3,10 +3,17 @@ namespace Aetheris.Kernel.Firmament.Materializer;
public sealed record AirRectangleProfile(double Width, double Height);
public sealed record AirCenteredCircleLoop(double Radius);
+public enum AirProfileStackLayerKind
+{
+ Unsupported = 0,
+ SolidInterval = 1,
+ CircularCutInterval = 2
+}
public sealed record AirProfileRegion2D(
AirRectangleProfile Outer,
AirCenteredCircleLoop? InnerCircle,
+ AirProfileStackLayerKind LayerKind,
string Role,
IReadOnlyList<string> Diagnostics);
@@ -34,7 +41,7 @@ public static class AirProfileStackExtrudeAdapter
var layers = spec.Layers.Select((l, i) => new AirProfileStackLayer(
l.ZMin,
l.ZMax,
- new AirProfileRegion2D(new AirRectangleProfile(spec.Width, spec.Depth), l.InnerCircleRadius.HasValue ? new AirCenteredCircleLoop(l.InnerCircleRadius.Value) : null, l.Role, l.Diagnostics),
+ new AirProfileRegion2D(new AirRectangleProfile(spec.Width, spec.Depth), l.InnerCircleRadius.HasValue ? new AirCenteredCircleLoop(l.InnerCircleRadius.Value) : null, l.InnerCircleRadius.HasValue ? AirProfileStackLayerKind.CircularCutInterval : AirProfileStackLayerKind.SolidInterval, l.Role, l.Diagnostics),
l.Role,
[.. l.Diagnostics, $"air-layer-index={i}"])).ToArray();
@@ -57,14 +64,13 @@ public static class AirProfileStackExtrudeAdapter
if (plan.HoleKind == HoleKind.Blind)
{
- diagnostics = [.. d, "air-profile-stack-v1-blind-deferred"];
+ _ = TryFromBlindPlan(plan, d, out _, out var blindDiagnostics);
+ diagnostics = [.. blindDiagnostics, "air-profile-stack-v2b-blind-emitter-deferred"];
return false;
}
-
- if (plan.HoleKind == HoleKind.Counterbore)
+ if (plan.HoleKind == HoleKind.Counterbore && TryFromCounterborePlan(plan, d, out air, out diagnostics))
{
- diagnostics = [.. d, "air-profile-stack-v1-counterbore-deferred"];
- return false;
+ return true;
}
if (plan.HoleKind is HoleKind.Countersink or HoleKind.ChamferedEntry)
@@ -106,7 +112,7 @@ public static class AirProfileStackExtrudeAdapter
ordered[0].Region.Outer.Height,
air.GlobalZMin,
air.GlobalZMax,
- ordered.Select(l => new ProfileStackLayer(l.ZMin, l.ZMax, l.Region.InnerCircle?.Radius, l.Role, l.Diagnostics)).ToArray(),
+ ordered.Select(l => new ProfileStackLayer(l.ZMin, l.ZMax, l.Region.LayerKind == AirProfileStackLayerKind.CircularCutInterval ? l.Region.InnerCircle?.Radius : null, l.Role, l.Diagnostics)).ToArray(),
[.. air.Diagnostics, .. d]);
diagnostics = d;
return true;
@@ -129,7 +135,19 @@ public static class AirProfileStackExtrudeAdapter
if (l.ZMax - l.ZMin <= tol) d.Add($"air-validation-failed-non-positive-span[{i}]");
if (l.ZMin < air.GlobalZMin - tol || l.ZMax > air.GlobalZMax + tol) d.Add($"air-validation-failed-outside-global[{i}]");
if (l.Region.Outer.Width <= tol || l.Region.Outer.Height <= tol) d.Add($"air-validation-failed-invalid-outer-rect[{i}]");
- if (l.Region.InnerCircle is not null && l.Region.InnerCircle.Radius <= tol) d.Add($"air-validation-failed-invalid-inner-radius[{i}]");
+ if (l.Region.LayerKind == AirProfileStackLayerKind.CircularCutInterval)
+ {
+ if (l.Region.InnerCircle is null) d.Add($"air-validation-failed-missing-inner-loop[{i}]");
+ else if (l.Region.InnerCircle.Radius <= tol) d.Add($"air-validation-failed-invalid-inner-radius[{i}]");
+ }
+ else if (l.Region.LayerKind == AirProfileStackLayerKind.SolidInterval && l.Region.InnerCircle is not null)
+ {
+ d.Add($"air-validation-failed-solid-interval-has-inner-loop[{i}]");
+ }
+ else if (l.Region.LayerKind == AirProfileStackLayerKind.Unsupported)
+ {
+ d.Add($"air-validation-failed-unsupported-layer-kind[{i}]");
+ }
if (i > 0 && Math.Abs(ordered[i - 1].ZMax - l.ZMin) > tol) d.Add($"air-validation-failed-non-contiguous[{i - 1}->{i}]");
}
@@ -137,4 +155,42 @@ public static class AirProfileStackExtrudeAdapter
diagnostics = d;
return d.Count == 0;
}
+
+ private static bool TryFromCounterborePlan(HoleRecoveryPlan plan, List<string> d, out AirProfileStackExtrude? air, out IReadOnlyList<string> diagnostics)
+ {
+ air = null;
+ diagnostics = [];
+ var tol = 1e-9;
+ if (plan.DepthKind != HoleDepthKind.ThroughWithEntryRelief || plan.HostKind != HoleHostKind.RectangularBox || plan.Axis != HoleAxisKind.Z || plan.ProfileStack.Count != 2)
+ { diagnostics = [.. d, "air-profile-stack-v2b-counterbore-rejected-shape"]; return false; }
+ var large = plan.ProfileStack[0]; var small = plan.ProfileStack[1];
+ if (large.SegmentKind != HoleProfileSegmentKind.Cylindrical || small.SegmentKind != HoleProfileSegmentKind.Cylindrical || !small.IsThrough || large.IsThrough || large.RadiusStart <= small.RadiusStart + tol)
+ { diagnostics = [.. d, "air-profile-stack-v2b-counterbore-rejected-segment-constraints"]; return false; }
+ var hostMin = plan.HostTranslation.Z - (plan.HostSizeZ * 0.5d); var hostMax = plan.HostTranslation.Z + (plan.HostSizeZ * 0.5d);
+ var split = large.AnchorSide == HoleTierAnchorSide.Top ? large.ZMin : large.ZMax;
+ var layers = large.AnchorSide == HoleTierAnchorSide.Top
+ ? new[] { new AirProfileStackLayer(hostMin, split, new AirProfileRegion2D(new(plan.HostSizeX, plan.HostSizeY), new(small.RadiusStart), AirProfileStackLayerKind.CircularCutInterval, "counterbore-through-small", []), "counterbore-through-small", []), new AirProfileStackLayer(split, hostMax, new AirProfileRegion2D(new(plan.HostSizeX, plan.HostSizeY), new(large.RadiusStart), AirProfileStackLayerKind.CircularCutInterval, "counterbore-entry-large", []), "counterbore-entry-large", []) }
+ : new[] { new AirProfileStackLayer(hostMin, split, new AirProfileRegion2D(new(plan.HostSizeX, plan.HostSizeY), new(large.RadiusStart), AirProfileStackLayerKind.CircularCutInterval, "counterbore-entry-large", []), "counterbore-entry-large", []), new AirProfileStackLayer(split, hostMax, new AirProfileRegion2D(new(plan.HostSizeX, plan.HostSizeY), new(small.RadiusStart), AirProfileStackLayerKind.CircularCutInterval, "counterbore-through-small", []), "counterbore-through-small", []) };
+ var model = new AirProfileStackExtrude(layers, hostMin, hostMax, ["source:HoleRecoveryPlan"], ["air-profile-stack-v2b-counterbore-contiguous-accepted"]);
+ if (!TryValidate(model, out var issues)) { diagnostics = [.. d, "air-profile-stack-v2b-counterbore-rejected-validation", .. issues]; return false; }
+ air = model; diagnostics = [.. d, "air-profile-stack-v2b-counterbore-contiguous-accepted"]; return true;
+ }
+
+ private static bool TryFromBlindPlan(HoleRecoveryPlan plan, List<string> d, out AirProfileStackExtrude? air, out IReadOnlyList<string> diagnostics)
+ {
+ air = null;
+ diagnostics = [];
+ if (plan.DepthKind != HoleDepthKind.Blind || plan.HostKind != HoleHostKind.RectangularBox || plan.Axis != HoleAxisKind.Z || plan.ProfileStack.Count != 1)
+ { diagnostics = [.. d, "air-profile-stack-v2b-blind-rejected-shape"]; return false; }
+ var seg = plan.ProfileStack[0];
+ if (seg.SegmentKind != HoleProfileSegmentKind.Cylindrical || seg.IsThrough || (seg.AnchorSide != HoleTierAnchorSide.Top && seg.AnchorSide != HoleTierAnchorSide.Bottom))
+ { diagnostics = [.. d, "air-profile-stack-v2b-blind-rejected-segment-constraints"]; return false; }
+ var hostMin = plan.HostTranslation.Z - (plan.HostSizeZ * 0.5d); var hostMax = plan.HostTranslation.Z + (plan.HostSizeZ * 0.5d);
+ AirProfileStackLayer[] layers = seg.AnchorSide == HoleTierAnchorSide.Top
+ ? [new(hostMin, seg.ZMin, new(new(plan.HostSizeX, plan.HostSizeY), null, AirProfileStackLayerKind.SolidInterval, "blind-solid", []), "blind-solid", []), new(seg.ZMin, hostMax, new(new(plan.HostSizeX, plan.HostSizeY), new(seg.RadiusStart), AirProfileStackLayerKind.CircularCutInterval, "blind-cut", []), "blind-cut", [])]
+ : [new(hostMin, seg.ZMax, new(new(plan.HostSizeX, plan.HostSizeY), new(seg.RadiusStart), AirProfileStackLayerKind.CircularCutInterval, "blind-cut", []), "blind-cut", []), new(seg.ZMax, hostMax, new(new(plan.HostSizeX, plan.HostSizeY), null, AirProfileStackLayerKind.SolidInterval, "blind-solid", []), "blind-solid", [])];
+ var model = new AirProfileStackExtrude(layers, hostMin, hostMax, ["source:HoleRecoveryPlan"], ["air-profile-stack-v2b-blind-solid-cut-accepted"]);
+ if (!TryValidate(model, out var issues)) { diagnostics = [.. d, "air-profile-stack-v2b-blind-rejected-validation", .. issues]; return false; }
+ air = model; diagnostics = [.. d, "air-profile-stack-v2b-blind-solid-interval-recognized"]; return true;
+ }
}
diff --git a/Aetheris.Kernel.Firmament/Materializer/HoleRecoveryExecutor.cs b/Aetheris.Kernel.Firmament/Materializer/HoleRecoveryExecutor.cs
index e88d99fc..e3881e27 100644
--- a/Aetheris.Kernel.Firmament/Materializer/HoleRecoveryExecutor.cs
+++ b/Aetheris.Kernel.Firmament/Materializer/HoleRecoveryExecutor.cs
@@ -47,6 +47,7 @@ public static class HoleRecoveryExecutor
return ExecuteCountersinkLike(plan, diagnostics, "chamfer cone");
}
+ diagnostics.Add("hole-family AIR attempt: profile-stack route evaluation started.");
if (AirProfileStackExtrudeAdapter.TryFromHoleRecoveryPlan(plan, out var air, out var airDiagnostics) && air is not null)
{
diagnostics.AddRange(airDiagnostics);
@@ -71,6 +72,16 @@ public static class HoleRecoveryExecutor
if (profileResult.Status != ProfileStackExtrudeExecutionStatus.Succeeded || profileResult.Body is null)
{
diagnostics.Add("hole-family profile-stack execution failed.");
+ if (plan.HoleKind == HoleKind.Blind && plan.DepthKind == HoleDepthKind.Blind)
+ {
+ diagnostics.Add("hole-family AIR failed; falling back to legacy blind executor.");
+ return ExecuteBlind(plan, diagnostics);
+ }
+ if (plan.HoleKind == HoleKind.Counterbore && plan.DepthKind == HoleDepthKind.ThroughWithEntryRelief)
+ {
+ diagnostics.Add("hole-family AIR failed; falling back to legacy counterbore executor.");
+ return ExecuteCounterbore(plan, diagnostics);
+ }
return new(HoleRecoveryExecutionStatus.BooleanFailed, null, diagnostics);
}
@@ -80,6 +91,7 @@ public static class HoleRecoveryExecutor
}
diagnostics.AddRange(airDiagnostics);
+ diagnostics.Add("hole-family AIR attempt rejected; evaluating legacy fallback routes.");
if (plan.HoleKind == HoleKind.Through)
{
@@ -97,6 +109,7 @@ public static class HoleRecoveryExecutor
if (plan.HoleKind == HoleKind.Blind && plan.DepthKind == HoleDepthKind.Blind)
{
+ diagnostics.Add("air-profile-stack-v2b-fallback-legacy-blind");
diagnostics.Add("Blind-hole plan accepted for bounded execution.");
return ExecuteBlind(plan, diagnostics);
}
@@ -109,6 +122,7 @@ public static class HoleRecoveryExecutor
if (plan.HoleKind == HoleKind.Counterbore && plan.DepthKind == HoleDepthKind.ThroughWithEntryRelief)
{
+ diagnostics.Add("air-profile-stack-v2b-fallback-legacy-counterbore");
diagnostics.Add("Counterbore plan accepted for bounded execution.");
return ExecuteCounterbore(plan, diagnostics);
}
diff --git a/Aetheris.Kernel.Firmament/Materializer/ProfileStackExtrudeExecutor.cs b/Aetheris.Kernel.Firmament/Materializer/ProfileStackExtrudeExecutor.cs
index 3c61c25e..21499c36 100644
--- a/Aetheris.Kernel.Firmament/Materializer/ProfileStackExtrudeExecutor.cs
+++ b/Aetheris.Kernel.Firmament/Materializer/ProfileStackExtrudeExecutor.cs
@@ -53,17 +53,17 @@ public static class ProfileStackExtrudeExecutor
diagnostics.Add($"profile-stack layer[{i}] role={l.Role} zMin={l.ZMin:0.###} zMax={l.ZMax:0.###} radius={(l.InnerCircleRadius?.ToString("0.###") ?? "none") }.");
}
- if (orderedLayers.Any(l => !l.InnerCircleRadius.HasValue || l.InnerCircleRadius.Value <= 0d))
- {
- diagnostics.Add("profile-stack unsupported-shape: V1 stepped-hole executor requires every layer to provide a positive inner radius.");
- return new(ProfileStackExtrudeExecutionStatus.UnsupportedProfileShape, null, diagnostics);
- }
+ if (orderedLayers.All(l => !l.InnerCircleRadius.HasValue))
+ { diagnostics.Add("profile-stack unsupported-shape: no cut intervals were provided."); return new(ProfileStackExtrudeExecutionStatus.UnsupportedProfileShape, null, diagnostics); }
+ if (orderedLayers.Any(l => l.InnerCircleRadius.HasValue && l.InnerCircleRadius.Value <= 0d))
+ { diagnostics.Add("profile-stack unsupported-shape: cut interval has non-positive inner radius."); return new(ProfileStackExtrudeExecutionStatus.UnsupportedProfileShape, null, diagnostics); }
var holes = new List<SupportedBooleanHole>();
var zAxis = Direction3D.Create(new Vector3D(0, 0, 1));
var xAxis = Direction3D.Create(new Vector3D(1, 0, 0));
foreach (var l in orderedLayers)
{
+ if (!l.InnerCircleRadius.HasValue) continue;
var span = l.ZMin <= spec.ZMin + 1e-9 && l.ZMax >= spec.ZMax - 1e-9
? SupportedBooleanHoleSpanKind.Through
: (Math.Abs(l.ZMax - spec.ZMax) < 1e-9
diff --git a/docs/air-v2a-blind-counterbore-profile-stack-support.md b/docs/air-v2a-blind-counterbore-profile-stack-support.md
index 80d04ecd..0040d437 100644
--- a/docs/air-v2a-blind-counterbore-profile-stack-support.md
+++ b/docs/air-v2a-blind-counterbore-profile-stack-support.md
@@ -31,3 +31,7 @@ Preserved defer breadcrumbs:
## Recommended next step
AIR-V2B should investigate bounded emitter support for blind/counterbore interval topology with dedicated composition constraints and diagnostics before re-enabling AIR routing for these variants.
+
+
+## AIR-V2B update
+Blind and counterbore are no longer blanket deferred when admissible contiguous AIR interval semantics are present; see `air-v2b-blind-counterbore-interval-production.md` for exact accepted/rejected boundaries and diagnostics.
diff --git a/docs/air-v2b-blind-counterbore-interval-production.md b/docs/air-v2b-blind-counterbore-interval-production.md
new file mode 100644
index 00000000..52182d56
--- /dev/null
+++ b/docs/air-v2b-blind-counterbore-interval-production.md
@@ -0,0 +1,42 @@
+# AIR-V2B blind/counterbore interval production
+
+AIR-V2B productionizes AIR-X2 findings from `docs/frictionlab/air-x2-blind-counterbore-interval-semantics-lab.md`:
+- blind-hole AIR requires explicit solid/no-hole interval semantics;
+- counterbore AIR can route as contiguous layered radii;
+- legacy bounded blind/counterbore execution remains available as fallback.
+
+## Production changes
+- Added explicit AIR layer semantics with `AirProfileStackLayerKind` (`CircularCutInterval`, `SolidInterval`, `Unsupported`).
+- Blind AIR model conversion emits explicit `solid + cut` contiguous intervals (never zero-radius holes), but production blind execution remains deferred to legacy fallback pending parity.
+- Counterbore AIR conversion now accepts contiguous layered radii plans and routes through profile-stack executor.
+- Executor now supports mixed cut/solid intervals by creating cylinders only for cut layers.
+
+## AIR-V2B accepted shapes
+- Through: one cut interval spanning host.
+- Stepped: contiguous cut intervals (existing V2 behavior).
+- Counterbore: contiguous two-layer cut profile with small through + larger entry tier.
+- Blind: model supports contiguous two-layer profile containing one `SolidInterval` and one `CircularCutInterval`; production execution currently falls back to legacy bounded blind route.
+
+## Fallback boundary
+- AIR rejection does not remove legacy bounded routes.
+- On AIR rejection, diagnostics report rejection and then legacy route evaluation.
+
+## Diagnostics contract
+- `hole-family AIR attempt: profile-stack route evaluation started.`
+- accept examples:
+ - `air-profile-stack-v2b-counterbore-contiguous-accepted`
+ - `air-profile-stack-v2b-blind-solid-interval-recognized`
+ - `air-profile-stack-v2b-blind-emitter-deferred`
+ - `air-profile-stack-v2b-fallback-legacy-blind`
+- reject examples:
+ - `air-profile-stack-v2b-*-rejected-*`
+- fallback marker:
+ - `hole-family AIR attempt rejected; evaluating legacy fallback routes.`
+
+## Test commands run
+- `dotnet test Aetheris.Kernel.Firmament.Tests/Aetheris.Kernel.Firmament.Tests.csproj --filter "AirProfileStack|ProfileStack|ThroughHoleRecovery|SteppedHole|BlindHole|Counterbore|HoleRecoveryPolicy|SemanticRecovery|FrepMaterializer|Rematerialize|FirmamentStepExporter"`
+- `dotnet test Aetheris.FrictionLab.Tests/Aetheris.FrictionLab.Tests.csproj -c Release -f net10.0 --filter "AirProfileStack|ProfileStackExtrude|RecoveryPolicy|CIRLab"`
+
+## Remaining limitations
+- Conical families (countersink/chamfer) remain deferred to conical route.
+- AIR remains bounded to cylindrical profile-stack semantics.
diff --git a/docs/cir-recovery-v19-hole-family-capability-manifest.md b/docs/cir-recovery-v19-hole-family-capability-manifest.md
index cbf5e9e4..ca7af23f 100644
--- a/docs/cir-recovery-v19-hole-family-capability-manifest.md
+++ b/docs/cir-recovery-v19-hole-family-capability-manifest.md
@@ -200,3 +200,5 @@ Through-hole and stepped-hole profile-stack routes now materialize a bounded AIR
## AIR-V2A.1 update (2026-05-23)
Capability manifest correction: blind-hole and counterbore remain AIR-deferred and execute via legacy bounded routes. Through/stepped remain on AIR/profile-stack; conical variants remain AIR-deferred.
+
+- AIR-V2B capability: bounded blind and counterbore may execute via AIR/profile-stack when interval semantics validate (counterbore contiguous layered radii; blind explicit solid/no-hole + cut interval), with deterministic fallback diagnostics.
diff --git a/docs/cir-sweep-v2-cylindrical-hole-profile-stack-migration.md b/docs/cir-sweep-v2-cylindrical-hole-profile-stack-migration.md
index 390fdaae..ce1a56ce 100644
--- a/docs/cir-sweep-v2-cylindrical-hole-profile-stack-migration.md
+++ b/docs/cir-sweep-v2-cylindrical-hole-profile-stack-migration.md
@@ -63,3 +63,5 @@ Through-hole and stepped-hole profile-stack routes now materialize a bounded AIR
## AIR-V2A.1 update (2026-05-23)
Through/stepped remain AIR/profile-stack. Blind/counterbore are explicitly deferred in AIR with legacy bounded execution retained; countersink/chamfer remain conical route.
+
+- AIR-V2B: counterbore contiguous layered-radii migrated to AIR/profile-stack, and blind migrated when explicit solid+cut interval semantics are admissible; legacy fallback remains active on AIR rejection.