Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add minimal topology-geometry binding model for M06

Yuechen Li4f0ea45098b4
diff --git a/Aetheris.Kernel.Core.Tests/Brep/BoxBrepFixtureTests.cs b/Aetheris.Kernel.Core.Tests/Brep/BoxBrepFixtureTests.cs
new file mode 100644
index 00000000..e1dbfa02
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Brep/BoxBrepFixtureTests.cs
@@ -0,0 +1,128 @@
+using Aetheris.Kernel.Core.Brep;
+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.Topology;
+
+namespace Aetheris.Kernel.Core.Tests.Brep;
+
+public sealed class BoxBrepFixtureTests
+{
+ [Fact]
+ public void ManualBoxBrep_CanBeConstructedAndValidated()
+ {
+ var body = BuildUnitBoxBrep();
+
+ var result = BrepBindingValidator.Validate(body);
+
+ Assert.True(result.IsSuccess);
+ Assert.True(body.TryGetEdgeCurveGeometry(new EdgeId(1), out var edgeCurve));
+ Assert.Equal(CurveGeometryKind.Line3, edgeCurve!.Kind);
+
+ Assert.True(body.TryGetFaceSurfaceGeometry(new FaceId(1), out var faceSurface));
+ Assert.Equal(SurfaceGeometryKind.Plane, faceSurface!.Kind);
+ }
+
+ private static BrepBody BuildUnitBoxBrep()
+ {
+ var builder = new TopologyBuilder();
+
+ var v1 = builder.AddVertex();
+ var v2 = builder.AddVertex();
+ var v3 = builder.AddVertex();
+ var v4 = builder.AddVertex();
+ var v5 = builder.AddVertex();
+ var v6 = builder.AddVertex();
+ var v7 = builder.AddVertex();
+ var v8 = builder.AddVertex();
+
+ var e1 = builder.AddEdge(v1, v2);
+ var e2 = builder.AddEdge(v2, v3);
+ var e3 = builder.AddEdge(v3, v4);
+ var e4 = builder.AddEdge(v4, v1);
+ var e5 = builder.AddEdge(v5, v6);
+ var e6 = builder.AddEdge(v6, v7);
+ var e7 = builder.AddEdge(v7, v8);
+ var e8 = builder.AddEdge(v8, v5);
+ var e9 = builder.AddEdge(v1, v5);
+ var e10 = builder.AddEdge(v2, v6);
+ var e11 = builder.AddEdge(v3, v7);
+ var e12 = builder.AddEdge(v4, v8);
+
+ var f1 = AddFaceWithLoop(builder, [e1, e2, e3, e4]);
+ var f2 = AddFaceWithLoop(builder, [e5, e6, e7, e8]);
+ var f3 = AddFaceWithLoop(builder, [e1, e10, e5, e9]);
+ var f4 = AddFaceWithLoop(builder, [e2, e11, e6, e10]);
+ var f5 = AddFaceWithLoop(builder, [e3, e12, e7, e11]);
+ var f6 = AddFaceWithLoop(builder, [e4, e9, e8, e12]);
+
+ var shell = builder.AddShell([f1, f2, f3, f4, f5, f6]);
+ builder.AddBody([shell]);
+
+ var geometry = new BrepGeometryStore();
+ AddLineCurve(geometry, 1, Point3D.Origin, new Vector3D(1d, 0d, 0d));
+ AddLineCurve(geometry, 2, new Point3D(1d, 0d, 0d), new Vector3D(0d, 1d, 0d));
+ AddLineCurve(geometry, 3, new Point3D(1d, 1d, 0d), new Vector3D(-1d, 0d, 0d));
+ AddLineCurve(geometry, 4, new Point3D(0d, 1d, 0d), new Vector3D(0d, -1d, 0d));
+ AddLineCurve(geometry, 5, new Point3D(0d, 0d, 1d), new Vector3D(1d, 0d, 0d));
+ AddLineCurve(geometry, 6, new Point3D(1d, 0d, 1d), new Vector3D(0d, 1d, 0d));
+ AddLineCurve(geometry, 7, new Point3D(1d, 1d, 1d), new Vector3D(-1d, 0d, 0d));
+ AddLineCurve(geometry, 8, new Point3D(0d, 1d, 1d), new Vector3D(0d, -1d, 0d));
+ AddLineCurve(geometry, 9, Point3D.Origin, new Vector3D(0d, 0d, 1d));
+ AddLineCurve(geometry, 10, new Point3D(1d, 0d, 0d), new Vector3D(0d, 0d, 1d));
+ AddLineCurve(geometry, 11, new Point3D(1d, 1d, 0d), new Vector3D(0d, 0d, 1d));
+ AddLineCurve(geometry, 12, new Point3D(0d, 1d, 0d), new Vector3D(0d, 0d, 1d));
+
+ geometry.AddSurface(new SurfaceGeometryId(1), PlaneAt(new Point3D(0d, 0d, 0d), new Vector3D(0d, 0d, -1d), new Vector3D(1d, 0d, 0d)));
+ geometry.AddSurface(new SurfaceGeometryId(2), PlaneAt(new Point3D(0d, 0d, 1d), new Vector3D(0d, 0d, 1d), new Vector3D(1d, 0d, 0d)));
+ geometry.AddSurface(new SurfaceGeometryId(3), PlaneAt(new Point3D(0d, 0d, 0d), new Vector3D(0d, -1d, 0d), new Vector3D(1d, 0d, 0d)));
+ geometry.AddSurface(new SurfaceGeometryId(4), PlaneAt(new Point3D(1d, 0d, 0d), new Vector3D(1d, 0d, 0d), new Vector3D(0d, 1d, 0d)));
+ geometry.AddSurface(new SurfaceGeometryId(5), PlaneAt(new Point3D(0d, 1d, 0d), new Vector3D(0d, 1d, 0d), new Vector3D(-1d, 0d, 0d)));
+ geometry.AddSurface(new SurfaceGeometryId(6), PlaneAt(new Point3D(0d, 0d, 0d), new Vector3D(-1d, 0d, 0d), new Vector3D(0d, 1d, 0d)));
+
+ var bindings = new BrepBindingModel();
+ for (var edgeIndex = 1; edgeIndex <= 12; edgeIndex++)
+ {
+ bindings.AddEdgeBinding(new EdgeGeometryBinding(new EdgeId(edgeIndex), new CurveGeometryId(edgeIndex), new ParameterInterval(0d, 1d)));
+ }
+
+ for (var faceIndex = 1; faceIndex <= 6; faceIndex++)
+ {
+ bindings.AddFaceBinding(new FaceGeometryBinding(new FaceId(faceIndex), new SurfaceGeometryId(faceIndex)));
+ }
+
+ return new BrepBody(builder.Model, geometry, bindings);
+ }
+
+ private static FaceId AddFaceWithLoop(TopologyBuilder builder, IReadOnlyList<EdgeId> edges)
+ {
+ var loopId = builder.AllocateLoopId();
+ var coedgeIds = new CoedgeId[edges.Count];
+
+ for (var i = 0; i < edges.Count; i++)
+ {
+ coedgeIds[i] = builder.AllocateCoedgeId();
+ }
+
+ for (var i = 0; i < edges.Count; i++)
+ {
+ var next = coedgeIds[(i + 1) % edges.Count];
+ var prev = coedgeIds[(i + edges.Count - 1) % edges.Count];
+ builder.AddCoedge(new Coedge(coedgeIds[i], edges[i], loopId, next, prev, false));
+ }
+
+ builder.AddLoop(new Loop(loopId, coedgeIds));
+ return builder.AddFace([loopId]);
+ }
+
+ private static void AddLineCurve(BrepGeometryStore geometry, int id, Point3D origin, Vector3D direction)
+ {
+ geometry.AddCurve(new CurveGeometryId(id), CurveGeometry.FromLine(new Line3Curve(origin, Direction3D.Create(direction))));
+ }
+
+ private static SurfaceGeometry PlaneAt(Point3D origin, Vector3D normal, Vector3D uAxis)
+ {
+ return SurfaceGeometry.FromPlane(new PlaneSurface(origin, Direction3D.Create(normal), Direction3D.Create(uAxis)));
+ }
+}
diff --git a/Aetheris.Kernel.Core.Tests/Brep/BrepBindingModelAndBodyTests.cs b/Aetheris.Kernel.Core.Tests/Brep/BrepBindingModelAndBodyTests.cs
new file mode 100644
index 00000000..fd42eead
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Brep/BrepBindingModelAndBodyTests.cs
@@ -0,0 +1,55 @@
+using Aetheris.Kernel.Core.Brep;
+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.Topology;
+
+namespace Aetheris.Kernel.Core.Tests.Brep;
+
+public sealed class BrepBindingModelAndBodyTests
+{
+ [Fact]
+ public void BrepBody_EdgeAndFaceBindingLookupResolvesGeometry()
+ {
+ var topology = new TopologyModel();
+ var edgeId = new EdgeId(1);
+ var faceId = new FaceId(1);
+
+ topology.AddVertex(new Vertex(new VertexId(1)));
+ topology.AddVertex(new Vertex(new VertexId(2)));
+ topology.AddEdge(new Edge(edgeId, new VertexId(1), new VertexId(2)));
+ topology.AddFace(new Face(faceId, []));
+
+ var geometry = new BrepGeometryStore();
+ geometry.AddCurve(new CurveGeometryId(1), CurveGeometry.FromLine(new Line3Curve(Point3D.Origin, Direction3D.Create(new Vector3D(1d, 0d, 0d)))));
+ geometry.AddSurface(new SurfaceGeometryId(1), SurfaceGeometry.FromPlane(new PlaneSurface(
+ Point3D.Origin,
+ Direction3D.Create(new Vector3D(0d, 0d, 1d)),
+ Direction3D.Create(new Vector3D(1d, 0d, 0d)))));
+
+ var bindings = new BrepBindingModel();
+ bindings.AddEdgeBinding(new EdgeGeometryBinding(edgeId, new CurveGeometryId(1), new ParameterInterval(0d, 1d)));
+ bindings.AddFaceBinding(new FaceGeometryBinding(faceId, new SurfaceGeometryId(1)));
+
+ var body = new BrepBody(topology, geometry, bindings);
+
+ Assert.True(body.TryGetEdgeCurveGeometry(edgeId, out var edgeCurve));
+ Assert.Equal(CurveGeometryKind.Line3, edgeCurve!.Kind);
+
+ Assert.True(body.TryGetFaceSurfaceGeometry(faceId, out var faceSurface));
+ Assert.Equal(SurfaceGeometryKind.Plane, faceSurface!.Kind);
+ }
+
+ [Fact]
+ public void BrepBody_MissingBindingLookupReturnsFalse()
+ {
+ var body = new BrepBody(new TopologyModel(), new BrepGeometryStore(), new BrepBindingModel());
+
+ Assert.False(body.TryGetEdgeCurveGeometry(new EdgeId(42), out var curve));
+ Assert.Null(curve);
+
+ Assert.False(body.TryGetFaceSurfaceGeometry(new FaceId(42), out var surface));
+ Assert.Null(surface);
+ }
+}
diff --git a/Aetheris.Kernel.Core.Tests/Brep/BrepBindingValidatorTests.cs b/Aetheris.Kernel.Core.Tests/Brep/BrepBindingValidatorTests.cs
new file mode 100644
index 00000000..1f1d3882
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Brep/BrepBindingValidatorTests.cs
@@ -0,0 +1,89 @@
+using Aetheris.Kernel.Core.Brep;
+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.Topology;
+
+namespace Aetheris.Kernel.Core.Tests.Brep;
+
+public sealed class BrepBindingValidatorTests
+{
+ [Fact]
+ public void Validator_DetectsMissingReferencedCurveGeometry()
+ {
+ var topology = new TopologyModel();
+ topology.AddVertex(new Vertex(new VertexId(1)));
+ topology.AddVertex(new Vertex(new VertexId(2)));
+ topology.AddEdge(new Edge(new EdgeId(1), new VertexId(1), new VertexId(2)));
+
+ var bindings = new BrepBindingModel();
+ bindings.AddEdgeBinding(new EdgeGeometryBinding(new EdgeId(1), new CurveGeometryId(99)));
+
+ var result = BrepBindingValidator.Validate(new BrepBody(topology, new BrepGeometryStore(), bindings), requireAllEdgeAndFaceBindings: false);
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains(result.Diagnostics, d => d.Message.Contains("missing curve geometry 99"));
+ }
+
+ [Fact]
+ public void Validator_DetectsMissingReferencedSurfaceGeometry()
+ {
+ var topology = new TopologyModel();
+ topology.AddFace(new Face(new FaceId(1), []));
+
+ var bindings = new BrepBindingModel();
+ bindings.AddFaceBinding(new FaceGeometryBinding(new FaceId(1), new SurfaceGeometryId(77)));
+
+ var result = BrepBindingValidator.Validate(new BrepBody(topology, new BrepGeometryStore(), bindings), requireAllEdgeAndFaceBindings: false);
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains(result.Diagnostics, d => d.Message.Contains("missing surface geometry 77"));
+ }
+
+ [Fact]
+ public void Validator_DetectsBindingsToNonexistentTopology()
+ {
+ var geometry = new BrepGeometryStore();
+ geometry.AddCurve(new CurveGeometryId(1), CurveGeometry.FromLine(new Line3Curve(Point3D.Origin, Direction3D.Create(new Vector3D(1d, 0d, 0d)))));
+ geometry.AddSurface(new SurfaceGeometryId(1), SurfaceGeometry.FromPlane(new PlaneSurface(
+ Point3D.Origin,
+ Direction3D.Create(new Vector3D(0d, 0d, 1d)),
+ Direction3D.Create(new Vector3D(1d, 0d, 0d)))));
+
+ var bindings = new BrepBindingModel();
+ bindings.AddEdgeBinding(new EdgeGeometryBinding(new EdgeId(10), new CurveGeometryId(1)));
+ bindings.AddFaceBinding(new FaceGeometryBinding(new FaceId(20), new SurfaceGeometryId(1)));
+
+ var result = BrepBindingValidator.Validate(new BrepBody(new TopologyModel(), geometry, bindings), requireAllEdgeAndFaceBindings: false);
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains(result.Diagnostics, d => d.Message.Contains("missing edge 10"));
+ Assert.Contains(result.Diagnostics, d => d.Message.Contains("missing face 20"));
+ }
+
+ [Fact]
+ public void Validator_ReturnsSuccessForValidCombinedModel()
+ {
+ var topology = new TopologyModel();
+ topology.AddVertex(new Vertex(new VertexId(1)));
+ topology.AddVertex(new Vertex(new VertexId(2)));
+ topology.AddEdge(new Edge(new EdgeId(1), new VertexId(1), new VertexId(2)));
+ topology.AddFace(new Face(new FaceId(1), []));
+
+ var geometry = new BrepGeometryStore();
+ geometry.AddCurve(new CurveGeometryId(1), CurveGeometry.FromLine(new Line3Curve(Point3D.Origin, Direction3D.Create(new Vector3D(1d, 0d, 0d)))));
+ geometry.AddSurface(new SurfaceGeometryId(1), SurfaceGeometry.FromPlane(new PlaneSurface(
+ Point3D.Origin,
+ Direction3D.Create(new Vector3D(0d, 0d, 1d)),
+ Direction3D.Create(new Vector3D(1d, 0d, 0d)))));
+
+ var bindings = new BrepBindingModel();
+ bindings.AddEdgeBinding(new EdgeGeometryBinding(new EdgeId(1), new CurveGeometryId(1), new ParameterInterval(0d, 1d)));
+ bindings.AddFaceBinding(new FaceGeometryBinding(new FaceId(1), new SurfaceGeometryId(1)));
+
+ var result = BrepBindingValidator.Validate(new BrepBody(topology, geometry, bindings));
+
+ Assert.True(result.IsSuccess);
+ }
+}
diff --git a/Aetheris.Kernel.Core.Tests/Brep/BrepGeometryStoreTests.cs b/Aetheris.Kernel.Core.Tests/Brep/BrepGeometryStoreTests.cs
new file mode 100644
index 00000000..005ddbbf
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Brep/BrepGeometryStoreTests.cs
@@ -0,0 +1,58 @@
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Geometry.Curves;
+using Aetheris.Kernel.Core.Geometry.Surfaces;
+using Aetheris.Kernel.Core.Math;
+
+namespace Aetheris.Kernel.Core.Tests.Brep;
+
+public sealed class BrepGeometryStoreTests
+{
+ [Fact]
+ public void GeometryTypedIds_ExposeValidityAndValueEquality()
+ {
+ var curveIdA = new CurveGeometryId(3);
+ var curveIdB = new CurveGeometryId(3);
+ var surfaceId = new SurfaceGeometryId(4);
+
+ Assert.Equal(curveIdA, curveIdB);
+ Assert.True(curveIdA.IsValid);
+ Assert.False(CurveGeometryId.Invalid.IsValid);
+ Assert.True(surfaceId.IsValid);
+ Assert.False(SurfaceGeometryId.Invalid.IsValid);
+ }
+
+ [Fact]
+ public void GeometryStore_AddGetTryGetWorks()
+ {
+ var store = new BrepGeometryStore();
+ var line = CurveGeometry.FromLine(new Line3Curve(Point3D.Origin, Direction3D.Create(new Vector3D(1d, 0d, 0d))));
+ var plane = SurfaceGeometry.FromPlane(new PlaneSurface(
+ Point3D.Origin,
+ Direction3D.Create(new Vector3D(0d, 0d, 1d)),
+ Direction3D.Create(new Vector3D(1d, 0d, 0d))));
+
+ store.AddCurve(new CurveGeometryId(1), line);
+ store.AddSurface(new SurfaceGeometryId(1), plane);
+
+ Assert.True(store.TryGetCurve(new CurveGeometryId(1), out var foundCurve));
+ Assert.Equal(CurveGeometryKind.Line3, foundCurve!.Kind);
+ Assert.Equal(line, store.GetCurve(new CurveGeometryId(1)));
+
+ Assert.True(store.TryGetSurface(new SurfaceGeometryId(1), out var foundSurface));
+ Assert.Equal(SurfaceGeometryKind.Plane, foundSurface!.Kind);
+ Assert.Equal(plane, store.GetSurface(new SurfaceGeometryId(1)));
+ }
+
+ [Fact]
+ public void GeometryStore_DuplicateIdAddThrows()
+ {
+ var store = new BrepGeometryStore();
+ var curveId = new CurveGeometryId(1);
+
+ store.AddCurve(curveId, CurveGeometry.FromLine(new Line3Curve(Point3D.Origin, Direction3D.Create(new Vector3D(1d, 0d, 0d)))));
+
+ Assert.Throws<ArgumentException>(() =>
+ store.AddCurve(curveId, CurveGeometry.FromLine(new Line3Curve(Point3D.Origin, Direction3D.Create(new Vector3D(0d, 1d, 0d))))));
+ }
+}
diff --git a/Aetheris.Kernel.Core/Brep/BrepBindingValidator.cs b/Aetheris.Kernel.Core/Brep/BrepBindingValidator.cs
new file mode 100644
index 00000000..5e621fae
--- /dev/null
+++ b/Aetheris.Kernel.Core/Brep/BrepBindingValidator.cs
@@ -0,0 +1,80 @@
+using Aetheris.Kernel.Core.Diagnostics;
+using Aetheris.Kernel.Core.Results;
+using Aetheris.Kernel.Core.Topology;
+
+namespace Aetheris.Kernel.Core.Brep;
+
+/// <summary>
+/// M06 scope: topology reference integrity + topology-to-geometry binding reference integrity.
+/// Geometric consistency checks are intentionally deferred.
+/// </summary>
+public static class BrepBindingValidator
+{
+ public static KernelResult<bool> Validate(BrepBody body, bool requireAllEdgeAndFaceBindings = true)
+ {
+ var diagnostics = new List<KernelDiagnostic>();
+
+ var topologyResult = TopologyGraphValidator.Validate(body.Topology);
+ diagnostics.AddRange(topologyResult.Diagnostics);
+
+ foreach (var edgeBinding in body.Bindings.EdgeBindings)
+ {
+ if (!body.Topology.TryGetEdge(edgeBinding.EdgeId, out _))
+ {
+ diagnostics.Add(Error($"Edge binding references missing edge {edgeBinding.EdgeId.Value}."));
+ }
+
+ if (!body.Geometry.TryGetCurve(edgeBinding.CurveGeometryId, out _))
+ {
+ diagnostics.Add(Error($"Edge {edgeBinding.EdgeId.Value} binding references missing curve geometry {edgeBinding.CurveGeometryId.Value}."));
+ }
+
+ if (edgeBinding.TrimInterval is { } trimInterval)
+ {
+ if (!double.IsFinite(trimInterval.Start) || !double.IsFinite(trimInterval.End) || trimInterval.End < trimInterval.Start)
+ {
+ diagnostics.Add(Error($"Edge {edgeBinding.EdgeId.Value} has invalid trim interval [{trimInterval.Start}, {trimInterval.End}]."));
+ }
+ }
+ }
+
+ foreach (var faceBinding in body.Bindings.FaceBindings)
+ {
+ if (!body.Topology.TryGetFace(faceBinding.FaceId, out _))
+ {
+ diagnostics.Add(Error($"Face binding references missing face {faceBinding.FaceId.Value}."));
+ }
+
+ if (!body.Geometry.TryGetSurface(faceBinding.SurfaceGeometryId, out _))
+ {
+ diagnostics.Add(Error($"Face {faceBinding.FaceId.Value} binding references missing surface geometry {faceBinding.SurfaceGeometryId.Value}."));
+ }
+ }
+
+ if (requireAllEdgeAndFaceBindings)
+ {
+ foreach (var edge in body.Topology.Edges)
+ {
+ if (!body.Bindings.TryGetEdgeBinding(edge.Id, out _))
+ {
+ diagnostics.Add(Error($"Edge {edge.Id.Value} is missing a geometry binding."));
+ }
+ }
+
+ foreach (var face in body.Topology.Faces)
+ {
+ if (!body.Bindings.TryGetFaceBinding(face.Id, out _))
+ {
+ diagnostics.Add(Error($"Face {face.Id.Value} is missing a geometry binding."));
+ }
+ }
+ }
+
+ return diagnostics.Any(d => d.Severity == KernelDiagnosticSeverity.Error)
+ ? KernelResult<bool>.Failure(diagnostics)
+ : KernelResult<bool>.Success(true, diagnostics);
+ }
+
+ private static KernelDiagnostic Error(string message) =>
+ new(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, message);
+}
diff --git a/Aetheris.Kernel.Core/Brep/BrepBindings.cs b/Aetheris.Kernel.Core/Brep/BrepBindings.cs
new file mode 100644
index 00000000..2e948259
--- /dev/null
+++ b/Aetheris.Kernel.Core/Brep/BrepBindings.cs
@@ -0,0 +1,33 @@
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Topology;
+
+namespace Aetheris.Kernel.Core.Brep;
+
+public readonly record struct EdgeGeometryBinding(EdgeId EdgeId, CurveGeometryId CurveGeometryId, ParameterInterval? TrimInterval = null);
+
+public readonly record struct FaceGeometryBinding(FaceId FaceId, SurfaceGeometryId SurfaceGeometryId);
+
+/// <summary>
+/// Explicit topology-to-geometry binding container.
+/// </summary>
+public sealed class BrepBindingModel
+{
+ private readonly Dictionary<EdgeId, EdgeGeometryBinding> _edgeBindings = [];
+ private readonly Dictionary<FaceId, FaceGeometryBinding> _faceBindings = [];
+
+ public IEnumerable<EdgeGeometryBinding> EdgeBindings => _edgeBindings.Values;
+
+ public IEnumerable<FaceGeometryBinding> FaceBindings => _faceBindings.Values;
+
+ public void AddEdgeBinding(EdgeGeometryBinding binding) => _edgeBindings.Add(binding.EdgeId, binding);
+
+ public void AddFaceBinding(FaceGeometryBinding binding) => _faceBindings.Add(binding.FaceId, binding);
+
+ public bool TryGetEdgeBinding(EdgeId edgeId, out EdgeGeometryBinding binding) => _edgeBindings.TryGetValue(edgeId, out binding);
+
+ public bool TryGetFaceBinding(FaceId faceId, out FaceGeometryBinding binding) => _faceBindings.TryGetValue(faceId, out binding);
+
+ public EdgeGeometryBinding GetEdgeBinding(EdgeId edgeId) => _edgeBindings[edgeId];
+
+ public FaceGeometryBinding GetFaceBinding(FaceId faceId) => _faceBindings[faceId];
+}
diff --git a/Aetheris.Kernel.Core/Brep/BrepBody.cs b/Aetheris.Kernel.Core/Brep/BrepBody.cs
new file mode 100644
index 00000000..67a6d21f
--- /dev/null
+++ b/Aetheris.Kernel.Core/Brep/BrepBody.cs
@@ -0,0 +1,47 @@
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Topology;
+
+namespace Aetheris.Kernel.Core.Brep;
+
+/// <summary>
+/// Minimal combined topology + geometry + binding aggregate for B-rep bodies.
+/// </summary>
+public sealed class BrepBody
+{
+ public BrepBody(TopologyModel topology, BrepGeometryStore geometry, BrepBindingModel bindings)
+ {
+ Topology = topology;
+ Geometry = geometry;
+ Bindings = bindings;
+ }
+
+ public TopologyModel Topology { get; }
+
+ public BrepGeometryStore Geometry { get; }
+
+ public BrepBindingModel Bindings { get; }
+
+ public bool TryGetEdgeCurveGeometry(EdgeId edgeId, out CurveGeometry? curve)
+ {
+ curve = null;
+
+ if (!Bindings.TryGetEdgeBinding(edgeId, out var binding))
+ {
+ return false;
+ }
+
+ return Geometry.TryGetCurve(binding.CurveGeometryId, out curve);
+ }
+
+ public bool TryGetFaceSurfaceGeometry(FaceId faceId, out SurfaceGeometry? surface)
+ {
+ surface = null;
+
+ if (!Bindings.TryGetFaceBinding(faceId, out var binding))
+ {
+ return false;
+ }
+
+ return Geometry.TryGetSurface(binding.SurfaceGeometryId, out surface);
+ }
+}
diff --git a/Aetheris.Kernel.Core/Brep/BrepGeometryStore.cs b/Aetheris.Kernel.Core/Brep/BrepGeometryStore.cs
new file mode 100644
index 00000000..1e921e7c
--- /dev/null
+++ b/Aetheris.Kernel.Core/Brep/BrepGeometryStore.cs
@@ -0,0 +1,28 @@
+using Aetheris.Kernel.Core.Geometry;
+
+namespace Aetheris.Kernel.Core.Brep;
+
+/// <summary>
+/// In-memory geometry definition store keyed by typed geometry IDs.
+/// </summary>
+public sealed class BrepGeometryStore
+{
+ private readonly Dictionary<CurveGeometryId, CurveGeometry> _curves = [];
+ private readonly Dictionary<SurfaceGeometryId, SurfaceGeometry> _surfaces = [];
+
+ public IEnumerable<KeyValuePair<CurveGeometryId, CurveGeometry>> Curves => _curves;
+
+ public IEnumerable<KeyValuePair<SurfaceGeometryId, SurfaceGeometry>> Surfaces => _surfaces;
+
+ public void AddCurve(CurveGeometryId id, CurveGeometry curve) => _curves.Add(id, curve);
+
+ public void AddSurface(SurfaceGeometryId id, SurfaceGeometry surface) => _surfaces.Add(id, surface);
+
+ public bool TryGetCurve(CurveGeometryId id, out CurveGeometry? curve) => _curves.TryGetValue(id, out curve);
+
+ public bool TryGetSurface(SurfaceGeometryId id, out SurfaceGeometry? surface) => _surfaces.TryGetValue(id, out surface);
+
+ public CurveGeometry GetCurve(CurveGeometryId id) => _curves[id];
+
+ public SurfaceGeometry GetSurface(SurfaceGeometryId id) => _surfaces[id];
+}
diff --git a/Aetheris.Kernel.Core/Geometry/CurveGeometry.cs b/Aetheris.Kernel.Core/Geometry/CurveGeometry.cs
new file mode 100644
index 00000000..febf7658
--- /dev/null
+++ b/Aetheris.Kernel.Core/Geometry/CurveGeometry.cs
@@ -0,0 +1,32 @@
+using Aetheris.Kernel.Core.Geometry.Curves;
+
+namespace Aetheris.Kernel.Core.Geometry;
+
+public enum CurveGeometryKind
+{
+ Line3,
+ Circle3,
+}
+
+/// <summary>
+/// Minimal discriminated wrapper for supported curve primitives.
+/// </summary>
+public sealed record CurveGeometry
+{
+ private CurveGeometry(CurveGeometryKind kind, Line3Curve? line3, Circle3Curve? circle3)
+ {
+ Kind = kind;
+ Line3 = line3;
+ Circle3 = circle3;
+ }
+
+ public CurveGeometryKind Kind { get; }
+
+ public Line3Curve? Line3 { get; }
+
+ public Circle3Curve? Circle3 { get; }
+
+ public static CurveGeometry FromLine(Line3Curve line) => new(CurveGeometryKind.Line3, line, null);
+
+ public static CurveGeometry FromCircle(Circle3Curve circle) => new(CurveGeometryKind.Circle3, null, circle);
+}
diff --git a/Aetheris.Kernel.Core/Geometry/GeometryIds.cs b/Aetheris.Kernel.Core/Geometry/GeometryIds.cs
new file mode 100644
index 00000000..aba573aa
--- /dev/null
+++ b/Aetheris.Kernel.Core/Geometry/GeometryIds.cs
@@ -0,0 +1,21 @@
+namespace Aetheris.Kernel.Core.Geometry;
+
+/// <summary>
+/// Stable in-memory geometry ID for a curve definition. The default value (0) is invalid.
+/// </summary>
+public readonly record struct CurveGeometryId(int Value)
+{
+ public static CurveGeometryId Invalid => default;
+
+ public bool IsValid => Value > 0;
+}
+
+/// <summary>
+/// Stable in-memory geometry ID for a surface definition. The default value (0) is invalid.
+/// </summary>
+public readonly record struct SurfaceGeometryId(int Value)
+{
+ public static SurfaceGeometryId Invalid => default;
+
+ public bool IsValid => Value > 0;
+}
diff --git a/Aetheris.Kernel.Core/Geometry/SurfaceGeometry.cs b/Aetheris.Kernel.Core/Geometry/SurfaceGeometry.cs
new file mode 100644
index 00000000..40c0d583
--- /dev/null
+++ b/Aetheris.Kernel.Core/Geometry/SurfaceGeometry.cs
@@ -0,0 +1,49 @@
+using Aetheris.Kernel.Core.Geometry.Surfaces;
+
+namespace Aetheris.Kernel.Core.Geometry;
+
+public enum SurfaceGeometryKind
+{
+ Plane,
+ Cylinder,
+ Cone,
+ Sphere,
+}
+
+/// <summary>
+/// Minimal discriminated wrapper for supported surface primitives.
+/// </summary>
+public sealed record SurfaceGeometry
+{
+ private SurfaceGeometry(
+ SurfaceGeometryKind kind,
+ PlaneSurface? plane,
+ CylinderSurface? cylinder,
+ ConeSurface? cone,
+ SphereSurface? sphere)
+ {
+ Kind = kind;
+ Plane = plane;
+ Cylinder = cylinder;
+ Cone = cone;
+ Sphere = sphere;
+ }
+
+ public SurfaceGeometryKind Kind { get; }
+
+ public PlaneSurface? Plane { get; }
+
+ public CylinderSurface? Cylinder { get; }
+
+ public ConeSurface? Cone { get; }
+
+ public SphereSurface? Sphere { get; }
+
+ public static SurfaceGeometry FromPlane(PlaneSurface plane) => new(SurfaceGeometryKind.Plane, plane, null, null, null);
+
+ public static SurfaceGeometry FromCylinder(CylinderSurface cylinder) => new(SurfaceGeometryKind.Cylinder, null, cylinder, null, null);
+
+ public static SurfaceGeometry FromCone(ConeSurface cone) => new(SurfaceGeometryKind.Cone, null, null, cone, null);
+
+ public static SurfaceGeometry FromSphere(SphereSurface sphere) => new(SurfaceGeometryKind.Sphere, null, null, null, sphere);
+}
diff --git a/docs/milestones.md b/docs/milestones.md
index ae419ad2..6b9bbbea 100644
--- a/docs/milestones.md
+++ b/docs/milestones.md
@@ -45,3 +45,12 @@
- [x] Add exact analytic surface primitives (`PlaneSurface`, `CylinderSurface`, `SphereSurface`, `ConeSurface`) with constructor validation and documented parameter conventions.
- [x] Add focused geometry unit tests that lock evaluation behavior/orientation conventions and invalid-construction guardrails.
- [x] Explicitly defer topology-geometry binding to M06.
+
+## M06 — Topology–Geometry Binding v1 (Minimal B-rep Body Definition)
+
+- [x] Add strongly typed geometry IDs and a lightweight geometry store for reusable curve/surface definitions.
+- [x] Add explicit topology-to-geometry bindings (`EdgeId -> CurveGeometryId`, `FaceId -> SurfaceGeometryId`) with optional edge parameter intervals.
+- [x] Add a minimal aggregate B-rep body model that combines topology, geometry, and bindings.
+- [x] Add binding validator v0 for topology + binding reference integrity (not advanced geometric/manifold correctness).
+- [x] Add focused tests, including manual construction and validation of a simple box-like B-rep fixture.
+- [x] Explicitly defer full geometric consistency checks, trim-loop/p-curve support, and modeling operations.