Skip to content

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.cs
index 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 KernelEndpoints
meshByFace.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 KernelEndpoints
patchKind,
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 KernelEndpoints
boundedMeshDiagnostics));
}
+ 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.cs
index 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.tsx
index 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.tsx
index 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.ts
index 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.md
index 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 recommendation
DISPLAY-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.md
new file mode 100644
index 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
+```