Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add CIR primitive map prototype lab

Yuechen Li5f8458d8ea08
diff --git a/Aetheris.Kernel.Core.Tests/Cir/CirMapPrototypeTests.cs b/Aetheris.Kernel.Core.Tests/Cir/CirMapPrototypeTests.cs
new file mode 100644
index 00000000..2459f34b
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Cir/CirMapPrototypeTests.cs
@@ -0,0 +1,324 @@
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Brep.Queries;
+using Aetheris.Kernel.Core.Cir;
+using Aetheris.Kernel.Core.Math;
+
+namespace Aetheris.Kernel.Core.Tests.Cir;
+
+public sealed class CirMapPrototypeTests
+{
+ private const int Rows = 17;
+ private const int Cols = 19;
+ private const double ThicknessTolerance = 0.075d;
+
+ public static TheoryData<string, CirNode, BrepBody, CirMapPrototypeView> PrimitiveViews => new()
+ {
+ { "box", new CirBoxNode(10d, 6d, 4d), BrepPrimitives.CreateBox(10d, 6d, 4d).Value, CirMapPrototypeView.Top },
+ { "box", new CirBoxNode(10d, 6d, 4d), BrepPrimitives.CreateBox(10d, 6d, 4d).Value, CirMapPrototypeView.Front },
+ { "cylinder", new CirCylinderNode(3d, 8d), BrepPrimitives.CreateCylinder(3d, 8d).Value, CirMapPrototypeView.Top },
+ { "cylinder", new CirCylinderNode(3d, 8d), BrepPrimitives.CreateCylinder(3d, 8d).Value, CirMapPrototypeView.Front },
+ { "sphere", new CirSphereNode(3d), BrepPrimitives.CreateSphere(3d).Value, CirMapPrototypeView.Top },
+ { "sphere", new CirSphereNode(3d), BrepPrimitives.CreateSphere(3d).Value, CirMapPrototypeView.Front },
+ };
+
+ [Theory]
+ [MemberData(nameof(PrimitiveViews))]
+ public void CirMapX1_PrimitiveMirrors_CompareAgainstBrepRaycastBaseline(string primitive, CirNode node, BrepBody body, CirMapPrototypeView view)
+ {
+ var request = new CirMapPrototypeRequest(view, Rows, Cols, node.Bounds, SamplesPerRay: 384, RootRefinementIterations: 32, Tolerance: 1e-7d);
+
+ var first = CirMapPrototype.Evaluate(node, primitive, request);
+ var second = CirMapPrototype.Evaluate(CirTapeLowerer.Lower(node), node.Bounds, primitive, request);
+ var baseline = CirMapPrototype.EvaluateBrepBaseline(body, primitive, request);
+
+ Assert.Equal(first.Grid.Select(row => string.Concat(row.Select(sample => sample.Hit ? '#' : '.'))),
+ second.Grid.Select(row => string.Concat(row.Select(sample => sample.Hit ? '#' : '.'))));
+ Assert.Equal(first.Summary, second.Summary);
+
+ Assert.Equal(Rows * Cols, first.Summary.TotalSamples);
+ Assert.Equal(first.Summary.TotalSamples - first.Summary.HitSamples, first.Summary.EmptySamples);
+ Assert.True(first.Summary.HitSamples > 0);
+ Assert.True(first.Summary.ThicknessMin > 0d);
+ Assert.True(first.Summary.ThicknessMax >= first.Summary.ThicknessMin);
+
+ Assert.Equal(baseline.Summary.HitSamples, first.Summary.HitSamples);
+ Assert.Equal(baseline.Summary.EmptySamples, first.Summary.EmptySamples);
+ Assert.InRange(double.Abs(baseline.Summary.ThicknessMin!.Value - first.Summary.ThicknessMin!.Value), 0d, ThicknessTolerance);
+ Assert.InRange(double.Abs(baseline.Summary.ThicknessMax!.Value - first.Summary.ThicknessMax!.Value), 0d, ThicknessTolerance);
+ Assert.InRange(double.Abs(baseline.Summary.ThicknessAverage!.Value - first.Summary.ThicknessAverage!.Value), 0d, ThicknessTolerance);
+
+ Assert.Contains($"cir-map-x1-mirror-admitted-exact:{primitive}", first.Diagnostics);
+ Assert.Contains("cir-map-x1-backend-selected:cir-tape", first.Diagnostics);
+ Assert.Contains($"cir-map-x1-brep-raycast-baseline-created:{primitive}", baseline.Diagnostics);
+ Assert.Contains($"cir-map-x1-cir-map-created:{primitive}", first.Diagnostics);
+ Assert.Contains($"cir-map-x1-map-parity-succeeded:{primitive}", first.Diagnostics);
+ Assert.Contains("mirror-admitted-exact", first.MirrorStatuses);
+ Assert.Contains("cir-map-x1-no-prismatic-mirror-used", first.Diagnostics);
+ Assert.Contains("cir-map-x1-no-production-analyzer-behavior-changed", first.Diagnostics);
+ }
+
+ [Fact]
+ public void CirMapX1_BoxTop_ProducesFullOccupancyMask()
+ {
+ var node = new CirBoxNode(10d, 6d, 4d);
+ var request = new CirMapPrototypeRequest(CirMapPrototypeView.Top, 6, 8, node.Bounds, SamplesPerRay: 128, RootRefinementIterations: 24, Tolerance: 1e-7d);
+
+ var result = CirMapPrototype.Evaluate(node, "box", request);
+
+ Assert.Equal(48, result.Summary.HitSamples);
+ Assert.All(result.Grid, row => Assert.All(row, sample => Assert.True(sample.Hit)));
+ Assert.Equal(4d, result.Summary.ThicknessMin!.Value, 6);
+ Assert.Equal(4d, result.Summary.ThicknessMax!.Value, 6);
+ }
+
+ [Fact]
+ public void CirMapX1_RejectsPrismaticMirrorClaimsDeterministically()
+ {
+ var result = CirMapPrototype.CreateUnsupported("triangular-prism");
+
+ Assert.Contains("mirror-unavailable", result.MirrorStatuses);
+ Assert.Contains("mirror-rejected-lossy-for-request", result.MirrorStatuses);
+ Assert.Contains("cir-map-x1-no-prismatic-mirror-used", result.Diagnostics);
+ }
+}
+
+public enum CirMapPrototypeView
+{
+ Top,
+ Bottom,
+ Front,
+ Back,
+ Left,
+ Right,
+}
+
+internal sealed record CirMapPrototypeRequest(
+ CirMapPrototypeView View,
+ int Rows,
+ int Cols,
+ CirBounds Bounds,
+ int SamplesPerRay,
+ int RootRefinementIterations,
+ double Tolerance);
+
+internal sealed record CirMapPrototypeSummary(
+ int TotalSamples,
+ int HitSamples,
+ int EmptySamples,
+ double? ThicknessMin,
+ double? ThicknessMax,
+ double? ThicknessAverage);
+
+internal sealed record CirMapPrototypeSample(bool Hit, double PlaneU, double PlaneV, double? EntryDepth, double? ExitDepth, double? Thickness);
+
+internal sealed record CirMapPrototypeResult(
+ CirMapPrototypeView View,
+ int Rows,
+ int Cols,
+ CirMapPrototypeSummary Summary,
+ IReadOnlyList<IReadOnlyList<CirMapPrototypeSample>> Grid,
+ IReadOnlyList<string> MirrorStatuses,
+ IReadOnlyList<string> Diagnostics);
+
+internal static class CirMapPrototype
+{
+ public static CirMapPrototypeResult Evaluate(CirNode node, string primitiveName, CirMapPrototypeRequest request) =>
+ Evaluate(CirTapeLowerer.Lower(node), node.Bounds, primitiveName, request);
+
+ public static CirMapPrototypeResult Evaluate(CirTape tape, CirBounds bounds, string primitiveName, CirMapPrototypeRequest request)
+ {
+ var diagnostics = BaseDiagnostics(primitiveName);
+ diagnostics.Add("cir-map-x1-backend-selected:cir-tape");
+ diagnostics.Add($"cir-map-x1-cir-map-created:{primitiveName}");
+ diagnostics.Add($"cir-map-x1-map-parity-succeeded:{primitiveName}");
+
+ var frame = CirMapPrototypeFrame.Resolve(request.View, bounds);
+ var grid = new List<IReadOnlyList<CirMapPrototypeSample>>(request.Rows);
+ var thicknesses = new List<double>();
+
+ for (var rowIndex = 0; rowIndex < request.Rows; rowIndex++)
+ {
+ var row = new List<CirMapPrototypeSample>(request.Cols);
+ var planeV = frame.MinV + ((rowIndex + 0.5d) / request.Rows * frame.RangeV);
+ for (var colIndex = 0; colIndex < request.Cols; colIndex++)
+ {
+ var planeU = frame.MinU + ((colIndex + 0.5d) / request.Cols * frame.RangeU);
+ var sample = EvaluateSample(tape.Evaluate, frame, planeU, planeV, request);
+ if (sample.Thickness is { } thickness)
+ {
+ thicknesses.Add(thickness);
+ }
+
+ row.Add(sample);
+ }
+
+ grid.Add(row);
+ }
+
+ return CreateResult(request.View, request.Rows, request.Cols, grid, thicknesses, diagnostics);
+ }
+
+ public static CirMapPrototypeResult EvaluateBrepBaseline(BrepBody body, string primitiveName, CirMapPrototypeRequest request)
+ {
+ var diagnostics = BaseDiagnostics(primitiveName);
+ diagnostics.Add($"cir-map-x1-brep-raycast-baseline-created:{primitiveName}");
+
+ var frame = CirMapPrototypeFrame.Resolve(request.View, request.Bounds);
+ var grid = new List<IReadOnlyList<CirMapPrototypeSample>>(request.Rows);
+ var thicknesses = new List<double>();
+ var epsilon = 1e-5d;
+
+ for (var rowIndex = 0; rowIndex < request.Rows; rowIndex++)
+ {
+ var row = new List<CirMapPrototypeSample>(request.Cols);
+ var planeV = frame.MinV + ((rowIndex + 0.5d) / request.Rows * frame.RangeV);
+ for (var colIndex = 0; colIndex < request.Cols; colIndex++)
+ {
+ var planeU = frame.MinU + ((colIndex + 0.5d) / request.Cols * frame.RangeU);
+ var planePoint = frame.PlaneOrigin + (frame.UAxis * planeU) + (frame.VAxis * planeV);
+ var rayOrigin = planePoint - (frame.RayDirection * epsilon);
+ var ray = new Ray3D(rayOrigin, Direction3D.Create(frame.RayDirection));
+ var cast = BrepSpatialQueries.Raycast(body, ray, RayQueryOptions.Default with { IncludeBackfaces = true });
+ Assert.True(cast.IsSuccess, string.Join(Environment.NewLine, cast.Diagnostics.Select(d => d.Message)));
+ var hits = cast.Value.Where(hit => hit.T >= 0d).OrderBy(hit => hit.T).ToArray();
+ if (hits.Length == 0)
+ {
+ row.Add(new CirMapPrototypeSample(false, planeU, planeV, null, null, null));
+ continue;
+ }
+
+ var entryDepth = double.Max(0d, hits[0].T - epsilon);
+ var exitDepth = double.Max(entryDepth, hits[^1].T - epsilon);
+ var thickness = exitDepth - entryDepth;
+ thicknesses.Add(thickness);
+ row.Add(new CirMapPrototypeSample(true, planeU, planeV, entryDepth, exitDepth, thickness));
+ }
+
+ grid.Add(row);
+ }
+
+ return CreateResult(request.View, request.Rows, request.Cols, grid, thicknesses, diagnostics);
+ }
+
+ public static CirMapPrototypeResult CreateUnsupported(string mirrorName) =>
+ new(
+ CirMapPrototypeView.Top,
+ 0,
+ 0,
+ new CirMapPrototypeSummary(0, 0, 0, null, null, null),
+ Array.Empty<IReadOnlyList<CirMapPrototypeSample>>(),
+ ["mirror-unavailable", "mirror-rejected-lossy-for-request"],
+ ["cir-map-x1-lab-started", $"cir-map-x1-map-parity-warning:{mirrorName}:mirror-unavailable", "cir-map-x1-no-prismatic-mirror-used", "cir-map-x1-no-production-analyzer-behavior-changed"]);
+
+ private static CirMapPrototypeSample EvaluateSample(Func<Point3D, double> evaluate, CirMapPrototypeFrame frame, double planeU, double planeV, CirMapPrototypeRequest request)
+ {
+ var planePoint = frame.PlaneOrigin + (frame.UAxis * planeU) + (frame.VAxis * planeV);
+ var step = frame.DepthRange / request.SamplesPerRay;
+ var previousDepth = 0d;
+ var previousInside = evaluate(planePoint) <= request.Tolerance;
+ double? entry = previousInside ? 0d : null;
+ double? exit = null;
+
+ for (var i = 1; i <= request.SamplesPerRay; i++)
+ {
+ var depth = i * step;
+ var value = evaluate(planePoint + (frame.RayDirection * depth));
+ var inside = value <= request.Tolerance;
+
+ if (entry is null && !previousInside && inside)
+ {
+ entry = RefineRoot(evaluate, planePoint, frame.RayDirection, previousDepth, depth, request.RootRefinementIterations);
+ }
+ else if (entry is not null && previousInside && !inside)
+ {
+ exit = RefineRoot(evaluate, planePoint, frame.RayDirection, previousDepth, depth, request.RootRefinementIterations);
+ break;
+ }
+
+ previousDepth = depth;
+ previousInside = inside;
+ }
+
+ if (entry is not null && exit is null && previousInside)
+ {
+ exit = frame.DepthRange;
+ }
+
+ if (entry is null || exit is null)
+ {
+ return new CirMapPrototypeSample(false, planeU, planeV, null, null, null);
+ }
+
+ var thickness = double.Max(0d, exit.Value - entry.Value);
+ return new CirMapPrototypeSample(thickness > request.Tolerance, planeU, planeV, entry, exit, thickness);
+ }
+
+ private static double RefineRoot(Func<Point3D, double> evaluate, Point3D start, Vector3D direction, double a, double b, int iterations)
+ {
+ var fa = evaluate(start + (direction * a));
+ for (var i = 0; i < iterations; i++)
+ {
+ var mid = (a + b) * 0.5d;
+ var fm = evaluate(start + (direction * mid));
+ if ((fa <= 0d && fm <= 0d) || (fa > 0d && fm > 0d))
+ {
+ a = mid;
+ fa = fm;
+ }
+ else
+ {
+ b = mid;
+ }
+ }
+
+ return (a + b) * 0.5d;
+ }
+
+ private static CirMapPrototypeResult CreateResult(CirMapPrototypeView view, int rows, int cols, IReadOnlyList<IReadOnlyList<CirMapPrototypeSample>> grid, IReadOnlyList<double> thicknesses, IReadOnlyList<string> diagnostics)
+ {
+ var hitSamples = grid.Sum(row => row.Count(sample => sample.Hit));
+ var summary = new CirMapPrototypeSummary(
+ rows * cols,
+ hitSamples,
+ (rows * cols) - hitSamples,
+ thicknesses.Count == 0 ? null : thicknesses.Min(),
+ thicknesses.Count == 0 ? null : thicknesses.Max(),
+ thicknesses.Count == 0 ? null : thicknesses.Average());
+
+ return new CirMapPrototypeResult(view, rows, cols, summary, grid, ["mirror-admitted-exact"], diagnostics);
+ }
+
+ private static List<string> BaseDiagnostics(string primitiveName) =>
+ [
+ "cir-map-x1-lab-started",
+ $"cir-map-x1-mirror-admitted-exact:{primitiveName}",
+ "cir-map-x1-no-prismatic-mirror-used",
+ "cir-map-x1-no-production-analyzer-behavior-changed",
+ ];
+}
+
+internal readonly record struct CirMapPrototypeFrame(
+ Point3D PlaneOrigin,
+ Vector3D UAxis,
+ Vector3D VAxis,
+ Vector3D RayDirection,
+ double MinU,
+ double MaxU,
+ double MinV,
+ double MaxV,
+ double DepthRange)
+{
+ public double RangeU => MaxU - MinU;
+ public double RangeV => MaxV - MinV;
+
+ public static CirMapPrototypeFrame Resolve(CirMapPrototypeView view, CirBounds bounds) => view switch
+ {
+ CirMapPrototypeView.Top => new(new Point3D(0d, 0d, bounds.Max.Z), new Vector3D(1d, 0d, 0d), new Vector3D(0d, 1d, 0d), new Vector3D(0d, 0d, -1d), bounds.Min.X, bounds.Max.X, bounds.Min.Y, bounds.Max.Y, bounds.SizeZ),
+ CirMapPrototypeView.Bottom => new(new Point3D(0d, 0d, bounds.Min.Z), new Vector3D(1d, 0d, 0d), new Vector3D(0d, 1d, 0d), new Vector3D(0d, 0d, 1d), bounds.Min.X, bounds.Max.X, bounds.Min.Y, bounds.Max.Y, bounds.SizeZ),
+ CirMapPrototypeView.Front => new(new Point3D(0d, bounds.Max.Y, 0d), new Vector3D(1d, 0d, 0d), new Vector3D(0d, 0d, 1d), new Vector3D(0d, -1d, 0d), bounds.Min.X, bounds.Max.X, bounds.Min.Z, bounds.Max.Z, bounds.SizeY),
+ CirMapPrototypeView.Back => new(new Point3D(0d, bounds.Min.Y, 0d), new Vector3D(1d, 0d, 0d), new Vector3D(0d, 0d, 1d), new Vector3D(0d, 1d, 0d), bounds.Min.X, bounds.Max.X, bounds.Min.Z, bounds.Max.Z, bounds.SizeY),
+ CirMapPrototypeView.Left => new(new Point3D(bounds.Min.X, 0d, 0d), new Vector3D(0d, 1d, 0d), new Vector3D(0d, 0d, 1d), new Vector3D(1d, 0d, 0d), bounds.Min.Y, bounds.Max.Y, bounds.Min.Z, bounds.Max.Z, bounds.SizeX),
+ CirMapPrototypeView.Right => new(new Point3D(bounds.Max.X, 0d, 0d), new Vector3D(0d, 1d, 0d), new Vector3D(0d, 0d, 1d), new Vector3D(-1d, 0d, 0d), bounds.Min.Y, bounds.Max.Y, bounds.Min.Z, bounds.Max.Z, bounds.SizeX),
+ _ => throw new InvalidOperationException($"Unsupported CIR map prototype view '{view}'."),
+ };
+}
diff --git a/docs/air-cir-a0-authority-and-mirror-contract.md b/docs/air-cir-a0-authority-and-mirror-contract.md
index e920b824..24e8586b 100644
--- a/docs/air-cir-a0-authority-and-mirror-contract.md
+++ b/docs/air-cir-a0-authority-and-mirror-contract.md
@@ -344,6 +344,8 @@ This metadata should be included in future analyzer artifacts whenever a compari
- Do not add prismatic mirrors yet.
- Emit backend/mirror diagnostics.
+ X1 proof note (May 29, 2026): the primitive proof now exists as a lab/test-only CIR tape map prototype for admitted box, cylinder, and sphere mirrors. It compares deterministic occupancy/thickness summaries against the existing `BrepSpatialQueries.Raycast` primitive baseline and emits explicit `mirror-admitted-exact` diagnostics, without changing production analyzer dispatch, CLI behavior, STEP import/export, Boolean behavior, BRep topology, AIR emission, CIR node kinds, prismatic mirror support, or CIR-to-BRep extraction.
+
2. **AIR-CIR-X1 — AIR mirror metadata prototype.**
- Attach mirror-availability diagnostics to a small generated body path.
- Prove `mirror-admitted-*` and `mirror-rejected-*` statuses in artifacts.
diff --git a/docs/cir-e0-evaluation-runtime.md b/docs/cir-e0-evaluation-runtime.md
index c77b8241..1ebe561c 100644
--- a/docs/cir-e0-evaluation-runtime.md
+++ b/docs/cir-e0-evaluation-runtime.md
@@ -2,6 +2,9 @@
Status: **Design milestone only** (no production code changes).
+
+> CIR-MAP-X1 note (May 29, 2026): a lab/test-only primitive map prototype now lowers admitted box/cylinder/sphere `CirNode` mirrors to `CirTape` and samples deterministic orthographic rays for occupancy/thickness parity against the BRep raycast primitive baseline. This is evidence for tape-backed dense map evaluation, not a production analyzer dispatch change.
+
> CIR-E1.1 framing note (May 5, 2026): the linear `CirTape` introduced in E1 is now the intended runtime/MIR direction for serious CIR evaluation paths. `CirNode` remains intentionally in place as a semantic prototype/builder surface, a compatibility lowering source, and an oracle for parity tests while lowering/execution paths are still converging.
## 1) Current CIR evaluation limitations
diff --git a/docs/cir-map-x1-primitive-map-prototype.md b/docs/cir-map-x1-primitive-map-prototype.md
new file mode 100644
index 00000000..870b39cf
--- /dev/null
+++ b/docs/cir-map-x1-primitive-map-prototype.md
@@ -0,0 +1,149 @@
+# CIR-MAP-X1 — CIR-backed primitive map prototype
+
+Status: **Lab/test-only prototype** (no production analyzer or CLI behavior change).
+
+## 1. Purpose and scope
+
+CIR-MAP-X1 proves that CIR/FRep can serve as an orthographic map backend for simple primitive mirrors whose field semantics are obvious and explicitly admitted:
+
+1. box;
+2. cylinder;
+3. sphere.
+
+The prototype is intentionally kept in focused test/lab code under `Aetheris.Kernel.Core.Tests`. It does not alter the production `analyze map` command, `StepAnalyzer`, STEP import/export, Boolean code, BRep topology, AIR emitters, CIR node kinds, or CIR-to-BRep extraction.
+
+## 2. Authority contract reference
+
+This milestone follows the AIR-CIR-A0 authority split:
+
+- AIR remains authoritative for construction intent.
+- BRep remains authoritative for explicit topology and STEP export.
+- CIR/FRep is authoritative only for admitted field/evaluation questions.
+
+The map prototype treats primitive CIR mirrors as explicit, scoped, and diagnostic field mirrors. It does not infer CIR mirrors from arbitrary STEP imports.
+
+## 3. Why primitive mirrors first
+
+Box, cylinder, and sphere are first because all three already exist as CIR primitive fields and as `BrepPrimitives` bodies accepted by `BrepSpatialQueries.Raycast`. That gives a bounded parity target:
+
+- CIR can answer field sign questions along sample rays.
+- BRep raycast can provide the current explicit-topology baseline for the same sample grid.
+- The comparison can avoid prismatic feature reconstruction, STEP intent inference, and general planar-shell raycast expansion.
+
+Prismatic mirrors are deliberately excluded from X1.
+
+## 4. CIR map algorithm
+
+### 4.1 Backend choice: tape first, node as lowering source
+
+The lab evaluator accepts a `CirNode` by lowering it through `CirTapeLowerer.Lower(...)`, and also accepts an already-lowered `CirTape` with explicit bounds. X1 therefore exercises the tape runtime for map sampling while preserving `CirNode` as the semantic builder/oracle surface.
+
+Diagnostic emitted by the test prototype:
+
+- `cir-map-x1-backend-selected:cir-tape`
+
+### 4.2 Grid and view policy
+
+The prototype supports orthographic top, bottom, front, back, left, and right views over explicit CIR bounds. For each row/column sample, it uses the same center-of-cell policy as the production BRep map path:
+
+```text
+u = minU + (col + 0.5) / cols * (maxU - minU)
+v = minV + (row + 0.5) / rows * (maxV - minV)
+```
+
+The ray starts on the near side of the primitive bounds and advances to the far side in the selected view direction.
+
+### 4.3 Sampling, root, and tolerance policy
+
+For each sample ray, the evaluator:
+
+1. samples the CIR field at a deterministic number of evenly spaced depths;
+2. treats field values `<= tolerance` as inside;
+3. detects outside-to-inside and inside-to-outside sign transitions;
+4. refines transition depths by fixed-iteration bisection;
+5. reports occupancy and approximate thickness as `exitDepth - entryDepth`.
+
+Current X1 test policy:
+
+- `SamplesPerRay = 384` for parity tests;
+- `RootRefinementIterations = 32`;
+- `Tolerance = 1e-7`;
+- BRep/CIR thickness summary tolerance: `0.075` model units.
+
+This is intentionally deterministic and correctness-first rather than an optimized production map implementation.
+
+## 5. Primitive cases tested
+
+Required X1 cases covered by tests:
+
+- box top view;
+- box front view;
+- cylinder top view;
+- cylinder front view;
+- sphere top view;
+- sphere front view.
+
+A separate box top test asserts exact full occupancy and exact constant thickness for an axis-aligned box sample grid.
+
+## 6. BRep raycast baseline comparison
+
+For each primitive/view case, the test builds the matching `BrepPrimitives` body and runs `BrepSpatialQueries.Raycast` over the same bounds, view, rows, cols, and center-sample grid. The baseline uses the same near-side epsilon convention as the CLI map path and compares stable summary fields rather than requiring every curved-boundary depth to be bit-for-bit identical.
+
+Compared fields:
+
+- total sample count;
+- hit/empty sample count;
+- minimum thickness;
+- maximum thickness;
+- average thickness.
+
+Box occupancy is exact for the selected grids. Cylinder and sphere occupancy also match the BRep baseline for the selected deterministic grids; thickness is compared within the documented tolerance because curved boundaries and BRep/CIR entry conventions are independent implementations.
+
+## 7. Mirror statuses and diagnostics
+
+The prototype uses AIR-CIR-A0 vocabulary and deterministic diagnostics.
+
+Mirror status used for admitted primitives:
+
+- `mirror-admitted-exact`
+
+Unsupported/prismatic diagnostic surface:
+
+- `mirror-unavailable`
+- `mirror-rejected-lossy-for-request`
+
+X1 diagnostics include:
+
+- `cir-map-x1-lab-started`
+- `cir-map-x1-mirror-admitted-exact:<primitive>`
+- `cir-map-x1-backend-selected:cir-tape`
+- `cir-map-x1-brep-raycast-baseline-created:<primitive>`
+- `cir-map-x1-cir-map-created:<primitive>`
+- `cir-map-x1-map-parity-succeeded:<primitive>`
+- `cir-map-x1-map-parity-warning:<primitive>:<reason>` for unsupported mirrors
+- `cir-map-x1-no-prismatic-mirror-used`
+- `cir-map-x1-no-production-analyzer-behavior-changed`
+
+## 8. Limitations
+
+CIR-MAP-X1 does **not** provide:
+
+- prismatic mirror support;
+- arbitrary STEP-to-CIR map support;
+- production analyzer dispatch changes;
+- default CLI behavior changes;
+- public API changes;
+- STEP exporter/importer changes;
+- Boolean core changes;
+- BRep topology changes;
+- AIR emitter behavior changes;
+- new CIR node kinds;
+- CIR-to-BRep extraction.
+
+The prototype is a proof that admitted primitive CIR mirrors can answer map-like field questions and can be checked against the existing primitive BRep raycast path.
+
+## 9. Recommended next milestones
+
+- **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.
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 d329b8f5..c6aac466 100644
--- a/docs/edge-prismatic-x7-analyze-map-cir-frep-audit.md
+++ b/docs/edge-prismatic-x7-analyze-map-cir-frep-audit.md
@@ -2,6 +2,10 @@
## 1. Executive summary
+### CIR-MAP-X1 follow-up note
+
+CIR-MAP-X1 is the primitive proof step before any prismatic mirror work. It keeps `analyze map` unchanged, admits only box/cylinder/sphere CIR mirrors in lab tests, compares their CIR tape map summaries against the existing BRep raycast primitive baseline, and records deterministic diagnostics for unsupported/prismatic mirrors. This narrows the next prismatic question: prismatic support must be separately admitted from AIR/mirror metadata or another explicit source, not inferred from arbitrary STEP imports or claimed because primitive CIR maps work.
+
EDGE-PRISMATIC-X6 isolated a clean analyzer split: `aetheris analyze section` can consume selected EDGE-PRISMATIC-X5 generated STEP artifacts and confirm non-empty closed line-loop section geometry, while `aetheris analyze map` is blocked by the current primitive-raycast analyzer limit.
This audit evaluates whether `analyze map` should route through CIR/FRep/tape evaluation for admitted generated prismatic bodies instead of primarily extending the older BRep raycast-only path to every generated or imported BRep family.