Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add AIR region X8 parent integration attempt
Yuechen Li420eeed45589
diff --git a/Aetheris.CLI.Tests/AirTraceCommandTests.cs b/Aetheris.CLI.Tests/AirTraceCommandTests.csindex 13c41671..70169568 100644--- a/Aetheris.CLI.Tests/AirTraceCommandTests.cs+++ b/Aetheris.CLI.Tests/AirTraceCommandTests.cs@@ -325,8 +325,8 @@ public sealed class AirTraceCommandTestsAssert.Contains("CutEntryLoop", output); Assert.Contains("CutWallFace", output);Assert.Contains("no parent topology mutation", output); Assert.Contains("no BRepPlan elements materialized", output);Assert.Contains("Region integration decision", output);- Assert.Contains("Selected: ControlledSideHolePatchMaterialization", output);- Assert.Contains("Status: Deferred", output);+ Assert.Contains("Selected: ControlledSideHoleParentBRepIntegration", output);+ Assert.Contains("Status: Blocked", output);Assert.Contains("FaceAttachedConstructiveInsertion: Deferred", output);Assert.Contains("LocalBRepPlanPatch: Deferred", output);Assert.Contains("BRepBooleanFallback: Rejected", output);@@ -342,7 +342,7 @@ public sealed class AirTraceCommandTestsusing var doc = JsonDocument.Parse(output); var root = doc.RootElement;Assert.Equal("valid", root.GetProperty("fixture").GetProperty("expectation").GetString());Assert.True(root.GetProperty("fixture").GetProperty("expectationSatisfied").GetBoolean());- Assert.Equal("region-materialization-partial", root.GetProperty("actualStageReached").GetString());+ Assert.Equal("region-parent-integration-blocked", root.GetProperty("actualStageReached").GetString());var regions = root.GetProperty("regions");Assert.Equal(2, regions.GetProperty("regionCount").GetInt32());Assert.True(regions.GetProperty("hasNestedRegions").GetBoolean());@@ -398,8 +398,8 @@ public sealed class AirTraceCommandTestsAssert.Contains("no-brep-plan-element-materialization", boundaryLosses);Assert.Equal("Deferred", brepBoundary.GetProperty("integrationStatus").GetString());var decision = side.GetProperty("integrationDecision");- Assert.Equal("ControlledSideHolePatchMaterialization", decision.GetProperty("selectedRouteKind").GetString());- Assert.Equal("Deferred", decision.GetProperty("selectedStatus").GetString());+ Assert.Equal("ControlledSideHoleParentBRepIntegration", decision.GetProperty("selectedRouteKind").GetString());+ Assert.Equal("Blocked", decision.GetProperty("selectedStatus").GetString());Assert.Equal("SwitchMatch", decision.GetProperty("selectionMode").GetString());var candidates = decision.GetProperty("candidates").EnumerateArray().ToDictionary(c => c.GetProperty("routeKind").GetString()!, c => c);Assert.Equal("Deferred", candidates["FaceAttachedConstructiveInsertion"].GetProperty("status").GetString());@@ -468,7 +468,7 @@ public sealed class AirTraceCommandTestsAssert.Contains("CutEntryLoop", roles); Assert.Contains("CutExitLoop", roles); Assert.Contains("CutWallFace", roles);Assert.Contains("AffectedParentFace", roles); Assert.Contains("RegionIntegrationPatch", roles);Assert.All(elements, e => Assert.True(e.GetProperty("materializationStatus").GetString() is "NotMaterialized" or "ReferenceOnly"));- Assert.Equal("ControlledSideHolePatchMaterialization", side.GetProperty("integrationDecision").GetProperty("selectedRouteKind").GetString());+ Assert.Equal("ControlledSideHoleParentBRepIntegration", side.GetProperty("integrationDecision").GetProperty("selectedRouteKind").GetString());Assert.Equal("Rejected", side.GetProperty("integrationDecision").GetProperty("candidates").EnumerateArray().Single(c => c.GetProperty("routeKind").GetString() == "BRepBooleanFallback").GetProperty("status").GetString());Assert.True(root.GetProperty("emission").GetProperty("succeeded").GetBoolean());Assert.False(root.GetProperty("stepSmoke").GetProperty("succeeded").GetBoolean());@@ -489,6 +489,84 @@ public sealed class AirTraceCommandTestsAssert.Equal(P(d1), P(d2));}+ [Fact]+ public void TraceSideHoleRegion_ParentIntegration_DefaultText()+ {+ var (exitCode, output, error) = Run("trace", "--fixture", RegionFixture("valid/side-hole-face-attached-region.valid.firmfixture"));+ Assert.Equal(0, exitCode); Assert.True(string.IsNullOrWhiteSpace(error));+ Assert.Contains("Region parent integration", output);+ Assert.Contains("Status: Blocked", output);+ Assert.Contains("Route: ControlledSideHoleParentBRepIntegration", output);+ Assert.Contains("Placeholder mappings:", output);+ Assert.Contains("CutEntryLoop: Deferred", output);+ Assert.Contains("CutWallFace: Materialized", output);+ Assert.Contains("Blocker:", output);+ Assert.Contains("Category: FaceSplitting", output);+ Assert.Contains("controlled fixture only", output);+ }++ [Fact]+ public void TraceSideHoleRegion_ParentIntegration_Json()+ {+ var (exitCode, output, _) = Run("trace", "--fixture", RegionFixture("valid/side-hole-face-attached-region.valid.firmfixture"), "--json");+ Assert.Equal(0, exitCode);+ using var doc = JsonDocument.Parse(output);+ var side = doc.RootElement.GetProperty("regions").GetProperty("regions").EnumerateArray().Single(r => r.GetProperty("regionKind").GetString() == "FaceAttachedRegion");+ var parent = side.GetProperty("parentIntegration");+ Assert.Equal("Blocked", parent.GetProperty("status").GetString());+ Assert.Equal("ControlledSideHoleParentBRepIntegration", parent.GetProperty("route").GetString());+ Assert.Contains(parent.GetProperty("placeholderMappings").EnumerateArray(), m => m.GetProperty("placeholderRole").GetString() == "CutEntryLoop" && m.GetProperty("materializationStatus").GetString() == "Deferred");+ Assert.Contains(parent.GetProperty("placeholderMappings").EnumerateArray(), m => m.GetProperty("placeholderRole").GetString() == "CutWallFace" && m.GetProperty("materializationStatus").GetString() == "Materialized");+ Assert.Equal("FaceSplitting", parent.GetProperty("blocker").GetProperty("category").GetString());+ Assert.Equal("controlled-side-hole-parent-face-splitting-missing", parent.GetProperty("blocker").GetProperty("code").GetString());+ }++ [Fact]+ public void TraceSideHoleRegion_PreservesRegionEvidenceChain()+ {+ var output = Run("trace", "--fixture", RegionFixture("valid/side-hole-face-attached-region.valid.firmfixture")).Stdout;+ Assert.Contains("Region yield", output);+ Assert.Contains("Region CIR mirror", output);+ Assert.Contains("Region BRepPlan boundary", output);+ Assert.Contains("Region integration decision", output);+ Assert.Contains("Region BRepPlan placeholders", output);+ Assert.Contains("Region materialization", output);+ Assert.Contains("Region parent integration", output);+ }++ [Fact]+ public void TraceSideHoleRegion_CirStillAnalysisOnly()+ {+ var output = Run("trace", "--fixture", RegionFixture("valid/side-hole-face-attached-region.valid.firmfixture"), "--json").Stdout;+ using var doc = JsonDocument.Parse(output);+ var side = doc.RootElement.GetProperty("regions").GetProperty("regions").EnumerateArray().Single(r => r.GetProperty("regionKind").GetString() == "FaceAttachedRegion");+ var losses = side.GetProperty("cirMirror").GetProperty("knownLosses").EnumerateArray().Select(x => x.GetString()).ToArray();+ Assert.Contains("no-topology-authority", losses);+ var guarantees = side.GetProperty("parentIntegration").GetProperty("guarantees").EnumerateArray().Select(x => x.GetString()).ToArray();+ Assert.Contains("CIR remains analysis-only", guarantees);+ }++ [Fact]+ public void TraceSideHoleRegion_BooleanPolicyIsExplicit()+ {+ var output = Run("trace", "--fixture", RegionFixture("valid/side-hole-face-attached-region.valid.firmfixture"), "--json").Stdout;+ using var doc = JsonDocument.Parse(output);+ var side = doc.RootElement.GetProperty("regions").GetProperty("regions").EnumerateArray().Single(r => r.GetProperty("regionKind").GetString() == "FaceAttachedRegion");+ var guarantees = side.GetProperty("parentIntegration").GetProperty("guarantees").EnumerateArray().Select(x => x.GetString()).ToArray();+ Assert.Contains("Boolean not used", guarantees);+ Assert.Contains("Boolean not generally admitted", guarantees);+ var diagnostics = side.GetProperty("parentIntegration").GetProperty("diagnostics").EnumerateArray().Select(x => x.GetString()).ToArray();+ Assert.DoesNotContain("air-region-x8-bounded-backend-used", diagnostics);+ }++ [Fact]+ public void SideHoleParentIntegration_IsDeterministic()+ {+ var first = Run("trace", "--fixture", RegionFixture("valid/side-hole-face-attached-region.valid.firmfixture"), "--json").Stdout;+ var second = Run("trace", "--fixture", RegionFixture("valid/side-hole-face-attached-region.valid.firmfixture"), "--json").Stdout;+ Assert.Equal(first, second);+ }+[Fact]public void TraceImplicitParentMutationRegion_RejectedWithYieldContractReason(){@@ -520,7 +598,7 @@ public sealed class AirTraceCommandTests}[Fact]- public void TraceSideHoleRegion_EnforcesLocality_NoParentBRepOrBoolean()+ public void TraceSideHoleRegion_EnforcesLocality_NoIntegratedParentBRepOrBoolean(){var (exitCode, output, _) = Run("trace", "--fixture", RegionFixture("valid/side-hole-face-attached-region.valid.firmfixture"), "--json");Assert.Equal(0, exitCode);diff --git a/Aetheris.CLI/AirTrace.cs b/Aetheris.CLI/AirTrace.csindex 00a774ee..15567ec9 100644--- a/Aetheris.CLI/AirTrace.cs+++ b/Aetheris.CLI/AirTrace.cs@@ -192,14 +192,14 @@ internal static class AirTraceReportBuilderprivate static AirTraceReport BuildSideHoleFaceAttachedRegionFixture(FirmFixture fixture){var regions = AirRegionTraceFactory.ForFaceAttachedSideHoleDeferred();- var actualStage = "region-materialization-partial";+ var actualStage = "region-parent-integration-blocked";var expectationSatisfied = fixture.Expectation == "valid" && (string.IsNullOrWhiteSpace(fixture.ExpectedStage) || fixture.ExpectedStage == actualStage);var fxDiagnostics = Stable([.. fixture.Diagnostics, .. regions.Diagnostics, "air-region-x1-firmfixture-case-mapped", "air-region-x4-firmfixture-boundary-contract-created", "air-region-x5-firmfixture-integration-decision-created", "air-region-x6-firmfixture-brep-placeholders-created", "air-region-x7-firmfixture-materialization-created", expectationSatisfied ? "air-region-x1-expectation-satisfied" : "air-region-x1-expectation-not-satisfied"]).ToArray();- return new("AIR-REGION-X7", "trace", "lowering", "firmfixture", fixture.CaseName, expectationSatisfied, "FaceAttachedRegion side-hole materializes a controlled standalone patch from BRepPlan placeholders; parent integration remains deferred.",- new("RegionFixture", "ControlledSideHolePatchMaterialization", "none", "none", "metadata-driven-region-contract", fixture.CaseName, fixture.CaseName, "AIR-REGION-X6"),- new("SwitchMatch", "ControlledSideHolePatchMaterialization", false, "controlled standalone side-hole patch materialized; parent integration deferred", "FaceAttachedRegion", "SideHole", []),+ return new("AIR-REGION-X8", "trace", "lowering", "firmfixture", fixture.CaseName, expectationSatisfied, "FaceAttachedRegion side-hole attempts controlled parent BRep integration; blocked at parent face splitting and loop insertion.",+ new("RegionFixture", "ControlledSideHoleParentBRepIntegration", "none", "none", "metadata-driven-region-contract", fixture.CaseName, fixture.CaseName, "AIR-REGION-X8"),+ new("SwitchMatch", "ControlledSideHoleParentBRepIntegration", false, "controlled parent integration attempted; blocked at parent face splitting and loop insertion", "FaceAttachedRegion", "SideHole", []),new("none", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "none", "none", null, []),- new("ControlledSideHolePatchMaterialization", true, "standalone side-hole patch evidence emitted; parent body not mutated"),+ new("ControlledSideHoleParentBRepIntegration", true, "standalone side-hole patch evidence preserved; parent integration blocked before topology mutation"),new(false, false, false, false, []),new("not-requested", "none", "none", "RegionFixture", "none", "none", "none", [], [], [], []),[], ["parent BRep integration not implemented", "CIR evaluator composition deferred"], fxDiagnostics,@@ -403,6 +403,38 @@ internal static class AirTraceTextRendererforeach (var guarantee in m.Guarantees) b.AppendLine($" - {guarantee}");}+ if (region.ParentIntegration is not null)+ {+ var pi = region.ParentIntegration;+ b.AppendLine(" Region parent integration");+ b.AppendLine($" Region: {pi.SourceRegionId}");+ b.AppendLine($" Feature: {pi.FeatureKind}");+ b.AppendLine($" Status: {pi.Status}");+ b.AppendLine($" Route: {pi.Route}");+ b.AppendLine(" Placeholder mappings:");+ foreach (var map in pi.PlaceholderMappings)+ {+ b.AppendLine($" - {map.PlaceholderRole}: {map.MaterializationStatus}");+ b.AppendLine($" Element: {map.MaterializedRole}");+ }+ b.AppendLine(" Topology:");+ b.AppendLine($" Faces: {(pi.TopologySummary.FaceCount.HasValue ? pi.TopologySummary.FaceCount.Value.ToString(System.Globalization.CultureInfo.InvariantCulture) : "unavailable")}");+ b.AppendLine($" Loops: {(pi.TopologySummary.LoopCount.HasValue ? pi.TopologySummary.LoopCount.Value.ToString(System.Globalization.CultureInfo.InvariantCulture) : "unavailable")}");+ b.AppendLine($" Cylindrical faces: {(pi.TopologySummary.CylindricalFaceCount.HasValue ? pi.TopologySummary.CylindricalFaceCount.Value.ToString(System.Globalization.CultureInfo.InvariantCulture) : "unavailable")}");+ b.AppendLine($" Closed: {(pi.TopologySummary.Closed.HasValue ? pi.TopologySummary.Closed.Value.ToString().ToLowerInvariant() : "unavailable")}");+ b.AppendLine($" STEP smoke: {pi.StepSmoke.Status}");+ if (pi.Blocker is not null)+ {+ b.AppendLine();+ b.AppendLine(" Blocker:");+ b.AppendLine($" Category: {pi.Blocker.Category}");+ b.AppendLine($" Code: {pi.Blocker.Code}");+ b.AppendLine($" Message: {pi.Blocker.Message}");+ }+ b.AppendLine(" Guarantees:");+ foreach (var guarantee in pi.Guarantees) b.AppendLine($" - {guarantee}");+ }+if (region.IntegrationDecision is not null){var decision = region.IntegrationDecision;diff --git a/Aetheris.Kernel.Core/Air/AirRegions.cs b/Aetheris.Kernel.Core/Air/AirRegions.csindex 02e78eb3..31afb3a6 100644--- a/Aetheris.Kernel.Core/Air/AirRegions.cs+++ b/Aetheris.Kernel.Core/Air/AirRegions.cs@@ -6,13 +6,14 @@ internal enum AirRegionYieldKind { None, YieldBody, YieldAdditiveBody, YieldSubtinternal enum AirRegionBoundaryContractKind { DoesNotEscape, YieldsBody, YieldsCutVolume, YieldsPatch, YieldsLoopRewrite, YieldsAttachmentInterface, YieldsSelection, RejectedOrDeferred }internal enum AirLocalFrameKind { WorldRoot, FaceAttached, Unsupported }internal enum AirLocalFrameHandedness { RightHanded, LeftHanded, Unknown }-internal enum AirRegionIntegrationStatus { NotRequired, Deferred, Rejected, Admitted, Unsupported }+internal enum AirRegionIntegrationStatus { NotRequired, Integrated, PartiallyIntegrated, Blocked, Deferred, Rejected, Admitted, Unsupported }internal enum AirRegionCirMirrorStatus { MirrorAdmittedConservative, MirrorUnavailable, MirrorRejectedLossyForRequest }internal enum AirRegionBRepBoundaryStatus { PlannedContractOnly, Deferred, Rejected, Unsupported }-internal enum AirRegionIntegrationRouteKind { FaceAttachedConstructiveInsertion, LocalBRepPlanPatch, ControlledSideHolePatchMaterialization, BRepBooleanFallback, CirAnalysisMirrorOnly, DeferredIntegration, Unsupported }+internal enum AirRegionIntegrationRouteKind { FaceAttachedConstructiveInsertion, LocalBRepPlanPatch, ControlledSideHolePatchMaterialization, ControlledSideHoleParentBRepIntegration, ControlledSideHoleDirectBRepPrototype, ControlledSideHoleBoundedBackend, ControlledSideHoleBooleanBackend, BRepBooleanFallback, CirAnalysisMirrorOnly, DeferredIntegration, Unsupported }internal enum AirRegionIntegrationCandidateStatus { Admitted, AvailableForAnalysis, Deferred, Rejected, Unavailable, NotApplicable, Selected }internal enum AirRegionBRepPlaceholderStatus { PlaceholderOnly, NotMaterialized, Deferred, Rejected, Unsupported }internal enum AirRegionMaterializationStatus { Materialized, PartiallyMaterialized, Deferred, Rejected, Unsupported }+internal enum AirRegionIntegrationBlockerCategory { MissingBRepApi, FaceSplitting, LoopInsertion, CylindricalWallBinding, ShellClosure, STEPExport, UnsafeBooleanBackend, FrameMismatch, TopologyValidation, Unknown }@@ -37,6 +38,10 @@ internal sealed record AirRegionBRepPlaceholderMaterialization(string Placeholdeinternal sealed record AirRegionMaterializationTopologySummary(bool BodyExists, bool? Closed, int FaceCount, int LoopCount, int CylindricalFaceCount, string Bounds, IReadOnlyList<string> EvidenceRoles);internal sealed record AirRegionMaterializationStepSmokeSummary(bool WasChecked, bool Succeeded, IReadOnlyList<string> Diagnostics);internal sealed record AirRegionSideHoleMaterializationSummary(string SourceRegionId, string FeatureKind, AirRegionMaterializationStatus Status, string Route, IReadOnlyList<AirRegionBRepPlaceholderMaterialization> PlaceholderMappings, AirRegionMaterializationTopologySummary TopologySummary, AirRegionMaterializationStepSmokeSummary StepSmoke, IReadOnlyList<string> Diagnostics, IReadOnlyList<string> KnownLosses, IReadOnlyList<string> Guarantees);+internal sealed record AirRegionIntegrationBlocker(AirRegionIntegrationBlockerCategory Category, string Code, string Message, string FailedStage, IReadOnlyList<string> RelevantPlaceholderIds, IReadOnlyList<string> CurrentEvidence, string SuggestedNextFix, IReadOnlyList<string> Diagnostics);+internal sealed record AirRegionParentIntegrationTopologySummary(bool ParentBodyExists, bool? Closed, int? FaceCount, int? LoopCount, int? CylindricalFaceCount, string Bounds, IReadOnlyList<string> EvidenceRoles);+internal sealed record AirRegionParentIntegrationStepSmokeSummary(bool WasChecked, bool Succeeded, string Status, IReadOnlyList<string> Diagnostics);+internal sealed record AirRegionParentIntegrationSummary(string SourceRegionId, string FeatureKind, AirRegionIntegrationStatus Status, AirRegionIntegrationRouteKind Route, IReadOnlyList<AirRegionBRepPlaceholderMaterialization> PlaceholderMappings, AirRegionParentIntegrationTopologySummary TopologySummary, AirRegionParentIntegrationStepSmokeSummary StepSmoke, AirRegionIntegrationBlocker? Blocker, IReadOnlyList<string> Diagnostics, IReadOnlyList<string> KnownLosses, IReadOnlyList<string> Guarantees);internal sealed record AirRegionAffectedParentSummary(string ParentRegionId, string ParentBody, string AffectedFaceSelector, string AffectedFaceRole, string AffectedScope, string Locality);internal sealed record AirRegionEntryBoundarySummary(string BoundaryKind, string ProfileKind, string ProfileSource, string LocalFrameId, string LoopIntent, string Role);internal sealed record AirRegionExitBoundarySummary(string BoundaryKind, string ExitKind, string Role, string Status, IReadOnlyList<string> Diagnostics);@@ -164,6 +169,37 @@ internal static class AirSideHolePlaceholderMaterializerprivate static IEnumerable<string> Stable(IEnumerable<string> values) => values.Distinct(StringComparer.Ordinal).OrderBy(x => x, StringComparer.Ordinal);}+internal static class AirSideHoleParentBRepIntegrationPrototype+{+ public static AirRegionParentIntegrationSummary Attempt(AirRegionSummary region, AirRegionBRepBoundarySummary boundary, AirRegionBRepPlaceholderPlan placeholders, AirRegionSideHoleMaterializationSummary patch)+ {+ if (region.Yield is null) throw new ArgumentException("Side-hole region must carry a yield summary.", nameof(region));+ var byRole = placeholders.Elements.ToDictionary(e => e.Role, StringComparer.Ordinal);+ var mappings = new[]+ {+ Map(byRole["AffectedParentFace"], AirRegionMaterializationStatus.Deferred, "ParentFace", "RequiresParentFaceSplit", "brep:root-box:face:+x", "air-region-x8-affected-parent-face-blocked-by-face-splitting"),+ Map(byRole["CutEntryLoop"], AirRegionMaterializationStatus.Deferred, "ParentLoop", "RequiresLoopInsertion", null, "air-region-x8-cut-entry-loop-blocked-by-face-splitting"),+ Map(byRole["CutExitLoop"], AirRegionMaterializationStatus.Deferred, "ParentLoop", "RequiresOppositeFaceLoopInsertion", null, "air-region-x8-cut-exit-loop-blocked-by-face-splitting"),+ Map(byRole["CutWallFace"], AirRegionMaterializationStatus.Materialized, "CylindricalFaceEvidence", "StandaloneCylindricalCutWallEvidence", "brep:side-hole:+x:cut-wall-face", "air-region-x8-cut-wall-face-evidence-preserved"),+ Map(byRole["RegionIntegrationPatch"], AirRegionMaterializationStatus.Deferred, "ParentIntegrationPatch", "BlockedBeforeParentConsumption", null, "air-region-x8-integration-patch-blocked-by-face-splitting")+ };+ var blocker = new AirRegionIntegrationBlocker(+ AirRegionIntegrationBlockerCategory.FaceSplitting,+ "controlled-side-hole-parent-face-splitting-missing",+ "The controlled side-hole parent integration attempt can consume the X6 placeholders and X7 patch evidence, but no bounded parent-face splitting and loop insertion API is available for inserting the circular entry/exit loops into the box shell without expanding to a general side-hole algorithm.",+ "ParentFaceSplitAndLoopInsertion",+ [byRole["AffectedParentFace"].Id, byRole["CutEntryLoop"].Id, byRole["CutExitLoop"].Id, byRole["RegionIntegrationPatch"].Id],+ ["x2-yield-contract-present", "x3-cir-mirror-analysis-only", "x4-brep-boundary-contract-present", "x5-route-decision-present", "x6-placeholders-present", "x7-standalone-patch-materialized", "standalone-cylindrical-cut-wall-face-evidence-present"],+ "Add a controlled parent-face split plus entry/exit loop insertion adapter for the exact +X through-hole fixture, then bind the preserved cylindrical cut-wall evidence into the parent shell.",+ ["air-region-x8-face-splitting-blocker", "air-region-x8-loop-insertion-blocker"]);+ var diagnostics = Stable(["air-region-x8-parent-integration-request-created", "air-region-x8-side-hole-parent-integration-started", "air-region-x8-placeholder-plan-consumed", "air-region-x8-x7-patch-evidence-consumed", "air-region-x8-controlled-parent-integration-route-selected", "air-region-x8-parent-integration-blocked", "air-region-x8-blocker-recorded", "air-region-x8-current-evidence-preserved", "air-region-x8-no-fake-parent-integration", "air-region-x8-face-splitting-blocker", "air-region-x8-loop-insertion-blocker", "air-region-x8-controlled-fixture-only", "air-region-x8-no-general-side-hole-support", "air-region-x8-no-production-route-replacement", "air-region-x8-cir-remains-analysis-only", .. mappings.SelectMany(m => m.Diagnostics), .. blocker.Diagnostics]).ToArray();+ return new(region.RegionId, region.Yield.FeatureKind, AirRegionIntegrationStatus.Blocked, AirRegionIntegrationRouteKind.ControlledSideHoleParentBRepIntegration, mappings, new(false, false, null, null, 1, "parent-box:10x8x6; parent shell not split; x7 local patch bounds preserved", ["StandaloneCylindricalCutWallFaceEvidence"]), new(false, false, "unavailable", ["air-region-x8-step-smoke-unavailable", "step smoke unavailable because parent BRep integration is blocked before shell closure"]), blocker, diagnostics, ["parent-face-splitting-missing", "entry-exit-loop-insertion-missing", "parent-shell-not-closed", "standalone-patch-only"], ["controlled fixture only", "no general side-hole support", "no arbitrary face/axis support", "no production route replacement", "no parent topology mutation", "CIR remains analysis-only", "Boolean not used", "Boolean not generally admitted", "no STEP exporter/importer change"]);+ }++ private static AirRegionBRepPlaceholderMaterialization Map(AirRegionBRepPlaceholderElement e, AirRegionMaterializationStatus status, string kind, string role, string? id, string diagnostic) => new(e.Id, e.Role, status, kind, role, id, [diagnostic]);+ private static IEnumerable<string> Stable(IEnumerable<string> values) => values.Distinct(StringComparer.Ordinal).OrderBy(x => x, StringComparer.Ordinal);+}+internal sealed record AirLocalFrameSummary(string FrameId,AirLocalFrameKind FrameKind,@@ -202,7 +238,9 @@ internal sealed record AirRegionSummary([property: System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]AirRegionBRepPlaceholderPlan? BrepPlaceholders = null,[property: System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]- AirRegionSideHoleMaterializationSummary? Materialization = null);+ AirRegionSideHoleMaterializationSummary? Materialization = null,+ [property: System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]+ AirRegionParentIntegrationSummary? ParentIntegration = null);internal sealed record AirRegionTraceSummary(IReadOnlyList<AirRegionSummary> Regions,@@ -244,22 +282,24 @@ internal static class AirRegionTraceFactoryvar decision = AirSideHoleRegionIntegrationSelector.Decide(sideBase, mirror.Summary, boundary);var placeholders = AirSideHoleBRepPlaceholderPlanner.Plan(sideBase, boundary, decision);var materialization = AirSideHolePlaceholderMaterializer.MaterializePatch(sideBase, boundary, placeholders);- var x7Decision = decision with { SelectedRouteKind = AirRegionIntegrationRouteKind.ControlledSideHolePatchMaterialization, SelectedStatus = AirRegionIntegrationStatus.Deferred, Recommendation = "controlled standalone side-hole patch materialized from placeholders; parent integration remains deferred", Diagnostics = Stable([.. decision.Diagnostics, .. materialization.Diagnostics]).ToArray(), KnownLosses = Stable([.. decision.KnownLosses, .. materialization.KnownLosses]).ToArray(), Guarantees = Stable([.. decision.Guarantees, .. materialization.Guarantees]).ToArray() };+ var parentIntegration = AirSideHoleParentBRepIntegrationPrototype.Attempt(sideBase, boundary, placeholders, materialization);+ var x8Decision = decision with { SelectedRouteKind = AirRegionIntegrationRouteKind.ControlledSideHoleParentBRepIntegration, SelectedStatus = AirRegionIntegrationStatus.Blocked, Recommendation = "controlled parent BRep integration attempted; blocked at parent face splitting and loop insertion", Diagnostics = Stable([.. decision.Diagnostics, .. materialization.Diagnostics, .. parentIntegration.Diagnostics]).ToArray(), KnownLosses = Stable([.. decision.KnownLosses, .. materialization.KnownLosses, .. parentIntegration.KnownLosses]).ToArray(), Guarantees = Stable([.. decision.Guarantees, .. materialization.Guarantees, .. parentIntegration.Guarantees]).ToArray() };var side = sideBase with{- StageReached = "region-materialization-partial",- Provenance = "AIR-REGION-X7 metadata-driven fixture",- Diagnostics = Stable([.. sideBase.Diagnostics.Where(d => d != "air-region-x2-no-cir-mirror"), .. mirror.Summary.Diagnostics, .. boundary.Diagnostics, .. x7Decision.Diagnostics, .. placeholders.Diagnostics, .. materialization.Diagnostics]).ToArray(),- KnownLosses = Stable([.. sideBase.KnownLosses, .. mirror.Summary.KnownLosses, .. boundary.KnownLosses, .. x7Decision.KnownLosses, .. placeholders.KnownLosses, .. materialization.KnownLosses]).ToArray(),- Guarantees = Stable([.. sideBase.Guarantees, .. mirror.Summary.Guarantees, .. boundary.Guarantees, .. x7Decision.Guarantees, .. placeholders.Guarantees, .. materialization.Guarantees]).ToArray(),- IntegrationRoute = "ControlledSideHolePatchMaterialization",+ StageReached = "region-parent-integration-blocked",+ Provenance = "AIR-REGION-X8 metadata-driven fixture",+ Diagnostics = Stable([.. sideBase.Diagnostics.Where(d => d != "air-region-x2-no-cir-mirror"), .. mirror.Summary.Diagnostics, .. boundary.Diagnostics, .. x8Decision.Diagnostics, .. placeholders.Diagnostics, .. materialization.Diagnostics]).ToArray(),+ KnownLosses = Stable([.. sideBase.KnownLosses, .. mirror.Summary.KnownLosses, .. boundary.KnownLosses, .. x8Decision.KnownLosses, .. placeholders.KnownLosses, .. materialization.KnownLosses]).ToArray(),+ Guarantees = Stable([.. sideBase.Guarantees, .. mirror.Summary.Guarantees, .. boundary.Guarantees, .. x8Decision.Guarantees, .. placeholders.Guarantees, .. materialization.Guarantees]).ToArray(),+ IntegrationRoute = "ControlledSideHoleParentBRepIntegration",CirMirror = mirror.Summary,BrepBoundary = boundary,- IntegrationDecision = x7Decision,+ IntegrationDecision = x8Decision,BrepPlaceholders = placeholders,- Materialization = materialization+ Materialization = materialization,+ ParentIntegration = parentIntegration};- return Summary([root, side], ["air-region-x1-region-trace-created", "air-region-x1-no-implicit-parent-mutation", "air-region-x1-no-boolean", "air-region-x1-no-brep-emission", "air-region-x1-no-production-route-replacement", "air-region-x1-trace-only", "air-region-x2-yield-contract-created", "air-region-x2-side-hole-yield-created", "air-region-x2-region-locality-enforced", "air-region-x2-explicit-yield-only", "air-region-x2-parent-integration-deferred", "air-region-x2-no-boolean", "air-region-x2-no-brep-emission", "air-region-x2-no-step-smoke", "air-region-x2-trace-only", .. side.CirMirror!.Diagnostics, .. side.BrepBoundary!.Diagnostics, .. side.IntegrationDecision!.Diagnostics, .. side.BrepPlaceholders!.Diagnostics, .. side.Materialization!.Diagnostics], ["escapes only through explicit yield", "no Boolean", "no production route replacement", .. side.CirMirror.Guarantees, .. side.BrepBoundary.Guarantees, .. side.IntegrationDecision.Guarantees, .. side.BrepPlaceholders.Guarantees, .. side.Materialization.Guarantees]);+ return Summary([root, side], ["air-region-x1-region-trace-created", "air-region-x1-no-implicit-parent-mutation", "air-region-x1-no-boolean", "air-region-x1-no-brep-emission", "air-region-x1-no-production-route-replacement", "air-region-x1-trace-only", "air-region-x2-yield-contract-created", "air-region-x2-side-hole-yield-created", "air-region-x2-region-locality-enforced", "air-region-x2-explicit-yield-only", "air-region-x2-parent-integration-deferred", "air-region-x2-no-boolean", "air-region-x2-no-brep-emission", "air-region-x2-no-step-smoke", "air-region-x2-trace-only", .. side.CirMirror!.Diagnostics, .. side.BrepBoundary!.Diagnostics, .. side.IntegrationDecision!.Diagnostics, .. side.BrepPlaceholders!.Diagnostics, .. side.Materialization!.Diagnostics, .. side.ParentIntegration!.Diagnostics], ["escapes only through explicit yield", "no Boolean", "no production route replacement", .. side.CirMirror.Guarantees, .. side.BrepBoundary.Guarantees, .. side.IntegrationDecision.Guarantees, .. side.BrepPlaceholders.Guarantees, .. side.Materialization.Guarantees, .. side.ParentIntegration.Guarantees]);}public static AirRegionTraceSummary ForImplicitParentMutationRejected()diff --git a/docs/air-a1-air-regions-scoped-feature-lowering-audit.md b/docs/air-a1-air-regions-scoped-feature-lowering-audit.mdindex 10a88c11..62daaab4 100644--- a/docs/air-a1-air-regions-scoped-feature-lowering-audit.md+++ b/docs/air-a1-air-regions-scoped-feature-lowering-audit.md@@ -653,3 +653,8 @@ AIR-REGION-X6 adds trace-only side-hole BRepPlan placeholder elements for the Fa## AIR-REGION-X7 noteAIR-REGION-X7 consumes the controlled side-hole placeholder plan for the `+X` fixture and materializes standalone patch evidence for the entry loop, exit loop, and cylindrical cut wall. Parent BRep integration remains deferred; CIR remains analysis-only; Boolean is not generally admitted; no production route replacement or general side-hole support is introduced.+++## AIR-REGION-X8 status note++AIR-REGION-X8 adds a controlled side-hole parent BRep integration attempt to the AIR Region trace. The attempt consumes the X2-X7 evidence chain and reports Outcome B: blocked at parent face splitting/loop insertion, with no fake integrated parent topology, no Boolean use, and no general side-hole support.diff --git a/docs/air-region-x4-side-hole-brep-boundary-contract.md b/docs/air-region-x4-side-hole-brep-boundary-contract.mdindex 13dfc968..f4d7c83f 100644--- a/docs/air-region-x4-side-hole-brep-boundary-contract.md+++ b/docs/air-region-x4-side-hole-brep-boundary-contract.md@@ -108,3 +108,8 @@ AIR-REGION-X6 keeps this X4 boundary contract as intent and adds deterministic p## AIR-REGION-X7 noteAIR-REGION-X7 consumes the controlled side-hole placeholder plan for the `+X` fixture and materializes standalone patch evidence for the entry loop, exit loop, and cylindrical cut wall. Parent BRep integration remains deferred; CIR remains analysis-only; Boolean is not generally admitted; no production route replacement or general side-hole support is introduced.+++## AIR-REGION-X8 parent integration blocker note++AIR-REGION-X8 confirms the X4 boundary contract is sufficient to identify the next topology blocker: the controlled parent path needs parent face splitting and entry/exit loop insertion before the cut-wall evidence can be bound into a closed parent shell.diff --git a/docs/air-region-x5-side-hole-integration-route-decision.md b/docs/air-region-x5-side-hole-integration-route-decision.mdindex 0ecd589f..3cab8d12 100644--- a/docs/air-region-x5-side-hole-integration-route-decision.md+++ b/docs/air-region-x5-side-hole-integration-route-decision.md@@ -71,3 +71,8 @@ AIR-REGION-X6 preserves the X5 `DeferredIntegration` selection and Boolean rejec## AIR-REGION-X7 noteAIR-REGION-X7 consumes the controlled side-hole placeholder plan for the `+X` fixture and materializes standalone patch evidence for the entry loop, exit loop, and cylindrical cut wall. Parent BRep integration remains deferred; CIR remains analysis-only; Boolean is not generally admitted; no production route replacement or general side-hole support is introduced.+++## AIR-REGION-X8 route update note++AIR-REGION-X8 updates the side-hole trace decision to the controlled attempted route `ControlledSideHoleParentBRepIntegration` with status `Blocked`. The prior route scaffold is preserved as evidence; Boolean remains rejected/not generally admitted, and the blocker is parent face splitting plus loop insertion for the controlled fixture.diff --git a/docs/air-region-x6-side-hole-brep-placeholders.md b/docs/air-region-x6-side-hole-brep-placeholders.mdindex ac90b953..c64868d2 100644--- a/docs/air-region-x6-side-hole-brep-placeholders.md+++ b/docs/air-region-x6-side-hole-brep-placeholders.md@@ -104,3 +104,8 @@ The implementation was validated with CLI help/build, side-hole text/JSON traces## AIR-REGION-X7 noteAIR-REGION-X7 consumes the controlled side-hole placeholder plan for the `+X` fixture and materializes standalone patch evidence for the entry loop, exit loop, and cylindrical cut wall. Parent BRep integration remains deferred; CIR remains analysis-only; Boolean is not generally admitted; no production route replacement or general side-hole support is introduced.+++## AIR-REGION-X8 placeholder consumption note++AIR-REGION-X8 consumes all five X6 placeholders in a controlled parent integration attempt. `CutWallFace` maps to preserved X7 cylindrical wall evidence, while `AffectedParentFace`, `CutEntryLoop`, `CutExitLoop`, and `RegionIntegrationPatch` are blocked by the missing parent face split and loop insertion adapter.diff --git a/docs/air-region-x7-side-hole-materialization-golden-path.md b/docs/air-region-x7-side-hole-materialization-golden-path.mdindex df1b93f5..803ec3fc 100644--- a/docs/air-region-x7-side-hole-materialization-golden-path.md+++ b/docs/air-region-x7-side-hole-materialization-golden-path.md@@ -90,3 +90,8 @@ No Boolean backend is used. Boolean remains not generally admitted as the AIR Re## Recommended next milestoneRecommended next: **AIR-REGION-X8 — Side-hole materialization artifact corpus / golden trace summaries**. The parent integration blocker should be approached only after the controlled patch evidence has a stable corpus and golden JSON/text trace summaries.+++## AIR-REGION-X8 parent integration attempt note++AIR-REGION-X8 consumes the X7 standalone patch evidence during a controlled parent BRep integration attempt. The attempt remains truthful Outcome B: the cylindrical cut-wall evidence is preserved, but parent integration is blocked at parent face splitting and entry/exit loop insertion.diff --git a/docs/air-region-x8-side-hole-parent-integration-attempt.md b/docs/air-region-x8-side-hole-parent-integration-attempt.mdnew file mode 100644index 00000000..e6979d98--- /dev/null+++ b/docs/air-region-x8-side-hole-parent-integration-attempt.md@@ -0,0 +1,71 @@+# AIR-REGION-X8 — Side-hole parent integration attempt++## Purpose and scope++AIR-REGION-X8 performs the first controlled parent-body BRep integration attempt for the metadata-driven side-hole `FaceAttachedRegion` fixture. The scope is intentionally narrow: the existing `side-hole-face-attached-region.valid.firmfixture`, a 10 × 8 × 6 parent box, the +X attached face, a radius-1 circular profile, and a through/inward subtractive `SideHole` feature.++## Relationship to AIR-A1 and AIR-REGION-X1 through X7++The trace preserves the existing region chain: `RootRegion`, `FaceAttachedRegion`, the X2 side-hole yield contract, the X3 CIR mirror summary, the X4 BRep boundary contract, the X5 route decision scaffold, the X6 BRepPlan placeholders, and the X7 standalone patch materialization evidence. X8 adds a `parentIntegration` section after consuming those prior artifacts.++## Controlled fixture geometry++- Parent box: 10 × 8 × 6.+- Attached face: +X.+- Profile: circle, radius 1, center `(0, 0)` in the face-attached local frame.+- Direction: through/inward along the local face normal/X axis.+- Effect: subtractive.+- Target: parent body.++## Integration route attempted++The attempted route is `ControlledSideHoleParentBRepIntegration`. It is an internal/test-visible controlled prototype path, not a production route replacement and not general side-hole support.++## Backend path used++Outcome B is implemented. No Boolean-like backend is used. The attempt consumes X6 placeholders and X7 local patch evidence, then blocks before mutating the parent shell because no bounded parent-face splitting and loop-insertion adapter exists for this exact fixture.++## Placeholder consumption++The X8 parent integration attempt maps all X6 placeholders:++| Placeholder | X8 mapping |+| --- | --- |+| `AffectedParentFace` | deferred; requires parent face split |+| `CutEntryLoop` | deferred; requires loop insertion |+| `CutExitLoop` | deferred; requires opposite-face loop insertion |+| `CutWallFace` | preserved from X7 standalone cylindrical wall evidence |+| `RegionIntegrationPatch` | deferred; blocked before parent consumption |++## Parent integration status++Status is `Blocked`. The blocker category is `FaceSplitting`, with code `controlled-side-hole-parent-face-splitting-missing`.++## Topology evidence or blocker++The X7 topology evidence is preserved: a standalone cylindrical cut-wall face and two local patch loops. X8 does not claim a closed parent shell or integrated parent topology. Parent topology counts remain unavailable except for preserved cylindrical wall evidence.++## CIR authority separation++CIR remains analysis-only. The parent integration does not claim topology authority, face identity, entry-loop identity, exit-loop identity, or boundary-patch identity from CIR.++## Boolean policy++Boolean was not used. Boolean remains not generally admitted for AIR Region integration, and X8 does not make Boolean the AIR Region model.++## Non-goals++- No general side-hole support.+- No arbitrary face/axis support.+- No production route replacement.+- No production Firmament grammar expansion.+- No STEP exporter/importer behavior change.+- No BRep topology behavior change outside this controlled prototype trace path.++## Tests run++The implementation was validated with CLI build/help, side-hole text and JSON traces, invalid implicit-parent-mutation JSON trace, parser-backed box trace, and focused filtered .NET tests recorded in the PR summary.++## Recommended next milestone++Recommended: **AIR-REGION-X9 — Controlled side-hole parent face split and loop insertion adapter**. The next milestone should directly address the reported `FaceSplitting` blocker by adding the smallest controlled adapter for the exact +X through-hole fixture, then binding the preserved X7 cylindrical wall evidence into the parent shell.diff --git a/docs/air-x6-aetheris-trace-lowering-report-cli.md b/docs/air-x6-aetheris-trace-lowering-report-cli.mdindex 7be4b970..2592cfe6 100644--- a/docs/air-x6-aetheris-trace-lowering-report-cli.md+++ b/docs/air-x6-aetheris-trace-lowering-report-cli.md@@ -192,3 +192,8 @@ Region fixture traces can now include a `Region BRepPlan placeholders` text sect## AIR-REGION-X7 noteAIR-REGION-X7 consumes the controlled side-hole placeholder plan for the `+X` fixture and materializes standalone patch evidence for the entry loop, exit loop, and cylindrical cut wall. Parent BRep integration remains deferred; CIR remains analysis-only; Boolean is not generally admitted; no production route replacement or general side-hole support is introduced.+++## AIR-REGION-X8 trace note++The side-hole region fixture now includes a `Region parent integration` text section and stable JSON `parentIntegration` object. For X8 it reports `Blocked`, route `ControlledSideHoleParentBRepIntegration`, placeholder mappings, preserved topology evidence, STEP smoke unavailable, and a structured `FaceSplitting` blocker.diff --git a/fixtures/Firmament/Region/valid/side-hole-face-attached-region.valid.firmfixture b/fixtures/Firmament/Region/valid/side-hole-face-attached-region.valid.firmfixtureindex 50946d69..eaa63826 100644--- a/fixtures/Firmament/Region/valid/side-hole-face-attached-region.valid.firmfixture+++ b/fixtures/Firmament/Region/valid/side-hole-face-attached-region.valid.firmfixture@@ -1,6 +1,6 @@// case: side-hole-face-attached-region// expected: valid-// expected-stage: region-materialization-partial+// expected-stage: region-parent-integration-blocked// expected-region-kind: FaceAttachedRegion// expected-effect: Subtractive// expected-yield: YieldSubtractiveVolume@@ -26,8 +26,8 @@// expected-brep-role: CutEntryLoop// expected-brep-role: CutWallFace// expected-brep-loss: no-emitted-entry-loop-identity-// expected-integration-route: ControlledSideHolePatchMaterialization-// expected-integration-status: Deferred+// expected-integration-route: ControlledSideHoleParentBRepIntegration+// expected-integration-status: Blocked// expected-candidate: FaceAttachedConstructiveInsertion:Deferred// expected-candidate: LocalBRepPlanPatch:Deferred// expected-candidate: BRepBooleanFallback:Rejected@@ -36,12 +36,14 @@// expected-reason: no-topology-integration-route-admitted// expected-materialization: PartiallyMaterialized// expected-materialization-route: ControlledSideHolePatchMaterialization-// expected-parent-integration: Deferred+// expected-parent-integration: Blocked+// expected-blocker-category: FaceSplitting+// expected-current-evidence: standalone-patch-materialized// expected-placeholder-materialized: CutEntryLoop// expected-placeholder-materialized: CutExitLoop// expected-placeholder-materialized: CutWallFace// expected-cylindrical-faces-min: 1-// description: Face-attached side-hole fixture with controlled standalone patch materialization; parent integration deferred.+// description: Face-attached side-hole fixture with controlled parent integration attempt blocked at parent face splitting.solid box = Box(width: 10, depth: 8, height: 6);region sideHole on box.face("+X") {