Skip to content

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.cs
index 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 DisplayPreparationFallbackBuilderTests
USegments: 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.cs
index d96e08e0..ffc0b566 100644
--- a/Aetheris.Server.Tests/KernelApiIntegrationTests.cs
+++ b/Aetheris.Server.Tests/KernelApiIntegrationTests.cs
@@ -266,7 +266,14 @@ public sealed class KernelApiIntegrationTests : IClassFixture<WebApplicationFact
Assert.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<WebApplicationFact
var 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.cs
index 4d3af4df..036cd543 100644
--- a/Aetheris.Server/Api/KernelEndpoints.cs
+++ b/Aetheris.Server/Api/KernelEndpoints.cs
@@ -300,29 +300,30 @@ public static class KernelEndpoints
var 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 KernelEndpoints
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";
return new DisplayFaceDto(
face.Id.Value,
analyticFace?.ShellId ?? fallbackFace?.ShellId,
@@ -349,6 +351,7 @@ public static class KernelEndpoints
patchKind,
meshPatch,
analyticFace,
+ materializationLane,
faceDiagnostics ?? []);
}).ToArray();
@@ -359,7 +362,36 @@ public static class KernelEndpoints
displayDiagnostics.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.cs
index 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.tsx
index 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.tsx
index 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.ts
index 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.md
index 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-up
DISPLAY-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.md
index 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 recommendation
DISPLAY-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.md
new file mode 100644
index 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`