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.csnew file mode 100644index 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.mdindex 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.mdindex 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 limitationsdiff --git a/docs/cir-map-x1-primitive-map-prototype.md b/docs/cir-map-x1-primitive-map-prototype.mdnew file mode 100644index 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.mdindex 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.