Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add inline STEP recognition evidence proposals
Yuechen Li8c79110a9336
diff --git a/Aetheris.CLI/AirTrace.cs b/Aetheris.CLI/AirTrace.csindex 4690c956..6a60493f 100644--- a/Aetheris.CLI/AirTrace.cs+++ b/Aetheris.CLI/AirTrace.cs@@ -134,7 +134,7 @@ internal static class AirTraceReportBuilderif (isFirmamentV2 && string.Equals(fixture.ExpectedStage, "step-verified", StringComparison.Ordinal)){var featureArea = fixture.Metadata.GetValueOrDefault("feature-area");- var stepVerified = string.Equals(featureArea, "semantic-hole", StringComparison.Ordinal) || string.Equals(featureArea, "semantic-reference", StringComparison.Ordinal) || string.Equals(featureArea, "multi-feature-composition", StringComparison.Ordinal) || string.Equals(featureArea, "semantic-pmi", StringComparison.Ordinal)+ var stepVerified = string.Equals(featureArea, "semantic-hole", StringComparison.Ordinal) || string.Equals(featureArea, "semantic-reference", StringComparison.Ordinal) || string.Equals(featureArea, "multi-feature-composition", StringComparison.Ordinal) || string.Equals(featureArea, "semantic-pmi", StringComparison.Ordinal) || (featureArea?.StartsWith("inline-step", StringComparison.Ordinal) ?? false)? TryVerifyV2SemanticHoleStepFixture(fixture): TryVerifyV2BoxStepFixture(fixture);if (stepVerified.Succeeded)diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentV2InlineStepTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentV2InlineStepTests.csindex 9263d8bb..3cf82369 100644--- a/Aetheris.Kernel.Firmament.Tests/FirmamentV2InlineStepTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentV2InlineStepTests.cs@@ -156,6 +156,50 @@ model BadRecognitionTarget { units mm solid importedPart: InlineStep { path: "..}+ [Fact]+ public void InlineStep_RecognizedRegion_ParsesEvidenceAndSemanticProposalMetadataOnly()+ {+ var repo = FindRepoRoot();+ var fixturePath = Path.Combine(repo, "fixtures/FirmamentV2/InlineStep/valid/inline-step-v2-recognized-hole-proposal-report.valid.firmfixture");+ var parse = FirmamentV2Parser.Parse(File.ReadAllText(fixturePath), Path.GetDirectoryName(fixturePath));++ Assert.True(parse.IsSuccess, string.Join(Environment.NewLine, parse.Diagnostics));+ var region = Assert.Single(parse.Document!.RecognizedRegions!);+ Assert.Equal("holeShaft", region.Kind);+ Assert.Equal("#191", Assert.Single(region.FaceRefs));+ Assert.NotNull(region.Evidence);+ Assert.Equal("cylindrical", Assert.Single(region.Evidence!.SurfaceFamilies));+ Assert.Equal(1d, region.Evidence.Radius);+ Assert.Equal("+Z", region.Evidence.Axis);+ Assert.True(region.Evidence.Through);+ Assert.NotNull(region.Proposal);+ Assert.Equal("holeShaft", region.Proposal!.ProposalKind);+ Assert.Equal("mountHole", region.Proposal.FeatureName);+ Assert.Equal("importedPart.face(\"#51\")", region.Proposal.PlacementTarget);+ Assert.Equal(1d, region.Proposal.Radius);+ Assert.Equal("throughAll", region.Proposal.EndCondition);+ Assert.Empty(parse.Document.Replacements!);+ }++ [Theory]+ [InlineData("evidence { surfaceFamily: cylindrical radius: -1mm axis: +Z through: true }", FirmamentV2Parser.RecognitionEvidenceRadiusInvalid)]+ [InlineData("evidence { surfaceFamily: spline radius: 1mm axis: +Z through: true }", FirmamentV2Parser.RecognitionEvidenceSurfaceFamilyUnknown)]+ [InlineData("evidence { surfaceFamily: cylindrical radius: 1mm axis: north through: true }", FirmamentV2Parser.RecognitionEvidenceAxisInvalid)]+ [InlineData("proposes datumPlane { radius: 1mm end: throughAll }", FirmamentV2Parser.SemanticProposalKindMismatch)]+ [InlineData("proposes hole<shaft> { radius: -1mm end: throughAll }", FirmamentV2Parser.SemanticProposalRadiusInvalid)]+ [InlineData("proposes hole<shaft> { on: importedPart.face(\"#999999\") radius: 1mm end: throughAll }", FirmamentV2Parser.SemanticProposalTargetUnresolved)]+ [InlineData("proposes hole<shaft> { radius: 1mm end: blind }", FirmamentV2Parser.SemanticProposalEndUnsupported)]+ public void InlineStep_InvalidEvidenceOrProposal_RejectsDeterministically(string metadata, string diagnostic)+ {+ var source = $$"""+model BadRecognitionProposal { units mm solid importedPart: InlineStep { path: "../testdata/canonical-through-hole.step" } recognize importedPart { region mountHole { kind: hole<shaft> faces: ["#191"] confidence: high {{metadata}} } } }+""";+ var parse = FirmamentV2Parser.Parse(source, Path.Combine(FindRepoRoot(), "fixtures/FirmamentV2/InlineStep/valid"));++ Assert.False(parse.IsSuccess);+ Assert.Contains(diagnostic, parse.Diagnostics);+ }+[Fact]public void InlineStep_ReplacementDeclaration_ParsesAndReferencesRecognizedRegion(){@@ -239,6 +283,30 @@ model BadReplacement { units mm solid importedPart: InlineStep { path: "../testdAssert.Contains("residual-emitted", report.ReplacementStates);}+ [Fact]+ public void InlineStep_MigrationReport_RecognizedProposalCountsDoNotReplace()+ {+ var repo = FindRepoRoot();+ var fixturePath = Path.Combine(repo, "fixtures/FirmamentV2/InlineStep/valid/inline-step-v2-recognized-hole-proposal-report.valid.firmfixture");+ var parse = FirmamentV2Parser.Parse(File.ReadAllText(fixturePath), Path.GetDirectoryName(fixturePath));+ Assert.True(parse.IsSuccess, string.Join(Environment.NewLine, parse.Diagnostics));++ var report = InlineStepMigrationReportBuilder.Build(parse.Document!, parse.Document!.Solids.Single());++ Assert.Equal(7, report.OriginalTopology.FaceCount);+ Assert.Equal(1, report.Recognized.RegionCount);+ Assert.Equal(1, report.Recognized.EvidenceCount);+ Assert.Equal(1, report.Recognized.ProposalCount);+ Assert.Equal(0, report.Recognized.ProposalVerifiedCount);+ Assert.Equal(1, report.Recognized.ProposalUnverifiedCount);+ Assert.Equal(0, report.Replacements.PlannedCount);+ Assert.Equal(0, report.Replacements.VerifiedCount);+ Assert.Equal(0, report.Replacements.EmittedCount);+ Assert.Equal(7, report.Residual.ResidualFaceCount);+ Assert.Equal("canonical-reexport", report.EmissionStrategy);+ Assert.False(report.ResidualSurgery);+ }+[Fact]public void InlineStep_MigrationReport_VerifiedReplacementCountsReplacedFaces(){diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Ast.cs b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Ast.csindex dd68d777..f1b2f09a 100644--- a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Ast.cs+++ b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Ast.cs@@ -33,11 +33,14 @@ public sealed record ImportedStepTopologyMap(IReadOnlyDictionary<string, string>{public bool TryResolveFaceEntity(string entityRef, out string faceId) => FaceEntityToFaceId.TryGetValue(entityRef, out faceId!);}-public sealed record FirmamentV2RecognizedRegion(string BodyName, string RegionName, string Kind, IReadOnlyList<string> FaceRefs, string Confidence)+public sealed record FirmamentV2RecognizedRegion(string BodyName, string RegionName, string Kind, IReadOnlyList<string> FaceRefs, string Confidence, FirmamentV2RecognitionEvidence? Evidence = null, FirmamentV2SemanticProposal? Proposal = null){public string TargetSource => $"{BodyName}.region(\"{RegionName}\")";}+public sealed record FirmamentV2RecognitionEvidence(IReadOnlyList<string> SurfaceFamilies, double? Radius = null, string? Axis = null, FirmamentV2FaceLocalPoint2D? Center = null, bool? Through = null, IReadOnlyList<string>? Notes = null);+public sealed record FirmamentV2SemanticProposal(string ProposalKind, string FeatureName, string? PlacementTarget = null, FirmamentV2FaceLocalPoint2D? Center = null, double? Radius = null, string? EndCondition = null);+public sealed record FirmamentV2ReplacementDecl(string ImportedBodyName, string RecognizedRegionName, string ReplacementKind, string ReplacementFeatureName, string PlacementTarget, FirmamentV2FaceLocalPoint2D Center, double Radius, string EndCondition, IReadOnlyList<double> HostSize, string Source){public string TargetSource => $"{ImportedBodyName}.region(\"{RecognizedRegionName}\")";diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Parser.cs b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Parser.csindex 0ba6e37b..f0abc148 100644--- a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Parser.cs+++ b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Parser.cs@@ -100,6 +100,13 @@ public static class FirmamentV2Parserpublic const string ReplacementVerificationFailed = "firmament-inline-step-replacement-verification-failed";public const string ReplacementRadiusInvalid = "firmament-inline-step-replacement-radius-invalid";public const string ReplacementEndUnsupported = "firmament-inline-step-replacement-end-unsupported";+ public const string RecognitionEvidenceRadiusInvalid = "firmament-inline-step-recognition-evidence-radius-invalid";+ public const string RecognitionEvidenceSurfaceFamilyUnknown = "firmament-inline-step-recognition-evidence-surface-family-unknown";+ public const string RecognitionEvidenceAxisInvalid = "firmament-inline-step-recognition-evidence-axis-invalid";+ public const string SemanticProposalKindMismatch = "firmament-inline-step-semantic-proposal-kind-mismatch";+ public const string SemanticProposalRadiusInvalid = "firmament-inline-step-semantic-proposal-radius-invalid";+ public const string SemanticProposalTargetUnresolved = "firmament-inline-step-semantic-proposal-target-unresolved";+ public const string SemanticProposalEndUnsupported = "firmament-inline-step-semantic-proposal-end-unsupported";private static readonly Regex ModelRegex = new(@"\bmodel\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*\{", RegexOptions.CultureInvariant);private static readonly Regex UnitsRegex = new(@"\bunits\s+(?<units>[A-Za-z_][A-Za-z0-9_]*)\b", RegexOptions.CultureInvariant);@@ -123,6 +130,12 @@ public static class FirmamentV2Parserprivate static readonly Regex KindRegex = new("\\bkind\\s*:\\s*(?<kind>\"[^\"]+\"|[A-Za-z_][A-Za-z0-9_]*(?:\\s*<\\s*[A-Za-z_][A-Za-z0-9_]*\\s*>)?)", RegexOptions.CultureInvariant);private static readonly Regex FacesRegex = new(@"\bfaces\s*:\s*\[(?<faces>[^\]]*)\]", RegexOptions.CultureInvariant | RegexOptions.Singleline);private static readonly Regex ConfidenceRegex = new(@"\bconfidence\s*:\s*(?<confidence>[A-Za-z_][A-Za-z0-9_]*)", RegexOptions.CultureInvariant);+ private static readonly Regex EvidenceHeaderRegex = new(@"\bevidence\s*\{", RegexOptions.CultureInvariant);+ private static readonly Regex ProposalHeaderRegex = new(@"\bproposes\s+(?<kind>[A-Za-z_][A-Za-z0-9_]*(?:\s*<\s*[A-Za-z_][A-Za-z0-9_]*\s*>)?)\s*(?<name>[A-Za-z_][A-Za-z0-9_]*)?\s*\{", RegexOptions.CultureInvariant);+ private static readonly Regex SurfaceFamilyRegex = new(@"\bsurfaceFamily\s*:\s*(?<value>[A-Za-z_][A-Za-z0-9_]*)", RegexOptions.CultureInvariant);+ private static readonly Regex AxisRegex = new(@"\baxis\s*:\s*(?<value>[+-][XYZ])", RegexOptions.CultureInvariant);+ private static readonly Regex BooleanThroughRegex = new(@"\bthrough\s*:\s*(?<value>true|false)", RegexOptions.CultureInvariant);+ private static readonly Regex EndConditionRegex = new(@"\bend\s*:\s*(?<value>[A-Za-z_][A-Za-z0-9_]*)", RegexOptions.CultureInvariant);private static readonly Regex ReplaceHeaderRegex = new("\\breplace\\s+(?<target>[A-Za-z_][A-Za-z0-9_]*\\.region\\(\"[A-Za-z_][A-Za-z0-9_]*\"\\))\\s+with\\s+(?<kind>[A-Za-z_][A-Za-z0-9_]*(?:\\s*<\\s*[A-Za-z_][A-Za-z0-9_]*\\s*>)?)\\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\\s*\\{", RegexOptions.CultureInvariant);private static readonly Regex OnRegex = new("\\bon\\s*:\\s*(?<target>[A-Za-z_][A-Za-z0-9_]*\\.face\\(\"#[0-9]+\"\\)|face\\([^)]+\\)|[A-Za-z_][A-Za-z0-9_]*)", RegexOptions.CultureInvariant);private static readonly Regex HostSizeRegex = new(@"\bhostSize\s*:\s*\[(?<values>[^\]]*)\]", RegexOptions.CultureInvariant | RegexOptions.Singleline);@@ -303,7 +316,7 @@ public static class FirmamentV2Parserreturn new(name, "Box", new FirmamentV2BoxRecord(values, []), baseName, new Dictionary<string, IReadOnlyList<double>>(StringComparer.Ordinal) { ["size"] = values });}- private static bool IsFatalDiagnostic(string code) => code is PrimitiveFieldMissing or PrimitiveFieldUnknown or PrimitiveFieldInvalid or MissingModel or MissingUnits or MissingSolid or UnsupportedConstruct or UnknownRecordType or BoxMissingSize or BoxSizeArity or DegenerateDimension or NameUnresolved or DuplicateName or WithRequiresRecord or WithRequiresBoxRecord or WithFieldNotFound or WithFieldTypeMismatch or WithForwardReference or WithDerivedRecordInvalid or ExposeBlockUnsupported or ExposeRequiresBoxRecord or ExposeAliasDuplicate or ExposeAliasInvalid or SelectorUnsupported or SelectorAxisInvalid or SelectorSubselectorUnsupported or FatArrowOutsideExpose or RawBackendIdReferenceForbidden or ModifyTargetUnresolved or ModifyTargetNotSolid or RegionUnsupported or RegionAttachmentSelectorUnsupported or CutUnsupported or CutToolUnsupported or CylinderRadiusMissing or CylinderRadiusInvalid or CylinderRadiusNotFinite or ThroughSelectorUnsupported or AliasUnresolved or AliasRefTypeUnsupported or SideHoleAliasMustResolveToFace or SideHoleAliasResolvesToUnsupportedFace or SideHoleOnlyPlusXMinusXSupported or SideHoleRouteUnsupported or SideHoleSameFaceUnsupported or SideHoleAxisNotYetSupported or SideHoleRadiusExceedsClearance or CylinderCenterInvalid or CylinderCenterArityInvalid or CylinderCenterNotFinite or SideHoleCenterExceedsClearance or HoleVariantUnknown or HoleEntryFaceMissing or HoleCenterMissing or HoleShaftMissing or HoleEndMissing or HoleDiameterInvalid or HoleDepthInvalid or HoleCounterboreInvalid or HoleCountersinkInvalid or PmiKindUnknown or PmiTargetMissing or PmiTargetUnresolved or PmiDiameterInvalid or PmiDuplicateName or InlineStepUnknownBody or InlineStepUnknownFace or PmiImportedTargetNotFace or PmiImportedTargetRequiresCanonicalStep or PmiInvalidImportedTarget or InlineStepPathMissing or InlineStepPathInvalid or InlineStepFileMissing or InlineStepRequiresCanonical or UnknownRecognitionBody or UnknownRecognitionFace or DuplicateRegion or UnknownRecognitionRegion or InvalidRecognitionKind or InvalidRecognitionConfidence or PmiRecognizedRegionKindMismatch or UnknownReplacementBody or UnknownReplacementRegion or ReplacementKindMismatch or ReplacementFaceUnresolved or ReplacementUnsupportedKind or ReplacementVerificationFailed or ReplacementRadiusInvalid or ReplacementEndUnsupported;+ private static bool IsFatalDiagnostic(string code) => code is PrimitiveFieldMissing or PrimitiveFieldUnknown or PrimitiveFieldInvalid or MissingModel or MissingUnits or MissingSolid or UnsupportedConstruct or UnknownRecordType or BoxMissingSize or BoxSizeArity or DegenerateDimension or NameUnresolved or DuplicateName or WithRequiresRecord or WithRequiresBoxRecord or WithFieldNotFound or WithFieldTypeMismatch or WithForwardReference or WithDerivedRecordInvalid or ExposeBlockUnsupported or ExposeRequiresBoxRecord or ExposeAliasDuplicate or ExposeAliasInvalid or SelectorUnsupported or SelectorAxisInvalid or SelectorSubselectorUnsupported or FatArrowOutsideExpose or RawBackendIdReferenceForbidden or ModifyTargetUnresolved or ModifyTargetNotSolid or RegionUnsupported or RegionAttachmentSelectorUnsupported or CutUnsupported or CutToolUnsupported or CylinderRadiusMissing or CylinderRadiusInvalid or CylinderRadiusNotFinite or ThroughSelectorUnsupported or AliasUnresolved or AliasRefTypeUnsupported or SideHoleAliasMustResolveToFace or SideHoleAliasResolvesToUnsupportedFace or SideHoleOnlyPlusXMinusXSupported or SideHoleRouteUnsupported or SideHoleSameFaceUnsupported or SideHoleAxisNotYetSupported or SideHoleRadiusExceedsClearance or CylinderCenterInvalid or CylinderCenterArityInvalid or CylinderCenterNotFinite or SideHoleCenterExceedsClearance or HoleVariantUnknown or HoleEntryFaceMissing or HoleCenterMissing or HoleShaftMissing or HoleEndMissing or HoleDiameterInvalid or HoleDepthInvalid or HoleCounterboreInvalid or HoleCountersinkInvalid or PmiKindUnknown or PmiTargetMissing or PmiTargetUnresolved or PmiDiameterInvalid or PmiDuplicateName or InlineStepUnknownBody or InlineStepUnknownFace or PmiImportedTargetNotFace or PmiImportedTargetRequiresCanonicalStep or PmiInvalidImportedTarget or InlineStepPathMissing or InlineStepPathInvalid or InlineStepFileMissing or InlineStepRequiresCanonical or UnknownRecognitionBody or UnknownRecognitionFace or DuplicateRegion or UnknownRecognitionRegion or InvalidRecognitionKind or InvalidRecognitionConfidence or PmiRecognizedRegionKindMismatch or UnknownReplacementBody or UnknownReplacementRegion or ReplacementKindMismatch or ReplacementFaceUnresolved or ReplacementUnsupportedKind or ReplacementVerificationFailed or ReplacementRadiusInvalid or ReplacementEndUnsupported or RecognitionEvidenceRadiusInvalid or RecognitionEvidenceSurfaceFamilyUnknown or RecognitionEvidenceAxisInvalid or SemanticProposalKindMismatch or SemanticProposalRadiusInvalid or SemanticProposalTargetUnresolved or SemanticProposalEndUnsupported;private static IReadOnlyList<FirmamentV2Exposure> ParseExposures(string body, List<string> diagnostics){@@ -628,7 +641,9 @@ public static class FirmamentV2Parser? Regex.Matches(facesMatch.Groups["faces"].Value, "\\\"(?<face>#[0-9]+)\\\"", RegexOptions.CultureInvariant).Select(m => m.Groups["face"].Value).ToArray(): [];if (faces.Length == 0 || faces.Any(f => !solid.InlineStep.TopologyMap.TryResolveFaceEntity(f, out _))) { diagnostics.Add(UnknownRecognitionFace); continue; }- result.Add(new FirmamentV2RecognizedRegion(bodyName, regionName, kind, faces, confidence));+ var evidence = ParseRecognitionEvidence(rb, diagnostics);+ var proposal = ParseSemanticProposal(rb, solid, kind, regionName, diagnostics);+ result.Add(new FirmamentV2RecognizedRegion(bodyName, regionName, kind, faces, confidence, evidence, proposal));}}return result;@@ -640,6 +655,108 @@ public static class FirmamentV2Parserreturn string.Equals(raw, "hole<shaft>", StringComparison.Ordinal) ? "holeShaft" : raw;}+ private static FirmamentV2RecognitionEvidence? ParseRecognitionEvidence(string regionBody, List<string> diagnostics)+ {+ var match = EvidenceHeaderRegex.Match(regionBody);+ if (!match.Success) return null;+ var open = regionBody.IndexOf('{', match.Index);+ var close = FindMatchingBrace(regionBody, open);+ if (close < 0) { diagnostics.Add(UnsupportedConstruct); return null; }+ var body = regionBody[(open + 1)..close];+ var families = new List<string>();+ foreach (Match familyMatch in SurfaceFamilyRegex.Matches(body))+ {+ var family = familyMatch.Groups["value"].Value;+ if (family is not ("cylindrical" or "planar")) diagnostics.Add(RecognitionEvidenceSurfaceFamilyUnknown);+ else families.Add(family);+ }++ double? radius = null;+ if (Regex.IsMatch(body, @"\bradius\s*:", RegexOptions.CultureInvariant))+ {+ if (!TryReadPositiveNumberWithOptionalMm(body, "radius", out var value)) diagnostics.Add(RecognitionEvidenceRadiusInvalid);+ else radius = value;+ }++ string? axis = null;+ if (Regex.IsMatch(body, @"\baxis\s*:", RegexOptions.CultureInvariant))+ {+ var axisMatch = AxisRegex.Match(body);+ if (!axisMatch.Success) diagnostics.Add(RecognitionEvidenceAxisInvalid);+ else axis = axisMatch.Groups["value"].Value;+ }++ var center = CenterRegex.IsMatch(body) ? ParseCenterWithOptionalUnits(body, diagnostics) : null;+ bool? through = null;+ var throughMatch = BooleanThroughRegex.Match(body);+ if (throughMatch.Success) through = bool.Parse(throughMatch.Groups["value"].Value);+ return new FirmamentV2RecognitionEvidence(families, radius, axis, center, through, []);+ }++ private static FirmamentV2SemanticProposal? ParseSemanticProposal(string regionBody, FirmamentV2SolidBinding solid, string regionKind, string regionName, List<string> diagnostics)+ {+ var match = ProposalHeaderRegex.Match(regionBody);+ if (!match.Success) return null;+ var proposalKind = NormalizeRecognitionKind(match.Groups["kind"].Value);+ if (!string.Equals(proposalKind, regionKind, StringComparison.Ordinal)) diagnostics.Add(SemanticProposalKindMismatch);+ if (proposalKind != "holeShaft") diagnostics.Add(SemanticProposalKindMismatch);+ var open = regionBody.IndexOf('{', match.Index);+ var close = FindMatchingBrace(regionBody, open);+ if (close < 0) { diagnostics.Add(UnsupportedConstruct); return null; }+ var body = regionBody[(open + 1)..close];+ string? placementTarget = null;+ var on = OnRegex.Match(body);+ if (on.Success)+ {+ placementTarget = on.Groups["target"].Value.Trim();+ if (!TryValidateReplacementFaceTarget(placementTarget, solid)) diagnostics.Add(SemanticProposalTargetUnresolved);+ }++ var center = CenterRegex.IsMatch(body) ? ParseCenterWithOptionalUnits(body, diagnostics) : null;+ double? radius = null;+ if (Regex.IsMatch(body, @"\bradius\s*:", RegexOptions.CultureInvariant))+ {+ if (!TryReadPositiveNumberWithOptionalMm(body, "radius", out var value)) diagnostics.Add(SemanticProposalRadiusInvalid);+ else radius = value;+ }++ string? end = null;+ var endMatch = EndConditionRegex.Match(body);+ if (endMatch.Success)+ {+ end = endMatch.Groups["value"].Value;+ if (end != "throughAll") diagnostics.Add(SemanticProposalEndUnsupported);+ }++ var featureName = match.Groups["name"].Success && !string.IsNullOrWhiteSpace(match.Groups["name"].Value) ? match.Groups["name"].Value : regionName;+ return new FirmamentV2SemanticProposal(proposalKind, featureName, placementTarget, center, radius, end);+ }++ private static FirmamentV2FaceLocalPoint2D? ParseCenterWithOptionalUnits(string body, List<string> diagnostics)+ {+ var match = CenterRegex.Match(body);+ if (!match.Success) return null;+ var parts = match.Groups["values"].Value.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);+ if (parts.Length != 2) { diagnostics.Add(CylinderCenterArityInvalid); return null; }+ if (!TryParseNumberWithOptionalMm(parts[0], out var u) || !TryParseNumberWithOptionalMm(parts[1], out var v)) { diagnostics.Add(CylinderCenterInvalid); return null; }+ if (!double.IsFinite(u) || !double.IsFinite(v)) { diagnostics.Add(CylinderCenterNotFinite); return null; }+ return new FirmamentV2FaceLocalPoint2D(u, v, string.Empty);+ }++ private static bool TryReadPositiveNumberWithOptionalMm(string body, string field, out double value)+ {+ value = 0d;+ var m = Regex.Match(body, $@"\b{field}\s*:\s*(?<value>[^\s}}]+)", RegexOptions.CultureInvariant);+ return m.Success && TryParseNumberWithOptionalMm(m.Groups["value"].Value, out value) && double.IsFinite(value) && value > 0d;+ }++ private static bool TryParseNumberWithOptionalMm(string raw, out double value)+ {+ raw = raw.Trim();+ if (raw.EndsWith("mm", StringComparison.Ordinal)) raw = raw[..^2];+ return double.TryParse(raw, NumberStyles.Float, CultureInfo.InvariantCulture, out value);+ }+private static IReadOnlyList<FirmamentV2ReplacementDecl> ParseReplacements(string source, Dictionary<string, FirmamentV2SolidBinding> solids, IReadOnlyList<FirmamentV2RecognizedRegion> recognizedRegions, List<string> diagnostics){diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/InlineStepMigrationReport.cs b/Aetheris.Kernel.Firmament/FirmamentV2/InlineStepMigrationReport.csindex 39b1909a..12a06e2a 100644--- a/Aetheris.Kernel.Firmament/FirmamentV2/InlineStepMigrationReport.cs+++ b/Aetheris.Kernel.Firmament/FirmamentV2/InlineStepMigrationReport.cs@@ -15,7 +15,7 @@ public sealed record InlineStepMigrationReport(IReadOnlyList<string> Diagnostics);public sealed record InlineStepOriginalTopologyAccounting(int FaceCount, int EdgeCount, int VertexCount);-public sealed record InlineStepRecognizedAccounting(int RegionCount, int ReferencedFaceCount, int DuplicateReferencedFaceCount, int UnresolvedReferenceCount);+public sealed record InlineStepRecognizedAccounting(int RegionCount, int ReferencedFaceCount, int DuplicateReferencedFaceCount, int UnresolvedReferenceCount, int EvidenceCount = 0, int ProposalCount = 0, int ProposalVerifiedCount = 0, int ProposalUnverifiedCount = 0);public sealed record InlineStepReplacementAccounting(int PlannedCount, int VerifiedCount, int EmittedCount, int FailedCount, int ReplacedFaceCount);public sealed record InlineStepResidualAccounting(int ResidualFaceCount, int UnclaimedFaceCount);public sealed record InlineStepCoverageAccounting(double RecognizedFaceRatio, double ReplacedFaceRatio);@@ -86,7 +86,7 @@ public static class InlineStepMigrationReportBuilderinlineStep.SourcePath,inlineStep.ContentHash,new InlineStepOriginalTopologyAccounting(originalFaceCount, 0, 0),- new InlineStepRecognizedAccounting(regions.Length, uniqueRecognized.Count, duplicateCount, unresolvedCount),+ new InlineStepRecognizedAccounting(regions.Length, uniqueRecognized.Count, duplicateCount, unresolvedCount, regions.Count(r => r.Evidence is not null), regions.Count(r => r.Proposal is not null), 0, regions.Count(r => r.Proposal is not null)),new InlineStepReplacementAccounting(plannedCount, verifiedCount, emittedCount, failedCount, replacedFaces.Count),new InlineStepResidualAccounting(residualFaceCount, residualFaceCount),new InlineStepCoverageAccounting(Ratio(uniqueRecognized.Count, originalFaceCount), Ratio(replacedFaces.Count, originalFaceCount)),diff --git a/docs/audits/inline-step-a0-strangler-fig-migration-audit.md b/docs/audits/inline-step-a0-strangler-fig-migration-audit.mdindex 9a104f2c..171aff78 100644--- a/docs/audits/inline-step-a0-strangler-fig-migration-audit.md+++ b/docs/audits/inline-step-a0-strangler-fig-migration-audit.md@@ -253,6 +253,9 @@ INLINE-STEP-X4:INLINE-STEP-X5:add residual body accounting, progress metrics, and hybrid STEP verification reports.++INLINE-STEP-X6:+ add metadata-only recognized-region evidence and semantic proposal records; see `docs/implementation/inline-step-x6-recognition-evidence-proposals.md`.```X1 and X2 should come before replacement. They force the project to solve provenance, source-ID resolution, unit diagnostics, imported-topology targeting, and AP242 enrichment before adding topology surgery.diff --git a/docs/implementation/inline-step-x6-recognition-evidence-proposals.md b/docs/implementation/inline-step-x6-recognition-evidence-proposals.mdnew file mode 100644index 00000000..c8670f66--- /dev/null+++ b/docs/implementation/inline-step-x6-recognition-evidence-proposals.md@@ -0,0 +1,102 @@+# INLINE-STEP-X6 recognition evidence and semantic proposals++INLINE-STEP-X6 extends Firmament V2 inline STEP recognition regions with metadata-only evidence and semantic proposal records.++## Chosen syntax++The parser accepts optional nested blocks inside an existing recognized region:++```firmament+recognize importedPart {+ region mountHole {+ kind: hole<shaft>+ faces: ["#191"]+ confidence: high++ evidence {+ surfaceFamily: cylindrical+ radius: 1mm+ axis: +Z+ through: true+ }++ proposes hole<shaft> {+ on: importedPart.face("#51")+ center: [0mm, 0mm]+ radius: 1mm+ end: throughAll+ }+ }+}+```++`hole<shaft>` is normalized to the existing internal `holeShaft` label.++## Model additions++`FirmamentV2RecognizedRegion` now carries optional `Evidence` and `Proposal` records. Evidence stores known surface families plus optional radius, axis, center, through flag, and notes. Proposal stores the normalized proposal kind, feature name, optional placement target, center, radius, and end condition.++## Validation now++Evidence validation is intentionally bounded:++- radius must be positive when present;+- axis must be one of `+X`, `-X`, `+Y`, `-Y`, `+Z`, or `-Z` when present;+- surface family must be known (`cylindrical` or `planar` currently);+- `through` is parsed as a boolean.++Proposal validation for X6 is limited to `hole<shaft>`:++- proposal kind must match the recognized region kind;+- proposal radius must be positive when present;+- `on` must resolve to an imported canonical STEP face when provided;+- end condition must be `throughAll` when provided.++## Metadata-only relationship to replacement++Evidence and proposals do not mutate geometry and do not create `replace` declarations. A proposal becomes construction authority only in a later explicit replacement path that verifies and emits replacement geometry.++## Migration report changes++`InlineStepRecognizedAccounting` includes:++- `EvidenceCount`;+- `ProposalCount`;+- `ProposalVerifiedCount` (always `0` in X6);+- `ProposalUnverifiedCount`.++X6 counts proposal presence but does not claim replacement verification.++## Fixture++The recognized-only fixture is:++`fixtures/FirmamentV2/InlineStep/valid/inline-step-v2-recognized-hole-proposal-report.valid.firmfixture`++It imports the canonical through-hole STEP body, recognizes the cylindrical wall face, attaches cylindrical/radius/axis/through evidence, proposes a future `hole<shaft>`, attaches diameter PMI to the recognized region, and re-exports canonical AP242 without replacement.++## Example report excerpt++Expected recognized-only accounting:++```text+recognized.regionCount = 1+recognized.evidenceCount = 1+recognized.proposalCount = 1+recognized.proposalVerifiedCount = 0+replacements.plannedCount = 0+replacements.emittedCount = 0+residual.residualFaceCount = original.faceCount+emissionStrategy = canonical-reexport+residualSurgery = false+```++## Deferred features++- automatic recognition;+- proposal scoring/JudgmentEngine selection;+- proposal-to-replacement automation;+- robust geometric signatures;+- multiple proposals per region;+- edge/vertex evidence;+- counterbore/countersink/fillet/slot proposals.diff --git a/fixtures/FirmamentV2/InlineStep/valid/inline-step-v2-recognized-hole-proposal-report.valid.firmfixture b/fixtures/FirmamentV2/InlineStep/valid/inline-step-v2-recognized-hole-proposal-report.valid.firmfixturenew file mode 100644index 00000000..9975b05a--- /dev/null+++ b/fixtures/FirmamentV2/InlineStep/valid/inline-step-v2-recognized-hole-proposal-report.valid.firmfixture@@ -0,0 +1,67 @@+// fixture-id: inline-step-v2-recognized-hole-proposal-report+// case: inline-step-v2-recognized-hole-proposal-report+// category: InlineStep+// syntax-version: FirmamentV2+// validity: valid+// implementation: parser-backed+// expected: valid+// expected-stage: step-verified+// current-stage: step-verified+// feature-area: inline-step-recognition-evidence-proposal+// build-command: aetheris build+// roundtrip-required: true+// expected-volume: 461.15044407846125+// expected-topology: canonical through-hole re-export; no replacement or geometry mutation+// canonical-input-required: true+// recognized-region-required: true+// recognition-evidence-required: true+// semantic-proposal-required: true+// replacement-required: false+// graphical-pmi-required: false+// input-step: ../testdata/canonical-through-hole.step+// migration-report-required: true+// migration-original-face-count: 7+// migration-recognized-region-count: 1+// migration-recognized-evidence-count: 1+// migration-recognized-proposal-count: 1+// migration-replaced-face-count: 0+// migration-residual-face-count: 7+// migration-emission-strategy: canonical-reexport+// migration-residual-surgery: false+// notes: INLINE-STEP-X6 recognition evidence/proposal metadata is descriptive only; no automatic recognition or replacement is executed.+model InlineStepRecognizedHoleProposalReport {+ units mm++ solid importedPart: InlineStep {+ path: "../testdata/canonical-through-hole.step"+ }++ recognize importedPart {+ region mountHole {+ kind: hole<shaft>+ faces: ["#191"]+ confidence: high++ evidence {+ surfaceFamily: cylindrical+ radius: 1mm+ axis: +Z+ through: true+ }++ proposes hole<shaft> {+ on: importedPart.face("#51")+ center: [0mm, 0mm]+ radius: 1mm+ end: throughAll+ }+ }+ }++ pmi {+ diameter mountHoleDiameter {+ target: importedPart.region("mountHole")+ value: 2mm+ }+ }+}