Skip to content

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.cs
index 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.cs
index 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 BrepDisplayTessellator
TimeSpan? 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 BrepDisplayTessellator
return 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.cs
index 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.cs
index 93df6bdf..d96e08e0 100644
--- a/Aetheris.Server.Tests/KernelApiIntegrationTests.cs
+++ b/Aetheris.Server.Tests/KernelApiIntegrationTests.cs
@@ -259,15 +259,16 @@ public sealed class KernelApiIntegrationTests : IClassFixture<WebApplicationFact
new 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.cs
index 7e03b889..4d3af4df 100644
--- a/Aetheris.Server/Api/KernelEndpoints.cs
+++ b/Aetheris.Server/Api/KernelEndpoints.cs
@@ -297,26 +297,79 @@ public static class KernelEndpoints
WithDocumentOccurrence(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.cs
index 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.tsx
index 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.ts
index 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.md
index 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 notes
This 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.md
new file mode 100644
index 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.md
index 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.