Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Verify Firmament V2 source composition STEP fixtures
Yuechen Li9aa3bf9274cd
diff --git a/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.cs b/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.csindex 9a7d6155..7f102f90 100644--- a/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.cs+++ b/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.cs@@ -244,7 +244,7 @@ public sealed class FirmamentFixtureCorpusTestspublic void FirmamentV2RecordDerivation_MetadataRecognized(){var fixtures = DiscoverV2Fixtures().Where(p => p.Contains("/RecordDerivation/", StringComparison.Ordinal)).ToArray();- Assert.Equal(8, fixtures.Length);+ Assert.Equal(10, fixtures.Length);foreach (var path in fixtures){var fixture = LoadMetadata(path);diff --git a/Aetheris.CLI.Tests/FirmamentV2SourceCompositionStepPipelineTests.cs b/Aetheris.CLI.Tests/FirmamentV2SourceCompositionStepPipelineTests.csnew file mode 100644index 00000000..9f995b0f--- /dev/null+++ b/Aetheris.CLI.Tests/FirmamentV2SourceCompositionStepPipelineTests.cs@@ -0,0 +1,113 @@+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 FirmamentV2SourceCompositionStepPipelineTests+{+ public static TheoryData<string, string, double> DerivationCases => new()+ {+ { "RecordDerivation/valid/derivation-v2-with-size-override-step-verified.valid.firmfixture", "derivation-v2-with-size-override-step-verified", 12d * 8d * 6d },+ { "RecordDerivation/valid/derivation-v2-with-chained-twice-step-verified.valid.firmfixture", "derivation-v2-with-chained-twice-step-verified", 12d * 8d * 7d }+ };++ [Theory]+ [MemberData(nameof(DerivationCases))]+ public void STEP_V2_X3_derivation_fixtures_build_emit_reimport_and_match_box_evidence(string fixtureRelativePath, string fixtureId, double expectedVolume)+ {+ var fixturePath = Fixture(fixtureRelativePath);+ var stepPath = TempStep(fixtureId);++ var (stepText, fixtureText) = BuildAndReadStep(fixturePath, stepPath, fixtureId);+ AssertStageHonesty(fixtureText, "derivation");++ Assert.True(CountStepEntities(stepText, "ADVANCED_FACE") > 0, fixtureId + " emits real STEP advanced faces");+ Assert.True(CountStepEntities(stepText, "VERTEX_POINT") > 0, fixtureId + " emits STEP vertex topology marker");+ AssertNoTraceOnlyStep(stepText);++ var import = Step242Importer.ImportBody(stepText);+ Assert.True(import.IsSuccess, string.Join(Environment.NewLine, import.Diagnostics.Select(d => d.Message)));+ Assert.Equal(6, import.Value.Topology.Faces.Count());+ Assert.Equal(8, import.Value.Topology.Vertices.Count());+ Assert.Equal(12, import.Value.Topology.Edges.Count());++ var volume = StepAnalyzer.AnalyzeVolume(stepPath);+ Assert.True(volume.Success, fixtureId + " volume analysis succeeds");+ Assert.True(volume.Exact, fixtureId + " volume should use exact closed-shell analysis");+ Assert.InRange(Math.Abs(volume.Volume - expectedVolume), 0d, 1e-9);+ }++ [Fact]+ public void STEP_V2_X3_semantic_face_alias_fixture_builds_emits_reimports_and_matches_hole_evidence()+ {+ const string fixtureId = "semanticref-v2-expose-face-alias-resolves-in-step";+ var fixturePath = Fixture("SemanticRefs/valid/semanticref-v2-expose-face-alias-resolves-in-step.valid.firmfixture");+ var stepPath = TempStep(fixtureId);++ var (stepText, fixtureText) = BuildAndReadStep(fixturePath, stepPath, fixtureId);+ AssertStageHonesty(fixtureText, "semantic-reference");+ Assert.Contains("on: top", fixtureText, StringComparison.Ordinal);+ Assert.Contains("face(+Z) => top", fixtureText, StringComparison.Ordinal);++ Assert.True(CountStepEntities(stepText, "ADVANCED_FACE") > 0, fixtureId + " emits real STEP advanced faces");+ Assert.True(CountStepEntities(stepText, "VERTEX_POINT") > 0, fixtureId + " emits STEP vertex topology marker");+ AssertNoTraceOnlyStep(stepText);++ 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);+ Assert.Equal(1, body.Topology.Faces.Count(f => body.TryGetFaceSurface(f.Id, out var surface) && surface?.Kind == SurfaceGeometryKind.Cylinder));++ var volume = StepAnalyzer.AnalyzeVolume(stepPath);+ Assert.True(volume.Success, fixtureId + " volume analysis succeeds");+ Assert.True(volume.Exact, fixtureId + " volume should use exact semantic hole interval analysis");+ Assert.Equal("analytic-box-minus-z-hole", volume.Method);+ Assert.InRange(Math.Abs(volume.Volume - (480d - Math.PI * 1d * 1d * 6d)), 0d, 1e-8);+ }++ private static (string StepText, string FixtureText) BuildAndReadStep(string fixturePath, string stepPath, string fixtureId)+ {+ 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), fixtureId + " reaches real build command");+ var stepText = File.ReadAllText(stepPath);+ Assert.Contains("ISO-10303-21", stepText, StringComparison.Ordinal);+ return (stepText, File.ReadAllText(fixturePath));+ }++ private static void AssertStageHonesty(string fixtureText, string featureArea)+ {+ Assert.Contains("tier: 3", fixtureText, StringComparison.Ordinal);+ 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);+ Assert.Contains("feature-area: " + featureArea, fixtureText, StringComparison.Ordinal);+ }++ private static void AssertNoTraceOnlyStep(string stepText)+ {+ Assert.DoesNotContain("controlled fixture only", stepText, StringComparison.OrdinalIgnoreCase);+ Assert.DoesNotContain("trace", stepText, StringComparison.OrdinalIgnoreCase);+ }++ private static string Fixture(string relativePath) =>+ Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../fixtures/FirmamentV2", relativePath));++ private static string TempStep(string fixtureId)+ {+ var outDir = Path.Combine(Path.GetTempPath(), "aetheris-step-v2-x3", Guid.NewGuid().ToString("N"));+ Directory.CreateDirectory(outDir);+ return Path.Combine(outDir, fixtureId + ".step");+ }++ private static int CountStepEntities(string stepText, string entityName) =>+ Regex.Matches(stepText, "=\\s*" + Regex.Escape(entityName) + "\\s*\\(", RegexOptions.CultureInvariant).Count;+}diff --git a/Aetheris.CLI/AirTrace.cs b/Aetheris.CLI/AirTrace.csindex 42953bdb..0cbf7a6f 100644--- a/Aetheris.CLI/AirTrace.cs+++ b/Aetheris.CLI/AirTrace.cs@@ -132,7 +132,8 @@ internal static class AirTraceReportBuildervar stepVerifiedDiagnostics = Array.Empty<string>();if (isFirmamentV2 && string.Equals(fixture.ExpectedStage, "step-verified", StringComparison.Ordinal)){- var stepVerified = string.Equals(fixture.Metadata.GetValueOrDefault("feature-area"), "semantic-hole", StringComparison.Ordinal)+ var featureArea = fixture.Metadata.GetValueOrDefault("feature-area");+ var stepVerified = string.Equals(featureArea, "semantic-hole", StringComparison.Ordinal) || string.Equals(featureArea, "semantic-reference", StringComparison.Ordinal)? TryVerifyV2SemanticHoleStepFixture(fixture): TryVerifyV2BoxStepFixture(fixture);if (stepVerified.Succeeded)@@ -240,14 +241,16 @@ internal static class AirTraceReportBuilder}var volume = StepAnalyzer.AnalyzeVolume(stepPath);- var expectedVolume = fixture.CaseName switch- {- "feature-v2-shaft-hole-through-step-verified" => 480d - Math.PI * 6d,- "feature-v2-shaft-hole-blind-step-verified" => 480d - Math.PI * 3d,- "feature-v2-counterbore-step-verified" => 480d - ((Math.PI * 6d) + (Math.PI * 3d)),- "feature-v2-countersink-step-verified" => 480d - ((Math.PI * 6d) + (Math.PI * 7d / 3d) - Math.PI),- _ => double.NaN- };+ var expectedVolume = fixture.Metadata.TryGetValue("expected-volume", out var expectedVolumeRaw) && double.TryParse(expectedVolumeRaw, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var parsedVolume)+ ? parsedVolume+ : fixture.CaseName switch+ {+ "feature-v2-shaft-hole-through-step-verified" => 480d - Math.PI * 6d,+ "feature-v2-shaft-hole-blind-step-verified" => 480d - Math.PI * 3d,+ "feature-v2-counterbore-step-verified" => 480d - ((Math.PI * 6d) + (Math.PI * 3d)),+ "feature-v2-countersink-step-verified" => 480d - ((Math.PI * 6d) + (Math.PI * 7d / 3d) - Math.PI),+ _ => double.NaN+ };if (!volume.Success || !volume.Exact || !double.IsFinite(expectedVolume) || Math.Abs(volume.Volume - expectedVolume) > 1e-8){diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentV2ParserTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentV2ParserTests.csindex da5ec812..9c44e231 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentV2ParserTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentV2ParserTests.cs@@ -103,6 +103,63 @@ public sealed class FirmamentV2ParserTestsAssert.Equal([10, 8, 12], result.Document.Solids.Single(s => s.Name == "tall").Box.Size);}++ [Fact]+ public void FirmamentV2Parser_WithBox_ChainedTwiceLowersWithoutStaleDimensions()+ {+ var result = FirmamentFrontendTraceProbe.ParseV2Only(Source("RecordDerivation/valid/derivation-v2-with-chained-twice-step-verified.valid.firmfixture"));+ Assert.True(result.ParseSucceeded, string.Join(", ", result.Diagnostics));+ Assert.Equal("CreateBox", result.FeatureAir!.FeatureAirNodeKind);+ Assert.Equal(12, result.FeatureAir.SourceDimensions!.Width);+ Assert.Equal(8, result.FeatureAir.SourceDimensions.Depth);+ Assert.Equal(7, result.FeatureAir.SourceDimensions.Height);+ Assert.Equal("taller", result.FirmamentV2!.SolidName);++ var parse = FirmamentV2Parser.Parse(Source("RecordDerivation/valid/derivation-v2-with-chained-twice-step-verified.valid.firmfixture"));+ Assert.True(parse.IsSuccess, string.Join(", ", parse.Diagnostics));+ Assert.Equal([10, 8, 6], parse.Document!.Solids.Single(s => s.Name == "base").Box!.Size);+ Assert.Equal([12, 8, 6], parse.Document.Solids.Single(s => s.Name == "wider").Box!.Size);+ Assert.Equal([12, 8, 7], parse.Document.Solids.Single(s => s.Name == "taller").Box!.Size);+ }++ [Fact]+ public void FirmamentV2Parser_SemanticFaceAlias_ResolvesBeforeHoleLowering()+ {+ var result = FirmamentV2Parser.Parse(Source("SemanticRefs/valid/semanticref-v2-expose-face-alias-resolves-in-step.valid.firmfixture"));+ Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));+ var hole = Assert.Single(Assert.Single(result.Document!.ModifyBlocks!).SemanticHoles);+ Assert.Equal("top", hole.EntryFace.Source);+ Assert.Equal("Alias", hole.EntryFace.Kind);+ Assert.Equal("+Z", hole.EntryFace.Axis);+ Assert.Equal("face(+Z)", hole.EntryFace.ResolvedSelector);+ Assert.Equal(FirmamentV2SemanticHoleVariant.Shaft, hole.Variant);+ }++ [Fact]+ public void FirmamentV2Parser_SemanticFaceAliasFailure_IsDeterministicDiagnostic()+ {+ const string source = """+model AliasFailure {+ units mm+ solid base: Box {+ size: [10, 8, 6]+ expose { face(+Z) => top }+ }+ modify base {+ hole<shaft> mount {+ on: missingAlias+ center: [0, 0]+ diameter: 2+ end: throughAll+ }+ }+}+""";+ var result = FirmamentV2Parser.Parse(source);+ Assert.False(result.IsSuccess);+ Assert.Contains(FirmamentV2Parser.AliasUnresolved, result.Diagnostics);+ }+[Fact]public void FirmamentV2Parser_WithBox_DegenerateDerivedSize_IsDiagnostic(){diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2BuildLowering.cs b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2BuildLowering.csindex 50d09299..4f46c6c9 100644--- a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2BuildLowering.cs+++ b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2BuildLowering.cs@@ -20,11 +20,6 @@ internal static class FirmamentV2BuildLoweringreturn Failure("Firmament V2 build/export currently admits only a single primitive solid with no modify blocks.");}- if (document.Solids.Count != 1)- {- return Failure("Firmament V2 build/export currently admits exactly one primitive solid.");- }-var solid = document.Solid;var primitive = ToLoweredPrimitive(solid);if (primitive is null)diff --git a/docs/implementation/step-v2-x3-derivation-semanticrefs-ap242.md b/docs/implementation/step-v2-x3-derivation-semanticrefs-ap242.mdnew file mode 100644index 00000000..88e9122c--- /dev/null+++ b/docs/implementation/step-v2-x3-derivation-semanticrefs-ap242.md@@ -0,0 +1,78 @@+# STEP-V2-X3 — derivation and semantic references AP242 verification++STEP-V2-X3 promotes Tier 3 Firmament V2 source-composition fixtures from parser/source intent to AP242 `step-verified` evidence through the production build path.++## Fixture paths++- `fixtures/FirmamentV2/RecordDerivation/valid/derivation-v2-with-size-override-step-verified.valid.firmfixture`+- `fixtures/FirmamentV2/RecordDerivation/valid/derivation-v2-with-chained-twice-step-verified.valid.firmfixture`+- `fixtures/FirmamentV2/SemanticRefs/valid/semanticref-v2-expose-face-alias-resolves-in-step.valid.firmfixture`++The repository's existing V2 derivation convention is `RecordDerivation`, so X3 keeps the new derivation fixtures there instead of creating a parallel `Derivation` tree.++## Command path++Each non-blocked fixture is verified by the real CLI path:++```bash+aetheris build <fixture> --out <path> --json+```++In local validation this is run via:++```bash+dotnet run --project Aetheris.CLI -- build <fixture> --out <path> --json+```++The build path parses Firmament V2, lowers through the production bridge/materializer, exports with `Step242Exporter.ExportBody`, and writes real AP242. No hardcoded STEP templates or trace-only output are used.++## Verified source composition features++### `with` size override++The size override fixture derives `wider` from `base` and changes only `size` from `10 x 8 x 6` to `12 x 8 x 6`. The final emitted solid is the derived record selected by the normal V2 document convention (`Document.Solid` is the last solid). Expected volume:++```text+12 * 8 * 6 = 576 mm^3+```++Expected topology after AP242 reimport is the canonical single box: 6 faces, 8 vertices, and 12 edges.++### chained `with` twice++The chained fixture derives `wider` from `base`, then `taller` from `wider`, proving the second derivation uses the immediate prior normalized record and does not accumulate stale dimensions. Expected final dimensions and volume:++```text+12 * 8 * 7 = 672 mm^3+```++Expected topology after AP242 reimport is again the canonical single box: 6 faces, 8 vertices, and 12 edges.++### semantic face alias consumed by a semantic hole++The semantic reference fixture exposes `face(+Z) => top`, then uses `on: top` in a later `hole<shaft>` feature. Parser/lowering tests assert the semantic hole entry face source is the alias `top`, while the resolved selector is `face(+Z)`. STEP verification then checks the same production AP242 evidence as the direct-face shaft-hole fixture: topology markers, successful reimport, cylindrical wall evidence, and analytic volume:++```text+480 - pi * 1^2 * 6 mm^3+```++## AP242 verification checks++The X3 integration tests assert:++- the real `build` command accepts the fixture;+- the output `.step` file exists;+- the file contains `ISO-10303-21`, `ADVANCED_FACE`, and `VERTEX_POINT` markers;+- trace-only markers such as `trace` and fixture-control text are absent;+- `Step242Importer.ImportBody` succeeds;+- derivation fixtures reimport as canonical box topology (6 faces / 8 vertices / 12 edges);+- semantic alias fixture reimports with cylindrical wall evidence;+- `StepAnalyzer.AnalyzeVolume` returns exact analytic volumes matching the hand-computed formulas.++## MVP readiness relationship++These fixtures satisfy the MVP readiness contract for Tier 3 V2 source composition because `current-stage: step-verified` is only claimed where the real production build/export path emits AP242, reimports it, and passes topology/semantic and volume evidence checks.++## Deferred item: edge-loop alias++Edge-loop alias remains deferred for X3. The parser can represent an exposure such as `face(+Z).outerLoop => topRim`, but there is no production operation in this milestone scope that consumes an edge-loop alias into AP242. Therefore no edge-loop alias fixture is marked `step-verified` here.diff --git a/fixtures/FirmamentV2/RecordDerivation/valid/derivation-v2-with-chained-twice-step-verified.valid.firmfixture b/fixtures/FirmamentV2/RecordDerivation/valid/derivation-v2-with-chained-twice-step-verified.valid.firmfixturenew file mode 100644index 00000000..5fdd88a9--- /dev/null+++ b/fixtures/FirmamentV2/RecordDerivation/valid/derivation-v2-with-chained-twice-step-verified.valid.firmfixture@@ -0,0 +1,37 @@+// fixture-id: derivation-v2-with-chained-twice-step-verified+// case: derivation-v2-with-chained-twice-step-verified+// category: RecordDerivation+// syntax-version: FirmamentV2+// validity: valid+// implementation: parser-backed+// expected: valid+// expected-stage: step-verified+// current-stage: step-verified+// expected-feature-air: CreateBox+// expected-solid: taller+// dimensions: base box 10 x 8 x 6; wider box 12 x 8 x 6; final taller box 12 x 8 x 7+// units: mm+// tier: 3+// mvp-required: true+// feature-area: derivation+// build-command: aetheris build+// expected-volume: 672+// expected-topology: faces=6, vertices=8, edges=12, advanced_face>0, vertex_point>0+// roundtrip-required: true+// parser-backed: true+// notes: STEP-V2-X3 chained with-derivation fixture proves the final derived record is selected without stale dimensions from earlier derivations.+model DerivationV2WithChainedTwiceStepVerified {+ units mm++ solid base: Box {+ size: [10, 8, 6]+ }++ solid wider: base with {+ size: [12, 8, 6]+ }++ solid taller: wider with {+ size: [12, 8, 7]+ }+}diff --git a/fixtures/FirmamentV2/RecordDerivation/valid/derivation-v2-with-size-override-step-verified.valid.firmfixture b/fixtures/FirmamentV2/RecordDerivation/valid/derivation-v2-with-size-override-step-verified.valid.firmfixturenew file mode 100644index 00000000..bc23e8ea--- /dev/null+++ b/fixtures/FirmamentV2/RecordDerivation/valid/derivation-v2-with-size-override-step-verified.valid.firmfixture@@ -0,0 +1,33 @@+// fixture-id: derivation-v2-with-size-override-step-verified+// case: derivation-v2-with-size-override-step-verified+// category: RecordDerivation+// syntax-version: FirmamentV2+// validity: valid+// implementation: parser-backed+// expected: valid+// expected-stage: step-verified+// current-stage: step-verified+// expected-feature-air: CreateBox+// expected-solid: wider+// dimensions: base box 10 x 8 x 6; derived wider box 12 x 8 x 6+// units: mm+// tier: 3+// mvp-required: true+// feature-area: derivation+// build-command: aetheris build+// expected-volume: 576+// expected-topology: faces=6, vertices=8, edges=12, advanced_face>0, vertex_point>0+// roundtrip-required: true+// parser-backed: true+// notes: STEP-V2-X3 with-derivation fixture verified through real build/export, Step242Exporter, reimport, canonical box topology, and analytic volume.+model DerivationV2WithSizeOverrideStepVerified {+ units mm++ solid base: Box {+ size: [10, 8, 6]+ }++ solid wider: base with {+ size: [12, 8, 6]+ }+}diff --git a/fixtures/FirmamentV2/SemanticRefs/valid/semanticref-v2-expose-face-alias-resolves-in-step.valid.firmfixture b/fixtures/FirmamentV2/SemanticRefs/valid/semanticref-v2-expose-face-alias-resolves-in-step.valid.firmfixturenew file mode 100644index 00000000..07bdc27e--- /dev/null+++ b/fixtures/FirmamentV2/SemanticRefs/valid/semanticref-v2-expose-face-alias-resolves-in-step.valid.firmfixture@@ -0,0 +1,42 @@+// fixture-id: semanticref-v2-expose-face-alias-resolves-in-step+// case: semanticref-v2-expose-face-alias-resolves-in-step+// category: SemanticRefs+// syntax-version: FirmamentV2+// validity: valid+// implementation: parser-backed+// expected: valid+// expected-stage: step-verified+// current-stage: step-verified+// expected-feature-air: AirHoleFeature(SimpleShaft)+// dimensions: base box 10 x 8 x 6; top alias resolves to face(+Z); shaft radius 1; through depth 6+// units: mm+// tier: 3+// mvp-required: true+// feature-area: semantic-reference+// build-command: aetheris build+// expected-volume: 461.15044407846124+// expected-topology: advanced_face>0, vertex_point>0, cylindrical-wall-face=true+// expected-semantic-evidence: entry face source is alias top and resolved selector is face(+Z)+// roundtrip-required: true+// parser-backed: true+// notes: STEP-V2-X3 face alias fixture proves expose face(+Z) => top is consumed by a later semantic shaft hole before real Step242Exporter output.+model SemanticRefV2ExposeFaceAliasResolvesInStep {+ units mm++ solid base: Box {+ size: [10, 8, 6]++ expose {+ face(+Z) => top+ }+ }++ modify base {+ hole<shaft> mount {+ on: top+ center: [0, 0]+ diameter: 2+ end: throughAll+ }+ }+}