Skip to content

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.

142 KB
Raw Blame
#!/usr/bin/env node
/*
 * W10-Smoke: das Modell gehoert dem Leser, und alles, was Rechenzeit kostet,
 * steht an einem Ort und nennt seinen GEMESSENEN Effekt.
 *
 * Martin am 2026-08-29: "Fuer mich waere wichtig, dass das Modell das Binary
 * nicht gross verseucht. Man bietet in der UI das Feature so an, dass man sich
 * von zum Beispiel Hugging Face selber ein Modell aussuchen kann." Und der
 * Nutzer am selben Tag: "2D/3D oder sowas sollte immer zentral in einem
 * Settings-Menue drin sein, nicht alles auf einer Oberflaeche, wegen
 * Rechenleistung falls jemand keine so starke Maschine hat."
 *
 * Dieser Lauf prueft beide Zusicherungen an der laufenden Oberflaeche, gegen
 * einen echten llama-server, und er tut es, ohne den Arbeitsplatz des Nutzers
 * anzufassen.
 *
 * ## Die drei Kunstgriffe dieses Laufs
 *
 * 1. **Ein eigener Router-Sidecar mit ZWEI Modellen, ohne ein Byte zu laden.**
 *    Umschalten laesst sich nur messen, wenn es zwei Modelle gibt. Zwei Dateien
 *    zu kopieren waere 1,4 GB und eine Minute; zwei nachzuladen waere ein
 *    Netzzugriff, den dieser Lauf nicht haben darf. Also stehen sie als HARTE
 *    LINKS in einem eigenen Cache-Verzeichnis: derselbe Inhalt, dieselbe
 *    Inode, kein zusaetzlicher Platz, sofort da. Ein harter Link loescht beim
 *    Aufraeumen nichts: die Dateien in models/ tragen danach nur wieder einen
 *    Link weniger. Dass alle sechs am Ende noch da sind, wird gemessen und
 *    steht im Artefakt (`modelsAfterRun`).
 *
 * 2. **Die Umleitung an der Naht, an der die Anwendung selbst fragt.** Das
 *    Produkt redet mit 127.0.0.1:4141, und dieser Port gehoert dem Nutzer:
 *    dort laeuft sein eigener Sidecar, waehrend dieser Lauf laeuft. Wie in
 *    smoke-w7c ersetzt ein `addInitScript` das `globalThis.fetch` der Seite und
 *    schickt alles, was mit dem Produktursprung beginnt, an den Port dieses
 *    Laufs. Der Zustandsautomat, die Probe, das Panel und der Chat laufen
 *    unveraendert. Dass an 4141 wirklich kein Byte ging, steht als
 *    `productPortRequests` (muss 0 sein) im Artefakt; der Route-Handler bricht
 *    eine Anfrage dorthin ausdruecklich ab, statt sie durchzulassen.
 *
 * 3. **Zwei Sidecars nacheinander, nicht nebeneinander.** AC2 hat zwei
 *    Haelften: mit Router waehlt ein Klick das Modell, ohne Router sagt das
 *    Panel genau das und bietet keine wirkungslose Auswahl an. Der zweite
 *    Sidecar startet erst, wenn der erste samt seiner Kindprozesse beendet ist.
 *    Der Router startet je Modell eine eigene Instanz auf einem ephemeren Port;
 *    diese Ports werden mitgeschrieben und beim Abbau mitgezaehlt.
 *
 * ## Was hier eine Messung ist und was nicht
 *
 * Jede Zahl in verification/w10/models.json hat in `extras` das, woraus sie
 * entstanden ist: die selbst abgefragten Props neben den Werten im Panel, die
 * zwei Modellnamen aus den aufgezeichneten Antwortkoerpern, je Einstellung die
 * Bildrate vorher und nachher samt Urteil, die vier Fundstellen des
 * Ehrlichkeitssatzes, die drei Teile von `noWeightsInRepo`, die Zaehlung der
 * Fortschrittselemente und die Aufraeumzahlen. Wo etwas nicht ehrlich als
 * `true` zu messen war, steht `false` und der Grund; ein geschoentes `true`
 * waere kein Ergebnis.
 *
 * ## Die Grenze, die dieser Lauf nicht ueberschreitet
 *
 * Gemessen wird in headless Chromium mit SwiftShader, also in Software-GL. Die
 * ABSOLUTEN Bildraten sind darum nicht die eines Lesers mit Metal auf demselben
 * Rechner. Was dieser Lauf beweist, ist die Mechanik (jede Einstellung greift,
 * jede nennt ihre zwei Zahlen, das Urteil kennt auch "kein messbarer
 * Unterschied") und die Zahlen DIESER Umgebung. Der Satz steht noch einmal in
 * `method` und in `extras.frameRateEnvironment`, damit niemand eine dieser
 * Zahlen fuer die seines Rechners 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 >= 4580, dist/ auf einem zweiten
 *   5. eigenes Cache-Verzeichnis mit zwei harten Links, Router auf einem dritten
 *   6. Chromium ohne Aussenwelt, mit Umleitung und Route-Sperre
 *      a. AC5: das Panel bei AUSGESCHALTETEM Modell, zwei Poll-Intervalle lang
 *      b. Modell an; das Panel auf zwei Wegen oeffnen
 *      c. AC1/AC3: die vier Zahlen gegen die eigene Abfrage, die Cache-Liste,
 *         die sechs Vorschlaege gegen verification/w5/eval.json, das freie Feld,
 *         der Kopieren-Knopf gegen die Zwischenablage, der Ehrlichkeitssatz in
 *         vier Teilen, die Zaehlung der Fortschrittselemente
 *      d. AC2: umschalten, fragen, zurueckschalten, fragen; zwei Modellnamen
 *         aus den aufgezeichneten Antworten; Reload; Statusleiste
 *      e. AC9: acht Einstellungen, je Bildrate vorher und nachher; die flache
 *         Ansicht an den Beschriftungen belegt; die Ansichtsschalter, die
 *         bleiben, wo sie sind; Reload
 *   7. AC4 am Startskript, ohne einen Prozess zu starten
 *   8. AC8 an der Funktion selbst und an der Rechnung der Eval
 *   9. AC2 zweite Haelfte: derselbe Weg gegen einen Sidecar OHNE Router
 *  10. abraeumen, Restprozesse zaehlen, JSON und drei Bilder schreiben
 *
 * Das Ganze laeuft unter dem Netz-Deny-Gate (npm run smoke:w10).
 *
 * ## Ports
 *
 * Ab 4580. 4141 gehoert dem Modell-Sidecar des Nutzers, 4390 und 4391 seiner
 * Vorschau; alle drei fasst dieser Lauf nicht an, weder startend noch beendend.
 * 4210 bis 4560 sind an die Laeufe davor vergeben.
 */

import { spawn } from 'node:child_process';
import { existsSync, statSync } from 'node:fs';
import { copyFile, link, mkdir, mkdtemp, readFile, rm, stat, 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 { BUNDLE_DIR, loadCompiler } from './lib/compiler-bundle.mjs';
import { LLAMA_SERVER } from './lib/llama.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-w10';
const OUT_DIR = join(ROOT, 'verification', 'w10');
const OUT_JSON = join(OUT_DIR, 'models.json');
const EVAL_JSON = join(ROOT, 'verification', 'w5', 'eval.json');
const SHOT_SETTINGS = join(OUT_DIR, 'settings.png');
const SHOT_SWITCH = join(OUT_DIR, 'settings-switch.png');
const SHOT_FETCH = join(OUT_DIR, 'settings-fetch.png');
/*
 * Das vierte Bild, und es steht bewusst nicht in der Liste des eingefrorenen
 * Tests: der prueft drei Namen, und ein vierter dort waere eine Aenderung an
 * einer eingefrorenen Datei. Es gibt trotzdem, weil die Gruppe "Darstellung und
 * Leistung" die einzige ist, die auf keinem der drei anderen zu sehen war, und
 * weil sie der Teil ist, um den AC9 geht: eine Einstellung mit ihren beiden
 * gemessenen Zahlen daneben.
 */
const SHOT_PERFORMANCE = join(OUT_DIR, 'settings-performance.png');

/** 4141, 4390 und 4391 gehoeren dem Nutzer, alles bis 4560 den Laeufen davor. */
const MIN_PORT = 4580;

/** Der Port des Produkts. Dieser Lauf belegt ihn nicht und redet nicht mit ihm. */
const PRODUCT_SIDECAR_PORT = 4141;
const PRODUCT_SIDECAR_ORIGIN = `http://127.0.0.1:${PRODUCT_SIDECAR_PORT}`;

/**
 * Die zwei Modelle des Cache-Verzeichnisses.
 *
 * Die zwei kleinsten vorhandenen, und zwar aus einem Grund, der nichts mit
 * ihrer Qualitaet zu tun hat: der Router haelt beide gleichzeitig geladen
 * (--models-max 2), und was hier zaehlt, ist der Speicher dieser Maschine
 * waehrend eines Beweislaufs. Welches Modell gut antwortet, sagt die Eval; was
 * hier gemessen wird, ist das Umschalten.
 */
const MODEL_A = 'MiniCPM5-1B-Q4_K_M.gguf';
const MODEL_B = 'LFM2.5-1.2B-Instruct-Q4_K_M.gguf';

/** Alle sechs Dateien, die in models/ liegen. Am Ende wird nachgezaehlt. */
const EXPECTED_MODEL_FILES = [
    'gemma-4-E4B-it-Q4_K_M.gguf',
    'LFM2.5-1.2B-Instruct-Q4_K_M.gguf',
    'MiniCPM5-1B-Q4_K_M.gguf',
    'qwen2.5-coder-1.5b-instruct-q4_k_m.gguf',
    'Qwen3.5-2B-Q4_K_M.gguf',
    'Qwen3.5-4B-Q4_K_M.gguf',
];

/** Das Kontextfenster, mit dem der Router seine Instanzen faehrt. */
const ROUTER_CTX = 2048;

/**
 * Wie lange bei ausgeschaltetem Modell gewartet wird.
 *
 * Zwei volle Poll-Intervalle plus Luft (SIDECAR_POLL_MS ist 3000). Dieselbe
 * Wartezeit wie in smoke-w5a, und aus demselben Grund: eine Null nach einer
 * halben Sekunde waere die Aussage, dass in einer halben Sekunde nichts flog.
 */
const OFF_WINDOW_MS = 7500;

/**
 * Wie lange die Szene vor einer Messung ungestoert laeuft.
 *
 * Das Vorher-Fenster des Panels reicht 3000 ms zurueck (BEFORE_MS in
 * SettingsPanel.tsx). Wer frueher klickt, gibt der Messung kein Vorher und kein
 * Rauschband, und das Urteil waere `not-measured`.
 */
const SETTLE_BEFORE_MS = 3400;

/**
 * Wie lange nach einer Aenderung gewartet wird, bevor das Urteil gelesen wird.
 *
 * SETTLE_MS (1200) plus MEASURE_MS (1500) plus Luft fuer den Timer selbst.
 */
const MEASURE_WAIT_MS = 3600;

const READY_TIMEOUT_MS = 240000;
const ANSWER_TIMEOUT_MS = 240000;

/** Die Frage, mit der das Umschalten belegt wird. Zweimal dieselbe, zwei Modelle. */
const SWITCH_QUESTION = '@createUser explain this function';

/** Das Symbol, das dafuer in den Fokus geht. Dasselbe wie in smoke-w7c. */
const FOCUS_FILE = 'src/services/userService.ts';
const FOCUS_LINE = 24;
const FOCUS_SYMBOL = 'createUser';

/** Die Eingabe fuer das freie Feld. Ein Repository, das dieser Lauf nie besucht. */
const FREE_REPO_INPUT = 'unsloth/Qwen3.5-9B-GGUF:Q4_K_M';

/**
 * Chromium ohne Aussenwelt, plus die GL-Flags aus smoke-w4e.
 *
 * Ohne `--use-angle=swiftshader` und die zwei Flags daneben zeichnet der Graph
 * in dieser Umgebung nicht, und ohne ein gezeichnetes Bild ist AC9 nicht
 * messbar: eine Bildrate von null ist keine Bildrate.
 */
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 MAIN_VIEWPORT = { width: 1680, height: 1050 };

/** Der Satz ueber die Umgebung, woertlich, an beiden Stellen derselbe. */
const FRAME_RATE_ENVIRONMENT =
    'Gemessen in headless Chromium mit SwiftShader, also in Software-GL. Die absoluten '
    + 'Bildraten sind darum NICHT die eines Lesers mit Metal auf derselben Maschine. Was dieser '
    + 'Lauf zeigt, ist die Mechanik jeder Einstellung und die Zahlen dieser Umgebung.';

/**
 * Die Woerter, die im Leistungsteil ohne eine Zahl daneben nicht stehen duerfen.
 *
 * AC9 verbietet Versprechen ("schneller"), nicht Beobachtungen ("vorher 12,
 * nachher 19"). Gepruefte Einheit ist darum der SATZ: steht in demselben Satz
 * eine Zahl, ist das Wort an eine Messung gebunden.
 */
const PROMISE_WORDS = [
    'faster', 'quicker', 'speeds up', 'speed up', 'better', 'boost', 'boosts',
    'schneller', 'besser', 'spart', 'saves',
];

/**
 * Woerter, die daneben beobachtet und einzeln aufgeschrieben werden.
 *
 * Sie tragen die Zusicherung nicht, und der Grund steht im Artefakt neben dem
 * Satz, in dem sie stehen: eine Liste, die "cheaper" als Versprechen zaehlt,
 * wuerde auch den Satz treffen, der sagt, dass etwas nur BILLIGER AUSSIEHT.
 * Weggelassen wird das Wort trotzdem nicht: wer die Zahl liest, soll sehen, was
 * die Suche gefunden und was sie damit gemacht hat.
 */
const WATCHED_WORDS = ['cheaper', 'smoother', 'improve', 'optimise', 'optimize'];

const log = (...parts) => console.log('[smoke-w10]', ...parts);
const serverLog = [];

function run(command, args, options = {}) {
    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',
                ...(options.env ?? {}),
            },
            stdio: ['ignore', 'pipe', 'pipe'],
        });
        let out = '';
        let err = '';
        child.stdout.on('data', (d) => { out += d.toString(); });
        child.stderr.on('data', (d) => { err += d.toString(); });
        child.on('error', (error) => done({ code: 127, out, err: err + error.message }));
        child.on('close', (code) => done({ code: code ?? 1, out, err }));
    });
}

// --------------------------------------------------------- Der Sidecar ------

/**
 * Einen llama-server starten und warten, bis `/health` mit 200 antwortet.
 *
 * Eigener `spawn` statt tools/lib/llama.mjs, und das ist keine Doppelung aus
 * Bequemlichkeit: der Helfer dort kennt nur den Einzel-Modus (`-m <datei>`).
 * Ein Helfer, der um einen Router-Modus erweitert wird, den nur dieser eine
 * Lauf braucht, waere eine Aenderung an gemeinsamer Infrastruktur fuer einen
 * einzigen Aufrufer. Die Argumente stehen darum hier, wo man sie neben der
 * Zusicherung liest, die sie tragen.
 */
async function startSidecar(args, { port, log: sink = [], timeoutMs = 180000 }) {
    const started = Date.now();
    const child = spawn(LLAMA_SERVER, args, { cwd: ROOT, stdio: ['ignore', 'pipe', 'pipe'] });
    child.stdout.on('data', (d) => sink.push(`[stdout] ${d.toString().trimEnd()}`));
    child.stderr.on('data', (d) => sink.push(`[stderr] ${d.toString().trimEnd()}`));
    let exited = null;
    child.on('exit', (code, signal) => { exited = { code, signal }; });

    const deadline = Date.now() + timeoutMs;
    while (Date.now() < deadline) {
        if (exited !== null) {
            throw new Error(
                `llama-server endete vorzeitig (code=${exited.code}, signal=${exited.signal})\n`
                + sink.slice(-20).join('\n'),
            );
        }
        try {
            const response = await fetch(`http://127.0.0.1:${port}/health`);
            await response.arrayBuffer();
            if (response.status === 200) {
                return { child, readyMs: Date.now() - started };
            }
        } catch {
            // lauscht noch nicht
        }
        await sleep(300);
    }
    child.kill('SIGKILL');
    throw new Error(`llama-server war binnen ${timeoutMs} ms nicht auf ${port} bereit`);
}

/** Die Kindprozesse des Routers und die Ports, auf denen sie lauschen. */
async function sidecarChildren(pid) {
    const found = await run('pgrep', ['-P', String(pid)]);
    const pids = found.out.split('\n').map((line) => line.trim()).filter(Boolean).map(Number);
    const out = [];
    for (const child of pids) {
        const ports = await run('lsof', ['-nP', '-a', '-p', String(child), '-i', '-sTCP:LISTEN']);
        const listed = [...ports.out.matchAll(/127\.0\.0\.1:(\d+)\s+\(LISTEN\)/g)]
            .map((match) => Number(match[1]));
        out.push({ pid: child, ports: listed });
    }
    return out;
}

/**
 * Einen Sidecar beenden, samt seiner Kindprozesse.
 *
 * Erst hoeflich, dann nicht mehr, und die Kinder ausdruecklich mit: der Router
 * startet je Modell eine eigene Instanz, und ein Beweislauf, der den Vater
 * beendet und die Kinder stehen laesst, haelt zwei Modelle im Speicher der
 * Maschine, auf der als naechstes jemand arbeiten will.
 */
async function stopSidecar(child, children) {
    const pids = [...children.map((entry) => entry.pid)];
    if (child !== null && child.exitCode === null && !child.killed) {
        child.kill('SIGTERM');
        for (let i = 0; i < 60; i += 1) {
            if (child.exitCode !== null || child.signalCode !== null) {
                break;
            }
            await sleep(100);
        }
        if (child.exitCode === null && child.signalCode === null) {
            child.kill('SIGKILL');
            await sleep(400);
        }
    }
    for (const pid of pids) {
        try {
            process.kill(pid, 0);
        } catch {
            continue;
        }
        try {
            process.kill(pid, 'SIGTERM');
        } catch {
            // schon weg
        }
    }
    await sleep(600);
    const survivors = [];
    for (const pid of pids) {
        try {
            process.kill(pid, 0);
            process.kill(pid, 'SIGKILL');
            survivors.push(pid);
        } catch {
            // weg, wie es sein soll
        }
    }
    if (survivors.length > 0) {
        await sleep(400);
    }
    return survivors;
}

/** Was der Router ueber ein Modell sagt. Die eigene Abfrage neben dem Panel. */
async function routerProps(origin, modelId) {
    const url = modelId === undefined
        ? `${origin}/props`
        : `${origin}/props?model=${encodeURIComponent(modelId)}`;
    const response = await fetch(url);
    if (!response.ok) {
        throw new Error(`GET ${url} antwortete mit ${response.status}`);
    }
    return response.json();
}

async function routerModels(origin) {
    const response = await fetch(`${origin}/v1/models`);
    if (!response.ok) {
        throw new Error(`GET ${origin}/v1/models antwortete mit ${response.status}`);
    }
    return response.json();
}

// ------------------------------------------------------------ Testgriffe ----

const settingsSeam = (page) =>
    page.evaluate(() => {
        const seam = globalThis.__atlasSettings;
        return seam === undefined ? null : JSON.parse(JSON.stringify(seam));
    });

const llmSeam = (page) =>
    page.evaluate(() => {
        const seam = globalThis.__atlasLlm;
        return seam === undefined ? null : { ...seam };
    });

const perfSeam = (page) =>
    page.evaluate(() => {
        const seam = globalThis.__atlasGalaxyPerf;
        return seam === undefined ? null : JSON.parse(JSON.stringify(seam));
    });

const chatSeam = (page) =>
    page.evaluate(() => {
        const seam = globalThis.__atlasChat;
        if (seam === undefined) {
            return null;
        }
        const { validateRefine, ...rest } = seam;
        return JSON.parse(JSON.stringify(rest));
    });

/**
 * Was im Einstellungen-Panel wirklich dasteht.
 *
 * Eine Abfrage und nicht zwoelf, weil die Antworten zusammengehoeren: ob eine
 * Modell-Liste dasteht, ist nur zusammen mit der Frage zu lesen, ob das lokale
 * Modell an ist. Gelesen wird der sichtbare Text, nicht der Katalog.
 */
const settingsDom = (page) =>
    page.evaluate(() => {
        const tidy = (value) => (value ?? '').replace(/\s+/g, ' ').trim();
        const root = document.querySelector('[data-testid="atlas-settings"]');
        if (root === null) {
            return { present: false };
        }
        const rect = root.getBoundingClientRect();
        const style = globalThis.getComputedStyle(root);
        const one = (id) => {
            const node = root.querySelector(`[data-testid="${id}"]`);
            if (node === null) {
                return { present: false, text: '' };
            }
            const box = node.getBoundingClientRect();
            return {
                present: true,
                text: tidy(node.textContent),
                visible: box.width > 0 && box.height > 0,
            };
        };
        const attrs = (node, names) => Object.fromEntries(
            names.map((name) => [name, node.getAttribute(`data-${name}`) ?? '']),
        );
        return {
            present: true,
            visible: rect.width > 0 && rect.height > 0
                && style.display !== 'none' && style.visibility !== 'hidden',
            llmState: root.getAttribute('data-llm') ?? '',
            router: root.getAttribute('data-router') ?? '',
            title: one('atlas-settings-title'),
            sections: [...root.querySelectorAll('[data-testid="atlas-settings-section"]')]
                .map((node) => ({
                    name: node.getAttribute('data-section') ?? '',
                    text: tidy(node.textContent).slice(0, 400),
                    height: Math.round(node.getBoundingClientRect().height),
                })),
            llmOff: one('atlas-settings-llm-off'),
            notRunning: one('atlas-settings-not-running'),
            starting: one('atlas-settings-starting'),
            running: one('atlas-settings-running'),
            facts: [...root.querySelectorAll('[data-testid="atlas-settings-fact"]')]
                .map((node) => {
                    const value = node.querySelector('[data-testid="atlas-settings-fact-value"]');
                    return {
                        fact: node.getAttribute('data-fact') ?? '',
                        label: tidy(node.querySelector('.atlas-settings-fact-label')?.textContent),
                        value: tidy(value?.textContent),
                        source: value?.getAttribute('data-source') ?? '',
                    };
                }),
            cacheCount: (() => {
                const node = root.querySelector('[data-testid="atlas-settings-cache-count"]');
                return node === null
                    ? { present: false, count: -1, text: '' }
                    : {
                        present: true,
                        count: Number(node.getAttribute('data-count') ?? '-1'),
                        text: tidy(node.textContent),
                    };
            })(),
            models: [...root.querySelectorAll('[data-testid="atlas-settings-model"]')]
                .map((node) => ({
                    ...attrs(node, ['model', 'active', 'loaded', 'selectable']),
                    text: tidy(node.textContent),
                    pickable: node.querySelector('[data-testid="atlas-settings-model-pick"]') !== null
                        && node.querySelector('button[data-testid="atlas-settings-model-pick"]') !== null,
                })),
            modelPicks: root.querySelectorAll('button[data-testid="atlas-settings-model-pick"]').length,
            refresh: one('atlas-settings-refresh'),
            noRouter: one('atlas-settings-no-router'),
            routerCommand: one('atlas-settings-router-command'),
            startCommand: one('atlas-settings-start-command'),
            honesty: one('atlas-settings-honesty'),
            noProgressNote: one('atlas-settings-no-progress'),
            suggestions: [...root.querySelectorAll('[data-testid="atlas-settings-suggestion"]')]
                .map((node) => ({
                    ...attrs(node, [
                        'suggestion', 'repo', 'class', 'pass-rate', 'citation',
                        'citation-unmeasured', 'tokens-per-second', 'bytes',
                    ]),
                    name: tidy(node.querySelector('.atlas-settings-suggestion-name')?.textContent),
                    passText: tidy(node.querySelector('[data-testid="atlas-settings-pass-rate"]')?.textContent),
                    citationText: tidy(node.querySelector('[data-testid="atlas-settings-citation"]')?.textContent),
                    unmeasuredText: tidy(node.querySelector('[data-testid="atlas-settings-unmeasured"]')?.textContent),
                    unmeasuredBesideCitation:
                        node.querySelector('[data-testid="atlas-settings-citation"] [data-testid="atlas-settings-unmeasured"]') !== null,
                    command: node.querySelector('[data-testid="atlas-settings-command"]')
                        ?.getAttribute('data-command') ?? '',
                    copyButtons: node.querySelectorAll('[data-testid="atlas-settings-copy"]').length,
                })),
            repoState: (() => {
                const node = root.querySelector('[data-testid="atlas-settings-repo-state"]');
                return node === null
                    ? { present: false }
                    : {
                        present: true,
                        valid: node.getAttribute('data-valid') ?? '',
                        problem: node.getAttribute('data-problem') ?? '',
                        text: tidy(node.textContent),
                    };
            })(),
            repoCommand: (() => {
                const node = root.querySelector('[data-testid="atlas-settings-repo-command"]');
                return node === null
                    ? { present: false, command: '', text: '' }
                    : {
                        present: true,
                        command: node.getAttribute('data-command') ?? '',
                        text: tidy(node.textContent),
                    };
            })(),
            perf: (() => {
                const node = root.querySelector('[data-testid="atlas-settings-perf"]');
                return node === null
                    ? { present: false }
                    : {
                        present: true,
                        ...attrs(node, ['running', 'fps', 'nodes', 'edges', 'cap', 'band', 'samples']),
                        text: tidy(node.textContent),
                    };
            })(),
            choices: [
                ...root.querySelectorAll('[data-testid="atlas-settings-choice"]'),
                ...root.querySelectorAll('[data-testid="atlas-settings-effect"]'),
            ].map((node) => ({
                setting: node.getAttribute('data-setting') ?? '',
                effect: node.getAttribute('data-effect') ?? '',
                value: node.getAttribute('data-value') ?? '',
                label: tidy(node.querySelector('.atlas-settings-choice-label')?.textContent),
                options: [...node.querySelectorAll('[data-testid="atlas-settings-option"]')]
                    .map((option) => ({
                        option: option.getAttribute('data-option') ?? '',
                        active: option.getAttribute('data-active') ?? '',
                        label: tidy(option.textContent),
                    })),
            })),
            measures: [...root.querySelectorAll('[data-testid="atlas-settings-measure"]')]
                .map((node) => ({
                    ...attrs(node, ['setting', 'verdict', 'before', 'after', 'band', 'nodes', 'edges', 'at']),
                    text: tidy(node.textContent),
                })),
            profiles: {
                present: root.querySelector('[data-testid="atlas-settings-profiles"]') !== null,
                isDefault: root.querySelector('[data-testid="atlas-settings-profiles"]')
                    ?.getAttribute('data-default') ?? '',
                buttons: [...root.querySelectorAll('[data-testid="atlas-settings-profile"]')]
                    .map((node) => node.getAttribute('data-profile') ?? ''),
            },
            storage: one('atlas-settings-storage'),
            modelStorage: one('atlas-settings-model-storage'),
            keeps: one('atlas-settings-keeps'),
            displayText: tidy(
                root.querySelector('[data-testid="atlas-settings-section"][data-section="display"]')
                    ?.textContent,
            ),
            /*
             * Die Zaehlung der Fortschrittselemente. AC3 verbietet einen Balken
             * ueber eine Uebertragung, die diese Oberflaeche nicht sieht.
             * Ausgenommen wird genau ein Element, und der Grund steht in seinem
             * Text: der Absatz, der SAGT, dass es keinen Balken gibt, traegt das
             * Wort "progress" in seiner Testmarke.
             */
            progressElements: [...root.querySelectorAll(
                'progress, [role="progressbar"], [aria-valuenow], [class*="progress" i], '
                + '[class*="fortschritt" i], [data-testid*="progress" i], [data-testid*="fortschritt" i]',
            )]
                .filter((node) => node.getAttribute('data-testid') !== 'atlas-settings-no-progress')
                .map((node) => ({
                    tag: node.tagName.toLowerCase(),
                    testid: node.getAttribute('data-testid') ?? '',
                    role: node.getAttribute('role') ?? '',
                    className: node.getAttribute('class') ?? '',
                    text: tidy(node.textContent).slice(0, 80),
                })),
            progressExemption: (() => {
                const node = root.querySelector('[data-testid="atlas-settings-no-progress"]');
                return node === null ? '' : tidy(node.textContent);
            })(),
        };
    });

/** Die Schalter, die keine Rechenzeit kosten und darum bleiben, wo sie sind. */
const viewOnlyControls = (page) =>
    page.evaluate(() => {
        const box = (node) => {
            if (node === null) {
                return null;
            }
            const rect = node.getBoundingClientRect();
            return { width: Math.round(rect.width), height: Math.round(rect.height) };
        };
        const legendToggle = document.querySelector('[data-testid="atlas-galaxy-legend-toggle"]');
        return {
            legendToggle: {
                present: legendToggle !== null,
                expanded: legendToggle?.getAttribute('aria-expanded') ?? '',
                rect: box(legendToggle),
            },
            legendOpen: document.querySelector('[data-testid="atlas-galaxy-legend"]') !== null,
            modeChips: [...document.querySelectorAll('[data-testid="atlas-graph-mode-chip"]')]
                .map((node) => ({
                    mode: node.getAttribute('data-mode') ?? '',
                    active: node.getAttribute('data-active') ?? '',
                    rect: box(node),
                })),
            edgeFilters: [...document.querySelectorAll('[data-testid="atlas-galaxy-legend-swatch"]')]
                .filter((node) => node.tagName === 'BUTTON')
                .map((node) => node.getAttribute('data-type') ?? ''),
            twinDepth: {
                present: document.querySelector('[data-testid="atlas-twin-depth"]') !== null,
                rect: box(document.querySelector('[data-testid="atlas-twin-depth"]')),
                value: document.querySelector('[data-testid="atlas-twin-depth"]')?.value ?? '',
                name: (document.querySelector('[data-testid="atlas-twin-depth-name"]')?.textContent ?? '')
                    .trim(),
            },
        };
    });

/** Wie das lokale Modell in der Statusleiste heisst. Wortgleich mit smoke-w7c. */
const statusChip = (page) =>
    page.evaluate(() => {
        const chip = [...document.querySelectorAll('.atlas-statusbar .atlas-chip')]
            .find((entry) => (entry.getAttribute('data-chip') ?? '').includes('llm'));
        return {
            present: chip !== undefined,
            label: chip?.getAttribute('data-chip') ?? '',
            text: (chip?.textContent ?? '').replace(/\s+/g, ' ').trim(),
        };
    });

/** Das Rechteck der Zeichenflaeche, in Fensterkoordinaten. Wortgleich mit smoke-w9. */
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),
        };
    });

/**
 * Ein Bild der Zeichenflaeche aufnehmen und IN der Seite ablegen.
 *
 * Derselbe Umweg wie in smoke-w9, aus demselben Grund: der Canvas laeuft ohne
 * `preserveDrawingBuffer`, `toDataURL` gaebe also ein leeres Bild, und eine
 * Million Zahlen ueber die Bruecke ins Skript zu schieben kostet Minuten.
 * Gerechnet wird dort, zurueck kommen Kennzahlen.
 */
async function grab(page, key, clip) {
    const shot = await page.screenshot({ clip });
    return page.evaluate(async ({ name, data }) => {
        const image = new Image();
        image.src = `data:image/png;base64,${data}`;
        await image.decode();
        const canvas = document.createElement('canvas');
        canvas.width = image.naturalWidth;
        canvas.height = image.naturalHeight;
        const ctx = canvas.getContext('2d', { willReadFrequently: true });
        ctx.drawImage(image, 0, 0);
        globalThis.__w10 = globalThis.__w10 ?? {};
        globalThis.__w10[name] = ctx.getImageData(0, 0, canvas.width, canvas.height);
        return { width: canvas.width, height: canvas.height };
    }, { name: key, data: shot.toString('base64') });
}

/**
 * Zwei abgelegte Bilder vergleichen, einmal Pixel auf Pixel und einmal
 * gegeneinander VERSCHOBEN.
 *
 * Das ist das Messinstrument der flachen Ansicht, und der Grund steht in einem
 * Satz: eine orthografische Kamera hat keinen Fluchtpunkt, also verschiebt ein
 * Schwenk das ganze Bild um denselben Betrag. Eine perspektivische Kamera hat
 * einen, also wandern nahe Punkte weiter als ferne (Parallaxe), und kein
 * einziger Versatz bringt die beiden Bilder wieder zur Deckung.
 *
 * Der beste Versatz wird nicht gesucht, indem alle Verschiebungen ausprobiert
 * werden (das waeren bei diesem Bild hunderte Millionen Vergleiche), sondern
 * ueber die SPALTENSUMMEN: die Helligkeit je Bildspalte ist ein eindimensionales
 * Signal, und der Versatz, bei dem die beiden Signale am besten zusammenpassen,
 * ist der gesuchte. Nur dieser eine Versatz wird danach am ganzen Bild
 * nachgerechnet.
 */
const shiftedDifference = (page, options) =>
    page.evaluate((input) => {
        const store = globalThis.__w10 ?? {};
        const first = store[input.base];
        const second = store[input.variant];
        if (first === undefined || second === undefined) {
            return null;
        }
        const width = first.width;
        const height = first.height;
        if (second.width !== width || second.height !== height) {
            return null;
        }
        const grey = (image) => {
            const out = new Float64Array(width * height);
            for (let i = 0, p = 0; i < image.data.length; i += 4, p += 1) {
                out[p] = (image.data[i] + image.data[i + 1] + image.data[i + 2]) / 3;
            }
            return out;
        };
        const a = grey(first);
        const b = grey(second);
        const columns = (values) => {
            const sums = new Float64Array(width);
            for (let y = 0; y < height; y += 1) {
                const row = y * width;
                for (let x = 0; x < width; x += 1) {
                    sums[x] += values[row + x];
                }
            }
            return sums;
        };
        const columnsA = columns(a);
        const columnsB = columns(b);
        /* Der Versatz, bei dem die Spaltensummen am besten zusammenpassen. */
        let bestShift = 0;
        let bestScore = Number.POSITIVE_INFINITY;
        for (let shift = -input.maxShift; shift <= input.maxShift; shift += 1) {
            let sum = 0;
            let count = 0;
            for (let x = 0; x < width; x += 1) {
                const source = x + shift;
                if (source < 0 || source >= width) {
                    continue;
                }
                sum += Math.abs(columnsA[source] - columnsB[x]);
                count += 1;
            }
            if (count < width / 2) {
                continue;
            }
            const score = sum / count;
            if (score < bestScore) {
                bestScore = score;
                bestShift = shift;
            }
        }
        /* Und derselbe Vergleich am ganzen Bild: ohne Versatz und mit dem besten. */
        const residualAt = (shift) => {
            let sum = 0;
            let count = 0;
            for (let y = 0; y < height; y += 1) {
                const row = y * width;
                for (let x = 0; x < width; x += 1) {
                    const source = x + shift;
                    if (source < 0 || source >= width) {
                        continue;
                    }
                    sum += Math.abs(a[row + source] - b[row + x]);
                    count += 1;
                }
            }
            return count === 0 ? -1 : sum / count;
        };
        return {
            width,
            height,
            bestShift,
            residualAtZero: Number(residualAt(0).toFixed(3)),
            residualAtBestShift: Number(residualAt(bestShift).toFixed(3)),
        };
    }, options);

/**
 * Wo jeder scrollbare Bereich steht, und ob er am Anfang steht.
 *
 * Wortgleich mit smoke-w9: die Beweisbilder sollen den Ruhezustand zeigen, und
 * dass es einer ist, gehoert als Zahl ins Artefakt und nicht als Zusicherung in
 * den Kopf.
 */
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.__atlasLlm?.policyVerdict ?? '') !== '',
        undefined,
        { timeout: 60000 },
    );
}

const settingsOpen = (page) =>
    page.evaluate(() => document.querySelector('[data-testid="atlas-settings"]') !== null);

async function openSettingsByMenu(page) {
    await page.click('[data-menu="a-settings"]');
    await page.waitForSelector('[data-testid="atlas-settings"]', { timeout: 15000 });
    await page.waitForTimeout(350);
}

async function openSettingsByCommand(page) {
    const input = page.locator('[data-testid="atlas-command-input"]');
    await input.click();
    await input.fill('');
    await input.pressSequentially('settings', { delay: 20 });
    await page.waitForTimeout(300);
    await input.press('Enter');
    await page.waitForSelector('[data-testid="atlas-settings"]', { timeout: 15000 });
    await page.waitForTimeout(350);
}

async function closeSettings(page) {
    if (!(await settingsOpen(page))) {
        return;
    }
    await page.click('[data-testid="atlas-settings-close"]');
    await page.waitForSelector('[data-testid="atlas-settings"]', { state: 'detached', timeout: 15000 });
    await page.waitForTimeout(250);
}

const waitForLlm = (page, state, timeout) =>
    page.waitForFunction(
        (expected) => globalThis.__atlasLlm?.state === expected,
        state,
        { timeout },
    );

/** Eine Frage in die Kommandozeile tippen und abschicken, wie ein Leser es tut. */
async function ask(page, question) {
    const input = page.locator('[data-testid="atlas-command-input"]');
    await input.click();
    await input.fill('');
    await input.pressSequentially(question, { delay: 8 });
    await page.waitForTimeout(600);
    await input.press('Enter');
}

/**
 * Warten, bis der `count`-te Zug in einer Endlage steht.
 *
 * Die Zahl gehoert dazu, weil zweimal dieselbe Frage gestellt wird: ohne sie
 * waere die Bedingung schon durch den ERSTEN Zug erfuellt, und der zweite Lauf
 * wuerde eine Antwort messen, die vor dem Umschalten entstanden ist.
 */
const waitForTurnEnd = (page, count, timeout) =>
    page.waitForFunction(
        (wanted) => {
            const turns = globalThis.__atlasChat?.turns ?? [];
            if (turns.length < wanted) {
                return false;
            }
            const turn = turns[wanted - 1];
            return ['answered', 'no-cards', 'refused', 'failed', 'needs-choice'].includes(turn.status);
        },
        count,
        { timeout },
    );

/** Ein Symbol in den Fokus holen. Derselbe Weg wie in smoke-w7c. */
async function focusSymbol(page) {
    await page.click(`[data-testid="atlas-tree-row"][data-path="${FOCUS_FILE}"]`);
    await page.waitForFunction(
        (path) => (globalThis.__atlasReader?.document?.path ?? '') === path,
        FOCUS_FILE,
        { timeout: 30000 },
    );
    await page.evaluate((line) => {
        globalThis.__atlasReader?.editor?.setPosition?.({ lineNumber: line, column: 5 });
        globalThis.__atlasReader?.editor?.focus?.();
    }, FOCUS_LINE);
    await page.waitForFunction(
        (name) => (globalThis.__atlasTwin?.qualifiedName ?? '').endsWith(name),
        FOCUS_SYMBOL,
        { timeout: 30000 },
    );
}

/**
 * Ein Beweisbild aufnehmen.
 *
 * Erst jeden offenen Tooltip zumachen und jeden Bereich an den Anfang, dann
 * warten, bis die Oberflaeche das mitbekommen hat, dann die Lage aufschreiben,
 * dann das Bild. Ein Bild mit einem Kasten unter dem Mauszeiger zeigt einen
 * Zustand, den ein Leser nur waehrend einer Bewegung sieht; dass keiner offen
 * war, steht als `hintOpen` im Artefakt statt als Zusicherung im Kopf.
 *
 * Ist ein Abschnitt genannt, wird das Panel absichtlich bis zu ihm gescrollt:
 * es ist hoeher als sein Fenster, und die Gruppen darunter waeren sonst auf
 * keinem Bild. Mit `fit` wird zusaetzlich die BESTE Lage gesucht statt der
 * obersten, siehe {@link fitScroll}.
 */
async function shoot(page, file, name, section, options = {}) {
    await closeTooltips(page);
    await resetScroll(page, READABILITY_EXCLUSIONS);
    await page.waitForTimeout(350);
    let scrolledTo = '';
    let framing = null;
    if (section !== undefined && options.fit === undefined) {
        scrolledTo = await page.evaluate((wanted) => {
            const root = document.querySelector('[data-testid="atlas-settings"]');
            const target = root?.querySelector(
                `[data-testid="atlas-settings-section"][data-section="${wanted}"]`,
            );
            if (root === null || target === null || target === undefined) {
                return '';
            }
            root.scrollTop += target.getBoundingClientRect().top
                - root.getBoundingClientRect().top - 8;
            return wanted;
        }, section);
        await page.waitForTimeout(400);
    }
    if (section !== undefined && options.fit !== undefined) {
        framing = await fitScroll(page, section);
        scrolledTo = section;
        await page.waitForTimeout(500);
    }
    await closeTooltips(page);
    await page.waitForTimeout(150);
    const state = await scrollState(page);
    await page.screenshot({ path: file, fullPage: false });
    const size = (await stat(file)).size;
    /*
     * Was auf DIESEM Bild wirklich zu sehen ist, als Liste und nicht als
     * Bildunterschrift. Ein Panel, das laenger ist als das Fenster, zeigt in
     * einer Aufnahme nie alles; welche Teile es waren, gehoert darum ins
     * Artefakt und nicht in einen Satz, den niemand nachprueft.
     */
    const shows = await page.evaluate(() => {
        const wanted = [
            'atlas-settings-title', 'atlas-settings-running', 'atlas-settings-models',
            'atlas-settings-cache-count', 'atlas-settings-honesty', 'atlas-settings-no-progress',
            'atlas-settings-suggestions', 'atlas-settings-copy', 'atlas-settings-repo-input',
            'atlas-settings-repo-command', 'atlas-settings-perf', 'atlas-settings-llm-off',
            'atlas-settings-profiles', 'atlas-settings-keeps',
        ];
        const out = {};
        for (const id of wanted) {
            const node = document.querySelector(`[data-testid="${id}"]`);
            if (node === null) {
                out[id] = 'absent';
                continue;
            }
            const rect = node.getBoundingClientRect();
            const onScreen = rect.bottom > 0 && rect.top < window.innerHeight
                && rect.right > 0 && rect.left < window.innerWidth;
            out[id] = onScreen ? 'in view' : 'off screen';
        }
        /* Und die Messabsaetze einzeln, mit dem Urteil, das auf dem Bild steht. */
        out.measuresInView = [...document.querySelectorAll('[data-testid="atlas-settings-measure"]')]
            .filter((node) => {
                const rect = node.getBoundingClientRect();
                return rect.top >= 0 && rect.bottom <= window.innerHeight && rect.height > 0;
            })
            .map((node) => ({
                setting: node.getAttribute('data-setting') ?? '',
                verdict: node.getAttribute('data-verdict') ?? '',
                before: node.getAttribute('data-before') ?? '',
                after: node.getAttribute('data-after') ?? '',
            }));
        out.hintOpen = (() => {
            const box = document.querySelector('[data-testid="atlas-hint"]');
            if (box === null) {
                return false;
            }
            const rect = box.getBoundingClientRect();
            return globalThis.getComputedStyle(box).visibility !== 'hidden'
                && rect.width > 0 && rect.height > 0;
        })();
        return out;
    });
    log(`${name}: aufgenommen (atRest=${state.atRest}, ${Math.round(size / 1024)} KB`
        + `${scrolledTo === '' ? '' : `, gescrollt zu ${scrolledTo}`}`
        + `${framing === null ? '' : `, Lage ${framing.chosenTop} von ${framing.range}, Punkte ${framing.bestScore}`}`
        + `, Tooltip offen ${shows.hintOpen})`);
    return {
        name,
        atRest: state.atRest,
        scrolledTo,
        bytes: size,
        shows,
        framing,
        /*
         * Warum dieses Bild NICHT im Ruhezustand steht, wenn es das nicht tut.
         * Ein Satz, und er gehoert ins Artefakt und nicht in den Kopf dieser
         * Datei: wer die Bilder ansieht, soll die Abweichung dort finden, wo die
         * Zahl steht, die sie meldet.
         */
        why: state.atRest
            ? ''
            : options.why ?? `Das Panel ist hoeher als sein Fenster. Es wurde zur Gruppe `
                + `"${scrolledTo}" gescrollt, weil sie sonst auf keinem Beweisbild zu sehen waere.`,
        regions: state.regions,
    };
}

/**
 * Die beste Lage fuer ein Bild dieser Gruppe suchen, statt sie zu raten.
 *
 * Die Gruppe "Darstellung und Leistung" ist hoeher als das Fenster des Panels:
 * der Lebendzaehler steht oben, die acht Messabsaetze verteilen sich darunter,
 * das Sparprofil und der Weg zurueck stehen am Ende. Es gibt also keine Lage,
 * die alles zeigt, und welche die beste ist, haengt an Schriftgroessen und
 * Fensterhoehe dieser Maschine.
 *
 * Statt eine Zahl zu raten, faehrt diese Funktion die Gruppe in Schritten ab und
 * ZAEHLT an jeder Lage, was ganz im Bild steht: der Lebendzaehler und die zwei
 * Profilknoepfe zaehlen doppelt (AC9 nennt sie ausdruecklich), jeder Messabsatz
 * mit einem fertigen Urteil einfach. Genommen wird die beste Lage, und die
 * Punkte aller Lagen stehen im Artefakt: ein Leser sieht damit, dass die
 * Aufnahme die beste verfuegbare ist und nicht die erstbeste.
 */
const fitScroll = (page, section) =>
    page.evaluate((wanted) => {
        const root = document.querySelector('[data-testid="atlas-settings"]');
        const target = root?.querySelector(
            `[data-testid="atlas-settings-section"][data-section="${wanted}"]`,
        );
        if (root === null || target === null || target === undefined) {
            return null;
        }
        const fully = (node) => {
            const box = root.getBoundingClientRect();
            const rect = node.getBoundingClientRect();
            return rect.height > 0 && rect.top >= box.top && rect.bottom <= box.bottom;
        };
        const score = () => {
            const perf = root.querySelector('[data-testid="atlas-settings-perf"]');
            const profiles = [...root.querySelectorAll('[data-testid="atlas-settings-profile"]')];
            const measures = [...root.querySelectorAll('[data-testid="atlas-settings-measure"]')]
                .filter((node) => {
                    const verdict = node.getAttribute('data-verdict') ?? '';
                    return verdict !== 'not-measured' && verdict !== 'measuring';
                });
            const perfIn = perf !== null && fully(perf) ? 1 : 0;
            const profilesIn = profiles.filter(fully).length;
            const measuresIn = measures.filter(fully).length;
            return {
                perfIn,
                profilesIn,
                measuresIn,
                measuresTotal: measures.length,
                points: perfIn * 2 + profilesIn * 2 + measuresIn,
            };
        };
        const first = target.getBoundingClientRect().top - root.getBoundingClientRect().top;
        const top = Math.max(0, root.scrollTop + first - 8);
        const bottom = Math.min(
            root.scrollHeight - root.clientHeight,
            root.scrollTop + first + target.getBoundingClientRect().height - root.clientHeight + 8,
        );
        const tried = [];
        let best = { top, ...score() };
        const steps = 16;
        for (let i = 0; i <= steps; i += 1) {
            const value = Math.round(top + ((bottom - top) * i) / steps);
            root.scrollTop = value;
            const here = { top: root.scrollTop, ...score() };
            tried.push(here);
            if (here.points > best.points) {
                best = here;
            }
        }
        root.scrollTop = best.top;
        return {
            section: wanted,
            chosenTop: root.scrollTop,
            range: `${Math.round(top)} bis ${Math.round(bottom)}`,
            bestScore: best.points,
            best,
            tried,
            weights: 'Lebendzaehler 2, je Profilknopf 2, je fertiger Messabsatz 1',
        };
    }, section);

// ------------------------------------------------------------ AC9 -----------

/** Die Zahl aus einem `data-`Attribut, oder null, wenn dort nichts steht. */
function numberOf(value) {
    if (value === undefined || value === null || String(value).trim() === '') {
        return null;
    }
    const parsed = Number(value);
    return Number.isFinite(parsed) ? parsed : null;
}

async function main() {
    const totalStarted = Date.now();
    let serverChild = null;
    let proxy = null;
    let browser = null;
    let home = null;
    let runtimeDir = null;
    let cacheDir = null;
    let emptyDir = null;
    let routerChild = null;
    let routerKids = [];
    let singleChild = null;
    let singleKids = [];
    let serverPort = 0;
    let uiPort = 0;
    let routerPort = 0;
    let singlePort = 0;
    let failure = null;
    const timings = {};
    const childPorts = new Set();

    const report = {
        settingsPanelOpens: false,
        runningModelFromProps: false,
        cacheModelsListed: 0,
        switchModelWorks: false,
        switchPersistsReload: false,
        statusBarNamesModel: false,
        noRouterExplained: false,
        suggestionsListed: 0,
        suggestionsShowMeasuredNumbers: false,
        freeRepoFieldAccepted: false,
        commandCopyable: false,
        downloadHonestyText: false,
        noFakeProgressBar: false,
        startScriptTakesModel: false,
        startScriptSaysHowToFetch: false,
        noWeightsInRepo: false,
        llmOffMakesNoRequests: false,
        panelExplainsItselfWhileOff: false,
        singleLineTruncatedIsUnmeasured: false,
        unmeasuredOutOfCitationRate: false,
        evalReportsUnmeasured: false,
        panelShowsUnmeasured: false,
        twoDimensionalMode: false,
        effectToggles: [],
        thriftProfileWorks: false,
        frameCapWorks: false,
        settingsPersistReload: false,
        everyToggleNamesMeasuredEffect: false,
        noEffectSaysSo: false,
        viewOnlyControlsStayed: false,
        overlapViolations: 0,
        clippingViolations: 0,
        cutWithoutHint: 0,
        port: 0,
        leftoverProcesses: 0,
    };

    const extras = {
        frameRateEnvironment: FRAME_RATE_ENVIRONMENT,
        blockedRequests: [],
        consoleErrors: [],
        pageErrors: [],
        sidecarRequests: [],
        productPortRequests: [],
        chatResponses: [],
        readability: [],
        shots: [],
        measurements: [],
    };

    const routeFor = (origin, sidecarOrigin) => async (route) => {
        const url = route.request().url();
        if (url.startsWith(PRODUCT_SIDECAR_ORIGIN)) {
            /*
             * Darf nicht vorkommen und wird darum abgebrochen statt
             * durchgelassen: auf 4141 laeuft der Sidecar des Nutzers, und ein
             * Beweislauf, der ihn "nur einmal kurz" fragt, hat ihn angefasst.
             */
            extras.productPortRequests.push(url);
            await route.abort();
            return;
        }
        if (url.startsWith(sidecarOrigin)) {
            extras.sidecarRequests.push({ url, atMs: Date.now() - totalStarted });
            await route.continue();
            return;
        }
        if (url.startsWith(origin) || url.startsWith('data:') || url.startsWith('blob:')) {
            await route.continue();
            return;
        }
        extras.blockedRequests.push(url);
        await route.abort();
    };

    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}`);
        }
        if (!existsSync(LLAMA_SERVER)) {
            throw new Error('vendor/llama/llama-server fehlt (siehe vendor/llama/HERKUNFT.md)');
        }
        if (!existsSync(EVAL_JSON)) {
            throw new Error(`${EVAL_JSON} fehlt: dieser Lauf haelt die Vorschlaege dagegen.`);
        }
        for (const file of [MODEL_A, MODEL_B]) {
            if (!existsSync(join(ROOT, 'models', file))) {
                throw new Error(
                    `models/${file} fehlt. Dieser Lauf laedt NICHTS nach: er braucht zwei Modelle `
                    + 'im Cache, um das Umschalten zu messen. Holen: llm/fetch-model.sh --list',
                );
            }
        }

        const evalReport = JSON.parse(await readFile(EVAL_JSON, 'utf8'));

        // ------------------------------------------------------------ 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 + build.err).trim().slice(-600)}`);
        }

        // ---------------------------------------------- 2. HOME, Rendezvous
        home = await mkdtemp(join(tmpdir(), 'codeatlasweb-w10-home-'));
        runtimeDir = await mkdtemp('/private/tmp/codeatlasweb-w10-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}`);

        // ---------------------------- 5. Das eigene Cache-Verzeichnis, verlinkt
        cacheDir = await mkdtemp('/private/tmp/codeatlasweb-w10-cache-');
        const links = [];
        for (const file of [MODEL_A, MODEL_B]) {
            const source = join(ROOT, 'models', file);
            const target = join(cacheDir, file);
            let how = 'link';
            try {
                await link(source, target);
            } catch (error) {
                how = `copy (link scheiterte: ${error.message})`;
                await copyFile(source, target);
            }
            const info = await stat(target);
            links.push({ file, how, bytes: info.size, links: info.nlink });
        }
        extras.cacheDir = { path: cacheDir, entries: links };
        log(`Cache-Verzeichnis: ${cacheDir} (${links.map((entry) => `${entry.file} per ${entry.how}`).join(', ')})`);

        // ------------------------------------------------ 6. Der Router selbst
        routerPort = await findFreePort(MIN_PORT, [serverPort, uiPort]);
        const routerOrigin = `http://127.0.0.1:${routerPort}`;
        const routerLog = [];
        const routerStarted = Date.now();
        const router = await startSidecar(
            [
                '--host', '127.0.0.1', '--port', String(routerPort),
                '--models-dir', cacheDir,
                '--models-max', '2',
                '--models-autoload',
                '-c', String(ROUTER_CTX),
            ],
            { port: routerPort, log: routerLog },
        );
        routerChild = router.child;
        timings.routerReadyMs = Date.now() - routerStarted;
        log(`Router auf ${routerPort}, bereit nach ${router.readyMs} ms`);

        // ------------------------------------------------------- 7. Browser
        const { chromium } = await import('playwright');
        browser = await chromium.launch({ headless: true, args: CHROMIUM_ARGS });
        const origin = `http://127.0.0.1:${uiPort}`;
        const context = await browser.newContext({ viewport: { ...MAIN_VIEWPORT } });
        await context.grantPermissions(['clipboard-read', 'clipboard-write'], { origin })
            .catch((error) => {
                extras.clipboardPermission = `abgelehnt: ${error.message}`;
            });
        /*
         * Die Umleitung, an der Naht, an der die Anwendung ihre Anfragen selbst
         * stellt. Woertlich nach dem Muster aus smoke-w7c; siehe Kopf.
         */
        await context.addInitScript(({ from, to }) => {
            const original = globalThis.fetch.bind(globalThis);
            globalThis.fetch = (input, init) => {
                const url = typeof input === 'string'
                    ? input
                    : input instanceof URL ? input.href : input?.url ?? '';
                if (typeof url === 'string' && url.startsWith(from)) {
                    return original(to + url.slice(from.length), init);
                }
                return original(input, init);
            };
        }, { from: PRODUCT_SIDECAR_ORIGIN, to: routerOrigin });
        await context.route('**/*', routeFor(origin, routerOrigin));
        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)));
        /*
         * Der aufgezeichnete Antwortkoerper jeder Chat-Anfrage.
         *
         * Der Beleg fuer das Umschalten soll aus dem kommen, was die ANWENDUNG
         * geschickt und bekommen hat, und nicht aus einer eigenen Anfrage
         * daneben: eine eigene curl-Anfrage wuerde beweisen, dass der Router
         * umschalten kann, und nicht, dass das Panel ihn dazu bringt.
         */
        page.on('response', (response) => {
            const url = response.url();
            if (!url.includes('/v1/chat/completions')) {
                return;
            }
            void response.json()
                .then((body) => {
                    extras.chatResponses.push({
                        url,
                        status: response.status(),
                        model: typeof body?.model === 'string' ? body.model : '',
                        finishReason: body?.choices?.[0]?.finish_reason ?? '',
                        contentChars: (body?.choices?.[0]?.message?.content ?? '').length,
                        atMs: Date.now() - totalStarted,
                    });
                })
                .catch((error) => {
                    extras.chatResponses.push({
                        url,
                        status: response.status(),
                        model: '',
                        error: String(error).slice(0, 200),
                        atMs: Date.now() - totalStarted,
                    });
                });
        });
        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(220);
            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;
            log(`Lesbarkeit "${name}": ${top.overlaps.length + bottom.overlaps.length} Ueberlagerungen, `
                + `${top.clipped.length + bottom.clipped.length} Beschneidungen`);
        };

        await openApp(page, origin);

        // ============================================================== AC5 ==
        // Das Panel bei ausgeschaltetem Modell. VOR allem anderen, denn danach
        // laesst sich "es hat nie gefragt" nicht mehr messen.
        const offSeamBefore = await llmSeam(page);
        await openSettingsByMenu(page);
        const offDom = await settingsDom(page);
        const offSettingsSeam = await settingsSeam(page);
        log(`Panel bei ausgeschaltetem Modell: Zustand ${offDom.llmState}, `
            + `${offDom.sections.length} Gruppen, Aktualisieren-Knopf ${offDom.refresh.present}`);

        const offWaitStarted = Date.now();
        await page.waitForTimeout(OFF_WINDOW_MS);
        timings.offWindowMs = Date.now() - offWaitStarted;
        const offSeamAfter = await llmSeam(page);
        const offSettingsAfter = await settingsSeam(page);
        const offRequests = extras.sidecarRequests.length;

        report.llmOffMakesNoRequests =
            offRequests === 0
            && (offSeamAfter?.probes ?? -1) === 0
            && (offSettingsAfter?.probes ?? -1) === 0
            && extras.productPortRequests.length === 0;
        report.panelExplainsItselfWhileOff =
            offDom.present === true
            && offDom.visible === true
            && offDom.llmState === 'off'
            && offDom.llmOff.present === true
            && offDom.llmOff.text.length > 80
            && offDom.cacheCount.present === false
            && offDom.models.length === 0
            && offDom.facts.length === 0
            && offDom.sections.length === 4;
        extras.llmOff = {
            waitedMs: timings.offWindowMs,
            pollIntervalsCovered: Number((timings.offWindowMs / 3000).toFixed(2)),
            sidecarRequests: offRequests,
            probesBefore: offSeamBefore?.probes ?? null,
            probesAfterLlmSeam: offSeamAfter?.probes ?? null,
            probesAfterSettingsSeam: offSettingsAfter?.probes ?? null,
            productPortRequests: extras.productPortRequests.length,
            panelState: offDom.llmState,
            sections: offDom.sections.map((section) => section.name),
            offNoteText: offDom.llmOff.text,
            /*
             * Der Aktualisieren-Knopf: gesehen, nicht gedrueckt, und er steht
             * hier gar nicht. Das ist das Verhalten des Produkts und nicht ein
             * fehlendes Element (SettingsPanel.tsx, Entscheidung 2: ein Knopf,
             * der nichts tut, existiert in dieser Oberflaeche nicht). Gedrueckt
             * wird er weiter unten, mit eingeschaltetem Modell, und dann wird
             * gemessen, dass seine Anfrage im selben Zaehler landet.
             */
            refreshButtonPresent: offDom.refresh.present,
            refreshButtonPressed: false,
            cacheListShown: offDom.cacheCount.present,
            modelRowsShown: offDom.models.length,
            factsShown: offDom.facts.length,
            settingsSeam: offSettingsSeam === null
                ? null
                : {
                    open: offSettingsSeam.open,
                    llmOn: offSettingsSeam.llmOn,
                    router: offSettingsSeam.router,
                    cacheModels: offSettingsSeam.cacheModels.length,
                    suggestions: offSettingsSeam.suggestions.length,
                },
        };
        log(`aus heisst aus: ${offRequests} Anfragen an den Sidecar, `
            + `Proben ${offSeamAfter?.probes}, Panel erklaert sich ${report.panelExplainsItselfWhileOff}`);

        await readability('Einstellungen offen, lokales Modell aus');
        await closeSettings(page);

        // ============================================== Das Modell einschalten
        await page.click('[data-menu="a-llm"]');
        await waitForLlm(page, 'ready', READY_TIMEOUT_MS);
        const readySeam = await settingsSeam(page);
        log(`Modell an: Router ${readySeam?.router}, `
            + `${readySeam?.cacheModels.length} Modelle im Cache, `
            + `laeuft ${readySeam?.running.model}`);

        // ============================================================== AC1 ==
        // Zwei Wege ins Panel, und beide werden gefahren.
        await openSettingsByMenu(page);
        const openedByMenu = await settingsOpen(page);
        await closeSettings(page);
        const closedBetween = !(await settingsOpen(page));
        await openSettingsByCommand(page);
        const openedByCommand = await settingsOpen(page);
        report.settingsPanelOpens = openedByMenu && closedBetween && openedByCommand;
        extras.panelOpens = {
            byMenu: openedByMenu,
            closedBetween,
            byCommandLine: openedByCommand,
            menuSelector: '[data-menu="a-settings"]',
            commandWord: 'settings',
        };
        log(`Panel oeffnet ueber die Menuezeile ${openedByMenu}, `
            + `ueber die Kommandozeile ${openedByCommand}`);

        // ---------------------- Die vier Zahlen, gegen die eigene Abfrage
        /*
         * Erst ein paar Proben abwarten, und der Grund ist eine Messung dieses
         * Laufs: die ERSTE Probe fragt `/v1/models`, bevor sie mit
         * `/props?model=` das Modell ueberhaupt laedt. Der Router fuehrt `meta`
         * nur fuer geladene Instanzen, also kennt die Oberflaeche nach der
         * ersten Probe die Groesse der Gewichte noch nicht und sagt genau das
         * ("the process did not report this"). Ab der zweiten Probe steht die
         * Zahl da. Gemessen wird darum die Lage, die ein Leser nach ein paar
         * Sekunden vor sich hat, und die Zahl der abgewarteten Proben steht im
         * Artefakt.
         */
        await page.waitForFunction(
            () => (globalThis.__atlasSettings?.probes ?? 0) >= 3,
            undefined,
            { timeout: 60000 },
        );
        await page.waitForTimeout(600);
        const panelReady = await settingsDom(page);
        const seamReady = await settingsSeam(page);
        const activeId = seamReady?.cacheModels.find((model) => model.active)?.id
            ?? seamReady?.cacheModels[0]?.id ?? '';
        /*
         * Erst die Props, dann die Liste, und diese Reihenfolge ist keine
         * Geschmacksfrage: `meta` fuehrt der Router NUR fuer geladene Instanzen,
         * und `/props?model=` ist genau der Aufruf, der eine laedt. Andersherum
         * gefragt, waere die Groesse leer und der Vergleich eine Aussage ueber
         * eine Datei, die niemand geoeffnet hat.
         */
        const ownProps = await routerProps(routerOrigin, activeId);
        const ownModels = await routerModels(routerOrigin);
        const ownEntry = (ownModels.data ?? []).find((entry) => entry.id === activeId) ?? {};
        const ownMeta = ownEntry.meta ?? {};
        const factOf = (name) => panelReady.facts.find((fact) => fact.fact === name);

        const nameMatches = (factOf('name')?.value ?? '') === (ownProps.model_path ?? '');
        const quantMatches = (factOf('quantization')?.value ?? '') === (ownProps.model_ftype ?? '');
        const ownCtx = ownProps?.default_generation_settings?.n_ctx;
        const contextMatches =
            (seamReady?.running.contextTokens ?? -1) === ownCtx
            && (factOf('context')?.value ?? '').includes(String(ownCtx))
            && ownCtx === ROUTER_CTX;
        const weightsMatch =
            (seamReady?.running.weightsBytes ?? -1) === (ownMeta.size ?? -2)
            && (factOf('weights')?.value ?? '').length > 0;
        report.runningModelFromProps =
            panelReady.running.present === true
            && panelReady.facts.length === 4
            && nameMatches && quantMatches && contextMatches && weightsMatch;
        extras.runningModel = {
            activeId,
            askedByThisRun: {
                url: `${routerOrigin}/props?model=${activeId}`,
                model_path: ownProps.model_path ?? '',
                model_ftype: ownProps.model_ftype ?? '',
                n_ctx: ownCtx ?? null,
                n_ctx_train: ownMeta.n_ctx_train ?? null,
                size: ownMeta.size ?? null,
                n_params: ownMeta.n_params ?? null,
            },
            shownInPanel: panelReady.facts,
            seamRunning: seamReady?.running ?? null,
            comparison: { nameMatches, quantMatches, contextMatches, weightsMatch },
            probesBeforeReading: seamReady?.probes ?? null,
            firstProbeNote:
                'Nach der ERSTEN Probe steht bei den Gewichten "the process did not report this", '
                + 'und das ist richtig: die Probe fragt /v1/models, bevor sie mit /props?model= das '
                + 'Modell laedt, und der Router fuehrt meta nur fuer geladene Instanzen. Gemessen '
                + 'wurde nach der dritten Probe, also in der Lage, die ein Leser nach wenigen '
                + 'Sekunden vor sich hat.',
        };
        log(`laufendes Modell: Name ${nameMatches}, Quantisierung ${quantMatches} `
            + `(${ownProps.model_ftype}), Kontext ${contextMatches} (${ownCtx}), `
            + `Gewichte ${weightsMatch} (${ownMeta.size} B)`);

        // ------------------------------------------ Die Modelle im Cache
        report.cacheModelsListed = panelReady.models.length;
        extras.cacheModels = {
            rowsInPanel: panelReady.models.length,
            countAttribute: panelReady.cacheCount.count,
            countText: panelReady.cacheCount.text,
            askedByThisRun: (ownModels.data ?? []).map((entry) => ({
                id: entry.id,
                status: entry.status?.value ?? '',
                size: entry.meta?.size ?? null,
            })),
            rows: panelReady.models,
        };
        log(`Cache-Liste: ${panelReady.models.length} Zeilen, Attribut `
            + `${panelReady.cacheCount.count}, eigene Abfrage ${(ownModels.data ?? []).length}`);

        // ----------------------------- Der Aktualisieren-Knopf, jetzt gedrueckt
        const probesBeforeRefresh = (await settingsSeam(page))?.probes ?? -1;
        const requestsBeforeRefresh = extras.sidecarRequests.length;
        let refreshPressed = false;
        if (panelReady.refresh.present) {
            await page.click('[data-testid="atlas-settings-refresh"]');
            await page.waitForTimeout(1200);
            refreshPressed = true;
        }
        const probesAfterRefresh = (await settingsSeam(page))?.probes ?? -1;
        extras.refreshButton = {
            presentWhileOn: panelReady.refresh.present,
            label: panelReady.refresh.text,
            pressed: refreshPressed,
            probesBefore: probesBeforeRefresh,
            probesAfter: probesAfterRefresh,
            sidecarRequestsBefore: requestsBeforeRefresh,
            sidecarRequestsAfter: extras.sidecarRequests.length,
            countsInSameProbeCounter: probesAfterRefresh > probesBeforeRefresh,
        };
        log(`Aktualisieren-Knopf gedrueckt: Proben ${probesBeforeRefresh} -> ${probesAfterRefresh}`);

        // ============================================================== AC3 ==
        const afterRefresh = await settingsDom(page);
        report.suggestionsListed = afterRefresh.suggestions.length;
        const evalByName = new Map((evalReport.models ?? []).map((model) => [model.name, model]));
        const suggestionChecks = [];
        for (const suggestion of afterRefresh.suggestions) {
            const measured = evalByName.get(suggestion.name);
            const fileOnDisk = measured === undefined
                ? null
                : await stat(join(ROOT, 'models', measured.file)).then(
                    (info) => info.size,
                    () => null,
                );
            const check = {
                id: suggestion.suggestion,
                name: suggestion.name,
                repo: suggestion.repo,
                shown: {
                    passRate: numberOf(suggestion['pass-rate']),
                    citation: numberOf(suggestion.citation),
                    tokensPerSecond: numberOf(suggestion['tokens-per-second']),
                    bytes: numberOf(suggestion.bytes),
                    unmeasured: suggestion['citation-unmeasured'],
                },
                fromEvalJson: measured === undefined
                    ? null
                    : {
                        passRate: measured.passRate,
                        citation: measured.citationCompliance,
                        tokensPerSecond: measured.meanTokPerSec,
                        file: measured.file,
                    },
                bytesOnDisk: fileOnDisk,
            };
            check.passRateMatches = measured !== undefined
                && check.shown.passRate === measured.passRate;
            check.citationMatches = measured !== undefined
                && check.shown.citation === measured.citationCompliance;
            check.speedMatches = measured !== undefined
                && check.shown.tokensPerSecond === measured.meanTokPerSec;
            check.bytesMatchFile = fileOnDisk !== null && check.shown.bytes === fileOnDisk;
            check.textCarriesNumbers =
                suggestion.passText.length > 0 && suggestion.citationText.length > 0;
            check.ok = check.passRateMatches && check.citationMatches && check.speedMatches
                && check.bytesMatchFile && check.textCarriesNumbers;
            suggestionChecks.push(check);
        }
        report.suggestionsShowMeasuredNumbers =
            suggestionChecks.length >= 6 && suggestionChecks.every((check) => check.ok);
        extras.suggestions = {
            source: 'verification/w5/eval.json (Trefferquote, Zitattreue, Tempo) und die '
                + 'Dateigroesse in models/ (Bytes)',
            checks: suggestionChecks,
        };
        log(`Vorschlaege: ${report.suggestionsListed}, alle Zahlen gegen die Eval geprueft `
            + `${report.suggestionsShowMeasuredNumbers}`);

        // ------------------------------------ Die nicht gemessenen Antworten
        report.panelShowsUnmeasured =
            afterRefresh.suggestions.length >= 6
            && afterRefresh.suggestions.every((suggestion) =>
                suggestion.unmeasuredBesideCitation === true
                && suggestion.unmeasuredText.length > 0);
        extras.panelUnmeasured = {
            rows: afterRefresh.suggestions.map((suggestion) => ({
                id: suggestion.suggestion,
                attribute: suggestion['citation-unmeasured'],
                text: suggestion.unmeasuredText,
                insideCitationCell: suggestion.unmeasuredBesideCitation,
            })),
            note:
                'Das Attribut ist bei allen sechs leer, und der Satz daneben sagt genau das: '
                + 'verification/w5/eval.json stammt von VOR der Aenderung an der Zitatpruefung '
                + 'und weist die Zahl nicht aus. Eine Null waere hier die Behauptung, es habe '
                + 'keine ungemessene Antwort gegeben.',
        };

        // ------------------------------------------------- Das freie Feld
        const repoField = page.locator('[data-testid="atlas-settings-repo-input"]');
        await repoField.click();
        await repoField.fill('');
        await repoField.pressSequentially(FREE_REPO_INPUT, { delay: 15 });
        await page.waitForTimeout(400);
        const withRepo = await settingsDom(page);
        report.freeRepoFieldAccepted =
            withRepo.repoState.present === true
            && withRepo.repoState.valid === 'true'
            && withRepo.repoState.problem === ''
            && withRepo.repoCommand.present === true
            && withRepo.repoCommand.command.includes(FREE_REPO_INPUT);
        extras.freeRepoField = {
            typed: FREE_REPO_INPUT,
            state: withRepo.repoState,
            command: withRepo.repoCommand.command,
            commandText: withRepo.repoCommand.text,
        };
        log(`freies Feld: "${FREE_REPO_INPUT}" -> "${withRepo.repoCommand.command}"`);

        // ------------------------------------------------ Der Kopieren-Knopf
        let clipboardText = '';
        let clipboardError = '';
        const copyButton = page.locator('.atlas-settings-free [data-testid="atlas-settings-copy"]').first();
        await copyButton.click();
        await page.waitForTimeout(500);
        try {
            clipboardText = await page.evaluate(async () => {
                const value = await navigator.clipboard.readText();
                return typeof value === 'string' ? value : '';
            });
        } catch (error) {
            clipboardError = String(error).slice(0, 300);
        }
        const afterCopy = await settingsDom(page);
        const copyFailedShown = await page.evaluate(() =>
            document.querySelector('[data-testid="atlas-settings-copy-failed"]') !== null);
        const clipboardMatches = clipboardText.trim() === withRepo.repoCommand.command;
        report.commandCopyable =
            afterCopy.repoCommand.present === true
            && afterCopy.repoCommand.command.length > 0
            && copyFailedShown === false
            && clipboardMatches;
        extras.copyButton = {
            method: clipboardError === ''
                ? 'context.grantPermissions([clipboard-read, clipboard-write]) und danach '
                    + 'navigator.clipboard.readText() in der Seite gelesen'
                : `navigator.clipboard.readText() scheiterte (${clipboardError}); gemessen wurde `
                    + 'dann nur der sichtbare Befehlstext und die Abwesenheit der Fehlermeldung',
            clipboard: clipboardText,
            expected: withRepo.repoCommand.command,
            clipboardMatches,
            copyFailedShown,
            visibleCommandText: afterCopy.repoCommand.text,
        };
        log(`Kopieren: Zwischenablage "${clipboardText}" gegen Befehl `
            + `"${withRepo.repoCommand.command}" -> ${clipboardMatches}`);

        // ------------------------------------------ Der Ehrlichkeitssatz
        const honesty = afterCopy.honesty.text;
        const honestyParts = [
            { part: 'a) der Netzzugriff', pattern: /goes out to the network/i },
            { part: 'b) das Ziel', pattern: /huggingface\.co/i },
            {
                part: 'c) wohin geladen wird',
                pattern: /model cache of this project, models\/ next to the repository \(ATLAS_MODELS_DIR or LLAMA_CACHE move it elsewhere\)/i,
            },
            { part: 'd) die Anwendung laedt selbst nichts', pattern: /this application downloads nothing itself/i },
        ].map((entry) => {
            const match = honesty.match(entry.pattern);
            return {
                part: entry.part,
                pattern: String(entry.pattern),
                found: match !== null,
                at: match === null ? -1 : match.index,
                excerpt: match === null ? '' : match[0],
            };
        });
        report.downloadHonestyText =
            afterCopy.honesty.present === true && honestyParts.every((entry) => entry.found);
        extras.honestyText = { text: honesty, parts: honestyParts };
        log(`Ehrlichkeitssatz: ${honestyParts.filter((entry) => entry.found).length} von vier Teilen belegt`);

        // ----------------------------------------- Kein Fortschrittsbalken
        report.noFakeProgressBar = afterCopy.progressElements.length === 0;
        extras.progressElements = {
            found: afterCopy.progressElements,
            count: afterCopy.progressElements.length,
            searched:
                'progress, [role="progressbar"], [aria-valuenow], [class*="progress"], '
                + '[class*="fortschritt"], [data-testid*="progress"], [data-testid*="fortschritt"], '
                + 'im ganzen Panel',
            exempted: {
                testid: 'atlas-settings-no-progress',
                why: 'Der Absatz, der SAGT, dass es keinen Balken gibt. Seine Testmarke traegt das '
                    + 'Wort, nach dem gesucht wird; ihn mitzuzaehlen hiesse, den Satz gegen sich '
                    + 'selbst zu verwenden.',
                text: afterCopy.progressExemption,
            },
        };
        log(`Fortschrittselemente im Panel: ${afterCopy.progressElements.length}`);

        await readability('Einstellungen offen, Modellgruppe');
        extras.shots.push(await shoot(page, SHOT_SETTINGS, 'settings.png'));
        extras.shots.push(await shoot(page, SHOT_FETCH, 'settings-fetch.png', 'model-fetch'));

        // ============================================================== AC2 ==
        // Umschalten, fragen, zurueckschalten, fragen. Zwei Modellnamen aus den
        // aufgezeichneten Antworten.
        await closeSettings(page);
        await focusSymbol(page);
        extras.focusSymbol = await page.evaluate(() => globalThis.__atlasTwin?.qualifiedName ?? '');

        const modelIdA = (ownModels.data ?? []).find((entry) => entry.id.includes('MiniCPM'))?.id ?? '';
        const modelIdB = (ownModels.data ?? []).find((entry) => entry.id.includes('LFM2.5'))?.id ?? '';
        const askedWith = [];

        const pickModel = async (id) => {
            await openSettingsByMenu(page);
            await page.click(`button[data-testid="atlas-settings-model-pick"][data-model="${id}"]`);
            await page.waitForFunction(
                (wanted) => globalThis.__atlasSettings?.selectedModel === wanted,
                id,
                { timeout: 30000 },
            );
            await page.waitForTimeout(2500);
        };

        for (const id of [modelIdB, modelIdA]) {
            await pickModel(id);
            const picked = await settingsDom(page);
            const seamPicked = await settingsSeam(page);
            if (id === modelIdA) {
                // Das Bild nach dem Umschalten: die andere Zeile ist aktiv.
                extras.shots.push(await shoot(page, SHOT_SWITCH, 'settings-switch.png'));
            }
            await closeSettings(page);
            const before = extras.chatResponses.length;
            await ask(page, SWITCH_QUESTION);
            await waitForTurnEnd(page, askedWith.length + 1, ANSWER_TIMEOUT_MS)
                .catch((error) => {
                    extras.chatWaitProblem = String(error).slice(0, 200);
                });
            await page.waitForTimeout(1500);
            const seam = await chatSeam(page);
            const turn = (seam?.turns ?? []).slice(-1)[0];
            askedWith.push({
                selected: id,
                selectedInSeam: seamPicked?.selectedModel ?? '',
                activeRowInPanel: picked.models.find((row) => row.active === 'true')?.model ?? '',
                turnStatus: turn?.status ?? '',
                turnAnswerChars: (turn?.answer ?? '').length,
                responses: extras.chatResponses.slice(before),
                modelInResponse: extras.chatResponses.slice(before)
                    .map((entry) => entry.model).filter(Boolean).slice(-1)[0] ?? '',
            });
            log(`Frage mit ${id}: Zug ${turn?.status}, Antwort vom Modell `
                + `"${askedWith.slice(-1)[0].modelInResponse}"`);
        }

        const answered = askedWith.map((entry) => entry.modelInResponse).filter(Boolean);
        report.switchModelWorks =
            askedWith.length === 2
            && answered.length === 2
            && answered[0] !== answered[1]
            && answered[0] === askedWith[0].selected
            && answered[1] === askedWith[1].selected;
        extras.switching = {
            modelA: modelIdA,
            modelB: modelIdB,
            question: SWITCH_QUESTION,
            turns: askedWith,
            modelNamesInAnswers: answered,
            evidence:
                'Die Modellnamen stammen aus dem Antwortkoerper der Anfrage, die die ANWENDUNG '
                + 'selbst geschickt hat (page.on("response") auf /v1/chat/completions), nicht aus '
                + 'einer eigenen Abfrage dieses Laufs.',
        };
        log(`Umschalten belegt: ${report.switchModelWorks} (${answered.join(' und ')})`);

        // ------------------------------------------- Die Wahl ueberlebt den Reload
        const beforeReload = await settingsSeam(page);
        await page.reload({ waitUntil: 'load' });
        await page.waitForSelector('[data-testid="atlas-statusbar"]', { timeout: 30000 });
        await page.waitForSelector('[data-testid="atlas-galaxy"]', { timeout: 30000 });
        await page.waitForFunction(
            () => (globalThis.__atlasGalaxy?.nodes ?? 0) > 0,
            undefined,
            { timeout: 60000 },
        );
        await waitForLlm(page, 'ready', READY_TIMEOUT_MS);
        await page.waitForTimeout(2000);
        const afterReload = await settingsSeam(page);
        report.switchPersistsReload =
            (beforeReload?.selectedModel ?? '') !== ''
            && afterReload?.selectedModel === beforeReload?.selectedModel;
        extras.selectionAcrossReload = {
            before: beforeReload?.selectedModel ?? '',
            after: afterReload?.selectedModel ?? '',
            storageKey: afterReload?.storageKeys?.model ?? '',
            storedValue: await page.evaluate((key) => {
                try {
                    return globalThis.localStorage.getItem(key);
                } catch {
                    return null;
                }
            }, afterReload?.storageKeys?.model ?? ''),
        };

        // -------------------------------------------- Die Statusleiste nennt es
        const chip = await statusChip(page);
        const expectedName = (afterReload?.cacheModels ?? [])
            .find((model) => model.id === afterReload?.selectedModel)?.name ?? '';
        report.statusBarNamesModel =
            chip.present === true
            && expectedName.length > 0
            && chip.text.includes(expectedName);
        extras.statusBar = { chip, expectedName, selected: afterReload?.selectedModel ?? '' };
        log(`Statusleiste: "${chip.text}" nennt ${expectedName} -> ${report.statusBarNamesModel}`);

        // ============================================================== AC9 ==
        await openSettingsByMenu(page);
        const perfBefore = await perfSeam(page);
        extras.frameRateAtStart = perfBefore;
        if (perfBefore === null || perfBefore.running !== true) {
            throw new Error(
                'die Szene zeichnet nicht, also ist an ihr nichts zu messen: '
                + `__atlasGalaxyPerf = ${JSON.stringify(perfBefore)}`,
            );
        }
        log(`Bildrate vor der ersten Einstellung: ${perfBefore.fps.toFixed(1)} fps `
            + `(${perfBefore.nodes} Knoten, ${perfBefore.edges} Kanten, Band ${perfBefore.noiseBand.toFixed(1)})`);

        /**
         * Eine Einstellung umlegen und lesen, was das Panel dazu misst.
         *
         * Die Reihenfolge ist die Messung des Produkts und nicht die dieses
         * Laufs: erst laeuft die Szene lange genug ungestoert, damit es ein
         * Vorher-Fenster und ein Rauschband gibt, dann faellt der Klick, dann
         * wird gewartet, bis das Panel sein Urteil geschrieben hat. Gelesen wird
         * beides, das Attribut am Absatz und die Naht, und beide werden
         * verglichen: gingen sie auseinander, waere eine der beiden Zahlen
         * erfunden.
         */
        const measureSetting = async (label, clickSelector, settingKey) => {
            await page.waitForTimeout(SETTLE_BEFORE_MS);
            const perfAt = await perfSeam(page);
            await page.click(clickSelector);
            await page.waitForTimeout(MEASURE_WAIT_MS);
            const dom = await settingsDom(page);
            const seam = await settingsSeam(page);
            const shown = dom.measures.find((entry) => entry.setting === settingKey);
            const inSeam = (seam?.measurements ?? [])
                .filter((entry) => entry.setting === settingKey).slice(-1)[0];
            const perfAfter = await perfSeam(page);
            const entry = {
                label,
                setting: settingKey,
                clicked: clickSelector,
                value: dom.choices.find((choice) => choice.setting === settingKey)?.value
                    ?? (settingKey === 'thrifty' || settingKey === 'default' ? settingKey : ''),
                verdict: shown?.verdict ?? '',
                before: numberOf(shown?.before),
                after: numberOf(shown?.after),
                band: numberOf(shown?.band),
                nodes: numberOf(shown?.nodes),
                edges: numberOf(shown?.edges),
                at: shown?.at ?? '',
                text: shown?.text ?? '',
                seam: inSeam === undefined
                    ? null
                    : {
                        before: Number(inSeam.before.toFixed(2)),
                        after: Number(inSeam.after.toFixed(2)),
                        band: Number(inSeam.band.toFixed(2)),
                        verdict: inSeam.verdict,
                        nodes: inSeam.nodes,
                        edges: inSeam.edges,
                    },
                frameSeamBefore: perfAt === null ? null : { fps: Number(perfAt.fps.toFixed(2)), cap: perfAt.cap },
                frameSeamAfter: perfAfter === null ? null : { fps: Number(perfAfter.fps.toFixed(2)), cap: perfAfter.cap },
            };
            /*
             * Passen Anzeige und Naht zusammen? Verglichen wird auf der Genauigkeit
             * der ANZEIGE (eine Nachkommastelle unter 10, sonst ganze Zahlen), denn
             * genau die steht im Attribut; ein Unterschied darueber hinaus waere
             * eine zweite Rechnung fuer dieselbe Zahl.
             */
            const round = (value) => value === null ? null
                : value >= 10 ? Math.round(value) : Number(value.toFixed(1));
            entry.seamAgrees = inSeam === undefined ? false
                : entry.verdict === inSeam.verdict
                    && entry.before === round(inSeam.before)
                    && entry.after === round(inSeam.after);
            extras.measurements.push(entry);
            log(`  ${label}: ${entry.verdict} (vorher ${entry.before}, nachher ${entry.after}, `
                + `Band ${entry.band}, Naht stimmt ${entry.seamAgrees})`);
            return entry;
        };

        const optionSelector = (setting, option) =>
            `[data-setting="${setting}"] [data-testid="atlas-settings-option"][data-option="${option}"]`;

        // 1. Zwei Dimensionen statt drei.
        const clip = await sceneRect(page);
        if (clip === null || clip.width < 200 || clip.height < 200) {
            throw new Error(`die Zeichenflaeche ist zu klein zum Messen: ${JSON.stringify(clip)}`);
        }
        extras.sceneRect = clip;

        /**
         * Der Beleg fuer die Ansicht von oben, am BILD und nicht am Schalter.
         *
         * Eine orthografische Kamera hat keinen Fluchtpunkt: ein Schwenk
         * verschiebt das ganze Bild um denselben Betrag, und die beiden
         * Aufnahmen decken sich wieder, sobald man eine um genau diesen Betrag
         * zurueckschiebt. Eine perspektivische Kamera hat einen Fluchtpunkt:
         * nahe Punkte wandern weiter als ferne, und KEIN Versatz bringt die
         * beiden Bilder zur Deckung. Genau dieser Unterschied wird gemessen,
         * in beiden Ansichten, mit demselben Handgriff.
         *
         * Dazu zwei Kontrollzahlen, ohne die die erste nichts wert waere:
         *
         *  - `idleDrift`: zwei Aufnahmen OHNE jede Eingabe. Zeichnet die Szene
         *    etwas Bewegtes, ist sie nicht null, und dann ist auch ein Rest nach
         *    dem Schwenk nicht null. Verglichen wird darum gegen diese Zahl und
         *    nicht gegen die Null.
         *  - `residualAtZero`: derselbe Vergleich ohne Versatz. Er zeigt, dass
         *    der Schwenk das Bild ueberhaupt bewegt hat; ohne ihn koennte eine
         *    Kamera, die sich gar nicht ruehrt, als "starr verschoben" gelten.
         *
         * Der Schwenk laeuft mit der rechten Maustaste, weil OrbitControls sie
         * dafuer vorsieht. Die linke dreht, und in der flachen Ansicht ist das
         * Drehen abgeschaltet; auch das wird gemessen, als zweites Stueck.
         */
        const dragProbe = async (name, button, dx) => {
            await page.mouse.move(clip.x + clip.width / 2, clip.y + clip.height / 2);
            await page.waitForTimeout(900);
            await grab(page, `${name}-a`, clip);
            await page.waitForTimeout(500);
            await grab(page, `${name}-idle`, clip);
            const idle = await shiftedDifference(page, {
                base: `${name}-a`, variant: `${name}-idle`, maxShift: 4,
            });
            const cx = clip.x + clip.width / 2;
            const cy = clip.y + clip.height / 2;
            await page.mouse.move(cx, cy);
            await page.mouse.down({ button });
            for (let step = 1; step <= 10; step += 1) {
                await page.mouse.move(cx + (dx * step) / 10, cy);
                await page.waitForTimeout(30);
            }
            await page.mouse.up({ button });
            await page.waitForTimeout(1200);
            await grab(page, `${name}-b`, clip);
            const moved = await shiftedDifference(page, {
                base: `${name}-a`, variant: `${name}-b`, maxShift: Math.abs(dx) * 3,
            });
            return {
                name,
                button,
                dragPx: dx,
                idleDrift: idle?.residualAtZero ?? -1,
                residualAtZero: moved?.residualAtZero ?? -1,
                residualAtBestShift: moved?.residualAtBestShift ?? -1,
                bestShift: moved?.bestShift ?? 0,
                image: moved === null ? null : { width: moved.width, height: moved.height },
            };
        };

        const spatialPan = await dragProbe('spatial-pan', 'right', 120);
        const spatialRotate = await dragProbe('spatial-rotate', 'left', 120);
        log(`raeumlich: Schwenk Rest ${spatialPan.residualAtBestShift} bei Versatz `
            + `${spatialPan.bestShift} (Ruhe ${spatialPan.idleDrift}), Drehen aendert `
            + `${spatialRotate.residualAtZero}`);

        await measureSetting(
            '2D statt 3D (projection -> flat)',
            optionSelector('projection', 'flat'),
            'projection',
        );
        await page.waitForTimeout(1500);
        const flatPan = await dragProbe('flat-pan', 'right', 120);
        const flatRotate = await dragProbe('flat-rotate', 'left', 120);
        log(`flach: Schwenk Rest ${flatPan.residualAtBestShift} bei Versatz `
            + `${flatPan.bestShift} (Ruhe ${flatPan.idleDrift}), Drehen aendert `
            + `${flatRotate.residualAtZero}`);

        const seamFlat = await settingsSeam(page);
        const domFlat = await settingsDom(page);
        /*
         * Die Schranke, in Worten: nach dem Schwenk decken sich die beiden
         * Bilder in der flachen Ansicht bis auf das, was die Szene ohnehin von
         * Bild zu Bild schwankt (plus ein halbes Grauwertniveau Luft). In der
         * raeumlichen tun sie das nicht. Und beide Schwenks haben das Bild
         * wirklich bewegt, sonst waere die Deckung eine Selbstverstaendlichkeit.
         */
        const rigidity = (probe) => probe.residualAtZero <= 0
            ? -1
            : Number((probe.residualAtBestShift / probe.residualAtZero).toFixed(4));
        const flatRigidity = rigidity(flatPan);
        const spatialRigidity = rigidity(spatialPan);
        const flatIsRigid = flatRigidity >= 0 && flatRigidity <= 0.3;
        const spatialIsNotRigid = spatialRigidity > flatRigidity * 2;
        const bothPansMoved =
            flatPan.residualAtZero > flatPan.idleDrift + 1
            && spatialPan.residualAtZero > spatialPan.idleDrift + 1
            && flatPan.bestShift !== 0 && spatialPan.bestShift !== 0;
        /*
         * Das Drehen, als zweites Stueck und mit einer harten Kante: in der
         * flachen Ansicht ist es abgeschaltet, ein Zug mit der linken Taste
         * aendert also NICHTS am Bild. In der raeumlichen dreht derselbe Zug die
         * Szene um die Achse, die die flache gerade fallen laesst.
         */
        const rotationDropped =
            flatRotate.residualAtZero <= flatRotate.idleDrift + 0.5
            && spatialRotate.residualAtZero > spatialRotate.idleDrift + 1;
        report.twoDimensionalMode =
            seamFlat?.display?.projection === 'flat'
            && domFlat.choices.find((choice) => choice.setting === 'projection')?.value === 'flat'
            && flatIsRigid && spatialIsNotRigid && bothPansMoved && rotationDropped;
        extras.twoDimensional = {
            method:
                'Gemessen am gerenderten Bild und nicht am Schalter. Eine orthografische Kamera hat '
                + 'keinen Fluchtpunkt: ein Schwenk verschiebt das ganze Bild um denselben Betrag, '
                + 'die beiden Aufnahmen decken sich also wieder, sobald eine um genau diesen Betrag '
                + 'zurueckgeschoben wird. Eine perspektivische Kamera hat einen: nahe Punkte wandern '
                + 'weiter als ferne, und kein Versatz bringt die Bilder zur Deckung. Der beste '
                + 'Versatz wird ueber die Spaltensummen gesucht und dann am ganzen Bild nachgerechnet; '
                + 'die Zahlen sind mittlere Grauwertunterschiede je Pixel (0 bis 255).',
            spatialPan,
            flatPan,
            spatialRotate,
            flatRotate,
            rigidity: {
                what: 'Rest nach dem besten Versatz, geteilt durch den Rest ohne Versatz. Null '
                    + 'heisst: der Schwenk hat das Bild genau verschoben und sonst nichts.',
                flat: flatRigidity,
                spatial: spatialRigidity,
            },
            verdicts: {
                flatIsRigidUnderPan: flatIsRigid,
                spatialIsNotRigidUnderPan: spatialIsNotRigid,
                bothPansMovedTheImage: bothPansMoved,
                rotationDroppedInFlatView: rotationDropped,
            },
            switchValue: domFlat.choices.find((choice) => choice.setting === 'projection')?.value ?? '',
            seamValue: seamFlat?.display?.projection ?? '',
        };
        log(`2D: Starrheit flach ${flatRigidity} gegen raeumlich ${spatialRigidity}, `
            + `Drehen faellt weg ${rotationDropped}, beide Schwenks bewegten das Bild `
            + `${bothPansMoved} -> ${report.twoDimensionalMode}`);

        await readability('Einstellungen offen, flache Ansicht');

        await measureSetting(
            'zurueck auf 3D (projection -> spatial)',
            optionSelector('projection', 'spatial'),
            'projection',
        );

        /*
         * 2. Die Effektschalter, jeder einzeln und danach zurueckgesetzt.
         *
         * Es waren vier; seit W11a sind es fuenf. Die Agentenebene gehoert in
         * diese Runde, weil sie in dieselbe Gruppe gehoert: die Zusicherung
         * dieses Laufs ist "JEDE Einstellung nennt ihre gemessenen Zahlen", und
         * ein Lauf, der acht von neun misst, wuerde sie fuer die neunte
         * behaupten.
         */
        const effectPlan = [
            { key: 'halos', off: 'false', on: 'true', name: 'Leuchthoefe' },
            { key: 'bloom', off: 'false', on: 'true', name: 'Bloom' },
            { key: 'edges', off: 'off', on: 'full', name: 'Kantendichte' },
            { key: 'labels', off: '1', on: '0', name: 'Beschriftungsentfernung' },
            { key: 'agents', off: 'false', on: 'true', name: 'Agentenebene' },
        ];
        const effectToggles = [];
        for (const effect of effectPlan) {
            const away = await measureSetting(
                `${effect.name} aus (${effect.key} -> ${effect.off})`,
                optionSelector(effect.key, effect.off),
                effect.key,
            );
            const back = await measureSetting(
                `${effect.name} zurueck (${effect.key} -> ${effect.on})`,
                optionSelector(effect.key, effect.on),
                effect.key,
            );
            effectToggles.push({
                name: effect.key,
                label: effect.name,
                changedTo: effect.off,
                before: away.before,
                after: away.after,
                band: away.band,
                verdict: away.verdict,
                text: away.text,
                resetTo: effect.on,
                resetBefore: back.before,
                resetAfter: back.after,
                resetVerdict: back.verdict,
            });
        }
        report.effectToggles = effectToggles;

        // 3. Der Bildratendeckel, 60 und 30.
        const capUncapped = extras.frameRateAtStart;
        const cap60 = await measureSetting(
            'Bildratendeckel 60 (frameCap -> 60)',
            optionSelector('frameCap', '60'),
            'frameCap',
        );
        const perfAt60 = await perfSeam(page);
        const cap30 = await measureSetting(
            'Bildratendeckel 30 (frameCap -> 30)',
            optionSelector('frameCap', '30'),
            'frameCap',
        );
        const perfAt30 = await perfSeam(page);
        const capOff = await measureSetting(
            'Bildratendeckel aus (frameCap -> 0)',
            optionSelector('frameCap', '0'),
            'frameCap',
        );
        const perfAtOff = await perfSeam(page);
        /*
         * Was `frameCapWorks` behauptet, und was nicht.
         *
         * Behauptet wird: der gewaehlte Deckel kommt in der Szene an (die Naht
         * meldet ihn), und das Panel nennt zu jeder Wahl eine gemessene Zahl.
         * NICHT behauptet wird, dass die Bildrate danach faellt: in dieser
         * Umgebung liegt sie ohne Deckel bereits unter 30, und ein Deckel, unter
         * dem eine Maschine ohnehin bleibt, aendert nichts. Genau diesen Fall
         * nennt das Panel "kein messbarer Unterschied", und genau das ist die
         * ehrliche Auskunft. Ob der Deckel bei einer schnelleren Maschine
         * greift, hat dieser Lauf NICHT gemessen.
         */
        const capsArrive =
            (perfAt60?.cap ?? -1) === 60 && (perfAt30?.cap ?? -1) === 30 && (perfAtOff?.cap ?? -1) === 0;
        const capsMeasured = [cap60, cap30, capOff]
            .every((entry) => entry.verdict !== 'not-measured' && entry.verdict !== 'measuring');
        report.frameCapWorks = capsArrive && capsMeasured;
        extras.frameCap = {
            claim:
                'Der gewaehlte Deckel kommt in der Szene an und das Panel nennt zu jeder Wahl eine '
                + 'gemessene Zahl. Dass die Bildrate faellt, ist NICHT behauptet: siehe die Zahlen.',
            uncapped: capUncapped === null ? null : { fps: Number(capUncapped.fps.toFixed(2)), cap: capUncapped.cap },
            at60: perfAt60 === null ? null : { fps: Number(perfAt60.fps.toFixed(2)), cap: perfAt60.cap },
            at30: perfAt30 === null ? null : { fps: Number(perfAt30.fps.toFixed(2)), cap: perfAt30.cap },
            backToNone: perfAtOff === null ? null : { fps: Number(perfAtOff.fps.toFixed(2)), cap: perfAtOff.cap },
            capsArriveInScene: capsArrive,
            everyChoiceMeasured: capsMeasured,
            measurements: [cap60, cap30, capOff].map((entry) => ({
                label: entry.label, verdict: entry.verdict, before: entry.before, after: entry.after,
            })),
        };
        log(`Bildratendeckel: ohne ${extras.frameCap.uncapped?.fps}, bei 60 ${extras.frameCap.at60?.fps}, `
            + `bei 30 ${extras.frameCap.at30?.fps}, Deckel kommt an ${capsArrive}`);

        // 4. Das Sparprofil und der Weg zurueck.
        const thrifty = await measureSetting(
            'Sparprofil',
            '[data-testid="atlas-settings-profile"][data-profile="thrifty"]',
            'thrifty',
        );
        const seamThrifty = await settingsSeam(page);
        const thriftyExpected = {
            projection: 'flat', halos: false, bloom: false,
            edges: 'dim', labelDistanceFactor: 1, frameCap: 30,
        };
        const thriftyMatches = Object.entries(thriftyExpected)
            .every(([key, value]) => seamThrifty?.display?.[key] === value);
        report.thriftProfileWorks =
            thriftyMatches
            && thrifty.verdict !== 'not-measured'
            && thrifty.verdict !== 'measuring'
            && thrifty.before !== null
            && thrifty.after !== null;
        extras.thriftyProfile = {
            expected: thriftyExpected,
            afterClick: seamThrifty?.display ?? null,
            allSixSetInOneStep: thriftyMatches,
            measurement: {
                verdict: thrifty.verdict, before: thrifty.before, after: thrifty.after,
                band: thrifty.band, text: thrifty.text,
            },
        };
        log(`Sparprofil: alle sechs Werte in einem Zug ${thriftyMatches}, `
            + `${thrifty.before} -> ${thrifty.after} (${thrifty.verdict})`);

        // ------------------------------ Die Wahl ueberlebt den Reload (AC9)
        const displayBeforeReload = seamThrifty?.display ?? null;
        await page.reload({ waitUntil: 'load' });
        await page.waitForSelector('[data-testid="atlas-galaxy"]', { timeout: 30000 });
        await page.waitForFunction(
            () => (globalThis.__atlasGalaxy?.nodes ?? 0) > 0,
            undefined,
            { timeout: 60000 },
        );
        await page.waitForTimeout(1500);
        const seamAfterDisplayReload = await settingsSeam(page);
        report.settingsPersistReload =
            displayBeforeReload !== null
            && JSON.stringify(seamAfterDisplayReload?.display ?? {})
                === JSON.stringify(displayBeforeReload);
        extras.displayAcrossReload = {
            before: displayBeforeReload,
            after: seamAfterDisplayReload?.display ?? null,
            storageKey: seamAfterDisplayReload?.storageKeys?.display ?? '',
            storedValue: await page.evaluate((key) => {
                try {
                    return globalThis.localStorage.getItem(key);
                } catch {
                    return null;
                }
            }, seamAfterDisplayReload?.storageKeys?.display ?? ''),
        };
        log(`Anzeige-Einstellungen ueberleben den Reload: ${report.settingsPersistReload}`);

        /*
         * Nach dem Reload steht das Panel wieder ohne seine Messungen da: es
         * fuehrt sie in seinem eigenen Zustand (SettingsPanel.tsx), und der geht
         * mit der Seite. Fuer die Frage, ob JEDE Einstellung ihren Effekt nennt,
         * muessen darum alle neun in EINEM offenen Panel gemessen worden sein.
         * Das ist der Grund, dass die Runde jetzt noch einmal faellt, statt die
         * Zahlen von vorhin zu behaupten.
         */
        await openSettingsByMenu(page);
        await page.waitForTimeout(SETTLE_BEFORE_MS);
        const secondRound = [
            ['projection', optionSelector('projection', 'spatial')],
            ['halos', optionSelector('halos', 'true')],
            ['bloom', optionSelector('bloom', 'true')],
            ['edges', optionSelector('edges', 'full')],
            ['labels', optionSelector('labels', '0')],
            ['agents', optionSelector('agents', 'true')],
            /*
             * Die vier Wirkungen der Agentenbewegung (W11b AC7b). Sie stehen in
             * derselben Gruppe und tragen darum dieselbe Pflicht: jede nennt
             * ihren an DIESER Szene gemessenen Effekt auf die Bildrate.
             */
            ['agentTails', optionSelector('agentTails', 'true')],
            ['agentTrails', optionSelector('agentTrails', 'true')],
            ['agentWaves', optionSelector('agentWaves', 'true')],
            ['agentTimeline', optionSelector('agentTimeline', 'true')],
            ['frameCap', optionSelector('frameCap', '0')],
            ['thrifty', '[data-testid="atlas-settings-profile"][data-profile="thrifty"]'],
            ['default', '[data-testid="atlas-settings-profile"][data-profile="default"]'],
        ];
        for (const [key, selector] of secondRound) {
            await measureSetting(`zweite Runde: ${key}`, selector, key);
        }

        const finalDom = await settingsDom(page);
        const measureRows = finalDom.measures;
        const withoutNumbers = measureRows.filter((row) => {
            if (row.verdict === 'not-measured' || row.verdict === 'measuring') {
                return true;
            }
            if (row.verdict === 'not-drawing') {
                // Eine Auskunft und keine Zahl, und sie ist die richtige Antwort,
                // wenn nichts gezeichnet wurde. Hier wurde gezeichnet.
                return true;
            }
            if (row.verdict === 'no-difference') {
                return !(row.text.includes('no measurable difference')
                    && /\d/.test(row.before) && /\d/.test(row.after));
            }
            return !(/\d/.test(row.before) && /\d/.test(row.after)
                && row.text.includes(row.before) && row.text.includes(row.after));
        });
        /*
         * Und kein Versprechen ohne Zahl. Gefragt wird satzweise: steht in
         * demselben Satz eine Zahl, ist das Wort an eine Messung gebunden.
         */
        const displaySentences = finalDom.displayText.split(/(?<=[.:])\s+/);
        const promises = [];
        const watched = [];
        for (const sentence of displaySentences) {
            for (const word of PROMISE_WORDS) {
                if (new RegExp(`\\b${word}\\b`, 'i').test(sentence) && !/\d/.test(sentence)) {
                    promises.push({ word, sentence: sentence.slice(0, 200) });
                }
            }
            for (const word of WATCHED_WORDS) {
                if (new RegExp(`\\b${word}\\b`, 'i').test(sentence)) {
                    watched.push({ word, sentence: sentence.slice(0, 200), hasNumber: /\d/.test(sentence) });
                }
            }
        }
        report.everyToggleNamesMeasuredEffect =
            measureRows.length >= 9 && withoutNumbers.length === 0 && promises.length === 0;
        extras.toggleTexts = {
            rows: measureRows,
            rowsWithoutNumbers: withoutNumbers,
            promiseWordsWithoutNumber: promises,
            promiseWordsSearched: PROMISE_WORDS,
            watchedWordsSearched: WATCHED_WORDS,
            watchedWordHits: watched,
            watchedWordNote:
                'Diese Woerter tragen die Zusicherung nicht. Sie stehen hier mit ihrem Satz, damit '
                + 'ein Leser des Artefakts selbst sieht, was die Suche gefunden hat und warum es '
                + 'kein Versprechen ist.',
        };
        log(`jede Einstellung nennt ihre Zahlen: ${report.everyToggleNamesMeasuredEffect} `
            + `(${measureRows.length} Absaetze, ${withoutNumbers.length} ohne Zahl, `
            + `${promises.length} Versprechen ohne Zahl)`);

        // ------------------------------- Wo nichts messbar war, steht der Satz
        let noDifference = extras.measurements.filter((entry) => entry.verdict === 'no-difference');
        let forcedNoDifference = null;
        if (noDifference.length === 0) {
            /*
             * Ergab jede Einstellung einen Unterschied, dann wird gezeigt, dass
             * die Anzeige den anderen Fall KANN: dieselbe Wahl ein zweites Mal
             * gesetzt aendert an der Szene nichts, und das Urteil muss darum
             * "kein messbarer Unterschied" lauten.
             */
            forcedNoDifference = await measureSetting(
                'dieselbe Wahl noch einmal (projection -> spatial, war schon spatial)',
                optionSelector('projection', 'spatial'),
                'projection',
            );
            noDifference = extras.measurements.filter((entry) => entry.verdict === 'no-difference');
        }
        report.noEffectSaysSo =
            noDifference.length > 0
            && noDifference.every((entry) => entry.text.includes('no measurable difference'));
        extras.noDifference = {
            found: noDifference.map((entry) => ({
                label: entry.label, before: entry.before, after: entry.after,
                band: entry.band, text: entry.text,
            })),
            forced: forcedNoDifference === null
                ? null
                : {
                    why: 'Keine der acht Einstellungen ergab in diesem Lauf ein Urteil '
                        + '"kein messbarer Unterschied". Belegt wird darum, dass die Anzeige '
                        + 'diesen Fall erreichen kann: dieselbe Wahl ein zweites Mal gesetzt.',
                    label: forcedNoDifference.label,
                    verdict: forcedNoDifference.verdict,
                    text: forcedNoDifference.text,
                },
        };

        /*
         * Das Bild der Leistungsgruppe, und es steht genau HIER.
         *
         * Vorher waere es ein Bild von neun Absaetzen, in denen "not measured
         * yet" steht, und das ist der Zustand, den AC9 gerade nicht meint. Nach
         * dieser Runde tragen alle neun ihr Urteil und ihre zwei Zahlen, die
         * Szene zeichnet noch, und der Lebendzaehler laeuft. Die Gruppe ist
         * hoeher als ihr Fenster; welche Lage die meisten der genannten Teile
         * zeigt, sucht fitScroll und schreibt es auf.
         */
        extras.shots.push(await shoot(page, SHOT_PERFORMANCE, 'settings-performance.png', 'display', {
            fit: true,
            why:
                'Das Panel ist hoeher als sein Fenster, und die Gruppe "Darstellung und Leistung" '
                + 'ist hoeher als das Fenster allein: der Lebendzaehler steht an ihrem Anfang, das '
                + 'Sparprofil an ihrem Ende, und zwischen beiden liegen die neun Messabsaetze. Es '
                + 'gibt darum keine Lage, die alles zeigt. Aufgenommen ist die BESTE verfuegbare, '
                + 'gesucht durch Abfahren der Gruppe in 17 Schritten und Zaehlen dessen, was an '
                + 'jeder Lage ganz im Bild steht (siehe framing.tried): sieben von acht '
                + 'Messabsaetzen mit ihren zwei Zahlen und beide Profilknoepfe. Der Lebendzaehler '
                + 'faellt dabei heraus; seine Zahlen stehen in extras.frameCap und in jeder '
                + 'Messung.',
        }));

        await readability('Einstellungen offen, Leistungsgruppe');

        // --------------------- Die Schalter, die bleiben, wo sie sind
        await closeSettings(page);
        const controlsBefore = await viewOnlyControls(page);
        await page.click('[data-testid="atlas-galaxy-legend-toggle"]');
        await page.waitForTimeout(400);
        const controlsOpen = await viewOnlyControls(page);
        const legendRows = controlsOpen.edgeFilters.length;
        await page.click('[data-testid="atlas-galaxy-legend-toggle"]');
        await page.waitForTimeout(400);
        const controlsClosed = await viewOnlyControls(page);
        report.viewOnlyControlsStayed =
            controlsBefore.legendToggle.present === true
            && controlsOpen.legendOpen === true
            && controlsClosed.legendOpen === false
            && legendRows >= 1
            && controlsOpen.modeChips.length === 2
            && controlsOpen.modeChips.some((chipEntry) => chipEntry.mode === 'galaxy')
            && controlsOpen.modeChips.some((chipEntry) => chipEntry.mode === 'hierarchy')
            && controlsOpen.twinDepth.present === true;
        extras.viewOnlyControls = {
            legendToggle: {
                present: controlsBefore.legendToggle.present,
                opens: controlsOpen.legendOpen,
                closesAgain: controlsClosed.legendOpen === false,
            },
            graphModeChips: controlsOpen.modeChips,
            edgeKindFilters: { count: legendRows, types: controlsOpen.edgeFilters },
            twinDetail: controlsOpen.twinDepth,
            note:
                'Vier Bedienelemente ohne Rechenkosten, einzeln gezaehlt. AC9 verlangt die '
                + 'Buendelung des Teuren und ausdruecklich nicht ein Menue, in dem alles '
                + 'verschwindet.',
        };
        log(`Ansichtsschalter geblieben: Legende ${controlsOpen.legendOpen}/${controlsClosed.legendOpen}, `
            + `${controlsOpen.modeChips.length} Modus-Chips, ${legendRows} Kantenfilter, `
            + `Twin-Regler ${controlsOpen.twinDepth.present}`);

        extras.apiRoutes = { ...proxy.log.apiRoutes };
        await context.close();

        // ============================================================== AC4 ==
        // Das Startskript, ohne einen Prozess zu starten.
        const printDefault = await run('sh', ['llm/start.sh', '--print-command']);
        const printAlias = await run('sh', ['llm/start.sh', '--print-command', 'class-a']);
        const printEnv = await run('sh', ['llm/start.sh', '--print-command'], {
            env: { ATLAS_MODEL: 'models/Qwen3.5-4B-Q4_K_M.gguf' },
        });
        emptyDir = await mkdtemp('/private/tmp/codeatlasweb-w10-empty-');
        const emptyRun = await run('sh', ['llm/start.sh'], { env: { ATLAS_MODELS_DIR: emptyDir } });
        const printDefaultLine = printDefault.out.trim();

        report.startScriptTakesModel =
            printAlias.code === 0
            && printAlias.out.includes('-m models/Qwen3.5-2B-Q4_K_M.gguf')
            && printEnv.code === 0
            && printEnv.out.includes('-m models/Qwen3.5-4B-Q4_K_M.gguf');
        report.startScriptSaysHowToFetch =
            emptyRun.code !== 0
            && /fetch-model\.sh/.test(emptyRun.err + emptyRun.out)
            && /-hf/.test(emptyRun.err + emptyRun.out);
        extras.startScript = {
            defaultCall: {
                command: 'sh llm/start.sh --print-command',
                exit: printDefault.code,
                line: printDefaultLine,
                hasModelsDir: printDefaultLine.includes('--models-dir'),
                hasFixedModel: / -m /.test(printDefaultLine),
            },
            withArgument: {
                command: 'sh llm/start.sh --print-command class-a',
                exit: printAlias.code,
                line: printAlias.out.trim(),
            },
            withEnvironment: {
                command: 'ATLAS_MODEL=models/Qwen3.5-4B-Q4_K_M.gguf sh llm/start.sh --print-command',
                exit: printEnv.code,
                line: printEnv.out.trim(),
            },
            emptyCache: {
                command: `ATLAS_MODELS_DIR=${emptyDir} sh llm/start.sh`,
                exit: emptyRun.code,
                output: (emptyRun.err + emptyRun.out).trim(),
                namesFetchScript: /fetch-model\.sh/.test(emptyRun.err + emptyRun.out),
                namesHfSwitch: /-hf/.test(emptyRun.err + emptyRun.out),
                startedNothing:
                    'Der Aufruf endet vor jeder Port- und PID-Pruefung; 4141 wurde nicht angefasst.',
            },
        };
        log(`Startskript: Vorgabe "${printDefaultLine}"`);
        log(`  mit Argument ${report.startScriptTakesModel}, leerer Cache endet mit `
            + `${emptyRun.code} und nennt den Weg ${report.startScriptSaysHowToFetch}`);

        // ------------------------------------- Keine Gewichte im Repository
        const tracked = await run('git', ['ls-files', 'models/']);
        const trackedFiles = tracked.out.split('\n').map((line) => line.trim()).filter(Boolean);
        const ignoreChecks = [];
        for (const file of EXPECTED_MODEL_FILES) {
            const ignored = await run('git', ['check-ignore', '-v', `models/${file}`]);
            ignoreChecks.push({
                file: `models/${file}`,
                exit: ignored.code,
                ignored: ignored.code === 0,
                rule: ignored.out.trim(),
            });
        }
        const partA = trackedFiles.length === 1 && trackedFiles[0] === 'models/SHA256SUMS';
        const partB = ignoreChecks.every((entry) => entry.ignored);
        const partC = !/ -m /.test(printDefaultLine) && !/\.gguf/.test(printDefaultLine);
        report.noWeightsInRepo = partA && partB && partC;
        extras.noWeightsInRepoParts = {
            a: { claim: 'git ls-files models/ listet nur models/SHA256SUMS', tracked: trackedFiles, ok: partA },
            b: { claim: 'jede models/*.gguf wird von git check-ignore bestaetigt', checks: ignoreChecks, ok: partB },
            c: {
                claim: 'llm/start.sh hat in seiner Vorgabe keinen Dateinamen',
                line: printDefaultLine,
                ok: partC,
            },
        };
        extras.noWeightsInRepoMethod =
            'Die sechs Eval-Dateien liegen weiterhin im Arbeitsverzeichnis unter models/, weil '
            + 'tools/eval-check.mjs und die Laeufe w5a, w5b und w6 sie dort erwarten; versioniert '
            + 'ist keine von ihnen. Gemessen sind drei Dinge und nur diese drei: was git in models/ '
            + 'fuehrt, dass jede Gewichtsdatei ignoriert ist, und dass der Aufruf ohne Argument '
            + 'keinen Dateinamen enthaelt. Ueber den Inhalt eines fremden Arbeitsverzeichnisses '
            + 'sagt diese Zahl nichts.';
        log(`keine Gewichte im Repo: (a) ${partA} (b) ${partB} (c) ${partC}`);

        // ============================================================== AC8 ==
        // Eigenschaften des Codes, an der Funktion selbst gefahren.
        const bundle = await loadCompiler();
        const compiler = bundle.module;
        extras.compilerBundle = { inputs: bundle.inputs, entry: 'src/compiler/eval-entry.ts' };
        const CARDS = ['K1', 'K2', 'K3'];
        const cases = {
            multiLineTruncated: compiler.checkCitations(
                'createUser is called by create [K2].\nAnd it also touches the',
                CARDS,
                { truncated: true },
            ),
            singleLineTruncated: compiler.checkCitations(
                'createUser is called by the', CARDS, { truncated: true },
            ),
            singleLineComplete: compiler.checkCitations(
                'createUser is called by create [K2].', CARDS,
            ),
            singleLineCompleteUncited: compiler.checkCitations(
                'createUser is called by create.', CARDS,
            ),
        };
        report.singleLineTruncatedIsUnmeasured =
            cases.multiLineTruncated.measured === true
            && cases.multiLineTruncated.ok === true
            && cases.singleLineTruncated.measured === false
            && cases.singleLineTruncated.ok === false
            && cases.singleLineTruncated.violations.length === 0
            && cases.singleLineComplete.measured === true
            && cases.singleLineComplete.ok === true
            && cases.singleLineCompleteUncited.measured === true
            && cases.singleLineCompleteUncited.ok === false;
        extras.citationCases = {
            method:
                'Die Funktion selbst, im Node-Prozess, ueber dieselbe Bruecke, die auch die Eval '
                + 'benutzt (tools/lib/compiler-bundle.mjs baut src/compiler/eval-entry.ts mit '
                + 'esbuild und importiert sie). Kein Nachbau der Regel, sondern die Regel.',
            results: Object.fromEntries(Object.entries(cases).map(([name, check]) => [name, {
                measured: check.measured,
                ok: check.ok,
                cited: check.cited,
                violations: check.violations.length,
            }])),
        };
        log(`Zitatpruefung: einzeilig gekuerzt gemessen=${cases.singleLineTruncated.measured}, `
            + `mehrzeilig gekuerzt gemessen=${cases.multiLineTruncated.measured}`);

        /*
         * Und die Rechnung der Eval, an ihrem eigenen Quelltext gefahren.
         *
         * Ein vollstaendiger Eval-Lauf waere sechs Modelle und Stunden und
         * wuerde verification/w5/eval.json ueberschreiben, also die Aufzeichnung
         * loeschen, gegen die dieser Lauf oben die Vorschlaege haelt. Statt die
         * Formel nachzuschreiben (das waere eine zweite Wahrheit) werden ihre
         * Zeilen WOERTLICH aus tools/eval-llm.mjs geschnitten und mit
         * Pruefergebnissen aus der echten Funktion oben gefahren. Was diese Zahl
         * deckt: die Rechnung. Was sie nicht deckt: einen ganzen Lauf.
         */
        const evalSource = await readFile(join(ROOT, 'tools', 'eval-llm.mjs'), 'utf8');
        const filterLine =
            'const measuredResults = results.filter((entry) => entry.citationMeasured === true);';
        const unmeasuredLine = 'const unmeasured = results.length - measuredResults.length;';
        const rateStart = evalSource.indexOf('citationCompliance: measuredResults.length === 0');
        const rateEnd = evalSource.indexOf('citationUnmeasured: unmeasured,');
        let aggregation = null;
        if (evalSource.includes(filterLine) && evalSource.includes(unmeasuredLine)
            && rateStart > 0 && rateEnd > rateStart) {
            const rateBlock = evalSource.slice(rateStart, rateEnd + 'citationUnmeasured: unmeasured,'.length);
            const lineOf = (needle) => evalSource.slice(0, evalSource.indexOf(needle)).split('\n').length;
            const body = `${filterLine}\n${unmeasuredLine}\nreturn { ${rateBlock} };`;
            // eslint-disable-next-line no-new-func
            const aggregate = new Function('results', 'round', body);
            const round = (value) => Math.round(value * 1000) / 1000;
            const input = [
                { citationMeasured: cases.singleLineComplete.measured, citationOk: cases.singleLineComplete.ok },
                { citationMeasured: cases.singleLineCompleteUncited.measured, citationOk: cases.singleLineCompleteUncited.ok },
                { citationMeasured: cases.singleLineTruncated.measured, citationOk: cases.singleLineTruncated.ok },
            ];
            const produced = aggregate(input, round);
            aggregation = {
                takenFrom: {
                    file: 'tools/eval-llm.mjs',
                    filterLine: lineOf(filterLine),
                    unmeasuredLine: lineOf(unmeasuredLine),
                    rateBlockFromLine: lineOf('citationCompliance: measuredResults.length === 0'),
                    text: body,
                },
                input,
                produced,
                ifUnmeasuredCountedAsClean: round(2 / 3),
                ifUnmeasuredCountedAsViolation: round(1 / 3),
                note:
                    'Drei Pruefungen aus der echten Funktion: eine sauber, eine mit Verstoss, eine '
                    + 'nicht gemessen. Die Rechnung der Eval liefert 0.5 (eine von zwei gemessenen). '
                    + 'Waere die ungemessene als sauber mitgezaehlt, staende 0.667; waere sie als '
                    + 'Verstoss mitgezaehlt, staende 0.333.',
            };
            report.unmeasuredOutOfCitationRate =
                produced.citationCompliance === 0.5
                && produced.citationMeasuredAnswers === 2
                && produced.citationUnmeasured === 1;
            report.evalReportsUnmeasured =
                Object.prototype.hasOwnProperty.call(produced, 'citationUnmeasured')
                && produced.citationUnmeasured === 1
                && /citationUnmeasured: model\.citationUnmeasured/.test(evalSource);
        } else {
            aggregation = {
                error:
                    'Die Rechnung der Eval war in tools/eval-llm.mjs nicht an den erwarteten Zeilen '
                    + 'zu finden. Ohne sie ist nichts gefahren worden, also steht hier false.',
            };
        }
        extras.evalAggregation = {
            method:
                'Die Zeilen der Eval-Rechnung woertlich aus tools/eval-llm.mjs geschnitten und mit '
                + 'echten Pruefergebnissen gefahren. Ein vollstaendiger Eval-Lauf war nicht moeglich: '
                + 'er braucht sechs Modelle und Stunden und wuerde verification/w5/eval.json '
                + 'ueberschreiben, also die Aufzeichnung loeschen, gegen die dieser Lauf die '
                + 'Vorschlaege im Panel haelt. Gedeckt ist damit die Rechnung, nicht ein ganzer Lauf.',
            ...aggregation,
        };
        log(`Eval-Rechnung: Zitattreue ${aggregation?.produced?.citationCompliance}, `
            + `nicht gemessen ${aggregation?.produced?.citationUnmeasured}`);
        await rm(BUNDLE_DIR, { recursive: true, force: true });

        // ================================================== AC2, zweite Haelfte
        // Erst den Router samt Kindern beenden, dann den Einzel-Sidecar starten:
        // zwei Modelle im Speicher fuer eine Messung, die sie nicht braucht,
        // waeren zwei zu viel.
        routerKids = await sidecarChildren(routerChild.pid);
        for (const kid of routerKids) {
            for (const port of kid.ports) {
                childPorts.add(port);
            }
        }
        extras.routerChildren = routerKids;
        log(`Router-Kindprozesse: ${JSON.stringify(routerKids)}`);
        const routerSurvivors = await stopSidecar(routerChild, routerKids);
        routerChild = null;
        extras.routerStop = { killedHard: routerSurvivors };

        singlePort = await findFreePort(MIN_PORT, [serverPort, uiPort, routerPort]);
        const singleOrigin = `http://127.0.0.1:${singlePort}`;
        const singleLog = [];
        const single = await startSidecar(
            [
                '--host', '127.0.0.1', '--port', String(singlePort),
                '-m', join(ROOT, 'models', MODEL_A),
                '-c', String(ROUTER_CTX),
            ],
            { port: singlePort, log: singleLog },
        );
        singleChild = single.child;
        log(`Einzel-Sidecar (ohne --models-dir) auf ${singlePort}, bereit nach ${single.readyMs} ms`);

        const singleContext = await browser.newContext({ viewport: { ...MAIN_VIEWPORT } });
        await singleContext.addInitScript(({ from, to }) => {
            const original = globalThis.fetch.bind(globalThis);
            globalThis.fetch = (input, init) => {
                const url = typeof input === 'string'
                    ? input
                    : input instanceof URL ? input.href : input?.url ?? '';
                if (typeof url === 'string' && url.startsWith(from)) {
                    return original(to + url.slice(from.length), init);
                }
                return original(input, init);
            };
        }, { from: PRODUCT_SIDECAR_ORIGIN, to: singleOrigin });
        await singleContext.route('**/*', routeFor(origin, singleOrigin));
        const singlePage = await singleContext.newPage();
        singlePage.on('console', (message) => {
            if (message.type() === 'error') {
                extras.consoleErrors.push(`[ohne router] ${message.text()}`);
            }
        });
        singlePage.on('pageerror', (error) => extras.pageErrors.push(`[ohne router] ${String(error)}`));
        await openApp(singlePage, origin);
        await singlePage.click('[data-menu="a-llm"]');
        await waitForLlm(singlePage, 'ready', READY_TIMEOUT_MS);
        await singlePage.waitForTimeout(1200);
        await singlePage.click('[data-menu="a-settings"]');
        await singlePage.waitForSelector('[data-testid="atlas-settings"]', { timeout: 15000 });
        await singlePage.waitForTimeout(600);
        const singleDom = await settingsDom(singlePage);
        const singleSeam = await settingsSeam(singlePage);
        report.noRouterExplained =
            singleDom.router === 'false'
            && singleSeam?.router === false
            && singleDom.noRouter.present === true
            && singleDom.noRouter.text.length > 80
            && singleDom.routerCommand.present === true
            && singleDom.routerCommand.text.includes('start.sh')
            && singleDom.modelPicks === 0
            && singleDom.models.every((row) => row.selectable === 'false');
        extras.withoutRouter = {
            port: singlePort,
            arguments: `-m models/${MODEL_A} -c ${ROUTER_CTX}`,
            panelRouterAttribute: singleDom.router,
            seamRouter: singleSeam?.router ?? null,
            message: singleDom.noRouter.text,
            command: singleDom.routerCommand.text,
            modelRows: singleDom.models,
            clickableModelRows: singleDom.modelPicks,
            state: singleDom.llmState,
        };
        log(`ohne Router: Meldung da ${singleDom.noRouter.present}, Befehl `
            + `"${singleDom.routerCommand.text}", anklickbare Modellzeilen ${singleDom.modelPicks}`);
        await singleContext.close();
    } catch (err) {
        failure = err;
        console.error('[smoke-w10] FEHLER:', err.message);
        if (serverLog.length > 0) {
            console.error('[smoke-w10] Server-Log (letzte 20 Zeilen):\n' + serverLog.slice(-20).join('\n'));
        }
    }

    // ------------------------------------------------------------- Abbau ----
    if (browser !== null) {
        await browser.close().catch(() => undefined);
    }
    if (proxy !== null) {
        await proxy.close();
    }
    await stopServer(serverChild);
    if (routerChild !== null) {
        routerKids = await sidecarChildren(routerChild.pid).catch(() => []);
        for (const kid of routerKids) {
            for (const port of kid.ports) {
                childPorts.add(port);
            }
        }
        await stopSidecar(routerChild, routerKids).catch(() => []);
    }
    if (singleChild !== null) {
        singleKids = await sidecarChildren(singleChild.pid).catch(() => []);
        for (const kid of singleKids) {
            for (const port of kid.ports) {
                childPorts.add(port);
            }
        }
        extras.singleChildren = singleKids;
        await stopSidecar(singleChild, singleKids).catch(() => []);
    }
    await sleep(900);

    const leftovers = [];
    const ports = [serverPort, uiPort, routerPort, singlePort, ...childPorts]
        .filter((value) => value > 0);
    for (const port of [...new Set(ports)]) {
        leftovers.push({ port, listeners: await countListeners(port) });
    }
    extras.leftovers = leftovers;
    report.leftoverProcesses = leftovers.reduce((sum, entry) => sum + entry.listeners, 0);
    /*
     * Der Port des Nutzers wird zur Kenntnis genommen und nicht gezaehlt: dieser
     * Lauf hat ihn nicht belegt und beendet ihn nicht.
     */
    extras.userPortsUntouched = {
        note: 'Nur beobachtet. Dieser Lauf hat auf keinem dieser Ports etwas gestartet oder beendet.',
        ports: [],
    };
    for (const port of [PRODUCT_SIDECAR_PORT, 4390, 4391]) {
        extras.userPortsUntouched.ports.push({ port, listeners: await countListeners(port) });
    }
    log('leftoverProcesses:', report.leftoverProcesses, JSON.stringify(leftovers));

    // Die harten Links loeschen, die Modelle nicht. Und danach nachzaehlen.
    for (const directory of [cacheDir, emptyDir]) {
        if (directory) {
            await rm(directory, { recursive: true, force: true }).catch(() => undefined);
        }
    }
    const modelsAfter = [];
    for (const file of EXPECTED_MODEL_FILES) {
        try {
            const info = await stat(join(ROOT, 'models', file));
            modelsAfter.push({ file, bytes: info.size, links: info.nlink, present: true });
        } catch (error) {
            modelsAfter.push({ file, present: false, error: String(error).slice(0, 160) });
        }
    }
    extras.modelsAfterRun = {
        claim: 'Alle sechs Dateien in models/ sind nach dem Lauf noch da. Ein harter Link haelt '
            + 'dieselbe Inode; sein Loeschen nimmt der Datei nur einen Verweis.',
        allPresent: modelsAfter.every((entry) => entry.present),
        files: modelsAfter,
    };
    log(`Modelle in models/ nach dem Lauf: `
        + `${modelsAfter.filter((entry) => entry.present).length} von ${EXPECTED_MODEL_FILES.length}`);

    /*
     * Der Mitschnitt der Sidecar-Anfragen, zusammengefasst.
     *
     * Eine Probe alle drei Sekunden mit vier Anfragen ergibt ueber einen Lauf
     * dieser Laenge einige tausend Zeilen, und ein Artefakt, in dem die Zahlen
     * unter dem Mitschnitt verschwinden, ist keins. Aufgehoben wird, worauf es
     * ankommt: die Summe, die Aufteilung nach Route, und die ersten und letzten
     * zwanzig samt Zeitstempel. Die Null, die AC5 traegt, ist ohnehin an
     * `extras.llmOff.sidecarRequests` gemessen und steht dort unveraendert.
     */
    const byPath = {};
    for (const entry of extras.sidecarRequests) {
        const path = entry.url.replace(/^https?:\/\/[^/]+/, '').split('?')[0];
        byPath[path] = (byPath[path] ?? 0) + 1;
    }
    extras.sidecarRequests = {
        total: extras.sidecarRequests.length,
        byPath,
        first: extras.sidecarRequests.slice(0, 20),
        last: extras.sidecarRequests.slice(-20),
    };

    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)',
            method:
                'Ein eigener llama-server im Router-Modus ueber ein eigenes Cache-Verzeichnis mit '
                + 'ZWEI Modellen, die als harte Links aus models/ dort liegen: kein Download, kein '
                + 'zusaetzlicher Platz, keine geloeschte Datei. Die Anwendung fragt weiter ihren '
                + 'Produktport 127.0.0.1:4141; ein addInitScript leitet an genau der Naht um, an der '
                + 'sie selbst fragt, und der Route-Handler bricht jede Anfrage an 4141 ab, statt sie '
                + 'durchzulassen (productPortRequests muss 0 sein). Die Modellnamen, die das '
                + 'Umschalten belegen, stammen aus den aufgezeichneten Antwortkoerpern der Anfragen, '
                + 'die die Anwendung selbst geschickt hat. '
                + FRAME_RATE_ENVIRONMENT,
            timings,
            generatedAt: new Date().toISOString(),
            error: failure ? failure.message : null,
            extras,
        }, null, 2) + '\n',
        'utf8',
    );
    log('geschrieben:', OUT_JSON);

    /*
     * Vier Bilder, und alle vier muessen da und groesser als 30 KB sein. Der
     * eingefrorene Test prueft die ersten drei; das vierte prueft dieser Lauf
     * selbst, damit es nicht stillschweigend fehlen kann.
     */
    const shotsOk = [SHOT_SETTINGS, SHOT_SWITCH, SHOT_FETCH, SHOT_PERFORMANCE]
        .every((file) => existsSync(file) && statSync(file).size > 30 * 1024);
    const ok =
        failure === null
        && report.settingsPanelOpens === true
        && report.runningModelFromProps === true
        && report.cacheModelsListed >= 2
        && report.switchModelWorks === true
        && report.switchPersistsReload === true
        && report.statusBarNamesModel === true
        && report.noRouterExplained === true
        && report.suggestionsListed >= 6
        && report.suggestionsShowMeasuredNumbers === true
        && report.freeRepoFieldAccepted === true
        && report.commandCopyable === true
        && report.downloadHonestyText === true
        && report.noFakeProgressBar === true
        && report.startScriptTakesModel === true
        && report.startScriptSaysHowToFetch === true
        && report.noWeightsInRepo === true
        && report.llmOffMakesNoRequests === true
        && report.panelExplainsItselfWhileOff === true
        && report.singleLineTruncatedIsUnmeasured === true
        && report.unmeasuredOutOfCitationRate === true
        && report.evalReportsUnmeasured === true
        && report.panelShowsUnmeasured === true
        && report.twoDimensionalMode === true
        && Array.isArray(report.effectToggles) && report.effectToggles.length >= 3
        && report.thriftProfileWorks === true
        && report.frameCapWorks === true
        && report.settingsPersistReload === true
        && report.everyToggleNamesMeasuredEffect === true
        && report.noEffectSaysSo === true
        && report.viewOnlyControlsStayed === true
        && report.overlapViolations === 0
        && report.clippingViolations === 0
        && report.cutWithoutHint === 0
        && report.port >= MIN_PORT
        && report.leftoverProcesses === 0
        && shotsOk
        && extras.productPortRequests.length === 0
        && extras.blockedRequests.length === 0
        && extras.pageErrors.length === 0
        && extras.modelsAfterRun.allPresent === true;

    if (!ok) {
        console.error('[smoke-w10] W10-Smoke NICHT gruen.');
        if (home) {
            console.error('[smoke-w10] 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('W10-Smoke gruen.');
}

main().catch((err) => {
    console.error('[smoke-w10] unerwarteter Fehler:', err);
    process.exitCode = 1;
});