Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Step242;
using Aetheris.Kernel.Firmament.Assembly;
using Aetheris.Kernel.Firmament.FirmamentV2.Syntax;
using Aetheris.Kernel.Firmament.Modules;
using System.Security.Cryptography;
using System.Text;
namespace Aetheris.Kernel.Firmament.Tests;
public sealed class FirmamentImportedResourceTests
{
static readonly string Part = Step242Exporter.ExportBody(BrepPrimitives.CreateBox(4, 6, 8).Value).Value;
const string Tree = "Assembly Machine { <Assembly Machine><Part A = bearing>Placement { from: Origin; to: World; }</Part><Part B = bearing>Placement { from: Origin; to: World; translateLocal: [50mm,0mm,0mm]; }</Part></Assembly> Anchor: Machine; }";
static void Accepted(AssemblyM1CompilationResult result) => Assert.True(result.IsSuccess, string.Join(" | ", result.Diagnostics.Select(d => d.Code + ": " + d.Message)));
static string Hash(string value) => Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(value))).ToLowerInvariant();
static string Lock(string root = "main.firmasm", string? part = null) => new FirmamentDependencyLock(root,
[new("vendor/bearing.step", "step", "sha256-bytes", Hash(part ?? Part))]).ToToml();
[Fact]
public void TypedIncludeAndInventoryUseTheSameSnapshotGeometryAndIdentity()
{
const string include = "include bearing: Part = Step(\"vendor/bearing\"); ";
var parsed = FirmamentSyntaxParser.Parse(include + Tree);
Assert.True(parsed.IsSuccess);
Assert.True(FirmamentSyntaxParser.Parse(FirmamentSyntaxWriter.Statements(parsed.Document.Statements)).IsSuccess);
var shortForm = new AssemblyM1Pipeline().CompileProject(new("main.firmasm", [new("main.firmasm", include + Tree), new("vendor/bearing.step", Part)]));
Accepted(shortForm);
var catalog = new AssemblyM1Pipeline().CompileProject(new("main.firmasm", [
new("main.firmasm", "Inventory Record Components { bearing: Part = Step(\"vendor/bearing\") } " + Tree.Replace("= bearing", "= Components.bearing")), new("vendor/bearing.step", Part)]));
Accepted(catalog);
Assert.Single(shortForm.Geometry!.DefinitionBodies);
Assert.Equal(2, shortForm.Geometry.InstanceBodies.Count);
Assert.Equal(catalog.Geometry!.DefinitionBodies.Keys, shortForm.Geometry.DefinitionBodies.Keys);
Assert.Equal(new[] { -2d, -3, -4 }, Assert.Single(shortForm.Geometry.Artifact.Definitions).Metrics.Minimum);
Assert.Contains(shortForm.Ir!.SourceDependencies!, d => d.Path == "vendor/bearing.step");
}
[Fact]
public void StepAssemblyRetainsHierarchyTransformsAndSharedLeafGeometry()
{
var identity = new double[] { 1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1 };
var translated = (double[])identity.Clone(); translated[12] = 25;
var asset = Step242AssemblyExporter.Export(new("Imported", "root", [new("bolt", "Bolt", BrepPrimitives.CreateBox(4,6,8).Value)], [
new("root", "Root", null, null, identity), new("first", "First", "root", "bolt", identity), new("second", "Second", "root", "bolt", translated)]));
Assert.True(asset.IsSuccess);
var source = "include drive: Assembly = Step(\"vendor/drive\"); Assembly Machine { <Assembly Machine><Assembly Unit = drive>Placement { from: Origin; to: World; }</Assembly></Assembly> Anchor: Machine; }";
var result = new AssemblyM1Pipeline().CompileProject(new("main.firmasm", [new("main.firmasm", source), new("vendor/drive.step", asset.Value)]));
Accepted(result);
Assert.Single(result.Geometry!.DefinitionBodies);
Assert.Equal(2, result.Geometry.InstanceBodies.Count);
Assert.Contains(result.Ir!.Instances, i => i.Path.ToString() == "Machine.Unit.second" && i.ResolvedTransform!.Matrix[12] == 25);
Assert.True(AssemblyIrAp242Exporter.Export(result).IsSuccess);
}
[Fact]
public void NestedStepAssemblyPreservesLocalTransformsAndRepeatedGeometry()
{
double[] Matrix(double x) => [1,0,0,0,0,1,0,0,0,0,1,0,x,0,0,1];
var asset = Step242AssemblyExporter.Export(new("Imported", "root", [new("bolt","Bolt",BrepPrimitives.CreateBox(4,6,8).Value)], [
new("root","Root",null,null,Matrix(0)),new("unitA","Unit","root",null,Matrix(20)), new("unitB","Unit","root",null,Matrix(60)),
new("boltA","Bolt","unitA","bolt",Matrix(5)),new("boltB","Bolt","unitB","bolt",Matrix(5))]));
Assert.True(asset.IsSuccess);
var source = "include drive: Assembly = Step(\"drive\"); Assembly Machine { <Assembly Machine><Assembly Drive = drive>Placement { from: Origin; to: World; }</Assembly></Assembly> Anchor: Machine; }";
var result = new AssemblyM1Pipeline().CompileProject(new("main.firmasm",[new("main.firmasm",source),new("drive.step",asset.Value)]));
Accepted(result);
Assert.Single(result.Geometry!.DefinitionBodies);
Assert.Equal(2,result.Geometry.InstanceBodies.Count);
Assert.Contains(result.Ir!.Instances,i => i.Path.ToString().EndsWith("unitA.boltA",StringComparison.Ordinal) && i.ResolvedTransform!.Matrix[12] == 25);
Assert.Contains(result.Ir.Instances,i => i.Path.ToString().EndsWith("unitB.boltB",StringComparison.Ordinal) && i.ResolvedTransform!.Matrix[12] == 65);
Assert.True(Step242AssemblyImporter.Import(AssemblyIrAp242Exporter.Export(result).Value).IsSuccess);
}
[Fact]
public void AnnotatedStepRequiresExplicitGeometryOnlyAdmission()
{
var annotated = Step242Exporter.ExportBody(BrepPrimitives.CreateBox(4,6,8).Value,
[new Step242SemanticPmiDatum("Body","plane","A","+Z")]).Value;
var source = "include bearing: Part = Step(\"vendor/bearing\"); " + Tree;
AssemblyM1CompilationResult Build(string text) => new AssemblyM1Pipeline().CompileProject(new("main.firmasm",[new("main.firmasm",text),new("vendor/bearing.step",annotated)]));
var refused = Build(source); Assert.False(refused.IsSuccess);
Assert.Contains(refused.Diagnostics,d => d.Code == "firmament-step-source-pmi-unsupported");
var admitted = Build(source.Replace("Step(\"vendor/bearing\")","Step(\"vendor/bearing\", geometryOnly: true)")); Accepted(admitted);
Assert.True(Assert.Single(admitted.Ir!.InventoryBindings).GeometryOnly);
Assert.Empty(Step242SemanticPmiInspector.Inspect(AssemblyIrAp242Exporter.Export(admitted).Value).Items);
}
[Fact]
public void SnapshotLockIsOptionalButAnExistingReceiptCannotBeBypassed()
{
var source = "include bearing: Part = Step(\"vendor/bearing\"); " + Tree;
var documents = new Dictionary<string,string> { ["main.firmasm"] = source, ["vendor/bearing.step"] = Part, [FirmamentDependencyLock.FileName] = Lock() };
Accepted(new AssemblyM1Pipeline().CompileProject(new("main.firmasm", documents)));
documents["vendor/bearing.step"] = Step242Exporter.ExportBody(BrepPrimitives.CreateBox(5,6,8).Value).Value;
var changed = new AssemblyM1Pipeline().CompileProject(new("main.firmasm", documents));
Assert.False(changed.IsSuccess);
Assert.Contains(changed.Diagnostics, d => d.Code == "firmament-lock-dependency-mismatch");
documents["vendor/bearing.step"] = Part;
documents[FirmamentDependencyLock.FileName] = Lock("another.firmasm");
var wrongRoot = new AssemblyM1Pipeline().CompileProject(new("main.firmasm", documents));
Assert.False(wrongRoot.IsSuccess);
Assert.Contains(wrongRoot.Diagnostics, d => d.Code == "firmament-lock-root-mismatch");
// A real file with the source-only adapter's conventional name is still
// a real root; special filenames cannot bypass root identity checking.
var specialName = new AssemblyM1Pipeline().CompileProject(new("__provided_source.firmament",[
new("__provided_source.firmament",source), new("vendor/bearing.step",Part), new(FirmamentDependencyLock.FileName,Lock("another.firmasm"))]));
Assert.False(specialName.IsSuccess);
Assert.Contains(specialName.Diagnostics,d => d.Code == "firmament-lock-root-mismatch");
documents[FirmamentDependencyLock.FileName] = Lock() + "unexpected = true\n";
Assert.False(new AssemblyM1Pipeline().CompileProject(new("main.firmasm", documents)).IsSuccess);
}
[Fact]
public void StandaloneRootCanLockAnEmptyDependencySet()
{
var empty = new FirmamentDependencyLock("standalone.firmament", []);
var parsed = FirmamentDependencyLock.Parse(empty.ToToml());
Assert.Equal(empty.Root,parsed.Root);
Assert.Empty(parsed.Dependencies);
var invalid = Lock().Replace("vendor/bearing.step","../outside.step",StringComparison.Ordinal);
Assert.Throws<ArgumentException>(() => FirmamentDependencyLock.Parse(invalid));
}
[Theory]
[InlineData("from: bearing")]
[InlineData("from: Components.bearing")]
[InlineData("path: \"vendor/bearing.step\"")]
public void InlineStepUsesLockedResourcesWithoutAuthoredHashes(string binding)
{
var prefix = binding.Contains("Components") ? "Inventory Record Components { bearing: Part = Step(\"vendor/bearing\") } "
: binding.StartsWith("from:") ? "include bearing: Part = Step(\"vendor/bearing\"); " : "";
var source = prefix + "Model Surgery { units: mm InlineStep Source { " + binding + "; geometryOnly: true } }";
var resources = new Dictionary<string,string> { ["vendor/bearing.step"] = Part, [FirmamentDependencyLock.FileName] = Lock("surgery.firmament") };
var result = FirmamentBuildAndExport.CompileSource(source, "", resources);
Assert.True(result.IsSuccess, string.Join(" | ", result.Diagnostics.Select(d => d.Message)));
Assert.Null(result.Value.ImportedHoleRevision);
var imported = Step242Importer.ImportBody(result.Value.StepText);
Assert.True(imported.IsSuccess);
Assert.Equal(6, imported.Value.Topology.Faces.Count());
Assert.Equal(12, imported.Value.Topology.Edges.Count());
var vertices = imported.Value.Topology.Vertices.Select(v =>
{ Assert.True(imported.Value.TryGetVertexPoint(v.Id,out var point)); return point; }).ToArray();
Assert.Equal(new[]{-2d,-3,-4},new[]{vertices.Min(p=>p.X),vertices.Min(p=>p.Y),vertices.Min(p=>p.Z)});
Assert.Equal(new[]{2d,3,4},new[]{vertices.Max(p=>p.X),vertices.Max(p=>p.Y),vertices.Max(p=>p.Z)});
resources["vendor/bearing.step"] = Part + "\n";
Assert.False(FirmamentBuildAndExport.CompileSource(source, "", resources).IsSuccess);
}
[Fact]
public void ImportMetadataBindsOrdinaryRecordsAndDoesNotAlterGeometry()
{
const string data = "Record VendorInfo { manufacturer: String revision: String } Static Receipt: VendorInfo { manufacturer: \"Acme\" revision: \"A\" } ";
var source = data + "Inventory Record Components { bearing: Part = Step(\"vendor/bearing\", metadata: Receipt) } " + Tree.Replace("= bearing", "= Components.bearing");
AssemblyM1CompilationResult Build(string text) => new AssemblyM1Pipeline().CompileProject(new("main.firmasm", [new("main.firmasm", text), new("vendor/bearing.step", Part)]));
var before = Build(source); Accepted(before);
var after = Build(source.Replace("revision: \"A\"", "revision: \"B\"")); Accepted(after);
var receipt = Assert.Single(before.Ir!.InventoryBindings);
Assert.Equal("VendorInfo", receipt.MetadataType);
Assert.Equal("Acme", receipt.Metadata["manufacturer"]);
Assert.Equal("B", Assert.Single(after.Ir!.InventoryBindings).Metadata["revision"]);
Assert.Equal(before.Geometry!.Artifact.DeterministicSha256, after.Geometry!.Artifact.DeterministicSha256);
Assert.False(Build(source.Replace("metadata: Receipt", "metadata: Missing")).IsSuccess);
}
[Fact]
public void NestedReleaseRecordsUseTheOrdinaryTypedBinder()
{
var source = "Record Person { name: String role: String } Record ReleaseInfo { author: Person date: Date version: Version description: String } "
+ "Static Designer: Person { name: \"Engineer\" role: \"Designer\" } Static Release: ReleaseInfo { author: Designer date: 2026-10-21 version: 1.0.0 description: \"Review witness\" } "
+ "include bearing: Part = Step(\"vendor/bearing\"); " + Tree.Replace("Assembly Machine {", "Assembly Machine { provenance: Release;");
var result = new AssemblyM1Pipeline().CompileProject(new("main.firmasm", [new("main.firmasm",source), new("vendor/bearing.step",Part)]));
Accepted(result);
Assert.Equal("Engineer", result.Ir!.Annotations!.Release!.Fields["Author"]);
Assert.Equal("Designer", result.Ir.Annotations.Release.Fields["author.role"]);
var exported = AssemblyIrAp242Exporter.Export(result);
Assert.True(exported.IsSuccess);
Assert.Contains("('Engineer')", exported.Value);
}
}