Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add explicit BoundedMesh display lane
Yuechen Lid289e6b48012
diff --git a/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayPreparationFallbackBuilderTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayPreparationFallbackBuilderTests.csindex 475c8433..1182cd20 100644--- a/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayPreparationFallbackBuilderTests.cs+++ b/Aetheris.Kernel.Core.Tests/Brep/Tessellation/DisplayPreparationFallbackBuilderTests.cs@@ -37,7 +37,8 @@ public sealed class DisplayPreparationFallbackBuilderTestsUSegments: 12,VSegments: 12,Acceptance: new BsplineUvGridScaffoldAcceptanceThresholds(- MaxTriangleDensityRatioVsFallback: 0.01d)));+ MaxTriangleDensityRatioVsFallback: 0.01d)),+ executionTimeout: TimeSpan.FromSeconds(30));Assert.True(result.IsSuccess);var patch = Assert.Single(result.Value.FacePatches);diff --git a/Aetheris.Server.Tests/KernelApiIntegrationTests.cs b/Aetheris.Server.Tests/KernelApiIntegrationTests.csindex d96e08e0..ffc0b566 100644--- a/Aetheris.Server.Tests/KernelApiIntegrationTests.cs+++ b/Aetheris.Server.Tests/KernelApiIntegrationTests.cs@@ -266,7 +266,14 @@ public sealed class KernelApiIntegrationTests : IClassFixture<WebApplicationFactAssert.NotNull(payload.Data);Assert.Equal("BRep", payload.Data.SourceAuthority);Assert.Equal("DisplayIR", payload.Data.DisplayAuthority);- Assert.Contains(payload.Data.Faces ?? [], face => face.Status == "DiagnosticOnly");+ var boundedMeshLane = Assert.Single(payload.Data.DisplayLanes ?? [], lane => lane.Kind == "BoundedMesh");+ Assert.Equal("BRep", boundedMeshLane.Source);+ Assert.Equal("DisplayIR", boundedMeshLane.DisplayAuthority);+ Assert.Equal("BrepDisplayTessellator", boundedMeshLane.Implementation);+ Assert.True(boundedMeshLane.TimeoutMs > 0);+ Assert.Contains(payload.Data.Faces ?? [], face => face.Status == "DiagnosticOnly" && face.MaterializationLane == "BoundedMesh");+ Assert.Contains(payload.Data.Faces ?? [], face => face.Status != "DiagnosticOnly" && face.Status != "Omitted");+ Assert.DoesNotContain(payload.Data.DisplayLanes ?? [], lane => lane.DisplayAuthority.Contains("fallback", StringComparison.OrdinalIgnoreCase));Assert.Contains(payload.Data.Diagnostics ?? [], diagnostic => diagnostic.Code == "Viewer.Tessellation.Timeout");Assert.Contains(payload.Data.Diagnostics ?? [], diagnostic => diagnostic.Phase == "PlanarTriangulationWithHoles" || diagnostic.Phase == "FaceTessellation");}@@ -300,6 +307,7 @@ public sealed class KernelApiIntegrationTests : IClassFixture<WebApplicationFactvar displayPrepared = await PrepareDisplayAsync(document.Data.DocumentId, imported!.Data!.OccurrenceId);Assert.NotNull(displayPrepared.Data!.TessellationFallback);+ Assert.Contains(displayPrepared.Data.DisplayLanes ?? [], lane => lane.Kind == "BoundedMesh" && lane.Source == "BRep");var tessellationResponse = await _client.PostAsJsonAsync($"/api/v1/documents/{document.Data.DocumentId}/bodies/{imported.Data.OccurrenceId}/tessellate",diff --git a/Aetheris.Server/Api/KernelEndpoints.cs b/Aetheris.Server/Api/KernelEndpoints.csindex 4d3af4df..036cd543 100644--- a/Aetheris.Server/Api/KernelEndpoints.cs+++ b/Aetheris.Server/Api/KernelEndpoints.cs@@ -300,29 +300,30 @@ public static class KernelEndpointsvar analyticDto = ApiMappings.ToAnalyticDisplayPacketResponse(analyticPacket);var lane = ResolveDisplayLane(analyticPacket);TessellationResponseDto? tessellationFallback = null;+ DisplayTessellationResult? boundedMeshResult = null;var displayDiagnostics = new List<DisplayDiagnosticDto>();if (lane is not "analytic-only"){var options = ApiMappings.BuildTessellationOptions(request?.TessellationOptions);- var completeFallback = DisplayPreparationFallbackBuilder.Build(body, options);- var fallbackResult = completeFallback.IsSuccess- ? completeFallback.Value+ var completeBoundedMesh = DisplayPreparationFallbackBuilder.Build(body, options);+ boundedMeshResult = completeBoundedMesh.IsSuccess+ ? completeBoundedMesh.Value: BrepDisplayTessellator.TessellateBoundedPartial(body, options);tessellationFallback = document.TryGetBodyTransform(bodyId, out var fallbackTransform)- ? ApiMappings.ToTessellationResponse(fallbackResult, fallbackTransform)- : ApiMappings.ToTessellationResponse(fallbackResult);+ ? ApiMappings.ToTessellationResponse(boundedMeshResult, fallbackTransform)+ : ApiMappings.ToTessellationResponse(boundedMeshResult);- if (!completeFallback.IsSuccess && fallbackResult.FaceDiagnostics is { Count: > 0 })+ if (!completeBoundedMesh.IsSuccess && boundedMeshResult.FaceDiagnostics is { Count: > 0 }){- displayDiagnostics.AddRange(fallbackResult.FaceDiagnostics.Select(diagnostic => new DisplayDiagnosticDto(+ displayDiagnostics.AddRange(boundedMeshResult.FaceDiagnostics.Select(diagnostic => new DisplayDiagnosticDto(diagnostic.Code,diagnostic.Message,diagnostic.FaceId?.Value,diagnostic.SurfaceKind,diagnostic.Phase,- "Keep the valid BRep/import result and use diagnostic/proxy display for this face until a bounded display lane supports it.")));+ "Use wire/proxy display or retry with explicit bounded mesh lowering.")));}}@@ -341,6 +342,7 @@ public static class KernelEndpointsdiagnosticsByFace.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";return new DisplayFaceDto(face.Id.Value,analyticFace?.ShellId ?? fallbackFace?.ShellId,@@ -349,6 +351,7 @@ public static class KernelEndpointspatchKind,meshPatch,analyticFace,+ materializationLane,faceDiagnostics ?? []);}).ToArray();@@ -359,7 +362,36 @@ public static class KernelEndpointsdisplayDiagnostics.Insert(0, new DisplayDiagnosticDto("Viewer.Display.Partial", "Display preparation completed with one or more diagnostic-only faces.", null, null, null, null));}- var lanes = faces.Select(face => face.PatchKind).Distinct().ToArray();+ var displayLanes = new List<DisplayLaneDto>();+ var analyticFaceCount = faces.Count(face => face.MaterializationLane == "AnalyticPatch");+ if (analyticFaceCount > 0)+ {+ displayLanes.Add(new DisplayLaneDto("AnalyticPatch", "Complete", "BRep", "DisplayIR", null, "Default", null, analyticFaceCount, 0));+ }++ if (boundedMeshResult is not null)+ {+ var boundedMeshDiagnostics = boundedMeshResult.FaceDiagnostics?.Count ?? 0;+ var boundedMeshFaceCount = faces.Count(face => face.MaterializationLane == "BoundedMesh" && face.Status == "Mesh");+ var boundedMeshStatus = boundedMeshDiagnostics > 0 ? (boundedMeshFaceCount > 0 ? "Partial" : "Failed") : "Complete";+ displayLanes.Add(new DisplayLaneDto(+ "BoundedMesh",+ boundedMeshStatus,+ "BRep",+ "DisplayIR",+ "BrepDisplayTessellator",+ "Default",+ 5000,+ boundedMeshFaceCount,+ boundedMeshDiagnostics));+ }++ 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));+ }++ var lanes = displayLanes.Select(displayLane => displayLane.Kind).ToArray();return ApiMappings.Ok(new DisplayPreparationResponseDto(lane,analyticDto,@@ -369,7 +401,8 @@ public static class KernelEndpoints"DisplayIR",lanes,faces,- displayDiagnostics));+ displayDiagnostics,+ displayLanes));}));documents.MapPost("/{documentId:guid}/bodies/{bodyId:guid}/pick", (Guid documentId, Guid bodyId, PickRequestDto request, KernelDocumentStore store) =>diff --git a/Aetheris.Server/Contracts/ApiContracts.cs b/Aetheris.Server/Contracts/ApiContracts.csindex 3da4b713..de6e907f 100644--- a/Aetheris.Server/Contracts/ApiContracts.cs+++ b/Aetheris.Server/Contracts/ApiContracts.cs@@ -154,7 +154,8 @@ public sealed record DisplayPreparationResponseDto(string DisplayAuthority = "DisplayIR",IReadOnlyList<string>? Lanes = null,IReadOnlyList<DisplayFaceDto>? Faces = null,- IReadOnlyList<DisplayDiagnosticDto>? Diagnostics = null);+ IReadOnlyList<DisplayDiagnosticDto>? Diagnostics = null,+ IReadOnlyList<DisplayLaneDto>? DisplayLanes = null);public sealed record DisplayFaceDto(int FaceId,@@ -164,8 +165,20 @@ public sealed record DisplayFaceDto(string PatchKind,FacePatchDto? MeshPatch,AnalyticDisplayFaceDto? AnalyticPatch,+ string? MaterializationLane,IReadOnlyList<DisplayDiagnosticDto> Diagnostics);+public sealed record DisplayLaneDto(+ string Kind,+ string Status,+ string Source,+ string DisplayAuthority,+ string? Implementation,+ string? Quality,+ int? TimeoutMs,+ int FaceCount,+ int DiagnosticCount);+public sealed record DisplayDiagnosticDto(string Code,string Message,diff --git a/aetheris.client/src/App.tsx b/aetheris.client/src/App.tsxindex 87bd4f90..a8d9001b 100644--- a/aetheris.client/src/App.tsx+++ b/aetheris.client/src/App.tsx@@ -683,7 +683,7 @@ 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; view materialization is partial. Some faces are diagnostic-only.</p> : null}+ {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}<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>diff --git a/aetheris.client/src/__tests__/App.test.tsx b/aetheris.client/src/__tests__/App.test.tsxindex 7b8a297d..172d78d8 100644--- a/aetheris.client/src/__tests__/App.test.tsx+++ b/aetheris.client/src/__tests__/App.test.tsx@@ -281,6 +281,61 @@ describe('App STEP file upload flow', () => {await screen.findByText('hash-123');});++ it('reports bounded mesh partial display 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', 'DiagnosticOnly'],+ displayLanes: [{ kind: 'BoundedMesh', status: 'Partial', source: 'BRep', displayAuthority: 'DisplayIR', implementation: 'BrepDisplayTessellator', quality: 'Default', timeoutMs: 5000, faceCount: 0, diagnosticCount: 1 }],+ faces: [{+ faceId: 9,+ shellId: 1,+ surfaceKind: 'Plane',+ status: 'DiagnosticOnly',+ patchKind: 'DiagnosticPatch',+ meshPatch: null,+ analyticPatch: null,+ materializationLane: 'BoundedMesh',+ diagnostics: [{ code: 'Viewer.Tessellation.Timeout', message: 'timeout', faceId: 9, surfaceKind: 'Plane', phase: 'PlanarTriangulationWithHoles', suggestedNextAction: null }],+ }],+ diagnostics: [],+ });++ render(<App />);+ await screen.findByText('Document: Ready');++ const fileInput = screen.getByTestId('step-import-file-input') as HTMLInputElement;+ const file = new File(['ISO-10303-21;DATA;'], 'part.stp', { type: 'text/plain' });+ fireEvent.change(fileInput, { target: { files: [file] } });+ await screen.findByText('part.stp');+ fireEvent.click(screen.getByRole('button', { name: 'Import STEP 242' }));++ 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('hash-123');+ });+it('downloads backend STEP text with deterministic filename without mutating hash state', async () => {const createObjectUrlSpy = vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:download');const revokeObjectUrlSpy = vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => undefined);diff --git a/aetheris.client/src/api/aetherisApi.ts b/aetheris.client/src/api/aetherisApi.tsindex e30a63cd..11570a61 100644--- a/aetheris.client/src/api/aetherisApi.ts+++ b/aetheris.client/src/api/aetherisApi.ts@@ -196,9 +196,22 @@ export interface DisplayFaceDto {patchKind: 'AnalyticPatch' | 'MeshPatch' | 'WirePatch' | 'ProxyPatch' | 'DiagnosticPatch' | string;meshPatch: FacePatchDto | null;analyticPatch: AnalyticDisplayFaceDto | null;+ materializationLane?: 'AnalyticPatch' | 'BoundedMesh' | 'DiagnosticOnly' | 'WirePatch' | 'ProxyPatch' | string | null;diagnostics: DisplayDiagnosticDto[];}+export interface DisplayLaneDto {+ kind: 'AnalyticPatch' | 'BoundedMesh' | 'DiagnosticOnly' | 'WirePatch' | 'ProxyPatch' | string;+ status: 'Complete' | 'Partial' | 'DiagnosticOnly' | 'Failed' | string;+ source: string;+ displayAuthority: string;+ implementation: string | null;+ quality: string | null;+ timeoutMs: number | null;+ faceCount: number;+ diagnosticCount: number;+}+export interface DisplayPreparationResponseDto {lane: 'analytic-only' | 'mixed-fallback' | 'fallback-only' | string;analyticPacket: AnalyticDisplayPacketDto;@@ -209,6 +222,7 @@ export interface DisplayPreparationResponseDto {lanes?: string[] | null;faces?: DisplayFaceDto[] | null;diagnostics?: DisplayDiagnosticDto[] | null;+ displayLanes?: DisplayLaneDto[] | null;}export interface PickOptionsDto {diff --git a/docs/display-architecture-a0-materialization-audit.md b/docs/display-architecture-a0-materialization-audit.mdindex 8927bb1e..1660b370 100644--- a/docs/display-architecture-a0-materialization-audit.md+++ b/docs/display-architecture-a0-materialization-audit.md@@ -541,3 +541,7 @@ This milestone is documentation-only. No production CAD/kernel behavior was chan## X1 follow-upDISPLAY-ARCH-X1 adds the first DisplayIR partial display contract. `display/prepare` now carries source/display authority metadata and per-face display records so a bounded face materialization timeout can become a diagnostic face rather than a whole-body display preparation failure. See `docs/display-architecture-x1-displayir-partial-display.md`.++## X2 implementation note++DISPLAY-ARCH-X2 landed the explicit `BoundedMesh` DisplayIR lane. Legacy BRep tessellation remains available for display materialization, but new `display/prepare` metadata reports it as a bounded lowering lane with `source = BRep` and `displayAuthority = DisplayIR`, preserving compatibility fields while removing generic fallback-authority semantics from new DisplayIR lane data.diff --git a/docs/display-architecture-x1-displayir-partial-display.md b/docs/display-architecture-x1-displayir-partial-display.mdindex 7e4db4e1..162e38b3 100644--- a/docs/display-architecture-x1-displayir-partial-display.md+++ b/docs/display-architecture-x1-displayir-partial-display.md@@ -100,3 +100,7 @@ The client DTOs now accept the DisplayIR metadata and diagnostic-only faces. The## Next milestone recommendationDISPLAY-ARCH-X2 should quarantine legacy tessellation behind an explicit bounded mesh lowering lane with quality/budget metadata and cleaner per-face cancellation semantics. If X2 absorbs most of that work quickly, DISPLAY-ARCH-X3 should focus on a robust planar face-with-holes display lane using FTC-07 face 9 as the motivating regression.++## X2 follow-up++DISPLAY-ARCH-X2 adds the explicit `BoundedMesh` DisplayIR lane for legacy BRep tessellation. The X1 compatibility fields remain, including `tessellationFallback`, but new lane metadata identifies mesh materialization as a bounded lowering from `BRep` into `DisplayIR` rather than a fallback display authority. See `docs/display-architecture-x2-bounded-mesh-lane.md`.diff --git a/docs/display-architecture-x2-bounded-mesh-lane.md b/docs/display-architecture-x2-bounded-mesh-lane.mdnew file mode 100644index 00000000..eda1c118--- /dev/null+++ b/docs/display-architecture-x2-bounded-mesh-lane.md@@ -0,0 +1,112 @@+# DISPLAY-ARCH-X2 — Explicit BoundedMesh DisplayIR lane++## 1. Purpose and scope++DISPLAY-ARCH-X2 quarantines legacy BRep display tessellation behind an explicit DisplayIR lowering lane named `BoundedMesh`. Tessellation remains available for rendering bounded faces, but it is no longer described by new DisplayIR metadata as implicit fallback authority or as a whole-body success/failure gate.++This milestone is intentionally additive: existing compatibility fields such as `tessellationFallback` remain available for old clients, while the authoritative DisplayIR metadata now exposes lane kind, source, implementation, quality, budget, status, and diagnostics.++## 2. Relationship to DISPLAY-ARCH-A0 and X1++DISPLAY-ARCH-A0 identified the display authority problem: BRep owns geometry/topology truth, DisplayIR should own view materialization, analytic DTOs are one display lane, and tessellation must not become hidden CAD truth.++DISPLAY-ARCH-X1 added partial DisplayIR semantics to `display/prepare`: response status, source/display authority fields, lane summaries, per-face records, stable diagnostics, and FTC-07 partial-display behavior.++X2 builds on X1 by making the mesh-producing path a named lowering lane: `BoundedMesh`.++## 3. Why tessellation is not fallback authority++Tessellation is a view materialization technique. It can approximate displayable face interiors, and it can fail per face because of bounded execution budgets or unsupported trim/surface cases. It does not replace BRep topology, STEP import/export, analytic display records, CIR, or any CAD feature authority.++Therefore `display/prepare` now reports tessellation as `BoundedMesh` with `source = BRep` and `displayAuthority = DisplayIR`. A failed mesh face becomes a diagnostic display face; it does not invalidate the imported body.++## 4. BoundedMesh lane contract++`BoundedMesh` means: lower BRep faces into bounded mesh patches for display only.++The contract is:++- source authority: `BRep`;+- display authority: `DisplayIR`;+- implementation: currently `BrepDisplayTessellator` through the existing display preparation mesh path;+- status: `Complete`, `Partial`, or `Failed` based on per-face materialization;+- success result: face mesh patches remain renderable;+- failure result: face diagnostics remain visible and attached to diagnostic-only face records;+- no single face failure may force whole-body display failure if other faces materialized.++## 5. Lane metadata++`DisplayPreparationResponseDto.lanes` remains the compatibility list of lane names. `DisplayPreparationResponseDto.displayLanes` carries structured lane metadata for the explicit DisplayIR lanes.++For `BoundedMesh`, the metadata includes:++- `kind`: `BoundedMesh`;+- `source`: `BRep`;+- `displayAuthority`: `DisplayIR`;+- `implementation`: `BrepDisplayTessellator`;+- `quality`: currently `Default`;+- `timeoutMs`: the current default bounded execution budget, when reported by the API;+- `faceCount`: successfully materialized mesh face count;+- `diagnosticCount`: lane diagnostics count.++Per-face `DisplayFaceDto.materializationLane` distinguishes `AnalyticPatch`, `BoundedMesh`, and `DiagnosticOnly` records.++## 6. FTC-07 behavior++FTC-07 remains a partial display case. The import succeeds, successful display faces remain present, and the timed-out planar face becomes a diagnostic-only face with:++- `materializationLane = BoundedMesh`;+- diagnostic code `Viewer.Tessellation.Timeout`;+- phase `PlanarTriangulationWithHoles` or the narrower phase reported by the tessellator.++This preserves X1's partial DisplayIR behavior while naming the failed lowering lane explicitly.++## 7. API/DTO changes++Additive DTO changes:++- `DisplayPreparationResponseDto.lanes` includes compatibility lane-name strings such as `AnalyticPatch`, `BoundedMesh`, and `DiagnosticOnly`.+- `DisplayPreparationResponseDto.displayLanes` contains structured `DisplayLaneDto` records.+- `DisplayLaneDto` records lane kind, status, source, display authority, implementation, quality, timeout, face count, and diagnostic count.+- `DisplayFaceDto.materializationLane` records which lane produced or attempted the face materialization.++Compatibility notes:++- `lane` remains the legacy coarse value (`analytic-only`, `mixed-fallback`, `fallback-only`) for old clients.+- `lanes` remains a string list for old clients, with `BoundedMesh` added when mesh lowering is used.+- `tessellationFallback` remains the mesh compatibility payload for old clients.+- New DisplayIR authority fields do not call tessellation the display authority; they keep `displayAuthority = DisplayIR`.++## 8. Frontend behavior++The client DTOs accept structured lane metadata and per-face materialization lanes. The inspector continues rendering existing analytic and mesh paths, but partial-display text now distinguishes import success from bounded mesh materialization failure.++Diagnostic-only faces from `BoundedMesh` are display diagnostics, not import failures.++## 9. What did not change++This milestone did not change:++- tessellation algorithms;+- `PlanarTriangulationWithHoles` behavior;+- STEP import/export semantics;+- BRep topology;+- Firmament V2 language or lowering;+- AIR Region route policy;+- CIR authority;+- Firmasm;+- CAD feature behavior.++## 10. Tests run++Validation for this milestone included solution restore/build, targeted kernel/server DisplayIR and tessellation tests, client App tests, FTC-06 same-sense regression tests, and FTC-07 CLI smoke commands.++## 11. Next milestone recommendation++Recommended next milestone:++`DISPLAY-ARCH-X3 — planar face with holes display lane rewrite using FTC-07 face 9`++If immediate user-facing resilience is preferred first, use:++`DISPLAY-ARCH-X3 — wireframe/edge-first diagnostic fallback for unsupported/timed-out faces`