Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Implement M7 bounded semantic PMI baseline

Yuechen Lia2267a23543e
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242ExporterTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242ExporterTests.cs
index a46caca3..d3b44539 100644
--- a/Aetheris.Kernel.Core.Tests/Step242/Step242ExporterTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242ExporterTests.cs
@@ -38,8 +38,8 @@ public sealed class Step242ExporterTests
var semanticPmi = new[]
{
- new Step242SemanticPmiDiameter("hole_a", 8d),
- new Step242SemanticPmiDiameter("hole_b", 6d)
+ new Step242SemanticPmiHole("hole_a", 8d, null, "through_or_blind_cylindrical", null, null),
+ new Step242SemanticPmiHole("hole_b", 6d, null, "through_or_blind_cylindrical", null, null)
};
var first = Step242Exporter.ExportBody(boxResult.Value, semanticPmi);
diff --git a/Aetheris.Kernel.Core/Step242/Step242Exporter.cs b/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
index dd56b5f3..d7d2d539 100644
--- a/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
@@ -16,7 +16,7 @@ public static class Step242Exporter
public static KernelResult<string> ExportBody(
BrepBody body,
- IReadOnlyList<Step242SemanticPmiDiameter>? semanticPmi,
+ IReadOnlyList<Step242SemanticPmi>? semanticPmi,
Step242ExportOptions? options = null)
{
options ??= new Step242ExportOptions();
@@ -212,37 +212,59 @@ public static class Step242Exporter
string shapeId,
string repContextId,
string lengthUnitId,
- IReadOnlyList<Step242SemanticPmiDiameter>? semanticPmi)
+ IReadOnlyList<Step242SemanticPmi>? semanticPmi)
{
if (semanticPmi is null || semanticPmi.Count == 0)
{
return;
}
- foreach (var diameter in semanticPmi)
+ foreach (var item in semanticPmi)
{
+ switch (item)
+ {
+ case Step242SemanticPmiHole hole:
+ EmitHoleSemanticPmi(writer, shapeId, repContextId, lengthUnitId, hole);
+ break;
+ case Step242SemanticPmiDatum datum:
+ EmitDatumSemanticPmi(writer, shapeId, datum);
+ break;
+ case Step242SemanticPmiNote note:
+ EmitNoteSemanticPmi(writer, shapeId, note);
+ break;
+ }
+ }
+ }
+
+ private static void EmitHoleSemanticPmi(
+ Step242TextWriter writer,
+ string shapeId,
+ string repContextId,
+ string lengthUnitId,
+ Step242SemanticPmiHole hole)
+ {
var featureShapeAspectId = writer.AddEntity(
"SHAPE_ASPECT",
- Step242TextWriter.String($"firmament-feature:{diameter.FeatureId}"),
+ Step242TextWriter.String($"firmament-feature:{hole.FeatureId}"),
Step242TextWriter.String("supported cylinder through-hole feature"),
Step242TextWriter.Ref(shapeId),
Step242TextWriter.Enum("FALSE"));
var propertyDefinitionId = writer.AddEntity(
"PROPERTY_DEFINITION",
- Step242TextWriter.String($"diameter:{diameter.FeatureId}"),
+ Step242TextWriter.String($"diameter:{hole.FeatureId}"),
Step242TextWriter.String("auto-derived semantic PMI diameter"),
Step242TextWriter.Ref(featureShapeAspectId));
var measureItemId = writer.AddEntity(
"MEASURE_REPRESENTATION_ITEM",
Step242TextWriter.String("diameter"),
- Step242TextWriter.Number(diameter.Diameter),
+ Step242TextWriter.Number(hole.Diameter),
Step242TextWriter.Ref(lengthUnitId));
var representationId = writer.AddEntity(
"SHAPE_DIMENSION_REPRESENTATION",
- Step242TextWriter.String($"diameter:{diameter.FeatureId}"),
+ Step242TextWriter.String($"diameter:{hole.FeatureId}"),
Step242TextWriter.List(measureItemId),
Step242TextWriter.Ref(repContextId));
@@ -250,9 +272,69 @@ public static class Step242Exporter
"PROPERTY_DEFINITION_REPRESENTATION",
Step242TextWriter.Ref(propertyDefinitionId),
Step242TextWriter.Ref(representationId));
+
+ if (hole.Depth.HasValue)
+ {
+ var depthItemId = writer.AddEntity(
+ "MEASURE_REPRESENTATION_ITEM",
+ Step242TextWriter.String("depth"),
+ Step242TextWriter.Number(hole.Depth.Value),
+ Step242TextWriter.Ref(lengthUnitId));
+ var depthRepId = writer.AddEntity(
+ "SHAPE_DIMENSION_REPRESENTATION",
+ Step242TextWriter.String($"depth:{hole.FeatureId}"),
+ Step242TextWriter.List(depthItemId),
+ Step242TextWriter.Ref(repContextId));
+ var depthPropertyDefinitionId = writer.AddEntity(
+ "PROPERTY_DEFINITION",
+ Step242TextWriter.String($"depth:{hole.FeatureId}"),
+ Step242TextWriter.String("semantic PMI depth"),
+ Step242TextWriter.Ref(featureShapeAspectId));
+ writer.AddEntity(
+ "PROPERTY_DEFINITION_REPRESENTATION",
+ Step242TextWriter.Ref(depthPropertyDefinitionId),
+ Step242TextWriter.Ref(depthRepId));
}
}
+ private static void EmitDatumSemanticPmi(
+ Step242TextWriter writer,
+ string shapeId,
+ Step242SemanticPmiDatum datum)
+ {
+ var aspectId = writer.AddEntity(
+ "SHAPE_ASPECT",
+ Step242TextWriter.String($"firmament-datum:{datum.Label}"),
+ Step242TextWriter.String($"semantic datum {datum.DatumKind} target={datum.Target}"),
+ Step242TextWriter.Ref(shapeId),
+ Step242TextWriter.Enum("FALSE"));
+
+ writer.AddEntity(
+ "PROPERTY_DEFINITION",
+ Step242TextWriter.String($"datum:{datum.Label}:{datum.FeatureId}"),
+ Step242TextWriter.String($"semantic datum {datum.DatumKind}"),
+ Step242TextWriter.Ref(aspectId));
+ }
+
+ private static void EmitNoteSemanticPmi(
+ Step242TextWriter writer,
+ string shapeId,
+ Step242SemanticPmiNote note)
+ {
+ var aspectId = writer.AddEntity(
+ "SHAPE_ASPECT",
+ Step242TextWriter.String($"firmament-note:{note.FeatureId}"),
+ Step242TextWriter.String($"semantic note target={note.Target}"),
+ Step242TextWriter.Ref(shapeId),
+ Step242TextWriter.Enum("FALSE"));
+
+ writer.AddEntity(
+ "PROPERTY_DEFINITION",
+ Step242TextWriter.String($"note:{note.FeatureId}"),
+ Step242TextWriter.String(note.Text),
+ Step242TextWriter.Ref(aspectId));
+ }
+
private static string BuildPlane(Step242TextWriter writer, PlaneSurface plane)
{
var originId = writer.AddEntity("CARTESIAN_POINT", "$", Step242TextWriter.List(Step242TextWriter.Number(plane.Origin.X), Step242TextWriter.Number(plane.Origin.Y), Step242TextWriter.Number(plane.Origin.Z)));
diff --git a/Aetheris.Kernel.Core/Step242/Step242SemanticPmi.cs b/Aetheris.Kernel.Core/Step242/Step242SemanticPmi.cs
index 8e3c3e71..d82b0f01 100644
--- a/Aetheris.Kernel.Core/Step242/Step242SemanticPmi.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242SemanticPmi.cs
@@ -1,5 +1,22 @@
namespace Aetheris.Kernel.Core.Step242;
-public sealed record Step242SemanticPmiDiameter(
+public abstract record Step242SemanticPmi(string FeatureId);
+
+public sealed record Step242SemanticPmiHole(
+ string FeatureId,
+ double Diameter,
+ double? Depth,
+ string? HoleFamily,
+ double? TolerancePlus,
+ double? ToleranceMinus) : Step242SemanticPmi(FeatureId);
+
+public sealed record Step242SemanticPmiDatum(
+ string FeatureId,
+ string DatumKind,
+ string Label,
+ string Target) : Step242SemanticPmi(FeatureId);
+
+public sealed record Step242SemanticPmiNote(
string FeatureId,
- double Diameter);
+ string Target,
+ string Text) : Step242SemanticPmi(FeatureId);
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs
index 450e2199..c3ea75c9 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs
@@ -338,7 +338,7 @@ public sealed class FirmamentFormatterTests
document.Model.Name,
document.Model.Units,
document.Schema is null ? null : CreateSchemaSnapshot(document.Schema),
- document.HasPmi,
+ document.Pmi is not null,
document.Ops.Entries.Select(CreateOpSnapshot).ToArray());
}
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPmiTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPmiTests.cs
new file mode 100644
index 00000000..a4683641
--- /dev/null
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPmiTests.cs
@@ -0,0 +1,56 @@
+using Aetheris.Kernel.Core.Diagnostics;
+using Aetheris.Kernel.Core.Results;
+
+namespace Aetheris.Kernel.Firmament.Tests;
+
+public sealed class FirmamentPmiTests
+{
+ [Fact]
+ public void Compile_And_Export_M7_BaselinePmiFixture_Succeeds_With_Structured_Semantic_Entities()
+ {
+ var compile = CompileFixture("testdata/firmament/examples/m7_semantic_pmi_baseline.firmament");
+ Assert.True(compile.Compilation.IsSuccess);
+ Assert.NotNull(compile.Compilation.Value.ParsedDocument?.Pmi);
+ Assert.Equal(3, compile.Compilation.Value.ParsedDocument!.Pmi!.Entries.Count);
+
+ var export = ExportFixture("testdata/firmament/examples/m7_semantic_pmi_baseline.firmament");
+ Assert.True(export.IsSuccess);
+ Assert.Contains("firmament-feature:main_hole", export.Value.StepText, StringComparison.Ordinal);
+ Assert.Contains("MEASURE_REPRESENTATION_ITEM('diameter',10,#", export.Value.StepText, StringComparison.Ordinal);
+ Assert.Contains("firmament-datum:A", export.Value.StepText, StringComparison.Ordinal);
+ Assert.Contains("semantic note target=main_hole", export.Value.StepText, StringComparison.Ordinal);
+ Assert.DoesNotContain("DRAUGHTING_CALLOUT", export.Value.StepText, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void Compile_PmiDatumAxis_On_NonCylindrical_Target_IsRejected_With_Bounded_Diagnostic()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7e-invalid-pmi-unsupported-target-kind.firmament");
+ Assert.False(result.Compilation.IsSuccess);
+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);
+ Assert.Equal(KernelDiagnosticCode.ValidationFailed, diagnostic.Code);
+ Assert.Contains("datum_kind 'axis' target 'base' to come from a cylindrical primitive/feature", diagnostic.Message, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void Compile_PmiTarget_UnknownSelectorRoot_IsRejected()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7e-invalid-pmi-unresolved-target.firmament");
+ Assert.False(result.Compilation.IsSuccess);
+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);
+ Assert.Contains("unknown selector root feature 'missing'", diagnostic.Message, StringComparison.Ordinal);
+ }
+
+ private static FirmamentCompileResult CompileFixture(string fixturePath)
+ {
+ var sourceText = FirmamentCorpusHarness.ReadFixtureText(fixturePath);
+ var compiler = new FirmamentCompiler();
+ return compiler.Compile(new FirmamentCompileRequest(new FirmamentSourceDocument(sourceText)));
+ }
+
+ private static KernelResult<FirmamentStepExportResult> ExportFixture(string fixturePath)
+ {
+ var sourceText = FirmamentCorpusHarness.ReadFixtureText(fixturePath);
+ return FirmamentStepExporter.Export(new FirmamentCompileRequest(new FirmamentSourceDocument(sourceText)));
+ }
+}
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentValidationExecutionTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentValidationExecutionTests.cs
index d18253a3..2cda9f88 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentValidationExecutionTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentValidationExecutionTests.cs
@@ -321,7 +321,7 @@ ops[2]:
ClassifiedFields: new Dictionary<string, string>(StringComparer.Ordinal) { ["targetShape"] = "FeatureId" })
]),
Schema: null,
- HasPmi: false);
+ Pmi: null);
var executionResult = new FirmamentPrimitiveExecutionResult(
ExecutedPrimitives:
diff --git a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
index 7fccfd28..b74bc5bf 100644
--- a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
@@ -69,6 +69,13 @@ public sealed class FirmamentCompiler
KernelResult<FirmamentCompilationArtifact>.Failure(documentCoherenceValidationResult.Diagnostics));
}
+ var pmiValidationResult = FirmamentPmiValidator.Validate(documentCoherenceValidationResult.Value);
+ if (!pmiValidationResult.IsSuccess)
+ {
+ return new FirmamentCompileResult(
+ KernelResult<FirmamentCompilationArtifact>.Failure(pmiValidationResult.Diagnostics));
+ }
+
var validatedDocument = documentCoherenceValidationResult.Value;
var compiledSchema = FirmamentCompiledSchemaMapper.Map(validatedDocument.Schema);
diff --git a/Aetheris.Kernel.Firmament/FirmamentStepExporter.cs b/Aetheris.Kernel.Firmament/FirmamentStepExporter.cs
index 3112c557..f76261b9 100644
--- a/Aetheris.Kernel.Firmament/FirmamentStepExporter.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentStepExporter.cs
@@ -5,6 +5,8 @@ using Aetheris.Kernel.Core.Step242;
using Aetheris.Kernel.Firmament.Diagnostics;
using Aetheris.Kernel.Firmament.Execution;
using Aetheris.Kernel.Firmament.Lowering;
+using Aetheris.Kernel.Firmament.ParsedModel;
+using Aetheris.Kernel.Firmament.Validation;
namespace Aetheris.Kernel.Firmament;
@@ -37,7 +39,7 @@ public static class FirmamentStepExporter
return KernelResult<FirmamentStepExportResult>.Failure(selectionResult.Diagnostics);
}
- var semanticPmi = DeriveSemanticPmi(artifact.PrimitiveLoweringPlan, selectionResult.Value);
+ var semanticPmi = DeriveSemanticPmi(artifact.ParsedDocument, artifact.PrimitiveLoweringPlan, artifact.PrimitiveExecutionResult, selectionResult.Value);
var stepResult = Step242Exporter.ExportBody(selectionResult.Value.Body, semanticPmi);
if (!stepResult.IsSuccess)
{
@@ -114,10 +116,18 @@ public static class FirmamentStepExporter
private const string ExportBodyCategoryPrimitive = "primitive";
private const string ExportBodyCategoryBoolean = "boolean";
- private static IReadOnlyList<Step242SemanticPmiDiameter> DeriveSemanticPmi(
+ private static IReadOnlyList<Step242SemanticPmi> DeriveSemanticPmi(
+ FirmamentParsedDocument? parsedDocument,
FirmamentPrimitiveLoweringPlan? loweringPlan,
+ FirmamentPrimitiveExecutionResult? executionResult,
ExportBodySelection selection)
{
+ var explicitPmi = DeriveExplicitPmi(parsedDocument, executionResult);
+ if (explicitPmi.Count > 0)
+ {
+ return explicitPmi;
+ }
+
if (loweringPlan is null
|| !string.Equals(selection.BodyCategory, ExportBodyCategoryBoolean, StringComparison.Ordinal)
|| !string.Equals(selection.FeatureKind, "subtract", StringComparison.Ordinal))
@@ -127,7 +137,7 @@ public static class FirmamentStepExporter
var booleansByFeatureId = loweringPlan.Booleans.ToDictionary(boolean => boolean.FeatureId, StringComparer.Ordinal);
var currentFeatureId = selection.FeatureId;
- var derived = new List<(int OpIndex, Step242SemanticPmiDiameter Item)>();
+ var derived = new List<(int OpIndex, Step242SemanticPmiHole Item)>();
while (booleansByFeatureId.TryGetValue(currentFeatureId, out var boolean)
&& boolean.Kind == FirmamentLoweredBooleanKind.Subtract)
@@ -137,7 +147,7 @@ public static class FirmamentStepExporter
&& !string.IsNullOrWhiteSpace(radiusRaw))
{
var radius = FirmamentPrimitiveToolParsing.ParseScalar(radiusRaw);
- derived.Add((boolean.OpIndex, new Step242SemanticPmiDiameter(boolean.FeatureId, radius * 2d)));
+ derived.Add((boolean.OpIndex, new Step242SemanticPmiHole(boolean.FeatureId, radius * 2d, null, "through_or_blind_cylindrical", null, null)));
}
currentFeatureId = boolean.PrimaryReferenceFeatureId;
@@ -149,6 +159,99 @@ public static class FirmamentStepExporter
.ToArray();
}
+ private static IReadOnlyList<Step242SemanticPmi> DeriveExplicitPmi(
+ FirmamentParsedDocument? parsedDocument,
+ FirmamentPrimitiveExecutionResult? executionResult)
+ {
+ if (parsedDocument?.Pmi is null || parsedDocument.Pmi.Entries.Count == 0 || executionResult is null)
+ {
+ return [];
+ }
+
+ var featureBodies = BuildFeatureBodyMap(executionResult);
+ var resolved = new List<Step242SemanticPmi>();
+
+ foreach (var entry in parsedDocument.Pmi.Entries)
+ {
+ if (!entry.RawFields.TryGetValue("target", out var targetRaw))
+ {
+ continue;
+ }
+
+ var featureId = targetRaw.Contains('.', StringComparison.Ordinal)
+ ? targetRaw[..targetRaw.IndexOf('.', StringComparison.Ordinal)]
+ : targetRaw;
+
+ switch (entry.Kind)
+ {
+ case FirmamentParsedPmiKind.Hole:
+ if (entry.RawFields.TryGetValue("diameter", out var diameterRaw)
+ && double.TryParse(diameterRaw, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var diameter))
+ {
+ double? depth = null;
+ if (entry.RawFields.TryGetValue("depth", out var depthRaw)
+ && double.TryParse(depthRaw, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var parsedDepth))
+ {
+ depth = parsedDepth;
+ }
+
+ resolved.Add(new Step242SemanticPmiHole(
+ featureId,
+ diameter,
+ depth,
+ entry.RawFields.TryGetValue("hole_family", out var familyRaw) ? familyRaw : null,
+ entry.RawFields.TryGetValue("tol_plus", out var tolPlusRaw) && double.TryParse(tolPlusRaw, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var tolPlus) ? tolPlus : null,
+ entry.RawFields.TryGetValue("tol_minus", out var tolMinusRaw) && double.TryParse(tolMinusRaw, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var tolMinus) ? tolMinus : null));
+ }
+
+ break;
+ case FirmamentParsedPmiKind.Datum:
+ if (entry.RawFields.TryGetValue("datum_kind", out var datumKind)
+ && entry.RawFields.TryGetValue("label", out var label))
+ {
+ resolved.Add(new Step242SemanticPmiDatum(featureId, datumKind, label, targetRaw));
+ }
+
+ break;
+ case FirmamentParsedPmiKind.Note:
+ if (entry.RawFields.TryGetValue("text", out var text))
+ {
+ if (FirmamentValidationTargetClassifier.TryClassify(targetRaw, out var targetShape)
+ && targetShape == FirmamentValidationTargetShape.SelectorShaped)
+ {
+ if (FirmamentSelectorResolver.TryResolve(targetRaw, featureBodies, FirmamentSelectorResultKind.Face, out var selectorResolution)
+ && selectorResolution.Count == 0)
+ {
+ continue;
+ }
+ }
+
+ resolved.Add(new Step242SemanticPmiNote(featureId, targetRaw, text));
+ }
+
+ break;
+ }
+ }
+
+ return resolved;
+ }
+
+ private static IReadOnlyDictionary<string, BrepBody> BuildFeatureBodyMap(FirmamentPrimitiveExecutionResult executionResult)
+ {
+ var map = new Dictionary<string, BrepBody>(StringComparer.Ordinal);
+ foreach (var primitive in executionResult.ExecutedPrimitives)
+ {
+ map[primitive.FeatureId] = primitive.Body;
+ }
+
+ foreach (var boolean in executionResult.ExecutedBooleans)
+ {
+ map[boolean.FeatureId] = boolean.Body;
+ }
+
+ return map;
+ }
+
private sealed record ExportBodySelection(
int OpIndex,
string FeatureId,
diff --git a/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs b/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs
index f9bd6569..0829e98f 100644
--- a/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs
+++ b/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs
@@ -27,10 +27,10 @@ internal static class FirmamentCanonicalFormatter
builder.AppendLine();
AppendOpsSection(builder, document.Ops);
- if (document.HasPmi)
+ if (document.Pmi is not null)
{
builder.AppendLine();
- builder.Append("pmi[0]:\n");
+ AppendPmiSection(builder, document.Pmi);
}
return builder.ToString();
@@ -107,6 +107,24 @@ internal static class FirmamentCanonicalFormatter
}
}
+ private static void AppendPmiSection(StringBuilder builder, FirmamentParsedPmiSection pmi)
+ {
+ builder.Append("pmi[").Append(pmi.Entries.Count.ToString(CultureInfo.InvariantCulture)).Append("]:\n");
+ for (var index = 0; index < pmi.Entries.Count; index++)
+ {
+ if (index > 0)
+ {
+ builder.AppendLine();
+ }
+
+ builder.Append(Indent(1)).Append("-\n");
+ foreach (var field in pmi.Entries[index].RawFields.OrderBy(kvp => kvp.Key, StringComparer.Ordinal))
+ {
+ AppendScalarField(builder, 2, field.Key, field.Value);
+ }
+ }
+ }
+
private static void AppendOpEntry(StringBuilder builder, FirmamentParsedOpEntry entry, int indentLevel)
{
var emitted = new HashSet<string>(StringComparer.Ordinal);
diff --git a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedDocument.cs b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedDocument.cs
index 00518fae..a27b18ce 100644
--- a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedDocument.cs
+++ b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedDocument.cs
@@ -5,7 +5,7 @@ public sealed record FirmamentParsedDocument(
FirmamentParsedModelHeader Model,
FirmamentParsedOpsSection Ops,
FirmamentParsedSchema? Schema,
- bool HasPmi);
+ FirmamentParsedPmiSection? Pmi);
public sealed record FirmamentParsedHeader(string Version);
diff --git a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedPmi.cs b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedPmi.cs
new file mode 100644
index 00000000..0b58017e
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedPmi.cs
@@ -0,0 +1,18 @@
+namespace Aetheris.Kernel.Firmament.ParsedModel;
+
+public sealed record FirmamentParsedPmiSection(
+ bool IsPresent,
+ IReadOnlyList<FirmamentParsedPmiEntry> Entries);
+
+public sealed record FirmamentParsedPmiEntry(
+ string KindRaw,
+ FirmamentParsedPmiKind Kind,
+ IReadOnlyDictionary<string, string> RawFields);
+
+public enum FirmamentParsedPmiKind
+{
+ Unknown = 0,
+ Hole = 1,
+ Datum = 2,
+ Note = 3
+}
diff --git a/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs b/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs
index f11aad8e..e07276e0 100644
--- a/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs
+++ b/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs
@@ -126,6 +126,11 @@ internal static class FirmamentTopLevelParser
}
var parsedSchema = ParseSchemaFromJsonRoot(root);
+ var parsedPmiResult = ParsePmiFromJsonRoot(root);
+ if (!parsedPmiResult.IsSuccess)
+ {
+ return KernelResult<FirmamentParsedDocument>.Failure(parsedPmiResult.Diagnostics);
+ }
return KernelResult<FirmamentParsedDocument>.Success(
new FirmamentParsedDocument(
@@ -133,7 +138,7 @@ internal static class FirmamentTopLevelParser
new FirmamentParsedModelHeader(nameElement.ToString(), unitsElement.ToString()),
new FirmamentParsedOpsSection(parsedOpsResult.Value),
Schema: parsedSchema,
- HasPmi: root.TryGetProperty("pmi", out _)));
+ Pmi: parsedPmiResult.Value));
}
private static KernelResult<FirmamentParsedDocument> ParseFromToon(FirmamentToonTopLevel toon)
@@ -206,6 +211,11 @@ internal static class FirmamentTopLevelParser
}
var parsedSchema = ParseSchemaFromToonSections(toon.Sections);
+ var parsedPmiResult = ParsePmiFromToonSections(toon.Sections);
+ if (!parsedPmiResult.IsSuccess)
+ {
+ return KernelResult<FirmamentParsedDocument>.Failure(parsedPmiResult.Diagnostics);
+ }
return KernelResult<FirmamentParsedDocument>.Success(
new FirmamentParsedDocument(
@@ -213,7 +223,7 @@ internal static class FirmamentTopLevelParser
new FirmamentParsedModelHeader(name, units),
new FirmamentParsedOpsSection(parsedOpsResult.Value),
Schema: parsedSchema,
- HasPmi: toon.Sections.ContainsKey("pmi")));
+ Pmi: parsedPmiResult.Value));
}
private static KernelResult<IReadOnlyList<FirmamentParsedOpEntry>> ParseJsonOpsEntries(JsonElement opsSection)
@@ -696,6 +706,131 @@ internal static class FirmamentTopLevelParser
};
}
+ private static KernelResult<FirmamentParsedPmiSection?> ParsePmiFromJsonRoot(JsonElement root)
+ {
+ if (!root.TryGetProperty("pmi", out var pmiSection))
+ {
+ return KernelResult<FirmamentParsedPmiSection?>.Success(null);
+ }
+
+ if (pmiSection.ValueKind != JsonValueKind.Array)
+ {
+ return KernelResult<FirmamentParsedPmiSection?>.Failure([
+ CreateDiagnostic(
+ KernelDiagnosticCode.ValidationFailed,
+ FirmamentDiagnosticCodes.StructureInvalidSectionShape,
+ "Section 'pmi' must be an array.")
+ ]);
+ }
+
+ var parseEntries = ParsePmiJsonEntries(pmiSection);
+ if (!parseEntries.IsSuccess)
+ {
+ return KernelResult<FirmamentParsedPmiSection?>.Failure(parseEntries.Diagnostics);
+ }
+
+ return KernelResult<FirmamentParsedPmiSection?>.Success(
+ new FirmamentParsedPmiSection(true, parseEntries.Value));
+ }
+
+ private static KernelResult<IReadOnlyList<FirmamentParsedPmiEntry>> ParsePmiJsonEntries(JsonElement pmiSection)
+ {
+ var entries = new List<FirmamentParsedPmiEntry>();
+ var index = 0;
+ foreach (var pmiElement in pmiSection.EnumerateArray())
+ {
+ if (pmiElement.ValueKind != JsonValueKind.Object)
+ {
+ return InvalidPmiEntryShape(index);
+ }
+
+ if (!pmiElement.TryGetProperty("kind", out var kindElement))
+ {
+ return MissingPmiField(index, "kind");
+ }
+
+ var kindRaw = kindElement.ToString().Trim();
+ if (string.IsNullOrWhiteSpace(kindRaw))
+ {
+ return InvalidPmiFieldValue(index, "kind", "expected non-empty scalar.");
+ }
+
+ var rawFields = new Dictionary<string, string>(StringComparer.Ordinal);
+ foreach (var property in pmiElement.EnumerateObject())
+ {
+ rawFields[property.Name] = property.Value.ToString();
+ }
+
+ entries.Add(new FirmamentParsedPmiEntry(kindRaw, ParsePmiKind(kindRaw), rawFields));
+ index++;
+ }
+
+ return KernelResult<IReadOnlyList<FirmamentParsedPmiEntry>>.Success(entries);
+ }
+
+ private static KernelResult<FirmamentParsedPmiSection?> ParsePmiFromToonSections(IReadOnlyDictionary<string, FirmamentToonSection> sections)
+ {
+ if (!sections.TryGetValue("pmi", out var pmiSection))
+ {
+ return KernelResult<FirmamentParsedPmiSection?>.Success(null);
+ }
+
+ if (!pmiSection.IsArrayLike)
+ {
+ return KernelResult<FirmamentParsedPmiSection?>.Failure([
+ CreateDiagnostic(
+ KernelDiagnosticCode.ValidationFailed,
+ FirmamentDiagnosticCodes.StructureInvalidSectionShape,
+ "Section 'pmi' must be an array.")
+ ]);
+ }
+
+ var parseEntries = ParsePmiToonEntries(pmiSection);
+ if (!parseEntries.IsSuccess)
+ {
+ return KernelResult<FirmamentParsedPmiSection?>.Failure(parseEntries.Diagnostics);
+ }
+
+ return KernelResult<FirmamentParsedPmiSection?>.Success(
+ new FirmamentParsedPmiSection(true, parseEntries.Value));
+ }
+
+ private static KernelResult<IReadOnlyList<FirmamentParsedPmiEntry>> ParsePmiToonEntries(FirmamentToonSection pmiSection)
+ {
+ var entries = new List<FirmamentParsedPmiEntry>();
+ for (var index = 0; index < pmiSection.ArrayEntries.Count; index++)
+ {
+ var entry = pmiSection.ArrayEntries[index];
+ if (!entry.IsObjectLike)
+ {
+ return InvalidPmiEntryShape(index);
+ }
+
+ if (!entry.Fields.TryGetValue("kind", out var kindRaw)
+ || string.IsNullOrWhiteSpace(kindRaw))
+ {
+ return MissingPmiField(index, "kind");
+ }
+
+ var normalizedKind = kindRaw.Trim();
+ entries.Add(new FirmamentParsedPmiEntry(
+ normalizedKind,
+ ParsePmiKind(normalizedKind),
+ new Dictionary<string, string>(entry.Fields, StringComparer.Ordinal)));
+ }
+
+ return KernelResult<IReadOnlyList<FirmamentParsedPmiEntry>>.Success(entries);
+ }
+
+ private static FirmamentParsedPmiKind ParsePmiKind(string raw) =>
+ raw switch
+ {
+ "hole" => FirmamentParsedPmiKind.Hole,
+ "datum" => FirmamentParsedPmiKind.Datum,
+ "note" => FirmamentParsedPmiKind.Note,
+ _ => FirmamentParsedPmiKind.Unknown
+ };
+
private static bool TryParseStructuredFields(string raw, out IReadOnlyDictionary<string, string> fields)
{
fields = new Dictionary<string, string>(StringComparer.Ordinal);
@@ -1044,7 +1179,34 @@ internal static class FirmamentTopLevelParser
CreateDiagnostic(
KernelDiagnosticCode.ValidationFailed,
FirmamentDiagnosticCodes.StructureUnknownOpKind,
- $"Operation entry at index {index} has unknown op kind '{opName}'.")
+ $"Operation entry at index {index} has unknown op kind '{opName}'.")
+ ]);
+
+ private static KernelResult<IReadOnlyList<FirmamentParsedPmiEntry>> InvalidPmiEntryShape(int index) =>
+ KernelResult<IReadOnlyList<FirmamentParsedPmiEntry>>.Failure(
+ [
+ CreateDiagnostic(
+ KernelDiagnosticCode.ValidationFailed,
+ FirmamentDiagnosticCodes.StructureInvalidSectionShape,
+ $"PMI entry at index {index} must be an object with fields.")
+ ]);
+
+ private static KernelResult<IReadOnlyList<FirmamentParsedPmiEntry>> MissingPmiField(int index, string fieldName) =>
+ KernelResult<IReadOnlyList<FirmamentParsedPmiEntry>>.Failure(
+ [
+ CreateDiagnostic(
+ KernelDiagnosticCode.ValidationFailed,
+ FirmamentDiagnosticCodes.StructureMissingRequiredField,
+ $"PMI entry at index {index} is missing required field '{fieldName}'.")
+ ]);
+
+ private static KernelResult<IReadOnlyList<FirmamentParsedPmiEntry>> InvalidPmiFieldValue(int index, string fieldName, string expectation) =>
+ KernelResult<IReadOnlyList<FirmamentParsedPmiEntry>>.Failure(
+ [
+ CreateDiagnostic(
+ KernelDiagnosticCode.ValidationFailed,
+ FirmamentDiagnosticCodes.StructureInvalidSectionShape,
+ $"PMI entry at index {index} has invalid field '{fieldName}'; {expectation}")
]);
private static KernelDiagnostic CreateDiagnostic(KernelDiagnosticCode kernelCode, FirmamentDiagnosticCode firmamentCode, string message) =>
diff --git a/Aetheris.Kernel.Firmament/Validation/FirmamentPmiValidator.cs b/Aetheris.Kernel.Firmament/Validation/FirmamentPmiValidator.cs
new file mode 100644
index 00000000..441a983e
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentPmiValidator.cs
@@ -0,0 +1,239 @@
+using System.Globalization;
+using Aetheris.Kernel.Core.Diagnostics;
+using Aetheris.Kernel.Core.Results;
+using Aetheris.Kernel.Firmament.Diagnostics;
+using Aetheris.Kernel.Firmament.ParsedModel;
+
+namespace Aetheris.Kernel.Firmament.Validation;
+
+internal static class FirmamentPmiValidator
+{
+ public static KernelResult<bool> Validate(FirmamentParsedDocument parsedDocument)
+ {
+ ArgumentNullException.ThrowIfNull(parsedDocument);
+
+ if (parsedDocument.Pmi is null)
+ {
+ return KernelResult<bool>.Success(true);
+ }
+
+ var opsByFeatureId = parsedDocument.Ops.Entries
+ .Where(entry => entry.RawFields.TryGetValue("id", out _))
+ .ToDictionary(entry => entry.RawFields["id"], StringComparer.Ordinal);
+
+ for (var index = 0; index < parsedDocument.Pmi.Entries.Count; index++)
+ {
+ var entry = parsedDocument.Pmi.Entries[index];
+ var result = entry.Kind switch
+ {
+ FirmamentParsedPmiKind.Hole => ValidateHole(entry, index, opsByFeatureId),
+ FirmamentParsedPmiKind.Datum => ValidateDatum(entry, index, opsByFeatureId),
+ FirmamentParsedPmiKind.Note => ValidateNote(entry, index, opsByFeatureId),
+ _ => Fail($"PMI entry at index {index} has unsupported kind '{entry.KindRaw}'. Supported kinds: hole, datum, note.")
+ };
+
+ if (!result.IsSuccess)
+ {
+ return result;
+ }
+ }
+
+ return KernelResult<bool>.Success(true);
+ }
+
+ private static KernelResult<bool> ValidateHole(FirmamentParsedPmiEntry entry, int index, IReadOnlyDictionary<string, FirmamentParsedOpEntry> opsByFeatureId)
+ {
+ var targetResult = RequireTarget(entry, index, allowSelectorShaped: false, opsByFeatureId);
+ if (!targetResult.IsSuccess)
+ {
+ return KernelResult<bool>.Failure(targetResult.Diagnostics);
+ }
+
+ var targetFeature = targetResult.Value;
+ if (!opsByFeatureId.TryGetValue(targetFeature, out var targetOp)
+ || targetOp.KnownKind != FirmamentKnownOpKind.Subtract
+ || !targetOp.RawFields.TryGetValue("with", out var toolRaw)
+ || !IsCylinderToolShape(toolRaw))
+ {
+ return Fail($"PMI hole entry at index {index} requires target feature '{targetFeature}' to be a subtract boolean with a cylinder tool (bounded hole family).");
+ }
+
+ if (!entry.RawFields.TryGetValue("diameter", out var diameterRaw)
+ || !double.TryParse(diameterRaw, NumberStyles.Float, CultureInfo.InvariantCulture, out var diameter)
+ || diameter <= 0d)
+ {
+ return Fail($"PMI hole entry at index {index} must declare positive numeric 'diameter'.");
+ }
+
+ if (entry.RawFields.TryGetValue("depth", out var depthRaw)
+ && (!double.TryParse(depthRaw, NumberStyles.Float, CultureInfo.InvariantCulture, out var depth) || depth <= 0d))
+ {
+ return Fail($"PMI hole entry at index {index} has invalid 'depth'; expected positive numeric value when supplied.");
+ }
+
+ if (entry.RawFields.TryGetValue("tol_plus", out var tolPlusRaw)
+ && !double.TryParse(tolPlusRaw, NumberStyles.Float, CultureInfo.InvariantCulture, out _))
+ {
+ return Fail($"PMI hole entry at index {index} has invalid 'tol_plus'; expected numeric value.");
+ }
+
+ if (entry.RawFields.TryGetValue("tol_minus", out var tolMinusRaw)
+ && !double.TryParse(tolMinusRaw, NumberStyles.Float, CultureInfo.InvariantCulture, out _))
+ {
+ return Fail($"PMI hole entry at index {index} has invalid 'tol_minus'; expected numeric value.");
+ }
+
+ return KernelResult<bool>.Success(true);
+ }
+
+ private static KernelResult<bool> ValidateDatum(FirmamentParsedPmiEntry entry, int index, IReadOnlyDictionary<string, FirmamentParsedOpEntry> opsByFeatureId)
+ {
+ if (!entry.RawFields.TryGetValue("datum_kind", out var datumKind)
+ || string.IsNullOrWhiteSpace(datumKind))
+ {
+ return Fail($"PMI datum entry at index {index} is missing required field 'datum_kind' (supported: plane, axis).");
+ }
+
+ if (!entry.RawFields.TryGetValue("label", out var label)
+ || string.IsNullOrWhiteSpace(label))
+ {
+ return Fail($"PMI datum entry at index {index} is missing required field 'label'.");
+ }
+
+ if (string.Equals(datumKind, "plane", StringComparison.Ordinal))
+ {
+ var selectorResult = RequireSelectorTarget(entry, index, opsByFeatureId);
+ if (!selectorResult.IsSuccess)
+ {
+ return KernelResult<bool>.Failure(selectorResult.Diagnostics);
+ }
+
+ var rootKind = opsByFeatureId[selectorResult.Value.FeatureId].KnownKind;
+ if (!FirmamentSelectorContracts.TryGetPortContract(rootKind, selectorResult.Value.Port, out var contract)
+ || contract.ResultKind is not (FirmamentSelectorResultKind.Face or FirmamentSelectorResultKind.FaceSet))
+ {
+ return Fail($"PMI datum entry at index {index} requires a planar-face selector target for datum_kind 'plane'.");
+ }
+
+ return KernelResult<bool>.Success(true);
+ }
+
+ if (string.Equals(datumKind, "axis", StringComparison.Ordinal))
+ {
+ var featureResult = RequireTarget(entry, index, allowSelectorShaped: false, opsByFeatureId);
+ if (!featureResult.IsSuccess)
+ {
+ return KernelResult<bool>.Failure(featureResult.Diagnostics);
+ }
+
+ var featureId = featureResult.Value;
+ var targetOp = opsByFeatureId[featureId];
+ var isSupportedAxisSource = targetOp.KnownKind == FirmamentKnownOpKind.Cylinder
+ || (targetOp.KnownKind == FirmamentKnownOpKind.Subtract
+ && targetOp.RawFields.TryGetValue("with", out var toolRaw)
+ && IsCylinderToolShape(toolRaw));
+
+ if (!isSupportedAxisSource)
+ {
+ return Fail($"PMI datum entry at index {index} requires datum_kind 'axis' target '{featureId}' to come from a cylindrical primitive/feature.");
+ }
+
+ return KernelResult<bool>.Success(true);
+ }
+
+ return Fail($"PMI datum entry at index {index} has unsupported datum_kind '{datumKind}'. Supported: plane, axis.");
+ }
+
+ private static KernelResult<bool> ValidateNote(FirmamentParsedPmiEntry entry, int index, IReadOnlyDictionary<string, FirmamentParsedOpEntry> opsByFeatureId)
+ {
+ if (!entry.RawFields.TryGetValue("text", out var text)
+ || string.IsNullOrWhiteSpace(text))
+ {
+ return Fail($"PMI note entry at index {index} is missing required field 'text'.");
+ }
+
+ var targetResult = RequireTarget(entry, index, allowSelectorShaped: true, opsByFeatureId);
+ if (!targetResult.IsSuccess)
+ {
+ return KernelResult<bool>.Failure(targetResult.Diagnostics);
+ }
+
+ return KernelResult<bool>.Success(true);
+ }
+
+ private static KernelResult<string> RequireTarget(FirmamentParsedPmiEntry entry, int index, bool allowSelectorShaped, IReadOnlyDictionary<string, FirmamentParsedOpEntry> opsByFeatureId)
+ {
+ if (!entry.RawFields.TryGetValue("target", out var targetRaw)
+ || !FirmamentValidationTargetClassifier.TryClassify(targetRaw, out var targetShape))
+ {
+ return FailTarget($"PMI entry at index {index} has invalid or missing 'target'; expected feature id or selector-shaped target.");
+ }
+
+ if (!allowSelectorShaped && targetShape == FirmamentValidationTargetShape.SelectorShaped)
+ {
+ return FailTarget($"PMI entry at index {index} does not support selector-shaped target '{targetRaw}'.");
+ }
+
+ if (targetShape == FirmamentValidationTargetShape.FeatureId)
+ {
+ if (!opsByFeatureId.ContainsKey(targetRaw))
+ {
+ return FailTarget($"PMI entry at index {index} references unknown feature target '{targetRaw}'.");
+ }
+
+ return KernelResult<string>.Success(targetRaw);
+ }
+
+ var separatorIndex = targetRaw.IndexOf('.', StringComparison.Ordinal);
+ var featureId = targetRaw[..separatorIndex];
+ if (!opsByFeatureId.ContainsKey(featureId))
+ {
+ return FailTarget($"PMI entry at index {index} references unknown selector root feature '{featureId}'.");
+ }
+
+ return KernelResult<string>.Success(featureId);
+ }
+
+ private static KernelResult<(string FeatureId, string Port)> RequireSelectorTarget(FirmamentParsedPmiEntry entry, int index, IReadOnlyDictionary<string, FirmamentParsedOpEntry> opsByFeatureId)
+ {
+ if (!entry.RawFields.TryGetValue("target", out var targetRaw)
+ || !FirmamentValidationTargetClassifier.TryClassify(targetRaw, out var targetShape)
+ || targetShape != FirmamentValidationTargetShape.SelectorShaped)
+ {
+ return KernelResult<(string FeatureId, string Port)>.Failure([
+ CreateDiagnostic($"PMI datum entry at index {index} requires selector target shaped as 'feature.port'.")
+ ]);
+ }
+
+ var separatorIndex = targetRaw.IndexOf('.', StringComparison.Ordinal);
+ var featureId = targetRaw[..separatorIndex];
+ var port = targetRaw[(separatorIndex + 1)..];
+ if (!opsByFeatureId.ContainsKey(featureId))
+ {
+ return KernelResult<(string FeatureId, string Port)>.Failure([
+ CreateDiagnostic($"PMI datum entry at index {index} references unknown selector root feature '{featureId}'.")
+ ]);
+ }
+
+ return KernelResult<(string FeatureId, string Port)>.Success((featureId, port));
+ }
+
+ private static KernelResult<bool> Fail(string message) =>
+ KernelResult<bool>.Failure([CreateDiagnostic(message)]);
+
+ private static KernelResult<string> FailTarget(string message) =>
+ KernelResult<string>.Failure([CreateDiagnostic(message)]);
+
+ private static KernelDiagnostic CreateDiagnostic(string message) =>
+ new(
+ KernelDiagnosticCode.ValidationFailed,
+ KernelDiagnosticSeverity.Error,
+ $"[{FirmamentDiagnosticCodes.ValidationInvalidTargetShape.Value}] {message}",
+ FirmamentDiagnosticConventions.Source);
+
+ private static bool IsCylinderToolShape(string toolRaw)
+ {
+ var normalized = new string(toolRaw.Where(character => !char.IsWhiteSpace(character)).ToArray());
+ return normalized.Contains("op:cylinder", StringComparison.Ordinal);
+ }
+}
diff --git a/testdata/firmament/examples/m7_semantic_pmi_baseline.firmament b/testdata/firmament/examples/m7_semantic_pmi_baseline.firmament
new file mode 100644
index 00000000..219f698e
--- /dev/null
+++ b/testdata/firmament/examples/m7_semantic_pmi_baseline.firmament
@@ -0,0 +1,47 @@
+firmament:
+ version: 1
+
+model:
+ name: m7_semantic_pmi_baseline
+ units: mm
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 100
+ 60
+ 20
+
+ -
+ op: subtract
+ id: main_hole
+ from: base
+ with:
+ op: cylinder
+ radius: 5
+ height: 24
+ place:
+ on_face: base.top_face
+ centered_on: base.top_face
+
+pmi[3]:
+ -
+ kind: hole
+ target: main_hole
+ hole_family: through
+ diameter: 10
+ tol_plus: 0.1
+ tol_minus: -0.1
+
+ -
+ kind: datum
+ datum_kind: plane
+ label: A
+ target: base.top_face
+
+ -
+ kind: note
+ target: main_hole
+ text: deburr and break sharp edges
diff --git a/testdata/firmament/fixtures/m7e-invalid-pmi-unresolved-target.firmament b/testdata/firmament/fixtures/m7e-invalid-pmi-unresolved-target.firmament
new file mode 100644
index 00000000..4fd6babd
--- /dev/null
+++ b/testdata/firmament/fixtures/m7e-invalid-pmi-unresolved-target.firmament
@@ -0,0 +1,21 @@
+firmament:
+ version: 1
+
+model:
+ name: m7e_invalid_pmi_unresolved_target
+ units: mm
+
+ops[1]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 10
+ 10
+
+pmi[1]:
+ -
+ kind: note
+ target: missing.top_face
+ text: hello
diff --git a/testdata/firmament/fixtures/m7e-invalid-pmi-unsupported-target-kind.firmament b/testdata/firmament/fixtures/m7e-invalid-pmi-unsupported-target-kind.firmament
new file mode 100644
index 00000000..e0ec4ea1
--- /dev/null
+++ b/testdata/firmament/fixtures/m7e-invalid-pmi-unsupported-target-kind.firmament
@@ -0,0 +1,22 @@
+firmament:
+ version: 1
+
+model:
+ name: m7e_invalid_pmi_unsupported_target_kind
+ units: mm
+
+ops[1]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 10
+ 10
+
+pmi[1]:
+ -
+ kind: datum
+ datum_kind: axis
+ label: A
+ target: base