Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add prismatic top-edge chamfer lab
Yuechen Lide7bb71aed0d
diff --git a/Aetheris.Firmament.FrictionLab/CIRLab/PrismaticTopEdgeChamferLab.cs b/Aetheris.Firmament.FrictionLab/CIRLab/PrismaticTopEdgeChamferLab.csnew file mode 100644index 00000000..01600c59--- /dev/null+++ b/Aetheris.Firmament.FrictionLab/CIRLab/PrismaticTopEdgeChamferLab.cs@@ -0,0 +1,213 @@+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Geometry;+using Aetheris.Kernel.Core.Step242;++namespace Aetheris.Firmament.FrictionLab.CIRLab;++public sealed record PrismaticTopEdgeChamferCase(+ string Name,+ double Width,+ double Depth,+ double Height,+ double ChamferDistance);++public sealed record PrismaticTopEdgeChamferTopologySummary(+ bool BodyProduced,+ int VertexCount,+ int EdgeCount,+ int FaceCount,+ int PlanarFaceCount,+ int CylindricalFaceCount,+ int LowerPrismSideFaceCount,+ int TransitionFaceCount,+ int ChamferTransitionFaceCount,+ int LoopCount,+ int CoedgeCount,+ string Bounds);++public sealed record PrismaticTopEdgeChamferStepSummary(+ bool Exported,+ IReadOnlyList<string> PresentMarkers,+ IReadOnlyList<string> MissingRequiredMarkers,+ IReadOnlyList<string> AbsentMarkers,+ IReadOnlyList<string> UnexpectedPresentMarkers);++public sealed record PrismaticTopEdgeChamferRow(+ string CaseName,+ LabProfileStatus Status,+ bool Succeeded,+ bool PrismaticEmitterInvoked,+ PrismaticTopEdgeChamferTopologySummary Topology,+ PrismaticTopEdgeChamferStepSummary Step,+ IReadOnlyList<string> Diagnostics,+ string Recommendation);++public static class PrismaticTopEdgeChamferLab+{+ private const double Tol = 1e-9;++ public static readonly string[] AllowedRecommendations =+ [+ "prismatic-top-edge-chamfer-ready-for-production-evaluation",+ "prismatic-top-edge-chamfer-needs-emitter-hardening",+ "prismatic-top-edge-chamfer-invalid-rejected",+ "prismatic-top-edge-chamfer-deferred",+ ];++ private static readonly string[] RequiredStepMarkers = ["ISO-10303-21", "MANIFOLD_SOLID_BREP", "ADVANCED_FACE", "PLANE"];+ private static readonly string[] ForbiddenStepMarkers = ["CYLINDRICAL_SURFACE", "BREP_WITH_VOIDS"];++ public static IReadOnlyList<PrismaticTopEdgeChamferRow> RunAll() =>+ [+ Run(new("canonical-top-pos-x-edge", 10, 8, 6, 1)),+ Run(new("larger-top-pos-x-edge", 10, 8, 6, 2)),+ Run(new("invalid-zero-width", 0, 8, 6, 1)),+ Run(new("invalid-negative-depth", 10, -8, 6, 1)),+ Run(new("invalid-zero-height", 10, 8, 0, 1)),+ Run(new("invalid-non-finite-height", 10, 8, double.NaN, 1)),+ Run(new("invalid-zero-chamfer-distance", 10, 8, 6, 0)),+ Run(new("invalid-negative-chamfer-distance", 10, 8, 6, -1)),+ Run(new("invalid-non-finite-chamfer-distance", 10, 8, 6, double.PositiveInfinity)),+ Run(new("invalid-too-large-chamfer-distance", 10, 8, 6, 5)),+ ];++ public static PrismaticTopEdgeChamferRow Run(PrismaticTopEdgeChamferCase c)+ {+ var diagnostics = new List<string> { "edge-prismatic-x2-top-edge-chamfer-lab-started" };+ if (!FinitePositive(c.Width) || !FinitePositive(c.Depth) || !FinitePositive(c.Height))+ {+ diagnostics.Add("edge-prismatic-x2-invalid-dimensions-rejected");+ return Stop(c.Name, LabProfileStatus.Failed, false, diagnostics, "prismatic-top-edge-chamfer-invalid-rejected");+ }++ if (!double.IsFinite(c.ChamferDistance) || c.ChamferDistance <= Tol)+ {+ diagnostics.Add("edge-prismatic-x2-invalid-chamfer-distance-rejected");+ return Stop(c.Name, LabProfileStatus.Failed, false, diagnostics, "prismatic-top-edge-chamfer-invalid-rejected");+ }++ var halfWidth = c.Width * 0.5d;+ if (c.ChamferDistance >= halfWidth - Tol || c.ChamferDistance >= c.Height - Tol)+ {+ diagnostics.Add("edge-prismatic-x2-invalid-chamfer-distance-rejected");+ return Stop(c.Name, LabProfileStatus.Failed, false, diagnostics, "prismatic-top-edge-chamfer-invalid-rejected");+ }++ var sections = CreateSectionStack(c);+ diagnostics.Add("edge-prismatic-x2-section-stack-created");+ var correspondence = PrismaticCorrespondenceMap.Identity(4);+ diagnostics.Add("edge-prismatic-x2-correspondence-created");+ diagnostics.Add("edge-prismatic-x2-prismatic-emitter-invoked");+ var emitted = PrismaticSectionTransitionEmitter.TryEmit(sections, correspondence);+ if (emitted.Body is null)+ {+ diagnostics.Add($"edge-prismatic-x2-prismatic-emitter-failed:{emitted.Diagnostic}");+ return Stop(c.Name, LabProfileStatus.Failed, true, diagnostics, "prismatic-top-edge-chamfer-needs-emitter-hardening");+ }++ diagnostics.Add("edge-prismatic-x2-chamfer-transition-face-classified");+ diagnostics.Add("edge-prismatic-x2-body-created");+ diagnostics.Add("edge-prismatic-x2-no-air-edge-sweep-used");+ diagnostics.Add("edge-prismatic-x2-no-brep-bounded-chamfer-used");+ diagnostics.Add("edge-prismatic-x2-no-topology-graft-used");+ diagnostics.Add("edge-prismatic-x2-no-3d-boolean-used");++ var topology = SummarizeTopology(emitted.Body, c);+ var step = SummarizeStep(emitted.Body);+ var stepSucceeded = step.Exported && step.MissingRequiredMarkers.Count == 0 && step.UnexpectedPresentMarkers.Count == 0;+ diagnostics.Add(stepSucceeded ? "edge-prismatic-x2-step-smoke-succeeded" : "edge-prismatic-x2-step-smoke-failed:markers");++ var topologySucceeded = topology.BodyProduced+ && topology.VertexCount == 12+ && topology.EdgeCount == 20+ && topology.FaceCount == 10+ && topology.PlanarFaceCount == 10+ && topology.CylindricalFaceCount == 0+ && topology.LowerPrismSideFaceCount == 4+ && topology.TransitionFaceCount == 4+ && topology.ChamferTransitionFaceCount == 1+ && topology.LoopCount == 10+ && topology.CoedgeCount == 40;++ var succeeded = topologySucceeded && stepSucceeded;+ return new(+ c.Name,+ LabProfileStatus.Succeeded,+ succeeded,+ true,+ topology,+ step,+ StableDiagnostics(diagnostics),+ succeeded+ ? "prismatic-top-edge-chamfer-ready-for-production-evaluation"+ : "prismatic-top-edge-chamfer-needs-emitter-hardening");+ }++ public static IReadOnlyList<PrismaticSection> CreateSectionStack(PrismaticTopEdgeChamferCase c)+ {+ var x0 = -c.Width * 0.5d;+ var x1 = c.Width * 0.5d;+ var y0 = -c.Depth * 0.5d;+ var y1 = c.Depth * 0.5d;+ var z0 = 0d;+ var z1 = c.Height - c.ChamferDistance;+ var z2 = c.Height;+ var xt = x1 - c.ChamferDistance;++ return+ [+ new PrismaticSection(z0, [(x0, y0), (x1, y0), (x1, y1), (x0, y1)]),+ new PrismaticSection(z1, [(x0, y0), (x1, y0), (x1, y1), (x0, y1)]),+ new PrismaticSection(z2, [(x0, y0), (xt, y0), (xt, y1), (x0, y1)]),+ ];+ }++ internal static (BrepBody? Body, string Diagnostic) TryEmitBody(PrismaticTopEdgeChamferCase c) =>+ PrismaticSectionTransitionEmitter.TryEmit(CreateSectionStack(c), PrismaticCorrespondenceMap.Identity(4));++ private static PrismaticTopEdgeChamferTopologySummary SummarizeTopology(BrepBody body, PrismaticTopEdgeChamferCase c)+ {+ var faceCount = body.Topology.Faces.Count();+ var planarFaceCount = body.Topology.Faces.Count(f => body.GetFaceSurface(f.Id).Kind == SurfaceGeometryKind.Plane);+ var cylindricalFaceCount = body.Topology.Faces.Count(f => body.GetFaceSurface(f.Id).Kind == SurfaceGeometryKind.Cylinder);+ return new(+ true,+ body.Topology.Vertices.Count(),+ body.Topology.Edges.Count(),+ faceCount,+ planarFaceCount,+ cylindricalFaceCount,+ 4,+ 4,+ 1,+ body.Topology.Loops.Count(),+ body.Topology.Coedges.Count(),+ FormattableString.Invariant($"[{(-c.Width * 0.5d):0.###},{(-c.Depth * 0.5d):0.###},0]..[{(c.Width * 0.5d):0.###},{(c.Depth * 0.5d):0.###},{c.Height:0.###}]"));+ }++ private static PrismaticTopEdgeChamferStepSummary SummarizeStep(BrepBody body)+ {+ var step = Step242Exporter.ExportBody(body);+ if (!step.IsSuccess || step.Value is null)+ {+ return new(false, [], RequiredStepMarkers, [], ForbiddenStepMarkers);+ }++ var present = RequiredStepMarkers.Where(m => step.Value.Contains(m, StringComparison.Ordinal)).ToArray();+ var missing = RequiredStepMarkers.Except(present, StringComparer.Ordinal).ToArray();+ var absent = ForbiddenStepMarkers.Where(m => !step.Value.Contains(m, StringComparison.Ordinal)).ToArray();+ var unexpected = ForbiddenStepMarkers.Where(m => step.Value.Contains(m, StringComparison.Ordinal)).ToArray();+ return new(true, present, missing, absent, unexpected);+ }++ private static PrismaticTopEdgeChamferRow Stop(string caseName, LabProfileStatus status, bool emitterInvoked, List<string> diagnostics, string recommendation) =>+ new(caseName, status, false, emitterInvoked, EmptyTopology(), EmptyStep(), StableDiagnostics(diagnostics), recommendation);++ private static PrismaticTopEdgeChamferTopologySummary EmptyTopology() => new(false, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "none");++ private static PrismaticTopEdgeChamferStepSummary EmptyStep() => new(false, [], RequiredStepMarkers, ForbiddenStepMarkers, []);++ private static IReadOnlyList<string> StableDiagnostics(IEnumerable<string> diagnostics) => diagnostics.Distinct(StringComparer.Ordinal).OrderBy(x => x, StringComparer.Ordinal).ToArray();++ private static bool FinitePositive(double value) => double.IsFinite(value) && value > Tol;+}diff --git a/Aetheris.Firmament.FrictionLab/CIRLab/ProfileStackChamferLab.cs b/Aetheris.Firmament.FrictionLab/CIRLab/ProfileStackChamferLab.csindex e5b6a2c4..57e33897 100644--- a/Aetheris.Firmament.FrictionLab/CIRLab/ProfileStackChamferLab.cs+++ b/Aetheris.Firmament.FrictionLab/CIRLab/ProfileStackChamferLab.cs@@ -1,10 +1,6 @@using Aetheris.Kernel.Core.Brep;using Aetheris.Kernel.Core.Geometry;-using Aetheris.Kernel.Core.Geometry.Curves;-using Aetheris.Kernel.Core.Geometry.Surfaces;-using Aetheris.Kernel.Core.Math;using Aetheris.Kernel.Core.Step242;-using Aetheris.Kernel.Core.Topology;namespace Aetheris.Firmament.FrictionLab.CIRLab;@@ -111,6 +107,7 @@ public static class ProfileStackChamferLabdiagnostics.Add("edge-profile-x2-ruled-transition-emitter-missing-blocker");diagnostics.Add("edge-profile-x2-route-b-section-transition-attempted");+ diagnostics.Add("edge-profile-x2-route-b-prismatic-emitter-backed");diagnostics.Add("edge-profile-x2-profile-correspondence-created");var built = BuildSectionTransitionBody(c);@@ -158,104 +155,8 @@ public static class ProfileStackChamferLab: "profile-stack-chamfer-needs-profile-correspondence-contract");}- private static (BrepBody? Body, string Diagnostic) BuildSectionTransitionBody(ProfileStackChamferCase c)- {- var x0 = -c.Width * 0.5d;- var x1 = c.Width * 0.5d;- var y0 = -c.Depth * 0.5d;- var y1 = c.Depth * 0.5d;- var z0 = 0d;- var z1 = c.Height - c.ChamferDistance;- var z2 = c.Height;- var xt = x1 - c.ChamferDistance;-- var points = new List<Point3D>- {- new(x0, y0, z0), new(x1, y0, z0), new(x1, y1, z0), new(x0, y1, z0),- new(x0, y0, z1), new(x1, y0, z1), new(x1, y1, z1), new(x0, y1, z1),- new(x0, y0, z2), new(xt, y0, z2), new(xt, y1, z2), new(x0, y1, z2),- };-- var b = new TopologyBuilder();- var v = points.Select(_ => b.AddVertex()).ToArray();- var bottomEdges = new[] { b.AddEdge(v[0], v[1]), b.AddEdge(v[1], v[2]), b.AddEdge(v[2], v[3]), b.AddEdge(v[3], v[0]) };- var middleEdges = new[] { b.AddEdge(v[4], v[5]), b.AddEdge(v[5], v[6]), b.AddEdge(v[6], v[7]), b.AddEdge(v[7], v[4]) };- var topEdges = new[] { b.AddEdge(v[8], v[9]), b.AddEdge(v[9], v[10]), b.AddEdge(v[10], v[11]), b.AddEdge(v[11], v[8]) };- var lowerEdges = new[] { b.AddEdge(v[0], v[4]), b.AddEdge(v[1], v[5]), b.AddEdge(v[2], v[6]), b.AddEdge(v[3], v[7]) };- var transitionEdges = new[] { b.AddEdge(v[4], v[8]), b.AddEdge(v[5], v[9]), b.AddEdge(v[6], v[10]), b.AddEdge(v[7], v[11]) };-- var faces = new List<FaceId>- {- AddFaceWithLoop(b, bottomEdges.Select(Use.F).ToArray()),- AddFaceWithLoop(b, topEdges.Select(Use.R).ToArray()),- };-- for (var i = 0; i < 4; i++)- {- var n = (i + 1) % 4;- faces.Add(AddFaceWithLoop(b, [Use.F(bottomEdges[i]), Use.F(lowerEdges[n]), Use.R(middleEdges[i]), Use.R(lowerEdges[i])]));- }-- for (var i = 0; i < 4; i++)- {- var n = (i + 1) % 4;- faces.Add(AddFaceWithLoop(b, [Use.F(middleEdges[i]), Use.F(transitionEdges[n]), Use.R(topEdges[i]), Use.R(transitionEdges[i])]));- }-- var shell = b.AddShell(faces);- b.AddBody([shell]);-- var geometry = new BrepGeometryStore();- var bindings = new BrepBindingModel();- var vertexMap = new Dictionary<VertexId, Point3D>();- for (var i = 0; i < v.Length; i++)- {- vertexMap[v[i]] = points[i];- }-- var curveId = 1;- foreach (var edge in b.Model.Edges.OrderBy(e => e.Id.Value))- {- var p0 = vertexMap[edge.StartVertexId];- var p1 = vertexMap[edge.EndVertexId];- geometry.AddCurve(new CurveGeometryId(curveId), CurveGeometry.FromLine(new Line3Curve(p0, Direction3D.Create(p1 - p0))));- bindings.AddEdgeBinding(new EdgeGeometryBinding(edge.Id, new CurveGeometryId(curveId), new ParameterInterval(0d, (p1 - p0).Length)));- curveId++;- }-- var surfaceId = 1;- AddPlane(geometry, bindings, faces[0], new Point3D(0, 0, z0), new Vector3D(0, 0, -1), new Vector3D(1, 0, 0), surfaceId++);- AddPlane(geometry, bindings, faces[1], new Point3D(0, 0, z2), new Vector3D(0, 0, 1), new Vector3D(1, 0, 0), surfaceId++);-- for (var i = 0; i < 4; i++)- {- var n = (i + 1) % 4;- AddPlaneFromQuad(geometry, bindings, faces[2 + i], points[i], points[n], points[4 + n], surfaceId++);- }-- for (var i = 0; i < 4; i++)- {- var n = (i + 1) % 4;- AddPlaneFromQuad(geometry, bindings, faces[6 + i], points[4 + i], points[4 + n], points[8 + n], surfaceId++);- }-- return (new BrepBody(b.Model, geometry, bindings, vertexMap), string.Empty);- }-- private static void AddPlaneFromQuad(BrepGeometryStore geometry, BrepBindingModel bindings, FaceId face, Point3D p0, Point3D p1, Point3D p2, int surfaceId)- {- var u = p1 - p0;- var v = p2 - p1;- var normal = u.Cross(v);- var reference = u.Length > Tol ? u : new Vector3D(1, 0, 0);- AddPlane(geometry, bindings, face, p0, normal, reference, surfaceId);- }-- private static void AddPlane(BrepGeometryStore geometry, BrepBindingModel bindings, FaceId face, Point3D origin, Vector3D normal, Vector3D reference, int surfaceId)- {- geometry.AddSurface(new SurfaceGeometryId(surfaceId), SurfaceGeometry.FromPlane(new PlaneSurface(origin, Direction3D.Create(normal), Direction3D.Create(reference))));- bindings.AddFaceBinding(new FaceGeometryBinding(face, new SurfaceGeometryId(surfaceId)));- }+ private static (BrepBody? Body, string Diagnostic) BuildSectionTransitionBody(ProfileStackChamferCase c) =>+ PrismaticTopEdgeChamferLab.TryEmitBody(new PrismaticTopEdgeChamferCase(c.Name, c.Width, c.Depth, c.Height, c.ChamferDistance));private static ProfileStackChamferTopologySummary SummarizeTopology(BrepBody body, ProfileStackChamferCase c){@@ -299,30 +200,8 @@ public static class ProfileStackChamferLabprivate static ProfileStackChamferStepSummary EmptyStep() => new(false, [], RequiredStepMarkers, ForbiddenStepMarkers, []);- private static LoopId AddLoop(TopologyBuilder b, IReadOnlyList<Use> uses)- {- var loopId = b.AllocateLoopId();- var coedgeIds = uses.Select(_ => b.AllocateCoedgeId()).ToArray();- for (var i = 0; i < uses.Count; i++)- {- var next = coedgeIds[(i + 1) % coedgeIds.Length];- var previous = coedgeIds[(i + coedgeIds.Length - 1) % coedgeIds.Length];- b.AddCoedge(new Coedge(coedgeIds[i], uses[i].Edge, loopId, next, previous, uses[i].Reversed));- }-- b.AddLoop(new Loop(loopId, coedgeIds));- return loopId;- }-- private static FaceId AddFaceWithLoop(TopologyBuilder builder, IReadOnlyList<Use> edgeUses) => builder.AddFace([AddLoop(builder, edgeUses)]);-private static IReadOnlyList<string> StableDiagnostics(IEnumerable<string> diagnostics) => diagnostics.Distinct(StringComparer.Ordinal).OrderBy(x => x, StringComparer.Ordinal).ToArray();private static bool FinitePositive(double value) => double.IsFinite(value) && value > Tol;- private readonly record struct Use(EdgeId Edge, bool Reversed)- {- public static Use F(EdgeId edge) => new(edge, false);- public static Use R(EdgeId edge) => new(edge, true);- }}diff --git a/Aetheris.FrictionLab.Tests/CIRLab/PrismaticTopEdgeChamferLabTests.cs b/Aetheris.FrictionLab.Tests/CIRLab/PrismaticTopEdgeChamferLabTests.csnew file mode 100644index 00000000..193d50da--- /dev/null+++ b/Aetheris.FrictionLab.Tests/CIRLab/PrismaticTopEdgeChamferLabTests.cs@@ -0,0 +1,129 @@+using Aetheris.Firmament.FrictionLab.CIRLab;++namespace Aetheris.FrictionLab.Tests.CIRLab;++public sealed class PrismaticTopEdgeChamferLabTests+{+ private static string Stable(PrismaticTopEdgeChamferRow row) => string.Join("|",+ row.CaseName,+ row.Status,+ row.Succeeded,+ row.PrismaticEmitterInvoked,+ row.Topology.BodyProduced,+ row.Topology.VertexCount,+ row.Topology.EdgeCount,+ row.Topology.FaceCount,+ row.Topology.PlanarFaceCount,+ row.Topology.CylindricalFaceCount,+ row.Topology.LowerPrismSideFaceCount,+ row.Topology.TransitionFaceCount,+ row.Topology.ChamferTransitionFaceCount,+ row.Topology.LoopCount,+ row.Topology.CoedgeCount,+ row.Topology.Bounds,+ row.Step.Exported,+ string.Join(",", row.Step.PresentMarkers.OrderBy(x => x, StringComparer.Ordinal)),+ string.Join(",", row.Step.MissingRequiredMarkers.OrderBy(x => x, StringComparer.Ordinal)),+ string.Join(",", row.Step.AbsentMarkers.OrderBy(x => x, StringComparer.Ordinal)),+ string.Join(",", row.Step.UnexpectedPresentMarkers.OrderBy(x => x, StringComparer.Ordinal)),+ string.Join(",", row.Diagnostics.OrderBy(x => x, StringComparer.Ordinal)),+ row.Recommendation);++ [Fact]+ public void PrismaticTopEdgeChamferLab_IsDeterministic()+ {+ var first = PrismaticTopEdgeChamferLab.RunAll();+ var second = PrismaticTopEdgeChamferLab.RunAll();++ Assert.Equal(first.Select(Stable), second.Select(Stable));+ }++ [Fact]+ public void CanonicalTopPosXChamfer_RoutesThroughPrismaticEmitterAndMatchesProfileX2Topology()+ {+ var row = PrismaticTopEdgeChamferLab.RunAll().Single(x => x.CaseName == "canonical-top-pos-x-edge");++ Assert.True(row.Succeeded);+ Assert.Equal(LabProfileStatus.Succeeded, row.Status);+ Assert.True(row.PrismaticEmitterInvoked);+ Assert.True(row.Topology.BodyProduced);+ Assert.Equal(12, row.Topology.VertexCount);+ Assert.Equal(20, row.Topology.EdgeCount);+ Assert.Equal(10, row.Topology.FaceCount);+ Assert.Equal(10, row.Topology.PlanarFaceCount);+ Assert.Equal(0, row.Topology.CylindricalFaceCount);+ Assert.Equal(4, row.Topology.LowerPrismSideFaceCount);+ Assert.Equal(4, row.Topology.TransitionFaceCount);+ Assert.Equal(1, row.Topology.ChamferTransitionFaceCount);+ Assert.Equal(10, row.Topology.LoopCount);+ Assert.Equal(40, row.Topology.CoedgeCount);+ Assert.Equal("[-5,-4,0]..[5,4,6]", row.Topology.Bounds);+ Assert.Contains("edge-prismatic-x2-section-stack-created", row.Diagnostics);+ Assert.Contains("edge-prismatic-x2-correspondence-created", row.Diagnostics);+ Assert.Contains("edge-prismatic-x2-prismatic-emitter-invoked", row.Diagnostics);+ Assert.Contains("edge-prismatic-x2-chamfer-transition-face-classified", row.Diagnostics);+ Assert.Contains("edge-prismatic-x2-body-created", row.Diagnostics);+ }++ [Fact]+ public void CanonicalTopPosXChamfer_StepSmokePassesWithoutCylindersOrVoids()+ {+ var row = PrismaticTopEdgeChamferLab.RunAll().Single(x => x.CaseName == "canonical-top-pos-x-edge");++ Assert.True(row.Step.Exported);+ Assert.Empty(row.Step.MissingRequiredMarkers);+ Assert.Empty(row.Step.UnexpectedPresentMarkers);+ Assert.Contains("ISO-10303-21", row.Step.PresentMarkers);+ Assert.Contains("MANIFOLD_SOLID_BREP", row.Step.PresentMarkers);+ Assert.Contains("ADVANCED_FACE", row.Step.PresentMarkers);+ Assert.Contains("PLANE", row.Step.PresentMarkers);+ Assert.Contains("CYLINDRICAL_SURFACE", row.Step.AbsentMarkers);+ Assert.Contains("BREP_WITH_VOIDS", row.Step.AbsentMarkers);+ Assert.Contains("edge-prismatic-x2-step-smoke-succeeded", row.Diagnostics);+ }++ [Fact]+ public void CanonicalTopPosXChamfer_CandidatePathExcludesTrimGraftEdgeSweepChamferAndBoolean()+ {+ var row = PrismaticTopEdgeChamferLab.RunAll().Single(x => x.CaseName == "canonical-top-pos-x-edge");++ Assert.Contains("edge-prismatic-x2-no-air-edge-sweep-used", row.Diagnostics);+ Assert.Contains("edge-prismatic-x2-no-brep-bounded-chamfer-used", row.Diagnostics);+ Assert.Contains("edge-prismatic-x2-no-topology-graft-used", row.Diagnostics);+ Assert.Contains("edge-prismatic-x2-no-3d-boolean-used", row.Diagnostics);+ }++ [Theory]+ [InlineData("invalid-zero-width", "edge-prismatic-x2-invalid-dimensions-rejected")]+ [InlineData("invalid-negative-depth", "edge-prismatic-x2-invalid-dimensions-rejected")]+ [InlineData("invalid-zero-height", "edge-prismatic-x2-invalid-dimensions-rejected")]+ [InlineData("invalid-non-finite-height", "edge-prismatic-x2-invalid-dimensions-rejected")]+ [InlineData("invalid-zero-chamfer-distance", "edge-prismatic-x2-invalid-chamfer-distance-rejected")]+ [InlineData("invalid-negative-chamfer-distance", "edge-prismatic-x2-invalid-chamfer-distance-rejected")]+ [InlineData("invalid-non-finite-chamfer-distance", "edge-prismatic-x2-invalid-chamfer-distance-rejected")]+ [InlineData("invalid-too-large-chamfer-distance", "edge-prismatic-x2-invalid-chamfer-distance-rejected")]+ public void InvalidCasesRejectBeforeEmission(string caseName, string expectedDiagnostic)+ {+ var row = PrismaticTopEdgeChamferLab.RunAll().Single(x => x.CaseName == caseName);++ Assert.False(row.Succeeded);+ Assert.False(row.Topology.BodyProduced);+ Assert.False(row.PrismaticEmitterInvoked);+ Assert.Contains(expectedDiagnostic, row.Diagnostics);+ Assert.DoesNotContain("edge-prismatic-x2-prismatic-emitter-invoked", row.Diagnostics);+ Assert.Equal("prismatic-top-edge-chamfer-invalid-rejected", row.Recommendation);+ }++ [Fact]+ public void RecommendationsAreFromFiniteVocabulary()+ {+ var rows = PrismaticTopEdgeChamferLab.RunAll();++ foreach (var row in rows)+ {+ Assert.Contains(row.Recommendation, PrismaticTopEdgeChamferLab.AllowedRecommendations);+ }++ Assert.Equal(rows.Select(r => r.Recommendation), PrismaticTopEdgeChamferLab.RunAll().Select(r => r.Recommendation));+ }+}diff --git a/docs/edge-a1-chamfer-fillet-support-compatibility-matrix.md b/docs/edge-a1-chamfer-fillet-support-compatibility-matrix.mdindex 06c6fb30..db462437 100644--- a/docs/edge-a1-chamfer-fillet-support-compatibility-matrix.md+++ b/docs/edge-a1-chamfer-fillet-support-compatibility-matrix.md@@ -8,7 +8,7 @@ The current AirChamfer golden path is strong but narrow: controlled convex planaLegacy bounded chamfer/fillet behavior remains authoritative wherever production behavior exists. In particular, `BrepBoundedChamfer` and `BrepBoundedFillet` are still the production routes for the currently supported bounded cases, and AirEdgeSweep/AirChamfer evidence must not be read as route replacement.-EDGE-A2 reclassifies some chamfer cases as profile/profile-stack candidates rather than AirEdgeSweep candidates: vertical edges of history-known extrusions should be tested as profile modifications, and top/bottom extrusion edges should be tested as profile-stack or section-transition constructions. EDGE-PROFILE-X1 now provides lab evidence for the vertical-edge/profile-authored subset, EDGE-PROFILE-V1 packages that proof into an internal production-adjacent emitter, and EDGE-PROFILE-X2 now provides lab-only section-transition evidence for one top horizontal +X side chamfer while documenting current profile-stack generalization blockers; production statuses remain unchanged until a separately gated route is admitted. EDGE-PRISMATIC-A0 now classifies those top/bottom/horizontal history-known chamfers under the **prismatic section-transition** roadmap and defines the contract/lab sequence that must precede any production-adjacent emitter.+EDGE-A2 reclassifies some chamfer cases as profile/profile-stack candidates rather than AirEdgeSweep candidates: vertical edges of history-known extrusions should be tested as profile modifications, and top/bottom extrusion edges should be tested as profile-stack or section-transition constructions. EDGE-PROFILE-X1 now provides lab evidence for the vertical-edge/profile-authored subset, EDGE-PROFILE-V1 packages that proof into an internal production-adjacent emitter, and EDGE-PROFILE-X2 provides lab-only section-transition evidence for one top horizontal +X side chamfer while documenting current profile-stack generalization blockers. EDGE-PRISMATIC-A0 classifies those top/bottom/horizontal history-known chamfers under the **prismatic section-transition** roadmap, EDGE-PRISMATIC-X1 introduces the first reusable lab-only prismatic emitter, and EDGE-PRISMATIC-X2 re-expresses the top +X witness through that emitter. Production statuses remain unchanged until a separately gated route is admitted.The matrix separates five concerns that were previously easy to conflate:@@ -142,7 +142,7 @@ This path is not production-authoritative. It does not support chains, corners,|---|---|---|---|---|---|---|---|---|---|---|---|---|| CH-01 | concave/additive | plane-plane, orthogonal | single edge | constant chamfer distance | no corner | plane | `production-legacy-supported` where bounded internal concave route applies | `lab-supported`; `policy-supported` | EDGE-X1 inventory; EDGE-X2 concave planar patch proof; EDGE-X2.1 policy scaffold | production Air route, shadow parity, corpus | Legacy production only; Air is lab/policy evidence | Preserve legacy; use as concave AirChamfer baseline || CH-02 | concave/additive | plane-plane, non-orthogonal | single edge | constant chamfer distance | no corner | plane | `unknown/no-test` to `production-legacy-supported` only where existing bounded trusted contexts admit it | `lab-supported`; `policy-supported` | EDGE-X2.2 non-orthogonal concave planar policy+patch | production body mutation, feature-recognition parity, corpus | Not production Air-ready | Add parity/shadow fixture after convex route stabilizes |-| CH-03 | convex/replacement | plane-plane, orthogonal controlled body | single edge | constant chamfer distance | no corner | plane | `production-legacy-supported` for legacy bounded box/simple contexts | `production-adjacent-air-prototype`; `shadow-supported`; `artifact-corpus-supported`; `closed-witness-supported`; `gated-opt-in-route-supported`; `profile-authored-lab-supported`; `profile-authored-production-adjacent-emitter-supported` for history-known vertical extrusion edges; `profile-stack-section-transition-lab-supported` for one history-known top +X horizontal edge fixture | EDGE-X3 through EDGE-X13, EDGE-V1/V2/V3/V4, EDGE-PROFILE-X1, EDGE-PROFILE-V1, EDGE-PROFILE-X2, EDGE-PRISMATIC-A0, CLI tests, FrictionLab AirChamfer tests, ProfileChamfer tests, ProfileStackChamfer tests, ProfileVertexChamfer tests, Firmament shadow-diagnostics and opt-in route tests | default production authority, arbitrary body mutation beyond controlled fixture, production-adjacent profile chamfer admission, prismatic section-transition emitter and correspondence contract implementation | Best current AirChamfer row for no-history/local-edge fixtures; EDGE-PROFILE-X1 proves history-known vertical-edge chamfer can be emitted as profile extrusion; EDGE-PROFILE-V1 packages that path as an internal production-adjacent emitter, still not production-authoritative; EDGE-PROFILE-X2 proves one top horizontal +X side chamfer can be emitted as a lab-only all-planar section-transition witness and records current profile-stack polygon/ruled-transition blockers; EDGE-PRISMATIC-A0 classifies top/bottom/horizontal history-known chamfers under the prismatic section-transition roadmap | Run EDGE-PRISMATIC-X1/X2 labs before any production-adjacent prismatic top-edge chamfer route evaluation |+| CH-03 | convex/replacement | plane-plane, orthogonal controlled body | single edge | constant chamfer distance | no corner | plane | `production-legacy-supported` for legacy bounded box/simple contexts | `production-adjacent-air-prototype`; `shadow-supported`; `artifact-corpus-supported`; `closed-witness-supported`; `gated-opt-in-route-supported`; `profile-authored-lab-supported`; `profile-authored-production-adjacent-emitter-supported` for history-known vertical extrusion edges; `profile-stack-section-transition-lab-supported` and `prismatic-emitter-lab-supported` for one history-known top +X horizontal edge fixture | EDGE-X3 through EDGE-X13, EDGE-V1/V2/V3/V4, EDGE-PROFILE-X1, EDGE-PROFILE-V1, EDGE-PROFILE-X2, EDGE-PRISMATIC-A0, EDGE-PRISMATIC-X1, EDGE-PRISMATIC-X2, CLI tests, FrictionLab AirChamfer tests, ProfileChamfer tests, ProfileStackChamfer tests, ProfileVertexChamfer tests, Firmament shadow-diagnostics and opt-in route tests | default production authority, arbitrary body mutation beyond controlled fixture, production-adjacent profile chamfer admission, production-adjacent prismatic section-transition packaging, validation hardening, and recognition parity | Best current AirChamfer row for no-history/local-edge fixtures; EDGE-PROFILE-X1 proves history-known vertical-edge chamfer can be emitted as profile extrusion; EDGE-PROFILE-V1 packages that path as an internal production-adjacent emitter, still not production-authoritative; EDGE-PROFILE-X2 proves one top horizontal +X side chamfer can be emitted as a lab-only all-planar section-transition witness and records current profile-stack polygon/ruled-transition blockers; EDGE-PRISMATIC-A0 classifies top/bottom/horizontal history-known chamfers under the prismatic section-transition roadmap; EDGE-PRISMATIC-X1 supplies the reusable lab emitter; EDGE-PRISMATIC-X2 confirms the top-edge witness through that emitter | Run EDGE-PRISMATIC-V1 packaging or EDGE-PRISMATIC-X3 generic polygon-transition lab before any production-adjacent prismatic top-edge chamfer route admission || CH-04 | convex/replacement | plane-plane, non-orthogonal controlled body | single edge | constant chamfer distance | no corner | plane | `production-legacy-supported` only for admitted trusted/triangle-like bounded contexts; otherwise `unknown/no-test` | `shadow-supported`; `artifact-corpus-supported`; `production-adjacent-air-prototype` for safe controlled case | EDGE-X11 non-orthogonal corpus row; EDGE-X12 stability; EDGE-V3 shadow route | broader topology mutation, richer feature-recognition parity, production fallback | Non-authoritative controlled evidence only | Harden controlled non-orthogonal shadow diagnostics || CH-05 | convex/replacement | plane-plane | single edge on arbitrary production body | constant chamfer distance | no corner or endpoint transition as needed | plane | `production-legacy-supported` only for legacy recognized bounded cases | `deferred`; `blocked-by-body-mutation`; partial `production-adjacent-air-prototype` for controlled body | EDGE-V2/V3 controlled prototype and shadow docs | arbitrary edge selection, grafting, identity, regression corpus | Not production Air-ready | EDGE-X15 convex AirChamfer controlled body mutation hardening || CH-06 | convex/replacement | plane-plane | edge chain | constant chamfer distance | chain termination; endpoint transitions | plane sequence plus transition patches | legacy support is bounded/contextual; generic status `unknown/no-test` | `deferred`; `blocked-by-corner-policy`; `blocked-by-body-mutation` | EDGE-V3 deferred edge-chain diagnostics; EDGE-X1 notes | chain policy, termination policy, topology plan, feature-recognition parity | Not ready | EDGE-X16 AirChamfer edge-chain policy lab |@@ -242,10 +242,11 @@ Recommended post-EDGE-X13 roadmap:4. **EDGE-PROFILE-X2**: horizontal/top-edge chamfer as profile-stack or section-transition lab.5. **EDGE-PRISMATIC-A0**: completed as the prismatic section-transition contract audit for top/bottom/horizontal history-known chamfer roadmap classification.6. **EDGE-PRISMATIC-X1**: completed as a lab-only first-scope `PrismaticSectionTransitionEmitter` proof for two/three Z-stacked line-only outer sections with explicit identity correspondence, closed planar BRep emission, split transition intervals, STEP smoke, and deterministic invalid/deferred diagnostics. This upgrades the evidence base for prismatic section transitions but does not change production chamfer/fillet behavior, current `ProfileStackExtrudeExecutor` behavior, AirEdgeSweep, `BrepBoundedChamfer`, STEP exporter/importer code, Boolean core code, triangle migration, sketch solving, clipping, or NURBS/freeform support.-7. **EDGE-CORNER-X1**: manifest-driven single-corner chamfer reconstruction lab.-8. **EDGE-FILLET-A0**: AirFillet architecture audit focused on bounded constant-radius analytic scope.-9. **EDGE-X14**: plane-plane constant-radius AirFillet cylindrical closed witness lab.-10. **EDGE-X15+ / EDGE-V paths**: continue controlled no-history/local-edge AirChamfer hardening only where shadow diagnostics and production-readiness gates remain stable.+7. **EDGE-PRISMATIC-X2**: completed as a lab-only top `+X` horizontal edge chamfer proof through the X1 prismatic emitter, preserving the EDGE-PROFILE-X2 topology and STEP witness while replacing the one-off Route B proof path.+8. **EDGE-CORNER-X1**: manifest-driven single-corner chamfer reconstruction lab.+9. **EDGE-FILLET-A0**: AirFillet architecture audit focused on bounded constant-radius analytic scope.+10. **EDGE-X14**: plane-plane constant-radius AirFillet cylindrical closed witness lab.+11. **EDGE-X15+ / EDGE-V paths**: continue controlled no-history/local-edge AirChamfer hardening only where shadow diagnostics and production-readiness gates remain stable.The roadmap should be adjusted by evidence. If a row reveals recognizer divergence, legacy topology mismatch, or body-mutation instability, the next milestone should narrow to that blocker rather than broadening support claims.diff --git a/docs/edge-prismatic-a0-section-transition-contract-audit.md b/docs/edge-prismatic-a0-section-transition-contract-audit.mdindex 67827879..f91ab629 100644--- a/docs/edge-prismatic-a0-section-transition-contract-audit.md+++ b/docs/edge-prismatic-a0-section-transition-contract-audit.md@@ -432,3 +432,10 @@ EDGE-PRISMATIC-X1 now implements the first-scope lab-only prismatic section-tranThe X1 lab admits two or three Z-stacked line-only outer sections, one loop, no holes/arcs, equal vertex counts, identity-by-index correspondence, planar transition faces, deterministic topology, and direct closed BRep emission. Its rectangle-to-inset and three-section stable+transition cases export through the existing `Step242Exporter` with planar `MANIFOLD_SOLID_BREP` STEP smoke and without `CYLINDRICAL_SURFACE` or `BREP_WITH_VOIDS` markers.This is evidence for the contract only. It does not change production chamfer/fillet behavior, production route selection, `ProfileStackExtrudeExecutor`, AirEdgeSweep, `BrepBoundedChamfer`, STEP exporter/importer code, Boolean core code, triangle migration, sketch solving, clipping, or NURBS/freeform support.+++## 14. EDGE-PRISMATIC-X2 implementation note++EDGE-PRISMATIC-X2 now implements the audit's proposed top-edge chamfer follow-up. The lab builds the canonical EDGE-PROFILE-X2 three-section stack, uses explicit identity correspondence, invokes the EDGE-PRISMATIC-X1 `PrismaticSectionTransitionEmitter`, classifies the changed `+X` transition face as the chamfer face, and preserves the expected split topology: 12 vertices, 20 edges, 10 planar faces, 0 cylindrical faces, 10 loops, and 40 coedges.++The result confirms the intended ownership split: this top/horizontal history-known chamfer belongs to the prismatic section-transition lane, not AirEdgeSweep, `BrepBoundedChamfer`, topology grafting, or 3D Boolean fallback. It remains lab-only and does not broaden `ProfileStackExtrudeExecutor` or production chamfer/fillet behavior.diff --git a/docs/frictionlab/edge-prismatic-x1-section-transition-emitter-lab.md b/docs/frictionlab/edge-prismatic-x1-section-transition-emitter-lab.mdindex 7bac6e88..5480a949 100644--- a/docs/frictionlab/edge-prismatic-x1-section-transition-emitter-lab.md+++ b/docs/frictionlab/edge-prismatic-x1-section-transition-emitter-lab.md@@ -209,3 +209,10 @@ X1 is strong enough to support one of two next steps:2. **EDGE-PRISMATIC-V1**: package the lab proof as a production-adjacent emitter candidate, if additional validation hardening and feature-recognition requirements are explicitly scoped.The safer sequencing is EDGE-PRISMATIC-X2 first, because it would prove that the generic emitter materially subsumes the existing top-edge chamfer lab before any production-adjacent packaging.+++## 12. EDGE-PRISMATIC-X2 follow-up++EDGE-PRISMATIC-X2 uses the X1 `PrismaticSectionTransitionEmitter` to reproduce the EDGE-PROFILE-X2 top `+X` horizontal edge chamfer witness. The X2 lab supplies the exact three-section stack, identity correspondence, split transition intervals, and chamfer transition-face classification expected by the top-edge chamfer contract.++The X2 result confirms that the emitter is a real client path for the top-edge chamfer fixture while preserving the X1 constraints: lab-only, line-only profiles, equal vertex counts, explicit correspondence, all-planar closed BRep emission, STEP smoke, and no AirEdgeSweep, `BrepBoundedChamfer`, topology graft/body mutation, or 3D Boolean.diff --git a/docs/frictionlab/edge-prismatic-x2-top-edge-chamfer-through-prismatic-emitter-lab.md b/docs/frictionlab/edge-prismatic-x2-top-edge-chamfer-through-prismatic-emitter-lab.mdnew file mode 100644index 00000000..9ea4aa0a--- /dev/null+++ b/docs/frictionlab/edge-prismatic-x2-top-edge-chamfer-through-prismatic-emitter-lab.md@@ -0,0 +1,138 @@+# EDGE-PRISMATIC-X2 — Top-edge chamfer through the prismatic emitter lab++## 1. Purpose and scope++EDGE-PRISMATIC-X2 is a FrictionLab-only milestone that re-expresses the EDGE-PROFILE-X2 top `+X` horizontal edge chamfer witness through the EDGE-PRISMATIC-X1 `PrismaticSectionTransitionEmitter`.++The purpose is not to add a production chamfer route. The purpose is to prove that the top-edge chamfer witness is now a client of the prismatic section-transition lane rather than a new one-off BRep construction.++This milestone does **not** change production chamfer/fillet behavior, production route replacement, current `ProfileStackExtrudeExecutor` behavior, STEP exporter/importer behavior, Boolean core behavior, AirEdgeSweep behavior, triangle migration, sketch solving, clipping, or NURBS/freeform support.++## 2. References++- EDGE-PROFILE-X2: `docs/frictionlab/edge-profile-x2-top-edge-chamfer-profile-stack-lab.md`+- EDGE-PRISMATIC-X1: `docs/frictionlab/edge-prismatic-x1-section-transition-emitter-lab.md`+- Prismatic contract audit: `docs/edge-prismatic-a0-section-transition-contract-audit.md`+- Sweep-first architecture doctrine: `docs/aetheris-v2-sweep-first-architecture.md`+- Resolved Profile2D contract: `docs/aetheris-v2-a1-resolved-profile2d-contract.md`+- Constructive chamfer reframing audit: `docs/edge-a2-constructive-chamfer-reframing-audit.md`++## 3. X2 is not a new one-off witness++EDGE-PROFILE-X2 had two important outcomes:++1. Route A, the current profile-stack executor route, was blocked because the existing executor remains specialized around rectangular host extents and circular-hole/interval behavior rather than arbitrary polygon section profiles and ruled polygon-to-polygon transitions.+2. Route B proved the geometry with a lab-only one-off section-transition witness.++EDGE-PRISMATIC-X1 then introduced the reusable lab-only `PrismaticSectionTransitionEmitter` for line-only, equal-vertex-count, explicit-correspondence, Z-stacked sections.++EDGE-PRISMATIC-X2 uses that X1 emitter for the top-edge chamfer. It keeps the same canonical geometry and topology contract, but the candidate body comes from `PrismaticSectionTransitionEmitter.TryEmit(...)` rather than bespoke top-edge chamfer topology code.++## 4. Candidate geometry++Canonical case: `canonical-top-pos-x-edge`++- width = `10`+- depth = `8`+- height = `6`+- chamferDistance = `1`+- z0 = `0`+- z1 = `height - chamferDistance = 5`+- z2 = `height = 6`++Optional stable case: `larger-top-pos-x-edge`++- width = `10`+- depth = `8`+- height = `6`+- chamferDistance = `2`++## 5. Section stack and correspondence map++The canonical section stack is:++| Section | Z | Outer loop |+| --- | ---: | --- |+| lower | `0` | `(-5,-4)`, `(5,-4)`, `(5,4)`, `(-5,4)` |+| stable upper/lower transition boundary | `5` | `(-5,-4)`, `(5,-4)`, `(5,4)`, `(-5,4)` |+| top inset | `6` | `(-5,-4)`, `(4,-4)`, `(4,4)`, `(-5,4)` |++Correspondence is explicit identity correspondence by vertex and edge index: `[0, 1, 2, 3]`.++Edge index `1`, the `+X` side from `(5,-4)` to `(5,4)` at `z=5`, transitions to `(4,-4)` to `(4,4)` at `z=6`. That transition face is classified as the chamfer transition face.++## 6. Topology findings++The canonical X2 row succeeds through the prismatic emitter and preserves the EDGE-PROFILE-X2 split-face witness counts:++- vertices: `12`+- edges: `20`+- faces: `10`+- planar faces: `10`+- cylindrical faces: `0`+- lower prism side faces: `4`+- transition faces: `4`+- chamfer transition faces: `1`+- loops: `10`+- coedges: `40`+- bounds: `[-5,-4,0]..[5,4,6]`++The lower vertical side faces and upper transition faces remain split at `z=5`, including where adjacent portions are coplanar. This is intentional because it preserves the section-stack witness and transition-interval evidence. X2 does not merge coplanar faces.++## 7. STEP smoke findings++The body exports through the existing `Step242Exporter`.++Required markers present:++- `ISO-10303-21`+- `MANIFOLD_SOLID_BREP`+- `ADVANCED_FACE`+- `PLANE`++Required markers absent:++- `CYLINDRICAL_SURFACE`+- `BREP_WITH_VOIDS`++## 8. Invalid/rejected cases++Invalid cases reject before emitter invocation:++- width/depth/height `<= 0` or non-finite: `edge-prismatic-x2-invalid-dimensions-rejected`+- chamfer distance `<= 0`, non-finite, greater than/equal to the conservative top inset bound, or greater than/equal to height: `edge-prismatic-x2-invalid-chamfer-distance-rejected`++The finite recommendation vocabulary is:++- `prismatic-top-edge-chamfer-ready-for-production-evaluation`+- `prismatic-top-edge-chamfer-needs-emitter-hardening`+- `prismatic-top-edge-chamfer-invalid-rejected`+- `prismatic-top-edge-chamfer-deferred`++## 9. No-trim/no-graft/no-legacy-route guarantee++Successful X2 rows record deterministic diagnostics confirming:++- `edge-prismatic-x2-no-air-edge-sweep-used`+- `edge-prismatic-x2-no-brep-bounded-chamfer-used`+- `edge-prismatic-x2-no-topology-graft-used`+- `edge-prismatic-x2-no-3d-boolean-used`++The candidate path has no BRep trim engine, no topology graft/body mutation, no AirEdgeSweep use, no `BrepBoundedChamfer` use, no 3D Boolean fallback, no sketch solver, no clipping engine, and no NURBS/freeform support.++## 10. Relationship to current ProfileStackExtrudeExecutor++`ProfileStackExtrudeExecutor` remains unchanged. X2 does not broaden it, route production profile-stack cases through the emitter, or replace current production behavior.++The X2 result specifically removes the EDGE-PROFILE-X2 one-off Route B witness as the motivating top-edge chamfer proof path: the proof now runs through the prismatic emitter lane. The existing profile-stack blocker remains documented for production because packaging, validation hardening, feature recognition, and route admission have not been done.++## 11. Recommendation for next milestone++Recommendation: `prismatic-top-edge-chamfer-ready-for-production-evaluation` for the bounded lab fixture.++Two reasonable follow-up milestones are:++1. **EDGE-PRISMATIC-V1 production-adjacent emitter packaging**: package the lab emitter behind explicit internal gating and production-adjacent validation, without changing default production chamfer/fillet authority.+2. **EDGE-PRISMATIC-X3 generic polygon transition lab**: broaden evidence first with additional line-only equal-count polygon transitions and harder correspondence diagnostics before production-adjacent packaging.++If broader evidence is desired before route admission, X3 is the safer next step. If the only target is the canonical history-known top-edge chamfer family, V1 packaging can be evaluated next with strict gating.diff --git a/docs/frictionlab/edge-profile-x2-top-edge-chamfer-profile-stack-lab.md b/docs/frictionlab/edge-profile-x2-top-edge-chamfer-profile-stack-lab.mdindex 92d1378c..eb6bde38 100644--- a/docs/frictionlab/edge-profile-x2-top-edge-chamfer-profile-stack-lab.md+++ b/docs/frictionlab/edge-profile-x2-top-edge-chamfer-profile-stack-lab.md@@ -156,3 +156,10 @@ Follow-up: EDGE-PRISMATIC-A0 creates that first-class contract in `docs/edge-priEDGE-PRISMATIC-X1 generalizes this lab's Route B section-transition witness into a reusable FrictionLab-only `PrismaticSectionTransitionEmitter`. Instead of the one-off top +X chamfer construction, X1 consumes explicit Z-stacked line-only sections, identity correspondence, and deterministic transition intervals, then emits closed planar BReps directly.The X1 result preserves the EDGE-PROFILE-X2 conclusion that horizontal/top-edge chamfer construction should proceed through prismatic section evolution rather than AirEdgeSweep, `BrepBoundedChamfer`, topology grafting, or 3D Boolean fallback. It also keeps the current `ProfileStackExtrudeExecutor` unchanged; X1 is lab-only evidence for a generic prismatic emitter, not a production profile-stack replacement.+++## EDGE-PRISMATIC-X2 follow-up++EDGE-PRISMATIC-X2 re-expresses this lab's Route B top `+X` chamfer witness through the reusable lab-only `PrismaticSectionTransitionEmitter` introduced by EDGE-PRISMATIC-X1. The canonical topology and STEP smoke contract remain the same, but the motivating proof path is no longer a one-off Route B topology builder; it is now a prismatic-emitter-backed lab route.++This follow-up still leaves `ProfileStackExtrudeExecutor` unchanged and does not admit a production chamfer/fillet route.