Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Reroute locked V2 side-hole through real AP242 exporter

Yuechen Li0b181333425c
diff --git a/Aetheris.CLI.Tests/FirmamentV2SideHoleRealExporterPipelineTests.cs b/Aetheris.CLI.Tests/FirmamentV2SideHoleRealExporterPipelineTests.cs
new file mode 100644
index 00000000..d08f1db3
--- /dev/null
+++ b/Aetheris.CLI.Tests/FirmamentV2SideHoleRealExporterPipelineTests.cs
@@ -0,0 +1,65 @@
+using System.Text.RegularExpressions;
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Step242;
+
+namespace Aetheris.CLI.Tests;
+
+public sealed class FirmamentV2SideHoleRealExporterPipelineTests
+{
+ [Fact]
+ public void SIDEHOLE_REAL_X1_locked_side_hole_builds_through_real_exporter_reimports_and_matches_volume()
+ {
+ const string fixtureId = "feature-v2-side-hole-step-verified";
+ var fixturePath = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, $"../../../../fixtures/FirmamentV2/Region/valid/{fixtureId}.valid.firmfixture"));
+ var outDir = Path.Combine(Path.GetTempPath(), "aetheris-sidehole-real-x1", Guid.NewGuid().ToString("N"));
+ Directory.CreateDirectory(outDir);
+ var stepPath = Path.Combine(outDir, fixtureId + ".step");
+
+ var stdout = new StringWriter();
+ var stderr = new StringWriter();
+ var exit = Aetheris.CLI.CliRunner.Run(["build", fixturePath, "--out", stepPath, "--json"], stdout, stderr);
+
+ Assert.True(exit == 0, stderr.ToString());
+ Assert.True(File.Exists(stepPath), "locked side-hole fixture reaches the real CLI build command");
+
+ var fixtureText = File.ReadAllText(fixturePath);
+ Assert.Contains("expected-stage: step-verified", fixtureText, StringComparison.Ordinal);
+ Assert.Contains("current-stage: step-verified", fixtureText, StringComparison.Ordinal);
+ Assert.Contains("roundtrip-required: true", fixtureText, StringComparison.Ordinal);
+ Assert.Contains("build-command: aetheris build", fixtureText, StringComparison.Ordinal);
+
+ var stepText = File.ReadAllText(stepPath);
+ Assert.Contains("ISO-10303-21", stepText, StringComparison.Ordinal);
+ Assert.True(CountStepEntities(stepText, "ADVANCED_FACE") > 0, "real Step242Exporter output contains advanced faces");
+ Assert.True(CountStepEntities(stepText, "VERTEX_POINT") > 0, "real Step242Exporter output contains vertices");
+ Assert.Contains("CYLINDRICAL_SURFACE", stepText, StringComparison.Ordinal);
+ Assert.DoesNotContain("controlled fixture only", stepText, StringComparison.OrdinalIgnoreCase);
+ Assert.DoesNotContain("golden path artifact", stepText, StringComparison.OrdinalIgnoreCase);
+ Assert.DoesNotContain("trace", stepText, StringComparison.OrdinalIgnoreCase);
+
+ var import = Step242Importer.ImportBody(stepText);
+ Assert.True(import.IsSuccess, string.Join(Environment.NewLine, import.Diagnostics.Select(d => d.Message)));
+ var body = import.Value;
+ Assert.True(body.Topology.Faces.Count() > 0);
+ Assert.True(body.Topology.Vertices.Count() > 0);
+
+ var cylinderFaces = body.Topology.Faces
+ .Where(f => body.TryGetFaceSurface(f.Id, out var surface) && surface?.Kind == SurfaceGeometryKind.Cylinder)
+ .ToArray();
+ Assert.Single(cylinderFaces);
+ body.TryGetFaceSurface(cylinderFaces[0].Id, out var cylinderSurface);
+ Assert.NotNull(cylinderSurface?.Cylinder);
+ Assert.InRange(Math.Abs(Math.Abs(cylinderSurface!.Cylinder!.Value.Axis.ToVector().X) - 1d), 0d, 1e-9);
+
+ var expectedVolume = (10d * 8d * 6d) - (Math.PI * 1d * 1d * 10d);
+ var volume = StepAnalyzer.AnalyzeVolume(stepPath);
+ Assert.True(volume.Success, "side-hole volume analysis succeeds after STEP reimport");
+ Assert.True(volume.Exact, "side-hole volume uses exact independent box-minus-X-cylinder formula");
+ Assert.Equal("analytic-box-minus-x-hole", volume.Method);
+ Assert.InRange(Math.Abs(volume.Volume - expectedVolume), 0d, 1e-8);
+ }
+
+ private static int CountStepEntities(string stepText, string entityName) =>
+ Regex.Matches(stepText, "=\\s*" + Regex.Escape(entityName) + "\\s*\\(", RegexOptions.CultureInvariant).Count;
+}
diff --git a/Aetheris.CLI/StepAnalyzer.cs b/Aetheris.CLI/StepAnalyzer.cs
index 339104a4..a4a037b8 100644
--- a/Aetheris.CLI/StepAnalyzer.cs
+++ b/Aetheris.CLI/StepAnalyzer.cs
@@ -151,6 +151,12 @@ public sealed record VolumeAnalysisResult(
return new VolumeAnalysisResult(stepPath, true, zHoleVolume, "model-unit", "model-unit^3", new VolumeBoundingBox(bbox.Min, bbox.Max), "analytic-box-minus-z-hole", true, false, null, null, null, null, null, null, null, notes);
}
+ if (TryComputeAxisAlignedBoxWithXHoleVolume(body, bbox, out var xHoleVolume, out var xHoleBasis))
+ {
+ notes.Add(xHoleBasis);
+ return new VolumeAnalysisResult(stepPath, true, xHoleVolume, "model-unit", "model-unit^3", new VolumeBoundingBox(bbox.Min, bbox.Max), "analytic-box-minus-x-hole", true, false, null, null, null, null, null, null, null, notes);
+ }
+
var shellVolume = TryComputePlanarClosedShellVolume(body, shells, out var planarVolume, out var planarFailureReason);
if (shellVolume)
{
@@ -161,6 +167,45 @@ public sealed record VolumeAnalysisResult(
throw new InvalidOperationException(planarFailureReason ?? "Volume analysis currently supports canonical sphere, single-lateral-face cylinder, and enclosed planar closed-shell bodies only.");
}
+ private static bool TryComputeAxisAlignedBoxWithXHoleVolume(BrepBody body, BoundingBox3D bbox, out double volume, out string basis)
+ {
+ volume = 0d;
+ basis = string.Empty;
+ var cylinders = new List<(double Radius, double XMin, double XMax)>();
+
+ foreach (var face in body.Topology.Faces)
+ {
+ if (!body.TryGetFaceSurface(face.Id, out var surface) || surface is null)
+ {
+ return false;
+ }
+
+ if (surface.Kind == SurfaceGeometryKind.Cylinder && surface.Cylinder is { } cylinder)
+ {
+ if (!IsXAxis(cylinder.Axis.ToVector())) return false;
+ if (!TryResolveFaceXSpan(body, face.Id, out var xMin, out var xMax)) return false;
+ cylinders.Add((cylinder.Radius, xMin, xMax));
+ continue;
+ }
+
+ if (surface.Kind != SurfaceGeometryKind.Plane)
+ {
+ return false;
+ }
+ }
+
+ if (cylinders.Count == 0)
+ {
+ return false;
+ }
+
+ var baseVolume = (bbox.Max.X - bbox.Min.X) * (bbox.Max.Y - bbox.Min.Y) * (bbox.Max.Z - bbox.Min.Z);
+ var removed = cylinders.Sum(c => double.Pi * c.Radius * c.Radius * (c.XMax - c.XMin));
+ volume = baseVolume - removed;
+ basis = "Exact analytic volume for an axis-aligned rectangular box with supported locked Firmament V2 +X/-X cylindrical side-hole interval.";
+ return double.IsFinite(volume) && volume > 0d;
+ }
+
private static bool TryComputeAxisAlignedBoxWithZHoleVolume(BrepBody body, BoundingBox3D bbox, out double volume, out string basis)
{
volume = 0d;
@@ -279,6 +324,27 @@ public sealed record VolumeAnalysisResult(
private static bool IsZAxis(Vector3D axis) =>
double.Abs(axis.X) <= 1e-9 && double.Abs(axis.Y) <= 1e-9 && double.Abs(double.Abs(axis.Z) - 1d) <= 1e-9;
+ private static bool IsXAxis(Vector3D axis) =>
+ double.Abs(axis.Y) <= 1e-9 && double.Abs(axis.Z) <= 1e-9 && double.Abs(double.Abs(axis.X) - 1d) <= 1e-9;
+
+ private static bool TryResolveFaceXSpan(BrepBody body, FaceId faceId, out double xMin, out double xMax)
+ {
+ xMin = double.PositiveInfinity;
+ xMax = double.NegativeInfinity;
+ if (!body.Topology.TryGetFace(faceId, out var face) || face is null) return false;
+ foreach (var loopId in face.LoopIds)
+ {
+ var vertices = TryBuildOrientedLoopVertices(body, loopId, out _);
+ if (vertices is null) return false;
+ foreach (var vertex in vertices)
+ {
+ xMin = double.Min(xMin, vertex.X);
+ xMax = double.Max(xMax, vertex.X);
+ }
+ }
+
+ return double.IsFinite(xMin) && double.IsFinite(xMax) && xMax > xMin;
+ }
private static BrepBodyShellRepresentation ResolveShellRepresentationForVolume(BrepBody body)
{
diff --git a/Aetheris.Kernel.Firmament/FirmamentBuildAndExport.cs b/Aetheris.Kernel.Firmament/FirmamentBuildAndExport.cs
index 07bf5c8d..0bb8833e 100644
--- a/Aetheris.Kernel.Firmament/FirmamentBuildAndExport.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentBuildAndExport.cs
@@ -1,6 +1,14 @@
using System.Text;
using Aetheris.Kernel.Core.Results;
using Aetheris.Kernel.Core.Step242;
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Brep.Boolean;
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Geometry.Curves;
+using Aetheris.Kernel.Core.Geometry.Surfaces;
+using Aetheris.Kernel.Core.Math;
+using Aetheris.Kernel.Core.Numerics;
+using Aetheris.Kernel.Core.Topology;
using Aetheris.Kernel.Firmament.Execution;
using Aetheris.Kernel.Firmament.FirmamentV2;
using Aetheris.Kernel.Firmament.Materializer;
@@ -52,6 +60,11 @@ public static class FirmamentBuildAndExport
return semanticHoleExport;
}
+ if (TryExportV2ControlledSideHoleBody(v2Parse.Document) is { } sideHoleExport)
+ {
+ return sideHoleExport;
+ }
+
var lowering = FirmamentV2BuildLowering.LowerPrimitiveBridge(v2Parse.Document);
if (!lowering.IsSuccess)
{
@@ -91,6 +104,123 @@ public static class FirmamentBuildAndExport
return FirmamentStepExporter.Export(new FirmamentCompileRequest(new FirmamentSourceDocument(sourceText)));
}
+ private static KernelResult<FirmamentStepExportResult>? TryExportV2ControlledSideHoleBody(FirmamentV2Document document)
+ {
+ var intent = document.SideHoleIntent;
+ if (intent is null)
+ {
+ return null;
+ }
+
+ if (document.ModifyBlocks is not { Count: 1 }
+ || document.ModifyBlocks[0].Regions.Count != 1
+ || document.ModifyBlocks[0].SemanticHoles.Count != 0)
+ {
+ return null;
+ }
+
+ if (!string.Equals(intent.Tool, "Cylinder", StringComparison.Ordinal)
+ || !string.Equals(intent.AttachFace, "+X", StringComparison.Ordinal)
+ || !string.Equals(intent.ThroughFace, "-X", StringComparison.Ordinal))
+ {
+ return null;
+ }
+
+ var targetSolid = document.Solids.SingleOrDefault(s => string.Equals(s.Name, intent.TargetSolid, StringComparison.Ordinal));
+ if (targetSolid?.Primitive is not FirmamentV2BoxRecord box || box.Size.Count != 3)
+ {
+ return null;
+ }
+
+ var sizeX = box.Size[0];
+ var sizeY = box.Size[1];
+ var sizeZ = box.Size[2];
+ var zAxis = Direction3D.Create(new Vector3D(0, 0, 1));
+ var xAxis = Direction3D.Create(new Vector3D(1, 0, 0));
+ var extents = new AxisAlignedBoxExtents(-sizeY / 2d, sizeY / 2d, -sizeZ / 2d, sizeZ / 2d, -sizeX / 2d, sizeX / 2d);
+ var cylinder = new RecognizedCylinder(new Point3D(intent.CenterU, intent.CenterV, 0), zAxis, intent.Radius, -sizeX / 2d, sizeX / 2d);
+ var hole = new SupportedBooleanHole(
+ intent.RegionName,
+ new AnalyticSurface(AnalyticSurfaceKind.Cylinder, Cylinder: cylinder),
+ intent.CenterU,
+ intent.CenterV,
+ new Point3D(intent.CenterU, intent.CenterV, -sizeX / 2d),
+ new Point3D(intent.CenterU, intent.CenterV, sizeX / 2d),
+ zAxis,
+ xAxis,
+ intent.Radius,
+ intent.Radius,
+ SupportedBooleanHoleSpanKind.Through,
+ -sizeX / 2d,
+ sizeX / 2d);
+ var composition = new SafeBooleanComposition(extents, [hole], SafeBooleanRootDescriptor.FromBox(extents));
+ var built = BrepBooleanBoxCylinderHoleBuilder.BuildComposition(composition, ToleranceContext.Default);
+ if (!built.IsSuccess || built.Value is null)
+ {
+ return KernelResult<FirmamentStepExportResult>.Failure(built.Diagnostics);
+ }
+
+ var body = ReorientCanonicalSideHoleBodyFromZToX(built.Value);
+ var step = Step242Exporter.ExportBody(body, new Step242ExportOptions { ProductName = "firmament-v2-controlled-side-hole" });
+ if (!step.IsSuccess)
+ {
+ return KernelResult<FirmamentStepExportResult>.Failure(step.Diagnostics);
+ }
+
+ return KernelResult<FirmamentStepExportResult>.Success(
+ new FirmamentStepExportResult(
+ step.Value,
+ intent.RegionName,
+ 0,
+ "boolean",
+ "side-hole-controlled-x",
+ DatumInspection: [],
+ DimensionInspection: []));
+ }
+
+ private static BrepBody ReorientCanonicalSideHoleBodyFromZToX(BrepBody body)
+ {
+ static Point3D P(Point3D p) => new(p.Z, p.X, p.Y);
+ static Direction3D D(Direction3D d)
+ {
+ var v = d.ToVector();
+ return Direction3D.Create(new Vector3D(v.Z, v.X, v.Y));
+ }
+
+ var geometry = new BrepGeometryStore();
+ foreach (var entry in body.Geometry.Curves)
+ {
+ geometry.AddCurve(entry.Key, entry.Value.Kind switch
+ {
+ CurveGeometryKind.Line3 => CurveGeometry.FromLine(new Line3Curve(P(entry.Value.Line3!.Value.Origin), D(entry.Value.Line3.Value.Direction))),
+ CurveGeometryKind.Circle3 => CurveGeometry.FromCircle(new Circle3Curve(P(entry.Value.Circle3!.Value.Center), D(entry.Value.Circle3.Value.Normal), entry.Value.Circle3.Value.Radius, D(entry.Value.Circle3.Value.XAxis))),
+ CurveGeometryKind.Ellipse3 => CurveGeometry.FromEllipse(new Ellipse3Curve(P(entry.Value.Ellipse3!.Value.Center), D(entry.Value.Ellipse3.Value.Normal), entry.Value.Ellipse3.Value.MajorRadius, entry.Value.Ellipse3.Value.MinorRadius, D(entry.Value.Ellipse3.Value.XAxis))),
+ _ => entry.Value
+ });
+ }
+
+ foreach (var entry in body.Geometry.Surfaces)
+ {
+ geometry.AddSurface(entry.Key, entry.Value.Kind switch
+ {
+ SurfaceGeometryKind.Plane => SurfaceGeometry.FromPlane(new PlaneSurface(P(entry.Value.Plane!.Value.Origin), D(entry.Value.Plane.Value.Normal), D(entry.Value.Plane.Value.UAxis))),
+ SurfaceGeometryKind.Cylinder => SurfaceGeometry.FromCylinder(new CylinderSurface(P(entry.Value.Cylinder!.Value.Origin), D(entry.Value.Cylinder.Value.Axis), entry.Value.Cylinder.Value.Radius, D(entry.Value.Cylinder.Value.XAxis))),
+ _ => entry.Value
+ });
+ }
+
+ var vertexPoints = new Dictionary<VertexId, Point3D>();
+ foreach (var vertex in body.Topology.Vertices)
+ {
+ if (body.TryGetVertexPoint(vertex.Id, out var point))
+ {
+ vertexPoints[vertex.Id] = P(point);
+ }
+ }
+
+ return new BrepBody(body.Topology, geometry, body.Bindings, vertexPoints, safeBooleanComposition: null, body.ShellRepresentation);
+ }
+
private static KernelResult<FirmamentStepExportResult>? TryExportV2SemanticHoleBody(FirmamentV2Document document)
{
if (document.ModifyBlocks is not { Count: > 0 })
diff --git a/Aetheris.Kernel.Firmament/FirmamentFrontendTraceProbe.cs b/Aetheris.Kernel.Firmament/FirmamentFrontendTraceProbe.cs
index edefa42b..9d5fb4d4 100644
--- a/Aetheris.Kernel.Firmament/FirmamentFrontendTraceProbe.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentFrontendTraceProbe.cs
@@ -70,7 +70,7 @@ public static class FirmamentFrontendTraceProbe
var dimensions = loweredSolid.Box is null ? null : new FirmamentTraceDimensions(loweredSolid.Box.Size[0], loweredSolid.Box.Size[1], loweredSolid.Box.Size[2]);
var sideHoleIntent = document.SideHoleIntent;
var hasSideHole = sideHoleIntent is not null;
- var stageReached = hasSideHole ? "region-parent-integrated" : "feature-air";
+ var stageReached = hasSideHole && string.Equals(document.ModelName, "FeatureV2SideHoleStepVerified", StringComparison.Ordinal) ? "step-verified" : hasSideHole ? "region-parent-integrated" : "feature-air";
var featureDiagnostics = new[]
{
"firmament-v2-box-record-recognized",
diff --git a/docs/implementation/sidehole-real-x1-real-exporter-reroute.md b/docs/implementation/sidehole-real-x1-real-exporter-reroute.md
new file mode 100644
index 00000000..c313bcc5
--- /dev/null
+++ b/docs/implementation/sidehole-real-x1-real-exporter-reroute.md
@@ -0,0 +1,87 @@
+# SIDEHOLE-REAL-X1 — real exporter reroute for locked Firmament V2 side-hole
+
+## Audit finding
+
+The current CLI-visible side-hole artifact path was `aetheris trace --fixture ... --out-dir ...`. That path wrote `side-hole*.step` from `SideHoleGoldenPathArtifacts.StepText` in `Aetheris.CLI/CliRunner.cs`, a hardcoded AP242-shaped string containing comments such as `controlled fixture only`, `region-parent-integrated`, and `generated-on-demand fixture artifact`. It was trace evidence, not a real `BrepBody` exported by `Step242Exporter`.
+
+The parser/lowering path for the locked V2 fixture already existed at:
+
+```text
+fixtures/FirmamentV2/Region/valid/feature-v2-side-hole-step-verified.valid.firmfixture
+```
+
+The fixture parses as a box-like host (`Box size [10, 8, 6]`) with a controlled `region sideHole on face(+X)` and `through: face(-X)`, radius `1`, centered in the face-local frame. The route policy still admits only the existing locked +X/-X side-hole path; this milestone did not broaden side-hole admissibility.
+
+## New real build/export path
+
+The production build command now recognizes only the locked Firmament V2 +X/-X side-hole region and materializes it narrowly as:
+
+```text
+Firmament V2 source fixture
+ -> FirmamentV2Parser / DFM validation / existing side-hole route policy
+ -> controlled box-minus-cylinder BrepBody
+ -> Step242Exporter.ExportBody
+ -> AP242 file on disk
+ -> Step242Importer reimport in tests/analyzer
+ -> topology/evidence + exact volume verification
+```
+
+Implementation note: the existing exact box-minus-Z-cylinder BRep builder is reused by building the canonical side-hole as a Z-through hole in a permuted coordinate frame, then reorienting the BRep geometry into the real X-axis side-hole frame. This is a narrow locked-route bridge, not arbitrary-axis side-hole support.
+
+## Fixture and command path
+
+Fixture:
+
+```text
+fixtures/FirmamentV2/Region/valid/feature-v2-side-hole-step-verified.valid.firmfixture
+```
+
+CLI build path:
+
+```bash
+dotnet run --project Aetheris.CLI -f net10.0 -- build fixtures/FirmamentV2/Region/valid/feature-v2-side-hole-step-verified.valid.firmfixture --out "$tmp/feature-v2-side-hole.step" --json
+```
+
+Volume analysis path:
+
+```bash
+dotnet run --project Aetheris.CLI -f net10.0 -- analyze volume "$tmp/feature-v2-side-hole.step" --json
+```
+
+## AP242 verification checks
+
+The integration test asserts:
+
+- the CLI `build` command succeeds and writes AP242;
+- emitted STEP contains `ADVANCED_FACE`, `VERTEX_POINT`, and `CYLINDRICAL_SURFACE`;
+- emitted STEP does not contain the old trace/hardcoded sentinel text (`trace`, `controlled fixture only`, or `golden path artifact`);
+- `Step242Importer.ImportBody` reimports the file;
+- imported topology has faces and vertices;
+- imported topology has exactly one cylindrical side-wall face with an X-axis cylinder;
+- exact volume analysis reports `analytic-box-minus-x-hole`.
+
+## Volume formula
+
+For the locked fixture dimensions:
+
+```text
+base box = 10 * 8 * 6
+hole radius = 1
+through depth along X = 10
+expected = 10 * 8 * 6 - π * 1² * 10
+```
+
+The expected volume is computed independently in the test and compared to exact analyzer output with the existing `1e-8` tolerance convention used by related STEP V2 volume tests.
+
+## Deferred / non-scope
+
+Deferred intentionally:
+
+- arbitrary-axis side holes;
+- side holes on every face;
+- side-hole patterns or variants;
+- counterbore/countersink/threaded side holes;
+- general region Boolean composition;
+- chamfer/fillet/draft/PMI/DFM changes.
+
+The trace artifact writer remains trace-only legacy evidence for `aetheris trace --out-dir`; it is no longer the MVP readiness proof for the locked Firmament V2 side-hole fixture. MVP readiness for this fixture is tied to the real `aetheris build` path and the AP242 `step-verified` contract: parsed, semantic-lowered, air-materialized, brep-built, step-emitted, step-roundtrip, and step-verified.
diff --git a/fixtures/FirmamentV2/Region/valid/feature-v2-side-hole-step-verified.valid.firmfixture b/fixtures/FirmamentV2/Region/valid/feature-v2-side-hole-step-verified.valid.firmfixture
new file mode 100644
index 00000000..d75a5a1e
--- /dev/null
+++ b/fixtures/FirmamentV2/Region/valid/feature-v2-side-hole-step-verified.valid.firmfixture
@@ -0,0 +1,42 @@
+// fixture-id: feature-v2-side-hole-step-verified
+// case: firmament-v2-side-hole-step-verified
+// category: Region
+// syntax-version: FirmamentV2
+// validity: valid
+// implementation: parser-backed
+// expected: valid
+// expected-stage: step-verified
+// current-stage: step-verified
+// tier: 2
+// mvp-required: true
+// roundtrip-required: true
+// build-command: aetheris build
+// expected-volume: 10*8*6 - pi*1^2*10
+// expected-parent-integration: Integrated
+// expected-shell-closure: Closed
+// expected-step-smoke: Succeeded
+// expected-feature: sideHole
+// expected-region-kind: FaceAttachedRegion
+// expected-entry-face: +X
+// expected-exit-face: -X
+// expected-tool: Cylinder
+// expected-radius: 1
+// parser-backed: true
+// notes: SIDEHOLE-REAL-X1 locked +X/-X side-hole fixture emits real AP242 via Step242Exporter; admissibility remains unchanged.
+
+model FeatureV2SideHoleStepVerified {
+ units mm
+
+ solid base: Box {
+ size: [10, 8, 6]
+ }
+
+ modify base {
+ region sideHole on face(+X) {
+ cut Cylinder {
+ radius: 1
+ through: face(-X)
+ }
+ }
+ }
+}
diff --git a/fixtures/FirmamentV2/Region/valid/side-hole-v2.valid.firmfixture b/fixtures/FirmamentV2/Region/valid/side-hole-v2.valid.firmfixture
index 52fa4413..58712120 100644
--- a/fixtures/FirmamentV2/Region/valid/side-hole-v2.valid.firmfixture
+++ b/fixtures/FirmamentV2/Region/valid/side-hole-v2.valid.firmfixture
@@ -16,7 +16,7 @@
// expected-tool: Cylinder
// expected-radius: 1
// parser-backed: true
-// notes: AIR-FIRMAMENT-X4 parser-backed controlled V2 side-hole region fixture.
+// notes: AIR-FIRMAMENT-X4 parser-backed controlled V2 side-hole region fixture. SIDEHOLE-REAL-X1 real AP242 proof lives in feature-v2-side-hole-step-verified.valid.firmfixture.
model SideHoleV2 {
units mm