Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Introduce DisplayIR partial display response
Yuechen Li154ac874fcf7
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242Ftc07ViewMaterializationRegressionTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242Ftc07ViewMaterializationRegressionTests.csindex de87e582..5b72c295 100644--- a/Aetheris.Kernel.Core.Tests/Step242/Step242Ftc07ViewMaterializationRegressionTests.cs+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242Ftc07ViewMaterializationRegressionTests.cs@@ -48,6 +48,20 @@ public sealed class Step242Ftc07ViewMaterializationRegressionTests|| diagnostic.Message.Contains("FaceTessellation", StringComparison.Ordinal));}++ [Fact]+ public void DisplayPrepare_Ftc07_ReturnsPartialDisplayInsteadOfWholeBodyFailure()+ {+ var body = ImportFixture();++ var partial = BrepDisplayTessellator.TessellateBoundedPartial(body);++ Assert.NotEmpty(partial.FacePatches);+ Assert.NotEmpty(partial.FaceDiagnostics ?? []);+ Assert.Contains(partial.FaceDiagnostics ?? [], diagnostic => diagnostic.Code == "Viewer.Tessellation.Timeout");+ Assert.Contains(partial.FaceDiagnostics ?? [], diagnostic => diagnostic.Phase == "PlanarTriangulationWithHoles" || diagnostic.Phase == "FaceTessellation");+ }+private static global::Aetheris.Kernel.Core.Brep.BrepBody ImportFixture(){var absolutePath = Path.Combine(Step242CorpusManifestRunner.RepoRoot(), RelativePath.Replace('/', Path.DirectorySeparatorChar));diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.csindex 04983009..c4dbf769 100644--- a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs+++ b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs@@ -43,6 +43,88 @@ public static class BrepDisplayTessellatorTimeSpan? executionTimeout = null)=> TessellateCore(body, options, new DisplayTessellationExecutionBudget(executionTimeout ?? TimeSpan.FromSeconds(5)));++ public static DisplayTessellationResult TessellateBoundedPartial(+ BrepBody body,+ DisplayTessellationOptions? options = null,+ TimeSpan? executionTimeout = null)+ {+ var effectiveOptions = options ?? DisplayTessellationOptions.Default;+ var executionBudget = new DisplayTessellationExecutionBudget(executionTimeout ?? TimeSpan.FromSeconds(5));+ var facePatches = new List<DisplayFaceMeshPatch>();+ var faceDiagnostics = new List<DisplayFaceMaterializationDiagnostic>();++ foreach (var face in body.Topology.Faces.OrderBy(f => f.Id.Value))+ {+ var surfaceKind = TryGetSurfaceKind(body, face.Id);+ try+ {+ executionBudget.ThrowIfExpired("FaceDispatch", face.Id, surfaceKind);+ var faceResult = ExecuteWithinOptionalBudget(+ () => TessellateFace(body, face.Id, effectiveOptions, executionBudget),+ executionBudget,+ "FaceTessellation",+ face.Id,+ surfaceKind,+ executionBudget.Remaining + TimeSpan.FromMilliseconds(250));++ if (faceResult.IsSuccess)+ {+ facePatches.Add(faceResult.Value);+ continue;+ }++ foreach (var diagnostic in faceResult.Diagnostics)+ {+ faceDiagnostics.Add(new DisplayFaceMaterializationDiagnostic(+ face.Id,+ surfaceKind?.ToString(),+ ExtractPhase(diagnostic.Message),+ diagnostic.Source ?? diagnostic.Code.ToString(),+ diagnostic.Message));+ }+ }+ catch (DisplayTessellationTimeoutException ex)+ {+ faceDiagnostics.Add(new DisplayFaceMaterializationDiagnostic(+ ex.FaceId ?? face.Id,+ ex.SurfaceKind?.ToString() ?? surfaceKind?.ToString(),+ ex.Phase,+ "Viewer.Tessellation.Timeout",+ ex.Message));+ }+ }++ var edgePolylines = new List<DisplayEdgePolyline>();+ foreach (var edge in body.Topology.Edges.OrderBy(e => e.Id.Value))+ {+ try+ {+ var edgeResult = TessellateEdge(body, edge.Id, effectiveOptions);+ if (edgeResult.IsSuccess)+ {+ edgePolylines.Add(edgeResult.Value);+ }+ }+ catch (DisplayTessellationTimeoutException)+ {+ break;+ }+ }++ return new DisplayTessellationResult(facePatches, edgePolylines, faceDiagnostics);+ }++ private static string ExtractPhase(string message)+ {+ const string marker = "during phase '";+ var start = message.IndexOf(marker, StringComparison.Ordinal);+ if (start < 0) return "FaceTessellation";+ start += marker.Length;+ var end = message.IndexOf('\'', start);+ return end > start ? message[start..end] : "FaceTessellation";+ }+private static KernelResult<DisplayTessellationResult> TessellateCore(BrepBody body,DisplayTessellationOptions? options,@@ -262,7 +344,7 @@ public static class BrepDisplayTessellatorreturn KernelResult<DisplayFaceMeshPatch>.Failure(triangulationResult.Diagnostics);}- return KernelResult<DisplayFaceMeshPatch>.Success(CreateEmptyPlanarPatch(faceId), triangulationResult.Diagnostics);+ return KernelResult<DisplayFaceMeshPatch>.Success(CreateEmptyPlanarPatch(faceId), triangulationResult.Diagnostics.Where(diagnostic => diagnostic.Severity != KernelDiagnosticSeverity.Error));}return KernelResult<DisplayFaceMeshPatch>.Success(CreatePlanarPatch(faceId, triangulationResult.Value.Points, plane.Normal.ToVector(), triangulationResult.Value.Indices));diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/DisplayTessellationResult.cs b/Aetheris.Kernel.Core/Brep/Tessellation/DisplayTessellationResult.csindex 76e5dcf7..f3fbda90 100644--- a/Aetheris.Kernel.Core/Brep/Tessellation/DisplayTessellationResult.cs+++ b/Aetheris.Kernel.Core/Brep/Tessellation/DisplayTessellationResult.cs@@ -5,7 +5,8 @@ namespace Aetheris.Kernel.Core.Brep.Tessellation;public sealed record DisplayTessellationResult(IReadOnlyList<DisplayFaceMeshPatch> FacePatches,- IReadOnlyList<DisplayEdgePolyline> EdgePolylines);+ IReadOnlyList<DisplayEdgePolyline> EdgePolylines,+ IReadOnlyList<DisplayFaceMaterializationDiagnostic>? FaceDiagnostics = null);public enum DisplayFaceMeshSource{@@ -25,3 +26,10 @@ public sealed record DisplayEdgePolyline(EdgeId EdgeId,IReadOnlyList<Point3D> Points,bool IsClosed);++public sealed record DisplayFaceMaterializationDiagnostic(+ FaceId? FaceId,+ string? SurfaceKind,+ string Phase,+ string Code,+ string Message);diff --git a/Aetheris.Server.Tests/KernelApiIntegrationTests.cs b/Aetheris.Server.Tests/KernelApiIntegrationTests.csindex 93df6bdf..d96e08e0 100644--- a/Aetheris.Server.Tests/KernelApiIntegrationTests.cs+++ b/Aetheris.Server.Tests/KernelApiIntegrationTests.cs@@ -259,15 +259,16 @@ public sealed class KernelApiIntegrationTests : IClassFixture<WebApplicationFactnew DisplayPrepareRequestDto(null),cts.Token);- Assert.Equal(HttpStatusCode.UnprocessableEntity, prepareResponse.StatusCode);- var payload = await prepareResponse.Content.ReadFromJsonAsync<ApiResponseDto<object>>(cts.Token);+ prepareResponse.EnsureSuccessStatusCode();+ var payload = await prepareResponse.Content.ReadFromJsonAsync<ApiResponseDto<DisplayPreparationResponseDto>>(cts.Token);Assert.NotNull(payload);- Assert.False(payload!.Success);- Assert.Contains(payload.Diagnostics, diagnostic => diagnostic.Source == "Viewer.Tessellation.Timeout");- Assert.Contains(payload.Diagnostics, diagnostic => diagnostic.Message.Contains("face", StringComparison.OrdinalIgnoreCase));- Assert.Contains(payload.Diagnostics, diagnostic =>- diagnostic.Message.Contains("PlanarTriangulationWithHoles", StringComparison.Ordinal)- || diagnostic.Message.Contains("FaceTessellation", StringComparison.Ordinal));+ Assert.True(payload!.Success);+ 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");+ Assert.Contains(payload.Data.Diagnostics ?? [], diagnostic => diagnostic.Code == "Viewer.Tessellation.Timeout");+ Assert.Contains(payload.Data.Diagnostics ?? [], diagnostic => diagnostic.Phase == "PlanarTriangulationWithHoles" || diagnostic.Phase == "FaceTessellation");}[Fact]diff --git a/Aetheris.Server/Api/KernelEndpoints.cs b/Aetheris.Server/Api/KernelEndpoints.csindex 7e03b889..4d3af4df 100644--- a/Aetheris.Server/Api/KernelEndpoints.cs+++ b/Aetheris.Server/Api/KernelEndpoints.cs@@ -297,26 +297,79 @@ public static class KernelEndpointsWithDocumentOccurrence(store, documentId, bodyId, (document, body) =>{var analyticPacket = AnalyticDisplayPacketBuilder.Build(body);+ var analyticDto = ApiMappings.ToAnalyticDisplayPacketResponse(analyticPacket);var lane = ResolveDisplayLane(analyticPacket);TessellationResponseDto? tessellationFallback = null;+ var displayDiagnostics = new List<DisplayDiagnosticDto>();if (lane is not "analytic-only"){- var tessellateKernel = DisplayPreparationFallbackBuilder.Build(body, ApiMappings.BuildTessellationOptions(request?.TessellationOptions));- if (!tessellateKernel.IsSuccess)- {- return ApiMappings.KernelFailure(tessellateKernel.Diagnostics);- }+ var options = ApiMappings.BuildTessellationOptions(request?.TessellationOptions);+ var completeFallback = DisplayPreparationFallbackBuilder.Build(body, options);+ var fallbackResult = completeFallback.IsSuccess+ ? completeFallback.Value+ : BrepDisplayTessellator.TessellateBoundedPartial(body, options);tessellationFallback = document.TryGetBodyTransform(bodyId, out var fallbackTransform)- ? ApiMappings.ToTessellationResponse(tessellateKernel.Value, fallbackTransform)- : ApiMappings.ToTessellationResponse(tessellateKernel.Value);+ ? ApiMappings.ToTessellationResponse(fallbackResult, fallbackTransform)+ : ApiMappings.ToTessellationResponse(fallbackResult);++ if (!completeFallback.IsSuccess && fallbackResult.FaceDiagnostics is { Count: > 0 })+ {+ displayDiagnostics.AddRange(fallbackResult.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.")));+ }}+ var meshByFace = tessellationFallback?.FacePatches.ToDictionary(patch => patch.FaceId) ?? [];+ var analyticByFace = analyticDto.AnalyticFaces.ToDictionary(face => face.FaceId);+ var fallbackByFace = analyticDto.FallbackFaces.ToDictionary(face => face.FaceId);+ var diagnosticsByFace = displayDiagnostics+ .Where(diagnostic => diagnostic.FaceId.HasValue)+ .GroupBy(diagnostic => diagnostic.FaceId!.Value)+ .ToDictionary(group => group.Key, group => (IReadOnlyList<DisplayDiagnosticDto>)group.ToArray());+ var faces = body.Topology.Faces.OrderBy(face => face.Id.Value).Select(face =>+ {+ analyticByFace.TryGetValue(face.Id.Value, out var analyticFace);+ 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";+ return new DisplayFaceDto(+ face.Id.Value,+ analyticFace?.ShellId ?? fallbackFace?.ShellId,+ analyticFace?.SurfaceKind ?? fallbackFace?.SurfaceKind,+ status,+ patchKind,+ meshPatch,+ analyticFace,+ faceDiagnostics ?? []);+ }).ToArray();++ var status = faces.All(face => face.Status is "DiagnosticOnly" or "Omitted") ? "DiagnosticOnly" :+ faces.Any(face => face.Status is "DiagnosticOnly" or "Omitted") ? "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));+ }++ var lanes = faces.Select(face => face.PatchKind).Distinct().ToArray();return ApiMappings.Ok(new DisplayPreparationResponseDto(lane,- ApiMappings.ToAnalyticDisplayPacketResponse(analyticPacket),- tessellationFallback));+ analyticDto,+ tessellationFallback,+ status,+ "BRep",+ "DisplayIR",+ lanes,+ faces,+ displayDiagnostics));}));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 b6a1409b..3da4b713 100644--- a/Aetheris.Server/Contracts/ApiContracts.cs+++ b/Aetheris.Server/Contracts/ApiContracts.cs@@ -148,7 +148,31 @@ public sealed record AnalyticDisplayPacketDto(public sealed record DisplayPreparationResponseDto(string Lane,AnalyticDisplayPacketDto AnalyticPacket,- TessellationResponseDto? TessellationFallback);+ TessellationResponseDto? TessellationFallback,+ string Status = "Complete",+ string SourceAuthority = "BRep",+ string DisplayAuthority = "DisplayIR",+ IReadOnlyList<string>? Lanes = null,+ IReadOnlyList<DisplayFaceDto>? Faces = null,+ IReadOnlyList<DisplayDiagnosticDto>? Diagnostics = null);++public sealed record DisplayFaceDto(+ int FaceId,+ int? ShellId,+ string? SurfaceKind,+ string Status,+ string PatchKind,+ FacePatchDto? MeshPatch,+ AnalyticDisplayFaceDto? AnalyticPatch,+ IReadOnlyList<DisplayDiagnosticDto> Diagnostics);++public sealed record DisplayDiagnosticDto(+ string Code,+ string Message,+ int? FaceId,+ string? SurfaceKind,+ string? Phase,+ string? SuggestedNextAction);public sealed record PickOptionsDto(bool? NearestOnly, bool? IncludeBackfaces, double? EdgeTolerance, double? SortTieTolerance, double? MaxDistance);diff --git a/aetheris.client/src/App.tsx b/aetheris.client/src/App.tsxindex 30757b00..87bd4f90 100644--- a/aetheris.client/src/App.tsx+++ b/aetheris.client/src/App.tsx@@ -682,6 +682,8 @@ function App() {<p><strong>Definition ID:</strong> {activeOccurrence?.definitionId ?? 'None'}</p><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}<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>@@ -787,6 +789,7 @@ function App() {<p><strong>Active occurrence ID:</strong> {activeBodyId ?? 'None'}</p><p><strong>Occurrence count:</strong> {bodyIds.length}</p><p><strong>Display lane:</strong> {displayPreparation?.lane ?? 'None'}</p>+ <p><strong>Display status:</strong> {displayPreparation?.status ?? 'None'}</p><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/api/aetherisApi.ts b/aetheris.client/src/api/aetherisApi.tsindex fe355cda..e30a63cd 100644--- a/aetheris.client/src/api/aetherisApi.ts+++ b/aetheris.client/src/api/aetherisApi.ts@@ -179,10 +179,36 @@ export interface AnalyticDisplayPacketDto {fallbackFaces: AnalyticDisplayFallbackFaceDto[];}+export interface DisplayDiagnosticDto {+ code: string;+ message: string;+ faceId: number | null;+ surfaceKind: string | null;+ phase: string | null;+ suggestedNextAction: string | null;+}++export interface DisplayFaceDto {+ faceId: number;+ shellId: number | null;+ surfaceKind: string | null;+ status: 'Analytic' | 'Mesh' | 'WireframeOnly' | 'BoundingProxy' | 'DiagnosticOnly' | 'Omitted' | string;+ patchKind: 'AnalyticPatch' | 'MeshPatch' | 'WirePatch' | 'ProxyPatch' | 'DiagnosticPatch' | string;+ meshPatch: FacePatchDto | null;+ analyticPatch: AnalyticDisplayFaceDto | null;+ diagnostics: DisplayDiagnosticDto[];+}+export interface DisplayPreparationResponseDto {lane: 'analytic-only' | 'mixed-fallback' | 'fallback-only' | string;analyticPacket: AnalyticDisplayPacketDto;tessellationFallback: TessellationResponseDto | null;+ status?: 'Complete' | 'Partial' | 'DiagnosticOnly' | 'Failed' | string;+ sourceAuthority?: string;+ displayAuthority?: string;+ lanes?: string[] | null;+ faces?: DisplayFaceDto[] | null;+ diagnostics?: DisplayDiagnosticDto[] | null;}export interface PickOptionsDto {diff --git a/docs/display-architecture-a0-materialization-audit.md b/docs/display-architecture-a0-materialization-audit.mdindex c0e80959..8927bb1e 100644--- a/docs/display-architecture-a0-materialization-audit.md+++ b/docs/display-architecture-a0-materialization-audit.md@@ -537,3 +537,7 @@ This audit does not and should not:## Validation notesThis milestone is documentation-only. No production CAD/kernel behavior was changed. Playwright was not used; code inspection, existing tests, and CLI/server validation were sufficient to map the current display path.++## 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`.diff --git a/docs/display-architecture-x1-displayir-partial-display.md b/docs/display-architecture-x1-displayir-partial-display.mdnew file mode 100644index 00000000..7e4db4e1--- /dev/null+++ b/docs/display-architecture-x1-displayir-partial-display.md@@ -0,0 +1,102 @@+# DISPLAY-ARCH-X1 — DisplayIR partial display contract++## Purpose and scope++DISPLAY-ARCH-X1 introduces an explicit DisplayIR/ViewIR response contract for `display/prepare`. The goal is bounded partial display: a valid imported BRep body can still produce a usable display response when one face cannot be materialized by the bounded mesh lane.++This milestone does not rewrite the tessellator, implement CIR display, or add a new analytic GPU renderer. It wraps the existing analytic packet and mesh tessellation outputs as explicit DisplayIR lanes.++## Relationship to DISPLAY-ARCH-A0++DISPLAY-ARCH-A0 identified ambiguous display authority: BRep is geometry/topology truth, analytic display packets describe some faces, legacy tessellation acted as implicit fallback authority, and Three.js rendered whichever triangles were available.++X1 follows the A0 recommendation by making the server-emitted DisplayIR response the view authority while keeping BRep as source authority.++## Current problem++Before X1, `display/prepare` required fallback tessellation to succeed for mixed/fallback bodies. If one fallback face timed out, the endpoint returned a whole-body failure even though STEP import, BRep construction, and canonical export could be valid.++FTC-07 exposed this: bounded tessellation reported `Viewer.Tessellation.Timeout` for face materialization on a planar face with holes during `PlanarTriangulationWithHoles`, and that diagnostic became an HTTP 422 display preparation failure.++## DisplayIR contract++`DisplayPreparationResponseDto` now carries compatibility fields plus DisplayIR metadata:++- `sourceAuthority`: `BRep`.+- `displayAuthority`: `DisplayIR`.+- `status`: `Complete`, `Partial`, `DiagnosticOnly`, or `Failed`.+- `lanes`: emitted patch kinds such as `AnalyticPatch`, `MeshPatch`, and `DiagnosticPatch`.+- `faces`: per-face DisplayIR records.+- `diagnostics`: body/display-level diagnostics with stable face fields where available.++Each `DisplayFaceDto` records:++- `faceId`, optional `shellId`, and `surfaceKind`.+- `status`: `Analytic`, `Mesh`, `DiagnosticOnly`, or another explicit display status.+- `patchKind`: `AnalyticPatch`, `MeshPatch`, or `DiagnosticPatch` in X1.+- optional `analyticPatch` or `meshPatch` payload.+- per-face diagnostics.++Diagnostics include stable fields for code, message, face id, surface kind, phase, and suggested next action.++## Partial display semantics++`display/prepare` now returns success for a valid body when at least some display lanes materialize. Failed faces are represented explicitly as diagnostic faces instead of silently disappearing or failing the whole body.++If all faces fail, the response is still bounded and explicit (`DiagnosticOnly`) rather than an infinite spinner. X1 does not yet synthesize wireframe/proxy patches for all failed faces; `WireframeOnly` remains future work.++## FTC-07 behavior before/after++Before X1:++- STEP/AP242 import succeeded.+- Canonical export could succeed.+- Server import succeeded.+- `display/prepare` could return HTTP 422 because bounded fallback tessellation timed out on a single face.++After X1:++- Import remains success.+- `display/prepare` returns a DisplayIR response with BRep source authority and DisplayIR display authority.+- Materialized faces remain available.+- Timed-out faces are reported as `DiagnosticOnly` with `Viewer.Tessellation.Timeout`, face id, surface kind, and phase where available.++## API response changes++The legacy fields remain:++- `lane`+- `analyticPacket`+- `tessellationFallback`++New DisplayIR fields are additive:++- `status`+- `sourceAuthority`+- `displayAuthority`+- `lanes`+- `faces`+- `diagnostics`++## Frontend behavior changes++The client DTOs now accept the DisplayIR metadata and diagnostic-only faces. The viewer continues to render existing analytic preview sampling and mesh fallback data, but the UI can report import success separately from partial view materialization.++## What did not change++- BRep remains geometry/topology truth.+- STEP import/export semantics were not changed.+- Tessellator algorithms, including planar-with-holes triangulation, were not rewritten.+- Firmament V2 language/lowering was not changed.+- AIR Region route policy was not changed.+- CIR authority and CIR display were not changed.+- Firmasm and CAD feature behavior were not changed.++## Tests run++- `dotnet restore Aetheris.slnx`+- `dotnet build Aetheris.slnx -f net10.0 --no-restore`++## 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.diff --git a/docs/step-ap242-ftc07-import-hang-house-call.md b/docs/step-ap242-ftc07-import-hang-house-call.mdindex 38a36ab5..7f1f0a5b 100644--- a/docs/step-ap242-ftc07-import-hang-house-call.md+++ b/docs/step-ap242-ftc07-import-hang-house-call.md@@ -183,3 +183,7 @@ Representative direct API result:- no AIR Region route policy changes- no CIR authority changes- no BRep redesign++## DISPLAY-ARCH-X1 follow-up++DISPLAY-ARCH-X1 changes the expected `display/prepare` behavior for this case: FTC-07 import remains successful, and a bounded face materialization timeout is represented in DisplayIR as a diagnostic-only face with `Viewer.Tessellation.Timeout` instead of a whole-body HTTP 422 display preparation failure. The planar-with-holes tessellator itself was not rewritten in X1.