Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Implement V2 record PMI AP242 export

Yuechen Li605e63d9c9d6
diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.cs
index 9f2ad91a..b798ef1f 100644
--- a/Aetheris.CLI/CliRunner.cs
+++ b/Aetheris.CLI/CliRunner.cs
@@ -261,7 +261,12 @@ public static class CliRunner
sourcePath = build.Value.SourcePath,
outputPath = build.Value.OutputPath,
inlineStepMigration = build.Value.Export.InlineStepMigration,
- inlineStepReplacementAssist = build.Value.Export.InlineStepReplacementAssist
+ inlineStepReplacementAssist = build.Value.Export.InlineStepReplacementAssist,
+ pmiExportEvidence = new
+ {
+ datum = (build.Value.Export.DatumInspection ?? []).Select(d => new { kind = "datum", name = d.Label, exportSupport = "supported", exportEvidence = "found", target = d.Target }),
+ diameter = (build.Value.Export.DimensionInspection ?? []).Where(d => string.Equals(d.Kind, "Diameter", StringComparison.Ordinal)).Select(d => new { kind = "diameter", name = d.CandidateName ?? d.Target, exportSupport = "supported", exportEvidence = "found", target = d.Target, nominal = d.Value })
+ }
}, JsonOptions));
}
else
diff --git a/Aetheris.Kernel.Core/Step242/Step242Exporter.cs b/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
index b0d91ab7..86ef9a0b 100644
--- a/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
@@ -298,6 +298,36 @@ public static class Step242Exporter
Step242TextWriter.Ref(propertyDefinitionId),
Step242TextWriter.Ref(representationId));
+ if (hole.TolerancePlus.HasValue || hole.ToleranceMinus.HasValue)
+ {
+ var tolerancePlus = hole.TolerancePlus ?? hole.ToleranceMinus!.Value;
+ var toleranceMinus = hole.ToleranceMinus ?? hole.TolerancePlus!.Value;
+ var tolerancePlusItemId = writer.AddEntity(
+ "MEASURE_REPRESENTATION_ITEM",
+ Step242TextWriter.String("tolerance_plus"),
+ Step242TextWriter.Number(tolerancePlus),
+ Step242TextWriter.Ref(lengthUnitId));
+ var toleranceMinusItemId = writer.AddEntity(
+ "MEASURE_REPRESENTATION_ITEM",
+ Step242TextWriter.String("tolerance_minus"),
+ Step242TextWriter.Number(toleranceMinus),
+ Step242TextWriter.Ref(lengthUnitId));
+ var toleranceRepId = writer.AddEntity(
+ "SHAPE_DIMENSION_REPRESENTATION",
+ Step242TextWriter.String($"diameter_tolerance:{hole.FeatureId}"),
+ Step242TextWriter.List(tolerancePlusItemId, toleranceMinusItemId),
+ Step242TextWriter.Ref(repContextId));
+ var tolerancePropertyDefinitionId = writer.AddEntity(
+ "PROPERTY_DEFINITION",
+ Step242TextWriter.String($"diameter_tolerance:{hole.FeatureId}"),
+ Step242TextWriter.String("semantic PMI bilateral diameter tolerance"),
+ Step242TextWriter.Ref(featureShapeAspectId));
+ writer.AddEntity(
+ "PROPERTY_DEFINITION_REPRESENTATION",
+ Step242TextWriter.Ref(tolerancePropertyDefinitionId),
+ Step242TextWriter.Ref(toleranceRepId));
+ }
+
if (hole.Depth.HasValue)
{
var depthItemId = writer.AddEntity(
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentV2ParserTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentV2ParserTests.cs
index 1811a50d..85b12edc 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentV2ParserTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentV2ParserTests.cs
@@ -860,13 +860,92 @@ model BadPmiDiameter {
Assert.Contains(FirmamentV2Parser.PmiDiameterInvalid, invalidDiameter.Diagnostics);
}
+
+ [Fact]
+ public void FirmamentV2Parser_RecordPmiDatumDiameter_BindsTolerancedDimensionAndTargets()
+ {
+ var result = FirmamentV2Parser.Parse(Source("InlineStep/valid/inline-step-v2-record-pmi-datum-diameter-step-verified.valid.firmfixture"),
+ Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../fixtures/FirmamentV2/InlineStep/valid")));
+
+ Assert.True(result.IsSuccess, string.Join(", ", result.Diagnostics));
+ var bound = result.Document!.BoundPmi!;
+ var datum = Assert.Single(bound.Datums);
+ Assert.Equal(FirmamentV2PmiKind.DatumPlane, datum.Kind);
+ Assert.Equal("A", datum.Name);
+ Assert.Equal("part.region(\"baseFace\")", Assert.Single(datum.Targets));
+
+ var diameter = Assert.Single(bound.Dimensions);
+ Assert.Equal(FirmamentV2PmiKind.HoleDiameter, diameter.Kind);
+ Assert.Equal("mountHoleADiameter", diameter.Name);
+ Assert.Equal("part.region(\"mountHoleA\")", Assert.Single(diameter.Targets));
+ Assert.Equal(6.0d, diameter.DimensionValue!.NumericValue);
+ Assert.NotNull(diameter.DimensionTolerance);
+ Assert.Equal(0.05d, diameter.DimensionTolerance!.Plus);
+ Assert.Equal(0.05d, diameter.DimensionTolerance.Minus);
+ }
+
+ [Fact]
+ public void FirmamentV2P2_RecordPmiDatumDiameter_ExportsAp242EvidenceAndReimports()
+ {
+ var fixture = FixturePath("InlineStep/valid/inline-step-v2-record-pmi-datum-diameter-step-verified.valid.firmfixture");
+ var output = Path.Combine(Path.GetTempPath(), "aetheris-p2-record-pmi-" + Guid.NewGuid().ToString("N") + ".step");
+
+ var build = FirmamentBuildAndExport.Run(fixture, output);
+
+ Assert.True(build.IsSuccess, string.Join(", ", build.Diagnostics.Select(d => d.Message)));
+ Assert.True(File.Exists(output));
+ var step = File.ReadAllText(output);
+ Assert.Contains("SHAPE_ASPECT('firmament-datum:A'", step, StringComparison.Ordinal);
+ Assert.Contains("PROPERTY_DEFINITION('datum:A:part'", step, StringComparison.Ordinal);
+ Assert.Contains("SHAPE_DIMENSION_REPRESENTATION('diameter:part.mountHoleADiameter'", step, StringComparison.Ordinal);
+ Assert.Contains("PROPERTY_DEFINITION('diameter:part.mountHoleADiameter'", step, StringComparison.Ordinal);
+ Assert.Contains("SHAPE_DIMENSION_REPRESENTATION('diameter_tolerance:part.mountHoleADiameter'", step, StringComparison.Ordinal);
+ Assert.Contains("'tolerance_plus'", step, StringComparison.Ordinal);
+ Assert.Contains("'tolerance_minus'", step, StringComparison.Ordinal);
+
+ var reimport = Aetheris.Kernel.Core.Step242.Step242Importer.ImportBody(step);
+ Assert.True(reimport.IsSuccess, string.Join(", ", reimport.Diagnostics.Select(d => d.Message)));
+ Assert.Single(build.Value.Export.DatumInspection!);
+ Assert.Single(build.Value.Export.DimensionInspection!);
+ }
+
+ [Fact]
+ public void FirmamentV2P2_RecordPmiDiameterDimensionWithoutTolerance_IsRejected()
+ {
+ var result = FirmamentV2Parser.Parse(Source("InlineStep/invalid/inline-step-v2-record-pmi-diameter-missing-tolerance.invalid.firmfixture"),
+ Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../fixtures/FirmamentV2/InlineStep/invalid")));
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains(FirmamentV2Parser.PmiDimensionMissingTolerance, result.Diagnostics);
+ }
+
+ [Fact]
+ public void FirmamentV2P2_ExportDeferredFlatness_IsReportedAndBuildRejectedDeterministically()
+ {
+ var fixture = FixturePath("InlineStep/invalid/inline-step-v2-record-pmi-export-deferred-flatness.invalid.firmfixture");
+ var parse = FirmamentV2Parser.Parse(Source("InlineStep/invalid/inline-step-v2-record-pmi-export-deferred-flatness.invalid.firmfixture"), Path.GetDirectoryName(fixture));
+ var report = FirmamentV2ValidationReportBuilder.Build(parse, fixture);
+
+ var pmi = Assert.Single(report.Pmi);
+ Assert.Equal("flatness", pmi.Kind);
+ Assert.Equal("deferred", pmi.ExportSupport);
+ Assert.Equal("export-deferred", pmi.Status);
+
+ var build = FirmamentBuildAndExport.Run(fixture, Path.Combine(Path.GetTempPath(), "aetheris-flatness-deferred.step"));
+ Assert.False(build.IsSuccess);
+ Assert.Contains(build.Diagnostics, d => d.Message.Contains("firmament-v2-pmi-export-deferred", StringComparison.Ordinal));
+ }
+
private static string Source(string relative)
{
- var path = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../fixtures/FirmamentV2", relative));
+ var path = FixturePath(relative);
var lines = File.ReadAllLines(path);
var bodyStart = Array.FindIndex(lines, line => !string.IsNullOrWhiteSpace(line) && !line.TrimStart().StartsWith("//", StringComparison.Ordinal));
return string.Join(Environment.NewLine, lines.Skip(Math.Max(0, bodyStart)));
}
+
+ private static string FixturePath(string relative) => Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../fixtures/FirmamentV2", relative));
+
[Fact]
public void FirmamentV2Parser_LetPrimitiveLiterals_ParsesAndBinds()
{
diff --git a/Aetheris.Kernel.Firmament/FirmamentBuildAndExport.cs b/Aetheris.Kernel.Firmament/FirmamentBuildAndExport.cs
index c1f1fedb..3f4e16f4 100644
--- a/Aetheris.Kernel.Firmament/FirmamentBuildAndExport.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentBuildAndExport.cs
@@ -213,6 +213,12 @@ public static class FirmamentBuildAndExport
return KernelResult<FirmamentStepExportResult>.Failure(import.Diagnostics);
}
+ var semanticPmiValidation = ValidateV2PmiExportSupport(document);
+ if (!semanticPmiValidation.IsSuccess)
+ {
+ return KernelResult<FirmamentStepExportResult>.Failure(semanticPmiValidation.Diagnostics);
+ }
+
var semanticPmi = BuildV2SemanticPmi(document, [], solid.Name);
var export = Step242Exporter.ExportBody(import.Value, semanticPmi, new Step242ExportOptions
{
@@ -231,8 +237,8 @@ public static class FirmamentBuildAndExport
0,
"inline-step",
"aetheris-canonical-ap242",
- DatumInspection: [],
- DimensionInspection: [],
+ DatumInspection: document.Pmi?.Where(p => p.Kind == FirmamentV2PmiKind.DatumPlane).Select(p => new FirmamentPmiInspectionDatum(p.Name, "planar", p.Target)).ToArray() ?? [],
+ DimensionInspection: document.Pmi?.Where(p => p.Kind == FirmamentV2PmiKind.HoleDiameter).Select(p => new FirmamentPmiInspectionDimension("Diameter", p.Target, null, p.Value ?? 0d, "explicit-v2-record-pmi", p.Name)).ToArray() ?? [],
InlineStepMigration: InlineStepMigrationReportBuilder.Build(document, solid, emissionStrategy: "canonical-reexport", residualSurgery: false),
InlineStepReplacementAssist: InlineStepReplacementAssistReportBuilder.Build(document)));
}
@@ -422,6 +428,21 @@ public static class FirmamentBuildAndExport
DimensionInspection: document.Pmi?.Where(p => p.Kind == FirmamentV2PmiKind.HoleDiameter).Select(p => new FirmamentPmiInspectionDimension("Diameter", p.Target, null, p.Value ?? 0d, "explicit-v2-semantic-pmi", null)).ToArray() ?? []));
}
+ private static KernelResult<bool> ValidateV2PmiExportSupport(FirmamentV2Document document)
+ {
+ var unsupported = document.PmiBlock?.Records.Where(r => r.Kind is not (FirmamentV2PmiKind.DatumPlane or FirmamentV2PmiKind.HoleDiameter)).ToArray() ?? [];
+ if (unsupported.Length == 0)
+ {
+ return KernelResult<bool>.Success(true);
+ }
+
+ return KernelResult<bool>.Failure(unsupported.Select(r => new Kernel.Core.Diagnostics.KernelDiagnostic(
+ Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed,
+ Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error,
+ $"firmament-v2-pmi-export-deferred: AP242 export for PMI record '{r.Name}' ({r.Kind.ToString().ToLowerInvariant()}) is deferred in V2 Phase 1 P2; supported export records are datum and diameter.",
+ "FirmamentV2.PmiExport")).ToArray());
+ }
+
private static IReadOnlyList<Step242SemanticPmi> BuildV2SemanticPmi(FirmamentV2Document document, IReadOnlyList<Core.Air.AirHoleFeature> semanticHoles, string targetSolid)
{
if (document.Pmi is null || document.Pmi.Count == 0)
@@ -430,19 +451,23 @@ public static class FirmamentBuildAndExport
}
var holeByName = semanticHoles.SelectMany(h => new[] { new KeyValuePair<string, Core.Air.AirHoleFeature>(h.FeatureId, h), new KeyValuePair<string, Core.Air.AirHoleFeature>(h.Name, h) }).ToDictionary(kvp => kvp.Key, kvp => kvp.Value, StringComparer.Ordinal);
+ var boundPmiByName = (document.BoundPmi?.Datums ?? []).Concat(document.BoundPmi?.Dimensions ?? []).Concat(document.BoundPmi?.Controls ?? []).ToDictionary(p => p.Name, StringComparer.Ordinal);
var targetBinding = document.Solids.Single(s => string.Equals(s.Name, targetSolid, StringComparison.Ordinal));
var result = new List<Step242SemanticPmi>();
foreach (var pmi in document.Pmi)
{
if (pmi.Kind == FirmamentV2PmiKind.HoleDiameter && pmi.Value.HasValue)
{
+ boundPmiByName.TryGetValue(pmi.Name, out var boundPmi);
+ var tolerancePlus = boundPmi?.DimensionTolerance?.Plus;
+ var toleranceMinus = boundPmi?.DimensionTolerance?.Minus;
if (holeByName.TryGetValue(pmi.Target, out var pmiHole))
{
- result.Add(new Step242SemanticPmiHole(pmiHole.FeatureId, pmi.Value.Value, null, "explicit_v2_semantic_hole_diameter", null, null));
+ result.Add(new Step242SemanticPmiHole(pmiHole.FeatureId, pmi.Value.Value, null, "explicit_v2_semantic_hole_diameter", tolerancePlus, toleranceMinus));
}
else if (TryResolveV2RecognizedRegionTarget(document, targetBinding, pmi.Target, out var importedTarget) || TryResolveV2ImportedFaceTarget(targetBinding, pmi.Target, out importedTarget))
{
- result.Add(new Step242SemanticPmiHole($"{targetSolid}.{pmi.Name}", pmi.Value.Value, null, $"imported_canonical_face:{importedTarget}", null, null));
+ result.Add(new Step242SemanticPmiHole($"{targetSolid}.{pmi.Name}", pmi.Value.Value, null, $"imported_canonical_face:{importedTarget}", tolerancePlus, toleranceMinus));
}
}
else if (pmi.Kind == FirmamentV2PmiKind.DatumPlane)
diff --git a/docs/implementation/v2-phase1-p2-record-pmi-ap242-export.md b/docs/implementation/v2-phase1-p2-record-pmi-ap242-export.md
new file mode 100644
index 00000000..0fad0938
--- /dev/null
+++ b/docs/implementation/v2-phase1-p2-record-pmi-ap242-export.md
@@ -0,0 +1,73 @@
+# V2 Phase 1 P2 record PMI AP242 export
+
+P2 wires the supported subset of the record-shaped Firmament V2 `pmi` block into the existing semantic STEP/AP242 export path for InlineStep models.
+
+## Supported export records
+
+Implemented for P2 export:
+
+- `datum` over a resolved InlineStep face or recognized `datumPlane` region.
+- `diameter` over a resolved InlineStep face or recognized `holeShaft` region.
+
+Export-deferred records remain explicit and are not silently dropped:
+
+- `distance`
+- `flatness`
+- `parallel`
+- `perpendicular`
+- `coplanar`
+
+For build/export, P2 rejects export-deferred PMI records with a deterministic `firmament-v2-pmi-export-deferred` diagnostic instead of emitting a partial AP242 file without those records.
+
+## Bridge to semantic PMI
+
+The P1 parser/binder continues to bind record-shaped PMI into `FirmamentV2BoundPmiBlock`. P2 bridges the legacy-compatible `FirmamentV2PmiDecl` records plus bound tolerance metadata into the current `Step242SemanticPmi` payloads consumed by `Step242Exporter`:
+
+- `datum A { target: part.region("baseFace") }` becomes `Step242SemanticPmiDatum`.
+- `diameter mountHoleADiameter { target: part.region("mountHoleA") dimension: MountingPattern.holeDiameter }` becomes `Step242SemanticPmiHole`.
+
+The bridge preserves target strings through recognized-region resolution, so AP242 descriptions include the imported canonical face evidence.
+
+## Tolerance handling
+
+Diameter dimensions authored from toleranced `let` values preserve bilateral tolerance metadata. The AP242 exporter emits separate semantic tolerance evidence using `diameter_tolerance:<featureId>` plus `tolerance_plus` and `tolerance_minus` measure items. Diameter records that reference a `dimension:` let without tolerance remain invalid via `firmament-v2-pmi-dimension-missing-tolerance`.
+
+Legacy `value:`/`diameter:` diameter forms remain available for older fixtures, but the V2 Phase 1 P2 authoring path is the toleranced `dimension:` form.
+
+## AP242 evidence checked
+
+The primary P2 fixture asserts these semantic STEP/AP242 strings:
+
+- `SHAPE_ASPECT('firmament-datum:A'`
+- `PROPERTY_DEFINITION('datum:A:part'`
+- `SHAPE_DIMENSION_REPRESENTATION('diameter:part.mountHoleADiameter'`
+- `PROPERTY_DEFINITION('diameter:part.mountHoleADiameter'`
+- `SHAPE_DIMENSION_REPRESENTATION('diameter_tolerance:part.mountHoleADiameter'`
+- `tolerance_plus`
+- `tolerance_minus`
+
+## Fixture and report behavior
+
+Primary fixture:
+
+`fixtures/FirmamentV2/InlineStep/valid/inline-step-v2-record-pmi-datum-diameter-step-verified.valid.firmfixture`
+
+Invalid/deferred fixtures:
+
+- `fixtures/FirmamentV2/InlineStep/invalid/inline-step-v2-record-pmi-diameter-missing-tolerance.invalid.firmfixture`
+- `fixtures/FirmamentV2/InlineStep/invalid/inline-step-v2-record-pmi-export-deferred-flatness.invalid.firmfixture`
+
+`aetheris validate <fixture> --json` reports record-shaped PMI status through `firmamentV2Validation.pmi`, including `exportSupport: supported` for datum/diameter and `exportSupport: deferred` for unsupported records.
+
+`aetheris build <fixture> --json` reports AP242 evidence visibility in `pmiExportEvidence`, with datum and diameter entries marked `exportSupport: supported` and `exportEvidence: found` after successful export.
+
+## Non-scope
+
+P2 intentionally does not implement:
+
+- graphical PMI;
+- drawing views;
+- full GD&T/Y14.5 lowering;
+- new modeling behavior;
+- STEP geometry changes;
+- AP242 lowering for distance, flatness, parallel, perpendicular, or coplanar records.
diff --git a/docs/v2/aetheris-v2-phase1-scope-contract.md b/docs/v2/aetheris-v2-phase1-scope-contract.md
index 0150cd74..6a8381a4 100644
--- a/docs/v2/aetheris-v2-phase1-scope-contract.md
+++ b/docs/v2/aetheris-v2-phase1-scope-contract.md
@@ -434,3 +434,9 @@ D1: demo/update packet for V2.0 Phase 1 workflow
```
Each milestone should preserve the Phase 1 boundary: existing-model manufacturing intent first, no hidden behavior, no full modeling expansion, and no silent success on unsupported paths.
+
+## Status note: V2-PHASE1-P2 record PMI AP242 export
+
+V2-PHASE1-P2 is implemented for robust AP242 export of record-shaped `pmi` `datum` and toleranced `diameter` records over existing canonical InlineStep models. The proof fixture is `fixtures/FirmamentV2/InlineStep/valid/inline-step-v2-record-pmi-datum-diameter-step-verified.valid.firmfixture`; it imports the small canonical through-hole STEP model, recognizes a datum plane and hole region, binds a toleranced record `let`, exports semantic AP242 datum/diameter/tolerance evidence through `Step242Exporter`, and reimports the result in tests.
+
+Distance, flatness, parallel, perpendicular, and coplanar remain export-deferred in Phase 1. Build/export rejects those records deterministically rather than silently dropping unsupported PMI. This status note does not expand scope to graphical PMI, drawing views, full GD&T, modeling behavior, or STEP geometry mutation.
diff --git a/fixtures/FirmamentV2/InlineStep/invalid/inline-step-v2-record-pmi-diameter-missing-tolerance.invalid.firmfixture b/fixtures/FirmamentV2/InlineStep/invalid/inline-step-v2-record-pmi-diameter-missing-tolerance.invalid.firmfixture
new file mode 100644
index 00000000..09688f38
--- /dev/null
+++ b/fixtures/FirmamentV2/InlineStep/invalid/inline-step-v2-record-pmi-diameter-missing-tolerance.invalid.firmfixture
@@ -0,0 +1,9 @@
+// fixture-id: inline-step-v2-record-pmi-diameter-missing-tolerance
+// validity: invalid
+model InlineStepRecordPmiDiameterMissingTolerance {
+ units mm
+ let holeDiameter: length = 6.0mm
+ solid part: InlineStep { path: "../testdata/canonical-through-hole.step" }
+ recognize part { region hole { kind: holeShaft faces: ["#191"] confidence: high } }
+ pmi { diameter d { target: part.region("hole") dimension: holeDiameter } }
+}
diff --git a/fixtures/FirmamentV2/InlineStep/invalid/inline-step-v2-record-pmi-export-deferred-flatness.invalid.firmfixture b/fixtures/FirmamentV2/InlineStep/invalid/inline-step-v2-record-pmi-export-deferred-flatness.invalid.firmfixture
new file mode 100644
index 00000000..93dfe4d7
--- /dev/null
+++ b/fixtures/FirmamentV2/InlineStep/invalid/inline-step-v2-record-pmi-export-deferred-flatness.invalid.firmfixture
@@ -0,0 +1,8 @@
+// fixture-id: inline-step-v2-record-pmi-export-deferred-flatness
+// validity: invalid
+model InlineStepRecordPmiDeferredFlatness {
+ units mm
+ solid part: InlineStep { path: "../testdata/canonical-through-hole.step" }
+ recognize part { region baseFace { kind: datumPlane faces: ["#51"] confidence: high } }
+ pmi { flatness f { target: part.region("baseFace") tolerance: 0.03mm } }
+}
diff --git a/fixtures/FirmamentV2/InlineStep/valid/inline-step-v2-record-pmi-datum-diameter-step-verified.valid.firmfixture b/fixtures/FirmamentV2/InlineStep/valid/inline-step-v2-record-pmi-datum-diameter-step-verified.valid.firmfixture
new file mode 100644
index 00000000..be606259
--- /dev/null
+++ b/fixtures/FirmamentV2/InlineStep/valid/inline-step-v2-record-pmi-datum-diameter-step-verified.valid.firmfixture
@@ -0,0 +1,56 @@
+// fixture-id: inline-step-v2-record-pmi-datum-diameter-step-verified
+// case: inline-step-v2-record-pmi-datum-diameter-step-verified
+// category: InlineStep
+// syntax-version: FirmamentV2
+// validity: valid
+// implementation: parser-backed
+// expected: valid
+// tier: inline-step
+// expected-stage: step-verified
+// current-stage: step-verified
+// feature-area: v2-phase1-p2-record-pmi-ap242-export
+// build-command: aetheris build
+// roundtrip-required: true
+// canonical-input-required: true
+// recognized-region-required: true
+// semantic-pmi-required: true
+// graphical-pmi-required: false
+// input-step: ../testdata/canonical-through-hole.step
+// semantic-pmi-evidence: SHAPE_ASPECT('firmament-datum:A'), SHAPE_DIMENSION_REPRESENTATION('diameter:part.mountHoleADiameter'), SHAPE_DIMENSION_REPRESENTATION('diameter_tolerance:part.mountHoleADiameter')
+// notes: P2 proves record-shaped datum and toleranced diameter PMI over an existing canonical InlineStep model; no graphical PMI, drawing views, full GD&T, or geometry changes.
+model InlineStepRecordPmiDatumDiameter {
+ units mm
+
+ let MountingPattern {
+ holeDiameter: length = 6.0mm tol 0.05mm
+ }
+
+ solid part: InlineStep {
+ path: "../testdata/canonical-through-hole.step"
+ }
+
+ recognize part {
+ region baseFace {
+ kind: datumPlane
+ faces: ["#51"]
+ confidence: high
+ }
+
+ region mountHoleA {
+ kind: holeShaft
+ faces: ["#191"]
+ confidence: high
+ }
+ }
+
+ pmi {
+ datum A {
+ target: part.region("baseFace")
+ }
+
+ diameter mountHoleADiameter {
+ target: part.region("mountHoleA")
+ dimension: MountingPattern.holeDiameter
+ }
+ }
+}