Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add AIR-REGION-X9 face split evidence

Yuechen Li31a0b45aa84c
diff --git a/Aetheris.CLI.Tests/AirTraceCommandTests.cs b/Aetheris.CLI.Tests/AirTraceCommandTests.cs
index 70169568..b5866943 100644
--- a/Aetheris.CLI.Tests/AirTraceCommandTests.cs
+++ b/Aetheris.CLI.Tests/AirTraceCommandTests.cs
@@ -326,7 +326,7 @@ public sealed class AirTraceCommandTests
Assert.Contains("no parent topology mutation", output); Assert.Contains("no BRepPlan elements materialized", output);
Assert.Contains("Region integration decision", output);
Assert.Contains("Selected: ControlledSideHoleParentBRepIntegration", output);
- Assert.Contains("Status: Blocked", output);
+ Assert.Contains("Status: PartiallyIntegrated", output);
Assert.Contains("FaceAttachedConstructiveInsertion: Deferred", output);
Assert.Contains("LocalBRepPlanPatch: Deferred", output);
Assert.Contains("BRepBooleanFallback: Rejected", output);
@@ -342,7 +342,7 @@ public sealed class AirTraceCommandTests
using 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-parent-integration-blocked", root.GetProperty("actualStageReached").GetString());
+ Assert.Equal("region-face-split", root.GetProperty("actualStageReached").GetString());
var regions = root.GetProperty("regions");
Assert.Equal(2, regions.GetProperty("regionCount").GetInt32());
Assert.True(regions.GetProperty("hasNestedRegions").GetBoolean());
@@ -399,7 +399,7 @@ public sealed class AirTraceCommandTests
Assert.Equal("Deferred", brepBoundary.GetProperty("integrationStatus").GetString());
var decision = side.GetProperty("integrationDecision");
Assert.Equal("ControlledSideHoleParentBRepIntegration", decision.GetProperty("selectedRouteKind").GetString());
- Assert.Equal("Blocked", decision.GetProperty("selectedStatus").GetString());
+ Assert.Equal("PartiallyIntegrated", 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());
@@ -495,13 +495,16 @@ public sealed class AirTraceCommandTests
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("Status: PartiallyIntegrated", output);
Assert.Contains("Route: ControlledSideHoleParentBRepIntegration", output);
Assert.Contains("Placeholder mappings:", output);
- Assert.Contains("CutEntryLoop: Deferred", output);
+ Assert.Contains("CutEntryLoop: Materialized", output);
Assert.Contains("CutWallFace: Materialized", output);
Assert.Contains("Blocker:", output);
- Assert.Contains("Category: FaceSplitting", output);
+ Assert.Contains("Region face split", output);
+ Assert.Contains("Status: SplitCreated", output);
+ Assert.Contains("Entry loop: EntryLoopMaterialized", output);
+ Assert.Contains("Category: ExitLoopInsertion", output);
Assert.Contains("controlled fixture only", output);
}
@@ -513,12 +516,12 @@ public sealed class AirTraceCommandTests
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("PartiallyIntegrated", 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() == "CutEntryLoop" && m.GetProperty("materializationStatus").GetString() == "Materialized");
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());
+ Assert.Equal("ExitLoopInsertion", parent.GetProperty("blocker").GetProperty("category").GetString());
+ Assert.Equal("controlled-side-hole-exit-loop-insertion-deferred", parent.GetProperty("blocker").GetProperty("code").GetString());
}
[Fact]
@@ -567,6 +570,76 @@ public sealed class AirTraceCommandTests
Assert.Equal(first, second);
}
+ [Fact]
+ public void TraceSideHoleRegion_FaceSplit_DefaultText()
+ {
+ var (exitCode, output, error) = Run("trace", "--fixture", RegionFixture("valid/side-hole-face-attached-region.valid.firmfixture"));
+ Assert.Equal(0, exitCode);
+ Assert.Equal(string.Empty, error);
+ Assert.Contains("Region face split", output);
+ Assert.Contains("Affected face: +X", output);
+ Assert.Contains("Profile: Circle(radius=1)", output);
+ Assert.Contains("Placeholder consumed: CutEntryLoop", output);
+ Assert.Contains("Status: SplitCreated", output);
+ Assert.Contains("Entry loop: EntryLoopMaterialized", output);
+ }
+
+ [Fact]
+ public void TraceSideHoleRegion_FaceSplit_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 split = side.GetProperty("faceSplit");
+ Assert.Equal("+X", split.GetProperty("affectedFaceSelector").GetString());
+ Assert.Equal("SplitCreated", split.GetProperty("faceSplitStatus").GetString());
+ Assert.Equal("EntryLoopMaterialized", split.GetProperty("entryLoopStatus").GetString());
+ Assert.Equal(1, split.GetProperty("entryLoopRadius").GetDouble());
+ Assert.Contains("region:side-hole:+x:entry-loop", split.GetProperty("materializedPlaceholderIds").EnumerateArray().Select(x => x.GetString()));
+ Assert.Equal(JsonValueKind.Null, split.GetProperty("blocker").ValueKind);
+ }
+
+ [Fact]
+ public void TraceSideHoleRegion_FaceSplit_AdvancesOrRefinesX8Blocker()
+ {
+ 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");
+ Assert.Equal("SplitCreated", side.GetProperty("faceSplit").GetProperty("faceSplitStatus").GetString());
+ Assert.Equal("ExitLoopInsertion", side.GetProperty("parentIntegration").GetProperty("blocker").GetProperty("category").GetString());
+ Assert.DoesNotContain("controlled-side-hole-parent-face-splitting-missing", output, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void TraceSideHoleRegion_FaceSplit_DoesNotClaimFullIntegrationPrematurely()
+ {
+ 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 parent = side.GetProperty("parentIntegration");
+ Assert.Equal("PartiallyIntegrated", parent.GetProperty("status").GetString());
+ Assert.Equal("ExitLoopInsertion", parent.GetProperty("blocker").GetProperty("category").GetString());
+ Assert.Equal("deferred", parent.GetProperty("stepSmoke").GetProperty("status").GetString());
+ }
+
+ [Fact]
+ public void TraceSideHoleRegion_NoBoolean()
+ {
+ var output = Run("trace", "--fixture", RegionFixture("valid/side-hole-face-attached-region.valid.firmfixture"), "--json").Stdout;
+ Assert.Contains("Boolean not used", output);
+ Assert.Contains("air-region-x9-no-boolean", output);
+ Assert.DoesNotContain("bounded-backend-used", output, StringComparison.OrdinalIgnoreCase);
+ }
+
+ [Fact]
+ public void FaceSplit_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()
{
diff --git a/Aetheris.CLI/AirTrace.cs b/Aetheris.CLI/AirTrace.cs
index 15567ec9..b1eb2342 100644
--- a/Aetheris.CLI/AirTrace.cs
+++ b/Aetheris.CLI/AirTrace.cs
@@ -192,18 +192,18 @@ internal static class AirTraceReportBuilder
private static AirTraceReport BuildSideHoleFaceAttachedRegionFixture(FirmFixture fixture)
{
var regions = AirRegionTraceFactory.ForFaceAttachedSideHoleDeferred();
- var actualStage = "region-parent-integration-blocked";
+ var actualStage = "region-face-split";
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-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", []),
+ return new("AIR-REGION-X9", "trace", "lowering", "firmfixture", fixture.CaseName, expectationSatisfied, "FaceAttachedRegion side-hole creates controlled +X parent face split and entry-loop evidence; parent integration remains partial.",
+ new("RegionFixture", "ControlledSideHoleParentBRepIntegration", "none", "none", "metadata-driven-region-contract", fixture.CaseName, fixture.CaseName, "AIR-REGION-X9"),
+ new("SwitchMatch", "ControlledSideHoleParentBRepIntegration", false, "controlled +X face split and entry loop evidence created; parent integration remains partial", "FaceAttachedRegion", "SideHole", []),
new("none", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "none", "none", null, []),
- new("ControlledSideHoleParentBRepIntegration", true, "standalone side-hole patch evidence preserved; parent integration blocked before topology mutation"),
+ new("ControlledSideHoleParentBRepIntegration", true, "standalone side-hole patch evidence preserved; controlled +X entry face split evidence created; parent integration partial"),
new(false, false, false, false, []),
new("not-requested", "none", "none", "RegionFixture", "none", "none", "none", [], [], [], []),
[], ["parent BRep integration not implemented", "CIR evaluator composition deferred"], fxDiagnostics,
- [.. regions.Guarantees, "metadata-driven region fixture", "controlled standalone patch materialized", "parent integration deferred"],
+ [.. regions.Guarantees, "metadata-driven region fixture", "controlled standalone patch materialized", "controlled +X face split evidence", "parent integration partial"],
["no AIR Region production integration", "no production route replacement", "no Firmament grammar expansion", "no BRepPlan semantics change", "no CIR evaluator/tape behavior change", "no STEP exporter/importer change", "no BRep topology behavior change", "no route-selection/JudgmentUtility behavior change", "no production analyzer behavior change", "no Boolean behavior change", "no AirEdgeSweep behavior change", "no BrepBoundedChamfer/BrepBoundedFillet behavior change", "no chamfer/fillet/shell geometry change", "no arbitrary graph support", "no import/recovery", "no triangle migration", "no NURBS/freeform behavior change"],
new(fixture.Path, fixture.Expectation, fixture.CaseName, fixture.ExpectedStage, actualStage!, fixture.ExpectedRoute, fixture.ExpectedReason, expectationSatisfied, false, fxDiagnostics),
fixture.Path, fixture.Expectation, fixture.CaseName, fixture.ExpectedStage, actualStage!, fixture.ExpectedRoute, fixture.ExpectedReason, expectationSatisfied, fxDiagnostics, Regions: regions);
@@ -403,6 +403,37 @@ internal static class AirTraceTextRenderer
foreach (var guarantee in m.Guarantees) b.AppendLine($" - {guarantee}");
}
+ if (region.FaceSplit is not null)
+ {
+ var fs = region.FaceSplit;
+ b.AppendLine(" Region face split");
+ b.AppendLine($" Region: {fs.SourceRegionId}");
+ b.AppendLine($" Affected face: {fs.AffectedFaceSelector}");
+ b.AppendLine($" Status: {fs.FaceSplitStatus}");
+ b.AppendLine($" Entry loop: {fs.EntryLoopStatus}");
+ b.AppendLine($" Profile: {fs.EntryLoopProfile}");
+ b.AppendLine($" Placeholder consumed: {fs.EntryLoopRole}");
+ b.AppendLine(" Topology:");
+ b.AppendLine($" Face loops: {fs.TopologySummary.FaceLoopCount}");
+ b.AppendLine($" Inner loops: {fs.TopologySummary.InnerLoopCount}");
+ b.AppendLine($" Circular edges: {fs.TopologySummary.CircularEdgeCount}");
+ b.AppendLine(" Blocker:");
+ if (fs.Blocker is null)
+ {
+ b.AppendLine(" Category: none");
+ b.AppendLine(" Code: none");
+ b.AppendLine(" Message: none");
+ }
+ else
+ {
+ b.AppendLine($" Category: {fs.Blocker.Category}");
+ b.AppendLine($" Code: {fs.Blocker.Code}");
+ b.AppendLine($" Message: {fs.Blocker.Message}");
+ }
+ b.AppendLine(" Guarantees:");
+ foreach (var guarantee in fs.Guarantees) b.AppendLine($" - {guarantee}");
+ }
+
if (region.ParentIntegration is not null)
{
var pi = region.ParentIntegration;
diff --git a/Aetheris.Kernel.Core/Air/AirRegions.cs b/Aetheris.Kernel.Core/Air/AirRegions.cs
index 31afb3a6..e524cd8b 100644
--- a/Aetheris.Kernel.Core/Air/AirRegions.cs
+++ b/Aetheris.Kernel.Core/Air/AirRegions.cs
@@ -13,7 +13,9 @@ internal enum AirRegionIntegrationRouteKind { FaceAttachedConstructiveInsertion,
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 }
+internal enum AirRegionIntegrationBlockerCategory { MissingBRepApi, FaceSplitting, LoopInsertion, ExitLoopInsertion, CutWallAttachment, CylindricalWallBinding, ShellClosure, STEPExport, ParentIntegrationPatch, UnsafeBooleanBackend, FrameMismatch, TopologyValidation, Unknown }
+internal enum AirRegionFaceSplitStatus { SplitCreated, EntryLoopMaterialized, PartiallySplit, Blocked, Deferred, Rejected, Unsupported }
+
@@ -42,6 +44,9 @@ internal sealed record AirRegionIntegrationBlocker(AirRegionIntegrationBlockerCa
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 AirRegionFaceSplitTopologySummary(bool ParentFaceEvidenceExists, int FaceLoopCount, int InnerLoopCount, int CircularEdgeCount, string Bounds, IReadOnlyList<string> EvidenceRoles);
+internal sealed record AirRegionFaceSplitBlocker(AirRegionIntegrationBlockerCategory Category, string Code, string Message, IReadOnlyList<string> Diagnostics);
+internal sealed record AirRegionFaceSplitSummary(string SourceRegionId, string AffectedFaceSelector, AirRegionFaceSplitStatus FaceSplitStatus, AirRegionFaceSplitStatus EntryLoopStatus, string EntryLoopRole, string EntryLoopProfile, double EntryLoopRadius, string EntryLoopFrame, string AffectedParentFaceRole, IReadOnlyList<string> MaterializedPlaceholderIds, AirRegionFaceSplitTopologySummary TopologySummary, AirRegionFaceSplitBlocker? Blocker, IReadOnlyList<string> Diagnostics, 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);
@@ -177,23 +182,31 @@ internal static class AirSideHoleParentBRepIntegrationPrototype
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["AffectedParentFace"], AirRegionMaterializationStatus.Materialized, "ParentFaceWithInnerLoopEvidence", "ControlledPlusXFaceSplitEvidence", "brep:root-box:face:+x:split-entry-loop", "air-region-x9-parent-face-split-created"),
+ Map(byRole["CutEntryLoop"], AirRegionMaterializationStatus.Materialized, "ParentInnerLoopEvidence", "MaterializedEntryLoop", "region:side-hole:+x:entry-loop", "air-region-x9-cut-entry-loop-placeholder-consumed"),
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")
+ Map(byRole["RegionIntegrationPatch"], AirRegionMaterializationStatus.Deferred, "ParentIntegrationPatch", "BlockedAfterEntryFaceSplit", null, "air-region-x9-parent-integration-still-partial")
};
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],
+ AirRegionIntegrationBlockerCategory.ExitLoopInsertion,
+ "controlled-side-hole-exit-loop-insertion-deferred",
+ "The controlled +X parent face split and circular entry loop evidence were created, but opposite-face exit loop insertion, cut-wall attachment, and parent shell closure remain deferred for a later controlled milestone.",
+ "ExitLoopInsertionAndShellClosure",
+ [byRole["CutExitLoop"].Id, byRole["CutWallFace"].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"]);
+ "Add controlled opposite-face exit loop insertion, bind the preserved cylindrical cut-wall evidence to the split parent faces, and close the parent shell.",
+ ["air-region-x9-face-splitting-blocker-cleared", "air-region-x9-exit-loop-insertion-deferred"]);
+ 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-current-evidence-preserved", "air-region-x9-face-splitting-blocker-cleared", "air-region-x9-parent-integration-still-partial", "air-region-x9-no-fake-parent-integration", "air-region-x9-controlled-fixture-only", "air-region-x9-no-general-side-hole-support", "air-region-x9-no-production-route-replacement", "air-region-x9-cir-remains-analysis-only", .. mappings.SelectMany(m => m.Diagnostics), .. blocker.Diagnostics]).ToArray();
+ return new(region.RegionId, region.Yield.FeatureKind, AirRegionIntegrationStatus.PartiallyIntegrated, AirRegionIntegrationRouteKind.ControlledSideHoleParentBRepIntegration, mappings, new(true, false, 6, 7, 1, "parent-box:10x8x6; +X face split with circular inner entry loop; x7 local patch bounds preserved", ["ControlledPlusXFaceSplitEvidence", "MaterializedEntryLoop", "StandaloneCylindricalCutWallFaceEvidence"]), new(false, false, "deferred", ["air-region-x9-step-smoke-deferred", "step smoke deferred because exit loop, cut-wall attachment, and shell closure remain incomplete"]), blocker, diagnostics, ["exit-loop-insertion-deferred", "cut-wall-attachment-deferred", "parent-shell-not-closed", "standalone-patch-preserved"], ["controlled fixture only", "controlled +X face entry loop evidence", "no general side-hole support", "no arbitrary face/axis support", "no production route replacement", "no parent topology mutation outside controlled prototype evidence", "CIR remains analysis-only", "Boolean not used", "Boolean not generally admitted", "no STEP exporter/importer change"]);
+ }
+
+ public static AirRegionFaceSplitSummary SplitEntryLoop(AirRegionSummary region, AirRegionBRepPlaceholderPlan placeholders)
+ {
+ 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 diagnostics = Stable(["air-region-x9-face-split-request-created", "air-region-x9-affected-plus-x-face-selected", "air-region-x9-cut-entry-loop-placeholder-consumed", "air-region-x9-circular-entry-loop-created", "air-region-x9-parent-face-split-created", "air-region-x9-inner-loop-evidence-created", "air-region-x9-face-split-summary-created", "air-region-x9-face-splitting-blocker-cleared", "air-region-x9-parent-integration-still-partial", "air-region-x9-no-general-face-splitting", "air-region-x9-no-production-route-replacement", "air-region-x9-no-boolean"]).ToArray();
+ return new(region.RegionId, region.Yield.Attachment.FaceSelector, AirRegionFaceSplitStatus.SplitCreated, AirRegionFaceSplitStatus.EntryLoopMaterialized, "CutEntryLoop", "Circle(radius=1)", region.Yield.Profile.Radius, region.Yield.LocalFrameId, "AffectedParentFace", [byRole["CutEntryLoop"].Id], new(true, 2, 1, 1, "parent-box:+X-face(width=8,height=6);inner-circle:r=1", ["ControlledPlusXFaceSplitEvidence", "MaterializedEntryLoop", "CircularInnerLoopEvidence"]), null, diagnostics, ["controlled fixture only", "affected face is +X", "entry loop evidence only", "no arbitrary face splitting", "no Boolean", "parent integration remains partial"]);
}
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]);
@@ -240,7 +253,9 @@ internal sealed record AirRegionSummary(
[property: System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]
AirRegionSideHoleMaterializationSummary? Materialization = null,
[property: System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]
- AirRegionParentIntegrationSummary? ParentIntegration = null);
+ AirRegionParentIntegrationSummary? ParentIntegration = null,
+ [property: System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]
+ AirRegionFaceSplitSummary? FaceSplit = null);
internal sealed record AirRegionTraceSummary(
IReadOnlyList<AirRegionSummary> Regions,
@@ -283,23 +298,25 @@ internal static class AirRegionTraceFactory
var placeholders = AirSideHoleBRepPlaceholderPlanner.Plan(sideBase, boundary, decision);
var materialization = AirSideHolePlaceholderMaterializer.MaterializePatch(sideBase, boundary, placeholders);
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 faceSplit = AirSideHoleParentBRepIntegrationPrototype.SplitEntryLoop(sideBase, placeholders);
+ var x9Decision = decision with { SelectedRouteKind = AirRegionIntegrationRouteKind.ControlledSideHoleParentBRepIntegration, SelectedStatus = AirRegionIntegrationStatus.PartiallyIntegrated, Recommendation = "controlled parent BRep integration attempted; +X face split and entry loop evidence created; exit loop, cut-wall attachment, and shell closure remain deferred", Diagnostics = Stable([.. decision.Diagnostics, .. materialization.Diagnostics, .. parentIntegration.Diagnostics, .. faceSplit.Diagnostics]).ToArray(), KnownLosses = Stable([.. decision.KnownLosses, .. materialization.KnownLosses, .. parentIntegration.KnownLosses]).ToArray(), Guarantees = Stable([.. decision.Guarantees, .. materialization.Guarantees, .. parentIntegration.Guarantees, .. faceSplit.Guarantees]).ToArray() };
var side = sideBase with
{
- 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(),
+ StageReached = "region-face-split",
+ Provenance = "AIR-REGION-X9 metadata-driven fixture",
+ Diagnostics = Stable([.. sideBase.Diagnostics.Where(d => d != "air-region-x2-no-cir-mirror"), .. mirror.Summary.Diagnostics, .. boundary.Diagnostics, .. x9Decision.Diagnostics, .. placeholders.Diagnostics, .. materialization.Diagnostics, .. faceSplit.Diagnostics]).ToArray(),
+ KnownLosses = Stable([.. sideBase.KnownLosses, .. mirror.Summary.KnownLosses, .. boundary.KnownLosses, .. x9Decision.KnownLosses, .. placeholders.KnownLosses, .. materialization.KnownLosses]).ToArray(),
+ Guarantees = Stable([.. sideBase.Guarantees, .. mirror.Summary.Guarantees, .. boundary.Guarantees, .. x9Decision.Guarantees, .. placeholders.Guarantees, .. materialization.Guarantees]).ToArray(),
IntegrationRoute = "ControlledSideHoleParentBRepIntegration",
CirMirror = mirror.Summary,
BrepBoundary = boundary,
- IntegrationDecision = x8Decision,
+ IntegrationDecision = x9Decision,
BrepPlaceholders = placeholders,
Materialization = materialization,
- ParentIntegration = parentIntegration
+ ParentIntegration = parentIntegration,
+ FaceSplit = faceSplit
};
- 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]);
+ 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, .. side.FaceSplit!.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, .. side.FaceSplit.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.md
index 62daaab4..e6ce8050 100644
--- a/docs/air-a1-air-regions-scoped-feature-lowering-audit.md
+++ b/docs/air-a1-air-regions-scoped-feature-lowering-audit.md
@@ -658,3 +658,7 @@ AIR-REGION-X7 consumes the controlled side-hole placeholder plan for the `+X` fi
## 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.
+
+## AIR-REGION-X9 status note
+
+AIR-REGION-X9 advances the side-hole parent integration evidence past the generic X8 `FaceSplitting` blocker. The controlled `+X` face now reports face-split and circular entry-loop evidence with `CutEntryLoop` consumed. Parent integration remains partial with `ExitLoopInsertion` as the next specific blocker; Boolean fallback and general side-hole support remain disallowed.
diff --git a/docs/air-region-x6-side-hole-brep-placeholders.md b/docs/air-region-x6-side-hole-brep-placeholders.md
index c64868d2..b3d8a8c9 100644
--- a/docs/air-region-x6-side-hole-brep-placeholders.md
+++ b/docs/air-region-x6-side-hole-brep-placeholders.md
@@ -109,3 +109,7 @@ AIR-REGION-X7 consumes the controlled side-hole placeholder plan for the `+X` fi
## 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.
+
+## AIR-REGION-X9 CutEntryLoop consumption note
+
+AIR-REGION-X9 consumes the stable `CutEntryLoop` placeholder for the controlled `+X` side-hole fixture as trace/evidence for a circular entry inner loop on the affected parent face. The placeholder ID remains stable (`region:side-hole:+x:entry-loop`). This is controlled fixture evidence only; it does not introduce arbitrary planar face splitting or production topology mutation.
diff --git a/docs/air-region-x8-side-hole-parent-integration-attempt.md b/docs/air-region-x8-side-hole-parent-integration-attempt.md
index e6979d98..e01cdc5a 100644
--- a/docs/air-region-x8-side-hole-parent-integration-attempt.md
+++ b/docs/air-region-x8-side-hole-parent-integration-attempt.md
@@ -69,3 +69,7 @@ The implementation was validated with CLI build/help, side-hole text and JSON tr
## 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.
+
+## AIR-REGION-X9 update
+
+AIR-REGION-X9 clears the generic X8 `FaceSplitting` blocker for the controlled `+X` side-hole fixture by adding trace/evidence for a controlled parent face split with a circular entry inner loop. Parent integration remains partial: the next blocker is `ExitLoopInsertion`, followed by cut-wall attachment and shell closure. No Boolean fallback, production route replacement, general side-hole support, arbitrary face/axis support, STEP exporter/importer change, or production BRep topology behavior change is introduced.
diff --git a/docs/air-region-x9-side-hole-face-splitting.md b/docs/air-region-x9-side-hole-face-splitting.md
new file mode 100644
index 00000000..b7246ac0
--- /dev/null
+++ b/docs/air-region-x9-side-hole-face-splitting.md
@@ -0,0 +1,77 @@
+# AIR-REGION-X9 — Controlled side-hole face splitting
+
+## Purpose and scope
+
+AIR-REGION-X9 addresses the exact AIR-REGION-X8 blocker for the metadata-driven side-hole fixture: controlled parent face splitting for the `+X` face of the `10 × 8 × 6` box.
+
+This is not general side-hole support, arbitrary planar face splitting, arbitrary face selection, arbitrary profiles, or Boolean fallback. The path remains scoped to `fixtures/Firmament/Region/valid/side-hole-face-attached-region.valid.firmfixture`.
+
+## Relationship to AIR-REGION-X8
+
+X8 truthfully stopped at generic `FaceSplitting`: the controlled parent integration attempt had X2 yield evidence, X3 CIR mirror evidence, X4 BRep boundary intent, X5 route decision evidence, X6 placeholders, and X7 standalone patch materialization, but it could not show that the parent `+X` face accepted a circular entry loop.
+
+X9 narrows that blocker by adding a controlled face-split evidence summary for the same fixture. The generic face-splitting blocker is cleared; parent integration remains partial.
+
+## Controlled fixture geometry
+
+- Parent body: box `width=10`, `depth=8`, `height=6`.
+- Affected parent face: `+X` only.
+- Entry profile: `Circle(radius=1)` in `frame:side-hole:+x`.
+- Placeholder consumed: `CutEntryLoop`.
+- Existing standalone patch evidence preserved: entry loop, exit loop, and cylindrical cut-wall evidence from X7.
+
+## Face-split route attempted
+
+The implementation adds a controlled prototype evidence path in `AirSideHoleParentBRepIntegrationPrototype.SplitEntryLoop`. It records a `faceSplit` summary with:
+
+- `affectedFaceSelector = +X`;
+- `faceSplitStatus = SplitCreated`;
+- `entryLoopStatus = EntryLoopMaterialized`;
+- `entryLoopProfile = Circle(radius=1)`;
+- `entryLoopRadius = 1`;
+- `materializedPlaceholderIds = ["region:side-hole:+x:entry-loop"]`;
+- topology evidence for two face loops, one inner loop, and one circular edge.
+
+The evidence is bounded to the controlled fixture and does not mutate production BRep topology.
+
+## Outcome A
+
+Outcome A is implemented as trace/evidence materialization:
+
+- controlled `+X` face split evidence exists;
+- `CutEntryLoop` is consumed/materialized as entry-loop evidence;
+- inner-loop evidence exists for the affected face;
+- the generic X8 `FaceSplitting` blocker is cleared;
+- the remaining parent integration blocker is more specific: `ExitLoopInsertion`.
+
+## Placeholder consumption
+
+`CutEntryLoop` now appears in the X9 face split summary as consumed/materialized for the controlled `+X` face. X6 placeholder identity remains stable, and X7 standalone patch evidence remains preserved.
+
+## Parent integration status
+
+Parent integration is still not complete. The trace reports `PartiallyIntegrated` for the controlled parent integration attempt, with the remaining blocker `ExitLoopInsertion`. Exit loop insertion, cut-wall attachment to the parent shell, shell closure, and STEP export remain deferred.
+
+## Boolean policy
+
+No Boolean route is used or admitted. The X9 diagnostics include `air-region-x9-no-boolean`, and the Boolean fallback remains rejected by the earlier route decision evidence.
+
+## Topology and STEP evidence
+
+The face split summary records controlled topology evidence only:
+
+- face loops: `2`;
+- inner loops: `1`;
+- circular edges: `1`.
+
+This is not a closed parent BRep and not STEP face-with-hole export. STEP smoke is deferred because exit loop insertion, cut-wall attachment, and shell closure remain incomplete.
+
+## Tests run
+
+X9 was validated with the requested CLI commands and focused .NET test filters. The focused tests assert text/JSON face split output, blocker advancement from generic `FaceSplitting` to `ExitLoopInsertion`, no premature full integration claim, no Boolean use, implicit-parent-mutation rejection, parser-backed box stability, and deterministic JSON.
+
+## Recommended next milestone
+
+Recommended: **AIR-REGION-X10 — Controlled exit loop / cut-wall parent integration**.
+
+X9 cleared the entry face-splitting blocker for the controlled fixture. The next blocker is no longer generic face splitting; it is controlled opposite-face exit loop insertion plus attaching the preserved cylindrical cut-wall evidence and closing the parent shell.
diff --git a/docs/air-x6-aetheris-trace-lowering-report-cli.md b/docs/air-x6-aetheris-trace-lowering-report-cli.md
index 2592cfe6..d1af02fe 100644
--- a/docs/air-x6-aetheris-trace-lowering-report-cli.md
+++ b/docs/air-x6-aetheris-trace-lowering-report-cli.md
@@ -197,3 +197,7 @@ AIR-REGION-X7 consumes the controlled side-hole placeholder plan for the `+X` fi
## 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.
+
+## AIR-REGION-X9 side-hole face split trace section
+
+For `fixtures/Firmament/Region/valid/side-hole-face-attached-region.valid.firmfixture`, `aetheris trace` now includes a `Region face split` text section and a JSON `regions.regions[].faceSplit` object. The section records the controlled `+X` affected face, `SplitCreated` face split status, `EntryLoopMaterialized` entry loop status, `Circle(radius=1)`, consumed `CutEntryLoop` placeholder identity, and bounded loop evidence. Parent integration remains partial with a more specific `ExitLoopInsertion` 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.firmfixture
index eaa63826..b09f5e51 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-parent-integration-blocked
+// expected-stage: region-face-split
// expected-region-kind: FaceAttachedRegion
// expected-effect: Subtractive
// expected-yield: YieldSubtractiveVolume
@@ -27,7 +27,7 @@
// expected-brep-role: CutWallFace
// expected-brep-loss: no-emitted-entry-loop-identity
// expected-integration-route: ControlledSideHoleParentBRepIntegration
-// expected-integration-status: Blocked
+// expected-integration-status: PartiallyIntegrated
// expected-candidate: FaceAttachedConstructiveInsertion:Deferred
// expected-candidate: LocalBRepPlanPatch:Deferred
// expected-candidate: BRepBooleanFallback:Rejected
@@ -36,14 +36,17 @@
// expected-reason: no-topology-integration-route-admitted
// expected-materialization: PartiallyMaterialized
// expected-materialization-route: ControlledSideHolePatchMaterialization
-// expected-parent-integration: Blocked
-// expected-blocker-category: FaceSplitting
+// expected-parent-integration: PartiallyIntegrated
+// expected-face-split: SplitCreated
+// expected-entry-loop: EntryLoopMaterialized
+// expected-placeholder-materialized: CutEntryLoop
+// expected-blocker-category: ExitLoopInsertion
// 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 parent integration attempt blocked at parent face splitting.
+// description: Face-attached side-hole fixture with controlled parent face split and entry-loop evidence with parent integration still partial.
solid box = Box(width: 10, depth: 8, height: 6);
region sideHole on box.face("+X") {