Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Generalize analyze map ray probes
Yuechen Li63cbaac0876b
diff --git a/Aetheris.CLI.Tests/CliBaselineTests.cs b/Aetheris.CLI.Tests/CliBaselineTests.csindex f80e1102..2d5de116 100644--- a/Aetheris.CLI.Tests/CliBaselineTests.cs+++ b/Aetheris.CLI.Tests/CliBaselineTests.cs@@ -512,6 +512,22 @@ public sealed class CliBaselineTestsAssert.True(grid[0][0].TryGetProperty("entrySurfaceType", out _));}+ [Fact]+ public void Analyze_Map_RayProbe_BoxTop_Returns_Llm_Grid_Samples()+ {+ var stepPath = ExportPrimitiveToTempStep(BrepPrimitives.CreateBox(10d, 6d, 4d).Value, "cli-ray-map-box-top");+ using var doc = RunAnalyzeRayMap(stepPath, "--plane", "xy", "--direction", "-z", "--resolution", "5x5");+ var root = doc.RootElement;++ Assert.Equal("grid", root.GetProperty("mode").GetString());+ Assert.Equal("xy", root.GetProperty("plane").GetString());+ Assert.Equal("-z", root.GetProperty("direction").GetString());+ Assert.Equal(25, root.GetProperty("samples").GetArrayLength());+ Assert.Equal(1d, root.GetProperty("summary").GetProperty("hitCoverage").GetDouble(), 8);+ Assert.Equal("plane", root.GetProperty("summary").GetProperty("surfaceFamiliesHit").EnumerateObject().Single().Name);+ Assert.True(root.GetProperty("samples")[12].GetProperty("firstHit").GetProperty("position").GetProperty("z").GetDouble() > 0d);+ }+[Fact]public void Analyze_Section_Box_XY_At_Midplane_Produces_One_Closed_Line_Loop(){@@ -1328,6 +1344,16 @@ public sealed class CliBaselineTestsreturn JsonDocument.Parse(stdout.ToString());}+ private static JsonDocument RunAnalyzeRayMap(string stepPath, params string[] args)+ {+ var stdout = new StringWriter();+ var stderr = new StringWriter();+ var exitCode = Aetheris.CLI.CliRunner.Run(["analyze", "map", stepPath, .. args, "--json"], stdout, stderr);+ Assert.Equal(0, exitCode);+ Assert.True(string.IsNullOrWhiteSpace(stderr.ToString()), stderr.ToString());+ return JsonDocument.Parse(stdout.ToString());+ }+private static JsonDocument RunAnalyzeSection(string stepPath, string planeFlag, double offset){var stdout = new StringWriter();diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.csindex 615b82d8..62142077 100644--- a/Aetheris.CLI/CliRunner.cs+++ b/Aetheris.CLI/CliRunner.cs@@ -109,7 +109,7 @@ public static class CliRunnerprivate const string TopLevelUsage = "Usage: aetheris <build|analyze|trace|canon|asm|experimental> <path> [options]";private const string BuildUsage = "Usage: aetheris build <file.firmament> [--out <path>] [--json]";private const string AnalyzeUsage = "Usage: aetheris analyze <file.step> [--face <id>] [--edge <id>] [--vertex <id>] [--json]";- private const string AnalyzeMapUsage = "Usage: aetheris analyze map <file.step> (--top|--bottom|--front|--back|--left|--right) --rows <N> --cols <N> --json";+ private const string AnalyzeMapUsage = "Usage: aetheris analyze map <file.step> --plane <xy|xz|yz> --direction <+x|-x|+y|-y|+z|-z> --resolution <NxM> [--point <u,v>] --json";private const string AnalyzeSectionUsage = "Usage: aetheris analyze section <file.step> (--xy|--xz|--yz) --offset <value> --json";private const string AnalyzeVolumeUsage = "Usage: aetheris analyze volume <file.step> [--approximate --resolution <N>] [--json]";private const string AnalyzeCompareUsage = "Usage: aetheris analyze compare <reference.step> <candidate.step> [--approximate-volume --resolution <N>] [--json]";@@ -1760,6 +1760,9 @@ public static class CliRunnervar viewOptionCount = 0;int? rows = null;int? cols = null;+ string? plane = null;+ string? direction = null;+ (double U, double V)? point = null;var json = false;for (var i = 1; i < args.Length; i++)@@ -1793,6 +1796,37 @@ public static class CliRunnercase "--rows" when i + 1 < args.Length && int.TryParse(args[++i], out var parsedRows):rows = parsedRows;break;+ case "--resolution" when i + 1 < args.Length && TryParseResolution(args[++i], out var parsedCols2, out var parsedRows2):+ cols = parsedCols2;+ rows = parsedRows2;+ break;+ case "--resolution":+ stderr.WriteLine("Analyze map option --resolution requires a value like 32x32.");+ stderr.WriteLine(AnalyzeMapUsage);+ return 1;+ case "--plane" when i + 1 < args.Length:+ plane = args[++i];+ break;+ case "--plane":+ stderr.WriteLine("Analyze map option --plane requires xy, xz, or yz.");+ stderr.WriteLine(AnalyzeMapUsage);+ return 1;+ case "--direction" when i + 1 < args.Length:+ direction = args[++i];+ break;+ case "--direction":+ stderr.WriteLine("Analyze map option --direction requires +x, -x, +y, -y, +z, or -z.");+ stderr.WriteLine(AnalyzeMapUsage);+ return 1;+ case "--point" when i + 1 < args.Length && TryParsePoint(args[++i], out var parsedPoint):+ point = parsedPoint;+ rows ??= 1;+ cols ??= 1;+ break;+ case "--point":+ stderr.WriteLine("Analyze map option --point requires a comma-separated coordinate like 3,4.");+ stderr.WriteLine(AnalyzeMapUsage);+ return 1;case "--rows":stderr.WriteLine("Analyze map option --rows requires an integer value.");stderr.WriteLine(AnalyzeMapUsage);@@ -1818,9 +1852,25 @@ public static class CliRunner}}- if (!view.HasValue || viewOptionCount != 1)+ var legacyViewMode = plane is null && view.HasValue;+ if (legacyViewMode)+ {+ var legacyView = view.GetValueOrDefault();+ (plane, direction) = legacyView switch+ {+ OrthographicView.Top => ("xy", "-z"),+ OrthographicView.Bottom => ("xy", "+z"),+ OrthographicView.Front => ("xz", "-y"),+ OrthographicView.Back => ("xz", "+y"),+ OrthographicView.Left => ("yz", "+x"),+ OrthographicView.Right => ("yz", "-x"),+ _ => ("xy", "-z")+ };+ }++ if (plane is null || direction is null || (viewOptionCount > 0 && viewOptionCount != 1)){- stderr.WriteLine("Analyze map requires exactly one orthographic view option (--top|--bottom|--front|--back|--left|--right).");+ stderr.WriteLine("Analyze map requires --plane and --direction (or one legacy view option --top|--bottom|--front|--back|--left|--right).");return 1;}@@ -1836,10 +1886,12 @@ public static class CliRunnerreturn 1;}- OrthographicMapResult map;+ object map;try{- map = StepAnalyzer.AnalyzeMap(stepPath, view.Value, rows.Value, cols.Value);+ map = legacyViewMode+ ? StepAnalyzer.AnalyzeMap(stepPath, view.GetValueOrDefault(), rows.Value, cols.Value)+ : StepAnalyzer.AnalyzeRayMap(stepPath, plane, direction, cols.Value, rows.Value, point);}catch (Exception ex){@@ -2054,6 +2106,27 @@ public static class CliRunnerstring.Equals(value, "--help", StringComparison.Ordinal)|| string.Equals(value, "-h", StringComparison.Ordinal);+ private static bool TryParseResolution(string value, out int cols, out int rows)+ {+ cols = 0;+ rows = 0;+ var parts = value.Split('x', 'X');+ return parts.Length == 2+ && int.TryParse(parts[0], System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out cols)+ && int.TryParse(parts[1], System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out rows);+ }++ private static bool TryParsePoint(string value, out (double U, double V) point)+ {+ point = default;+ var parts = value.Split(',');+ if (parts.Length != 2) return false;+ if (!double.TryParse(parts[0], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var u)) return false;+ if (!double.TryParse(parts[1], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var v)) return false;+ point = (u, v);+ return true;+ }+private static bool IsVersionFlag(string value) =>string.Equals(value, "--version", StringComparison.Ordinal)|| string.Equals(value, "-v", StringComparison.Ordinal);diff --git a/Aetheris.CLI/StepAnalysisModels.cs b/Aetheris.CLI/StepAnalysisModels.csindex 1560a74b..2cdff2e7 100644--- a/Aetheris.CLI/StepAnalysisModels.cs+++ b/Aetheris.CLI/StepAnalysisModels.cs@@ -118,6 +118,13 @@ public sealed record OrthographicMapResult(IReadOnlyList<IReadOnlyList<OrthographicSample>> Grid,IReadOnlyList<string> Notes);++public sealed record RayMapBounds(double[] U, double[] V);+public sealed record RayMapHit(double T, Point3D Position, int? FaceIndex, string? SurfaceFamily, Vector3D? Normal, string IntersectionMode);+public sealed record RayMapSample(int I, int J, double U, double V, bool Hit, RayMapHit? FirstHit, RayMapHit? LastHit, int HitCount, IReadOnlyList<RayMapHit> Hits);+public sealed record RayMapSummary(double HitCoverage, double[]? HeightRange, IReadOnlyDictionary<string, int> SurfaceFamiliesHit);+public sealed record RayMapResult(string Mode, string Plane, string Direction, int[]? Resolution, double[]? Point, RayMapBounds Bounds, IReadOnlyList<RayMapSample> Samples, int HitCount, IReadOnlyList<RayMapHit>? Hits, RayMapSummary Summary, string IntersectionMode, IReadOnlyList<string> Diagnostics);+public enum SectionPlaneFamily{XY,diff --git a/Aetheris.CLI/StepAnalyzer.cs b/Aetheris.CLI/StepAnalyzer.csindex c4d4e7ea..d179a948 100644--- a/Aetheris.CLI/StepAnalyzer.cs+++ b/Aetheris.CLI/StepAnalyzer.cs@@ -1,5 +1,6 @@using Aetheris.Kernel.Core.Brep;using Aetheris.Kernel.Core.Brep.Queries;+using Aetheris.Kernel.Core.Brep.Tessellation;using Aetheris.Kernel.Core.Geometry;using Aetheris.Kernel.Core.Geometry.Curves;using Aetheris.Kernel.Core.Geometry.Surfaces;@@ -823,7 +824,7 @@ public sealed record VolumeAnalysisResult(var bbox = TryComputeBodyBoundingBox(body) ?? throw new InvalidOperationException("Map probe requires body vertex coordinates to compute a bounding box.");var frame = ResolveProjectionFrame(view, bbox);var epsilon = Math.Max(ToleranceContext.Default.Linear * 64d, 1e-5d);- var faceSurfaceKinds = BuildFaceSurfaceKinds(body);+ var faceSurfaceKinds = BuildFaceSurfaceKinds(body, familyNames: false);var grid = new List<IReadOnlyList<OrthographicSample>>(rows);var hitSamples = 0;@@ -927,6 +928,78 @@ public sealed record VolumeAnalysisResult(return new OrthographicMapResult(metadata, summary, grid, notes);}+ public static RayMapResult AnalyzeRayMap(string stepPath, string plane, string direction, int cols, int rows, (double U, double V)? point = null)+ {+ var (fullPath, body) = ImportStepBody(stepPath);+ return AnalyzeImportedBodyRayMap(body, fullPath, plane, direction, cols, rows, point);+ }++ public static RayMapResult AnalyzeImportedBodyRayMap(BrepBody body, string stepPath, string plane, string direction, int cols, int rows, (double U, double V)? point = null)+ {+ if (rows <= 0 || cols <= 0) throw new InvalidOperationException("Map resolution must be positive.");+ var bbox = TryComputeBodyBoundingBox(body) ?? throw new InvalidOperationException("Map probe requires body vertex coordinates to compute a bounding box.");+ var frame = ResolveRayMapFrame(plane, direction, bbox);+ var faceSurfaceKinds = BuildFaceSurfaceKinds(body, familyNames: true);+ var diagnostics = new List<string>();+ var exactUnavailable = new HashSet<string>(StringComparer.Ordinal);+ foreach (var family in faceSurfaceKinds.Values.Distinct(StringComparer.Ordinal))+ {+ if (family is not "plane" and not "cylinder" and not "sphere")+ {+ exactUnavailable.Add(family);+ }+ }++ foreach (var family in exactUnavailable.OrderBy(v => v, StringComparer.Ordinal))+ {+ diagnostics.Add($"Exact ray intersection unavailable for {family}; used tessellated fallback.");+ }++ var tessellation = BrepDisplayTessellator.TessellateBoundedPartial(body, DisplayTessellationOptions.Default, TimeSpan.FromSeconds(10));+ foreach (var d in tessellation.FaceDiagnostics ?? [])+ {+ diagnostics.Add($"Tessellation diagnostic for face {d.FaceId?.Value.ToString(System.Globalization.CultureInfo.InvariantCulture) ?? "unknown"}: {d.Message}");+ }++ var samples = new List<RayMapSample>();+ var allHeights = new List<double>();+ var surfaceHits = new Dictionary<string, int>(StringComparer.Ordinal);+ var total = point.HasValue ? 1 : rows * cols;+ for (var j = 0; j < (point.HasValue ? 1 : rows); j++)+ {+ var v = point?.V ?? frame.MinV + (rows == 1 ? 0.5d : j / (double)(rows - 1)) * frame.RangeV;+ for (var i = 0; i < (point.HasValue ? 1 : cols); i++)+ {+ var u = point?.U ?? frame.MinU + (cols == 1 ? 0.5d : i / (double)(cols - 1)) * frame.RangeU;+ var origin = frame.PlaneOrigin + (frame.UAxis * u) + (frame.VAxis * v) - (frame.RayDirection * Math.Max(1e-5d, ToleranceContext.Default.Linear * 64d));+ var hits = IntersectTessellatedRay(tessellation, origin, frame.RayDirection, faceSurfaceKinds)+ .OrderBy(h => h.T)+ .ToArray();+ var first = hits.FirstOrDefault();+ var last = hits.LastOrDefault();+ if (first is not null)+ {+ allHeights.Add(frame.Height(first.Position));+ if (first.SurfaceFamily is { } sf)+ {+ surfaceHits[sf] = surfaceHits.TryGetValue(sf, out var c) ? c + 1 : 1;+ }+ }++ samples.Add(new RayMapSample(i, j, u, v, first is not null, first, last, hits.Length, hits));+ }+ }++ var summary = new RayMapSummary(+ samples.Count(s => s.Hit) / (double)total,+ allHeights.Count == 0 ? null : [allHeights.Min(), allHeights.Max()],+ new SortedDictionary<string, int>(surfaceHits, StringComparer.Ordinal));+ var bounds = new RayMapBounds([frame.MinU, frame.MaxU], [frame.MinV, frame.MaxV]);+ var mode = point.HasValue ? "point" : "grid";+ var pointArray = point.HasValue ? new[] { point.Value.U, point.Value.V } : null;+ return new RayMapResult(mode, plane.ToLowerInvariant(), direction.ToLowerInvariant(), point.HasValue ? null : [cols, rows], pointArray, bounds, samples, samples.Sum(s => s.HitCount), point.HasValue ? samples.Single().Hits : null, summary, "tessellated-fallback", diagnostics);+ }+private static AnalyzeSummary BuildSummary(BrepBody body, ICollection<string> notes){var topology = body.Topology;@@ -1318,7 +1391,7 @@ public sealed record VolumeAnalysisResult(_ => "other"};- private static Dictionary<int, string> BuildFaceSurfaceKinds(BrepBody body)+ private static Dictionary<int, string> BuildFaceSurfaceKinds(BrepBody body, bool familyNames = false){var result = new Dictionary<int, string>();foreach (var face in body.Topology.Faces)@@ -1328,7 +1401,7 @@ public sealed record VolumeAnalysisResult(continue;}- result[face.Id.Value] = surface.Kind.ToString();+ result[face.Id.Value] = familyNames ? ToSurfaceFamilyName(surface.Kind) : surface.Kind.ToString();}return result;@@ -1763,6 +1836,71 @@ public sealed record VolumeAnalysisResult(};}+ private static RayMapFrame ResolveRayMapFrame(string plane, string direction, BoundingBox3D bbox)+ {+ var dir = direction.ToLowerInvariant() switch+ {+ "+x" => new Vector3D(1d, 0d, 0d),+ "-x" => new Vector3D(-1d, 0d, 0d),+ "+y" => new Vector3D(0d, 1d, 0d),+ "-y" => new Vector3D(0d, -1d, 0d),+ "+z" => new Vector3D(0d, 0d, 1d),+ "-z" => new Vector3D(0d, 0d, -1d),+ _ => throw new InvalidOperationException("Analyze map direction must be one of +x, -x, +y, -y, +z, -z.")+ };++ return plane.ToLowerInvariant() switch+ {+ "xy" => new RayMapFrame(new Point3D(0d, 0d, dir.Z < 0 ? bbox.Max.Z : bbox.Min.Z), new Vector3D(1d, 0d, 0d), new Vector3D(0d, 1d, 0d), dir, bbox.Min.X, bbox.Max.X, bbox.Min.Y, bbox.Max.Y, p => p.Z),+ "xz" => new RayMapFrame(new Point3D(0d, dir.Y < 0 ? bbox.Max.Y : bbox.Min.Y, 0d), new Vector3D(1d, 0d, 0d), new Vector3D(0d, 0d, 1d), dir, bbox.Min.X, bbox.Max.X, bbox.Min.Z, bbox.Max.Z, p => p.Y),+ "yz" => new RayMapFrame(new Point3D(dir.X < 0 ? bbox.Max.X : bbox.Min.X, 0d, 0d), new Vector3D(0d, 1d, 0d), new Vector3D(0d, 0d, 1d), dir, bbox.Min.Y, bbox.Max.Y, bbox.Min.Z, bbox.Max.Z, p => p.X),+ _ => throw new InvalidOperationException("Analyze map plane must be xy, xz, or yz.")+ };+ }++ private static IReadOnlyList<RayMapHit> IntersectTessellatedRay(DisplayTessellationResult tessellation, Point3D origin, Vector3D direction, IReadOnlyDictionary<int, string> faceSurfaceKinds)+ {+ var hits = new List<RayMapHit>();+ foreach (var patch in tessellation.FacePatches)+ {+ for (var index = 0; index + 2 < patch.TriangleIndices.Count; index += 3)+ {+ var a = patch.Positions[patch.TriangleIndices[index]];+ var b = patch.Positions[patch.TriangleIndices[index + 1]];+ var c = patch.Positions[patch.TriangleIndices[index + 2]];+ if (!TryIntersectTriangle(origin, direction, a, b, c, out var t, out var normal)) continue;+ var p = origin + direction * t;+ var family = faceSurfaceKinds.TryGetValue(patch.FaceId.Value, out var sf) ? sf : "unknown";+ if (hits.Any(h => Math.Abs(h.T - t) < 1e-7d && h.FaceIndex == patch.FaceId.Value)) continue;+ hits.Add(new RayMapHit(t, p, patch.FaceId.Value, family, normal, "tessellated-fallback"));+ }+ }++ return hits.OrderBy(h => h.T).ToArray();+ }++ private static bool TryIntersectTriangle(Point3D origin, Vector3D direction, Point3D a, Point3D b, Point3D c, out double t, out Vector3D normal)+ {+ t = 0d;+ normal = new Vector3D(0d, 0d, 0d);+ var e1 = b - a;+ var e2 = c - a;+ var p = direction.Cross(e2);+ var det = e1.Dot(p);+ if (Math.Abs(det) < 1e-10d) return false;+ var invDet = 1d / det;+ var tv = origin - a;+ var u = tv.Dot(p) * invDet;+ if (u < -1e-9d || u > 1d + 1e-9d) return false;+ var q = tv.Cross(e1);+ var v = direction.Dot(q) * invDet;+ if (v < -1e-9d || u + v > 1d + 1e-9d) return false;+ t = e2.Dot(q) * invDet;+ if (t < -1e-9d) return false;+ normal = e1.Cross(e2);+ return TryNormalize(normal, out normal);+ }+private readonly record struct ProjectionFrame(Point3D PlaneOrigin,Vector3D UAxis,@@ -1781,6 +1919,21 @@ public sealed record VolumeAnalysisResult(public double RangeV => MaxV - MinV;}+ private readonly record struct RayMapFrame(+ Point3D PlaneOrigin,+ Vector3D UAxis,+ Vector3D VAxis,+ Vector3D RayDirection,+ double MinU,+ double MaxU,+ double MinV,+ double MaxV,+ Func<Point3D, double> Height)+ {+ public double RangeU => MaxU - MinU;+ public double RangeV => MaxV - MinV;+ }+private readonly record struct SectionFrame(Vector3D Normal,Vector3D UAxis,diff --git a/docs/implementation/analyze-map-a0-ray-height-map.md b/docs/implementation/analyze-map-a0-ray-height-map.mdnew file mode 100644index 00000000..042983f8--- /dev/null+++ b/docs/implementation/analyze-map-a0-ray-height-map.md@@ -0,0 +1,35 @@+# ANALYZE-MAP-A0 ray/height-map probe++`aetheris analyze map` is an LLM-oriented spatial measurement tool. It samples imported STEP/AP242/BRep bodies by shooting rays from a selected plane and returns hit heights/depths, face ids, surface families, and compact coverage summaries. It is not a topology metadata report and does not attempt CAD feature reconstruction.++## Syntax++```bash+aetheris analyze map part.step --plane xy --direction -z --resolution 32x32 --json+aetheris analyze map part.step --plane xy --direction -z --point 3,4 --json+```++Legacy view flags (`--top`, `--bottom`, `--front`, `--back`, `--left`, `--right`) are still accepted and map to plane/direction pairs.++## Modes++* **Grid**: `--resolution NxM` samples the selected plane over the imported body's bounding-box extent and returns one sample per grid point.+* **Point**: `--point u,v` shoots one ray at a plane coordinate and returns all tessellated hits sorted by ray parameter.++Each sample reports first hit, last hit, hit count, and all hits. The summary includes hit coverage, height range, and surface families hit.++## Backend approach++A0 uses imported BRep bounds to place the sampling plane, then intersects probe rays with display tessellation. This is reported honestly as `tessellated-fallback`; exact analytic ray intersection remains a future optimization for supported surface families.++Fallback diagnostics are emitted when exact intersection is unavailable for surface families such as `linear-extrusion`, `surface-of-revolution`, `bspline`, or `unknown`. Tessellation diagnostics are surfaced instead of crashing.++## Relationship to other analyze commands++* Base `aetheris analyze` reports topology and basic STEP/BRep metadata.+* `aetheris analyze volume` estimates or computes volume and keeps its unsupported-surface policy.+* `aetheris analyze map` measures what a model looks like in space as rays and height/depth samples.++## Limitations++The A0 map is tessellation-backed, so curved and swept surfaces are approximate. It does not classify solid intervals yet, and six-view output is deferred to A1; run the command once per direction for equivalent coverage.diff --git a/docs/implementation/ruled-tooling-a0-inline-step-probe-harness.md b/docs/implementation/ruled-tooling-a0-inline-step-probe-harness.mdindex 788d38a9..d1863467 100644--- a/docs/implementation/ruled-tooling-a0-inline-step-probe-harness.md+++ b/docs/implementation/ruled-tooling-a0-inline-step-probe-harness.md@@ -3,3 +3,13 @@RULED-ANALYZE-A0 updated analyze/reporting so exact swept surface kinds are recognized in analyzer summaries. `SURFACE_OF_LINEAR_EXTRUSION` imports now appear as `linear-extrusion`, and `SURFACE_OF_REVOLUTION` imports now appear as `surface-of-revolution`.Open ruled/swept surface bodies still do not have exact volume integration. `aetheris analyze volume` reports that state as unsupported instead of throwing a dictionary-key exception; this milestone did not add ruled-surface area or volume integration.++## Spatial probe follow-up++`aetheris analyze map` can now spatially inspect ruled and swept STEP artifacts as a ray/height-map probe. For example:++```bash+aetheris analyze map testdata/step242/generated/ruled-a2/ellipse-linear-extrusion-production.step --plane xy --direction -z --resolution 8x8 --json+```++Linear-extrusion faces are reported through the tessellated fallback path unless an exact intersection path is added later; the JSON diagnostics make that fallback explicit.