Skip to content

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.cs
index 9a7d6155..7f102f90 100644
--- a/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.cs
+++ b/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.cs
@@ -244,7 +244,7 @@ public sealed class FirmamentFixtureCorpusTests
public 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.cs
new file mode 100644
index 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.cs
index 42953bdb..0cbf7a6f 100644
--- a/Aetheris.CLI/AirTrace.cs
+++ b/Aetheris.CLI/AirTrace.cs
@@ -132,7 +132,8 @@ internal static class AirTraceReportBuilder
var 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.cs
index da5ec812..9c44e231 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentV2ParserTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentV2ParserTests.cs
@@ -103,6 +103,63 @@ public sealed class FirmamentV2ParserTests
Assert.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.cs
index 50d09299..4f46c6c9 100644
--- a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2BuildLowering.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2BuildLowering.cs
@@ -20,11 +20,6 @@ internal static class FirmamentV2BuildLowering
return 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.md
new file mode 100644
index 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.firmfixture
new file mode 100644
index 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.firmfixture
new file mode 100644
index 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.firmfixture
new file mode 100644
index 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
+ }
+ }
+}