Skip to content

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.cs
new file mode 100644
index 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.md
index 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.md
index 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.md
new file mode 100644
index 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.md
index 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.