dogfather-universe/server/pruef-team.mjs

/* DIE ARBEITSLAGE VON MANAGERN UND SCOUTS (09.09.2026)

   Filipe: "so eine kategorie wie über die creator will ich dass nur für
   die spicy und dogfather rolle auch über manager und scouts gibt ...
   keine geheimen sachen also termine, chats und geheime dateien soll
   auch so bleiben dass keiner."

   ---------------------------------------------------------------------
   DER WICHTIGSTE ABSCHNITT IST DER ERSTE, NICHT DER LETZTE

   Diese Seite zeigt Zahlen über Kollegen. Zwei Dinge daran können
   schiefgehen, und beide wären schwer wieder gutzumachen:

     1. Sie zeigt sie den Falschen. Ein Manager, der die Auslastung
        seiner Kollegen sieht, hat eine Auskunft, die ihm nicht gehört.
     2. Sie zeigt etwas, das nicht hineingehört -- Termine, Chats,
        Dateien.

   Punkt 2 wird hier auf ZWEI Wegen geprüft: an der Antwort (keine
   Felder mit diesen Namen) UND am Quelltext (die Datei nennt diese
   Tabellen nicht). Der zweite Weg ist der stärkere: Er hält auch dann,
   wenn jemand morgen ein Feld hinzufügt, das im Testbestand zufällig
   leer bleibt.

   DREI AUSGÄNGE: 0 in Ordnung · 1 Befunde · 2 konnte nicht arbeiten. */

import { mkdtempSync, rmSync, readFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, dirname } from "node:path";
import { fileURLToPath } from "node:url";

const ordner = mkdtempSync(join(tmpdir(), "ws-team-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");

import { notbremse } from "./helfer-notbremse.mjs";
const { eigenerPort } = await import("./helfer-port.mjs");
const PORT = await eigenerPort(import.meta, "die Team-Pruefung");

process.env.PORT = `${PORT}`;
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";

const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
await import("./index.js");
notbremse(300_000, "pruef-team");
await new Promise((r) => setTimeout(r, 900));
const BASIS = `http://127.0.0.1:${PORT}`;

let fehler = 0, geprueft = 0;
const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

/* ---- Bestand ------------------------------------------------------------ */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
for (let i = 0; i < 60; i++) {
  try { const p = new DatabaseSync(process.env.WORKSPACE_DB);
    try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
  } catch { await new Promise((r) => setTimeout(r, 250)); }
}
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
const tagT = (v) => { const x = new Date(Date.now() + v * 86400000);
  return `${x.getFullYear()}-${String(x.getMonth() + 1).padStart(2, "0")}`
    + `-${String(x.getDate()).padStart(2, "0")}`; };
function anlegen(name, rolle, code) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(code, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi  = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idSpicy = anlegen("Cigdem", "spicy", "CODE-SPIC-0001");
const idVan   = anlegen("VanVan", "admin", "CODE-VANV-0001");   /* der zweite Admin */
const idMara  = anlegen("Mara", "manager", "CODE-MANA-0001");
const idPat   = anlegen("Patrick", "scout", "CODE-SCOU-0001");
const idBen   = anlegen("Ben", "scout", "CODE-SCOB-0001");
const idTili  = anlegen("Tili", "creator", "CODE-ANNA-0001");
const idLuna  = anlegen("Luna", "creator", "CODE-LUNA-0001");
const idRoy   = anlegen("Roy", "creator", "CODE-ROYY-0001");
const idFrei  = anlegen("Nio", "creator", "CODE-NIOO-0001");     /* ohne Betreuung */

/* Patrick betreut Tili und Luna, Ben betreut Roy, Mara fuehrt Patrick.
   Nio hat NIEMANDEN -- das ist die Luecke, die die Seite zeigen soll. */
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idTili, idPat, jetzt);
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idPat, jetzt);
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idRoy, idBen, jetzt);
d.prepare("INSERT INTO scout_zuteilung (scout_id, manager_id, seit) VALUES (?,?,?)").run(idPat, idMara, jetzt);

const auf = (titel, creator, status, frist) =>
  d.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, frist,
    creator_id, verantwortlich_id, erstellt, erstellt_von, erledigt_am)
    VALUES (?,?,?,'mittel',?,?,?,?,?,?)`)
    .run(titel, "", status, frist, creator, creator, jetzt, idDogi,
      status === "erledigt" ? jetzt : null);
auf("T1", idTili, "offen", tagT(-3));      /* ueberfaellig */
auf("T2", idTili, "arbeit", tagT(5));
auf("T3", idLuna, "erledigt", tagT(-1));
auf("T4", idRoy, "offen", tagT(2));

d.prepare(`INSERT INTO leads (name, plattform, handle, status, scout_id, erstellt, erstellt_von,
           naechster_followup, uebergeben_am) VALUES (?,?,?,?,?,?,?,?,?)`)
  .run("Kandidat A", "tiktok", "@a", "angesprochen", idPat, jetzt, idPat, tagT(-2), null);
d.prepare(`INSERT INTO leads (name, plattform, handle, status, scout_id, erstellt, erstellt_von,
           naechster_followup, uebergeben_am) VALUES (?,?,?,?,?,?,?,?,?)`)
  .run("Kandidat B", "tiktok", "@b", "uebergeben", idPat, jetzt, idPat, null, jetzt);
d.close();

const keks = async (rolle, code) => {
  const a = await fetch(BASIS + "/workspace/api/anmelden", {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle, code }) });
  return (a.headers.getSetCookie?.() || []).map((k) => k.split(";")[0]).join("; ");
};
const kDogi  = await keks("admin", "CODE-DOGI-0001");
const kSpicy = await keks("spicy", "CODE-SPIC-0001");
const kMara  = await keks("manager", "CODE-MANA-0001");
const kPat   = await keks("scout", "CODE-SCOU-0001");
const kTili  = await keks("creator", "CODE-ANNA-0001");
const ruf = (pfad, k) => fetch(BASIS + pfad, { headers: { cookie: k }, redirect: "manual" });

/* =======================================================================
   1. WER DARF HINEIN -- und wer nicht
   ======================================================================= */
console.log("\n=== Wer darf hinein");
{
  for (const [name, k, soll] of [
    ["DogFather", kDogi, 200], ["Spicy Media", kSpicy, 200],
    ["Manager", kMara, 404], ["Scout", kPat, 404], ["Creator", kTili, 404],
  ]) {
    const a = await ruf("/workspace/api/team", k);
    ok(a.status === soll, `${name}: HTTP ${a.status} (erwartet ${soll})`);
  }
  /* Ohne Anmeldung ueberhaupt nichts. */
  const ohne = await fetch(BASIS + "/workspace/api/team", { redirect: "manual" });
  ok(ohne.status === 401, `ohne Anmeldung: HTTP ${ohne.status}`);

  /* Und die SEITE ebenso -- eine offene Seite mit gesperrter
     Schnittstelle waere eine leere Seite und eine offene Frage. */
  for (const [name, k, offen] of [
    ["DogFather", kDogi, true], ["Spicy Media", kSpicy, true],
    ["Manager", kMara, false], ["Scout", kPat, false], ["Creator", kTili, false],
  ]) {
    const a = await ruf("/workspace/team.html", k);
    const drin = a.status === 200;
    ok(drin === offen, `team.html für ${name}: HTTP ${a.status}`);
  }
}

/* =======================================================================
   2. WAS NICHT HINEINGEHÖRT -- Termine, Chats, Dateien

   Auf zwei Wegen geprüft. Der zweite ist der stärkere.
   ======================================================================= */
console.log("\n=== Termine, Chats und Dateien bleiben draußen");
{
  const daten = await (await ruf("/workspace/api/team", kDogi)).json();

  /* DAS HINWEISSCHILD WIRD AUSGENOMMEN -- und zwar ausdrücklich.

     Die Antwort trägt ein Feld `ausgenommen: ["Termine","Chats",
     "Dateien"]`; daraus schreibt die Seite den Satz, der dem Betrachter
     sagt, was hier NICHT steht. Beim ersten Lauf hat die Wortsuche
     genau dieses Schild gefunden und Alarm geschlagen.

     Es einfach zu ignorieren wäre die bequeme Lösung und eine schlechte:
     Dann könnte künftig jedes beliebige Feld unter diesem Namen
     durchrutschen. Stattdessen wird es HERAUSGENOMMEN und danach
     eigens geprüft -- was es enthalten darf, steht dann fest. */
  const { ausgenommen, ...ohneSchild } = daten;
  const text = JSON.stringify(ohneSchild).toLowerCase();
  const verboten = ["termin", "chat", "datei", "nachricht", "anhang"];
  const gefunden = verboten.filter((w) => text.includes(w));
  ok(gefunden.length === 0,
    gefunden.length ? `in der Antwort steht: ${gefunden.join(", ")}`
      : `kein einziges dieser Wörter in der Antwort (${verboten.join(", ")})`);
  ok(Array.isArray(ausgenommen) && ausgenommen.join(",") === "Termine,Chats,Dateien",
    `und das Schild nennt genau die drei (${(ausgenommen || []).join(", ")})`);

  /* GEGENPROBE ZUR WORTSUCHE: Sie muss ein verbotenes Wort auch finden.
     Ohne sie hiesse "nichts gefunden" nur, dass nicht gesucht wurde. */
  ok(verboten.some((w) => JSON.stringify({ x: "Termine am Montag" }).toLowerCase().includes(w)),
    "Gegenprobe: die Wortsuche schlägt bei einem verbotenen Wort an");

  /* DER STÄRKERE WEG: der Quelltext selbst. Ein leerer Testbestand
     kann ein Feld verstecken; eine Abfrage, die es gar nicht gibt,
     kann nichts liefern. */
  const HIER = dirname(fileURLToPath(import.meta.url));
  const quelle = readFileSync(join(HIER, "workspace-team.js"), "utf8");
  /* Nur der CODE, nicht die Kommentare -- dort steht ausdrücklich, was
     ausgenommen ist, und das soll dort auch stehen bleiben. */
  const nurCode = quelle.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
  const tabellen = ["termine", "termin_teilnehmer", "chat_nachrichten", "chat_raeume",
    "chat_teilnehmer", "dateien", "datei_personen"];
  const benutzt = tabellen.filter((t) => new RegExp(`\\b${t}\\b`).test(nurCode));
  ok(benutzt.length === 0,
    benutzt.length ? `der Quelltext fragt ab: ${benutzt.join(", ")}`
      : `keine dieser ${tabellen.length} Tabellen wird abgefragt`);

  /* GEGENPROBE: Die Suche findet eine Tabelle, die WIRKLICH benutzt
     wird. Ohne sie hiesse "nichts gefunden" nur, dass die Suche nicht
     sucht. */
  ok(/\baufgaben\b/.test(nurCode) && /\bleads\b/.test(nurCode),
    "Gegenprobe: `aufgaben` und `leads` werden gefunden — die Suche sucht wirklich");
}

/* =======================================================================
   3. STIMMEN DIE ZAHLEN?
   ======================================================================= */
console.log("\n=== Die Zahlen");
{
  const daten = await (await ruf("/workspace/api/team", kDogi)).json();
  const p = (name) => daten.leute.find((x) => x.name === name);

  ok(daten.leute.length === 3,
    `drei Leute: Manager und zwei Scouts (${daten.leute.map((x) => x.name).join(", ")})`);
  ok(!daten.leute.some((x) => x.rolle === "creator" || x.rolle === "admin"),
    "keine Creator und keine Admins in der Liste — die Seite ist für Manager und Scouts");

  const pat = p("Patrick");
  ok(pat?.creator.length === 2, `Patrick betreut zwei Creator (${pat?.creator.length})`);
  ok(pat?.aufgaben.ueberfaellig === 1,
    `eine überfällige Aufgabe bei seinen Creators (${pat?.aufgaben.ueberfaellig})`);
  ok(pat?.aufgaben.laufend === 2, `zwei laufende (${pat?.aufgaben.laufend})`);

  /* DER MANAGER TRÄGT DIE CREATOR SEINER SCOUTS MIT.
     Ohne das sähe ein Manager mit fünf Scouts aus wie jemand ohne
     Arbeit -- und genau das wäre die falsche Auskunft. */
  const mara = p("Mara");
  ok(mara?.creator.length === 0 && mara?.creator_mittelbar === 2,
    `Mara betreut niemanden direkt, aber zwei über Patrick `
    + `(${mara?.creator.length} / ${mara?.creator_mittelbar})`);
  ok(mara?.aufgaben.ueberfaellig === 1,
    `und sieht deren überfällige Aufgabe (${mara?.aufgaben.ueberfaellig})`);
  ok(mara?.scouts.includes("Patrick"), `mit Namen des Scouts (${mara?.scouts.join(", ")})`);

  /* Die Pipeline gibt es nur bei Scouts. */
  ok(pat?.pipeline && pat.pipeline.gesamt === 2 && pat.pipeline.uebergeben === 1,
    `Patricks Pipeline: ${pat?.pipeline?.gesamt} Kontakte, ${pat?.pipeline?.uebergeben} übergeben`);
  ok(pat?.pipeline?.faellig === 1,
    `davon einer überfällig im Nachfassen (${pat?.pipeline?.faellig})`);
  ok(mara?.pipeline === null, "ein Manager hat keine Pipeline — und bekommt auch keine leere");

  /* ---- DIE LÜCKEN ---- */
  ok(daten.luecken.creator_ohne_betreuung.some((c) => c.name === "Nio"),
    `Nio steht als Creator ohne Betreuung da `
    + `(${daten.luecken.creator_ohne_betreuung.map((c) => c.name).join(", ")})`);
  ok(daten.luecken.scouts_ohne_manager.some((s) => s.name === "Ben"),
    `Ben steht als Scout ohne Manager da `
    + `(${daten.luecken.scouts_ohne_manager.map((s) => s.name).join(", ")})`);
  /* GEGENPROBE: Wer versorgt ist, taucht NICHT auf. */
  ok(!daten.luecken.creator_ohne_betreuung.some((c) => c.name === "Tili")
     && !daten.luecken.scouts_ohne_manager.some((s) => s.name === "Patrick"),
    "und die versorgten stehen nicht darin");
}

/* =======================================================================
   4. SPICY MEDIA SIEHT VANVAN NICHT

   Die Hausregel gilt auch hier -- und zwar über dieselbe zentrale
   Funktion, nicht über eine eigene Fassung.
   ======================================================================= */
console.log("\n=== Niemand sieht VanVan außer DogFather");
{
  const alsSpicy = await (await ruf("/workspace/api/team", kSpicy)).json();
  const text = JSON.stringify(alsSpicy);
  ok(!text.includes("VanVan"), "in der Spicy-Ansicht steht VanVan nirgends");
  /* Sie ist Admin und stünde ohnehin nicht in der Liste -- geprüft wird
     deshalb, dass die Regel überhaupt greift: DogFather sieht sie in
     der Personenliste, Spicy nicht. */
  const beiDogi = await (await ruf("/workspace/api/verwaltung/personen", kDogi)).json();
  const beiSpicy = await (await ruf("/workspace/api/verwaltung/personen", kSpicy)).json();
  const nDogi = (beiDogi.personen || []).some((x) => x.name === "VanVan");
  const nSpicy = (beiSpicy.personen || []).some((x) => x.name === "VanVan");
  ok(nDogi && !nSpicy,
    `Gegenprobe an der Personenliste: DogFather sieht sie (${nDogi}), Spicy nicht (${nSpicy})`);
}

/* =======================================================================
   5. IM BROWSER
   ======================================================================= */
console.log("\n=== Auf der Seite");
{
  const pw = await import("file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await pw.chromium.launch();
  const konsole = [];
  const ctx = await browser.newContext({ viewport: { width: 1440, height: 1200 } });
  const s = await ctx.newPage();
  s.on("pageerror", (f) => konsole.push("Absturz: " + f.message));
  s.on("console", (m) => { if (m.type() === "error") konsole.push("Konsole: " + m.text()); });
  await s.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
  await s.click('.rolle[data-rolle="admin"]');
  await s.fill("#code", "CODE-DOGI-0001");
  await s.click("button[type=submit]");
  await s.waitForURL("**/start.html", { timeout: 20000 });
  await s.waitForTimeout(1200);

  /* Die Kachel steht auf der Startseite und führt hin. */
  const kachel = await s.evaluate(() => {
    const k = [...document.querySelectorAll(".kachel")]
      .find((x) => /Team-Lage/.test(x.textContent));
    return k ? { da: true, ziel: k.getAttribute("href") || k.dataset.ziel || "",
                 gruppe: k.closest(".gruppe")?.textContent?.slice(0, 40) } : { da: false };
  });
  ok(kachel.da, `die Kachel steht auf der Startseite (Gruppe: ${kachel.gruppe})`);

  await s.goto(BASIS + "/workspace/team.html", { waitUntil: "networkidle" });
  await s.waitForTimeout(1500);
  const m = await s.evaluate(() => ({
    leute: document.querySelectorAll(".tperson").length,
    zahlen: document.querySelectorAll(".tz").length,
    luecken: document.querySelectorAll(".tl").length,
    pipelines: document.querySelectorAll(".tpipe").length,
    grenze: document.querySelector(".t-kopf__grenze")?.textContent?.trim().slice(0, 60),
    warnungen: document.querySelectorAll('.tz[data-art="warn"]').length,
    ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
  }));
  ok(m.leute === 3, `drei Personenkarten (${m.leute})`);
  ok(m.pipelines === 2, `zwei Pipelines — nur die Scouts (${m.pipelines})`);
  ok(m.luecken >= 2, `die Lücken stehen oben (${m.luecken} Kästen)`);
  ok(m.warnungen > 0, `und was liegengeblieben ist, ist markiert (${m.warnungen})`);
  ok(/Termine, Chats und Dateien/.test(m.grenze || ""),
    `der Kopf sagt, was NICHT darin steht ("${m.grenze}…")`);
  ok(m.ueber <= 1, `nichts steht seitlich über (${m.ueber} px)`);
  if (process.env.BILD === "ja") {
    await s.screenshot({ path: "_team-gross.png", fullPage: true });
  }

  /* Am Handy ebenfalls. */
  /* MIT FINGER. Ohne `hasTouch` meldet der Browser einen feinen
     Zeiger, und keine Regel aus `@media (pointer: coarse)` greift --
     dort stehen die 44-Pixel-Beruehrziele. Siehe pruef-fingermass.mjs. */
  const ctx2 = await browser.newContext({ viewport: { width: 390, height: 900 },
    hasTouch: true, isMobile: true });
  const s2 = await ctx2.newPage();
  await s2.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
  await s2.click('.rolle[data-rolle="admin"]');
  await s2.fill("#code", "CODE-DOGI-0001");
  await s2.click("button[type=submit]");
  await s2.waitForURL("**/start.html", { timeout: 20000 });
  await s2.goto(BASIS + "/workspace/team.html", { waitUntil: "networkidle" });
  await s2.waitForTimeout(1400);
  const h = await s2.evaluate(() => ({
    ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
    leute: document.querySelectorAll(".tperson").length,
    breiter: [...document.querySelectorAll(".tperson, .tz, .tl")]
      .filter((e) => e.getBoundingClientRect().right > 391).length,
  }));
  ok(h.ueber <= 1 && h.breiter === 0,
    `am Handy nichts über (${h.ueber} px, ${h.breiter} zu breit) bei ${h.leute} Karten`);
  if (process.env.BILD === "ja") {
    await s2.screenshot({ path: "_team-handy.png", fullPage: true });
  }
  await ctx2.close();

  /* ---- LESBAR, NICHT NUR DA (09.09.2026) --------------------------
     Die Lektion vom Vorlagenbrett: Eine Karte mit sieben Prozent Farbe
     auf durchsichtigem Grund laesst das Buehnenfoto durch, und dann
     haengt die Lesbarkeit davon ab, welche Stelle des Fotos gerade
     dahinterliegt. Dort waren es 3,61:1, wo 4,5 noetig sind.

     Gemessen wird gegen die WIRKLICHE Flaeche: Der Text wird kurz
     unsichtbar gemacht und die Flaeche fotografiert. */
  {
    const leuchtkraft = (r, g, b) => {
      const f = (w) => { const v = w / 255; return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4); };
      return 0.2126 * f(r) + 0.7152 * f(g) + 0.0722 * f(b);
    };
    const kontrast = (a, b) => {
      const l1 = leuchtkraft(...a), l2 = leuchtkraft(...b);
      return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
    };
    async function messen(waehler) {
      const stelle = await s.evaluate((w) => {
        const e = document.querySelector(w);
        if (!e) return null;
        e.scrollIntoView({ block: "center" });
        const r = e.getBoundingClientRect();
        if (r.width < 8 || r.height < 6) return null;
        /* Die Farbe wird GEMALT und zurueckgelesen -- getComputedStyle
           liefert bei color-mix() "color(srgb ...)", und ein Muster
           ueber die Ziffern liest daraus Unsinn. */
        const c = document.createElement("canvas");
        c.width = 1; c.height = 1;
        const g = c.getContext("2d", { willReadFrequently: true });
        g.fillStyle = "#000000";
        g.fillStyle = getComputedStyle(e).color;
        g.fillRect(0, 0, 1, 1);
        const px = g.getImageData(0, 0, 1, 1).data;
        e.dataset.messen = "ja";
        e.style.color = "transparent";
        return { x: Math.round(r.x), y: Math.round(r.y),
                 w: Math.round(r.width), h: Math.round(Math.min(r.height, 40)),
                 farbe: [px[0], px[1], px[2]] };
      }, waehler);
      if (!stelle) return null;
      const bild = await s.screenshot({
        clip: { x: stelle.x, y: stelle.y, width: stelle.w, height: stelle.h } });
      const hinten = await s.evaluate(async (b64) => {
        const bild = new Image();
        await new Promise((r) => { bild.onload = r; bild.src = "data:image/png;base64," + b64; });
        const c = document.createElement("canvas");
        c.width = bild.width; c.height = bild.height;
        const g = c.getContext("2d", { willReadFrequently: true });
        g.drawImage(bild, 0, 0);
        const dd = g.getImageData(0, 0, c.width, c.height).data;
        let r = 0, gr = 0, bl = 0, n = 0;
        for (let i = 0; i < dd.length; i += 4) { r += dd[i]; gr += dd[i + 1]; bl += dd[i + 2]; n++; }
        return [Math.round(r / n), Math.round(gr / n), Math.round(bl / n)];
      }, bild.toString("base64"));
      await s.evaluate(() => {
        const e = document.querySelector('[data-messen="ja"]');
        if (e) { e.style.color = ""; delete e.dataset.messen; }
      });
      return { farbe: stelle.farbe, hinten, wert: kontrast(stelle.farbe, hinten) };
    }
    for (const [name, waehler] of [
      ["Lücken-Titel", ".tl__titel"],
      ["Lücken-Namen", ".tl__namen"],
      ["Kennzahl", ".tz__wert"],
      ["Beschriftung", ".tz__schild"],
      ["Kennzahl (Warnung)", '.tz[data-art="warn"] .tz__wert'],
      ["Name", ".tperson__name"],
      ["Zuletzt da", ".tperson__zuletzt"],
      ["Grenzsatz", ".t-kopf__grenze"],
    ]) {
      const m = await messen(waehler);
      ok(m !== null && m.wert >= 4.5,
        `${name}: ${m ? m.wert.toFixed(2) + ":1 (" + m.farbe.join(",") + " auf " + m.hinten.join(",") + ")" : "nicht gefunden"}`);
    }
    /* GEGENPROBE: ein absichtlich zu dunkler Text MUSS durchfallen. */
    await s.evaluate(() => { document.querySelector(".tz__wert").style.color = "#131820"; });
    const schlecht = await messen(".tz__wert");
    ok(schlecht !== null && schlecht.wert < 4.5,
      `absichtlich zu dunkler Text fällt durch (${schlecht?.wert.toFixed(2)}:1)`);
    await s.evaluate(() => { document.querySelector(".tz__wert").style.color = ""; });
  }

  ok(konsole.length === 0, konsole.length ? "Konsole: " + konsole[0] : "keine Fehler in der Konsole");
  /* GEGENPROBE zum Lauscher. */
  await s.evaluate(() => { setTimeout(() => { throw new Error("Absicht"); }, 0); });
  await s.waitForTimeout(400);
  ok(konsole.some((z) => /Absicht/.test(z)), "ein absichtlicher Fehler wird bemerkt");
  await ctx.close();
  await browser.close();
}

console.log(`\n${geprueft} Prüfungen`);
console.log(fehler ? `${fehler} FEHLER` : "ALLES IN ORDNUNG");
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
process.exit(fehler ? 1 : 0);