Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
#!/usr/bin/env node
/*
* W10b-Smoke: die Griffe erklaeren nichts mehr, die Ansichts-Knoepfe klappen,
* die Hierarchie waechst aus dem Fokus, und der Graph passt ins Bild.
*
* ## Warum dieser Lauf existiert
*
* Fuenf Nutzerbefunde vom 2026-08-29 Abend und 2026-08-30 Vormittag. Sie sind
* einzeln klein und haben dieselbe Wirkung: sie halten jemanden auf, der die
* Oberflaeche benutzen will.
*
* 1. "diese Meldung nicht anzeigen ... Bitte an allen Bordern die Meldung
* entfernen." Der vierzeilige Kasten an den vier Zonengriffen.
* 2. "die beiden Buttons unten links sollten auch aufklappen und zuklappen
* koennen." Der Ansichts-Schalter war ein reiner Umschalter.
* 3. "und hierarchies werden auch nicht angezeigt." Die Projektion hing am
* Einstiegs-Spaziergang; ein Symbol im Fokus reichte nicht.
* 4. "mich nervt, dass die Galaxy manchmal einfach flach ist" und "auch soll
* der Graph am besten standardmaessig immer ganz sichtbar sein."
* 5. Der Vorschau-Server kopiert `dist` beim Start und sieht spaetere Bauten
* nie. Das ist kein Produktfehler, sondern ein Loch im Ablauf.
*
* ## Was hier gemessen wird und nicht behauptet
*
* Der Kern dieses Laufs ist Punkt 4, und er ist eine Aussage ueber ein BILD.
* Sie wird darum am Bild bewiesen und nicht an der Absicht: die Szene meldet
* ueber `globalThis.__atlasGalaxyFit`, wo JEDER ihrer Knoten in der
* Zeichenflaeche liegt (Projektion mit genau der Kamera, die gerade zeichnet;
* src/galaxy/GraphScene.tsx). Der Lauf liest daran zwei Zahlen: wie viele
* Knoten ausserhalb liegen (null) und wie viel Rand der aeusserste noch hat
* (mehr als null Pixel).
*
* Die zweite Haelfte von Punkt 4 ist die AUSRICHTUNG, und die wird
* UNABHAENGIG geprueft: dieser Lauf rechnet die Hauptachsen der geladenen
* Knotenpositionen selbst (Jacobi, `principalAxes` unten) und haelt die
* duennste Achse gegen die Blickrichtung, die die Kamera gemeldet hat. Die
* Rechnung der Oberflaeche und die Rechnung dieses Laufs teilen keine Zeile
* Code; stimmen sie ueberein, steht die Kamera wirklich senkrecht auf der
* groessten Flaeche.
*
* Gemessen wird ausserdem, dass die Messung ueberhaupt etwas sieht: bevor der
* Knopf "fit view" gedrueckt wird, verdreht der Lauf die Kamera mit Zug und
* Rad, bis Knoten aus dem Bild fallen, und schreibt die Zahl auf. Ein
* Nachweis "null Knoten ausserhalb" von einer Messung, die nie etwas anderes
* gemeldet hat, waere kein Nachweis.
*
* ## Zwei Groessen, und warum die zweite synthetisch ist
*
* Die Fixture dieses Projekts hat 76 Knoten. Der Nutzer indiziert daneben sein
* echtes Projekt: 5000 Knoten, 5209 Kanten, 17 Kantenarten. Die Einpassung muss
* bei beiden stimmen, also misst dieser Lauf beide. Die grosse Wolke kommt
* dabei ueber DIESELBE Route (`/api/layout`) in dieselbe Oberflaeche, ihr
* Inhalt ist aber erzeugt und nicht indiziert: sie traegt genau die Form der
* echten Antwort (Zahlen oben) und eine gedrehte, in den drei Richtungen
* verschieden weite Punktwolke. Das steht so im Artefakt, damit niemand die
* Zahl fuer eine Messung an echtem Code haelt.
*
* ## Ablauf
*
* 1. `npm run build`
* 2. isoliertes HOME, eigenes Rendezvous-Verzeichnis (CBM_RUNTIME_DIR)
* 3. fixtures/atlas-sample indizieren (die Fixture wird nur gelesen)
* 4. C-Server auf einem freien Port >= 4640, dist/ auf einem zweiten
* 5. Chromium ohne Aussenwelt, plus Route-Sperre
* a. Ruhezustand: kein Tooltip an den Griffen, Tastatur und ARIA da
* b. der graue hierarchy-Knopf sagt, was fehlt
* c. ein Symbol oeffnen: Hierarchie aus dem Fokus, Kopf nennt die Herkunft
* d. der Ansichts-Schalter klappt zu, auf und um, und stimmt mit dem
* beschrifteten Schalter daneben ueberein
* e. die Einpassung in drei Fenstergroessen und in beiden Ansichten
* f. verdrehen, "fit view", "reset layout": jedes Mal wieder alles im Bild
* g. dieselbe Messung mit 5000 Knoten
* h. der dokumentierte Vorschau-Ablauf, einmal wirklich ausgefuehrt
* 6. abraeumen, Restprozesse geduldig zaehlen, JSON und drei Bilder
*
* Das Ganze laeuft unter dem Netz-Deny-Gate (npm run smoke:w10b).
*
* ## Ports
*
* Ab 4640. 4390/4391 und 4392/4393 gehoeren den beiden Vorschauen des Nutzers,
* 4141 seinem Modell-Sidecar, 4142 der Agenten-Bruecke, 3001 der Vorschau des
* Referenzprojekts. Alles darunter gehoert frueheren Laeufen. Dieser Lauf fasst
* keinen davon an.
*/
import { spawn } from 'node:child_process';
import { existsSync, readdirSync } from 'node:fs';
import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { dirname, join, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import {
countListeners,
findFreePort,
indexRepository,
sleep,
startServer,
stopServer,
} from './lib/cbm-server.mjs';
import {
READABILITY_EXCLUSIONS,
closeTooltips,
measureReadability,
resetScroll,
scrollRegionsToEnd,
} from './lib/readability.mjs';
import { startStaticProxy } from './lib/static-proxy.mjs';
const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
const BINARY = join(ROOT, 'cbm', 'build', 'c', 'codebase-memory-mcp');
const DIST = join(ROOT, 'dist');
const FIXTURE = join(ROOT, 'fixtures', 'atlas-sample');
const PROJECT = 'codeatlasweb-w10b';
const OUT_DIR = join(ROOT, 'verification', 'w10b');
const OUT_JSON = join(OUT_DIR, 'fixes.json');
const SHOT_HANDLES = join(OUT_DIR, 'handles.png');
const SHOT_HIERARCHY = join(OUT_DIR, 'hierarchy-from-focus.png');
const SHOT_COLLAPSED = join(OUT_DIR, 'graph-collapsed.png');
/** Contract-Invariante. Alles darunter gehoert dem Nutzer oder frueheren Laeufen. */
const MIN_PORT = 4640;
/** Das Symbol, ueber das gelaufen wird. Dasselbe wie in W5c, W8, W8b und W9. */
const FOCUS_TARGET = 'createUser';
const FOCUS_FILE = 'src/services/userService.ts';
/**
* Die drei Fenstergroessen aus AC5.
*
* Die erste ist die der uebrigen Beweislaeufe, die zweite ein kleineres
* Fenster, die dritte ein hohes und schmales. Der Graph sitzt in der rechten
* Spalte, also aendert jede von ihnen das Seitenverhaeltnis der Zeichenflaeche,
* und genau daran haengt die Rahmung.
*/
const VIEWPORTS = [
{ width: 1680, height: 1050 },
{ width: 1400, height: 880 },
{ width: 1180, height: 1360 },
];
/** Die Form der zweiten Vorschau des Nutzers, in Zahlen. Siehe Kopf. */
const BIG_NODES = 5000;
const BIG_EDGES = 5209;
const BIG_KINDS = 17;
/** Chromium ohne Aussenwelt, plus die Software-GL-Flags aus smoke-w5c. */
const CHROMIUM_ARGS = [
'--host-resolver-rules=MAP * ~NOTFOUND, EXCLUDE 127.0.0.1, EXCLUDE localhost',
'--disable-background-networking',
'--disable-component-update',
'--disable-domain-reliability',
'--disable-client-side-phishing-detection',
'--disable-sync',
'--disable-default-apps',
'--no-first-run',
'--no-default-browser-check',
'--metrics-recording-only',
'--no-pings',
'--disable-breakpad',
'--disable-features=Translate,OptimizationHints,MediaRouter,AutofillServerCommunication,InterestFeedContentSuggestions,DialMediaRouteProvider,CalculateNativeWinOcclusion',
'--use-angle=swiftshader',
'--enable-unsafe-swiftshader',
'--ignore-gpu-blocklist',
];
const log = (...parts) => console.log('[smoke-w10b]', ...parts);
const serverLog = [];
function run(command, args) {
return new Promise((done) => {
const child = spawn(command, args, {
cwd: ROOT,
env: {
...process.env,
NO_UPDATE_NOTIFIER: '1',
npm_config_update_notifier: 'false',
npm_config_audit: 'false',
npm_config_fund: 'false',
},
stdio: ['ignore', 'pipe', 'pipe'],
});
let out = '';
child.stdout.on('data', (d) => { out += d.toString(); });
child.stderr.on('data', (d) => { out += d.toString(); });
child.on('error', (error) => done({ code: 127, out: out + error.message }));
child.on('close', (code) => done({ code: code ?? 1, out }));
});
}
// ------------------------------------------- die eigene Rechnung des Laufs ---
/**
* Die Hauptachsen einer Punktwolke, unabhaengig von der Oberflaeche gerechnet.
*
* Absichtlich eine zweite Rechnung und keine Wiederverwendung: die Zusicherung
* aus AC5 lautet, dass die Kamera senkrecht auf der groessten Flaeche steht.
* Sie mit derselben Funktion zu pruefen, die sie erzeugt hat, hiesse zu
* pruefen, ob eine Zahl gleich sich selbst ist. Hier steht darum ein eigenes
* Jacobi-Verfahren; verglichen wird am Ende nur das Ergebnis, also die
* Richtung, die die Kamera gemeldet hat.
*/
function principalAxes(points) {
if (points.length === 0) {
return null;
}
const mean = [0, 0, 0];
for (const p of points) {
mean[0] += p.x;
mean[1] += p.y;
mean[2] += p.z;
}
for (let i = 0; i < 3; i += 1) {
mean[i] /= points.length;
}
const c = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
for (const p of points) {
const d = [p.x - mean[0], p.y - mean[1], p.z - mean[2]];
for (let i = 0; i < 3; i += 1) {
for (let j = 0; j < 3; j += 1) {
c[i][j] += d[i] * d[j];
}
}
}
for (let i = 0; i < 3; i += 1) {
for (let j = 0; j < 3; j += 1) {
c[i][j] /= points.length;
}
}
const v = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
for (let sweep = 0; sweep < 32; sweep += 1) {
for (const [p, q] of [[0, 1], [0, 2], [1, 2]]) {
if (Math.abs(c[p][q]) < 1e-14) {
continue;
}
const theta = (c[q][q] - c[p][p]) / (2 * c[p][q]);
const t = Math.sign(theta || 1) / (Math.abs(theta) + Math.sqrt(theta * theta + 1));
const cs = 1 / Math.sqrt(t * t + 1);
const sn = t * cs;
for (let k = 0; k < 3; k += 1) {
const kp = c[k][p];
const kq = c[k][q];
c[k][p] = cs * kp - sn * kq;
c[k][q] = sn * kp + cs * kq;
}
for (let k = 0; k < 3; k += 1) {
const pk = c[p][k];
const qk = c[q][k];
c[p][k] = cs * pk - sn * qk;
c[q][k] = sn * pk + cs * qk;
}
for (let k = 0; k < 3; k += 1) {
const kp = v[k][p];
const kq = v[k][q];
v[k][p] = cs * kp - sn * kq;
v[k][q] = sn * kp + cs * kq;
}
}
}
// Sortiert wird nach der AUSDEHNUNG und nicht nach der Varianz: ins Bild
// muss der Kasten. Dieselbe Wahl wie in der Oberflaeche, aber hier aus dem
// Zweck heraus getroffen und nicht abgeschrieben.
const axes = [0, 1, 2].map((column) => {
const axis = [v[0][column], v[1][column], v[2][column]];
const length = Math.hypot(...axis) || 1;
const unit = axis.map((value) => value / length);
let min = Infinity;
let max = -Infinity;
for (const p of points) {
const value = p.x * unit[0] + p.y * unit[1] + p.z * unit[2];
min = Math.min(min, value);
max = Math.max(max, value);
}
return { axis: unit, extent: max - min };
});
axes.sort((a, b) => b.extent - a.extent);
return {
widest: axes[0],
middle: axes[1],
thinnest: axes[2],
};
}
/** Der Betrag des Skalarprodukts zweier Richtungen. 1 heisst: dieselbe Achse. */
const alignment = (a, b) => Math.abs(a[0] * b[0] + a[1] * b[1] + a[2] * b[2]);
/**
* Eine Layout-Antwort in der Form der echten, mit 5000 Knoten.
*
* Deterministisch erzeugt (eigener Zufallsgenerator, fester Startwert), damit
* zwei Laeufe dieselbe Wolke messen. Die Form ist die einer Galaxie, wie der
* Server sie rechnet: eine Scheibe, in einer Richtung deutlich duenner als in
* den beiden anderen, und danach im Raum gedreht, damit die duennste Richtung
* KEINE Weltachse ist. Genau daran haengt die Zusicherung.
*/
function syntheticLayout() {
let state = 20260830;
const random = () => {
state = (state * 1103515245 + 12345) % 2147483648;
return state / 2147483648;
};
const kinds = [
'CALLS', 'IMPORTS', 'DEFINES', 'USAGE', 'RAISES', 'RETURNS', 'READS', 'WRITES',
'EXTENDS', 'IMPLEMENTS', 'DEPENDS', 'CONFIGURES', 'TESTS', 'ROUTES', 'EMITS',
'HANDLES', 'CONTAINS',
].slice(0, BIG_KINDS);
const nodes = [];
// Eine feste Drehung, zusammengesetzt aus zwei Winkeln.
const ca = Math.cos(0.7);
const sa = Math.sin(0.7);
const cb = Math.cos(0.4);
const sb = Math.sin(0.4);
for (let i = 0; i < BIG_NODES; i += 1) {
const radius = 1500 * Math.sqrt(random());
const angle = random() * Math.PI * 2;
const a = radius * Math.cos(angle);
const b = radius * 0.62 * Math.sin(angle);
const g = (random() - 0.5) * 190;
const x1 = a * ca - b * sa;
const y1 = a * sa + b * ca;
const z1 = g;
nodes.push({
id: i,
x: x1,
y: y1 * cb - z1 * sb,
z: y1 * sb + z1 * cb,
label: 'Function',
name: `symbol${i}`,
qualified_name: `synthetic.symbol${i}`,
file_path: `src/generated/part${i % 200}.ts`,
start_line: 1 + (i % 400),
end_line: 4 + (i % 400),
size: 2 + (i % 9),
color: '#8fa3b0',
});
}
const edges = [];
for (let i = 0; i < BIG_EDGES; i += 1) {
edges.push({
source: Math.floor(random() * BIG_NODES),
target: Math.floor(random() * BIG_NODES),
type: kinds[i % kinds.length],
});
}
return { nodes, edges, total_nodes: BIG_NODES };
}
// ------------------------------------------------------------- Testgriffe ---
/** Der Griff des Graph-Panels, ohne die Funktion darin. */
const galaxySeam = (page) =>
page.evaluate(() => {
const seam = globalThis.__atlasGalaxy;
if (seam === undefined) {
return null;
}
const { clickNode, labelBoxes, hierarchy, ...rest } = seam;
return JSON.parse(JSON.stringify({
...rest,
labels: labelBoxes?.length ?? 0,
hierarchy: hierarchy === undefined ? null : {
root: hierarchy.root,
rootName: hierarchy.rootName,
nodes: hierarchy.nodes,
depth: hierarchy.depth,
placements: hierarchy.placements,
edges: hierarchy.edges,
},
}));
});
/** Die Messung der Szene: wo JEDER Knoten im Bild liegt. */
const fitMeasure = (page) =>
page.evaluate(() => {
const probe = globalThis.__atlasGalaxyFit;
return probe === undefined ? null : JSON.parse(JSON.stringify(probe.measure()));
});
/** Die vier Griffe, samt allem, was an ihnen etwas erklaeren koennte. */
const separators = (page) =>
page.evaluate(() =>
[...document.querySelectorAll('[role="separator"]')].map((node) => ({
testId: node.getAttribute('data-testid') ?? '',
orientation: node.getAttribute('data-orientation') ?? '',
label: node.getAttribute('aria-label') ?? '',
valueText: node.getAttribute('aria-valuetext') ?? '',
valueNow: node.getAttribute('aria-valuenow') ?? '',
valueMin: node.getAttribute('aria-valuemin') ?? '',
valueMax: node.getAttribute('aria-valuemax') ?? '',
tabIndex: node.tabIndex,
/* Die drei Wege, auf denen sich hier ein Kasten erklaeren koennte. */
hint: node.getAttribute('data-hint') ?? '',
title: node.getAttribute('title') ?? '',
describedBy: node.getAttribute('aria-describedby') ?? '',
})));
/** Wie viele eigene Tooltips ueberhaupt im Dokument haengen. */
const hintCount = (page) =>
page.evaluate(() => document.querySelectorAll('[data-hint]').length);
/** Der Ansichts-Schalter, sein Rahmen und was jeder Chip gerade tut. */
const viewToggle = (page) =>
page.evaluate(() => {
const group = document.querySelector('[data-testid="atlas-graph-mode"]');
if (group === null) {
return null;
}
const panel = document.querySelector('[data-testid="atlas-galaxy"]');
const fold = document.querySelector('[data-testid="atlas-galaxy-collapse"]');
return {
role: group.getAttribute('role') ?? '',
groupOpen: group.getAttribute('data-open') ?? '',
visible: panel?.getAttribute('data-visible') ?? '',
mode: panel?.getAttribute('data-mode') ?? '',
foldLabel: (fold?.textContent ?? '').replace(/\s+/g, ' ').trim(),
foldExpanded: fold?.getAttribute('aria-expanded') ?? '',
chips: [...group.querySelectorAll('[data-testid="atlas-graph-mode-chip"]')].map((chip) => ({
mode: chip.getAttribute('data-mode') ?? '',
pressed: chip.getAttribute('aria-pressed') ?? '',
active: chip.getAttribute('data-active') === 'true',
action: chip.getAttribute('data-action') ?? '',
available: chip.getAttribute('data-available') === 'true',
ariaDisabled: chip.getAttribute('aria-disabled') ?? '',
hint: chip.getAttribute('data-hint') ?? '',
})),
};
});
/** Der Satz unter dem Bild, so wie er dasteht. */
const noteText = (page) =>
page.evaluate(() => {
const node = document.querySelector('[data-testid="atlas-galaxy-note"]');
return node === null ? '' : (node.textContent ?? '').replace(/\s+/g, ' ').trim();
});
/** Der Kopf des Panels. */
const headline = (page) =>
page.evaluate(() => {
const node = document.querySelector('[data-testid="atlas-galaxy-headline"]');
return node === null ? '' : (node.textContent ?? '').replace(/\s+/g, ' ').trim();
});
/** Das Rechteck der Zeichenflaeche, in Fensterkoordinaten. */
const sceneRect = (page) =>
page.evaluate(() => {
const node = document.querySelector('[data-testid="atlas-galaxy-scene"]');
if (node === null) {
return null;
}
const rect = node.getBoundingClientRect();
return {
x: Math.round(rect.x),
y: Math.round(rect.y),
width: Math.round(rect.width),
height: Math.round(rect.height),
};
});
/**
* Die Uhr der Leerlauf-Drehung zuruecksetzen, ohne die Kamera zu bewegen.
*
* Wortgleich aus smoke-w9: ein Radereignis mit Weg null setzt `autoRotate`
* zurueck, und OrbitControls rechnet daraus einen Zoomfaktor von genau 1.
*/
const nudge = (page) =>
page.evaluate(() => {
const canvas = document.querySelector('[data-testid="atlas-galaxy-scene"] canvas');
if (canvas === null) {
return false;
}
canvas.dispatchEvent(new WheelEvent('wheel', { deltaY: 0, bubbles: true, cancelable: true }));
return true;
});
/** Wo jeder scrollbare Bereich steht. Wortgleich aus smoke-w9 (Beweisbilder). */
const scrollState = (page) =>
page.evaluate(() => {
const regions = [];
for (const node of document.body.querySelectorAll('*')) {
if (node.closest('.monaco-editor') !== null) {
continue;
}
const style = globalThis.getComputedStyle(node);
const scrollsY = (style.overflowY === 'auto' || style.overflowY === 'scroll')
&& node.scrollHeight > node.clientHeight + 1;
const scrollsX = (style.overflowX === 'auto' || style.overflowX === 'scroll')
&& node.scrollWidth > node.clientWidth + 1;
if (!scrollsY && !scrollsX) {
continue;
}
regions.push({
name: node.getAttribute('data-testid')
?? (node.getAttribute('class') ?? '').split(/\s+/).filter(Boolean)[0]
?? node.tagName.toLowerCase(),
top: Math.round(node.scrollTop),
left: Math.round(node.scrollLeft),
hidden: Math.round(node.scrollHeight - node.clientHeight),
});
}
return {
regions,
atRest: regions.every((region) => region.top <= 1 && region.left <= 1),
};
});
// ------------------------------------------------------------- Klickstrecke -
async function openApp(page, origin) {
await page.goto(`${origin}/?project=${PROJECT}`, { waitUntil: 'load' });
await page.waitForSelector('[data-testid="atlas-statusbar"]', { timeout: 30000 });
await page.waitForSelector('[data-testid="atlas-tree-row"]', { timeout: 30000 });
await page.waitForSelector('[data-testid="atlas-galaxy"]', { timeout: 30000 });
await page.waitForFunction(
() => (globalThis.__atlasGalaxy?.nodes ?? 0) > 0,
undefined,
{ timeout: 60000 },
);
await page.waitForFunction(
() => globalThis.__atlasGalaxyFit !== undefined,
undefined,
{ timeout: 60000 },
);
await page.waitForTimeout(700);
}
/** Ein Symbol ueber die Kommandozeile oeffnen. Wortgleich aus smoke-w8b. */
async function openSymbol(page, name, file) {
const input = page.locator('[data-testid="atlas-command-input"]');
await input.click();
await input.fill('');
await input.pressSequentially(name, { delay: 40 });
await page.waitForSelector(`[data-testid="atlas-search-row"][data-name="${name}"]`, { timeout: 30000 });
await page.waitForTimeout(600);
await page.click(`[data-testid="atlas-search-row"][data-name="${name}"]`);
await page.waitForFunction(
(expected) => globalThis.__atlasReader?.document?.path === expected,
file,
{ timeout: 40000 },
);
await page.waitForFunction(
(expected) => (globalThis.__atlasTwin?.symbol ?? '') === expected,
name,
{ timeout: 40000 },
);
await page.waitForTimeout(500);
}
/** Einen der beiden Ansichts-Chips klicken. */
async function clickChip(page, mode) {
await page.click(`[data-testid="atlas-graph-mode-chip"][data-mode="${mode}"]`);
await page.waitForTimeout(450);
}
/**
* Denselben Chip anklicken, waehrend er `aria-disabled` traegt.
*
* Ueber `dispatchEvent` und nicht ueber `page.click`, und der Grund gehoert zur
* Sache: Playwright haelt ein `aria-disabled="true"` fuer "nicht bedienbar" und
* wartet, bis das Attribut verschwindet. Ein Browser tut das nicht. Genau darum
* traegt der Knopf `aria-disabled` und nicht `disabled` (AC3): ein gesperrter
* Knopf bekaeme keine Zeigerereignisse und koennte sich nicht erklaeren. Was
* hier gemessen wird, ist also der Weg, den ein Leser wirklich geht.
*/
async function clickDespiteAriaDisabled(page, selector) {
await page.dispatchEvent(selector, 'click');
await page.waitForTimeout(450);
}
/**
* Ein Beweisbild im Ruhezustand.
*
* Wie in smoke-w9, plus einer Zeile mehr: der Zeiger geht ZUERST aus dem Weg.
* Er bleibt nach einem Klick liegen, wo er zuletzt war, und ein Kasten, der
* dort aufgeht, steht im Bild ueber dem Text, den das Bild beweisen soll. Der
* erste Anlauf dieses Laufs hatte genau das: der Tooltip des aktiven Chips lag
* ueber der Kopfzeile, die die Herkunft der Wurzel nennt. Dass keiner mehr
* offen ist, wird gemessen und steht am Bild.
*/
async function shootAtRest(page, file, name) {
await closeTooltips(page);
await page.mouse.move(1, 1);
await page.waitForTimeout(250);
await resetScroll(page, READABILITY_EXCLUSIONS);
await page.waitForTimeout(350);
const state = await scrollState(page);
const openHints = await page.evaluate(() =>
document.querySelectorAll('[data-testid="atlas-hint"]').length);
await page.screenshot({ path: file, fullPage: false });
log(`${name}: aufgenommen im Ruhezustand=${state.atRest}, offene Kaesten=${openHints}`);
return { name, atRest: state.atRest, openHints, regions: state.regions };
}
async function main() {
const totalStarted = Date.now();
let serverChild = null;
let proxy = null;
let browser = null;
let home = null;
let runtimeDir = null;
let serverPort = 0;
let uiPort = 0;
let failure = null;
const timings = {};
const report = {
/* AC1 */
splitterTooltips: -1,
splitterKeyboardStillWorks: false,
splitterAriaKept: false,
splitterCount: 0,
/* AC2 */
toggleCollapsesActive: false,
toggleOpensFromCollapsed: false,
toggleSwitchesView: false,
toggleAgreesWithLabelledButton: false,
/* AC3 */
hierarchyFromFocus: false,
hierarchyHeadNamesRoot: false,
hierarchyDisabledExplains: false,
hierarchyDeterminismUnchanged: false,
/* AC4 */
previewFlowDocumented: false,
previewBundleCheckWorks: false,
/* AC5 */
graphFitsOnOpen: false,
allNodesInsideViewport: false,
fitMarginPx: -1,
cameraOnLargestFace: false,
refitControlWorks: false,
resetLayoutRefits: false,
fitMeasuredInSizes: 0,
fitMeasurements: 0,
nodesOutsideBeforeRefit: 0,
bigGraphNodes: 0,
bigGraphFits: false,
bigGraphMarginPx: -1,
/* Ruhe und Lesbarkeit */
overlapViolations: 0,
clippingViolations: 0,
cutWithoutHint: 0,
screenshotsAtRest: false,
port: 0,
leftoverProcesses: 0,
};
const extras = {
blockedRequests: [],
consoleErrors: [],
pageErrors: [],
readability: [],
fits: [],
shots: [],
toggle: [],
separators: [],
};
/* Der Schalter fuer die synthetische Layout-Antwort. Siehe Kopf. */
let bigLayout = null;
try {
if (!existsSync(BINARY)) {
throw new Error(`Binary fehlt: ${BINARY} (erst 'make -f Makefile.cbm cbm-with-ui' im cbm-Clone bauen)`);
}
if (!existsSync(FIXTURE)) {
throw new Error(`Fixture fehlt: ${FIXTURE}`);
}
// ------------------------------------------------------------ 1. Bau
log('npm run build');
const buildStarted = Date.now();
const build = await run('npm', ['run', 'build']);
timings.buildMs = Date.now() - buildStarted;
if (build.code !== 0) {
throw new Error(`npm run build endete mit ${build.code}: ${build.out.trim().slice(-600)}`);
}
// ---------------------------------------------- 2. HOME, Rendezvous
home = await mkdtemp(join(tmpdir(), 'codeatlasweb-w10b-home-'));
runtimeDir = await mkdtemp('/private/tmp/codeatlasweb-w10b-run-');
process.env.CBM_RUNTIME_DIR = runtimeDir;
log('isoliertes HOME:', home);
// -------------------------------------------------------- 3. Index
const indexed = await indexRepository(BINARY, { home, repoPath: FIXTURE, project: PROJECT });
extras.indexed = { nodes: indexed.nodes, edges: indexed.edges };
log(`indiziert: ${indexed.nodes} Knoten, ${indexed.edges} Kanten`);
// ------------------------------------------------- 4. Server, Proxy
serverPort = await findFreePort(MIN_PORT);
const started = await startServer(BINARY, { home, port: serverPort, log: serverLog });
serverChild = started.child;
uiPort = await findFreePort(MIN_PORT, [serverPort]);
proxy = await startStaticProxy({ distDir: DIST, upstreamPort: serverPort, port: uiPort });
report.port = uiPort;
extras.serverPort = serverPort;
log(`C-Server auf ${serverPort}, dist/ auf ${uiPort}`);
/*
* Das echte Layout, unabhaengig von der Oberflaeche geholt.
*
* Aus DIESEN Positionen rechnet der Lauf gleich seine eigenen
* Hauptachsen. Die Oberflaeche liest dieselbe Route, aber der Vergleich
* darf nicht ueber Zahlen laufen, die sie selbst gemeldet hat.
*/
const layoutUrl = `http://127.0.0.1:${uiPort}/api/layout?project=${PROJECT}&max_nodes=5000`;
const layoutResponse = await fetch(layoutUrl, { headers: { Accept: 'application/json' } });
if (!layoutResponse.ok) {
throw new Error(`/api/layout antwortete mit HTTP ${layoutResponse.status}`);
}
const layout = await layoutResponse.json();
const layoutPoints = (layout.nodes ?? []).map((node) => ({
x: Number(node.x), y: Number(node.y), z: Number(node.z),
}));
const layoutAxes = principalAxes(layoutPoints);
extras.layout = {
url: `/api/layout?project=${PROJECT}&max_nodes=5000`,
nodes: layoutPoints.length,
edges: (layout.edges ?? []).length,
extents: layoutAxes === null ? null : {
widest: Number(layoutAxes.widest.extent.toFixed(2)),
middle: Number(layoutAxes.middle.extent.toFixed(2)),
thinnest: Number(layoutAxes.thinnest.extent.toFixed(2)),
},
thinnestAxis: layoutAxes === null ? null : layoutAxes.thinnest.axis,
};
log(`/api/layout: ${layoutPoints.length} Knoten, Ausdehnungen `
+ `${JSON.stringify(extras.layout.extents)}`);
// ------------------------------------------------------- 5. Browser
const { chromium } = await import('playwright');
browser = await chromium.launch({ headless: true, args: CHROMIUM_ARGS });
const context = await browser.newContext({ viewport: { ...VIEWPORTS[0] } });
const origin = `http://127.0.0.1:${uiPort}`;
await context.route('**/*', async (route) => {
const url = route.request().url();
/*
* Die synthetische Antwort geht durch DIESELBE Route wie die echte,
* und nur, solange der Lauf sie eingeschaltet hat. Sie ist erzeugt
* und nicht indiziert; das steht so im Artefakt.
*/
if (bigLayout !== null && url.startsWith(`${origin}/api/layout`)) {
await route.fulfill({
status: 200,
contentType: 'application/json; charset=utf-8',
body: bigLayout,
});
return;
}
if (url.startsWith(origin) || url.startsWith('data:') || url.startsWith('blob:')) {
await route.continue();
return;
}
extras.blockedRequests.push(url);
await route.abort();
});
const page = await context.newPage();
page.on('console', (message) => {
if (message.type() === 'error') {
extras.consoleErrors.push(message.text());
}
});
page.on('pageerror', (error) => extras.pageErrors.push(String(error)));
await mkdir(OUT_DIR, { recursive: true });
const readability = async (name) => {
const top = await measureReadability(page, READABILITY_EXCLUSIONS);
const scrolled = await scrollRegionsToEnd(page, READABILITY_EXCLUSIONS);
await page.waitForTimeout(200);
const bottom = await measureReadability(page, READABILITY_EXCLUSIONS);
await resetScroll(page, READABILITY_EXCLUSIONS);
extras.readability.push({
name,
scrolledRegions: scrolled.length,
top: { candidates: top.candidates, overlaps: top.overlaps, clipped: top.clipped },
bottom: { candidates: bottom.candidates, overlaps: bottom.overlaps, clipped: bottom.clipped },
});
report.overlapViolations += top.overlaps.length + bottom.overlaps.length;
report.clippingViolations += top.clipped.length + bottom.clipped.length;
report.cutWithoutHint += [...top.clipped, ...bottom.clipped]
.filter((entry) => entry.kind === 'cut-without-hint').length;
};
/** Einmal messen, aufschreiben und zurueckgeben. */
const measureFit = async (where, extra = {}) => {
await nudge(page);
await page.waitForTimeout(250);
const seen = await fitMeasure(page);
const seam = await galaxySeam(page);
const entry = {
where,
...extra,
mode: seam?.mode ?? '',
fits: seam?.fits ?? -1,
lastFit: seam?.lastFit ?? null,
measured: seen,
};
extras.fits.push(entry);
report.fitMeasurements += 1;
log(`Einpassung ${where}: ${seen?.inside ?? -1} von ${seen?.nodes ?? -1} im Bild, `
+ `Rand ${seen?.marginPx ?? -1} px, Fuellung `
+ `${seen?.fill?.horizontal ?? -1}x${seen?.fill?.vertical ?? -1}`);
return entry;
};
await openApp(page, origin);
// ---------------------------------- 5a. Die Griffe, im Ruhezustand
const handles = await separators(page);
extras.separators = handles;
report.splitterCount = handles.length;
report.splitterTooltips = handles.filter((handle) =>
handle.hint.length > 0 || handle.title.length > 0 || handle.describedBy.length > 0).length;
report.splitterAriaKept = handles.length === 4
&& handles.every((handle) =>
handle.label.length > 0
&& /\d+\s*pixels/.test(handle.valueText)
&& handle.valueNow.length > 0
&& handle.valueMin.length > 0
&& handle.valueMax.length > 0);
extras.hintsInDocument = await hintCount(page);
log(`Griffe: ${handles.length}, davon mit Kasten: ${report.splitterTooltips}, `
+ `ARIA vollstaendig: ${report.splitterAriaKept}, `
+ `Tooltips im Dokument insgesamt: ${extras.hintsInDocument}`);
/*
* Die Faehigkeit, die NICHT entfernt wurde.
*
* Gemessen an der Zahl, die der Griff selbst meldet, und an der Breite,
* die die Zone danach wirklich hat: ein `aria-valuenow`, das sich
* bewegt, waehrend nichts breiter wird, waere eine Anzeige und keine
* Bedienung.
*/
const widthOfExplorer = () => page.evaluate(() => {
const node = document.querySelector('[data-testid="atlas-tree"]');
return node === null ? -1 : Math.round(node.getBoundingClientRect().width);
});
const valueOf = () => page.evaluate(() => Number(
document.querySelector('[data-testid="atlas-split-left"]')?.getAttribute('aria-valuenow') ?? '-1'));
await page.focus('[data-testid="atlas-split-left"]');
const keyBefore = { value: await valueOf(), width: await widthOfExplorer() };
await page.keyboard.press('ArrowRight');
await page.waitForTimeout(160);
const afterStep = { value: await valueOf(), width: await widthOfExplorer() };
await page.keyboard.press('Shift+ArrowRight');
await page.waitForTimeout(160);
const afterBigStep = { value: await valueOf(), width: await widthOfExplorer() };
await page.keyboard.press('ArrowLeft');
await page.keyboard.press('Shift+ArrowLeft');
await page.waitForTimeout(200);
const afterBack = { value: await valueOf(), width: await widthOfExplorer() };
extras.keyboard = { keyBefore, afterStep, afterBigStep, afterBack };
report.splitterKeyboardStillWorks =
afterStep.value > keyBefore.value
&& afterBigStep.value - afterStep.value > afterStep.value - keyBefore.value
&& afterStep.width > keyBefore.width
&& afterBack.value === keyBefore.value;
log(`Tastatur am Griff: ${JSON.stringify(extras.keyboard)} -> `
+ `${report.splitterKeyboardStillWorks}`);
await readability('Ruhezustand, Griffe ohne Kasten');
extras.shots.push(await shootAtRest(page, SHOT_HANDLES, 'handles.png'));
// --------------------------- 5b. Der graue Knopf sagt, was ihm fehlt
const beforeFocus = await viewToggle(page);
extras.toggle.push({ where: 'ohne Fokus', state: beforeFocus });
const hierarchyChipBefore = beforeFocus?.chips.find((chip) => chip.mode === 'hierarchy');
await clickDespiteAriaDisabled(
page,
'[data-testid="atlas-graph-mode-chip"][data-mode="hierarchy"]',
);
const noteAfterDisabledClick = await noteText(page);
const stillGalaxy = (await viewToggle(page))?.mode === 'galaxy';
report.hierarchyDisabledExplains =
hierarchyChipBefore !== undefined
&& hierarchyChipBefore.ariaDisabled === 'true'
&& hierarchyChipBefore.available === false
&& /open a symbol|pick a way in/i.test(hierarchyChipBefore.hint)
&& /open a symbol|pick a way in/i.test(noteAfterDisabledClick)
&& stillGalaxy;
extras.disabledChip = { chip: hierarchyChipBefore, note: noteAfterDisabledClick, stillGalaxy };
log(`grauer hierarchy-Knopf erklaert sich: ${report.hierarchyDisabledExplains} `
+ `("${noteAfterDisabledClick}")`);
// ----------------------- 5c. Die Einpassung beim Oeffnen, drei Groessen
const sizesSeen = new Set();
const openFits = [];
for (const viewport of VIEWPORTS) {
await page.setViewportSize(viewport);
await page.waitForTimeout(900);
const entry = await measureFit(`galaxy ${viewport.width}x${viewport.height}`, {
viewport,
view: 'galaxy',
atOpen: true,
});
openFits.push(entry);
sizesSeen.add(`${viewport.width}x${viewport.height}`);
}
await page.setViewportSize(VIEWPORTS[0]);
await page.waitForTimeout(700);
/*
* Die Ausrichtung, gegen die EIGENE Rechnung des Laufs gehalten.
*
* `direction` ist die Blickrichtung, die die Szene gemeldet hat;
* `layoutAxes.thinnest` ist die duennste Achse der Wolke, aus den
* Positionen der Layout-Antwort selbst gerechnet. Stimmen sie ueberein,
* sieht die Kamera die duenne Richtung entlang, also auf die groesste
* Flaeche.
*/
const alignments = openFits.map((entry) => {
const direction = entry.measured?.camera?.direction ?? [0, 0, 0];
return {
where: entry.where,
toThinnest: layoutAxes === null ? -1
: Number(alignment(direction, layoutAxes.thinnest.axis).toFixed(4)),
toWidest: layoutAxes === null ? -1
: Number(alignment(direction, layoutAxes.widest.axis).toFixed(4)),
};
});
extras.alignment = { measured: alignments, method: 'eigene Jacobi-Rechnung, siehe principalAxes' };
report.cameraOnLargestFace = alignments.length === VIEWPORTS.length
&& alignments.every((entry) => entry.toThinnest > 0.99 && entry.toWidest < 0.1);
log(`Kamera auf der groessten Flaeche: ${report.cameraOnLargestFace} `
+ `(${JSON.stringify(alignments)})`);
// -------------------------- 5d. Die Hierarchie aus dem Symbol im Fokus
await openSymbol(page, FOCUS_TARGET, FOCUS_FILE);
await page.waitForFunction(
() => globalThis.__atlasGalaxy?.hierarchyAvailable === true,
undefined,
{ timeout: 60000 },
);
const withFocus = await viewToggle(page);
extras.toggle.push({ where: 'mit Fokus, vor dem Umschalten', state: withFocus });
const seamWithFocus = await galaxySeam(page);
// Ein Fokus macht die Hierarchie moeglich und waehlt sie nicht.
const stayedInGalaxy = seamWithFocus?.mode === 'galaxy';
await clickChip(page, 'hierarchy');
await page.waitForTimeout(900);
const hierarchySeam = await galaxySeam(page);
const hierarchyHead = await headline(page);
report.hierarchyFromFocus =
stayedInGalaxy
&& hierarchySeam?.mode === 'hierarchy'
&& hierarchySeam?.hierarchyOrigin === 'focus'
&& (hierarchySeam?.hierarchy?.nodes ?? 0) > 1
&& hierarchySeam?.hierarchy?.rootName === FOCUS_TARGET;
/*
* Gemessen wird nicht nur, dass der Satz die Herkunft NENNT, sondern
* auch, dass sie in der Spalte zu LESEN ist: diese Zeile bricht nicht
* um und endet in einem Auslassungszeichen. Ein Kopf, der die Auskunft
* hinter der Kante traegt, hat sie nicht gegeben.
*/
const headClipped = await page.evaluate(() => {
const node = document.querySelector('[data-testid="atlas-galaxy-headline"]');
if (node === null) {
return { clipped: true, visibleChars: 0 };
}
const style = globalThis.getComputedStyle(node);
const perChar = node.scrollWidth / Math.max(1, (node.textContent ?? '').length);
return {
clipped: node.scrollWidth > node.clientWidth + 1,
visibleChars: Math.floor(node.clientWidth / Math.max(1, perChar)),
fontSize: style.fontSize,
};
});
extras.headline = { text: hierarchyHead, ...headClipped };
report.hierarchyHeadNamesRoot =
/hierarchy of createUser \(in focus\)/.test(hierarchyHead)
&& hierarchyHead.indexOf('in focus') < headClipped.visibleChars;
extras.hierarchy = {
stayedInGalaxy,
origin: hierarchySeam?.hierarchyOrigin ?? '',
headline: hierarchyHead,
nodes: hierarchySeam?.hierarchy?.nodes ?? 0,
depth: hierarchySeam?.hierarchy?.depth ?? 0,
root: hierarchySeam?.hierarchy?.root ?? '',
placements: hierarchySeam?.hierarchy?.placements ?? [],
};
log(`Hierarchie aus dem Fokus: ${report.hierarchyFromFocus}, Kopf nennt die Herkunft: `
+ `${report.hierarchyHeadNamesRoot} ("${hierarchyHead}")`);
/*
* Der Determinismus der Projektion, an denselben drei Fragen wie in
* W9: die Spalte ist der Hop mal einer festen Breite, in einer Spalte
* stehen die Namen ordinal sortiert, und jedes Symbol jenseits der
* Wurzel wird von einer Walk-Kante aus der Spalte davor erreicht.
* Dazu die vierte: zweimal dasselbe Bild ergibt zweimal dieselben Orte.
*/
const placements = extras.hierarchy.placements;
const walkEdges = hierarchySeam?.hierarchy?.edges ?? [];
const hopOf = new Map(placements.map((placement) => [placement.key, placement.hop]));
const columnWidth = placements.find((placement) => placement.hop === 1)?.x ?? 0;
const columnsOk = columnWidth > 0
&& placements.every((placement) => placement.x === placement.hop * columnWidth);
const sortedOk = [...new Set(placements.map((placement) => placement.hop))].every((hop) => {
const level = placements.filter((placement) => placement.hop === hop);
const names = level.map((placement) => `${placement.name} ${placement.key}`);
return JSON.stringify(names) === JSON.stringify([...names].sort());
});
const reachedByWalk = placements.every((placement) => {
if (placement.hop === 0) {
return true;
}
return walkEdges.some((edge) =>
edge.to === placement.key && (hopOf.get(edge.from) ?? -1) === placement.hop - 1);
});
await clickChip(page, 'galaxy');
await clickChip(page, 'hierarchy');
await page.waitForTimeout(700);
const again = await galaxySeam(page);
const sameTwice = JSON.stringify(again?.hierarchy?.placements ?? [])
=== JSON.stringify(placements);
report.hierarchyDeterminismUnchanged =
placements.length > 1 && columnsOk && sortedOk && reachedByWalk && sameTwice;
extras.determinism = { columnWidth, columnsOk, sortedOk, reachedByWalk, sameTwice };
log(`Determinismus der Projektion: ${report.hierarchyDeterminismUnchanged} `
+ `${JSON.stringify(extras.determinism)}`);
// Die Einpassung in der zweiten Ansicht, wieder in drei Groessen.
for (const viewport of VIEWPORTS) {
await page.setViewportSize(viewport);
await page.waitForTimeout(900);
await measureFit(`hierarchy ${viewport.width}x${viewport.height}`, {
viewport,
view: 'hierarchy',
atOpen: true,
});
sizesSeen.add(`${viewport.width}x${viewport.height}`);
}
await page.setViewportSize(VIEWPORTS[0]);
await page.waitForTimeout(700);
report.fitMeasuredInSizes = sizesSeen.size;
await readability('Hierarchie aus dem Fokus');
extras.shots.push(await shootAtRest(page, SHOT_HIERARCHY, 'hierarchy-from-focus.png'));
// -------------------------- 5e. Der Ansichts-Schalter klappt (AC2)
const stateBeforeCollapse = await viewToggle(page);
await clickChip(page, 'hierarchy');
const collapsedByChip = await viewToggle(page);
report.toggleCollapsesActive =
stateBeforeCollapse?.visible === 'true'
&& collapsedByChip?.visible === 'false'
&& collapsedByChip?.mode === 'hierarchy';
extras.toggle.push({ where: 'nach Klick auf den aktiven Chip', state: collapsedByChip });
log(`aktiver Chip klappt zu: ${report.toggleCollapsesActive}`);
await readability('Graph zugeklappt');
extras.shots.push(await shootAtRest(page, SHOT_COLLAPSED, 'graph-collapsed.png'));
await clickChip(page, 'galaxy');
const openedByChip = await viewToggle(page);
report.toggleOpensFromCollapsed =
openedByChip?.visible === 'true' && openedByChip?.mode === 'galaxy';
extras.toggle.push({ where: 'nach Klick bei zugeklappter Sektion', state: openedByChip });
log(`Chip klappt auf und waehlt: ${report.toggleOpensFromCollapsed}`);
await clickChip(page, 'hierarchy');
const switched = await viewToggle(page);
report.toggleSwitchesView =
switched?.visible === 'true'
&& switched?.mode === 'hierarchy'
&& switched.chips.filter((chip) => chip.pressed === 'true').length === 1;
extras.toggle.push({ where: 'nach Klick auf den anderen Chip', state: switched });
log(`der andere Chip wechselt: ${report.toggleSwitchesView}`);
/*
* Beide Wege, derselbe Zustand.
*
* Erst ueber den beschrifteten Schalter zu und wieder auf, dann ueber
* den Chip zu und wieder auf. Verglichen wird, was danach dasteht:
* dieselbe Sichtbarkeit, dieselbe Ansicht, dieselbe Beschriftung am
* Schalter. Zwei Wege in eine Lage, die sich unterscheidet, waeren zwei
* Wahrheiten ueber denselben Zustand.
*/
await page.click('[data-testid="atlas-galaxy-collapse"]');
await page.waitForTimeout(400);
const closedByLabel = await viewToggle(page);
await page.click('[data-testid="atlas-galaxy-collapse"]');
await page.waitForTimeout(500);
const openedByLabel = await viewToggle(page);
await clickChip(page, 'hierarchy');
const closedByChip = await viewToggle(page);
await clickChip(page, 'hierarchy');
const openedAgainByChip = await viewToggle(page);
const sameState = (a, b) => a !== null && b !== null
&& a.visible === b.visible && a.mode === b.mode
&& a.foldLabel === b.foldLabel && a.foldExpanded === b.foldExpanded
&& JSON.stringify(a.chips.map((chip) => [chip.mode, chip.pressed, chip.action]))
=== JSON.stringify(b.chips.map((chip) => [chip.mode, chip.pressed, chip.action]));
report.toggleAgreesWithLabelledButton =
sameState(closedByLabel, closedByChip) && sameState(openedByLabel, openedAgainByChip);
extras.toggle.push({ where: 'zwei Wege', closedByLabel, closedByChip, openedByLabel, openedAgainByChip });
log(`beide Wege ergeben denselben Zustand: ${report.toggleAgreesWithLabelledButton}`);
// --------------------------- 5f. Verdrehen, "fit view", "reset layout"
await clickChip(page, 'galaxy');
await page.waitForTimeout(700);
await measureFit('galaxy nach dem Aufklappen', { view: 'galaxy' });
const rect = await sceneRect(page);
extras.sceneRect = rect;
if (rect === null) {
throw new Error('die Zeichenflaeche hat kein Rechteck');
}
const cx = rect.x + Math.round(rect.width / 2);
const cy = rect.y + Math.round(rect.height / 2);
await page.mouse.move(cx, cy);
await page.mouse.down();
await page.mouse.move(cx + 260, cy - 190, { steps: 14 });
await page.mouse.up();
await page.waitForTimeout(600);
/*
* Ein Radereignis ist EIN Schritt, egal wie gross sein Weg ist
* (OrbitControls fragt nur nach dem Vorzeichen). Also zwoelf davon:
* jeder holt die Kamera um rund sieben Prozent naeher, zusammen auf gut
* die Haelfte, und damit liegt die Wolke sicher ausserhalb des Bildes.
*/
await page.mouse.move(cx, cy);
for (let notch = 0; notch < 12; notch += 1) {
await page.mouse.wheel(0, -120);
await page.waitForTimeout(60);
}
await page.waitForTimeout(1400);
const turned = await measureFit('nach dem Verdrehen und Heranzoomen', {
view: 'galaxy',
turned: true,
});
report.nodesOutsideBeforeRefit = turned.measured?.outside ?? 0;
await page.click('[data-testid="atlas-galaxy-fit"]');
await page.waitForTimeout(900);
const refitted = await measureFit('nach "fit view"', { view: 'galaxy' });
report.refitControlWorks =
report.nodesOutsideBeforeRefit > 0
&& (refitted.measured?.outside ?? -1) === 0
&& (refitted.measured?.marginPx ?? -1) > 0;
log(`vor der Einpassung ausserhalb: ${report.nodesOutsideBeforeRefit}, `
+ `Knopf bringt zurueck: ${report.refitControlWorks}`);
/* Und derselbe Weg ueber "reset layout" (alt+r). */
await page.mouse.move(cx, cy);
await page.mouse.down();
await page.mouse.move(cx - 300, cy + 160, { steps: 12 });
await page.mouse.up();
await page.waitForTimeout(500);
// Zurueck in die Mitte der Szene, BEVOR gescrollt wird: ein Radereignis
// geht an das Element unter dem Zeiger, und der stand nach dem Zug am
// Rand der Zeichenflaeche.
await page.mouse.move(cx, cy);
for (let notch = 0; notch < 12; notch += 1) {
await page.mouse.wheel(0, -120);
await page.waitForTimeout(60);
}
await page.waitForTimeout(1200);
const turnedAgain = await measureFit('vor "reset layout"', { view: 'galaxy', turned: true });
await page.keyboard.press('Alt+r');
await page.waitForTimeout(1100);
const afterReset = await measureFit('nach "reset layout"', { view: 'galaxy' });
/*
* Zwei Arten, die Ansicht zu verlieren, und beide zaehlen.
*
* Ein Zug kann Knoten aus dem Bild schieben, und er kann die Kamera in
* die duenne Richtung drehen: dann ist alles noch im Bild und trotzdem
* nichts mehr zu sehen ("mich nervt, dass die Galaxy manchmal einfach
* flach ist"). Der Nachweis verlangt darum, dass die Ansicht vorher in
* EINER der beiden Weisen verloren war und danach in BEIDEN wieder da
* ist: jeder Knoten im Bild UND die Kamera wieder senkrecht auf der
* groessten Flaeche.
*/
const facing = (entry) => (layoutAxes === null ? -1 : Number(alignment(
entry.measured?.camera?.direction ?? [0, 0, 0],
layoutAxes.thinnest.axis,
).toFixed(4)));
extras.reset = {
outsideBefore: turnedAgain.measured?.outside ?? -1,
facingBefore: facing(turnedAgain),
fillBefore: turnedAgain.measured?.fill ?? null,
outsideAfter: afterReset.measured?.outside ?? -1,
facingAfter: facing(afterReset),
fillAfter: afterReset.measured?.fill ?? null,
};
report.resetLayoutRefits =
((turnedAgain.measured?.outside ?? 0) > 0 || extras.reset.facingBefore < 0.9)
&& (afterReset.measured?.outside ?? -1) === 0
&& extras.reset.facingAfter > 0.99;
log(`"reset layout" passt wieder ein: ${report.resetLayoutRefits} `
+ `${JSON.stringify(extras.reset)}`);
// ------------------------------ 5g. Dieselbe Messung mit 5000 Knoten
bigLayout = JSON.stringify(syntheticLayout());
await openApp(page, origin);
await page.waitForTimeout(1200);
const bigSeam = await galaxySeam(page);
const bigFit = await measureFit('galaxy mit 5000 Knoten (synthetisch)', {
view: 'galaxy',
synthetic: true,
});
report.bigGraphNodes = bigFit.measured?.nodes ?? 0;
report.bigGraphMarginPx = bigFit.measured?.marginPx ?? -1;
report.bigGraphFits =
report.bigGraphNodes >= BIG_NODES
&& (bigFit.measured?.outside ?? -1) === 0
&& (bigFit.measured?.behind ?? -1) === 0
&& report.bigGraphMarginPx > 0;
extras.bigGraph = {
note:
'Die Antwort ist ERZEUGT und nicht indiziert: 5000 Knoten, 5209 Kanten, 17 '
+ 'Kantenarten, eine gedrehte Scheibe. Sie kommt ueber dieselbe Route in dieselbe '
+ 'Oberflaeche wie eine echte Antwort. Gemessen wird die Einpassung, nicht der Index.',
nodes: BIG_NODES,
edges: BIG_EDGES,
kinds: BIG_KINDS,
seamNodes: bigSeam?.nodes ?? 0,
lastFit: bigFit.lastFit,
};
const bigAxes = principalAxes(JSON.parse(bigLayout).nodes);
const bigDirection = bigFit.measured?.camera?.direction ?? [0, 0, 0];
extras.bigGraph.alignmentToThinnest = bigAxes === null ? -1
: Number(alignment(bigDirection, bigAxes.thinnest.axis).toFixed(4));
log(`5000 Knoten: ${report.bigGraphNodes} gemessen, ausserhalb `
+ `${bigFit.measured?.outside ?? -1}, Rand ${report.bigGraphMarginPx} px, `
+ `Ausrichtung ${extras.bigGraph.alignmentToThinnest}`);
await readability('5000 Knoten, eingepasst');
bigLayout = null;
// ---------------------------------- Die Bilanz ueber alle Messungen
const graphFits = extras.fits.filter((entry) => entry.atOpen === true);
report.graphFitsOnOpen = graphFits.length >= 6
&& graphFits.every((entry) => (entry.measured?.outside ?? -1) === 0
&& (entry.measured?.behind ?? -1) === 0);
/*
* Alles, was NICHT absichtlich verdreht wurde. Die beiden verdrehten
* Messungen sind der Gegenbeweis (die Messung sieht etwas) und gehoeren
* darum nicht in die Bilanz.
*/
const allFits = extras.fits.filter((entry) => entry.turned !== true);
report.allNodesInsideViewport = allFits.length >= 9 && allFits.every((entry) =>
(entry.measured?.outside ?? -1) === 0 && (entry.measured?.nodes ?? 0) > 0);
report.fitMarginPx = Number(Math.min(...allFits.map((entry) =>
entry.measured?.marginPx ?? -1)).toFixed(2));
log(`alle Knoten im Bild: ${report.allNodesInsideViewport}, kleinster Rand `
+ `${report.fitMarginPx} px ueber ${allFits.length} Messungen`);
// ------------------------- 5h. Der Vorschau-Ablauf, wirklich gefahren
const readme = await readFile(join(ROOT, 'README.md'), 'utf8');
const documented =
/dist/.test(readme)
&& /(neu ?starten|restart)/i.test(readme)
&& /index-/.test(readme)
&& /kopiert/i.test(readme);
/*
* Und die Probe aufs Exempel: der dokumentierte Vergleich, hier
* ausgefuehrt. Dieser Auslieferer bedient dist/ direkt, also MUESSEN die
* beiden Kennungen uebereinstimmen; taeten sie es nicht, waere entweder
* der Bau oder die Anleitung falsch.
*/
const builtBundle = readdirSync(join(DIST, 'assets'))
.filter((name) => /^index-[A-Za-z0-9_-]+\.js$/.test(name))
.sort()[0] ?? '';
const servedHtml = await (await fetch(`${origin}/`)).text();
const servedBundle = (servedHtml.match(/index-[A-Za-z0-9_-]+\.js/) ?? [''])[0];
report.previewBundleCheckWorks = builtBundle.length > 0 && builtBundle === servedBundle;
report.previewFlowDocumented = documented && report.previewBundleCheckWorks;
extras.preview = { builtBundle, servedBundle, documented };
log(`Vorschau-Ablauf dokumentiert: ${documented}, Kennung gebaut ${builtBundle} `
+ `= ausgeliefert ${servedBundle}`);
report.screenshotsAtRest =
extras.shots.length === 3
&& extras.shots.every((shot) => shot.atRest === true && shot.openHints === 0);
extras.apiRoutes = { ...proxy.log.apiRoutes };
extras.rpcTools = { ...proxy.log.rpcTools };
await context.close();
} catch (err) {
failure = err;
console.error('[smoke-w10b] FEHLER:', err.message);
if (serverLog.length > 0) {
console.error('[smoke-w10b] Server-Log (letzte 20 Zeilen):\n' + serverLog.slice(-20).join('\n'));
}
}
if (browser !== null) {
await browser.close().catch(() => undefined);
}
if (proxy !== null) {
await proxy.close();
}
await stopServer(serverChild);
await sleep(600);
/*
* Gezaehlt wird mit Geduld, und die Geduld hat eine Grenze.
*
* Dasselbe Muster wie in smoke-w5b und smoke-w6-full: das Betriebssystem
* gibt einen Port erst nach dem Ende des Prozesses frei, gemessen bis zu
* 1557 ms. Ein einziger Blick faellt genau in dieses Fenster, und der Lauf
* wuerde rot, obwohl nichts mehr laeuft. Wie lange gewartet wurde, steht im
* Artefakt, damit ein langsamer werdender Abbau auffaellt.
*/
const FREE_PORT_TIMEOUT_MS = 5000;
const leftovers = [];
for (const port of [serverPort, uiPort].filter((value) => value > 0)) {
const startedAt = Date.now();
let listeners = await countListeners(port);
while (listeners > 0 && Date.now() - startedAt < FREE_PORT_TIMEOUT_MS) {
await sleep(250);
listeners = await countListeners(port);
}
leftovers.push({ port, listeners, waitedMs: Date.now() - startedAt });
}
extras.leftovers = leftovers;
report.leftoverProcesses = leftovers.reduce((sum, entry) => sum + entry.listeners, 0);
log('leftoverProcesses:', report.leftoverProcesses, JSON.stringify(leftovers));
timings.totalMs = Date.now() - totalStarted;
await mkdir(OUT_DIR, { recursive: true });
await writeFile(
OUT_JSON,
JSON.stringify({
...report,
project: PROJECT,
fixture: 'fixtures/atlas-sample (nur gelesen)',
focusTarget: FOCUS_TARGET,
viewports: VIEWPORTS,
method:
'Die Einpassung wird am BILD gemessen: die Szene projiziert jeden Knoten mit genau '
+ 'der Kamera, die gerade zeichnet, in die Zeichenflaeche (globalThis.__atlasGalaxyFit '
+ 'in src/galaxy/GraphScene.tsx). Gezaehlt werden die Knoten ausserhalb und der '
+ 'kleinste verbleibende Rand in Pixeln. Die AUSRICHTUNG wird unabhaengig geprueft: '
+ 'dieser Lauf rechnet die Hauptachsen der geladenen Positionen selbst (Jacobi, '
+ 'principalAxes in dieser Datei) und haelt die duennste Achse gegen die gemeldete '
+ 'Blickrichtung. Dass die Messung ueberhaupt etwas sieht, wird vorher gezeigt: die '
+ 'Kamera wird mit Zug und Rad verdreht, bis Knoten aus dem Bild fallen.',
timings,
generatedAt: new Date().toISOString(),
error: failure ? failure.message : null,
extras,
}, null, 2) + '\n',
'utf8',
);
log('geschrieben:', OUT_JSON);
const shotsOk = [SHOT_HANDLES, SHOT_HIERARCHY, SHOT_COLLAPSED].every((file) => existsSync(file));
const ok =
failure === null
&& report.splitterCount === 4
&& report.splitterTooltips === 0
&& report.splitterKeyboardStillWorks === true
&& report.splitterAriaKept === true
&& report.toggleCollapsesActive === true
&& report.toggleOpensFromCollapsed === true
&& report.toggleSwitchesView === true
&& report.toggleAgreesWithLabelledButton === true
&& report.hierarchyFromFocus === true
&& report.hierarchyHeadNamesRoot === true
&& report.hierarchyDisabledExplains === true
&& report.hierarchyDeterminismUnchanged === true
&& report.previewFlowDocumented === true
&& report.previewBundleCheckWorks === true
&& report.graphFitsOnOpen === true
&& report.allNodesInsideViewport === true
&& report.fitMarginPx > 0
&& report.cameraOnLargestFace === true
&& report.refitControlWorks === true
&& report.resetLayoutRefits === true
&& report.fitMeasuredInSizes >= 3
&& report.bigGraphFits === true
&& report.overlapViolations === 0
&& report.clippingViolations === 0
&& report.cutWithoutHint === 0
&& report.screenshotsAtRest === true
&& report.port >= MIN_PORT
&& report.leftoverProcesses === 0
&& shotsOk
&& extras.blockedRequests.length === 0
&& extras.pageErrors.length === 0;
if (!ok) {
console.error('[smoke-w10b] W10b-Smoke NICHT gruen.');
if (home) {
console.error('[smoke-w10b] isoliertes HOME bleibt zum Nachsehen liegen:', home);
}
process.exitCode = 1;
return;
}
for (const directory of [home, runtimeDir]) {
if (directory) {
await rm(directory, { recursive: true, force: true });
}
}
log('W10b-Smoke gruen.');
}
main().catch((err) => {
console.error('[smoke-w10b] unerwarteter Fehler:', err);
process.exitCode = 1;
});