Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add AIR-X4 lab-only Box-as-AirExtrude parity probe

Yuechen Li548ee41021ab
diff --git a/Aetheris.Firmament.FrictionLab/CIRLab/AirBoxExtrudeLab.cs b/Aetheris.Firmament.FrictionLab/CIRLab/AirBoxExtrudeLab.cs
new file mode 100644
index 00000000..9118df3a
--- /dev/null
+++ b/Aetheris.Firmament.FrictionLab/CIRLab/AirBoxExtrudeLab.cs
@@ -0,0 +1,151 @@
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Brep.Features;
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Math;
+using Aetheris.Kernel.Core.Step242;
+
+namespace Aetheris.Firmament.FrictionLab.CIRLab;
+
+public sealed record AirBoxExtrudeCase(string Name, double Width, double Depth, double Height);
+
+public sealed record AirBoxExtrudeTopologySummary(
+ bool BodyProduced,
+ int VertexCount,
+ int EdgeCount,
+ int FaceCount,
+ int PlanarFaceCount,
+ int LoopCount,
+ int CoedgeCount);
+
+public sealed record AirBoxExtrudeStepSummary(
+ bool Exported,
+ IReadOnlyList<string> PresentMarkers,
+ IReadOnlyList<string> MissingMarkers,
+ bool ContainsBrepWithVoids,
+ IReadOnlyList<string> Diagnostics);
+
+public sealed record AirBoxExtrudeLabResult(
+ AirBoxExtrudeCase Case,
+ bool IsValid,
+ AirBoxExtrudeTopologySummary Baseline,
+ AirBoxExtrudeTopologySummary Extrude,
+ AirBoxExtrudeStepSummary BaselineStep,
+ AirBoxExtrudeStepSummary ExtrudeStep,
+ IReadOnlyList<string> Diagnostics,
+ string FinalRecommendation,
+ bool TopologyParity,
+ bool StepSmokeParity);
+
+public static class AirBoxExtrudeLab
+{
+ private static readonly string[] RequiredStepMarkers = ["ISO-10303-21", "MANIFOLD_SOLID_BREP", "ADVANCED_FACE", "PLANE"];
+
+ public static AirBoxExtrudeLabResult Run(AirBoxExtrudeCase @case)
+ {
+ var diagnostics = new List<string> { "air-x4-box-extrude-lab-started" };
+
+ if (!IsPositiveFinite(@case.Width) || !IsPositiveFinite(@case.Depth) || !IsPositiveFinite(@case.Height))
+ {
+ diagnostics.Add("air-x4-invalid-dimensions");
+ return new AirBoxExtrudeLabResult(
+ @case,
+ false,
+ EmptyTopology(),
+ EmptyTopology(),
+ EmptyStep(["invalid dimensions"]),
+ EmptyStep(["invalid dimensions"]),
+ diagnostics,
+ "box-air-extrude-needs-emitter-parity-work",
+ false,
+ false);
+ }
+
+ var baselineResult = BrepPrimitives.CreateBox(@case.Width, @case.Depth, @case.Height);
+ if (!baselineResult.IsSuccess || baselineResult.Value is null)
+ {
+ diagnostics.Add("air-x4-baseline-box-failed");
+ diagnostics.AddRange(baselineResult.Diagnostics.Select(d => d.Message));
+ return new AirBoxExtrudeLabResult(@case, true, EmptyTopology(), EmptyTopology(), EmptyStep(["baseline failed"]), EmptyStep(["baseline failed"]), diagnostics, "box-air-extrude-needs-emitter-parity-work", false, false);
+ }
+
+ diagnostics.Add("air-x4-baseline-box-created");
+ var baselineBody = baselineResult.Value;
+ var baselineTopology = SummarizeTopology(baselineBody);
+ var baselineStep = SummarizeStep(baselineBody);
+
+ var profileResult = PolylineProfile2D.Create([
+ new ProfilePoint2D([email protected] * 0.5d, [email protected] * 0.5d),
+ new ProfilePoint2D(@case.Width * 0.5d, [email protected] * 0.5d),
+ new ProfilePoint2D(@case.Width * 0.5d, @case.Depth * 0.5d),
+ new ProfilePoint2D([email protected] * 0.5d, @case.Depth * 0.5d)
+ ]);
+
+ if (!profileResult.IsSuccess)
+ {
+ diagnostics.Add("air-x4-extrude-box-failed:profile-create");
+ diagnostics.AddRange(profileResult.Diagnostics.Select(d => d.Message));
+ return new AirBoxExtrudeLabResult(@case, true, baselineTopology, EmptyTopology(), baselineStep, EmptyStep(profileResult.Diagnostics.Select(d => d.Message).ToArray()), diagnostics, "box-air-extrude-needs-emitter-parity-work", false, false);
+ }
+
+ var frame = new ExtrudeFrame3D(new Point3D(0d, 0d, [email protected] * 0.5d), Direction3D.Create(new Vector3D(0d, 0d, 1d)), Direction3D.Create(new Vector3D(1d, 0d, 0d)));
+ var extrudeResult = BrepExtrude.Create(profileResult.Value, frame, @case.Height);
+ if (!extrudeResult.IsSuccess || extrudeResult.Value is null)
+ {
+ diagnostics.Add("air-x4-extrude-box-failed:extrude-create");
+ diagnostics.AddRange(extrudeResult.Diagnostics.Select(d => d.Message));
+ return new AirBoxExtrudeLabResult(@case, true, baselineTopology, EmptyTopology(), baselineStep, EmptyStep(extrudeResult.Diagnostics.Select(d => d.Message).ToArray()), diagnostics, "box-air-extrude-needs-emitter-parity-work", false, false);
+ }
+
+ diagnostics.Add("air-x4-extrude-box-created");
+ var extrudeBody = extrudeResult.Value;
+ var extrudeTopology = SummarizeTopology(extrudeBody);
+ var extrudeStep = SummarizeStep(extrudeBody);
+
+ var topologyParity = baselineTopology == extrudeTopology;
+ diagnostics.Add(topologyParity ? "air-x4-topology-parity-succeeded" : $"air-x4-topology-parity-mismatch: baseline={baselineTopology} extrude={extrudeTopology}");
+
+ var stepParity = baselineStep.Exported
+ && extrudeStep.Exported
+ && baselineStep.MissingMarkers.Count == 0
+ && extrudeStep.MissingMarkers.Count == 0
+ && !baselineStep.ContainsBrepWithVoids
+ && !extrudeStep.ContainsBrepWithVoids;
+ diagnostics.Add(stepParity ? "air-x4-step-smoke-succeeded" : "air-x4-step-smoke-failed");
+
+ var recommendation = topologyParity && stepParity
+ ? "box-air-extrude-ready-for-production-migration"
+ : "box-air-extrude-needs-emitter-parity-work";
+
+ return new AirBoxExtrudeLabResult(@case, true, baselineTopology, extrudeTopology, baselineStep, extrudeStep, diagnostics, recommendation, topologyParity, stepParity);
+ }
+
+ private static bool IsPositiveFinite(double value) => double.IsFinite(value) && value > 0d;
+
+ private static AirBoxExtrudeTopologySummary EmptyTopology() => new(false, 0, 0, 0, 0, 0, 0);
+
+ private static AirBoxExtrudeStepSummary EmptyStep(IReadOnlyList<string> diagnostics) => new(false, [], RequiredStepMarkers, false, diagnostics);
+
+ private static AirBoxExtrudeTopologySummary SummarizeTopology(BrepBody body)
+ => new(
+ true,
+ body.Topology.Vertices.Count(),
+ body.Topology.Edges.Count(),
+ body.Topology.Faces.Count(),
+ body.Topology.Faces.Count(face => body.GetFaceSurface(face.Id).Kind == Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.Plane),
+ body.Topology.Loops.Count(),
+ body.Topology.Coedges.Count());
+
+ private static AirBoxExtrudeStepSummary SummarizeStep(BrepBody body)
+ {
+ var exported = Step242Exporter.ExportBody(body);
+ if (!exported.IsSuccess || exported.Value is null)
+ {
+ return new AirBoxExtrudeStepSummary(false, [], RequiredStepMarkers, false, exported.Diagnostics.Select(d => d.Message).ToArray());
+ }
+
+ var text = exported.Value;
+ var present = RequiredStepMarkers.Where(marker => text.Contains(marker, StringComparison.Ordinal)).ToArray();
+ var missing = RequiredStepMarkers.Except(present).ToArray();
+ return new AirBoxExtrudeStepSummary(true, present, missing, text.Contains("BREP_WITH_VOIDS", StringComparison.Ordinal), []);
+ }
+}
diff --git a/Aetheris.FrictionLab.Tests/CIRLab/AirBoxExtrudeLabTests.cs b/Aetheris.FrictionLab.Tests/CIRLab/AirBoxExtrudeLabTests.cs
new file mode 100644
index 00000000..8f1a72a1
--- /dev/null
+++ b/Aetheris.FrictionLab.Tests/CIRLab/AirBoxExtrudeLabTests.cs
@@ -0,0 +1,74 @@
+using Aetheris.Firmament.FrictionLab.CIRLab;
+
+namespace Aetheris.FrictionLab.Tests.CIRLab;
+
+public class AirBoxExtrudeLabTests
+{
+ [Theory]
+ [InlineData("cube", 10d, 10d, 10d)]
+ [InlineData("rect", 12d, 8d, 6d)]
+ public void AirBoxExtrude_HappyCases_AreDeterministic(string name, double width, double depth, double height)
+ {
+ var @case = new AirBoxExtrudeCase(name, width, depth, height);
+ var first = AirBoxExtrudeLab.Run(@case);
+ var second = AirBoxExtrudeLab.Run(@case);
+
+ Assert.Equal(first.Baseline, second.Baseline);
+ Assert.Equal(first.Extrude, second.Extrude);
+ Assert.Equal(first.BaselineStep.Exported, second.BaselineStep.Exported);
+ Assert.Equal(string.Join("|", first.BaselineStep.PresentMarkers), string.Join("|", second.BaselineStep.PresentMarkers));
+ Assert.Equal(string.Join("|", first.BaselineStep.MissingMarkers), string.Join("|", second.BaselineStep.MissingMarkers));
+ Assert.Equal(first.BaselineStep.ContainsBrepWithVoids, second.BaselineStep.ContainsBrepWithVoids);
+ Assert.Equal(first.ExtrudeStep.Exported, second.ExtrudeStep.Exported);
+ Assert.Equal(string.Join("|", first.ExtrudeStep.PresentMarkers), string.Join("|", second.ExtrudeStep.PresentMarkers));
+ Assert.Equal(string.Join("|", first.ExtrudeStep.MissingMarkers), string.Join("|", second.ExtrudeStep.MissingMarkers));
+ Assert.Equal(first.ExtrudeStep.ContainsBrepWithVoids, second.ExtrudeStep.ContainsBrepWithVoids);
+ Assert.Equal(first.FinalRecommendation, second.FinalRecommendation);
+ Assert.Equal(first.TopologyParity, second.TopologyParity);
+ Assert.Equal(first.StepSmokeParity, second.StepSmokeParity);
+ Assert.Contains("air-x4-baseline-box-created", first.Diagnostics);
+ Assert.Contains(first.Diagnostics, d => d.StartsWith("air-x4-extrude-box-", StringComparison.Ordinal));
+ }
+
+ [Theory]
+ [InlineData("cube", 10d, 10d, 10d)]
+ [InlineData("rect", 12d, 8d, 6d)]
+ public void AirBoxExtrude_HappyCases_ReportParityOrExplicitBlocker(string name, double width, double depth, double height)
+ {
+ var result = AirBoxExtrudeLab.Run(new AirBoxExtrudeCase(name, width, depth, height));
+
+ Assert.True(result.Baseline.BodyProduced);
+ Assert.True(result.Extrude.BodyProduced);
+
+ if (result.TopologyParity && result.StepSmokeParity)
+ {
+ Assert.Equal(8, result.Baseline.VertexCount);
+ Assert.Equal(12, result.Baseline.EdgeCount);
+ Assert.Equal(6, result.Baseline.FaceCount);
+ Assert.Equal(6, result.Baseline.PlanarFaceCount);
+ Assert.Equal(8, result.Extrude.VertexCount);
+ Assert.Equal(12, result.Extrude.EdgeCount);
+ Assert.Equal(6, result.Extrude.FaceCount);
+ Assert.Equal(6, result.Extrude.PlanarFaceCount);
+ Assert.Equal("box-air-extrude-ready-for-production-migration", result.FinalRecommendation);
+ }
+ else
+ {
+ Assert.Equal("box-air-extrude-needs-emitter-parity-work", result.FinalRecommendation);
+ Assert.Contains(result.Diagnostics, d => d.StartsWith("air-x4-topology-parity-", StringComparison.Ordinal) || d == "air-x4-step-smoke-failed");
+ }
+ }
+
+ [Theory]
+ [InlineData(0d, 10d, 10d)]
+ [InlineData(10d, -2d, 10d)]
+ public void AirBoxExtrude_InvalidDimensions_ReportDeterministicValidation(double width, double depth, double height)
+ {
+ var result = AirBoxExtrudeLab.Run(new AirBoxExtrudeCase("invalid", width, depth, height));
+ Assert.False(result.IsValid);
+ Assert.Contains("air-x4-invalid-dimensions", result.Diagnostics);
+ Assert.False(result.Baseline.BodyProduced);
+ Assert.False(result.Extrude.BodyProduced);
+ Assert.Equal("box-air-extrude-needs-emitter-parity-work", result.FinalRecommendation);
+ }
+}
diff --git a/docs/frictionlab/air-x4-box-as-air-extrude-lab.md b/docs/frictionlab/air-x4-box-as-air-extrude-lab.md
new file mode 100644
index 00000000..1109795b
--- /dev/null
+++ b/docs/frictionlab/air-x4-box-as-air-extrude-lab.md
@@ -0,0 +1,89 @@
+# AIR-X4 — Box-as-AirExtrude lab-only EVT
+
+## Purpose and scope
+
+AIR-X4 introduces a **lab-only** evidence lane that compares:
+
+1. baseline `BrepPrimitives.CreateBox(width, depth, height)` behavior, and
+2. an AIR-style rectangle-profile linear extrusion built with existing `BrepExtrude` helpers.
+
+No production primitive routing is changed in this milestone.
+
+## AIR-X3 reference
+
+This lab follows the recommendation from `docs/air-x3-primitive-as-air-normalization-audit.md`:
+
+- primitive-as-AIR normalization is viable for bounded analytic solids;
+- box is the lowest-risk first candidate;
+- primary risk is topology/seam/cap parity rather than geometric expressiveness.
+
+## Existing `CreateBox` topology summary
+
+For valid dimensions, baseline `CreateBox` emits a closed solid with expected box topology signatures:
+
+- vertices, edges, faces
+- planar face count
+- loop/coedge totals
+- STEP smoke markers
+
+The lab captures those signatures per case and compares them against AIR-style extrude outputs.
+
+## AIR-style rectangle-extrude construction attempted
+
+For each valid case the lab builds:
+
+- rectangle profile with centered extents `[-width/2,+width/2] x [-depth/2,+depth/2]`, and
+- `BrepExtrude.Create` along +Z from origin `z=-height/2` for depth `height`.
+
+If profile creation or extrusion fails, the lab records explicit `air-x4-extrude-box-failed:*` diagnostics and recommends parity follow-up instead of patching production emitters.
+
+## Test cases and results
+
+Covered cases:
+
+- cube-like: `(10,10,10)`
+- rectangular: `(12,8,6)`
+- invalid dimensions: zero/negative inputs
+
+Non-origin translated case is deferred in AIR-X4 because this EVT focuses on canonical centered parity and avoids introducing additional placement ambiguity.
+
+## Topology parity findings
+
+The lab emits deterministic diagnostics:
+
+- `air-x4-box-extrude-lab-started`
+- `air-x4-baseline-box-created`
+- `air-x4-extrude-box-created` (or explicit failure)
+- `air-x4-topology-parity-succeeded` (or explicit mismatch payload)
+
+The recommendation is derived deterministically from topology and STEP smoke parity.
+
+## STEP smoke findings
+
+Both baseline and AIR-style bodies are exported via `Step242Exporter.ExportBody` and checked for:
+
+- contains: `ISO-10303-21`, `MANIFOLD_SOLID_BREP`, `ADVANCED_FACE`, `PLANE`
+- does not contain: `BREP_WITH_VOIDS`
+
+The lab emits `air-x4-step-smoke-succeeded` or `air-x4-step-smoke-failed`.
+
+## Final recommendation
+
+Per case recommendation is one of:
+
+- `box-air-extrude-ready-for-production-migration`, or
+- `box-air-extrude-needs-emitter-parity-work`.
+
+AIR-X4 remains lab-only; no production migration is performed here.
+
+## Explicit non-goals
+
+- no production migration of `BrepPrimitives.CreateBox`
+- no cylinder/cone/sphere/torus primitive-as-AIR expansion
+- no STEP exporter/importer changes
+- no Boolean core changes
+
+## Test commands run
+
+- `dotnet test Aetheris.FrictionLab.Tests/Aetheris.FrictionLab.Tests.csproj -c Release -f net10.0 --filter "AirBoxExtrude|AirProfileStack|ProfileStackExtrude|RecoveryPolicy|CIRLab"`
+- `dotnet test Aetheris.Kernel.Core.Tests/Aetheris.Kernel.Core.Tests.csproj --filter "BrepPrimitives|CreateBox|Step242|Primitive"`