Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Refine judgment engine and CLI validation flow
Yuechen Lieb45236f6f4b
diff --cc aetheris.client/src/App.tsxindex 4a84949d,0f7dd484..00b18b7b--- a/aetheris.client/src/App.tsx+++ b/aetheris.client/src/App.tsx@@@ -217,8 -164,7 +214,7 @@@ function App()try {const preparedDisplay = await prepareBodyDisplay(documentId, selected);setDisplayPreparation(preparedDisplay);- setTessellation(preparedDisplay.tessellationFallback);- return null;+ return { preparation: preparedDisplay, error: null };} catch (error) {const apiError = error instanceof ApiError? error@@@ -229,10 -174,9 +224,9 @@@throw apiError;}- return apiError;+ return { preparation: null, error: apiError };}} else {- setTessellation(null);setDisplayPreparation(null);}@@@ -752,10 -688,10 +751,10 @@@<p><strong>Render path:</strong> {displayScene.renderPath}</p><p><strong>Analytic faces:</strong> {displayPreparation?.analyticPacket.analyticFaces.length ?? 0}</p><p><strong>Fallback faces:</strong> {displayPreparation?.analyticPacket.fallbackFaces.length ?? 0}</p>- <p><strong>Wire-only faces:</strong> {displayPreparation?.faces?.filter((face) => face.status === 'WireframeOnly').length ?? 0}</p>- <p><strong>Diagnostic-only faces:</strong> {displayPreparation?.faces?.filter((face) => face.status === 'DiagnosticOnly').length ?? 0}</p>+ <p><strong>Wire-only faces:</strong> {displayStatusSummary?.wireOnlyFaceCount ?? 0}</p>+ <p><strong>Diagnostic-only faces:</strong> {displayStatusSummary?.diagnosticOnlyFaceCount ?? 0}</p>- <p><strong>Face count:</strong> {tessellation?.facePatches.length ?? 0}</p>- <p><strong>Edge count:</strong> {tessellation?.edgePolylines.length ?? 0}</p>+ <p><strong>Face count:</strong> {displayRenderableCounts.meshFaces}</p>+ <p><strong>Edge count:</strong> {displayRenderableCounts.wireEdges || displayScene.displayScene?.legacyCompatibility?.edgePolylineCount || 0}</p><p><strong>Shell count:</strong> {activeBodyId ? 1 : 0}</p></section></>@@@ -860,10 -796,10 +859,10 @@@<p><strong>Render path:</strong> {displayScene.renderPath}</p><p><strong>Analytic faces:</strong> {displayPreparation?.analyticPacket.analyticFaces.length ?? 0}</p><p><strong>Fallback faces:</strong> {displayPreparation?.analyticPacket.fallbackFaces.length ?? 0}</p>- <p><strong>Wire-only faces:</strong> {displayPreparation?.faces?.filter((face) => face.status === 'WireframeOnly').length ?? 0}</p>- <p><strong>Diagnostic-only faces:</strong> {displayPreparation?.faces?.filter((face) => face.status === 'DiagnosticOnly').length ?? 0}</p>+ <p><strong>Wire-only faces:</strong> {displayStatusSummary?.wireOnlyFaceCount ?? 0}</p>+ <p><strong>Diagnostic-only faces:</strong> {displayStatusSummary?.diagnosticOnlyFaceCount ?? 0}</p>- <p><strong>Face patches:</strong> {tessellation?.facePatches.length ?? 0}</p>- <p><strong>Edge polylines:</strong> {tessellation?.edgePolylines.length ?? 0}</p>+ <p><strong>Face patches:</strong> {displayRenderableCounts.meshFaces}</p>+ <p><strong>Edge polylines:</strong> {displayRenderableCounts.wireEdges || displayScene.displayScene?.legacyCompatibility?.edgePolylineCount || 0}</p><h3 className="section-title section-title--sub">Pick Diagnostics (active body only)</h3><p><strong>Pick status:</strong> {pickStatus}</p><p><strong>Pick message:</strong> {pickMessage}</p>diff --cc aetheris.client/src/__tests__/displaySceneBounds.test.tsindex 37eb6810,aac9108b..71095d92--- a/aetheris.client/src/__tests__/displaySceneBounds.test.ts+++ b/aetheris.client/src/__tests__/displaySceneBounds.test.ts@@@ -1,143 -1,20 +1,187 @@@import { describe, expect, it } from 'vitest';-import { computeDisplaySceneBounds } from '../viewer/displaySceneBounds';import type { DisplayScene } from '../viewer/displayRenderables';+import { computeDisplaySceneBounds, computeOrthographicCameraFit } from '../viewer/displaySceneBounds';- import type { RenderSceneData } from '../viewer/tessellationMapper';-const baseScene: Omit<DisplayScene, 'renderables'> = { status: 'Partial', sourceAuthority: 'BRep', displayAuthority: 'DisplayIR', lanes: [], diagnostics: [] };+const baseScene: DisplayScene = {+ renderables: [],+ sourceAuthority: 'BRep',+ displayAuthority: 'DisplayIR',- displayLanes: [],- displayStatus: 'Complete',++ lanes: [],++ diagnostics: [],++ status: 'Complete',+};-describe('computeDisplaySceneBounds', () => {- it('DisplaySceneBounds_StillFitsImportedFtc06Shape', () => {- const scene: DisplayScene = {+describe('displaySceneBounds', () => {+ it('computeDisplaySceneBounds_IncludesMeshRenderableVertices', () => {+ const displayScene: DisplayScene = {+ ...baseScene,+ renderables: [{+ kind: 'MeshPatch',+ faceId: 1,+ surfaceKind: 'Plane',+ status: 'Mesh',+ patchKind: 'MeshPatch',+ materializationLane: 'BoundedMesh',+ diagnostics: [],+ mesh: {+ faceId: 1,+ positions: new Float32Array([10, 20, 30, 40, 50, 60, 15, 25, 35]),+ normals: new Float32Array([0, 0, 1, 0, 0, 1, 0, 0, 1]),+ indices: new Uint32Array([0, 1, 2]),+ },+ }],+ };++ const bounds = computeDisplaySceneBounds(displayScene);++ expect(bounds.isValid).toBe(true);+ expect(bounds.min).toEqual([10, 20, 30]);+ expect(bounds.max).toEqual([40, 50, 60]);+ });++ it('computeDisplaySceneBounds_IncludesAnalyticPreviewVertices', () => {+ const displayScene: DisplayScene = {+ ...baseScene,+ renderables: [{+ kind: 'AnalyticPatch',+ faceId: 2,+ surfaceKind: 'Cylinder',+ status: 'Analytic',+ patchKind: 'AnalyticPatch',+ materializationLane: 'AnalyticPatch',+ diagnostics: [],+ previewMesh: {+ faceId: 2,+ positions: new Float32Array([-5, -2, -1, 7, 3, 11, 1, 0, 2]),+ normals: new Float32Array([0, 1, 0, 0, 1, 0, 0, 1, 0]),+ indices: new Uint32Array([0, 1, 2]),+ },+ }],+ };++ const bounds = computeDisplaySceneBounds(displayScene);++ expect(bounds.min).toEqual([-5, -2, -1]);+ expect(bounds.max).toEqual([7, 3, 11]);+ });++ it('computeDisplaySceneBounds_IncludesWirePatchPoints', () => {+ const displayScene: DisplayScene = {+ ...baseScene,+ renderables: [{+ kind: 'WirePatch',+ faceId: 3,+ surfaceKind: 'Plane',+ status: 'WireframeOnly',+ patchKind: 'WirePatch',+ materializationLane: 'WirePatch',+ diagnostics: [],+ wires: [{ edgeId: 30, points: new Float32Array([-20, 1, 4, 12, 6, 8, 0, -3, 5]) }],+ }],+ };++ const bounds = computeDisplaySceneBounds(displayScene);++ expect(bounds.min).toEqual([-20, -3, 4]);+ expect(bounds.max).toEqual([12, 6, 8]);+ });++ it('computeDisplaySceneBounds_IgnoresDiagnosticOnlyFacesWithoutProxy', () => {+ const displayScene: DisplayScene = {+ ...baseScene,+ renderables: [{+ kind: 'DiagnosticPatch',+ faceId: 4,+ surfaceKind: 'Plane',+ status: 'DiagnosticOnly',+ patchKind: 'DiagnosticPatch',+ materializationLane: 'DiagnosticOnly',+ diagnostics: [{ code: 'Viewer.Tessellation.Timeout', message: 'timeout', faceId: 4, surfaceKind: 'Plane', phase: 'phase', suggestedNextAction: null }],+ }],+ };++ const bounds = computeDisplaySceneBounds(displayScene);++ expect(bounds.isValid).toBe(false);+ });+- it('AetherisViewport_FitsCameraToDisplaySceneBounds', () => {- const sceneData: RenderSceneData = {- faces: [],- edges: [],++ it('computeDisplaySceneBounds_ProducesValidLargeFarFromOriginBounds', () => {++ const displayScene: DisplayScene = {+ ...baseScene,+ renderables: [- { kind: 'MeshPatch', faceId: 1, surfaceKind: 'Plane', status: 'Mesh', patchKind: 'MeshPatch', materializationLane: 'BoundedMesh', diagnostics: [], mesh: { faceId: 1, positions: new Float32Array([10000, -50, 25000, 10120, 60, 25140, 9980, 40, 25080]), normals: new Float32Array(9), indices: new Uint32Array([0, 1, 2]) } },- { kind: 'WirePatch', faceId: 2, surfaceKind: 'Plane', status: 'WireframeOnly', patchKind: 'WirePatch', materializationLane: 'WirePatch', diagnostics: [], wires: [{ edgeId: 2, points: new Float32Array([9975, -55, 24990, 10130, 65, 25150]) }] },- { kind: 'DiagnosticPatch', faceId: 3, surfaceKind: 'Plane', status: 'DiagnosticOnly', patchKind: 'DiagnosticPatch', materializationLane: 'DiagnosticOnly', diagnostics: [] },++ {++ kind: 'MeshPatch',++ faceId: 1,++ surfaceKind: 'Plane',++ status: 'Mesh',++ patchKind: 'MeshPatch',++ materializationLane: 'BoundedMesh',++ diagnostics: [],++ mesh: {++ faceId: 1,++ positions: new Float32Array([10000, -50, 25000, 10120, 60, 25140, 9980, 40, 25080]),++ normals: new Float32Array(9),++ indices: new Uint32Array([0, 1, 2]),++ },++ },++ {++ kind: 'WirePatch',++ faceId: 2,++ surfaceKind: 'Plane',++ status: 'WireframeOnly',++ patchKind: 'WirePatch',++ materializationLane: 'WirePatch',++ diagnostics: [],++ wires: [{ edgeId: 2, points: new Float32Array([9975, -55, 24990, 10130, 65, 25150]) }],++ },++ {++ kind: 'DiagnosticPatch',++ faceId: 3,++ surfaceKind: 'Plane',++ status: 'DiagnosticOnly',++ patchKind: 'DiagnosticPatch',++ materializationLane: 'DiagnosticOnly',++ diagnostics: [],++ },+ ],};+- expect(computeDisplaySceneBounds(scene)).toEqual({ minX: 9975, minY: -55, minZ: 24990, maxX: 10130, maxY: 65, maxZ: 25150 });++ const bounds = computeDisplaySceneBounds(displayScene);++++ expect(bounds.isValid).toBe(true);++ expect(bounds.min).toEqual([9975, -55, 24990]);++ expect(bounds.max).toEqual([10130, 65, 25150]);++ });++++ it('computeOrthographicCameraFit_FitsLargeFarFromOriginSceneBounds', () => {+ const displayScene: DisplayScene = {+ ...baseScene,+ renderables: [{+ kind: 'MeshPatch',+ faceId: 5,+ surfaceKind: 'Plane',+ status: 'Mesh',+ patchKind: 'MeshPatch',+ materializationLane: 'BoundedMesh',+ diagnostics: [],+ mesh: {+ faceId: 5,+ positions: new Float32Array([1000, 1000, 1000, 1100, 1000, 1000, 1000, 1200, 1000]),+ normals: new Float32Array([0, 0, 1, 0, 0, 1, 0, 0, 1]),+ indices: new Uint32Array([0, 1, 2]),+ },+ }],+ };+- const bounds = computeDisplaySceneBounds(displayScene, sceneData);++ const bounds = computeDisplaySceneBounds(displayScene);+ const fit = computeOrthographicCameraFit(bounds, 20, 20);++ expect(fit).not.toBeNull();+ expect(fit?.target).toEqual([1050, 1100, 1000]);+ expect(fit?.position[0]).toBeGreaterThan(1050);+ expect(fit?.position[1]).toBeGreaterThan(1100);+ expect(fit?.position[2]).toBeGreaterThan(1000);+ expect(fit?.zoom).toBeGreaterThan(0);+ expect(fit?.far).toBeGreaterThan(fit?.near ?? 0);});});diff --cc aetheris.client/src/viewer/AetherisViewport.tsxindex 1c763060,aaf627ac..e30a02a4--- a/aetheris.client/src/viewer/AetherisViewport.tsx+++ b/aetheris.client/src/viewer/AetherisViewport.tsx@@@ -5,8 -5,6 +5,7 @@@ import { useEffect, useMemo, useStateimport type { ReactNode } from 'react';import { BufferAttribute, BufferGeometry, Color, DoubleSide, MeshStandardMaterial, OrthographicCamera, Raycaster, Vector2, Vector3 } from 'three';import type { DisplayScene } from './displayRenderables';+import { computeDisplaySceneBounds, computeOrthographicCameraFit } from './displaySceneBounds';- import type { RenderSceneData } from './tessellationMapper';import { selectLogarithmicGridScales } from './logarithmicGrid';const VIEWPORT_THEME = {@@@ -453,7 -451,8 +452,6 @@@ function DraftingGrid()export interface AetherisViewportProps {displayScene?: DisplayScene | null;- sceneData: RenderSceneData | null;- /** Compatibility-only input for callers not yet migrated to DisplayScene. */- sceneData?: null;highlightedFaceId?: number | null;highlightedEdgeId?: number | null;showGrid?: boolean;@@@ -585,44 -584,8 +583,43 @@@ function PickRayCapture({ onPickRay }:return null;}- function FitCameraToScene({ displayScene, sceneData }: { displayScene: DisplayScene | null; sceneData: RenderSceneData | null }) {++function FitCameraToScene({ displayScene }: { displayScene: DisplayScene | null }) {+ const { camera, controls, size } = useThree();- const sceneBounds = useMemo(() => computeDisplaySceneBounds(displayScene, sceneData), [displayScene, sceneData]);++ const sceneBounds = useMemo(() => computeDisplaySceneBounds(displayScene), [displayScene]);++ useEffect(() => {+ if (!(camera instanceof OrthographicCamera) || !sceneBounds.isValid) {+ return;+ }++ const frustumWidth = Math.abs(camera.right - camera.left) || size.width || 1;+ const frustumHeight = Math.abs(camera.top - camera.bottom) || size.height || 1;+ const fit = computeOrthographicCameraFit(sceneBounds, frustumWidth, frustumHeight);++ if (!fit) {+ return;+ }++ camera.position.set(...fit.position);+ camera.zoom = fit.zoom;+ camera.near = fit.near;+ camera.far = fit.far;+ camera.lookAt(...fit.target);+ camera.updateProjectionMatrix();+ camera.updateMatrixWorld(false);++ if (controls && typeof controls === 'object' && 'target' in controls) {+ const orbitControls = controls as { target: Vector3; update?: () => void };+ orbitControls.target.set(...fit.target);+ orbitControls.update?.();+ }+ }, [camera, controls, sceneBounds, size.height, size.width]);++ return null;+}+export function AetherisViewport({displayScene = null,- sceneData,highlightedFaceId = null,highlightedEdgeId = null,showGrid = true,@@@ -636,7 -597,6 +631,7 @@@{/*Negative near value is indeed correct in order to show negative value on grid. Documentation is wrong.*/}<ambientLight intensity={VIEWPORT_THEME.ambientIntensity} /><directionalLight position={[-5, 9, 6]} intensity={VIEWPORT_THEME.directionalIntensity} />- <FitCameraToScene displayScene={displayScene} sceneData={sceneData} />++ <FitCameraToScene displayScene={displayScene} />{showGrid ? <DraftingGrid /> : null}{showAxisGuide ? <AxisGuide /> : null}{displayScene?.renderables.map((renderable) => {diff --cc aetheris.client/src/viewer/displaySceneBounds.tsindex 90dea14f,c24baf90..3b76f990--- a/aetheris.client/src/viewer/displaySceneBounds.ts+++ b/aetheris.client/src/viewer/displaySceneBounds.ts@@@ -1,25 -1,6 +1,24 @@@import type { DisplayScene } from './displayRenderables';- import type { RenderSceneData } from './tessellationMapper';-export interface DisplaySceneBounds {+export interface SceneBounds {+ min: [number, number, number];+ max: [number, number, number];+ center: [number, number, number];+ size: [number, number, number];+ diagonal: number;+ radius: number;+ isValid: boolean;+}++export interface OrthographicCameraFit {+ position: [number, number, number];+ target: [number, number, number];+ zoom: number;+ near: number;+ far: number;+}++interface MutableBounds {minX: number;minY: number;minZ: number;@@@ -77,177 -24,27 +76,154 @@@ function includeTriplets(bounds: Mutabl}}-export function computeDisplaySceneBounds(scene: DisplayScene | null): DisplaySceneBounds | null {- if (!scene) return null;+function finalizeBounds(bounds: MutableBounds): SceneBounds {+ if (bounds.pointCount === 0) {+ return EMPTY_BOUNDS;+ }- const bounds: DisplaySceneBounds = {- minX: Number.POSITIVE_INFINITY,- minY: Number.POSITIVE_INFINITY,- minZ: Number.POSITIVE_INFINITY,- maxX: Number.NEGATIVE_INFINITY,- maxY: Number.NEGATIVE_INFINITY,- maxZ: Number.NEGATIVE_INFINITY,+ const min: [number, number, number] = [bounds.minX, bounds.minY, bounds.minZ];+ const max: [number, number, number] = [bounds.maxX, bounds.maxY, bounds.maxZ];+ const size: [number, number, number] = [+ bounds.maxX - bounds.minX,+ bounds.maxY - bounds.minY,+ bounds.maxZ - bounds.minZ,+ ];+ const center: [number, number, number] = [+ (bounds.minX + bounds.maxX) * 0.5,+ (bounds.minY + bounds.maxY) * 0.5,+ (bounds.minZ + bounds.maxZ) * 0.5,+ ];+ const diagonal = Math.hypot(size[0], size[1], size[2]);++ return {+ min,+ max,+ center,+ size,+ diagonal,+ radius: diagonal > 0 ? diagonal * 0.5 : 0.5,+ isValid: true,};+}+- function computeTypedBounds(displayScene: DisplayScene | null): SceneBounds {++export function computeDisplaySceneBounds(displayScene: DisplayScene | null): SceneBounds {+ if (!displayScene) {+ return EMPTY_BOUNDS;+ }- for (const renderable of scene.renderables) {+ const bounds = createBounds();++ for (const renderable of displayScene.renderables) {if (renderable.kind === 'AnalyticPatch') {- includeArray(bounds, renderable.previewMesh.positions);- } else if (renderable.kind === 'MeshPatch') {- includeArray(bounds, renderable.mesh.positions);- } else if (renderable.kind === 'WirePatch') {- for (const wire of renderable.wires) includeArray(bounds, wire.points);+ includeTriplets(bounds, renderable.previewMesh.positions);+ continue;+ }++ if (renderable.kind === 'MeshPatch') {+ includeTriplets(bounds, renderable.mesh.positions);+ continue;+ }++ if (renderable.kind === 'WirePatch') {+ for (const wire of renderable.wires) {+ includeTriplets(bounds, wire.points);+ }}}- return Number.isFinite(bounds.minX) ? bounds : null;+ return finalizeBounds(bounds);+}+- function computeFallbackBounds(sceneData: RenderSceneData | null): SceneBounds {- if (!sceneData) {- return EMPTY_BOUNDS;- }-- const bounds = createBounds();-- for (const face of sceneData.faces) {- includeTriplets(bounds, face.positions);- }-- for (const edge of sceneData.edges) {- includeTriplets(bounds, edge.points);- }-- return finalizeBounds(bounds);- }-- export function computeDisplaySceneBounds(displayScene: DisplayScene | null, sceneData: RenderSceneData | null = null): SceneBounds {- const typedBounds = computeTypedBounds(displayScene);- return typedBounds.isValid ? typedBounds : computeFallbackBounds(sceneData);- }-+function normalize(vector: Vec3): Vec3 {+ const length = Math.hypot(vector.x, vector.y, vector.z);+ if (length <= 1e-9) {+ return { x: 0, y: 0, z: 1 };+ }++ return {+ x: vector.x / length,+ y: vector.y / length,+ z: vector.z / length,+ };+}++function cross(a: Vec3, b: Vec3): Vec3 {+ return {+ x: (a.y * b.z) - (a.z * b.y),+ y: (a.z * b.x) - (a.x * b.z),+ z: (a.x * b.y) - (a.y * b.x),+ };+}++function dot(a: Vec3, b: Vec3): number {+ return (a.x * b.x) + (a.y * b.y) + (a.z * b.z);+}++function getBoundsCorners(bounds: SceneBounds): Vec3[] {+ const [minX, minY, minZ] = bounds.min;+ const [maxX, maxY, maxZ] = bounds.max;++ return [+ { x: minX, y: minY, z: minZ },+ { x: minX, y: minY, z: maxZ },+ { x: minX, y: maxY, z: minZ },+ { x: minX, y: maxY, z: maxZ },+ { x: maxX, y: minY, z: minZ },+ { x: maxX, y: minY, z: maxZ },+ { x: maxX, y: maxY, z: minZ },+ { x: maxX, y: maxY, z: maxZ },+ ];+}++export function computeOrthographicCameraFit(+ bounds: SceneBounds,+ frustumWidth: number,+ frustumHeight: number,+ viewDirection: [number, number, number] = [1, 1, 1],+): OrthographicCameraFit | null {+ if (!bounds.isValid || frustumWidth <= 0 || frustumHeight <= 0) {+ return null;+ }++ const target: Vec3 = { x: bounds.center[0], y: bounds.center[1], z: bounds.center[2] };+ const forward = normalize({ x: viewDirection[0], y: viewDirection[1], z: viewDirection[2] });+ const worldUp = Math.abs(forward.y) > 0.95 ? { x: 0, y: 0, z: 1 } : { x: 0, y: 1, z: 0 };+ const right = normalize(cross(worldUp, forward));+ const up = normalize(cross(forward, right));++ let projectedHalfWidth = 0;+ let projectedHalfHeight = 0;++ for (const corner of getBoundsCorners(bounds)) {+ const relative = {+ x: corner.x - target.x,+ y: corner.y - target.y,+ z: corner.z - target.z,+ };++ projectedHalfWidth = Math.max(projectedHalfWidth, Math.abs(dot(relative, right)));+ projectedHalfHeight = Math.max(projectedHalfHeight, Math.abs(dot(relative, up)));+ }++ const margin = 1.15;+ const zoom = Math.max(+ 0.01,+ Math.min(+ frustumWidth / (Math.max(projectedHalfWidth * 2, 1e-3) * margin),+ frustumHeight / (Math.max(projectedHalfHeight * 2, 1e-3) * margin),+ ),+ );+ const distance = Math.max(bounds.radius * 4, 6);++ return {+ position: [+ target.x + (forward.x * distance),+ target.y + (forward.y * distance),+ target.z + (forward.z * distance),+ ],+ target: [target.x, target.y, target.z],+ zoom,+ near: 0.01,+ far: Math.max(distance + (bounds.radius * 8), 100),+ };}diff --cc docs/display-architecture-x5-threejs-displayir-renderer-cleanup.mdindex e44bb5bf,2058fb88..3f8efb4f--- a/docs/display-architecture-x5-threejs-displayir-renderer-cleanup.md+++ b/docs/display-architecture-x5-threejs-displayir-renderer-cleanup.md@@@ -65,6 -65,6 +65,10 @@@ DISPLAY-ARCH-X6 — typed DisplayIR APDISPLAY-ARCH-X5.1 resolved the imported-occurrence server validation issue by documenting and testing the distinction between direct bounded `/tessellate` mesh lowering and DisplayIR-authoritative `/display/prepare`. The frontend typed renderable architecture from X5 remains unchanged.+## X5.2 follow-up++DISPLAY-QA-X2 kept the X5 typed-renderable contract intact but fixed one remaining frontend legacy assumption: imported-body framing still used a fixed orthographic camera pose instead of bounds derived from typed DisplayIR renderables. X2 added DisplayIR-aware bounds and orthographic fit logic without changing renderable semantics or server authority.+++ ## Follow-up: DISPLAY-ARCH-X6++ DISPLAY-ARCH-X6 follows this cleanup by making `DisplayScene` / `DisplayRenderable` the primary frontend scene contract and quarantining legacy tessellation fallback conversion behind explicit compatibility adapters. See `docs/display-architecture-x6-retire-legacy-mesh-scene.md`.diff --cc docs/display-qa-x2-imported-body-framing-status.mdindex a0f10e97,02d48665..c6507b47--- a/docs/display-qa-x2-imported-body-framing-status.md+++ b/docs/display-qa-x2-imported-body-framing-status.md@@@ -1,179 -1,4 +1,183 @@@+# DISPLAY-QA-X2: imported-body framing and display status++## 1. Purpose and scope++DISPLAY-QA-X2 fixes the frontend/viewer regression identified in DISPLAY-QA-X1 where FTC-06 imported and prepared display data successfully, but the default viewport framing was so wrong that the model was effectively off-screen. This milestone also fixes the local client production build break in `aetheris.client/src/App.tsx` and promotes mixed/partial display status into the main visible UI.++Scope stayed intentionally narrow:++- frontend DisplayIR-aware bounds and camera fit;+- frontend import/display status messaging;+- frontend TypeScript build repair;+- local FTC-06 / FTC-07 visual QA rerun.++This milestone did not change STEP import/export semantics, BRep topology, DisplayIR server authority, tessellator algorithms, Firmament V2 language/lowering, AIR Region route policy, CIR authority, Firmasm, or CAD feature behavior.++## 2. Relationship to DISPLAY-QA-X1++DISPLAY-QA-X1 established that FTC-06 was not an import-loss problem:++- FTC-06 import succeeded.+- `/display/prepare` succeeded as `mixed-fallback`.+- Backend facts were `161` analytic faces plus `26` fallback faces, `187` total.+- The UI still showed only the drafting grid until extreme manual zoom-out, and even then the model was clipped and offset.++DISPLAY-QA-X2 resolves that frontend framing defect and reruns the local pass with the same FTC corpus files.++## 3. Root cause of FTC-06 bad framing++The root cause was the viewport camera path, not the importer or kernel:++- `aetheris.client/src/viewer/AetherisViewport.tsx` mounted a fixed orthographic camera at `[6, 6, 6]` with a fixed zoom and no fit-to-scene pass.+- The typed DisplayIR path in `displaySceneBuilder.ts` preferred `DisplayScene` renderables and often left legacy `sceneData` null.+- Because the viewport never computed bounds from typed DisplayIR renderables, imported bodies could exist correctly in scene space while the camera target and zoom remained pinned to legacy assumptions around the origin.++In practice, FTC-06 geometry was present, but the initial camera target/zoom was not derived from the imported model's actual bounds.++## 4. Fix++### DisplayIR-aware bounds++Added `aetheris.client/src/viewer/displaySceneBounds.ts` with:++- `computeDisplaySceneBounds(displayScene, sceneData)`+- `computeOrthographicCameraFit(bounds, frustumWidth, frustumHeight, viewDirection)`++Bounds now consider typed DisplayIR geometry first:++- `AnalyticPatch`: analytic preview mesh vertex positions+- `MeshPatch`: bounded-mesh vertex positions+- `WirePatch`: wire polyline points+- `DiagnosticPatch`: ignored unless geometry exists elsewhere++If typed renderables have no geometry, the code falls back to legacy `RenderSceneData`.++### Camera fit++`AetherisViewport.tsx` now mounts a `FitCameraToScene` helper that:++- recomputes bounds from typed DisplayIR renderables or legacy scene fallback;+- centers the orbit target on the bounds center;+- repositions the orthographic camera along the existing isometric viewing direction;+- computes a conservative orthographic zoom from projected bounds size;+- updates `near` / `far` to avoid clipping the imported body.++This is intentionally conservative and does not redesign the viewer camera model.++### Status UI++`App.tsx` now emits first-class import/display summaries:++- mixed fallback: `Import complete. Display: mixed analytic + bounded mesh fallback.`+- partial display: `Import complete. Display partial: N wire-only face(s), M diagnostic-only face(s).`+- materialization failure remains separate from import failure.++Mixed fallback is treated as success, not failure.++## 5. Client build break fix++The local production build failure in `aetheris.client/src/App.tsx` around the old lines `393/394` came from the import flow's mutable `displayError` control flow and TypeScript narrowing.++The import flow was simplified so it now:++- performs the import path directly inside `handleImportStep`;+- uses a structured `RefreshDisplayResult` from `refreshSummaryAndActiveTessellation`;+- sets import success, partial-display, and materialization-failure messaging explicitly.++`npm run build` now passes.++## 6. FTC-06 before/after++### Backend facts++- Import: success+- `/display/prepare`: success+- Display lane: `mixed-fallback`+- Display status: `Complete`+- Analytic faces: `161`+- Fallback faces: `26`+- Face count: `187`+- Edge count: `476`++### UI facts after X2++- The body is visible in the default imported view.+- The body is centered and framed without extreme manual zoom-out.+- The main UI now says `Import complete. Display: mixed analytic + bounded mesh fallback.`+- The inspector still matches backend facts.++### Artifact paths++- Viewport screenshot: [ftc06-imported-display-fixed.png](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-qa-x2/ftc06-imported-display-fixed.png)+- Status screenshot: [ftc06-display-status-fixed.png](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-qa-x2/ftc06-display-status-fixed.png)+- Display response capture: [ftc06-display-prepare.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-qa-x2/ftc06-display-prepare.json)++## 7. FTC-07 smoke status++FTC-07 no longer reproduced the old DISPLAY-QA-X1 local outcome during this X2 rerun.++Observed local smoke result:++- Import: success+- `/display/prepare`: success (`200`)+- Display lane: `mixed-fallback`+- Display status: `Partial`+- Main UI message: `Import complete. Display partial: 210 wire-only face(s), 0 diagnostic-only face(s).`+- Analytic faces: `96`+- Fallback faces: `210`+- Inspector face count: `8`+- Edge count: `871`++This is a changed local smoke result, not a frontend framing change. X2 did not modify server-side display semantics or tessellation algorithms.++Artifact paths:++- Viewport screenshot: [ftc07-imported-display-smoke.png](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-qa-x2/ftc07-imported-display-smoke.png)+- Status screenshot: [ftc07-display-status-smoke.png](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-qa-x2/ftc07-display-status-smoke.png)+- Display response capture: [ftc07-display-prepare.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-qa-x2/ftc07-display-prepare.json)++## 8. Tests run++Frontend:++```powershell+cd aetheris.client+npm test -- --run src/__tests__/App.test.tsx src/__tests__/displayRenderables.test.ts src/__tests__/displaySceneBuilder.test.ts src/__tests__/AetherisViewport.test.tsx src/__tests__/displaySceneBounds.test.ts+npm run build+```++Solution / server-core smoke:++```powershell+dotnet restore Aetheris.slnx+dotnet build Aetheris.slnx -f net10.0 --no-restore /m:1+dotnet test Aetheris.Kernel.Core.Tests/Aetheris.Kernel.Core.Tests.csproj -f net10.0 --no-build --filter "DisplayIR|BoundedMesh|WirePatch|DisplayPrepare|ViewMaterialization|FTC07|Ftc07|Tessellation|FTC06|Ftc06" --logger "console;verbosity=minimal"+dotnet test Aetheris.Server.Tests/Aetheris.Server.Tests.csproj -f net10.0 --no-build --filter "DisplayIR|BoundedMesh|WirePatch|DisplayPrepare|FTC07|Ftc07|FTC06|Ftc06|KernelApi|ViewMaterialization|Tessellate|Tessellation|StepIo" --logger "console;verbosity=minimal"+dotnet test Aetheris.Kernel.Core.Tests/Aetheris.Kernel.Core.Tests.csproj -f net10.0 --no-build --filter "Step242Ftc06SameSenseRegressionTests|FTC06|Ftc06|same_sense" --logger "console;verbosity=minimal"+dotnet run --project Aetheris.CLI -f net10.0 -- analyze testdata/step242/nist/FTC/nist_ftc_06_asme1_ap242-e2.stp --json+dotnet run --project Aetheris.CLI -f net10.0 -- analyze testdata/step242/nist/FTC/nist_ftc_07_asme1_ap242-e2.stp --json+```++Local visual QA:++```powershell+node scripts/display-qa-x2-playwright.mjs+```++The local rerun used the same script with `AETHERIS_QA_CASE=ftc06` and `AETHERIS_QA_CASE=ftc07` so each capture ran against a fresh server/client pair.++## 9. Remaining limitations++- Camera fit is still an orthographic, isometric, geometry-bounds fit; it is not a full viewer-camera redesign.+- Diagnostic-only faces without geometry remain intentionally excluded from bounds.+- FTC-07 changed locally from X1's materialization failure to a partial mixed-fallback result, but X2 does not explain or claim ownership of that backend behavior change.++## 10. Next milestone recommendation++Recommended next step: a focused FTC-07 follow-up that explains the changed local smoke result and stabilizes the intended server-side behavior for planar / wire degradation reporting.++If the team wants to stay in frontend scope first, the next small slice would be viewer polish around partial-display highlighting and optional explicit wireframe emphasis, not more camera work.++ ## Follow-up: DISPLAY-ARCH-X6++ DISPLAY-ARCH-X6 keeps the imported-body framing/status behavior from this milestone while removing the remaining frontend dependency on legacy mesh-scene data as a primary viewport contract. Legacy tessellation fallback is now compatibility-only. See `docs/display-architecture-x6-retire-legacy-mesh-scene.md`.diff --cc docs/display-quality-x1-ftc06-ftc07-post-displayscene-qa.mdindex 00000000,00000000..75b0ead3new file mode 100644--- /dev/null+++ b/docs/display-quality-x1-ftc06-ftc07-post-displayscene-qa.md@@@ -1,0 -1,0 +1,341 @@@++# DISPLAY-QUALITY-X1 — FTC-06 / FTC-07 post-DisplayScene QA++++## 1. Purpose and scope++++This report records a post-`DisplayScene` frontend stabilization QA pass for FTC-06 and FTC-07 after `DISPLAY-ARCH-X6` retired the legacy frontend mesh-scene contract.++++This milestone was treated as a stabilization and evidence-gathering pass only. No backend semantic changes were intended, and no product behavior was intentionally changed during this milestone.++++Follow-up note: `CLIENT-BUILD-FIX-X1` resolved the frontend merge-marker blocker found during this pass and restored a clean production client build from the same branch line.++++## 2. Environment++++- OS: Microsoft Windows 11 Pro 64-bit, version `10.0.26200`, build `26200`++- Shell: PowerShell `7.6.2`++- .NET SDK: `10.0.301`++- Node: `v26.2.0`++- npm: `11.13.0`++- Browser used for blocker verification: Microsoft Edge `149.0.4022.69`++- Standalone Playwright script: not run as a grounded UI pass because the current client worktree did not compile cleanly++++## 3. Exact files tested++++- `testdata/step242/nist/FTC/nist_ftc_06_asme1_ap242-e2.stp`++- `testdata/step242/nist/FTC/nist_ftc_07_asme1_ap242-e2.stp`++++## 4. Build/test baseline++++Commands run:++++```bash++dotnet restore Aetheris.slnx++dotnet build Aetheris.slnx -f net10.0 --no-restore /m:1++cd aetheris.client++npm run build++npm test -- --run App.test.tsx displayRenderables.test.ts AetherisViewport.test.tsx displaySceneBuilder.test.ts displaySceneBounds.test.ts++```++++Results:++++- `dotnet restore Aetheris.slnx`: passed++- `dotnet build Aetheris.slnx -f net10.0 --no-restore /m:1`: passed++- `npm run build`: failed in the current worktree because `aetheris.client/src/App.tsx`, `src/viewer/AetherisViewport.tsx`, `src/viewer/displaySceneBounds.ts`, and `src/__tests__/displaySceneBounds.test.ts` still contain merge conflict markers++- `npm test -- --run ...`: failed for the same reason; `displayRenderables.test.ts` and `displaySceneBuilder.test.ts` passed, while `App.test.tsx`, `AetherisViewport.test.tsx`, and `displaySceneBounds.test.ts` failed during transform on merge markers++++Focused display/server test commands:++++```bash++dotnet test Aetheris.Kernel.Core.Tests/Aetheris.Kernel.Core.Tests.csproj -f net10.0 --no-build --filter "DisplayIR|BoundedMesh|WirePatch|DisplayPrepare|ViewMaterialization|FTC07|Ftc07|Tessellation|FTC06|Ftc06" --logger "console;verbosity=minimal"++++dotnet test Aetheris.Server.Tests/Aetheris.Server.Tests.csproj -f net10.0 --no-build --filter "DisplayIR|BoundedMesh|WirePatch|DisplayPrepare|FTC07|Ftc07|FTC06|Ftc06|KernelApi|ViewMaterialization|Tessellate|Tessellation|StepIo" --logger "console;verbosity=minimal"++```++++Results:++++- `Aetheris.Kernel.Core.Tests`: passed, `91/91`++- `Aetheris.Server.Tests`: passed, `33/33`++++Additional regression check:++++```bash++dotnet test Aetheris.Kernel.Core.Tests/Aetheris.Kernel.Core.Tests.csproj -f net10.0 --no-build --filter "Step242Ftc06SameSenseRegressionTests|FTC06|Ftc06|same_sense" --logger "console;verbosity=minimal"++```++++- FTC-06 regression slice: passed, `6/6`++++## 5. Backend facts: FTC-06++++CLI / API artifacts:++++- Analyze JSON: [ftc06-analyze.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc06-analyze.json)++- Canon JSON: [ftc06-canon.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc06-canon.json)++- API import JSON: [ftc06-api-import.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc06-api-import.json)++- API display/prepare JSON: [ftc06-api-display-prepare.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc06-api-display-prepare.json)++- Compact backend summary: [ftc06-backend-summary.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc06-backend-summary.json)++++Observed facts:++++- Analyze result: success++- Canon result: success++- UI/API import result: success++- `display/prepare` status: success, `Complete`++- DisplayIR status: emitted++- `sourceAuthority`: `BRep`++- `displayAuthority`: `DisplayIR`++- Display lanes: `AnalyticPatch`, `BoundedMesh`++- Renderable counts by kind:++ - `AnalyticPatch`: `161`++ - `MeshPatch / BoundedMesh`: `26`++ - `WirePatch`: `0`++ - `DiagnosticPatch`: `0`++- Analyze face count: `187`++- Analyze edge count: `476`++- Diagnostic count: `0`++- Lane summary:++ - `AnalyticPatch`: `Complete`, `161` faces++ - `BoundedMesh`: `Complete`, `26` faces++++Interpretation:++++- FTC-06 backend still lands in the healthy `mixed-fallback` path observed after X2.++- No backend diagnostic evidence suggests clipping, omission, or display degradation for FTC-06.++++## 6. UI facts: FTC-06++++Expected screenshot targets:++++- `artifacts/display-quality-x1/ftc06-default-view.png`++- `artifacts/display-quality-x1/ftc06-status-inspector.png`++- `artifacts/display-quality-x1/ftc06-angle-1.png`++- `artifacts/display-quality-x1/ftc06-angle-2.png`++++Current result:++++- A grounded fresh-client FTC-06 UI pass could not be completed.++- A fresh Vite instance on `https://127.0.0.1:43117/` hit a compile-time overlay before the app shell rendered because the current worktree contains unresolved merge markers in `aetheris.client/src/App.tsx` and related DisplayScene viewer files.++- Existing listeners on `5173` were present before this pass and were treated as stale local runtime state, not acceptable evidence for post-X6 UI QA.++++Available UI blocker artifact:++++- Fresh-client Vite overlay screenshot: [client-43117-vite-overlay.png](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/client-43117-vite-overlay.png)++++What could not be verified from a fresh client build:++++- whether FTC-06 is visible by default++- whether camera framing remains fixed++- whether any geometry is clipped++- whether shading/materials look sane++- whether fallback faces are visibly different++- whether wire/diagnostic state is visible++- whether UI status matches backend facts++++Best grounded statement for this milestone:++++- FTC-06 backend evidence remains healthy and consistent with X2/X6 expectations, but the current frontend worktree was not in a runnable state for a fresh visual confirmation.++++## 7. Backend facts: FTC-07++++CLI / API artifacts:++++- Analyze JSON: [ftc07-analyze.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc07-analyze.json)++- Canon JSON: [ftc07-canon.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc07-canon.json)++- API import JSON: [ftc07-api-import.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc07-api-import.json)++- API display/prepare JSON: [ftc07-api-display-prepare.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc07-api-display-prepare.json)++- Compact backend summary: [ftc07-backend-summary.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc07-backend-summary.json)++++Observed facts:++++- Analyze result: success++- Canon result: success++- UI/API import result: success++- `display/prepare` status: success, `Partial`++- DisplayIR status: emitted++- `sourceAuthority`: `BRep`++- `displayAuthority`: `DisplayIR`++- Display lanes: `AnalyticPatch`, `BoundedMesh`, `WirePatch`++- Renderable counts by kind:++ - `AnalyticPatch`: `96`++ - `MeshPatch / BoundedMesh`: `0`++ - `WirePatch`: `210`++ - `DiagnosticPatch`: `0`++- Analyze face count: `306`++- Analyze edge count: `871`++- Diagnostic count: `299`++- Lane summary:++ - `AnalyticPatch`: `Complete`, `96` faces++ - `BoundedMesh`: `Failed`, `0` faces++ - `WirePatch`: `Partial`, `210` faces++++Key backend diagnostic evidence:++++- Top-level partial-display diagnostic: `Viewer.Display.Partial`++- First blocking face still includes the known planar hole path:++ - code: `Viewer.Tessellation.Timeout`++ - face: `9`++ - surface: `Plane`++ - phase: `PlanarTriangulationWithHoles`++- Subsequent degraded faces continue through `FaceDispatch`++- Representative wire-only faces include spheres, cylinders, torus, and BSpline faces downgraded to `WirePatch`++++Interpretation:++++- FTC-07 is no longer an import failure and no longer a total display-prepare failure.++- FTC-07 currently materializes as a partial DisplayIR result with `96` filled analytic faces and `210` wire-only faces.++- The dominant remaining backend/display issue is still bounded-mesh fill recovery, not import, not canon, and not DisplayIR authority.++++## 8. UI facts: FTC-07++++Expected screenshot targets:++++- `artifacts/display-quality-x1/ftc07-default-view.png`++- `artifacts/display-quality-x1/ftc07-status-inspector.png`++- `artifacts/display-quality-x1/ftc07-angle-1.png`++- `artifacts/display-quality-x1/ftc07-angle-2.png`++++Current result:++++- A grounded fresh-client FTC-07 UI pass could not be completed for the same reason as FTC-06: the current DisplayScene frontend worktree did not compile to a runnable app shell.++- Because a fresh client could not render, the pass could not verify body visibility, partial-display visuals, wire-only face prominence, diagnostic marker visibility, or UI/backend status agreement.++++What can still be stated from backend facts:++++- FTC-07 backend state is `Partial`, not failed import.++- The partial result is strongly wire-heavy (`210` `WirePatch` faces).++- The degraded lane is specifically the `BoundedMesh` path, which reported `Failed`.++++## 9. Visual issue classification++++### FTC-06 visual artifacts++++Issue:++ title: FTC-06 fresh visual confirmation blocked by unresolved frontend merge state++ model: FTC-06++ screenshot: [client-43117-vite-overlay.png](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/client-43117-vite-overlay.png)++ suspected layer:++ - local runtime/build++ evidence: fresh Vite boot on alternate port `43117` rendered a compile overlay before the application shell; current source still contains merge markers in `aetheris.client/src/App.tsx` and related DisplayScene files++ severity: high for QA confidence, low for backend display correctness++ recommended follow-up: resolve the worktree merge state before claiming a new visual pass; then rerun FTC-06 screenshots against a fresh client instance++++### FTC-07 partial/wire/diagnostic display issues++++Issue:++ title: FTC-07 remains predominantly wire-only after DisplayIR partial recovery++ model: FTC-07++ screenshot: none captured from a fresh client build++ suspected layer:++ - BoundedMesh tessellation++ - DisplayIR mapping++ evidence: live `display/prepare` returned `Partial`; `AnalyticPatch=96`, `BoundedMesh=0`, `WirePatch=210`; `BoundedMesh` lane status was `Failed`; first timeout remained `face 9 / Plane / PlanarTriangulationWithHoles`++ severity: high++ recommended follow-up: `DISPLAY-BACKEND-X1 — FTC-07 wire-only-to-fill recovery triage`++++Issue:++ title: FTC-07 timeout fan-out extends beyond the initial planar face++ model: FTC-07++ screenshot: none captured from a fresh client build++ suspected layer:++ - BoundedMesh tessellation++ - AnalyticPatch sampling++ evidence: after the initial face-9 planar timeout, additional faces degraded during `FaceDispatch`; representative wire-only faces include `Sphere`, `Cylinder`, `Torus`, and `BSplineSurfaceWithKnots`++ severity: medium++ recommended follow-up: isolate why one stalled bounded-mesh path causes broad wire-only fallback instead of preserving more fill coverage++++### Status UI issues++++Issue:++ title: UI/backend status agreement could not be revalidated post-X6 from a fresh build++ model: FTC-06 and FTC-07++ screenshot: [client-43117-vite-overlay.png](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/client-43117-vite-overlay.png)++ suspected layer:++ - frontend DisplayIR status/inspector polish++ - local runtime/build++ evidence: the client never reached the app shell, so no status panel or inspector state was visible; existing `5173` listeners were treated as stale runtime and not accepted as grounded evidence++ severity: medium++ recommended follow-up: after resolving the merge state, rerun a fresh-client UI pass before making any new frontend status-polish claims++++### Build/test issues++++Issue:++ title: DisplayScene frontend worktree contains unresolved merge markers++ model: repo-wide blocker affecting FTC UI QA++ screenshot: [client-43117-vite-overlay.png](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/client-43117-vite-overlay.png)++ suspected layer:++ - local runtime/build++ evidence: `npm run build` and `npm test -- --run ...` both fail on merge markers in `aetheris.client/src/App.tsx`, `src/viewer/AetherisViewport.tsx`, `src/viewer/displaySceneBounds.ts`, and `src/__tests__/displaySceneBounds.test.ts`; fresh Vite startup reproduced the same parse error++ severity: high++ recommended follow-up: resolve the local merge state first; do not interpret this as a product display regression++++## 10. Screenshots / artifact index++++Report artifact:++++- Report: [display-quality-x1-ftc06-ftc07-post-displayscene-qa.md](/C:/Users/yuech/source/repos/Aetheris/docs/display-quality-x1-ftc06-ftc07-post-displayscene-qa.md) — intended to commit++++Backend artifacts:++++- [ftc06-backend-summary.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc06-backend-summary.json) — local-only++- [ftc07-backend-summary.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc07-backend-summary.json) — local-only++- [ftc06-api-display-prepare.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc06-api-display-prepare.json) — local-only, very large raw payload++- [ftc07-api-display-prepare.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc07-api-display-prepare.json) — local-only++- [ftc06-api-import.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc06-api-import.json) — local-only++- [ftc07-api-import.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc07-api-import.json) — local-only++- [ftc06-analyze.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc06-analyze.json) — local-only++- [ftc07-analyze.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc07-analyze.json) — local-only++- [ftc06-canon.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc06-canon.json) — local-only++- [ftc07-canon.json](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/ftc07-canon.json) — local-only++- [nist_ftc_06_canonical.step](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/nist_ftc_06_canonical.step) — local-only++- [nist_ftc_07_canonical.step](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/nist_ftc_07_canonical.step) — local-only++++UI/blocker artifacts:++++- [client-43117-vite-overlay.png](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/client-43117-vite-overlay.png) — local-only++- [client-dev-43117-stdout.log](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/client-dev-43117-stdout.log) — local-only++- [client-dev-43117-stderr.log](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/client-dev-43117-stderr.log) — local-only++- [server-stdout.log](/C:/Users/yuech/source/repos/Aetheris/artifacts/display-quality-x1/server-stdout.log) — local-only++++Not generated:++++- `ftc06-default-view.png`++- `ftc06-status-inspector.png`++- `ftc06-angle-1.png`++- `ftc06-angle-2.png`++- `ftc07-default-view.png`++- `ftc07-status-inspector.png`++- `ftc07-angle-1.png`++- `ftc07-angle-2.png`++++Reason:++++- the current frontend worktree did not compile into a fresh runnable UI++++## 11. Recommended next milestone++++Recommended next milestone:++++`DISPLAY-BACKEND-X1 — FTC-07 wire-only-to-fill recovery triage`++++Why this is the right next milestone:++++- FTC-06 backend display is already healthy and complete++- FTC-07 import, analyze, and canon all succeed++- FTC-07 no longer presents as an import failure or a total display-prepare failure++- the remaining substantive product issue is that FTC-07 still collapses to `210` wire-only faces because the `BoundedMesh` lane fails and the first explicit timeout remains `face 9 / Plane / PlanarTriangulationWithHoles`++- the frontend blockage found during this pass is a local merge-state issue, not the next architecture milestone to optimize around++++## 12. Non-goals++++- no STEP import/export semantic changes++- no BRep topology changes++- no tessellator rewrite++- no Firmament V2 changes++- no AIR Region route policy changes++- no CIR authority changes++- no CAD feature changes++++Additional explicit non-changes for this pass:++++- no DisplayIR server authority changes++- no Firmasm changes++- no frontend typed renderable semantic changes++- no AP242 importer/exporter behavior changes