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.csindex 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 Step242ExporterTestsvar 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.csindex dd56b5f3..d7d2d539 100644--- a/Aetheris.Kernel.Core/Step242/Step242Exporter.cs+++ b/Aetheris.Kernel.Core/Step242/Step242Exporter.cs@@ -16,7 +16,7 @@ public static class Step242Exporterpublic 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 Step242Exporterstring 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.csindex 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.csindex 450e2199..c3ea75c9 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentFormatterTests.cs@@ -338,7 +338,7 @@ public sealed class FirmamentFormatterTestsdocument.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.csnew file mode 100644index 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.csindex 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.csindex 7fccfd28..b74bc5bf 100644--- a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs+++ b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs@@ -69,6 +69,13 @@ public sealed class FirmamentCompilerKernelResult<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.csindex 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 FirmamentStepExporterreturn 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 FirmamentStepExporterprivate 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 FirmamentStepExportervar 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.csindex f9bd6569..0829e98f 100644--- a/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs+++ b/Aetheris.Kernel.Firmament/Formatting/FirmamentCanonicalFormatter.cs@@ -27,10 +27,10 @@ internal static class FirmamentCanonicalFormatterbuilder.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.csindex 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.csnew file mode 100644index 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.csindex 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 FirmamentTopLevelParsernew 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 FirmamentTopLevelParsernew 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 FirmamentTopLevelParserCreateDiagnostic(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.csnew file mode 100644index 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.firmamentnew file mode 100644index 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 edgesdiff --git a/testdata/firmament/fixtures/m7e-invalid-pmi-unresolved-target.firmament b/testdata/firmament/fixtures/m7e-invalid-pmi-unresolved-target.firmamentnew file mode 100644index 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: hellodiff --git a/testdata/firmament/fixtures/m7e-invalid-pmi-unsupported-target-kind.firmament b/testdata/firmament/fixtures/m7e-invalid-pmi-unsupported-target-kind.firmamentnew file mode 100644index 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