dogfather-universe/server/pruef-rollen.mjs

/* =====================================================================
   Rollen-Rundgang: was eine Rolle SIEHT, muss auch funktionieren.

   Anlass (02.09.2026): "cigdem kriegt als manager gewisse sachen nicht
   auf die sie sieht, check jede rolle ab und sieh zu dass alles
   funktioniert in jeder rolle."

   ---------------------------------------------------------------------
   WARUM DAS EINE EIGENE PRÜFUNG IST

   Die bestehenden Prüfungen sehen fast alle mit den Augen von DogFather
   auf die Anwendung — und DogFather sieht alles. Genau deshalb fallen
   Rollenfehler nicht auf: Eine Seite, die für einen Manager leer bleibt
   oder mit 404 antwortet, ist in einer Admin-Prüfung tadellos.

   Hier läuft jede der vier Rollen über JEDE Seite, und geprüft wird
   nicht "sieht gut aus", sondern dreierlei:

     1. Keine Fehler in der Browser-Konsole.
     2. Kein Aufruf an den Server, der mit 4xx/5xx zurückkommt
        (401 auf dem Anmeldeweg ausgenommen — der gehört dazu).
     3. Kein sichtbarer Knopf, der ins Leere führt: Jeder Verweis muss
        ein Ziel haben, das es gibt.

   Dazu die eigentliche Frage: Wo eine Rolle etwas sehen DARF, darf die
   Seite nicht wortlos leer sein. Ein leerer Bereich ohne Erklärung
   sieht aus wie ein Fehler — und ist oft auch einer.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { heuteLokal, tagLokal } from "./helfer-zeit.mjs";
/* Die Adresse des anderen Hauses kommt aus der EINEN Stelle, an der
   sie steht -- eine zweite hier waere die, die beim Umzug stehen
   bleibt und dann eine falsche Adresse als "bekannt" durchwinkt. */
import { CREW_ADRESSE } from "./crew-adresse.js";

const ordner = mkdtempSync(join(tmpdir(), "ws-rollen-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
   Ohne diese Zeile startet der eigene Server bei belegtem Port
   STILL nicht -- und alles Folgende misst gegen einen fremden
   Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
   als kaputt. */
const PORT = await eigenerPort(import.meta, "pruef-rollen");
process.env.PORT = `${PORT}`;
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
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 }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { eigenerPort } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
   zwei Auffangnetze ein, die einen Absturz nur protokollieren --
   richtig fuer den Betrieb, fatal fuer eine Pruefung. Ohne diese
   Zeile bleibt der Prozess nach einem Fehler ewig stehen, weil der
   Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
/* DIE FRIST MUSS ZUR ARBEIT PASSEN -- 900 s seit dem 11.09.2026.

   Diese Pruefung besucht JEDE Kachel JEDER Rolle einzeln und wartet
   dabei auf networkidle. Ihre Dauer haengt also an der Zahl der
   Kacheln, und die ist heute gewachsen: Die rechte Hand hat vier
   dazubekommen (Entwicklung, Talente, Wer sieht was, Wie geht es dir).

   Bei 480 s ist der Lauf danach in die Notbremse gelaufen -- mitten im
   Zaehlen, nichts haing. Gemessen am 11.09.2026 auf diesem Rechner:
   423 s fuer 315 Pruefungen, also 12 % Luft. Das ist zu knapp; eine
   Notbremse, die bei normaler Arbeit ausloest, ist keine Notbremse,
   sondern ein Fehlalarm -- und ein Fehlalarm, der regelmaessig kommt,
   wird ueberlesen (siehe die Projektnotiz zur Loeschwarnung).

   900 s sind gut das Doppelte der Messung. Wer hier wieder anstoesst,
   soll NICHT die Zahl erhoehen, sondern zuerst nachsehen, ob der Lauf
   noch vorankommt: eine Frist, die man dreimal hochsetzt, misst
   irgendwann gar nichts mehr. */
notbremse(900_000, "pruef-rollen");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 540_000).unref?.();

let fehler = 0;
let geprueft = 0;
/* Summe der Seiten, die alle Rollen ZUSAMMEN durchgehen -- je Rolle
   verschieden, seit die beiden aus dem anderen Haus ihre eigenen
   haben. Siehe unten beim Abschluss. */
let erwartetGesamt = 0;
/* DER DRITTE AUSGANG (23.09.2026). Diese Pruefung kannte nur zwei: in
   Ordnung und nicht in Ordnung. Eine Kachel, die aus dem Haus
   hinausfuehrt, ist weder das eine noch das andere -- sie ist von hier
   aus nicht messbar. Ohne diesen Ausgang muesste man sie entweder
   gruen luegen oder rot melden; beides sagt etwas, das nicht stimmt. */
let offen = 0;
const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };
const unklar = (t) => { offen++; console.log("  --   " + t); };

/* ---------- Ein Team mit echten Daten ----------------------------------
   Ohne Daten prüft ein Rundgang nur leere Seiten -- und leere Seiten
   machen selten Fehler. Jede Rolle bekommt deshalb etwas zu sehen. */

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
/* ORTSZEIT, nicht UTC -- Begruendung in helfer-zeit.mjs. */
const tag = (v) => tagLokal(v);

/* DER SUCHSCHLUESSEL ZUM CODE (09.09.2026).

   Ohne ihn kaeme ein Modi nicht herein: Er hat keine Kachel, der stille
   Zugang findet ihn allein ueber diesen Wert. Er muss dastehen, BEVOR
   die erste Person angelegt wird -- die Personen entstehen hier von
   Hand und nicht ueber personAnlegen(), das ihn sonst selbst schreibt. */
const kennungSchluessel = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
  + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
  .run("code_kennung_schluessel", kennungSchluessel, jetzt);

function person(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");
  const kennung = createHmac("sha256", kennungSchluessel).update(code).digest("hex");
  d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, code_kennung, aktiv, erstellt)"
    + " VALUES (?,?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, kennung, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi = person("Filipe", "admin", "CODE-DOGI-0001");
const idCigdem = person("Cigdem", "manager", "CODE-CIGDEM-01");
const idBen = person("Ben", "scout", "CODE-BEN-00001");
const idTili = person("Tili", "creator", "CODE-TILI-0001");
/* SPICY MEDIA HAT HIER VIER WOCHEN GEFEHLT (06.10.2026).

   Von den fuenf Rollen des Agenturhauses liefen fuenf Durchgaenge --
   aber zweimal Manager und zweimal Scout, und Spicy Media gar nicht.
   Gemerkt habe ich es erst, als die Anleitung ihr eine eigene
   Fassung gab und ich wissen wollte, ob die Seite fuer sie aufgeht.

   Sie ist nicht "noch eine Rolle": Ihr gehoert die Gruppe "Rund um
   das Team" samt Team-Lage, die sonst niemand ausser DogFather hat.
   Diese Kachel ist also auf keinem Durchgang je geoeffnet worden. */
person("Spicy", "spicy", "CODE-SPICY-00001");
/* Zwei Neue ohne jede Zuteilung -- der Zustand am ersten Tag. */
person("Neu-Scout", "scout", "CODE-NEU-000001");
person("Neu-Manager", "manager", "CODE-NEUM-00001");
/* Ein Modi -- verborgen fuer alle ausser der DogFather-Rolle und den
   anderen Modis. Er laeuft hier ueber JEDE Seite, denn "verborgen"
   heisst nicht "darf kaputt sein": Was er sieht, muss auch gehen. */
person("Marina", "modi", "CODE-MODI-0001");
/* Und die Stellvertretung (10.09.2026). Sie sieht mehr als ein Modi
   -- unter anderem den Eingang --, ist aber genauso verborgen. Beides
   muss durch denselben Rundgang: Wer mehr Kacheln hat, hat auch mehr
   Stellen, an denen eine ins Leere fuehren kann. */
person("Rieke", "hand", "CODE-HAND-0001");

/* Cigdem betreut Tili, Ben ebenfalls -- so hat jede betreuende Rolle
   etwas zu sehen. Genau diese Zuteilung fehlte im echten Bestand, und
   deshalb blieben Cigdems Seiten leer. */
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idTili, idCigdem, jetzt);
/* Ein zweiter Creator, damit auch der Scout WIRKLICH jemanden betreut.
   Ohne ihn hiess ein Durchgang "Scout (mit Creator)" und prüfte in
   Wahrheit denselben leeren Fall wie der ohne -- eine Prüfung, die
   glaubt, zwei Fälle abzudecken, und in Wirklichkeit einen zweimal
   nimmt. */
const idLuna = person("Luna", "creator", "CODE-LUNA-0001");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idBen, jetzt);
d.prepare("INSERT INTO scout_zuteilung (scout_id, manager_id, seit) VALUES (?,?,?)").run(idBen, idCigdem, jetzt);

d.prepare(`INSERT INTO aufgaben (titel, status, prioritaet, creator_id, verantwortlich_id, frist, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,?,?)`)
  .run("Thumbnail bauen", "offen", "hoch", idTili, idTili, tag(2), jetzt, idDogi);
d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, creator_id, teilnehmer_id, erledigt, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,0,?,?)`)
  .run("Wochen-Call", "call", tag(1) + "T18:00", 30, idTili, idTili, jetzt, idDogi);
d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, creator_id, teilnehmer_id, erledigt, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,0,?,?)`)
  .run("Vergangener Call", "call", tag(-1) + "T18:00", 30, idTili, idTili, jetzt, idDogi);
d.prepare(`INSERT INTO eintraege (bereich, art, titel, datum, status, creator_id, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,?,?)`)
  .run("live", "vorbereitung", "Technik prüfen", tag(0), "offen", idTili, jetzt, idDogi);
d.prepare(`INSERT INTO eintraege (bereich, art, titel, datum, status, creator_id, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,?,?)`)
  .run("content", "idee", "Videoidee Halloween", tag(0), "offen", idTili, jetzt, idDogi);
d.close();

/* ---------- Der Rundgang ------------------------------------------------ */

/* ZWEI SEITEN FEHLTEN HIER (06.10.2026).

   `manager-ziele.html` (seit 02.10.) und `anleitung.html` (seit heute)
   standen nicht in dieser Liste. Ganz ungeprueft waren sie nicht -- der
   Kachel-Durchgang weiter unten oeffnet jede Kachel jeder Rolle und
   haette gemerkt, wenn eine ins Leere fuehrt. Er prueft aber nur, WO
   man landet. Die eigentliche Arbeit dieser Liste -- Fehler in der
   Browserkonsole, 4xx-Antworten vom Server, tote Verweise, leere
   Seiten, waagerechtes Ueberstehen -- lief fuer beide nie.

   Das ist dieselbe Sorte Luecke wie am 28.08.2026 bei RunOne: Der Lauf
   war gruen, und acht Pruefungen je Geraet fielen still weg. Hier
   waren es zwei Seiten mal acht Rollen.

   Eine abgeschriebene Liste bleibt es trotzdem, und sie wird wieder
   veralten. Richtig waere, sie aus `rechte.js` abzuleiten -- dort
   steht jede Seite des Hauses genau einmal. Das ist ein eigener
   Umbau; bis dahin gilt: Wer eine Seite anlegt, traegt sie hier ein. */
const SEITEN = [
  "start.html", "uebersicht.html", "aufgaben.html", "kalender.html", "calls.html",
  "content.html", "bereich.html?b=live", "dateien.html", "personen.html",
  "scouting.html", "steckbrief.html", "profil.html", "report.html",
  "wissen.html", "startcheck.html", "automation.html",
  "manager-ziele.html", "anleitung.html",
];

/* Fünf Durchgänge, nicht vier.

   Der fünfte ist der wichtigste: eine Person MIT Rolle, aber OHNE
   zugeteilte Creator. Das ist kein Sonderfall, sondern der Normalfall
   am ersten Tag -- und es war Cigdems echte Lage, als sie meldete,
   dass Dinge nicht gehen. Genau in diesem Zustand fielen beim ersten
   Lauf drei Seiten durch, während dieselben Seiten mit Zuteilung
   tadellos waren. Wer nur den bestückten Fall prüft, findet das nie. */
const ROLLEN = [
  { rolle: "admin", code: "CODE-DOGI-0001", name: "DogFather" },
  { rolle: "manager", code: "CODE-CIGDEM-01", name: "Manager (mit Creator)" },
  { rolle: "scout", code: "CODE-BEN-00001", name: "Scout (mit Creator)" },
  { rolle: "creator", code: "CODE-TILI-0001", name: "Creator (Tili)" },
  { rolle: "spicy", code: "CODE-SPICY-00001", name: "Spicy Media" },
  { rolle: "scout", code: "CODE-NEU-000001", name: "Scout (OHNE Creator)" },
  { rolle: "manager", code: "CODE-NEUM-00001", name: "Manager (OHNE Creator)" },
  /* ==== DIE BEIDEN AUS DEM ANDEREN HAUS (berichtigt 06.10.2026) ====

     HIER STAND `rolle: "creator"` MIT EINER AUSFUEHRLICHEN BEGRUENDUNG:
     „Fuer einen Modi gibt es keine Kachel; er tippt auf irgendeine
     vorhandene, und der Code entscheidet." Das war am 09.09.2026
     richtig und ist es seit der Haustrennung nicht mehr.

     Ein Modi kommt auf der AGENTURADRESSE gar nicht mehr herein --
     die Anmeldung antwortet mit 401, und zwar zu Recht
     (`sitzungPasstZurAdresse`). Der Lauf hing danach fuenfzehn
     Sekunden in `waitForURL` und BRACH AB. Damit war nicht nur der
     Modi ungeprueft, sondern auch die rechte Hand dahinter -- und der
     ganze Lauf meldete rot, seit Wochen. Eine Pruefung, die immer rot
     ist, liest niemand mehr.

     DER FEHLER SAH AUS WIE EINE ZEITUEBERSCHREITUNG, also wie
     Langsamkeit. Gemessen (eigener Nachbau, echter Browser) war es
     etwas anderes: Die Seite blieb auf `/workspace/` stehen, und in
     der Konsole stand ein 401. Nicht langsam -- abgewiesen.

     Beide gehen jetzt ueber ihre eigene Adresse, und `rolle` ist
     wieder das, wonach es aussieht: die Kachel, die dort steht. */
  { rolle: "modi", code: "CODE-MODI-0001", name: "Modi (Marina)", haus: "crew" },
  { rolle: "hand", code: "CODE-HAND-0001", name: "Rechte Hand (Rieke)", haus: "crew" },
];

/* =====================================================================
   DIE CREW-ADRESSE BRAUCHT HTTPS -- und das ist keine Umstaendlichkeit
   =====================================================================

   Erster Versuch war `http://crew.dogfather-universe.com:PORT` mit
   blosser Namensaufloesung. Das ergab eine Seite GANZ OHNE
   GESTALTUNG: nackte Browserdarstellung, der Anmeldeknopf 76 x 21
   Pixel am linken Rand, und jeder Klick darauf lief in eine
   Zeitueberschreitung.

   DER GRUND steht in pruef-handy-teamdogi: `dogfather-universe.com`
   ist in der HSTS-Liste der Browser eingetragen. Chromium stuft jede
   http-Adresse dieser Domain selbst auf https hoch -- die
   Stilvorlagen kamen deshalb nie an. Nachgemessen hat das erst der
   Blick auf das Bildschirmfoto; die Zahlen davor (sichtbar, nicht
   gesperrt, bewegt sich nicht) sahen alle in Ordnung aus.

   LIVE IST ALLES HEIL -- gegengeprueft auf der echten Adresse: Die
   Wand verlangt gate.css und crew-haus.css, beide kommen mit 200.
   Es war also ein Fehler meines Aufbaus, kein Befund am Haus.

   Also derselbe Weg wie dort: ein kleiner HTTPS-Vorbau mit eigenem
   Zertifikat, der unveraendert an den echten Server weiterreicht --
   besonders die Host-Kopfzeile, denn an ihr entscheidet das Haus,
   wer was sieht. */
const CREW = "crew.dogfather-universe.com";
const { createServer: httpsServer } = await import("node:https");
const { request: httpAnfrage } = await import("node:http");
const { readFileSync: liesDatei } = await import("node:fs");
const { zertifikatBauen } = await import("./helfer-openssl.mjs");
const { mkdtempSync: machOrdner } = await import("node:fs");
const { tmpdir: zwischenlager } = await import("node:os");
const { join: pfadBauen } = await import("node:path");

const certOrdner = machOrdner(pfadBauen(zwischenlager(), "ws-rollen-cert-"));
const schluesselDatei = pfadBauen(certOrdner, "pruef.key");
const zertDatei = pfadBauen(certOrdner, "pruef.crt");
zertifikatBauen(schluesselDatei, zertDatei, CREW);

const CREW_PORT = PORT + 1;
const vorbau = httpsServer({
  key: liesDatei(schluesselDatei), cert: liesDatei(zertDatei),
}, (von, nach) => {
  const weiter = httpAnfrage({
    host: "127.0.0.1", port: PORT, path: von.url, method: von.method,
    headers: { ...von.headers, host: `${CREW}:${CREW_PORT}` },
  }, (antwort) => {
    nach.writeHead(antwort.statusCode || 502, antwort.headers);
    antwort.pipe(nach);
  });
  weiter.on("error", () => { try { nach.writeHead(502); nach.end(); } catch { /* egal */ } });
  von.pipe(weiter);
});
await new Promise((r) => vorbau.listen(CREW_PORT, "127.0.0.1", r));

const CREW_BASIS = `https://${CREW}:${CREW_PORT}`;

const { chromium } = await import(
  "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");

/* ==== EIN BROWSER JE ROLLE, NICHT EINER FUER ALLE (19.09.2026) ========

   DER BEFUND: Dieser Lauf ist bei der fuenften Rolle abgestuerzt --
   "Target crashed", nach 234 gruenen Pruefungen. Kein Fehlschlag,
   sondern ein toter Browser: Der Renderer-Prozess wird vom System
   beendet, wenn ihm der Speicher ausgeht.

   Nachgemessen gegen den Stand VOR den Aenderungen dieses Tages
   (Commit 0b73fbb) -- dort stuerzt er genauso ab, an derselben Stelle.
   Er war also schon vorher rot, und zwar ohne dass es jemandem
   aufgefallen ist: Von aussen sieht ein abgestuerzter Browser aus wie
   ein Programmfehler, und die 234 gruenen Zeilen davor lesen sich wie
   ein fast bestandener Lauf.

   DIE URSACHE IST DIE MENGE: fuenf Rollen mal sechzehn Seiten, jede
   mit Hintergrundbild, Schriften und Skripten -- rund achtzig
   Seitenaufbauten in EINEM Browserprozess. Die Kontexte wurden zwar
   je Rolle geschlossen (`kontext.close()`), der Prozess darunter lief
   aber durch und gab den Speicher nicht zurueck.

   Ein Prueflauf, der abstuerzt, beweist nichts -- er ist schlimmer als
   einer, der scheitert, weil das Ergebnis nach Programmfehler aussieht.
   Deshalb bekommt jede Rolle ihren eigenen Browser, und der wird am
   Ende der Runde beendet. Kostet ein paar Sekunden je Rolle. */

/* Fehler, die nichts mit uns zu tun haben. Bewusst kurz gehalten: Jede
   Ausnahme hier ist eine Stelle, an der eine echte Panne durchrutschen
   könnte. */
const EGAL = [
  /favicon/i,
  /Failed to load resource: net::ERR_/i,   // abgebrochene Bilder beim Seitenwechsel
];
const istEgal = (t) => EGAL.some((r) => r.test(t));

const berichte = [];

/* =====================================================================
   DIE MESSUNG EINER SEITE -- an EINER Stelle, weil sie zweimal
   gebraucht wird: einmal fuer die Seite selbst, einmal fuer die
   Gegenprobe weiter unten. Eine zweite, danebengeschriebene Fassung
   waere die, die beim naechsten Umbau auseinanderlaeuft -- und dann
   prueft die Gegenprobe etwas anderes als der Rundgang.

   Sie laeuft IM BROWSER (Playwright schickt den Quelltext hinueber),
   darf also nichts aus diesem Modul benutzen.
   ===================================================================== */
function zustandMessen() {
  const sichtbar = (e) => {
    const k = e.getBoundingClientRect();
    return k.width > 0 && k.height > 0 && getComputedStyle(e).visibility !== "hidden";
  };
  /* Verweise, die ins Leere zeigen. Ein Knopf, der nichts tut, ist
     schlimmer als kein Knopf: Man klickt ihn immer wieder. */
  const tote = [...document.querySelectorAll("a[href]")]
    .filter(sichtbar)
    .filter((a) => {
      const h = a.getAttribute("href");
      return !h || h === "#" || h === "javascript:void(0)";
    })
    .map((a) => a.textContent.trim().slice(0, 40));

  /* ==================================================================
     EIN LADEHINWEIS ZAEHLT NUR, WENN ER AUCH DASTEHT (06.10.2026)

     Diese Prüfung meldete drei Befunde, und alle drei waren falsch:
     `#liste` auf werdegang.html, `#personen` und `#meine-karte` auf
     entwicklung.html. Alle drei stehen in einem Abschnitt, der
     `hidden` traegt, und `gate.css` setzt hausweit
     `[hidden] { display: none !important; }`. Sie werden also gar
     nicht dargestellt und sind damit auch aus dem Baum draussen, den
     Vorleseprogramme lesen -- niemand bekommt dort je ein "wird
     geladen" zu hoeren.

     Ich hatte das Gegenteil notiert und sauber begruendet ("meldet
     Vorleseprogrammen dauerhaft, die Seite laedt"). Die Begruendung
     klang schluessig und war trotzdem falsch, weil ich sie nicht
     nachgemessen hatte. Und eine Warnung, die bei jedem Lauf kommt,
     ohne dass jemand etwas davon hat, ist keine Warnung mehr -- sie
     bringt einem bei, die naechste zu ueberlesen, und die koennte
     echt sein.

     `checkVisibility()` statt der Kasten-Rechnung oben: Ein
     Ladebehaelter, der sichtbar, aber noch LEER ist, hat Hoehe 0 --
     die Kasten-Rechnung wuerde ihn durchwinken, und das waere genau
     der Fall, den diese Zeile fangen soll. `checkVisibility` fragt
     dagegen, ob das Element ueberhaupt dargestellt wird.

     Kann der Browser die Frage nicht beantworten (sehr alt), wird
     NICHT stillschweigend gefiltert, sondern alles gemeldet und das
     Nichtwissen weitergereicht -- siehe `kannSichtbarkeit`.
     ================================================================== */
  const kannSichtbarkeit = typeof Element.prototype.checkVisibility === "function";
  const ladend = [...document.querySelectorAll('[aria-busy="true"]')];
  const haengt = (kannSichtbarkeit ? ladend.filter((e) => e.checkVisibility()) : ladend)
    .map((e) => e.id || e.getAttribute("class") || e.tagName.toLowerCase());

  /* Sichtbarer Text insgesamt -- eine Seite, auf der praktisch
     nichts steht, ist entweder leer oder kaputt. */
  const text = (document.querySelector("main")?.innerText || "").trim();
  return {
    tote,
    laenge: text.length,
    /* Ein sichtbarer Hinweis, der die Leere erklärt. */
    erklaert: [...document.querySelectorAll(".leer-hinweis, .leer, .k-leer, .block__frage")]
      .some((e) => e.getBoundingClientRect().height > 0 && e.textContent.trim().length > 25),
    haengt,
    kannSichtbarkeit,
    ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
  };
}

for (const r of ROLLEN) {
  /* `--ignore-certificate-errors` als ARGUMENT und nicht nur
     `ignoreHTTPSErrors` am Kontext: Die Domain steht in der
     HSTS-Liste, und dort laesst Chromium sonst kein eigenes
     Zertifikat durch (steht so in pruef-handy-teamdogi). */
  const browser = await chromium.launch({
    args: [`--host-resolver-rules=MAP ${CREW} 127.0.0.1`,
      "--ignore-certificate-errors"],
    ignoreHTTPSErrors: true,
  });
  const kontext = await browser.newContext({ viewport: { width: 1440, height: 1000 } });
  const seite = await kontext.newPage();

  /* EIN ABGESTUERZTER BROWSER MUSS SICH MELDEN, nicht schweigen.
     Ohne diesen Zuhoerer faellt der Absturz erst beim naechsten
     Zugriff auf -- als Zeitueberschreitung irgendwo weiter unten,
     Hunderte Zeilen von der Ursache entfernt. */
  seite.on("crash", () => {
    console.error(`  ABSTURZ: Der Browser ist bei "${r.name}" gestorben.`);
    console.error("  Das ist kein Befund am Code -- meist fehlender Speicher.");
  });

  /* JEDE ROLLE AUF IHRER EIGENEN ADRESSE. Steht hier oben, weil der
     Antwort-Zuhoerer darunter sie schon braucht. */
  const wurzel = r.haus === "crew" ? CREW_BASIS : BASIS;
  const konsole = [];
  const schlechteAntworten = [];
  seite.on("console", (m) => { if (m.type() === "error" && !istEgal(m.text())) konsole.push(m.text()); });
  seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));
  seite.on("response", (a) => {
    const u = a.url();
    if (!u.includes("/workspace/")) return;
    /* 401 auf dem Anmeldeweg gehoert dazu -- die Seite fragt, bekommt
       "nicht angemeldet" und leitet um. Alles andere nicht. */
    if (a.status() === 401 && /\/api\/ich|\/api\/sitzung/.test(u)) return;
    if (a.status() >= 400) schlechteAntworten.push(`${a.status()} ${u.replace(wurzel, "")}`);
  });

  await seite.goto(wurzel + "/workspace/", { waitUntil: "domcontentloaded" });
  await seite.click(`.rolle[data-rolle="${r.rolle}"]`, { timeout: 10000 });
  await seite.fill("#code", r.code);
  /* Die Altersfrage erscheint nur fuer die Community -- deshalb erst
     fragen, ob sie ueberhaupt sichtbar ist. Dieselbe Reihenfolge wie
     in pruef-handy-teamdogi. */
  const alter = await seite.$("#alter-ok");
  if (alter && await alter.isVisible().catch(() => false)) await alter.check();
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 20000 });

  console.log(`\n===== ${r.name} =====`);

  /* WELCHE SEITEN DIESE ROLLE BEKOMMT -- abgeleitet, nicht
     abgeschrieben.

     `SEITEN` oben ist die Liste des AGENTURHAUSES. Fuer einen Modi
     waeren das lauter Seiten, die es auf seiner Adresse nicht gibt;
     der Rundgang liefe sechzehnmal gegen dieselbe Startseite und
     bewiese nichts.

     Was eine Rolle wirklich hat, steht auf ihrer Startseite -- genau
     das benutzt der Kachel-Durchgang weiter unten schon seit dem
     10.09.2026, mit derselben Begruendung („eine feste Liste daneben
     koennte selbst veralten"). */
  let seitenListe = SEITEN;
  if (r.haus === "crew") {
    await seite.goto(wurzel + "/workspace/start.html", { waitUntil: "networkidle" });
    await seite.waitForSelector(".gruppe a[href]", { timeout: 15000 }).catch(() => {});
    const eigene = await seite.evaluate(() =>
      [...document.querySelectorAll(".gruppe a[href]")]
        .map((a) => a.getAttribute("href"))
        .filter((h) => h && !h.startsWith("#") && !/^https?:/i.test(h)));
    /* DIE ZAHL GEHOERT IN DIE BEDINGUNG: Faende sich keine Kachel,
       bliebe die Liste leer und der Rundgang waere still
       uebersprungen -- gruen, ohne eine Seite gesehen zu haben. */
    ok(eigene.length > 0,
      `${r.name.padEnd(18)} hat ${eigene.length} eigene Seiten zum Durchgehen`);
    if (eigene.length) seitenListe = [...new Set(["start.html", ...eigene])];
  }
  erwartetGesamt += seitenListe.length;

  for (const pfad of seitenListe) {
    konsole.length = 0;
    schlechteAntworten.length = 0;
    await seite.goto(wurzel + "/workspace/" + pfad, { waitUntil: "networkidle" });
    await seite.waitForTimeout(700);

    const zustand = await seite.evaluate(zustandMessen);
    /* DER DRITTE AUSGANG: Kann der Browser die Sichtbarkeit nicht
       beantworten, meldet die Messung ALLE Ladehinweise -- auch die
       verborgenen. Dann ist ein Befund hier kein Befund am Code,
       sondern ein Hinweis auf die Messung. Darf nicht schweigen. */
    if (!zustand.kannSichtbarkeit) {
      unklar(`${r.name.padEnd(18)} ${pfad.padEnd(22)} dieser Browser kennt`
        + " checkVisibility() nicht -- Ladehinweise ungefiltert gezaehlt");
    }

    const probleme = [];
    if (konsole.length) probleme.push("Konsole: " + konsole.slice(0, 2).join(" | ").slice(0, 160));
    if (schlechteAntworten.length) probleme.push("Server: " + [...new Set(schlechteAntworten)].slice(0, 3).join(", "));
    if (zustand.tote.length) probleme.push("tote Verweise: " + zustand.tote.slice(0, 3).join(", "));
    /* Mit NAMEN und nicht nur als Zahl: "3x haengt beim Laden" schickt
       einen auf die Suche, "haengt beim Laden: liste" nicht. */
    if (zustand.haengt.length) probleme.push("haengt beim Laden: " + zustand.haengt.join(", "));
    /* =================================================================
       „WORTLOS leer" -- das Wort stand im Kopf dieser Datei und war
       nie umgesetzt (gefunden 06.10.2026).

       Oben heisst es seit dem ersten Tag: „Ein leerer Bereich OHNE
       ERKLAERUNG sieht aus wie ein Fehler." Gemessen wurde die
       Erklaerung auch -- `erklaert` stand im Rueckgabewert. Benutzt
       hat sie nie jemand. Eine Seite, die zu Recht leer ist und das
       ordentlich sagt („Noch nichts hier"), waere also als Fehler
       gemeldet worden.

       Das ist keine Kleinigkeit, sondern eine gestellte Falle: Wer
       eines Tages so eine Seite baut, bekommt Rot ohne Fehler und
       senkt am wahrscheinlichsten die Grenze von 120 -- fuer alle
       Seiten, auch die wirklich kaputten. Eine Messung, die
       danebenliegt und nicht benutzt wird, liest sich im Quelltext
       wie eine Zusage, die es nicht gibt.

       HEUTE AENDERT DAS NICHTS: Keine der 368 Durchgaenge liegt unter
       120 Zeichen, der Lauf davor war mit der strengen Fassung
       ebenso gruen. Die Zeile wirkt erst in dem Fall, fuer den sie
       von Anfang an gedacht war -- und sie schweigt ihn nicht weg,
       sondern schreibt ihn in den Bericht. */
    if (zustand.laenge < 120) {
      if (zustand.erklaert) {
        /* NICHT `unklar()`: Das ist der dritte Ausgang fuer „konnte
           nicht nachsehen". Hier wurde nachgesehen, und das Ergebnis
           ist in Ordnung -- nur erwaehnenswert. Die Seite bekommt
           ihren normalen Haken wie jede andere. */
        console.log(`  INFO ${r.name.padEnd(18)} ${pfad.padEnd(22)} ist leer`
          + ` (${zustand.laenge} Zeichen), sagt aber warum -- kein Fehler`);
      } else {
        probleme.push(`wortlos leer (${zustand.laenge} Zeichen, kein Hinweis, der es erklaert)`);
      }
    }
    if (zustand.ueber > 0) probleme.push(`ragt ${zustand.ueber}px heraus`);

    ok(!probleme.length, `${r.name.padEnd(18)} ${pfad.padEnd(22)} ${probleme.join(" · ")}`);
    if (probleme.length) berichte.push({ rolle: r.name, pfad, probleme });
  }

  /* =====================================================================
     DIE GEGENPROBE ZUM LADEHINWEIS (06.10.2026)

     Seit die Messung oben verborgene Ladehinweise nicht mehr zaehlt,
     kann sie auf zwei Arten falsch sein: Sie koennte gar nichts mehr
     finden. Eine Pruefung, die immer bestaetigt, bestaetigt nichts --
     also wird hier beides bewiesen, und zwar MIT DERSELBEN Funktion,
     die der Rundgang benutzt:

       1. Ein SICHTBARER Ladehinweis wird gefunden  -> sie kann rot.
       2. Ein VERBORGENER wird nicht gefunden       -> sie filtert
          wirklich nach Sichtbarkeit und nicht nach irgendetwas.

     Beides auf der Seite, auf der die Rolle gerade steht. Die beiden
     Knoten verschwinden sofort wieder; der naechste Aufruf laedt die
     Seite ohnehin neu.
     ===================================================================== */
  await seite.evaluate(() => {
    const wo = document.querySelector("main") || document.body;
    const sicht = document.createElement("p");
    sicht.id = "gegenprobe-sichtbar";
    sicht.setAttribute("aria-busy", "true");
    sicht.textContent = "wird geladen …";
    wo.append(sicht);

    const huelle = document.createElement("section");
    huelle.hidden = true;
    const still = document.createElement("p");
    still.id = "gegenprobe-verborgen";
    still.setAttribute("aria-busy", "true");
    still.textContent = "wird geladen …";
    huelle.append(still);
    wo.append(huelle);
  });
  const probe = await seite.evaluate(zustandMessen);
  ok(probe.haengt.includes("gegenprobe-sichtbar"),
    `${r.name.padEnd(18)} Gegenprobe: ein SICHTBARER Ladehinweis wird gefunden`);
  ok(!probe.haengt.includes("gegenprobe-verborgen"),
    `${r.name.padEnd(18)} Gegenprobe: ein VERBORGENER wird nicht mitgezaehlt`);
  await seite.evaluate(() => {
    document.getElementById("gegenprobe-sichtbar")?.remove();
    document.getElementById("gegenprobe-verborgen")?.closest("section")?.remove();
  });


  /* =====================================================================
     JEDE KACHEL, DIE EINE ROLLE BEKOMMT, MUSS AUCH AUFGEHEN
     (10.09.2026)

     Anlass: Ein Modi bekam zehn Kacheln, und FUENF davon leiteten
     wortlos auf die Startseite zurueck -- der Server liess seine Rolle
     nicht auf bereich.html und profil.html. Der Rundgang oben meldete
     alle Seiten trotzdem als "ok", und zu Recht: Eine Umleitung ist
     kein Fehler. Die Seite laedt, es gibt keinen roten Eintrag in der
     Konsole, keine 4xx-Antwort. Sie ist nur eine andere.

     Das ist eine eigene Fehlerklasse: nicht "kaputt", sondern "fuehrt
     woandershin". Sie faellt niemandem auf, der die Anwendung nicht
     selbst benutzt -- und dem Benutzer faellt sie auf, weil ein Knopf
     nichts tut.

     GEPRUEFT WIRD DIE ZUSAGE, NICHT DIE SEITENLISTE OBEN: Was eine
     Rolle angeboten bekommt, steht auf ihrer Startseite. Genau das wird
     hier durchgeklickt. Eine feste Liste daneben ginge am Punkt vorbei
     -- sie koennte selbst veralten.
     ===================================================================== */
  await seite.goto(wurzel + "/workspace/start.html", { waitUntil: "networkidle" });
  await seite.waitForSelector(".gruppe a[href]", { timeout: 15000 }).catch(() => {});
  const kacheln = await seite.evaluate(() =>
    [...document.querySelectorAll(".gruppe a[href]")]
      .map((a) => a.getAttribute("href"))
      .filter((h) => h && !h.startsWith("#")));
  /* DIE ZAHL GEHOERT IN DIE BEDINGUNG. Faende die Suche keine Kachel --
     anderer Aufbau, anderer Klassenname --, waere unten alles gruen,
     ohne dass ein einziger Knopf gedrueckt wurde. */
  ok(kacheln.length > 0, `${r.name.padEnd(18)} bekommt ${kacheln.length} Kacheln angeboten`);
  for (const href of kacheln) {
    /* =================================================================
       EINE KACHEL KANN AUS DEM HAUS HINAUSFUEHREN (23.09.2026)
       =================================================================

       DogFather bekommt auf der Agenturadresse die Kachel „Zu Team
       Dogi". Ihr Ziel ist eine VOLLSTAENDIGE Adresse -- es muss eine
       sein, das andere Haus liegt auf einem anderen Rechnernamen.

       Diese Pruefung klebte jedes Ziel an `BASIS + "/workspace/"`.
       Bei einer vollstaendigen Adresse kommt dabei Unsinn heraus; der
       Browser landete auf start.html, und die Zeile meldete
       „LANDET AUF start.html". Ein echter Befund war das nie -- die
       Kachel ist richtig, die Messung war es nicht.

       Dass es solche Kacheln GIBT, steht im Server ausdruecklich
       (`aussen: true` an der Kachel, samt Begruendung). Das Merkmal
       kommt aber nicht in die Seite; hier ist nur die Adresse zu
       sehen. Also wird abgeleitet: Wer eine vollstaendige Adresse
       traegt, fuehrt hinaus.

       WAS DANN GEPRUEFT WIRD -- und was nicht. Ob die andere Tuer
       aufgeht, laesst sich von hier nicht sagen: Das andere Haus
       antwortet unter einem anderen Namen, und dieser Browser kennt
       nur BASIS. Das ist der dritte Ausgang, und er wird als solcher
       gemeldet. Geprueft wird stattdessen, was hier zu pruefen IST:
       dass die Adresse zu einem Haus fuehrt, das dieses Haus kennt --
       und nicht irgendwohin.
       ================================================================= */
    if (/^https?:\/\//i.test(href)) {
      let ziel2 = null;
      try { ziel2 = new URL(href); } catch { ziel2 = null; }
      const heim = (() => { try { return new URL(CREW_ADRESSE).host; } catch { return null; } })();
      ok(!!ziel2 && !!heim && ziel2.host === heim && /\.html$/.test(ziel2.pathname),
        `${r.name.padEnd(18)} Kachel fuehrt aus dem Haus: ${href}`
        + (ziel2 && ziel2.host === heim ? " (bekanntes Haus)" : " -- FREMDE ADRESSE"));
      unklar(`${r.name.padEnd(18)} ob dort die Tuer aufgeht, laesst sich von hier`
        + " nicht messen -- das andere Haus hat eine andere Adresse");
      continue;
    }
    const ziel = href.split("#")[0];
    const seitenname = ziel.split("?")[0];
    await seite.goto(wurzel + "/workspace/" + ziel, { waitUntil: "networkidle" });
    await seite.waitForTimeout(400);
    const wo = seite.url().replace(wurzel + "/workspace/", "");
    ok(wo.split("?")[0] === seitenname,
      `${r.name.padEnd(18)} Kachel ${ziel.padEnd(26)} `
      + (wo.split("?")[0] === seitenname ? "kommt an" : `LANDET AUF ${wo}`));
  }

  await seite.screenshot({ path: `pruef-rollen-${r.rolle}.png`, fullPage: false });
  await kontext.close();
  await browser.close();
}

/* ---------- Abschluss --------------------------------------------------- */

console.log("");
/* FRUEHER: `ROLLEN.length * SEITEN.length`. Das stimmte, solange alle
   acht Rollen dieselbe Seitenliste hatten. Seit die beiden aus dem
   anderen Haus ihre EIGENEN Seiten durchgehen, wird aufsummiert --
   eine feste Multiplikation waere hier eine Rechnung von gestern. */
ok(geprueft >= erwartetGesamt,
  `jede Rolle war auf jeder ihrer Seiten (${geprueft} von ${erwartetGesamt} Durchgängen)`);

if (berichte.length) {
  console.log("\n--- Was zu tun ist ---");
  for (const b of berichte) console.log(`  ${b.rolle} · ${b.pfad}\n      ${b.probleme.join("\n      ")}`);
}

try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
console.log(`\n${fehler ? "FEHLER: " + fehler : "Alles in Ordnung"} — ${geprueft} Prüfungen`
  + (offen ? `, ${offen} nicht nachsehbar` : ""));
process.exit(fehler ? 1 : 0);