Skip to content

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.cs
index f80e1102..2d5de116 100644
--- a/Aetheris.CLI.Tests/CliBaselineTests.cs
+++ b/Aetheris.CLI.Tests/CliBaselineTests.cs
@@ -512,6 +512,22 @@ public sealed class CliBaselineTests
Assert.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 CliBaselineTests
return 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.cs
index 615b82d8..62142077 100644
--- a/Aetheris.CLI/CliRunner.cs
+++ b/Aetheris.CLI/CliRunner.cs
@@ -109,7 +109,7 @@ public static class CliRunner
private 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 CliRunner
var 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 CliRunner
case "--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 CliRunner
return 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 CliRunner
string.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.cs
index 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.cs
index 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.md
new file mode 100644
index 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.md
index 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.