Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add M04 topology graph skeleton with validator and tests

Yuechen Lib8e51a7833a9
diff --git a/Aetheris.Kernel.Core.Tests/Topology/TopologyBuilderTests.cs b/Aetheris.Kernel.Core.Tests/Topology/TopologyBuilderTests.cs
new file mode 100644
index 00000000..f09021c3
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Topology/TopologyBuilderTests.cs
@@ -0,0 +1,99 @@
+using Aetheris.Kernel.Core.Topology;
+
+namespace Aetheris.Kernel.Core.Tests.Topology;
+
+public sealed class TopologyBuilderTests
+{
+ [Fact]
+ public void Builder_CanCreateMinimalValidSingleFaceGraph()
+ {
+ var builder = new TopologyBuilder();
+
+ var v1 = builder.AddVertex();
+ var v2 = builder.AddVertex();
+ var v3 = builder.AddVertex();
+
+ var e1 = builder.AddEdge(v1, v2);
+ var e2 = builder.AddEdge(v2, v3);
+ var e3 = builder.AddEdge(v3, v1);
+
+ var loopId = builder.AllocateLoopId();
+ var c1 = builder.AllocateCoedgeId();
+ var c2 = builder.AllocateCoedgeId();
+ var c3 = builder.AllocateCoedgeId();
+
+ builder.AddCoedge(new Coedge(c1, e1, loopId, c2, c3, false));
+ builder.AddCoedge(new Coedge(c2, e2, loopId, c3, c1, false));
+ builder.AddCoedge(new Coedge(c3, e3, loopId, c1, c2, false));
+
+ builder.AddLoop(new Loop(loopId, [c1, c2, c3]));
+
+ var faceId = builder.AddFace([loopId]);
+ var shellId = builder.AddShell([faceId]);
+ builder.AddBody([shellId]);
+
+ var validation = TopologyGraphValidator.Validate(builder.Model);
+
+ Assert.True(validation.IsSuccess);
+ }
+
+ [Fact]
+ public void Builder_CanCreateCubeLikeTopologySkeleton_ValidatorAccepts()
+ {
+ var builder = new TopologyBuilder();
+
+ var vertices = Enumerable.Range(0, 8).Select(_ => builder.AddVertex()).ToArray();
+
+ var edges = new Dictionary<string, EdgeId>
+ {
+ ["e0"] = builder.AddEdge(vertices[0], vertices[1]),
+ ["e1"] = builder.AddEdge(vertices[1], vertices[2]),
+ ["e2"] = builder.AddEdge(vertices[2], vertices[3]),
+ ["e3"] = builder.AddEdge(vertices[3], vertices[0]),
+ ["e4"] = builder.AddEdge(vertices[4], vertices[5]),
+ ["e5"] = builder.AddEdge(vertices[5], vertices[6]),
+ ["e6"] = builder.AddEdge(vertices[6], vertices[7]),
+ ["e7"] = builder.AddEdge(vertices[7], vertices[4]),
+ ["e8"] = builder.AddEdge(vertices[0], vertices[4]),
+ ["e9"] = builder.AddEdge(vertices[1], vertices[5]),
+ ["e10"] = builder.AddEdge(vertices[2], vertices[6]),
+ ["e11"] = builder.AddEdge(vertices[3], vertices[7]),
+ };
+
+ var faceLoopEdges = new[]
+ {
+ new[] { "e0", "e1", "e2", "e3" },
+ new[] { "e4", "e5", "e6", "e7" },
+ new[] { "e0", "e9", "e4", "e8" },
+ new[] { "e1", "e10", "e5", "e9" },
+ new[] { "e2", "e11", "e6", "e10" },
+ new[] { "e3", "e8", "e7", "e11" },
+ };
+
+ var faceIds = new List<FaceId>();
+
+ foreach (var edgeNames in faceLoopEdges)
+ {
+ var loopId = builder.AllocateLoopId();
+ var coedges = edgeNames.Select(_ => builder.AllocateCoedgeId()).ToArray();
+
+ for (var i = 0; i < coedges.Length; i++)
+ {
+ var next = coedges[(i + 1) % coedges.Length];
+ var prev = coedges[(i - 1 + coedges.Length) % coedges.Length];
+ var edgeId = edges[edgeNames[i]];
+ builder.AddCoedge(new Coedge(coedges[i], edgeId, loopId, next, prev, false));
+ }
+
+ builder.AddLoop(new Loop(loopId, coedges));
+ faceIds.Add(builder.AddFace([loopId]));
+ }
+
+ var shellId = builder.AddShell(faceIds);
+ builder.AddBody([shellId]);
+
+ var validation = TopologyGraphValidator.Validate(builder.Model);
+
+ Assert.True(validation.IsSuccess);
+ }
+}
diff --git a/Aetheris.Kernel.Core.Tests/Topology/TopologyGraphValidatorTests.cs b/Aetheris.Kernel.Core.Tests/Topology/TopologyGraphValidatorTests.cs
new file mode 100644
index 00000000..db31ae44
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Topology/TopologyGraphValidatorTests.cs
@@ -0,0 +1,90 @@
+using Aetheris.Kernel.Core.Diagnostics;
+using Aetheris.Kernel.Core.Topology;
+
+namespace Aetheris.Kernel.Core.Tests.Topology;
+
+public sealed class TopologyGraphValidatorTests
+{
+ [Fact]
+ public void Validator_FlagsDanglingFaceLoopReference()
+ {
+ var model = new TopologyModel();
+ model.AddFace(new Face(new FaceId(1), [new LoopId(100)]));
+
+ var result = TopologyGraphValidator.Validate(model);
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains(result.Diagnostics, d => d.Severity == KernelDiagnosticSeverity.Error && d.Message.Contains("Face 1 references missing child ID"));
+ }
+
+ [Fact]
+ public void Validator_FlagsDanglingCoedgeReferences()
+ {
+ var model = new TopologyModel();
+
+ model.AddLoop(new Loop(new LoopId(1), [new CoedgeId(1)]));
+ model.AddCoedge(new Coedge(new CoedgeId(1), new EdgeId(5), new LoopId(1), new CoedgeId(2), new CoedgeId(3), false));
+
+ var result = TopologyGraphValidator.Validate(model);
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains(result.Diagnostics, d => d.Message.Contains("references missing edge 5"));
+ Assert.Contains(result.Diagnostics, d => d.Message.Contains("references missing next coedge 2"));
+ Assert.Contains(result.Diagnostics, d => d.Message.Contains("references missing prev coedge 3"));
+ }
+
+ [Fact]
+ public void Validator_FlagsEdgeMissingVertexReferences()
+ {
+ var model = new TopologyModel();
+ model.AddEdge(new Edge(new EdgeId(1), new VertexId(10), new VertexId(11)));
+
+ var result = TopologyGraphValidator.Validate(model);
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains(result.Diagnostics, d => d.Message.Contains("missing start vertex 10"));
+ Assert.Contains(result.Diagnostics, d => d.Message.Contains("missing end vertex 11"));
+ }
+
+ [Fact]
+ public void Validator_FlagsLoopCoedgeMismatch()
+ {
+ var model = new TopologyModel();
+ model.AddVertex(new Vertex(new VertexId(1)));
+ model.AddVertex(new Vertex(new VertexId(2)));
+ model.AddEdge(new Edge(new EdgeId(1), new VertexId(1), new VertexId(2)));
+
+ model.AddLoop(new Loop(new LoopId(1), [new CoedgeId(1)]));
+ model.AddLoop(new Loop(new LoopId(2), [new CoedgeId(2)]));
+
+ model.AddCoedge(new Coedge(new CoedgeId(1), new EdgeId(1), new LoopId(2), new CoedgeId(2), new CoedgeId(2), false));
+ model.AddCoedge(new Coedge(new CoedgeId(2), new EdgeId(1), new LoopId(2), new CoedgeId(2), new CoedgeId(2), false));
+
+ var result = TopologyGraphValidator.Validate(model);
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains(result.Diagnostics, d => d.Message.Contains("belongs to loop 2, but is listed on loop 1"));
+ }
+
+ [Fact]
+ public void Validator_ReturnsSuccessForValidGraph()
+ {
+ var builder = new TopologyBuilder();
+ var v1 = builder.AddVertex();
+ var v2 = builder.AddVertex();
+ var edgeId = builder.AddEdge(v1, v2);
+ var loopId = builder.AllocateLoopId();
+
+ var c1 = builder.AllocateCoedgeId();
+ builder.AddCoedge(new Coedge(c1, edgeId, loopId, c1, c1, false));
+ builder.AddLoop(new Loop(loopId, [c1]));
+
+ var faceId = builder.AddFace([loopId]);
+ var shellId = builder.AddShell([faceId]);
+ builder.AddBody([shellId]);
+
+ var result = TopologyGraphValidator.Validate(builder.Model);
+
+ Assert.True(result.IsSuccess);
+ }
+}
diff --git a/Aetheris.Kernel.Core.Tests/Topology/TopologyIdsAndModelTests.cs b/Aetheris.Kernel.Core.Tests/Topology/TopologyIdsAndModelTests.cs
new file mode 100644
index 00000000..9c486852
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Topology/TopologyIdsAndModelTests.cs
@@ -0,0 +1,43 @@
+using Aetheris.Kernel.Core.Topology;
+
+namespace Aetheris.Kernel.Core.Tests.Topology;
+
+public sealed class TopologyIdsAndModelTests
+{
+ [Fact]
+ public void TypedIds_CompareAndHashByValue()
+ {
+ var idA = new VertexId(7);
+ var idB = new VertexId(7);
+ var idC = new VertexId(8);
+
+ Assert.Equal(idA, idB);
+ Assert.Equal(idA.GetHashCode(), idB.GetHashCode());
+ Assert.NotEqual(idA, idC);
+ Assert.False(VertexId.Invalid.IsValid);
+ }
+
+ [Fact]
+ public void TopologyModel_CanStoreAndRetrieveById()
+ {
+ var model = new TopologyModel();
+ var vertex = new Vertex(new VertexId(1));
+
+ model.AddVertex(vertex);
+
+ Assert.True(model.TryGetVertex(vertex.Id, out var found));
+ Assert.Equal(vertex, found);
+ Assert.Equal(vertex, model.GetVertex(vertex.Id));
+ }
+
+ [Fact]
+ public void TopologyModel_MissingTryGetReturnsFalse_AndGetThrows()
+ {
+ var model = new TopologyModel();
+ var missingId = new EdgeId(99);
+
+ Assert.False(model.TryGetEdge(missingId, out var edge));
+ Assert.Null(edge);
+ Assert.Throws<KeyNotFoundException>(() => model.GetEdge(missingId));
+ }
+}
diff --git a/Aetheris.Kernel.Core/Topology/TopologyBuilder.cs b/Aetheris.Kernel.Core/Topology/TopologyBuilder.cs
new file mode 100644
index 00000000..346e0dec
--- /dev/null
+++ b/Aetheris.Kernel.Core/Topology/TopologyBuilder.cs
@@ -0,0 +1,74 @@
+namespace Aetheris.Kernel.Core.Topology;
+
+/// <summary>
+/// Minimal helper for constructing topology graphs in tests and simple setup code.
+/// </summary>
+public sealed class TopologyBuilder
+{
+ private int _nextVertexId = 1;
+ private int _nextEdgeId = 1;
+ private int _nextCoedgeId = 1;
+ private int _nextLoopId = 1;
+ private int _nextFaceId = 1;
+ private int _nextShellId = 1;
+ private int _nextBodyId = 1;
+
+ public TopologyModel Model { get; } = new();
+
+ public VertexId AddVertex()
+ {
+ var id = new VertexId(_nextVertexId++);
+ Model.AddVertex(new Vertex(id));
+ return id;
+ }
+
+ public EdgeId AddEdge(VertexId startVertexId, VertexId endVertexId)
+ {
+ var id = new EdgeId(_nextEdgeId++);
+ Model.AddEdge(new Edge(id, startVertexId, endVertexId));
+ return id;
+ }
+
+ public CoedgeId AddCoedge(EdgeId edgeId, LoopId loopId, CoedgeId nextCoedgeId, CoedgeId prevCoedgeId, bool isReversed)
+ {
+ var id = new CoedgeId(_nextCoedgeId++);
+ Model.AddCoedge(new Coedge(id, edgeId, loopId, nextCoedgeId, prevCoedgeId, isReversed));
+ return id;
+ }
+
+ public LoopId AddLoop(IReadOnlyList<CoedgeId> coedgeIds)
+ {
+ var id = new LoopId(_nextLoopId++);
+ Model.AddLoop(new Loop(id, coedgeIds));
+ return id;
+ }
+
+ public LoopId AllocateLoopId() => new(_nextLoopId++);
+
+ public void AddLoop(Loop loop) => Model.AddLoop(loop);
+
+ public FaceId AddFace(IReadOnlyList<LoopId> loopIds)
+ {
+ var id = new FaceId(_nextFaceId++);
+ Model.AddFace(new Face(id, loopIds));
+ return id;
+ }
+
+ public ShellId AddShell(IReadOnlyList<FaceId> faceIds)
+ {
+ var id = new ShellId(_nextShellId++);
+ Model.AddShell(new Shell(id, faceIds));
+ return id;
+ }
+
+ public BodyId AddBody(IReadOnlyList<ShellId> shellIds)
+ {
+ var id = new BodyId(_nextBodyId++);
+ Model.AddBody(new Body(id, shellIds));
+ return id;
+ }
+
+ public CoedgeId AllocateCoedgeId() => new(_nextCoedgeId++);
+
+ public void AddCoedge(Coedge coedge) => Model.AddCoedge(coedge);
+}
diff --git a/Aetheris.Kernel.Core/Topology/TopologyEntities.cs b/Aetheris.Kernel.Core/Topology/TopologyEntities.cs
new file mode 100644
index 00000000..8b802228
--- /dev/null
+++ b/Aetheris.Kernel.Core/Topology/TopologyEntities.cs
@@ -0,0 +1,45 @@
+namespace Aetheris.Kernel.Core.Topology;
+
+/// <summary>
+/// Topology-only vertex node. Geometry binding is intentionally deferred in M04.
+/// </summary>
+public sealed record Vertex(VertexId Id);
+
+/// <summary>
+/// Topology-only edge that references its endpoint vertices.
+/// </summary>
+public sealed record Edge(EdgeId Id, VertexId StartVertexId, VertexId EndVertexId);
+
+/// <summary>
+/// Topology-only directed edge use inside a loop.
+/// </summary>
+/// <remarks>
+/// M04 keeps coedge structure minimal: edge use, owning loop, and local loop links.
+/// </remarks>
+public sealed record Coedge(
+ CoedgeId Id,
+ EdgeId EdgeId,
+ LoopId LoopId,
+ CoedgeId NextCoedgeId,
+ CoedgeId PrevCoedgeId,
+ bool IsReversed);
+
+/// <summary>
+/// Topology-only loop that owns ordered coedges.
+/// </summary>
+public sealed record Loop(LoopId Id, IReadOnlyList<CoedgeId> CoedgeIds);
+
+/// <summary>
+/// Topology-only face that owns loops.
+/// </summary>
+public sealed record Face(FaceId Id, IReadOnlyList<LoopId> LoopIds);
+
+/// <summary>
+/// Topology-only shell that owns faces.
+/// </summary>
+public sealed record Shell(ShellId Id, IReadOnlyList<FaceId> FaceIds);
+
+/// <summary>
+/// Topology-only body that owns shells.
+/// </summary>
+public sealed record Body(BodyId Id, IReadOnlyList<ShellId> ShellIds);
diff --git a/Aetheris.Kernel.Core/Topology/TopologyGraphValidator.cs b/Aetheris.Kernel.Core/Topology/TopologyGraphValidator.cs
new file mode 100644
index 00000000..ada86a61
--- /dev/null
+++ b/Aetheris.Kernel.Core/Topology/TopologyGraphValidator.cs
@@ -0,0 +1,136 @@
+using Aetheris.Kernel.Core.Diagnostics;
+using Aetheris.Kernel.Core.Results;
+
+namespace Aetheris.Kernel.Core.Topology;
+
+/// <summary>
+/// M04 validator scope: reference integrity only (dangling IDs and local loop link consistency).
+/// </summary>
+public static class TopologyGraphValidator
+{
+ public static KernelResult<bool> Validate(TopologyModel model)
+ {
+ var diagnostics = new List<KernelDiagnostic>();
+
+ foreach (var body in model.Bodies)
+ {
+ ValidateChildren(model, body.ShellIds, model.TryGetShell, $"Body {body.Id.Value}", diagnostics);
+ }
+
+ foreach (var shell in model.Shells)
+ {
+ ValidateChildren(model, shell.FaceIds, model.TryGetFace, $"Shell {shell.Id.Value}", diagnostics);
+ }
+
+ foreach (var face in model.Faces)
+ {
+ ValidateChildren(model, face.LoopIds, model.TryGetLoop, $"Face {face.Id.Value}", diagnostics);
+ }
+
+ foreach (var loop in model.Loops)
+ {
+ if (loop.CoedgeIds.Count == 0)
+ {
+ diagnostics.Add(Error($"Loop {loop.Id.Value} does not reference any coedges."));
+ }
+
+ ValidateChildren(model, loop.CoedgeIds, model.TryGetCoedge, $"Loop {loop.Id.Value}", diagnostics);
+
+ foreach (var coedgeId in loop.CoedgeIds)
+ {
+ if (!model.TryGetCoedge(coedgeId, out var coedge) || coedge is null)
+ {
+ continue;
+ }
+
+ if (coedge.LoopId != loop.Id)
+ {
+ diagnostics.Add(Error($"Coedge {coedge.Id.Value} belongs to loop {coedge.LoopId.Value}, but is listed on loop {loop.Id.Value}."));
+ }
+ }
+ }
+
+ foreach (var edge in model.Edges)
+ {
+ if (!model.TryGetVertex(edge.StartVertexId, out _))
+ {
+ diagnostics.Add(Error($"Edge {edge.Id.Value} has missing start vertex {edge.StartVertexId.Value}."));
+ }
+
+ if (!model.TryGetVertex(edge.EndVertexId, out _))
+ {
+ diagnostics.Add(Error($"Edge {edge.Id.Value} has missing end vertex {edge.EndVertexId.Value}."));
+ }
+ }
+
+ foreach (var coedge in model.Coedges)
+ {
+ if (!model.TryGetEdge(coedge.EdgeId, out _))
+ {
+ diagnostics.Add(Error($"Coedge {coedge.Id.Value} references missing edge {coedge.EdgeId.Value}."));
+ }
+
+ if (!model.TryGetLoop(coedge.LoopId, out _))
+ {
+ diagnostics.Add(Error($"Coedge {coedge.Id.Value} references missing loop {coedge.LoopId.Value}."));
+ }
+
+ if (!model.TryGetCoedge(coedge.NextCoedgeId, out var next) || next is null)
+ {
+ diagnostics.Add(Error($"Coedge {coedge.Id.Value} references missing next coedge {coedge.NextCoedgeId.Value}."));
+ }
+ else if (next.LoopId != coedge.LoopId)
+ {
+ diagnostics.Add(Error($"Coedge {coedge.Id.Value} next coedge {next.Id.Value} belongs to loop {next.LoopId.Value}, expected {coedge.LoopId.Value}."));
+ }
+
+ if (!model.TryGetCoedge(coedge.PrevCoedgeId, out var prev) || prev is null)
+ {
+ diagnostics.Add(Error($"Coedge {coedge.Id.Value} references missing prev coedge {coedge.PrevCoedgeId.Value}."));
+ }
+ else if (prev.LoopId != coedge.LoopId)
+ {
+ diagnostics.Add(Error($"Coedge {coedge.Id.Value} prev coedge {prev.Id.Value} belongs to loop {prev.LoopId.Value}, expected {coedge.LoopId.Value}."));
+ }
+ }
+
+ return diagnostics.Any(d => d.Severity == KernelDiagnosticSeverity.Error)
+ ? KernelResult<bool>.Failure(diagnostics)
+ : KernelResult<bool>.Success(true, diagnostics);
+ }
+
+ private static void ValidateChildren<TId, TEntity>(
+ TopologyModel model,
+ IReadOnlyList<TId> childIds,
+ TryGet<TId, TEntity> tryGet,
+ string parent,
+ ICollection<KernelDiagnostic> diagnostics)
+ where TId : struct
+ where TEntity : class
+ {
+ var seen = new HashSet<TId>();
+
+ foreach (var childId in childIds)
+ {
+ if (!seen.Add(childId))
+ {
+ diagnostics.Add(Warning($"{parent} contains duplicate child reference {childId}."));
+ }
+
+ if (!tryGet(model, childId, out _))
+ {
+ diagnostics.Add(Error($"{parent} references missing child ID {childId}."));
+ }
+ }
+ }
+
+ private static KernelDiagnostic Error(string message) =>
+ new(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, message);
+
+ private static KernelDiagnostic Warning(string message) =>
+ new(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Warning, message);
+
+ private delegate bool TryGet<TId, TEntity>(TopologyModel model, TId id, out TEntity? entity)
+ where TId : struct
+ where TEntity : class;
+}
diff --git a/Aetheris.Kernel.Core/Topology/TopologyIds.cs b/Aetheris.Kernel.Core/Topology/TopologyIds.cs
new file mode 100644
index 00000000..920175c5
--- /dev/null
+++ b/Aetheris.Kernel.Core/Topology/TopologyIds.cs
@@ -0,0 +1,71 @@
+namespace Aetheris.Kernel.Core.Topology;
+
+/// <summary>
+/// Stable in-memory topology ID for a vertex. The default value (0) is invalid.
+/// </summary>
+public readonly record struct VertexId(int Value)
+{
+ public static VertexId Invalid => default;
+
+ public bool IsValid => Value > 0;
+}
+
+/// <summary>
+/// Stable in-memory topology ID for an edge. The default value (0) is invalid.
+/// </summary>
+public readonly record struct EdgeId(int Value)
+{
+ public static EdgeId Invalid => default;
+
+ public bool IsValid => Value > 0;
+}
+
+/// <summary>
+/// Stable in-memory topology ID for a coedge. The default value (0) is invalid.
+/// </summary>
+public readonly record struct CoedgeId(int Value)
+{
+ public static CoedgeId Invalid => default;
+
+ public bool IsValid => Value > 0;
+}
+
+/// <summary>
+/// Stable in-memory topology ID for a loop. The default value (0) is invalid.
+/// </summary>
+public readonly record struct LoopId(int Value)
+{
+ public static LoopId Invalid => default;
+
+ public bool IsValid => Value > 0;
+}
+
+/// <summary>
+/// Stable in-memory topology ID for a face. The default value (0) is invalid.
+/// </summary>
+public readonly record struct FaceId(int Value)
+{
+ public static FaceId Invalid => default;
+
+ public bool IsValid => Value > 0;
+}
+
+/// <summary>
+/// Stable in-memory topology ID for a shell. The default value (0) is invalid.
+/// </summary>
+public readonly record struct ShellId(int Value)
+{
+ public static ShellId Invalid => default;
+
+ public bool IsValid => Value > 0;
+}
+
+/// <summary>
+/// Stable in-memory topology ID for a body. The default value (0) is invalid.
+/// </summary>
+public readonly record struct BodyId(int Value)
+{
+ public static BodyId Invalid => default;
+
+ public bool IsValid => Value > 0;
+}
diff --git a/Aetheris.Kernel.Core/Topology/TopologyModel.cs b/Aetheris.Kernel.Core/Topology/TopologyModel.cs
new file mode 100644
index 00000000..2e10b337
--- /dev/null
+++ b/Aetheris.Kernel.Core/Topology/TopologyModel.cs
@@ -0,0 +1,62 @@
+namespace Aetheris.Kernel.Core.Topology;
+
+public sealed class TopologyModel
+{
+ private readonly Dictionary<VertexId, Vertex> _vertices = [];
+ private readonly Dictionary<EdgeId, Edge> _edges = [];
+ private readonly Dictionary<CoedgeId, Coedge> _coedges = [];
+ private readonly Dictionary<LoopId, Loop> _loops = [];
+ private readonly Dictionary<FaceId, Face> _faces = [];
+ private readonly Dictionary<ShellId, Shell> _shells = [];
+ private readonly Dictionary<BodyId, Body> _bodies = [];
+
+ public IEnumerable<Vertex> Vertices => _vertices.Values;
+ public IEnumerable<Edge> Edges => _edges.Values;
+ public IEnumerable<Coedge> Coedges => _coedges.Values;
+ public IEnumerable<Loop> Loops => _loops.Values;
+ public IEnumerable<Face> Faces => _faces.Values;
+ public IEnumerable<Shell> Shells => _shells.Values;
+ public IEnumerable<Body> Bodies => _bodies.Values;
+
+ public void AddVertex(Vertex vertex) => _vertices.Add(vertex.Id, vertex);
+
+ public void AddEdge(Edge edge) => _edges.Add(edge.Id, edge);
+
+ public void AddCoedge(Coedge coedge) => _coedges.Add(coedge.Id, coedge);
+
+ public void AddLoop(Loop loop) => _loops.Add(loop.Id, loop);
+
+ public void AddFace(Face face) => _faces.Add(face.Id, face);
+
+ public void AddShell(Shell shell) => _shells.Add(shell.Id, shell);
+
+ public void AddBody(Body body) => _bodies.Add(body.Id, body);
+
+ public bool TryGetVertex(VertexId id, out Vertex? vertex) => _vertices.TryGetValue(id, out vertex);
+
+ public bool TryGetEdge(EdgeId id, out Edge? edge) => _edges.TryGetValue(id, out edge);
+
+ public bool TryGetCoedge(CoedgeId id, out Coedge? coedge) => _coedges.TryGetValue(id, out coedge);
+
+ public bool TryGetLoop(LoopId id, out Loop? loop) => _loops.TryGetValue(id, out loop);
+
+ public bool TryGetFace(FaceId id, out Face? face) => _faces.TryGetValue(id, out face);
+
+ public bool TryGetShell(ShellId id, out Shell? shell) => _shells.TryGetValue(id, out shell);
+
+ public bool TryGetBody(BodyId id, out Body? body) => _bodies.TryGetValue(id, out body);
+
+ public Vertex GetVertex(VertexId id) => _vertices[id];
+
+ public Edge GetEdge(EdgeId id) => _edges[id];
+
+ public Coedge GetCoedge(CoedgeId id) => _coedges[id];
+
+ public Loop GetLoop(LoopId id) => _loops[id];
+
+ public Face GetFace(FaceId id) => _faces[id];
+
+ public Shell GetShell(ShellId id) => _shells[id];
+
+ public Body GetBody(BodyId id) => _bodies[id];
+}
diff --git a/docs/milestones.md b/docs/milestones.md
index e56aaaa3..ce234fd0 100644
--- a/docs/milestones.md
+++ b/docs/milestones.md
@@ -27,3 +27,12 @@
- [x] Add minimal affine `Transform3D` wrapper with point/vector/direction application, composition, and inverse behavior.
- [x] Add minimal spatial substrate (`BoundingBox3D`, `Ray3D`) for later query/intersection work.
- [x] Add focused unit tests for primitive math invariants and transform behavior.
+
+## M04 — Topology Entity IDs + Minimal B-rep Topology Graph Skeleton
+
+- [x] Add strongly typed topology IDs (`BodyId`, `ShellId`, `FaceId`, `LoopId`, `CoedgeId`, `EdgeId`, `VertexId`) for stable in-memory references.
+- [x] Add topology-only entity graph primitives (body/shell/face/loop/coedge/edge/vertex) with ID-based references and no geometry binding.
+- [x] Add a minimal topology model container and a small builder helper for readable test graph assembly.
+- [x] Add reference-integrity validator v0 (dangling references and local loop/coedge consistency only).
+- [x] Add unit tests, including a cube-like topology graph skeleton validation test.
+- [x] Explicitly defer geometry binding and manifold-level correctness checks to future milestones.