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
/*
* W3-Smoke: die Galaxie an einem echten Server, und der Fokus in beide
* Richtungen.
*
* Was hier bewiesen wird, koennen die Unit-Tests nicht beweisen. Sie zeigen an
* erfundenen Knoten, dass ein qualifizierter Name den richtigen Punkt findet,
* dass Nachbarn Nachbarn sind und dass die Rangfolge der Suche dieselbe ist
* wie im Referenzprojekt. Sie sagen nichts darueber, ob dieser Server ein
* Layout liefert, ob ein Browser die Szene ueberhaupt zeichnet, ob ein
* getipptes Wort in der Fusszeile zu einer Liste wird, ob ein Enter darauf die
* Datei oeffnet und die Kamera bewegt, und ob ein Klick in die Galaxie
* zurueckfuehrt in den Reader.
*
* Ablauf, wie bei smoke-w2b:
* 1. `npm run build`
* 2. isoliertes HOME, fixtures/atlas-sample ueber die CLI indizieren
* 3. C-Server auf einem freien Port >= 4250 starten
* 4. dist/ auf einem zweiten Port ausliefern, /rpc und /api dorthin proxen
* (auch /api/layout: die Galaxie holt ihr Layout ueber genau diese Route)
* 5. Chromium ohne Aussenwelt, plus Route-Sperre
* 6. Klickstrecke: Layout abwarten, "createUser" tippen, Enter, dann einen
* Knoten in der Galaxie anklicken
* 7. abraeumen, Restprozesse zaehlen, verification/w3/galaxy.json schreiben
*
* Das Ganze laeuft unter dem Netz-Deny-Gate (npm run smoke:w3).
*
* ## WebGL im Headless-Browser
*
* Headless-Chromium hat keine GPU. Ohne Zutun faellt es auf SwiftShader
* zurueck, und seit Chrome 127 verlangt dieser Rueckfall ein ausdrueckliches
* Flag. Beide Flags stehen unten in CHROMIUM_ARGS und sind der Grund, warum
* dieser Lauf headless bleiben kann: `--use-angle=swiftshader` waehlt den
* Software-Renderer, `--enable-unsafe-swiftshader` erlaubt ihn. Ob er
* wirklich gegriffen hat, wird nicht vermutet, sondern gemessen: der Bericht
* traegt den Renderer-String aus WEBGL_debug_renderer_info und die Zahl der
* nicht schwarzen Pixel des gerenderten Canvas.
*/
import { spawn } from 'node:child_process';
import { existsSync } from 'node:fs';
import { mkdir, mkdtemp, 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 { 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-w3';
const OUT_DIR = join(ROOT, 'verification', 'w3');
const OUT_JSON = join(OUT_DIR, 'galaxy.json');
const MIN_PORT = 4250;
const SEARCH_TERM = 'createUser';
const SERVICE_FILE = 'src/services/userService.ts';
const TARGET_FILE = 'src/util/validate.ts';
/** Das Symbol, auf das in der Galaxie geklickt wird, an seinem Namensende. */
const CLICK_TARGET_SUFFIX = 'validate.validateUser';
/** Ueber die Entprellung der Suche hinaus warten (src/search/find-by-meaning.ts). */
const SEARCH_SETTLE_MS = 600;
/**
* Chromium ohne Aussenwelt. Wortgleich mit smoke-w2b, plus die beiden
* Software-GL-Flags: die Flags sind die Absicht, das Netz-Deny-Gate daneben
* ist der Beweis.
*/
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-w3]', ...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();
process.stdout.write(d);
});
child.stderr.on('data', (d) => {
out += d.toString();
process.stderr.write(d);
});
child.on('error', (error) => done({ code: 127, out: out + error.message }));
child.on('close', (code) => done({ code: code ?? 1, out }));
});
}
/**
* Wie viel auf dem Canvas der Galaxie zu sehen ist.
*
* Die Dateigroesse des Screenshots ist ein Indiz und kein Befund: ein
* schwarzes Bild mit einer vollen Oberflaeche drumherum kann auch gross
* werden. Also wird der Canvas selbst gelesen. `preserveDrawingBuffer` ist
* aus (so kommt die Szene aus der Uebernahme), deshalb wird direkt nach einem
* Frame gelesen: `readPixels` in einem requestAnimationFrame-Rueckruf sieht
* den Puffer, bevor er verworfen wird.
*/
async function canvasBrightness(page) {
return page.evaluate(async () => {
const canvas = document.querySelector('.atlas-galaxy-scene canvas');
if (canvas === null) {
return { found: false };
}
const gl = canvas.getContext('webgl2') ?? canvas.getContext('webgl');
if (gl === null) {
return { found: true, context: false };
}
const debug = gl.getExtension('WEBGL_debug_renderer_info');
const renderer = debug === null ? '' : String(gl.getParameter(debug.UNMASKED_RENDERER_WEBGL));
const width = gl.drawingBufferWidth;
const height = gl.drawingBufferHeight;
const pixels = await new Promise((done) => {
requestAnimationFrame(() => {
const buffer = new Uint8Array(width * height * 4);
gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, buffer);
done(buffer);
});
});
let lit = 0;
let brightest = 0;
for (let i = 0; i < pixels.length; i += 4) {
const value = Math.max(pixels[i], pixels[i + 1], pixels[i + 2]);
if (value > 40) {
lit += 1;
}
if (value > brightest) {
brightest = value;
}
}
return {
found: true,
context: true,
renderer,
width,
height,
litPixels: lit,
brightest,
};
});
}
async function main() {
const totalStarted = Date.now();
let serverChild = null;
let proxy = null;
let browser = null;
let home = null;
let serverPort = 0;
let uiPort = 0;
let failure = null;
const timings = {};
const report = {
searchResultCount: 0,
searchTopNames: [],
enterOpenedFile: '',
twinSubject: '',
twinSubjectAfterClick: '',
flyToCount: 0,
clickOpenedFile: '',
highlightedCount: 0,
layoutNodes: 0,
layoutSource: '/api/layout',
port: 0,
leftoverProcesses: 0,
};
const extras = { blockedRequests: [], consoleErrors: [], pageErrors: [] };
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}`);
}
if (!existsSync(join(DIST, 'index.html'))) {
throw new Error('dist/index.html fehlt nach dem Build');
}
// -------------------------------------------------------- 2. Index
home = await mkdtemp(join(tmpdir(), 'codeatlasweb-w3-home-'));
log('isoliertes HOME:', home);
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`);
// -------------------------------------------------------- 3. Server
serverPort = await findFreePort(MIN_PORT);
const started = await startServer(BINARY, { home, port: serverPort, log: serverLog });
serverChild = started.child;
timings.serverStartMs = started.durationMs;
log(`C-Server bereit auf ${serverPort} nach ${started.durationMs} ms`);
// --------------------------------------------------------- 4. Proxy
uiPort = await findFreePort(MIN_PORT, [serverPort]);
proxy = await startStaticProxy({ distDir: DIST, upstreamPort: serverPort, port: uiPort });
report.port = uiPort;
extras.serverPort = serverPort;
log(`dist/ liegt auf ${uiPort}, /rpc und /api gehen nach ${serverPort}`);
// ------------------------------------------------------- 5. Browser
const { chromium } = await import('playwright');
browser = await chromium.launch({ headless: true, args: CHROMIUM_ARGS });
const context = await browser.newContext({ viewport: { width: 1680, height: 1050 } });
const origin = `http://127.0.0.1:${uiPort}`;
await context.route('**/*', async (route) => {
const url = route.request().url();
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)));
// ------------------------------------------- 6a. Layout abwarten
await page.goto(`${origin}/?project=${PROJECT}`, { waitUntil: 'load' });
await page.waitForSelector('[data-testid="atlas-galaxy"]', { timeout: 20000 });
await page.waitForFunction(() => (globalThis.__atlasGalaxy?.nodes ?? 0) >= 50, undefined, {
timeout: 30000,
});
report.layoutNodes = await page.evaluate(() => globalThis.__atlasGalaxy?.nodes ?? 0);
extras.galaxyHeadline = await page.evaluate(
() =>
document.querySelector('[data-testid="atlas-galaxy-headline"]')?.textContent?.trim() ?? '',
);
log(`Layout geladen: ${report.layoutNodes} Knoten`);
// Ein paar Frames Zeit, damit die Szene wirklich gezeichnet ist,
// bevor sie fotografiert und vermessen wird.
await page.waitForTimeout(1200);
extras.canvas = await canvasBrightness(page);
log('Canvas:', JSON.stringify(extras.canvas));
await mkdir(OUT_DIR, { recursive: true });
await page.screenshot({ path: join(OUT_DIR, 'galaxy.png'), fullPage: true });
log('galaxy.png geschrieben (Galaxie ohne Auswahl, ganze Wolke)');
// ------------------------------------------------ 6b. Suche tippen
const commandInput = page.locator('[data-testid="atlas-command-input"]');
await commandInput.click();
await commandInput.pressSequentially(SEARCH_TERM, { delay: 40 });
await page.waitForSelector('[data-testid="atlas-search-results"]', { timeout: 10000 });
await page.waitForFunction(
() => document.querySelectorAll('[data-testid="atlas-search-row"]').length > 0,
undefined,
{ timeout: 20000 },
);
// Ueber die Entprellung hinaus warten, damit die Liste die fertige ist
// und nicht die eines halb getippten Wortes.
await page.waitForTimeout(SEARCH_SETTLE_MS);
report.searchTopNames = await page.evaluate(() =>
[...document.querySelectorAll('[data-testid="atlas-search-row"]')].map(
(node) => node.getAttribute('data-name') ?? '',
),
);
report.searchResultCount = report.searchTopNames.length;
extras.searchHeadline = await page.evaluate(
() =>
document.querySelector('[data-testid="atlas-search-headline"]')?.textContent?.trim() ?? '',
);
extras.searchRows = await page.evaluate(() =>
[...document.querySelectorAll('[data-testid="atlas-search-row"]')].map((node) =>
(node.textContent ?? '').replace(/\s+/g, ' ').trim(),
),
);
log(`Suchtreffer: ${report.searchTopNames.join(', ')}`);
await page.screenshot({ path: join(OUT_DIR, 'search.png'), fullPage: true });
log('search.png geschrieben (Overlay offen)');
// Wieviel Kamerafahrt es vor dem Enter gab. Ohne diese Zahl waere
// "es ist geflogen" nicht von "es war schon da" zu unterscheiden.
extras.flyToBeforeEnter = await page.evaluate(
() => globalThis.__atlasGalaxy?.targetChanges ?? 0,
);
// ----------------------------------------------------- 6c. Enter
await page.keyboard.press('Enter');
await page.waitForFunction(
() => globalThis.__atlasReader?.document?.path === 'src/services/userService.ts',
undefined,
{ timeout: 20000 },
);
await page.waitForFunction(
() => /userService\.createUser$/.test(globalThis.__atlasTwin?.qualifiedName ?? ''),
undefined,
{ timeout: 30000 },
);
await page.waitForFunction(
(before) => (globalThis.__atlasGalaxy?.targetChanges ?? 0) > before,
extras.flyToBeforeEnter,
{ timeout: 20000 },
);
const afterEnter = await page.evaluate(() => ({
breadcrumb: (document.querySelector('[data-testid="atlas-breadcrumb"]')?.textContent ?? '')
.replace(/\s+/g, ' ')
.trim(),
tabs: [...document.querySelectorAll('.atlas-tab')].map((node) => node.getAttribute('data-path')),
readerPath: globalThis.__atlasReader?.document?.path ?? '',
twin: globalThis.__atlasTwin?.qualifiedName ?? '',
twinName: globalThis.__atlasTwin?.symbol ?? '',
targetChanges: globalThis.__atlasGalaxy?.targetChanges ?? 0,
highlightedCount: globalThis.__atlasGalaxy?.highlightedCount ?? 0,
lastTargetQn: globalThis.__atlasGalaxy?.lastTargetQn ?? '',
commandValue: document.querySelector('[data-testid="atlas-command-input"]')?.value ?? '',
overlayGone: document.querySelector('[data-testid="atlas-search-results"]') === null,
}));
extras.afterEnter = afterEnter;
// Die geoeffnete Datei wird an zwei Stellen gelesen und nur dann
// gemeldet, wenn beide dasselbe sagen: die Breadcrumb ist das, was der
// Leser sieht, der Tab das, was die Anwendung fuehrt.
const enterFileAgrees =
afterEnter.tabs.includes(SERVICE_FILE) &&
afterEnter.breadcrumb.includes('userService.ts') &&
afterEnter.readerPath === SERVICE_FILE;
report.enterOpenedFile = enterFileAgrees ? SERVICE_FILE : '';
report.twinSubject = afterEnter.twin;
report.highlightedCount = afterEnter.highlightedCount;
log(`nach Enter: ${report.enterOpenedFile}, Twin ${report.twinSubject}, `
+ `${afterEnter.highlightedCount} Knoten markiert, ${afterEnter.targetChanges} Fahrten`);
// ------------------------------------- 6d. Klick in die Galaxie
const clickQn = await page.evaluate(async (project) => {
const res = await fetch(`/api/layout?project=${project}&max_nodes=5000`);
const data = await res.json();
const hit = (data.nodes ?? []).find((node) =>
(node.qualified_name ?? '').endsWith('validate.validateUser'),
);
return hit?.qualified_name ?? '';
}, PROJECT);
extras.clickQn = clickQn;
if (clickQn.length === 0) {
throw new Error(`kein Knoten mit ${CLICK_TARGET_SUFFIX} im Layout`);
}
const clicked = await page.evaluate((qn) => globalThis.__atlasGalaxy?.clickNode(qn) ?? false, clickQn);
extras.clickAccepted = clicked;
if (clicked !== true) {
throw new Error(`clickNode(${clickQn}) hat den Knoten nicht gefunden`);
}
await page.waitForFunction(
() => globalThis.__atlasReader?.document?.path === 'src/util/validate.ts',
undefined,
{ timeout: 20000 },
);
await page.waitForFunction(
() => /validate\.validateUser$/.test(globalThis.__atlasTwin?.qualifiedName ?? ''),
undefined,
{ timeout: 30000 },
);
const afterClick = await page.evaluate(() => ({
breadcrumb: (document.querySelector('[data-testid="atlas-breadcrumb"]')?.textContent ?? '')
.replace(/\s+/g, ' ')
.trim(),
tabs: [...document.querySelectorAll('.atlas-tab')].map((node) => node.getAttribute('data-path')),
readerPath: globalThis.__atlasReader?.document?.path ?? '',
twin: globalThis.__atlasTwin?.qualifiedName ?? '',
targetChanges: globalThis.__atlasGalaxy?.targetChanges ?? 0,
highlightedCount: globalThis.__atlasGalaxy?.highlightedCount ?? 0,
lastTargetQn: globalThis.__atlasGalaxy?.lastTargetQn ?? '',
}));
extras.afterClick = afterClick;
const clickFileAgrees =
afterClick.tabs.includes(TARGET_FILE) &&
afterClick.breadcrumb.includes('validate.ts') &&
afterClick.readerPath === TARGET_FILE;
report.clickOpenedFile = clickFileAgrees ? TARGET_FILE : '';
report.twinSubjectAfterClick = afterClick.twin;
report.flyToCount = afterClick.targetChanges;
log(`nach dem Klick: ${report.clickOpenedFile}, Twin ${report.twinSubjectAfterClick}, `
+ `${report.flyToCount} Fahrten`);
// Ein drittes Bild, das keine Abnahme verlangt und das man trotzdem
// sehen will: die Galaxie im Fokus. Erst hier beschriftet die Szene,
// und zwar genau die Nachbarschaft, die gerade gefragt wurde.
await page.waitForTimeout(1200);
extras.canvasFocused = await canvasBrightness(page);
await page.screenshot({ path: join(OUT_DIR, 'galaxy-focus.png'), fullPage: true });
log('galaxy-focus.png geschrieben (validateUser und Nachbarn, Kamera angefahren)');
// --------------------------------------- 6e. Der [a]tlas-Schalter
/*
* Drei Aussagen in einem Stueck Strecke:
*
* 1. Ein `a` in der Kommandozeile ist ein Buchstabe und kein Kuerzel.
* Wer "createUser" tippt, tippt ein a mit; klappte dabei die
* Galaxie weg, waere das Kuerzel eine Falle.
* 2. Mit Alt/Option ist dasselbe `a` der Schalter.
* 3. Nach dem Wiederaufklappen zeichnet dieselbe Szene weiter. Das
* ist der Beweis fuer den gehaltenen WebGL-Kontext: waere sie
* ausgehaengt worden, stuende hier ein neuer, schwarzer Canvas.
*
* Nachgezogen am 2026-08-29 (W7a): das Kuerzel traegt seit dem
* Nutzerbefund Alt/Option, weil ein blanker Buchstabe in die
* Kommandozeile gehoert und nicht in ein Panel (src/app/keyboard.ts).
* Aussage 1 wird dadurch nicht schwaecher, sondern gilt jetzt ueberall:
* ein blankes `a` schaltet nirgends mehr.
*/
const galaxyVisible = () =>
page.evaluate(
() =>
document.querySelector('[data-testid="atlas-galaxy"]')?.getAttribute('data-visible') ===
'true',
);
await page.locator('[data-testid="atlas-command-input"]').focus();
await page.keyboard.press('a');
const visibleWhileTyping = await galaxyVisible();
await page.keyboard.press('Backspace');
await page.locator('.atlas-brand').click();
await page.keyboard.press('Alt+a');
await page.waitForFunction(
() =>
document.querySelector('[data-testid="atlas-galaxy"]')?.getAttribute('data-visible') ===
'false',
undefined,
{ timeout: 10000 },
);
const hiddenAfterKey = !(await galaxyVisible());
await page.click('[data-testid="atlas-menu-item"][data-menu="a"]');
await page.waitForFunction(
() =>
document.querySelector('[data-testid="atlas-galaxy"]')?.getAttribute('data-visible') ===
'true',
undefined,
{ timeout: 10000 },
);
await page.waitForTimeout(800);
const canvasAfterReopen = await canvasBrightness(page);
extras.toggle = {
visibleWhileTyping,
hiddenAfterKey,
visibleAfterMenuClick: await galaxyVisible(),
canvasAfterReopen,
nodesAfterReopen: await page.evaluate(() => globalThis.__atlasGalaxy?.nodes ?? 0),
};
log('Schalter:', JSON.stringify({ ...extras.toggle, canvasAfterReopen: undefined }));
// ------------------------------------------- 6f. Was noch auffiel
extras.galaxyNote = await page.evaluate(
() => document.querySelector('[data-testid="atlas-galaxy-note"]')?.textContent?.trim() ?? '',
);
extras.apiRoutes = { ...proxy.log.apiRoutes };
extras.rpcTools = { ...proxy.log.rpcTools };
/*
* Was die Entprellung gekostet hat, in Anfragen.
*
* Zehn Tastendruecke, und der Server hat zwei Suchen gesehen: eine je
* Wort der einen fertigen Anfrage ("createUser" wird zu create und
* user). Ohne die 200 ms waeren es bis zu zwanzig gewesen.
*/
extras.debounce = {
typedChars: SEARCH_TERM.length,
searchGraphCalls: proxy.log.rpcTools['search_graph'] ?? 0,
};
await context.close();
} catch (err) {
failure = err;
console.error('[smoke-w3] FEHLER:', err.message);
if (serverLog.length > 0) {
console.error('[smoke-w3] 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(500);
const leftovers = [];
for (const port of [serverPort, uiPort].filter((value) => value > 0)) {
leftovers.push(await countListeners(port));
}
report.leftoverProcesses = leftovers.reduce((sum, value) => sum + value, 0);
log('leftoverProcesses:', report.leftoverProcesses);
timings.totalMs = Date.now() - totalStarted;
report.project = PROJECT;
report.fixture = 'fixtures/atlas-sample';
report.searchTerm = SEARCH_TERM;
report.timings = timings;
report.extras = extras;
report.generatedAt = new Date().toISOString();
report.error = failure ? failure.message : null;
await mkdir(OUT_DIR, { recursive: true });
await writeFile(OUT_JSON, JSON.stringify(report, null, 2) + '\n', 'utf8');
log('geschrieben:', OUT_JSON);
const ok =
failure === null &&
report.searchResultCount >= 1 &&
report.searchTopNames.includes('createUser') &&
report.enterOpenedFile === SERVICE_FILE &&
/userService\.createUser$/.test(report.twinSubject) &&
report.clickOpenedFile === TARGET_FILE &&
/validate\.validateUser$/.test(report.twinSubjectAfterClick) &&
report.flyToCount >= 2 &&
report.highlightedCount >= 2 &&
report.layoutNodes >= 50 &&
report.port >= MIN_PORT &&
report.leftoverProcesses === 0 &&
extras.canvas?.litPixels > 0 &&
extras.toggle?.visibleWhileTyping === true &&
extras.toggle?.hiddenAfterKey === true &&
extras.toggle?.visibleAfterMenuClick === true &&
extras.toggle?.canvasAfterReopen?.litPixels > 0 &&
extras.blockedRequests.length === 0 &&
extras.pageErrors.length === 0;
if (!ok) {
console.error('[smoke-w3] W3-Smoke NICHT gruen.');
if (home) {
console.error('[smoke-w3] isoliertes HOME bleibt zum Nachsehen liegen:', home);
}
process.exitCode = 1;
return;
}
if (home) {
await rm(home, { recursive: true, force: true });
}
log('W3-Smoke gruen.');
}
main().catch((err) => {
console.error('[smoke-w3] unerwarteter Fehler:', err);
process.exitCode = 1;
});