Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add DisplayIR wireframe fallback
Yuechen Li5f6c4355a335
diff --git a/Aetheris.Server/Api/KernelEndpoints.cs b/Aetheris.Server/Api/KernelEndpoints.csindex 036cd543..5e4f5b04 100644--- a/Aetheris.Server/Api/KernelEndpoints.cs+++ b/Aetheris.Server/Api/KernelEndpoints.cs@@ -4,8 +4,10 @@ using Aetheris.Kernel.Core.Brep.Features;using Aetheris.Kernel.Core.Brep.Picking;using Aetheris.Kernel.Core.Brep.Queries;using Aetheris.Kernel.Core.Brep.Tessellation;+using Aetheris.Kernel.Core.Geometry;using Aetheris.Kernel.Core.Math;using Aetheris.Kernel.Core.Step242;+using Aetheris.Kernel.Core.Topology;using Aetheris.Server.Contracts;using Aetheris.Server.Documents;using System.Security.Cryptography;@@ -328,6 +330,11 @@ public static class KernelEndpoints}var meshByFace = tessellationFallback?.FacePatches.ToDictionary(patch => patch.FaceId) ?? [];+ var wireByFace = body.Topology.Faces+ .OrderBy(face => face.Id.Value)+ .Select(face => (face.Id, Wire: TryBuildWirePatch(body, face.Id)))+ .Where(item => item.Wire is not null)+ .ToDictionary(item => item.Id.Value, item => item.Wire!);var analyticByFace = analyticDto.AnalyticFaces.ToDictionary(face => face.FaceId);var fallbackByFace = analyticDto.FallbackFaces.ToDictionary(face => face.FaceId);var diagnosticsByFace = displayDiagnostics@@ -340,9 +347,14 @@ public static class KernelEndpointsmeshByFace.TryGetValue(face.Id.Value, out var meshPatch);fallbackByFace.TryGetValue(face.Id.Value, out var fallbackFace);diagnosticsByFace.TryGetValue(face.Id.Value, out var faceDiagnostics);- var status = analyticFace is not null ? "Analytic" : meshPatch is not null ? "Mesh" : faceDiagnostics is { Count: > 0 } ? "DiagnosticOnly" : "Omitted";- var patchKind = analyticFace is not null ? "AnalyticPatch" : meshPatch is not null ? "MeshPatch" : faceDiagnostics is { Count: > 0 } ? "DiagnosticPatch" : "DiagnosticPatch";- var materializationLane = analyticFace is not null ? "AnalyticPatch" : meshPatch is not null ? "BoundedMesh" : faceDiagnostics is { Count: > 0 } ? "BoundedMesh" : "DiagnosticOnly";+ wireByFace.TryGetValue(face.Id.Value, out var wirePatch);+ var canUseWireFallback = analyticFace is null && meshPatch is null && faceDiagnostics is { Count: > 0 } && wirePatch is not null && wirePatch.Loops.Count > 0;+ var status = analyticFace is not null ? "Analytic" : meshPatch is not null ? "Mesh" : canUseWireFallback ? "WireframeOnly" : faceDiagnostics is { Count: > 0 } ? "DiagnosticOnly" : "Omitted";+ var patchKind = analyticFace is not null ? "AnalyticPatch" : meshPatch is not null ? "MeshPatch" : canUseWireFallback ? "WirePatch" : faceDiagnostics is { Count: > 0 } ? "DiagnosticPatch" : "DiagnosticPatch";+ var materializationLane = analyticFace is not null ? "AnalyticPatch" : meshPatch is not null ? "BoundedMesh" : canUseWireFallback ? "WirePatch" : faceDiagnostics is { Count: > 0 } ? "BoundedMesh" : "DiagnosticOnly";+ var combinedDiagnostics = canUseWireFallback+ ? (faceDiagnostics ?? []).Concat([new DisplayDiagnosticDto("Viewer.Display.WireframeOnly", "Face fill materialization failed; boundary edges were emitted as preview wireframe DisplayIR.", face.Id.Value, analyticFace?.SurfaceKind ?? fallbackFace?.SurfaceKind, "BRepEdgeWireLowering", null)]).ToArray()+ : faceDiagnostics ?? [];return new DisplayFaceDto(face.Id.Value,analyticFace?.ShellId ?? fallbackFace?.ShellId,@@ -351,15 +363,16 @@ public static class KernelEndpointspatchKind,meshPatch,analyticFace,+ canUseWireFallback ? wirePatch : null,materializationLane,- faceDiagnostics ?? []);+ combinedDiagnostics);}).ToArray();var status = faces.All(face => face.Status is "DiagnosticOnly" or "Omitted") ? "DiagnosticOnly" :- faces.Any(face => face.Status is "DiagnosticOnly" or "Omitted") ? "Partial" : "Complete";+ faces.Any(face => face.Status is "DiagnosticOnly" or "Omitted" or "WireframeOnly") ? "Partial" : "Complete";if (status is "Partial"){- displayDiagnostics.Insert(0, new DisplayDiagnosticDto("Viewer.Display.Partial", "Display preparation completed with one or more diagnostic-only faces.", null, null, null, null));+ displayDiagnostics.Insert(0, new DisplayDiagnosticDto("Viewer.Display.Partial", "Display preparation completed with one or more diagnostic-only or wireframe-only faces.", null, null, null, null));}var displayLanes = new List<DisplayLaneDto>();@@ -386,6 +399,11 @@ public static class KernelEndpointsboundedMeshDiagnostics));}+ if (faces.Any(face => face.Status == "WireframeOnly"))+ {+ displayLanes.Add(new DisplayLaneDto("WirePatch", "Partial", "BRep", "DisplayIR", "BRepEdgeWireLowering", "PreviewPolyline", null, faces.Count(face => face.Status == "WireframeOnly"), faces.Where(face => face.Status == "WireframeOnly").Sum(face => face.Diagnostics.Count)));+ }+if (faces.Any(face => face.Status == "DiagnosticOnly")){displayLanes.Add(new DisplayLaneDto("DiagnosticOnly", status, "DisplayIR", "DisplayIR", null, "Diagnostic", null, faces.Count(face => face.Status == "DiagnosticOnly"), displayDiagnostics.Count));@@ -513,6 +531,77 @@ public static class KernelEndpoints}}+ private static DisplayWirePatchDto? TryBuildWirePatch(Aetheris.Kernel.Core.Brep.BrepBody body, FaceId faceId)+ {+ var loops = new List<DisplayLoopDto>();+ var loopIds = body.GetLoopIds(faceId);+ for (var loopIndex = 0; loopIndex < loopIds.Count; loopIndex++)+ {+ var loopId = loopIds[loopIndex];+ var edges = new List<DisplayEdgeDto>();+ foreach (var coedgeId in body.GetCoedgeIds(loopId))+ {+ if (!body.Topology.TryGetCoedge(coedgeId, out var coedge) || coedge is null)+ {+ continue;+ }++ edges.Add(BuildWireEdge(body, coedge.EdgeId));+ }++ if (edges.Count > 0)+ {+ loops.Add(new DisplayLoopDto(loopId.Value, loopIndex == 0 ? "Outer" : "Inner", edges));+ }+ }++ return loops.Count == 0 ? null : new DisplayWirePatchDto("WirePatch", "BRepEdges", "PreviewPolyline", loops);+ }++ private static DisplayEdgeDto BuildWireEdge(Aetheris.Kernel.Core.Brep.BrepBody body, EdgeId edgeId)+ {+ var points = new List<Point3Dto>();+ var diagnostics = new List<DisplayDiagnosticDto>();+ var sourceCurveKind = "Unknown";+ if (body.TryGetEdgeCurve(edgeId, out var curve) && curve is not null && body.Bindings.TryGetEdgeBinding(edgeId, out var binding))+ {+ sourceCurveKind = curve.Kind.ToString();+ var interval = binding.TrimInterval;+ var start = interval?.Start ?? 0d;+ var end = interval?.End ?? (curve.Kind == CurveGeometryKind.Circle3 ? 2d * double.Pi : 1d);+ if (curve.Kind == CurveGeometryKind.Line3 && curve.Line3 is { } line)+ {+ points.Add(ApiMappings.ToPointDto(line.Evaluate(start)));+ points.Add(ApiMappings.ToPointDto(line.Evaluate(end)));+ }+ else if (curve.Kind == CurveGeometryKind.Circle3 && curve.Circle3 is { } circle)+ {+ var samples = Math.Clamp((int)Math.Ceiling(Math.Abs(end - start) / (Math.PI / 12d)) + 1, 3, 33);+ for (var i = 0; i < samples; i++)+ {+ var t = start + ((end - start) * i / (samples - 1));+ points.Add(ApiMappings.ToPointDto(circle.Evaluate(t)));+ }+ }+ else+ {+ diagnostics.Add(new DisplayDiagnosticDto("Viewer.Wireframe.UnsupportedCurve", $"Wireframe preview does not sample edge curve kind '{curve.Kind}'.", null, null, "BRepEdgeWireLowering", "Keep face diagnostic visible; harden edge polyline sampler in a later milestone."));+ }+ }+ else+ {+ diagnostics.Add(new DisplayDiagnosticDto("Viewer.Wireframe.UnsupportedCurve", "Wireframe preview could not resolve an edge curve binding.", null, null, "BRepEdgeWireLowering", "Keep face diagnostic visible; inspect BRep edge bindings."));+ }++ if (points.Count == 0 && body.TryGetEdgeVertices(edgeId, out var startVertex, out var endVertex))+ {+ if (body.TryGetVertexPoint(startVertex, out var startPoint)) points.Add(ApiMappings.ToPointDto(startPoint));+ if (body.TryGetVertexPoint(endVertex, out var endPoint)) points.Add(ApiMappings.ToPointDto(endPoint));+ }++ return new DisplayEdgeDto(edgeId.Value, points, sourceCurveKind, points.Count, diagnostics);+ }+private static string ResolveDisplayLane(AnalyticDisplayPacket packet){if (packet.AnalyticFaces.Count > 0 && packet.FallbackFaces.Count == 0)diff --git a/Aetheris.Server/Contracts/ApiContracts.cs b/Aetheris.Server/Contracts/ApiContracts.csindex de6e907f..c3147845 100644--- a/Aetheris.Server/Contracts/ApiContracts.cs+++ b/Aetheris.Server/Contracts/ApiContracts.cs@@ -165,9 +165,28 @@ public sealed record DisplayFaceDto(string PatchKind,FacePatchDto? MeshPatch,AnalyticDisplayFaceDto? AnalyticPatch,+ DisplayWirePatchDto? WirePatch,string? MaterializationLane,IReadOnlyList<DisplayDiagnosticDto> Diagnostics);+public sealed record DisplayWirePatchDto(+ string Kind,+ string Source,+ string Quality,+ IReadOnlyList<DisplayLoopDto> Loops);++public sealed record DisplayLoopDto(+ int LoopId,+ string Role,+ IReadOnlyList<DisplayEdgeDto> Edges);++public sealed record DisplayEdgeDto(+ int EdgeId,+ IReadOnlyList<Point3Dto> Points,+ string SourceCurveKind,+ int SampleCount,+ IReadOnlyList<DisplayDiagnosticDto> Diagnostics);+public sealed record DisplayLaneDto(string Kind,string Status,diff --git a/aetheris.client/src/App.tsx b/aetheris.client/src/App.tsxindex a8d9001b..0741ae1d 100644--- a/aetheris.client/src/App.tsx+++ b/aetheris.client/src/App.tsx@@ -683,10 +683,12 @@ function App() {<p><strong>Occurrence ID:</strong> {activeBodyId ?? 'None'}</p><p><strong>Display lane:</strong> {displayPreparation?.lane ?? 'None'}</p><p><strong>Display status:</strong> {displayPreparation?.status ?? 'None'}</p>- {displayPreparation?.status === 'Partial' ? <p role="status">Import succeeded. Display partial: bounded mesh materialization failed for {displayPreparation.faces?.filter((face) => face.materializationLane === 'BoundedMesh' && face.status === 'DiagnosticOnly').length ?? 'some'} face(s).</p> : null}+ {displayPreparation?.status === 'Partial' ? <p role="status">Import succeeded. Display partial: display degraded: {displayPreparation.faces?.filter((face) => face.status === 'WireframeOnly').length ?? 0} wire-only face(s), {displayPreparation.faces?.filter((face) => face.status === 'DiagnosticOnly').length ?? 0} diagnostic-only face(s).</p> : null}<p><strong>Render path:</strong> {displayScene.renderPath}</p><p><strong>Analytic faces:</strong> {displayPreparation?.analyticPacket.analyticFaces.length ?? 0}</p><p><strong>Fallback faces:</strong> {displayPreparation?.analyticPacket.fallbackFaces.length ?? 0}</p>+ <p><strong>Wire-only faces:</strong> {displayPreparation?.faces?.filter((face) => face.status === 'WireframeOnly').length ?? 0}</p>+ <p><strong>Diagnostic-only faces:</strong> {displayPreparation?.faces?.filter((face) => face.status === 'DiagnosticOnly').length ?? 0}</p><p><strong>Face count:</strong> {tessellation?.facePatches.length ?? 0}</p><p><strong>Edge count:</strong> {tessellation?.edgePolylines.length ?? 0}</p><p><strong>Shell count:</strong> {activeBodyId ? 1 : 0}</p>@@ -793,6 +795,8 @@ function App() {<p><strong>Render path:</strong> {displayScene.renderPath}</p><p><strong>Analytic faces:</strong> {displayPreparation?.analyticPacket.analyticFaces.length ?? 0}</p><p><strong>Fallback faces:</strong> {displayPreparation?.analyticPacket.fallbackFaces.length ?? 0}</p>+ <p><strong>Wire-only faces:</strong> {displayPreparation?.faces?.filter((face) => face.status === 'WireframeOnly').length ?? 0}</p>+ <p><strong>Diagnostic-only faces:</strong> {displayPreparation?.faces?.filter((face) => face.status === 'DiagnosticOnly').length ?? 0}</p><p><strong>Face patches:</strong> {tessellation?.facePatches.length ?? 0}</p><p><strong>Edge polylines:</strong> {tessellation?.edgePolylines.length ?? 0}</p><h3 className="section-title section-title--sub">Pick Diagnostics (active body only)</h3>diff --git a/aetheris.client/src/__tests__/App.test.tsx b/aetheris.client/src/__tests__/App.test.tsxindex 172d78d8..de1b4a30 100644--- a/aetheris.client/src/__tests__/App.test.tsx+++ b/aetheris.client/src/__tests__/App.test.tsx@@ -282,6 +282,40 @@ describe('App STEP file upload flow', () => {});+ it('reports wireframe-only display fallback separately from import success', async () => {+ apiMocks.importStep.mockResolvedValue({ documentId: 'doc-1', definitionId: 'def-2', occurrenceId: 'occ-2', name: 'Imported', diagnostics: [] });+ apiMocks.exportDefinitionStep.mockResolvedValue({ documentId: 'doc-1', definitionId: 'def-2', stepText: 'ISO-10303-21;', canonicalHash: 'hash-123', diagnostics: [] });+ apiMocks.prepareBodyDisplay.mockResolvedValue({+ lane: 'fallback-only',+ analyticPacket: { bodyId: 1, analyticFaces: [], fallbackFaces: [{ faceId: 9, shellId: 1, shellRole: 'Outer', reason: 'UnsupportedTrim', surfaceKind: 'Plane', detail: null }] },+ tessellationFallback: { facePatches: [], edgePolylines: [] },+ status: 'Partial',+ sourceAuthority: 'BRep',+ displayAuthority: 'DisplayIR',+ lanes: ['BoundedMesh', 'WirePatch'],+ displayLanes: [{ kind: 'WirePatch', status: 'Partial', source: 'BRep', displayAuthority: 'DisplayIR', implementation: 'BRepEdgeWireLowering', quality: 'PreviewPolyline', timeoutMs: null, faceCount: 1, diagnosticCount: 1 }],+ faces: [{+ faceId: 9, shellId: 1, surfaceKind: 'Plane', status: 'WireframeOnly', patchKind: 'WirePatch', meshPatch: null, analyticPatch: null,+ wirePatch: { kind: 'WirePatch', source: 'BRepEdges', quality: 'PreviewPolyline', loops: [{ loopId: 12, role: 'Outer', edges: [{ edgeId: 44, points: [{ x: 0, y: 0, z: 0 }, { x: 1, y: 0, z: 0 }], sourceCurveKind: 'Line3', sampleCount: 2, diagnostics: [] }] }] },+ materializationLane: 'WirePatch',+ diagnostics: [{ code: 'Viewer.Display.WireframeOnly', message: 'wire', faceId: 9, surfaceKind: 'Plane', phase: 'BRepEdgeWireLowering', suggestedNextAction: null }],+ }],+ diagnostics: [],+ });++ render(<App />);+ await screen.findByText('Document: Ready');+ const fileInput = screen.getByTestId('step-import-file-input') as HTMLInputElement;+ fireEvent.change(fileInput, { target: { files: [new File(['ISO-10303-21;DATA;'], 'part.stp', { type: 'text/plain' })] } });+ await screen.findByText('part.stp');+ fireEvent.click(screen.getByRole('button', { name: 'Import STEP 242' }));++ await screen.findByText('Import succeeded. Display partial: display degraded: 1 wire-only face(s), 0 diagnostic-only face(s).');+ await screen.findByText('Wire-only faces:');+ await screen.findByText('Diagnostic-only faces:');+ });++it('reports bounded mesh partial display separately from import success', async () => {apiMocks.importStep.mockResolvedValue({documentId: 'doc-1',@@ -314,6 +348,7 @@ describe('App STEP file upload flow', () => {patchKind: 'DiagnosticPatch',meshPatch: null,analyticPatch: null,+ wirePatch: null,materializationLane: 'BoundedMesh',diagnostics: [{ code: 'Viewer.Tessellation.Timeout', message: 'timeout', faceId: 9, surfaceKind: 'Plane', phase: 'PlanarTriangulationWithHoles', suggestedNextAction: null }],}],@@ -332,7 +367,7 @@ describe('App STEP file upload flow', () => {await waitFor(() => {expect(apiMocks.prepareBodyDisplay).toHaveBeenCalledWith('doc-1', 'occ-2');});- await screen.findByText('Import succeeded. Display partial: bounded mesh materialization failed for 1 face(s).');+ await screen.findByText('Import succeeded. Display partial: display degraded: 0 wire-only face(s), 1 diagnostic-only face(s).');await screen.findByText('hash-123');});diff --git a/aetheris.client/src/api/aetherisApi.ts b/aetheris.client/src/api/aetherisApi.tsindex 11570a61..acb21ecc 100644--- a/aetheris.client/src/api/aetherisApi.ts+++ b/aetheris.client/src/api/aetherisApi.ts@@ -188,6 +188,27 @@ export interface DisplayDiagnosticDto {suggestedNextAction: string | null;}+export interface DisplayWirePatchDto {+ kind: 'WirePatch' | string;+ source: 'BRepEdges' | string;+ quality: 'PreviewPolyline' | string;+ loops: DisplayLoopDto[];+}++export interface DisplayLoopDto {+ loopId: number;+ role: 'Outer' | 'Inner' | 'Unknown' | string;+ edges: DisplayEdgeDto[];+}++export interface DisplayEdgeDto {+ edgeId: number;+ points: Point3Dto[];+ sourceCurveKind: string;+ sampleCount: number;+ diagnostics: DisplayDiagnosticDto[];+}+export interface DisplayFaceDto {faceId: number;shellId: number | null;@@ -196,6 +217,7 @@ export interface DisplayFaceDto {patchKind: 'AnalyticPatch' | 'MeshPatch' | 'WirePatch' | 'ProxyPatch' | 'DiagnosticPatch' | string;meshPatch: FacePatchDto | null;analyticPatch: AnalyticDisplayFaceDto | null;+ wirePatch: DisplayWirePatchDto | null;materializationLane?: 'AnalyticPatch' | 'BoundedMesh' | 'DiagnosticOnly' | 'WirePatch' | 'ProxyPatch' | string | null;diagnostics: DisplayDiagnosticDto[];}diff --git a/docs/display-architecture-x3-planar-with-holes-materialization.md b/docs/display-architecture-x3-planar-with-holes-materialization.mdindex 7a625062..a8d2501e 100644--- a/docs/display-architecture-x3-planar-with-holes-materialization.md+++ b/docs/display-architecture-x3-planar-with-holes-materialization.md@@ -53,3 +53,7 @@ X3 did not change STEP import/export semantics, AP242 importer/exporter behavior## Next milestone recommendationDISPLAY-ARCH-X4 should add a wireframe/edge-first fallback for planar materialization failures so diagnostic-only faces can still expose their loop geometry without pretending that a filled mesh succeeded.++## Follow-up: DISPLAY-ARCH-X4 wireframe fallback++DISPLAY-ARCH-X4 builds on X3 by allowing a face whose fill materialization still fails to degrade to `WireframeOnly` when BRep boundary loops/edges are available. This keeps X3 planar diagnostics intact while making partial display more visually useful. See `docs/display-architecture-x4-wireframe-fallback.md`.diff --git a/docs/display-architecture-x4-wireframe-fallback.md b/docs/display-architecture-x4-wireframe-fallback.mdnew file mode 100644index 00000000..d1720b01--- /dev/null+++ b/docs/display-architecture-x4-wireframe-fallback.md@@ -0,0 +1,106 @@+# DISPLAY-ARCH-X4 — Wireframe fallback for unsupported faces++## 1. Purpose and scope++DISPLAY-ARCH-X4 makes DisplayIR degradation more useful when a BRep face cannot be filled by analytic or bounded mesh materialization. A failed fill can now degrade to a `WireframeOnly` face with a `WirePatch` sourced from existing BRep loops/coedges/edges, so the viewer receives visible diagnostic boundary geometry instead of only a diagnostic record.++The scope is intentionally limited to the BRep display/view path, DisplayIR response shape, server-side edge polyline extraction, and minimal frontend acceptance/status reporting.++## 2. Relationship to A0/X1/X2/X3++- A0 identified that BRep owns geometric/topological source authority while DisplayIR owns display authority.+- X1 introduced partial DisplayIR response semantics and per-face display records.+- X2 made legacy tessellation explicit as the bounded `BoundedMesh` lane rather than hidden fallback authority.+- X3 improved planar loop classification and planar-with-holes behavior, especially FTC-07 boundedness.+- X4 adds the next display degradation step after failed fill: `WireframeOnly`/`WirePatch`.++## 3. Display degradation ladder++The intended per-face display ladder is now:++1. `AnalyticPatch`+2. `BoundedMesh`+3. `WireframeOnly`+4. `DiagnosticOnly`++X4 does not implement a general proxy patch system.++## 4. Wireframe DisplayIR contract++A wire fallback face is emitted as:++- `status = WireframeOnly`;+- `patchKind = WirePatch`;+- `materializationLane = WirePatch`;+- `sourceAuthority = BRep` at the response level;+- `displayAuthority = DisplayIR` at the response and lane levels;+- a `wirePatch` containing preview loops and edge polylines.++The `WirePatch` DTO contains `kind`, `source = BRepEdges`, `quality = PreviewPolyline`, and loop records. Each loop carries a loop id, a best-effort role (`Outer` for first loop, `Inner` for later loops), and edge records. Each edge record carries edge id, sampled points, source curve kind, sample count, and edge-local diagnostics.++## 5. Server wire extraction behavior++Server extraction is bounded and topology-driven:++- iterate face loops;+- iterate loop coedges;+- resolve coedge edge ids;+- sample line curves at trim interval endpoints;+- sample circle curves with a capped preview count;+- fall back to vertex endpoint points when available;+- report unsupported curve kinds as `Viewer.Wireframe.UnsupportedCurve` without blocking the response.++The extraction is a display approximation only; it does not change BRep topology or curve semantics.++## 6. Frontend behavior++The client API type now accepts `wirePatch` on `DisplayFaceDto`. The app inspector distinguishes wire-only and diagnostic-only face counts and reports partial display as a display degradation, not as an import failure.++X4 keeps filled face rendering unchanged. Full Three.js typed rendering cleanup remains a follow-up milestone.++## 7. Diagnostics++X4 adds/stabilizes these display diagnostics:++- `Viewer.Display.WireframeOnly` when a failed fill is represented by boundary wireframe DisplayIR.+- `Viewer.Wireframe.UnsupportedCurve` when an edge curve cannot be sampled by the conservative preview sampler.++Existing fill diagnostics, including `Viewer.Tessellation.Timeout`, `Viewer.PlanarTriangulation.*`, and `Viewer.Display.FaceMaterializationFailed`, remain attached and are not replaced by wireframe diagnostics.++## 8. FTC-07 status after X4++FTC-07 display preparation remains a bounded DisplayIR operation. If a face cannot fill but has BRep boundary edges, the response can surface it as `WireframeOnly`; otherwise it remains diagnostic-only. Import/export success remains separate from display partial status.++## 9. What did not change++X4 does not change:++- STEP import/export semantics;+- AP242 importer/exporter behavior;+- BRep topology;+- tessellator algorithms;+- CIR authority;+- Firmament V2 language/lowering;+- AIR Region route policy;+- Firmasm;+- CAD feature behavior.++## 10. Tests run++Validation for this branch includes solution restore/build, targeted DisplayIR/tessellation tests, server DisplayIR tests, client App tests, FTC-06 regression, and FTC-07 CLI smoke commands. Any local MSBuild file-lock failures should be treated as build hygiene rather than a DisplayIR semantic failure when a serialized rebuild passes.++## 11. Next milestone recommendation++Recommended next milestone:++```text+DISPLAY-ARCH-X5 — Three.js DisplayIR renderer cleanup+```++Goal: make the frontend renderer consume typed DisplayIR records directly (`AnalyticPatch`, `BoundedMesh`, `WireframeOnly`, `DiagnosticOnly`) instead of treating every successful display as mesh scene data.++If wire extraction becomes the bottleneck, use the alternate milestone:++```text+DISPLAY-ARCH-X5 — BRep edge polyline sampler hardening+```