Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add mirror-aware CIR map dispatch prototype
Yuechen Li4fe31398b527
diff --git a/Aetheris.Kernel.Core.Tests/Cir/CirMapDispatchPrototypeTests.cs b/Aetheris.Kernel.Core.Tests/Cir/CirMapDispatchPrototypeTests.csnew file mode 100644index 00000000..11303557--- /dev/null+++ b/Aetheris.Kernel.Core.Tests/Cir/CirMapDispatchPrototypeTests.cs@@ -0,0 +1,319 @@+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Cir;+using Aetheris.Kernel.Core.Cir.Mirrors;+using Aetheris.Kernel.Core.Math;++namespace Aetheris.Kernel.Core.Tests.Cir;++public sealed class CirMapDispatchPrototypeTests+{+ private const int Rows = 17;+ private const int Cols = 19;+ private const double ThicknessTolerance = 0.075d;++ public static TheoryData<string, int, CirNode, BrepBody, CirMapPrototypeView> PrimitiveViews => new()+ {+ { "box", (int)CirMirrorAtomKind.BoxPrimitive, new CirBoxNode(10d, 6d, 4d), BrepPrimitives.CreateBox(10d, 6d, 4d).Value, CirMapPrototypeView.Top },+ { "box", (int)CirMirrorAtomKind.BoxPrimitive, new CirBoxNode(10d, 6d, 4d), BrepPrimitives.CreateBox(10d, 6d, 4d).Value, CirMapPrototypeView.Front },+ { "cylinder", (int)CirMirrorAtomKind.CylinderPrimitive, new CirCylinderNode(3d, 8d), BrepPrimitives.CreateCylinder(3d, 8d).Value, CirMapPrototypeView.Top },+ { "cylinder", (int)CirMirrorAtomKind.CylinderPrimitive, new CirCylinderNode(3d, 8d), BrepPrimitives.CreateCylinder(3d, 8d).Value, CirMapPrototypeView.Front },+ { "sphere", (int)CirMirrorAtomKind.SpherePrimitive, new CirSphereNode(3d), BrepPrimitives.CreateSphere(3d).Value, CirMapPrototypeView.Top },+ { "sphere", (int)CirMirrorAtomKind.SpherePrimitive, new CirSphereNode(3d), BrepPrimitives.CreateSphere(3d).Value, CirMapPrototypeView.Front },+ };++ [Theory]+ [MemberData(nameof(PrimitiveViews))]+ public void CirMapX2_PrimitiveMapOccupancy_SelectsCirTapeAndComparesBrepBaseline(string source, int atomKindValue, CirNode node, BrepBody body, CirMapPrototypeView view)+ {+ var request = new CirMapPrototypeRequest(view, Rows, Cols, node.Bounds, SamplesPerRay: 384, RootRefinementIterations: 32, Tolerance: 1e-7d);+ var dispatch = CirMapDispatchPrototype.Dispatch(CreateRequest(source, (CirMirrorAtomKind)atomKindValue, CirMapAnalyzerUse.MapOccupancy), CirMapAnalyzerUse.MapOccupancy, node, request, body, ThicknessTolerance);++ Assert.Equal(CirMapBackendKind.CirTape, dispatch.SelectedBackend);+ Assert.Equal(CirMirrorStatus.MirrorAdmittedExact, dispatch.MirrorAdmission.Status);+ Assert.Equal("cir-map-dispatch-ready-for-primitive-lab", dispatch.Recommendation);+ Assert.NotNull(dispatch.MapResult);+ Assert.NotNull(dispatch.BrepBaselineComparison);+ Assert.True(dispatch.BrepBaselineComparison.ParitySucceeded);+ Assert.Equal(dispatch.BrepBaselineComparison.BrepSummary.HitSamples, dispatch.MapResult.Summary.HitSamples);+ Assert.Equal(dispatch.BrepBaselineComparison.BrepSummary.EmptySamples, dispatch.MapResult.Summary.EmptySamples);+ Assert.InRange(dispatch.BrepBaselineComparison.ThicknessMinDelta!.Value, 0d, ThicknessTolerance);+ Assert.InRange(dispatch.BrepBaselineComparison.ThicknessMaxDelta!.Value, 0d, ThicknessTolerance);+ Assert.InRange(dispatch.BrepBaselineComparison.ThicknessAverageDelta!.Value, 0d, ThicknessTolerance);+ Assert.Contains("cir-map-x2-dispatch-started", dispatch.Diagnostics);+ Assert.Contains($"cir-map-x2-mirror-admission-requested:{source}", dispatch.Diagnostics);+ Assert.Contains($"cir-map-x2-mirror-admitted-exact:{source}", dispatch.Diagnostics);+ Assert.Contains("cir-map-x2-backend-selected:cir-tape", dispatch.Diagnostics);+ Assert.Contains($"cir-map-x2-brep-baseline-compared:{source}", dispatch.Diagnostics);+ Assert.Contains($"cir-map-x2-map-parity-succeeded:{source}", dispatch.Diagnostics);+ Assert.Contains("cir-map-x2-no-production-analyzer-behavior-changed", dispatch.Diagnostics);+ }++ [Fact]+ public void CirMapX2_BoxFaceIdentityRequest_RejectsCirAsLossy()+ {+ var node = new CirBoxNode(10d, 6d, 4d);+ var request = new CirMapPrototypeRequest(CirMapPrototypeView.Top, Rows, Cols, node.Bounds, SamplesPerRay: 128, RootRefinementIterations: 24, Tolerance: 1e-7d);++ var dispatch = CirMapDispatchPrototype.Dispatch(CreateRequest("box", CirMirrorAtomKind.BoxPrimitive, CirMapAnalyzerUse.FaceIdentity), CirMapAnalyzerUse.FaceIdentity, node, request);++ Assert.Equal(CirMapBackendKind.Unsupported, dispatch.SelectedBackend);+ Assert.Equal(CirMirrorStatus.MirrorRejectedLossyForRequest, dispatch.MirrorAdmission.Status);+ Assert.Null(dispatch.MapResult);+ Assert.Equal("cir-map-dispatch-lossy-request-rejected", dispatch.Recommendation);+ Assert.Contains("cir-map-x2-mirror-rejected-lossy-for-request:face-identity", dispatch.Diagnostics);+ Assert.Contains("cir-map-x2-backend-selected:unsupported", dispatch.Diagnostics);+ }++ [Fact]+ public void CirMapX2_BoxTopologyParityRequest_RejectsCirAsLossy()+ {+ var node = new CirBoxNode(10d, 6d, 4d);+ var request = new CirMapPrototypeRequest(CirMapPrototypeView.Top, Rows, Cols, node.Bounds, SamplesPerRay: 128, RootRefinementIterations: 24, Tolerance: 1e-7d);++ var dispatch = CirMapDispatchPrototype.Dispatch(CreateRequest("box", CirMirrorAtomKind.BoxPrimitive, CirMapAnalyzerUse.TopologyParity), CirMapAnalyzerUse.TopologyParity, node, request);++ Assert.Equal(CirMapBackendKind.Unsupported, dispatch.SelectedBackend);+ Assert.Equal(CirMirrorStatus.MirrorRejectedLossyForRequest, dispatch.MirrorAdmission.Status);+ Assert.Null(dispatch.MapResult);+ Assert.Equal("cir-map-dispatch-lossy-request-rejected", dispatch.Recommendation);+ Assert.Contains("cir-map-x2-mirror-rejected-lossy-for-request:topology-parity", dispatch.Diagnostics);+ Assert.Contains("cir-map-x2-backend-selected:unsupported", dispatch.Diagnostics);+ }++ [Theory]+ [InlineData("prismatic-section-transition", (int)CirMirrorAtomKind.PrismaticSectionTransition, (int)CirMirrorStatus.MirrorRejectedUnsupportedAtom)]+ [InlineData("profile-authored-chamfer", (int)CirMirrorAtomKind.ProfileAuthoredVerticalChamfer, (int)CirMirrorStatus.MirrorUnavailable)]+ public void CirMapX2_UnavailableSources_DoNotSelectCir(string source, int atomKindValue, int expectedStatusValue)+ {+ var bounds = new CirBounds(new Point3D(-1d, -1d, -1d), new Point3D(1d, 1d, 1d));+ var request = new CirMapPrototypeRequest(CirMapPrototypeView.Top, Rows, Cols, bounds, SamplesPerRay: 128, RootRefinementIterations: 24, Tolerance: 1e-7d);++ var dispatch = CirMapDispatchPrototype.Dispatch(CreateRequest(source, (CirMirrorAtomKind)atomKindValue, CirMapAnalyzerUse.MapOccupancy), CirMapAnalyzerUse.MapOccupancy, node: null, request);++ Assert.Equal(CirMapBackendKind.Unsupported, dispatch.SelectedBackend);+ Assert.Equal((CirMirrorStatus)expectedStatusValue, dispatch.MirrorAdmission.Status);+ Assert.Null(dispatch.MapResult);+ Assert.Equal("cir-map-dispatch-mirror-unavailable", dispatch.Recommendation);+ Assert.Contains($"cir-map-x2-mirror-unavailable:{source}", dispatch.Diagnostics);+ Assert.Contains("cir-map-x2-no-prismatic-mirror-used", dispatch.Diagnostics);+ Assert.Contains("cir-map-x2-backend-selected:unsupported", dispatch.Diagnostics);+ }++ [Fact]+ public void CirMapX2_RepeatedDispatchesProduceStableProjection()+ {+ var node = new CirSphereNode(3d);+ var request = new CirMapPrototypeRequest(CirMapPrototypeView.Front, Rows, Cols, node.Bounds, SamplesPerRay: 384, RootRefinementIterations: 32, Tolerance: 1e-7d);++ var first = CirMapDispatchPrototype.Dispatch(CreateRequest("sphere", CirMirrorAtomKind.SpherePrimitive, CirMapAnalyzerUse.MapOccupancy), CirMapAnalyzerUse.MapOccupancy, node, request, BrepPrimitives.CreateSphere(3d).Value, ThicknessTolerance);+ var second = CirMapDispatchPrototype.Dispatch(CreateRequest("sphere", CirMirrorAtomKind.SpherePrimitive, CirMapAnalyzerUse.MapOccupancy), CirMapAnalyzerUse.MapOccupancy, node, request, BrepPrimitives.CreateSphere(3d).Value, ThicknessTolerance);++ Assert.Equal(first.StableProjection(), second.StableProjection());+ }++ private static CirMirrorAdmission CreateRequest(string source, CirMirrorAtomKind atomKind, CirMapAnalyzerUse use) =>+ new(+ CirMirrorSourceRepresentationKind.Air,+ source,+ atomKind,+ CirMapDispatchPrototype.CapabilityForUse(use),+ SourceIdOrLabel: source,+ DiagnosticsLabel: "cir-map-x2");+}++internal enum CirMapAnalyzerUse+{+ MapOccupancy,+ FaceIdentity,+ TopologyParity,+ PointContainment,+ SectionSampling,+}++internal enum CirMapBackendKind+{+ CirTape,+ CirNode,+ BrepRaycastBaseline,+ Unsupported,+}++internal sealed record CirMapBackendCandidate(CirMapBackendKind Kind, bool Admissible, string Reason);++internal sealed record CirMapBaselineComparison(+ CirMapPrototypeSummary CirSummary,+ CirMapPrototypeSummary BrepSummary,+ bool ParitySucceeded,+ double? ThicknessMinDelta,+ double? ThicknessMaxDelta,+ double? ThicknessAverageDelta);++internal sealed record CirMapDispatchResult(+ CirMapBackendKind SelectedBackend,+ CirMirrorAdmissionResult MirrorAdmission,+ IReadOnlyList<CirMapBackendCandidate> Candidates,+ CirMapPrototypeResult? MapResult,+ CirMapBaselineComparison? BrepBaselineComparison,+ IReadOnlyList<string> Diagnostics,+ string Recommendation)+{+ public string StableProjection() => string.Join("|", new[]+ {+ SelectedBackend.ToString(),+ MirrorAdmission.StatusText,+ Recommendation,+ MapResult?.Summary.ToString() ?? "no-map",+ BrepBaselineComparison?.ToString() ?? "no-baseline",+ string.Join(",", Diagnostics),+ });+}++internal static class CirMapDispatchPrototype+{+ public static CirMapDispatchResult Dispatch(+ CirMirrorAdmission mirrorRequest,+ CirMapAnalyzerUse requestedUse,+ CirNode? node,+ CirMapPrototypeRequest mapRequest,+ BrepBody? brepBaselineBody = null,+ double summaryTolerance = 0.075d)+ {+ var source = mirrorRequest.SourceRoute;+ var diagnostics = new List<string>+ {+ "cir-map-x2-dispatch-started",+ $"cir-map-x2-mirror-admission-requested:{source}",+ };++ var admissionRequest = mirrorRequest with { RequestedCapabilities = CapabilityForUse(requestedUse) };+ var admission = CirMirrorAdmissionService.Admit(admissionRequest);+ diagnostics.AddRange(admission.Diagnostics.Select(MapAdmissionDiagnostic));++ if (admission.Status == CirMirrorStatus.MirrorRejectedLossyForRequest || requestedUse is CirMapAnalyzerUse.FaceIdentity or CirMapAnalyzerUse.TopologyParity)+ {+ diagnostics.Add($"cir-map-x2-mirror-rejected-lossy-for-request:{UseToken(requestedUse)}");+ diagnostics.Add("cir-map-x2-backend-selected:unsupported");+ diagnostics.Add("cir-map-x2-no-production-analyzer-behavior-changed");+ return new CirMapDispatchResult(+ CirMapBackendKind.Unsupported,+ admission,+ [new CirMapBackendCandidate(CirMapBackendKind.CirTape, false, "lossy-request-rejected")],+ null,+ null,+ diagnostics,+ "cir-map-dispatch-lossy-request-rejected");+ }++ if (admission.Status == CirMirrorStatus.MirrorAdmittedExact && admission.Supports(CirMirrorCapability.MapOccupancy) && requestedUse == CirMapAnalyzerUse.MapOccupancy && node is not null)+ {+ diagnostics.Add($"cir-map-x2-mirror-admitted-exact:{source}");+ diagnostics.Add("cir-map-x2-backend-selected:cir-tape");+ var map = CirMapPrototype.Evaluate(CirTapeLowerer.Lower(node), node.Bounds, source, mapRequest);+ CirMapBaselineComparison? comparison = null;+ var recommendation = "cir-map-dispatch-ready-for-primitive-lab";++ if (brepBaselineBody is not null)+ {+ var baseline = CirMapPrototype.EvaluateBrepBaseline(brepBaselineBody, source, mapRequest);+ comparison = Compare(map.Summary, baseline.Summary, summaryTolerance);+ diagnostics.Add($"cir-map-x2-brep-baseline-compared:{source}");+ if (comparison.ParitySucceeded)+ {+ diagnostics.Add($"cir-map-x2-map-parity-succeeded:{source}");+ }+ else+ {+ diagnostics.Add($"cir-map-x2-map-parity-warning:{source}:summary-mismatch");+ recommendation = "cir-map-dispatch-needs-tape-hardening";+ }+ }++ diagnostics.Add("cir-map-x2-no-prismatic-mirror-used");+ diagnostics.Add("cir-map-x2-no-production-analyzer-behavior-changed");+ return new CirMapDispatchResult(+ CirMapBackendKind.CirTape,+ admission,+ [new CirMapBackendCandidate(CirMapBackendKind.CirTape, true, "mirror-admitted-exact-map-occupancy")],+ map,+ comparison,+ diagnostics,+ recommendation);+ }++ diagnostics.Add($"cir-map-x2-mirror-unavailable:{source}");+ diagnostics.Add("cir-map-x2-no-prismatic-mirror-used");+ diagnostics.Add("cir-map-x2-backend-selected:unsupported");+ diagnostics.Add("cir-map-x2-no-production-analyzer-behavior-changed");+ return new CirMapDispatchResult(+ CirMapBackendKind.Unsupported,+ admission,+ [new CirMapBackendCandidate(CirMapBackendKind.CirTape, false, admission.StatusText)],+ null,+ null,+ diagnostics,+ "cir-map-dispatch-mirror-unavailable");+ }++ public static CirMirrorCapability CapabilityForUse(CirMapAnalyzerUse use) => use switch+ {+ CirMapAnalyzerUse.MapOccupancy => CirMirrorCapability.MapOccupancy,+ CirMapAnalyzerUse.FaceIdentity => CirMirrorCapability.FaceIdentity,+ CirMapAnalyzerUse.TopologyParity => CirMirrorCapability.TopologyParity,+ CirMapAnalyzerUse.PointContainment => CirMirrorCapability.PointContainment,+ CirMapAnalyzerUse.SectionSampling => CirMirrorCapability.SectionSampling,+ _ => CirMirrorCapability.None,+ };++ private static CirMapBaselineComparison Compare(CirMapPrototypeSummary cir, CirMapPrototypeSummary brep, double tolerance)+ {+ var minDelta = Delta(cir.ThicknessMin, brep.ThicknessMin);+ var maxDelta = Delta(cir.ThicknessMax, brep.ThicknessMax);+ var averageDelta = Delta(cir.ThicknessAverage, brep.ThicknessAverage);+ var paritySucceeded = cir.HitSamples == brep.HitSamples &&+ cir.EmptySamples == brep.EmptySamples &&+ DeltaWithinTolerance(minDelta, tolerance) &&+ DeltaWithinTolerance(maxDelta, tolerance) &&+ DeltaWithinTolerance(averageDelta, tolerance);++ return new CirMapBaselineComparison(cir, brep, paritySucceeded, minDelta, maxDelta, averageDelta);+ }++ private static double? Delta(double? left, double? right) => left is null || right is null ? null : double.Abs(left.Value - right.Value);++ private static bool DeltaWithinTolerance(double? delta, double tolerance) => delta is null || delta.Value <= tolerance;++ private static string MapAdmissionDiagnostic(string diagnostic)+ {+ if (diagnostic.StartsWith("air-cir-x1-mirror-admitted-exact:", StringComparison.Ordinal))+ {+ return diagnostic.Replace("air-cir-x1-mirror-admitted-exact:", "cir-map-x2-mirror-admitted-exact:", StringComparison.Ordinal);+ }++ if (diagnostic.StartsWith("air-cir-x1-mirror-unavailable:", StringComparison.Ordinal))+ {+ return diagnostic.Replace("air-cir-x1-mirror-unavailable:", "cir-map-x2-mirror-unavailable:", StringComparison.Ordinal);+ }++ if (diagnostic.StartsWith("air-cir-x1-mirror-rejected-unsupported-atom:", StringComparison.Ordinal))+ {+ return diagnostic.Replace("air-cir-x1-mirror-rejected-unsupported-atom:", "cir-map-x2-mirror-unavailable:", StringComparison.Ordinal);+ }++ if (diagnostic.StartsWith("air-cir-x1-mirror-rejected-lossy-for-request:", StringComparison.Ordinal))+ {+ return diagnostic.Replace("air-cir-x1-mirror-rejected-lossy-for-request:", "cir-map-x2-mirror-rejected-lossy-for-request:", StringComparison.Ordinal);+ }++ return diagnostic;+ }++ private static string UseToken(CirMapAnalyzerUse use) => use switch+ {+ CirMapAnalyzerUse.MapOccupancy => "map-occupancy",+ CirMapAnalyzerUse.FaceIdentity => "face-identity",+ CirMapAnalyzerUse.TopologyParity => "topology-parity",+ CirMapAnalyzerUse.PointContainment => "point-containment",+ CirMapAnalyzerUse.SectionSampling => "section-sampling",+ _ => "unknown",+ };+}diff --git a/docs/air-cir-x1-mirror-metadata-prototype.md b/docs/air-cir-x1-mirror-metadata-prototype.mdindex 0961c64a..9198cbd5 100644--- a/docs/air-cir-x1-mirror-metadata-prototype.md+++ b/docs/air-cir-x1-mirror-metadata-prototype.md@@ -123,3 +123,7 @@ Recommended next work is one of:1. **CIR-MAP-X2** — mirror-aware primitive map dispatch prototype that consumes X1 metadata while preserving current CLI defaults;2. **CIR-PRISMATIC-X1** — prismatic mirror feasibility for exact section-stack/convex polyhedral fields;3. **EDGE-PRISMATIC-X8** — hybrid map dispatch only after mirror metadata and actual mirror availability exist.++## 13. CIR-MAP-X2 consumption note++CIR-MAP-X2 is the first lab/test-only consumer of `CirMirrorAdmissionService` for map backend selection. The X2 dispatcher asks admission for the requested analyzer use, selects the CIR tape primitive map backend only when a box/cylinder/sphere mirror is `mirror-admitted-exact` for `MapOccupancy`, and rejects face identity/topology parity as lossy. Prismatic section transitions and profile-authored chamfers remain mirror-unavailable or unsupported; no production analyzer, CLI, STEP, Boolean, BRep topology, AIR emitter, CIR node kind, prismatic mirror, or CIR-to-BRep behavior changes are introduced.diff --git a/docs/cir-map-x1-primitive-map-prototype.md b/docs/cir-map-x1-primitive-map-prototype.mdindex 1998ee1e..84caed42 100644--- a/docs/cir-map-x1-primitive-map-prototype.md+++ b/docs/cir-map-x1-primitive-map-prototype.md@@ -147,3 +147,7 @@ The prototype is a proof that admitted primitive CIR mirrors can answer map-like- **CIR-MAP-X2:** harden the tape-backed map evaluator, move toward a non-test internal lab package if needed, and evaluate interval/early-out acceleration.- **AIR-CIR-X1:** prototype explicit mirror metadata so generated AIR bodies can declare admitted CIR mirrors without STEP inference.- **CIR-PRISMATIC-X1:** investigate whether prismatic field mirrors are feasible without losing construction/topology authority or making unsupported map claims.++## 10. CIR-MAP-X2 follow-up note++CIR-MAP-X2 consumes the AIR-CIR-X1 mirror admission metadata from a lab/test-only dispatcher (`CirMapDispatchPrototype`). X1 remains the primitive map evaluator and BRep baseline comparison surface; X2 adds the policy proof that box, cylinder, and sphere primitive mirrors select the CIR tape backend only for map occupancy, while face identity, topology parity, prismatic section transitions, and profile-authored chamfers remain rejected or unavailable. Production `analyze map` behavior is still unchanged.diff --git a/docs/cir-map-x2-mirror-aware-primitive-map-dispatch.md b/docs/cir-map-x2-mirror-aware-primitive-map-dispatch.mdnew file mode 100644index 00000000..1325df3b--- /dev/null+++ b/docs/cir-map-x2-mirror-aware-primitive-map-dispatch.md@@ -0,0 +1,172 @@+# CIR-MAP-X2 — Mirror-aware primitive map dispatch prototype++Status: **Lab/test-only prototype** (no production analyzer or CLI behavior change).++## 1. Purpose and scope++CIR-MAP-X2 proves that AIR/CIR mirror admission metadata can drive a bounded map-backend selection decision without changing production `analyze map` behavior. The milestone adds a focused test/lab dispatcher named `CirMapDispatchPrototype` in `Aetheris.Kernel.Core.Tests` that asks `CirMirrorAdmissionService` whether a requested analyzer use is allowed, then selects the CIR tape map prototype only for exact primitive mirrors and map-occupancy requests.++The prototype remains intentionally non-production. It does not route `StepAnalyzer`, `aetheris analyze map`, imported STEP bodies, production BRep map code, Boolean code, topology code, AIR emitters, or exporters through the dispatcher.++## 2. References++CIR-MAP-X2 builds directly on:++- `docs/air-cir-a0-authority-and-mirror-contract.md` for the AIR/CIR/BRep authority boundary and topology-loss guardrails;+- `docs/air-cir-x1-mirror-metadata-prototype.md` for `CirMirrorAdmissionService`, `CirMirrorStatus`, `CirMirrorCapability`, and primitive/prismatic admission vocabulary;+- `docs/cir-map-x1-primitive-map-prototype.md` for the CIR tape-backed primitive map evaluator and BRep raycast summary baseline;+- `docs/cir-m0-design.md` and `docs/cir-e0-evaluation-runtime.md` for CIR node/tape evaluation context.++## 3. Dispatcher/API shape++The lab dispatcher types are internal to the test assembly:++- `CirMapDispatchPrototype` — policy entry point;+- `CirMapDispatchResult` — selected backend, mirror admission result, optional map result, optional BRep comparison, diagnostics, and recommendation;+- `CirMapBackendCandidate` — candidate backend/admissibility/reason record;+- `CirMapBackendKind` — `CirTape`, `CirNode`, `BrepRaycastBaseline`, or `Unsupported`;+- `CirMapAnalyzerUse` — requested analyzer use such as `MapOccupancy`, `FaceIdentity`, `TopologyParity`, `PointContainment`, and `SectionSampling`;+- `CirMapBaselineComparison` — stable summary comparison between CIR and BRep maps.++Inputs are deliberately explicit:++- a `CirMirrorAdmission` source descriptor;+- the requested analyzer use;+- the `CirNode` primitive when a CIR map is potentially allowed;+- a `CirMapPrototypeRequest` containing view, rows, cols, bounds, sample count, root iterations, and tolerance;+- an optional `BrepBody` baseline for primitive parity comparison.++Outputs include:++- selected backend;+- raw mirror admission result from `CirMirrorAdmissionService`;+- optional CIR map result when the CIR path is selected;+- optional BRep baseline summary comparison;+- deterministic diagnostics;+- a finite recommendation string.++## 4. Backend selection policy++The dispatcher applies this policy:++1. Convert the requested analyzer use to a `CirMirrorCapability` and ask `CirMirrorAdmissionService`.+2. If admission is `mirror-admitted-exact`, the requested use is map occupancy, and the admitted capabilities include `MapOccupancy`, select `CirTape`.+3. If the request asks for face identity or topology parity, reject CIR as lossy for the request and select `Unsupported`.+4. If the source is prismatic/profile-chamfer and mirror admission is unavailable or unsupported, select `Unsupported` and emit no prismatic-mirror-used diagnostics.+5. If an optional BRep primitive baseline is provided, evaluate the existing BRep raycast baseline over the same request and compare bounded summaries.+6. Never route production CLI/analyzer calls through this dispatcher.++`CirNode` is kept only as a semantic primitive source for lowering to tape; the selected successful backend is `CirTape`.++## 5. Mirror-admitted primitive cases++The X2 proof cases are:++- box, top view;+- box, front view;+- cylinder, top view;+- cylinder, front view;+- sphere, top view;+- sphere, front view.++For each case:++- mirror admission status is `mirror-admitted-exact`;+- selected backend is `CirTape`;+- map occupancy is produced by the CIR tape evaluator;+- the BRep raycast baseline is compared over stable summaries;+- diagnostics include backend selection, baseline comparison, parity success, no prismatic mirror use, and no production analyzer behavior change.++## 6. Rejected and unavailable cases++CIR-MAP-X2 explicitly rejects or defers these paths:++- **Face identity:** `BoxPrimitive + FaceIdentity` is rejected as `mirror-rejected-lossy-for-request` and produces no CIR map result.+- **Topology parity:** `BoxPrimitive + TopologyParity` is rejected as `mirror-rejected-lossy-for-request` and produces no CIR map result.+- **Prismatic section transition:** `PrismaticSectionTransition + MapOccupancy` remains unsupported/unavailable and does not select CIR.+- **Profile-authored chamfer:** `ProfileAuthoredVerticalChamfer + MapOccupancy` remains unavailable and does not select CIR.++These rejections are intentional. CIR/FRep map occupancy is a field question; face IDs, loops, split-face lineage, and exact topology remain BRep/explicit-topology responsibilities unless a later milestone designs a representation that preserves them.++## 7. Map summary and BRep baseline comparison fields++The dispatcher compares the same stable summary fields used by the X1 primitive map prototype:++- total sample count;+- hit sample count;+- empty sample count;+- minimum thickness;+- maximum thickness;+- average thickness.++The current test tolerance for primitive BRep/CIR thickness deltas is `0.075` model units. Occupancy counts must match exactly for the selected deterministic grids. Thickness is tolerance-bounded because CIR zero-crossings and BRep ray intersections are independent implementations with different boundary conventions.++## 8. Diagnostics contract++CIR-MAP-X2 diagnostics are deterministic and machine-checkable. The prototype emits:++- `cir-map-x2-dispatch-started`+- `cir-map-x2-mirror-admission-requested:<source>`+- `cir-map-x2-mirror-admitted-exact:<source>`+- `cir-map-x2-backend-selected:cir-tape`+- `cir-map-x2-backend-selected:unsupported`+- `cir-map-x2-brep-baseline-compared:<source>`+- `cir-map-x2-map-parity-succeeded:<source>`+- `cir-map-x2-map-parity-warning:<source>:<reason>`+- `cir-map-x2-mirror-rejected-lossy-for-request:<request>`+- `cir-map-x2-mirror-unavailable:<source>`+- `cir-map-x2-no-prismatic-mirror-used`+- `cir-map-x2-no-production-analyzer-behavior-changed`++The finite recommendation vocabulary is:++- `cir-map-dispatch-ready-for-primitive-lab`+- `cir-map-dispatch-needs-tape-hardening`+- `cir-map-dispatch-mirror-unavailable`+- `cir-map-dispatch-lossy-request-rejected`+- `cir-map-dispatch-deferred`++The current implementation reaches `cir-map-dispatch-ready-for-primitive-lab`, `cir-map-dispatch-mirror-unavailable`, and `cir-map-dispatch-lossy-request-rejected` in tests. The remaining recommendation values are reserved for follow-on hardening/deferred branches.++## 9. Limitations++CIR-MAP-X2 does **not** provide:++- production CLI behavior changes;+- production analyzer behavior changes;+- public API changes;+- prismatic mirrors;+- map support claims for prismatic BReps;+- new CIR node kinds;+- CIR-to-BRep extraction;+- STEP exporter/importer changes;+- Boolean core changes;+- BRep topology changes;+- AIR emitter behavior changes;+- default gated corpus execution.++The dispatcher is a lab policy proof, not a general imported-body map router.++## 10. Tests run++Validation runs during the milestone:++```text+dotnet test Aetheris.Kernel.Core.Tests/Aetheris.Kernel.Core.Tests.csproj --filter "CirMapX2|CirMapX1|CirMirror" -v minimal+dotnet test Aetheris.Kernel.Core.Tests/Aetheris.Kernel.Core.Tests.csproj --filter "AIR-CIR|AirCir|CirMirror|CirMap|CIR|Cir|BrepSpatialQueries|Raycast|BrepPrimitives|Step242|Primitive|Boolean|SafeComposition" -v minimal+dotnet test Aetheris.CLI.Tests/Aetheris.CLI.Tests.csproj --filter "Analyze|Map|CliBaseline|Step|Prismatic|AirChamfer|Experimental|Corpus" -v minimal+dotnet test Aetheris.FrictionLab.Tests/Aetheris.FrictionLab.Tests.csproj -c Release -f net10.0 --filter "CIRLab|PrismaticSectionTransition|PrismaticTopEdgeChamfer|ProfileStackChamfer|ProfileChamfer|ProfileStack|LineArcProfileExtrude|Profile2D|AirChamfer|EdgeSweep" -v minimal+dotnet test Aetheris.Kernel.Firmament.Tests/Aetheris.Kernel.Firmament.Tests.csproj --filter "FirmamentPrimitive|FirmamentStepExporter|SemanticRecovery|FrepMaterializer|Rematerialize|Chamfer|Fillet|Corner|ProfileStack|LineArcProfileExtrude" -v minimal+```++All listed runs passed. EDGE-X12 / EDGE-PRISMATIC-X6 gated corpus stability tests remain opt-in and are not required by default.++## 11. Recommended next milestone++Recommended next work is one of:++1. **CIR-MAP-X3** — experimental CLI/lab dispatch behind an explicit flag, still preserving default `analyze map` behavior;+2. **CIR-PRISMATIC-X1** — prismatic mirror feasibility, likely requiring a real section-stack/convex-polyhedral field strategy rather than metadata-only admission;+3. **AIR-CIR-X2** — mirror provenance/staleness hardening before any wider analyzer routing.++Do not claim prismatic map support until an actual admitted mirror exists and can be compared against a trustworthy baseline.diff --git a/docs/edge-prismatic-x7-analyze-map-cir-frep-audit.md b/docs/edge-prismatic-x7-analyze-map-cir-frep-audit.mdindex 82fce14d..20a7ad93 100644--- a/docs/edge-prismatic-x7-analyze-map-cir-frep-audit.md+++ b/docs/edge-prismatic-x7-analyze-map-cir-frep-audit.md@@ -387,3 +387,7 @@ This milestone explicitly does not include:- claims that `analyze map` supports prismatic BReps;- default execution of gated artifact tests;- test weakening.++## 13. CIR-MAP-X2 prismatic status note++CIR-MAP-X2 adds a lab/test-only mirror-aware primitive map dispatcher, but it deliberately does not add prismatic mirror support. Prismatic section-transition and profile-authored chamfer sources still resolve to mirror-unavailable or unsupported admission for map occupancy, emit no-prismatic-mirror-used diagnostics, and do not select the CIR map backend. Prismatic map support remains blocked until a real admitted prismatic mirror exists and can be validated against an appropriate baseline.