Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
housecall
Yuechen Li7af464dbe500
diff --git a/docs/display-qa-x1-ftc06-ftc07-local-visual-pass.md b/docs/display-qa-x1-ftc06-ftc07-local-visual-pass.mdnew file mode 100644index 00000000..cb7dabf0--- /dev/null+++ b/docs/display-qa-x1-ftc06-ftc07-local-visual-pass.md@@ -0,0 +1,291 @@+# DISPLAY-QA-X1: FTC-06 / FTC-07 local visual pass++## 1. Purpose and scope++This pass validates the current local viewer behavior for FTC-06 and FTC-07 after the DisplayIR architecture milestones, with emphasis on:++- whether UI import succeeds;+- whether `/display/prepare` succeeds, partially succeeds, or fails;+- whether the UI presentation matches backend reality;+- which remaining defects are most likely kernel/import, DisplayIR preparation, fallback lane, frontend renderer, camera/framing, or local build/runtime issues.++This milestone did not attempt broad fixes, tessellator rewrites, legacy mesh-scene removal, STEP semantic changes, or topology changes.++## 2. Environment++- OS: Microsoft Windows 11 Pro, version `10.0.26200`, build `26200`+- Command shell: PowerShell+- `dotnet --version`: `10.0.301`+- `node --version`: `v26.2.0`+- `npm --version`: `11.13.0`+- Browser used for UI QA: Microsoft Edge (`C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe`) driven headlessly by Playwright `1.61.0`+- In-app browser was also used for inspection, but not for the final import flow because its exposed runtime here could not populate the native file input.++## 3. Exact files tested++- FTC-06: `testdata/step242/nist/FTC/nist_ftc_06_asme1_ap242-e2.stp`+- FTC-07: `testdata/step242/nist/FTC/nist_ftc_07_asme1_ap242-e2.stp`++## 4. Exact commands used++Build / validation:++```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"+cd aetheris.client+npm test -- --run App.test.tsx displayRenderables.test.ts AetherisViewport.test.ts displaySceneBuilder.test.ts+npm run build+```++CLI analysis / canonicalization:++```powershell+dotnet run --project Aetheris.CLI -f net10.0 --no-build -- analyze testdata/step242/nist/FTC/nist_ftc_06_asme1_ap242-e2.stp --json+dotnet run --project Aetheris.CLI -f net10.0 --no-build -- analyze testdata/step242/nist/FTC/nist_ftc_07_asme1_ap242-e2.stp --json+dotnet run --project Aetheris.CLI -f net10.0 --no-build -- canon testdata/step242/nist/FTC/nist_ftc_06_asme1_ap242-e2.stp --out artifacts/display-qa-x1/nist_ftc_06_canonical.step --json+dotnet run --project Aetheris.CLI -f net10.0 --no-build -- canon testdata/step242/nist/FTC/nist_ftc_07_asme1_ap242-e2.stp --out artifacts/display-qa-x1/nist_ftc_07_canonical.step --json+```++Server / client startup:++```powershell+dotnet run --project Aetheris.Server --launch-profile http+$env:ASPNETCORE_URLS='http://localhost:5142'+npm.cmd run dev -- --host 127.0.0.1+```++Direct API capture:++```powershell+node <inline script posting to /api/v1/documents, /import/step, and /display/prepare for FTC-06 and FTC-07>+```++UI automation:++```powershell+npm init -y # in artifacts/display-qa-x1/playwright-env+npm install playwright --no-save # in artifacts/display-qa-x1/playwright-env+$env:AETHERIS_PLAYWRIGHT_MODULE='C:\Users\yuech\source\repos\Aetheris\artifacts\display-qa-x1\playwright-env\node_modules\playwright\index.mjs'+node scripts\display-qa-x1-playwright.mjs+```++Focused FTC-06 camera experiment:++```powershell+node <inline Playwright script importing FTC-06, then repeatedly wheel-zooming the viewport and saving comparison screenshots>+```++Notes:++- `npm test -- --run ... AetherisViewport.test.ts displayRenderables.test.ts ...` only matched existing `App.test.tsx` and `displaySceneBuilder.test.ts`; those two files passed.+- `npm run build` failed locally in [aetheris.client/src/App.tsx](C:/Users/yuech/source/repos/Aetheris/aetheris.client/src/App.tsx:393) and [aetheris.client/src/App.tsx](C:/Users/yuech/source/repos/Aetheris/aetheris.client/src/App.tsx:394) with TypeScript `never` narrowing errors.+- The in-app browser could inspect the app but could not populate the native STEP file input through its exposed runtime here, so final screenshot capture used standalone Playwright.++## 5. FTC-06 backend facts++- `analyze`: succeeded+- `canon`: succeeded+- API/UI import: succeeded (`200`)+- `/display/prepare`: succeeded (`200`)+- DisplayIR status: `mixed-fallback`+- Lanes emitted: analytic plus fallback+- Analytic faces: `161`+- Fallback faces: `26`+- Fallback reason breakdown: `UnsupportedTrim = 26`+- Diagnostic faces count: `0` observed as emitted diagnostic-only faces+- Wireframe-only faces count: `0` observed as explicit wireframe-only emission+- Bounded mesh faces count: `26` inferred+ Reason: all 26 fallback faces were present in `tessellationFallback.facePatches`, all patch `source` values were `Tessellator`, and all `scaffoldRejectionReason` values were `None`+- Analytic faces count: `161`+- Raw artifacts:+ - `artifacts/display-qa-x1/ftc06-analyze.json`+ - `artifacts/display-qa-x1/ftc06-canon.json`+ - `artifacts/display-qa-x1/ftc06-import.json`+ - `artifacts/display-qa-x1/ftc06-display-prepare.json`+ - `artifacts/display-qa-x1/ftc06-api-summary.json`++Important limitation:++- The current API contract does not expose first-class `WirePatch`, `WireframeOnly`, or `DiagnosticOnly` counters in `DisplayPreparationResponseDto`; those counts above are based on emitted payload evidence, not explicit server fields.++## 6. FTC-06 UI facts++- Screenshot paths:+ - `artifacts/display-qa-x1/ftc06-imported-display.png`+ - `artifacts/display-qa-x1/ftc06-display-status.png`+ - `artifacts/display-qa-x1/ftc06-imported-display-baseline.png`+ - `artifacts/display-qa-x1/ftc06-imported-display-zoomed-out.png`+ - `artifacts/display-qa-x1/ftc06-imported-display-max-zoomout.png`+- Whether body visible:+ - At default post-import view: effectively no; the viewport shows only the drafting grid+ - After aggressive wheel zoom-out: yes, but only as a heavily clipped partial body entering from the upper-right/top edge+- Whether visual defects remain: yes+ - The default camera framing fails badly for the imported model+ - Even after manual zoom-out, the model is still clipped and not fit to the viewport+- Whether UI status matches backend status:+ - Partially yes+ - Inspector correctly reports `Display lane: mixed-fallback`, `Render path: mixed-fallback`, `Analytic faces: 161`, `Fallback faces: 26`, `Face count: 187`, `Edge count: 476`+ - Import status only says `Import complete.` and does not explicitly communicate that this is a partial analytic+fallback display case++## 7. FTC-07 backend facts++- `analyze`: succeeded+- `canon`: succeeded+- API/UI import: succeeded (`200`)+- `/display/prepare`: failed (`422`)+- DisplayIR status: not emitted; display preparation aborted before a usable packet was returned+- Lanes emitted: none in the failed response+- Diagnostic faces count: unavailable because no display packet was emitted+- Wireframe-only faces count: unavailable because no display packet was emitted+- Bounded mesh faces count: unavailable because no display packet was emitted+- Analytic faces count: unavailable because no display packet was emitted+- Failure diagnostic:+ - `ValidationFailed`+ - `Viewer.Tessellation.Timeout`+ - `Display tessellation exceeded the bounded execution budget after ~5s while processing face 9 on surface 'Plane' during phase 'PlanarTriangulationWithHoles'.`+- Raw artifacts:+ - `artifacts/display-qa-x1/ftc07-analyze.json`+ - `artifacts/display-qa-x1/ftc07-canon.json`+ - `artifacts/display-qa-x1/ftc07-import.json`+ - `artifacts/display-qa-x1/ftc07-display-prepare.json`+ - `artifacts/display-qa-x1/ftc07-api-summary.json`+ - `artifacts/display-qa-x1/ftc07-display-prepare-ui-response.json`++## 8. FTC-07 UI facts++- Screenshot paths:+ - `artifacts/display-qa-x1/ftc07-imported-display.png`+ - `artifacts/display-qa-x1/ftc07-display-status.png`+- Whether body visible: no+- Whether partial display / wire / diagnostic status is visible:+ - The UI clearly shows `Import complete. View materialization failed.`+ - It does not show a partial-display state, because `/display/prepare` failed outright+ - It does not show wireframe-only or diagnostic-only face counts or labels+- Whether UI status matches backend status:+ - Yes for the important distinction between import success and display failure+ - Inspector falls back to `Display lane: None`, `Render path: fallback`, and zero counts, which is consistent with the absence of a successful display packet but not especially rich diagnostically++## 9. Visual bug classification++### Issue 1++- Title: FTC-06 imported body is not framed into the default view+- Model: FTC-06+- Screenshot path: `artifacts/display-qa-x1/ftc06-imported-display.png`+- Suspected layer: frontend camera / old mesh-scene compatibility assumptions+- Evidence:+ - backend import and `/display/prepare` both succeed+ - inspector shows `mixed-fallback` with `187` rendered face patches and `476` edges+ - default viewport still shows only the grid and axis guide+- Severity: High+- Suggested follow-up: remove or repair legacy camera/framing assumptions and add fit-to-imported-body behavior for DisplayIR-backed scenes++### Issue 2++- Title: FTC-06 geometry appears only after extreme manual zoom-out and remains clipped+- Model: FTC-06+- Screenshot path: `artifacts/display-qa-x1/ftc06-imported-display-max-zoomout.png`+- Suspected layer: frontend camera / Three.js viewport setup / old mesh-scene compatibility assumptions+- Evidence:+ - after repeated zoom-out, geometry becomes visible only as a clipped upper-right fragment+ - this strongly suggests the body exists in scene space but is not normalized/framed correctly for the imported bounding box+- Severity: High+- Suggested follow-up: implement imported-body fit/center logic against actual scene bounds before removing legacy mesh-scene assumptions++### Issue 3++- Title: FTC-07 display preparation still times out on planar multi-loop face 9+- Model: FTC-07+- Screenshot path: `artifacts/display-qa-x1/ftc07-display-status.png`+- Suspected layer: DisplayIR server preparation / bounded mesh tessellation path+- Evidence:+ - kernel analyze, canon, and import all succeed+ - `/display/prepare` returns `422`+ - diagnostic identifies face `9`, surface `Plane`, phase `PlanarTriangulationWithHoles`+ - UI correctly reports view materialization failure instead of import failure+- Severity: High+- Suggested follow-up: isolate and repair the bounded planar-with-holes triangulation failure for FTC-07 face 9 without broad tessellator rewrite++### Issue 4++- Title: FTC-06 partial-display state is present in backend/inspector but under-signaled in the main UI+- Model: FTC-06+- Screenshot path: `artifacts/display-qa-x1/ftc06-display-status.png`+- Suspected layer: frontend typed DisplayIR renderer / status presentation+- Evidence:+ - backend returns `mixed-fallback`+ - inspector exposes lane and counts+ - main import status says only `Import complete.` and does not highlight that the display is mixed analytic+fallback+- Severity: Medium+- Suggested follow-up: add a first-class viewer status pill/banner for partial display, separate from import success/failure++### Issue 5++- Title: Local client production build currently fails independently of the visual QA flow+- Model: repo-wide local runtime issue+- Screenshot path: n/a+- Suspected layer: local build/runtime issue+- Evidence:+ - `npm run build` fails with TypeScript errors at [aetheris.client/src/App.tsx](C:/Users/yuech/source/repos/Aetheris/aetheris.client/src/App.tsx:393) and [aetheris.client/src/App.tsx](C:/Users/yuech/source/repos/Aetheris/aetheris.client/src/App.tsx:394)+ - dev server still runs, so this did not block the QA pass+- Severity: Medium+- Suggested follow-up: fix the `displayError` narrowing/build break separately so future local UI verification does not depend on the dev server only++## 10. Recommended next milestones++1. Remove or repair legacy imported-scene camera/framing assumptions for DisplayIR-backed viewer scenes.+ Reason: FTC-06 already imports and prepares display data successfully; the strongest remaining visible defect is framing, not kernel loss.+2. Fix the FTC-07 planar-with-holes display materialization failure in the bounded fallback path.+ Reason: the remaining blocker is narrow and well-identified at face 9 / `PlanarTriangulationWithHoles`.+3. Promote partial-display status to a first-class UI signal.+ Reason: FTC-06 is a successful mixed-fallback case, but the main status line currently hides that fact unless the user inspects the side panel.+4. After the camera/framing fix, rerun the same local FTC-06 pass before removing old mesh-scene assumptions.+ Reason: the current screenshots show imported geometry is present but badly framed; that is exactly the evidence needed before touching the legacy scene path.++Recommended immediate next milestone name:++- `DISPLAY-QA-X2` if the next step is a narrow frontend framing/status follow-up+- `DISPLAY-ARCH-X6` if the team wants to frame it as the first legacy-camera/scene-assumption removal slice++## 11. Non-goals++- no kernel rewrite+- no STEP import/export semantic changes+- no AP242 importer/exporter behavior changes+- no BRep topology changes+- no broad tessellator rewrite+- no Firmament V2 language/lowering changes+- no AIR Region route policy changes+- no CIR authority changes+- no Firmasm changes+- no frontend typed renderables behavior changes beyond a lightweight local QA helper script++## Answers to the milestone questions++1. Can FTC-06 import through the UI?+ Yes.+2. Can FTC-07 import through the UI?+ Yes.+3. Does FTC-06 display with remaining obvious visual defects?+ Yes. The body is effectively off-screen by default and only becomes partially visible after extreme zoom-out.+4. Does FTC-07 display fully, partially, wireframe-only, or diagnostic-only?+ No usable display is emitted in the current pass; import succeeds, but display preparation fails with a bounded diagnostic.+5. Likely remaining layers:+ - FTC-06 primary issue: frontend camera / old mesh-scene compatibility assumptions+ - FTC-07 primary issue: DisplayIR server preparation / planar-with-holes fallback tessellation+ - local secondary issue: client `npm run build` break+6. Does the UI correctly distinguish import success, partial display, wireframe-only, diagnostic-only, and materialization failure?+ - import success vs materialization failure: yes+ - partial display: only indirectly through inspector lane/counts, not prominently+ - wireframe-only faces: not explicitly surfaced in this UI+ - diagnostic-only faces: not explicitly surfaced in this UI+7. What should the next follow-up be?+ Fix imported-body framing/camera behavior first, then rerun FTC-06; keep FTC-07 on a narrow display-preparation/tessellation follow-up rather than another importer investigation.++## Artifact note++Artifacts were generated locally under `artifacts/display-qa-x1/`. They were not committed in this pass. Notable large local-only artifacts include `ftc06-display-prepare.json`, which is large because it contains the full tessellation fallback payload.diff --git a/scripts/display-qa-x1-playwright.mjs b/scripts/display-qa-x1-playwright.mjsnew file mode 100644index 00000000..211dd99a--- /dev/null+++ b/scripts/display-qa-x1-playwright.mjs@@ -0,0 +1,188 @@+import fs from 'node:fs/promises';+import path from 'node:path';+import { fileURLToPath, pathToFileURL } from 'node:url';++const __filename = fileURLToPath(import.meta.url);+const __dirname = path.dirname(__filename);+const repoRoot = path.resolve(__dirname, '..');+const artifactRoot = path.join(repoRoot, 'artifacts', 'display-qa-x1');+const playwrightModuleSpecifier = process.env.AETHERIS_PLAYWRIGHT_MODULE ?? 'playwright';++const clientUrl = process.env.AETHERIS_CLIENT_URL ?? 'https://127.0.0.1:5173/';+const edgeExecutablePath = process.env.AETHERIS_EDGE_PATH+ ?? 'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe';++const cases = [+ {+ id: 'ftc06',+ label: 'FTC-06',+ fixturePath: path.join(repoRoot, 'testdata', 'step242', 'nist', 'FTC', 'nist_ftc_06_asme1_ap242-e2.stp'),+ expectedImportStatus: 'Import complete.',+ },+ {+ id: 'ftc07',+ label: 'FTC-07',+ fixturePath: path.join(repoRoot, 'testdata', 'step242', 'nist', 'FTC', 'nist_ftc_07_asme1_ap242-e2.stp'),+ expectedImportStatus: 'Import complete. View materialization failed.',+ },+];++function ensureEdgeExists() {+ return fs.access(edgeExecutablePath);+}++async function writeJson(targetPath, value) {+ await fs.writeFile(targetPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');+}++async function loadChromium() {+ const specifier = path.isAbsolute(playwrightModuleSpecifier)+ ? pathToFileURL(playwrightModuleSpecifier).href+ : playwrightModuleSpecifier;+ const module = await import(specifier);+ return module.chromium;+}++async function run() {+ await ensureEdgeExists();+ await fs.mkdir(artifactRoot, { recursive: true });++ const chromium = await loadChromium();+ const browser = await chromium.launch({+ executablePath: edgeExecutablePath,+ headless: true,+ });++ const context = await browser.newContext({+ ignoreHTTPSErrors: true,+ viewport: { width: 1440, height: 960 },+ });++ const page = await context.newPage();+ const consoleEntries = [];+ const pageErrors = [];+ const requestFailures = [];+ const responseLog = new Map();++ page.on('console', (message) => {+ consoleEntries.push({+ type: message.type(),+ text: message.text(),+ location: message.location(),+ });+ });++ page.on('pageerror', (error) => {+ pageErrors.push({+ name: error.name,+ message: error.message,+ stack: error.stack ?? null,+ });+ });++ page.on('requestfailed', (request) => {+ requestFailures.push({+ url: request.url(),+ method: request.method(),+ failure: request.failure(),+ });+ });++ page.on('response', async (response) => {+ const url = response.url();+ if (!url.includes('/api/v1/documents/')) {+ return;+ }++ if (!url.includes('/import/step') && !url.includes('/display/prepare')) {+ return;+ }++ let bodyText;+ try {+ bodyText = await response.text();+ } catch (error) {+ bodyText = `<<failed to read response body: ${error}>>`;+ }++ responseLog.set(url, {+ url,+ status: response.status(),+ ok: response.ok(),+ bodyText,+ });+ });++ const summary = [];++ try {+ await page.goto(clientUrl, { waitUntil: 'load' });+ await page.getByRole('status').waitFor({ state: 'visible', timeout: 30000 });++ for (const testCase of cases) {+ await page.getByRole('button', { name: 'New Document' }).click();+ await page.getByText('Ready. Select a file to import.').waitFor({ state: 'visible', timeout: 30000 });++ const fileInput = page.getByTestId('step-import-file-input');+ await fileInput.setInputFiles(testCase.fixturePath);+ await page.getByRole('button', { name: 'Import STEP 242' }).click();+ await page.getByText(testCase.expectedImportStatus, { exact: true }).waitFor({ state: 'visible', timeout: 30000 });++ const viewportFrame = page.locator('.viewport-frame');+ const inspector = page.locator('.audit-panel');++ const displayLane = (await page.locator('.audit-panel p').filter({ hasText: 'Display lane:' }).innerText()).replace('Display lane:', '').trim();+ const renderPath = (await page.locator('.audit-panel p').filter({ hasText: 'Render path:' }).innerText()).replace('Render path:', '').trim();+ const analyticFaces = (await page.locator('.audit-panel p').filter({ hasText: 'Analytic faces:' }).innerText()).replace('Analytic faces:', '').trim();+ const fallbackFaces = (await page.locator('.audit-panel p').filter({ hasText: 'Fallback faces:' }).innerText()).replace('Fallback faces:', '').trim();+ const faceCount = (await page.locator('.audit-panel p').filter({ hasText: 'Face count:' }).innerText()).replace('Face count:', '').trim();+ const edgeCount = (await page.locator('.audit-panel p').filter({ hasText: 'Edge count:' }).innerText()).replace('Edge count:', '').trim();++ const importedDisplayPath = path.join(artifactRoot, `${testCase.id}-imported-display.png`);+ const statusDisplayPath = path.join(artifactRoot, `${testCase.id}-display-status.png`);+ await viewportFrame.screenshot({ path: importedDisplayPath });+ await inspector.screenshot({ path: statusDisplayPath });++ const importStatusText = await page.locator('.import-status-box').innerText();+ const responseEntries = [...responseLog.values()];+ const importResponse = responseEntries.filter((entry) => entry.url.includes('/import/step')).at(-1) ?? null;+ const displayPrepareResponse = responseEntries.filter((entry) => entry.url.includes('/display/prepare')).at(-1) ?? null;++ if (displayPrepareResponse) {+ await fs.writeFile(path.join(artifactRoot, `${testCase.id}-display-prepare-ui-response.json`), `${displayPrepareResponse.bodyText}\n`, 'utf8');+ }++ summary.push({+ caseId: testCase.id,+ fixturePath: testCase.fixturePath,+ importStatusText,+ displayLane,+ renderPath,+ analyticFaces,+ fallbackFaces,+ faceCount,+ edgeCount,+ screenshotPaths: {+ viewport: importedDisplayPath,+ status: statusDisplayPath,+ },+ importResponse: importResponse+ ? { url: importResponse.url, status: importResponse.status, ok: importResponse.ok }+ : null,+ displayPrepareResponse: displayPrepareResponse+ ? { url: displayPrepareResponse.url, status: displayPrepareResponse.status, ok: displayPrepareResponse.ok }+ : null,+ });+ }+ } finally {+ await writeJson(path.join(artifactRoot, 'playwright-summary.json'), summary);+ await writeJson(path.join(artifactRoot, 'playwright-console.json'), consoleEntries);+ await writeJson(path.join(artifactRoot, 'playwright-pageerrors.json'), pageErrors);+ await writeJson(path.join(artifactRoot, 'playwright-requestfailures.json'), requestFailures);+ await browser.close();+ }++ console.log(JSON.stringify(summary, null, 2));+}++await run();