dogfather-universe/server/pruef-struktur.mjs

/* STRUKTURPRUEFUNG — findet Kaputtes, das kein Browser meldet.

   Auftrag vom 04.09.2026: vollstaendiger Audit des Creator Workspace.

   WAS DIESE PRUEFUNG SUCHT — drei Sorten stiller Fehler:

     1. Eine Seite laedt eine Datei, die es nicht gibt.
        Der Browser meldet das nur in der Konsole; die Seite sieht
        einfach etwas anders aus. Bei CSS faellt es auf, bei einem
        einzelnen JS-Baustein oft monatelang nicht.

     2. Ein Verweis fuehrt ins Leere.
        Eine Kachel, ein Zurueck-Knopf, ein Menuepunkt — Ziel existiert
        nicht. Erst der Klick zeigt es.

     3. Die Oberflaeche ruft eine Schnittstelle auf, die der Server
        nicht (mehr) hat.
        Das ist der gefaehrlichste Fall: Der Knopf ist da, er tut nur
        nichts. Genau so verschwindet eine Funktion still, wenn eine
        Route umbenannt wird.

   DIE ANZAHL GEHOERT IN DIE BEDINGUNG. Faende das Skript keine einzige
   Seite, waere "0 kaputte Verweise" das beste Ergebnis ueberhaupt --
   und voellig wertlos. Deshalb wird jede Menge gezaehlt und eine leere
   Menge ist ein Fehler.

   GEGENPROBE am Ende: ein absichtlich falscher Verweis MUSS gemeldet
   werden. Eine Pruefung, die immer bestaetigt, bestaetigt nichts. */

import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
import { join, dirname, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import { brotliCompressSync, constants } from "node:zlib";

const __dirname = dirname(fileURLToPath(import.meta.url));
const REPO = join(__dirname, "..");
const WS = join(REPO, "workspace");
const SERVER = __dirname;

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

/* ---------- Bestand einsammeln ------------------------------------------ */

/* ZWEI SEITEN SIND KEINE SEITEN FUER MENSCHEN.

   `buehne.html` und `tafel.html` sind Quellen fuer OBS und TikTok
   Studio: Sie laufen in einem Programmfenster, werden nie auf einem
   Telefon geoeffnet und nie installiert. Ein Symbol fuer den
   Startbildschirm, ein Manifest und eine Leistenfarbe waeren dort
   ohne Sinn.

   BENANNT UND MIT GRUND, nicht still: Eine Ausnahme ohne Namen ist
   die, die spaeter auch die naechste Seite verschluckt. */
const NUR_FUER_OBS = new Set(["buehne.html", "tafel.html"]);

const alleSeiten = readdirSync(WS).filter((n) => n.endsWith(".html"));
const seiten = alleSeiten.filter((n) => !NUR_FUER_OBS.has(n));
console.log(`\n=== Bestand ===`);
ok(seiten.length >= 10, `${seiten.length} Workspace-Seiten gefunden`);

const serverDateien = readdirSync(SERVER).filter((n) => /^workspace.*\.js$/.test(n));
ok(serverDateien.length >= 20, `${serverDateien.length} Server-Module gefunden`);

/* Alle Routen, die der Server wirklich anbietet. Gelesen wird der Code,
   nicht eine gepflegte Liste -- eine Liste altert, der Code nicht. */
const ROUTEN = [];
for (const datei of serverDateien) {
  const text = readFileSync(join(SERVER, datei), "utf8");
  /* AUCH ROUTEN IN ANFUEHRUNGSSTRICHEN UND BACKTICKS (23.09.2026).

     Hier stand nur das doppelte Anfuehrungszeichen. Wer eine Route in
     einer Schleife registriert, schreibt sie aber als Template:

       for (const weg of ["annehmen", "ablehnen"])
         router.post(`/workspace/api/vorlagen/bewerbung/${weg}`, ...)

     Diese Routen fehlten in der Liste -- und die Aufrufe dorthin
     wurden als "Schnittstelle gibt es nicht" gemeldet, obwohl sie
     jeden Tag laufen. Ein Fehlalarm, den man zweimal liest und dann
     nicht mehr; genau davor warnt der Kommentar weiter unten bei den
     sechs angeblich verwaisten Seiten.

     Die Erfassung der AUFRUFE kannte alle drei Zeichen schon
     (["'`]) -- nur die Erfassung der ROUTEN nicht. Zwei Regeln fuer
     dieselbe Frage, und eine davon war aelter. */
  const treffer = text.matchAll(
    /Router\.(get|post|patch|put|delete|use)\(\s*\n?\s*["'`](\/workspace\/[^"'`]*)/g);
  for (const t of treffer) ROUTEN.push({ art: t[1], pfad: t[2], datei });
}
ok(ROUTEN.length >= 80, `${ROUTEN.length} Server-Routen eingelesen`);

/** Ein Pfad aus der Oberflaeche gegen die Routenliste halten.
 *  Platzhalter (:id) und eingesetzte Werte (${...}) gelten als gleich.
 *
 *  WICHTIG — .use() zaehlt NICHT als Gegenstueck. Diese Eintraege sind
 *  Schranken ("jeder Pfad unter /workspace/api braucht eine Anmeldung"),
 *  keine Endpunkte. Sie mitzuzaehlen war der erste Entwurf, und die
 *  Gegenprobe hat ihn sofort ueberfuehrt: /workspace/api/gibtesnicht
 *  galt als vorhanden, weil aufgabenRouter.use("/workspace/api", …)
 *  darueber liegt. Damit haette diese ganze Pruefung nie einen einzigen
 *  toten Aufruf gefunden und trotzdem gruen gemeldet. */
function routeGibtEs(pfad, art) {
  const teileA = pfad.split("/").filter(Boolean);
  return ROUTEN.some((r) => {
    if (r.art === "use") return false;
    if (art && r.art !== art) return false;
    const teileB = r.pfad.split("/").filter(Boolean);
    if (teileA.length !== teileB.length) return false;
    /* ${...} IN EINER ROUTE IST EIN PLATZHALTER wie :id -- was dort
       eingesetzt wird, entscheidet die Schleife beim Start. Der
       Aufrufpfad ist oben schon zu "1" normalisiert worden; ohne diese
       Zeile verglichen wir "1" mit "${weg}" und faenden nie etwas. */
    return teileB.every((t, i) => t.startsWith(":") || t === "*"
      || t.includes("${") || t === teileA[i]);
  });
}

/* ---------- 1. Geladene Dateien ----------------------------------------- */

console.log(`\n=== Geladene Dateien (script/link/img) ===`);
let geprueftAssets = 0;
for (const seite of seiten) {
  const text = readFileSync(join(WS, seite), "utf8");
  const quellen = [
    ...text.matchAll(/<script[^>]+src="([^"]+)"/g),
    ...text.matchAll(/<link[^>]+href="([^"]+\.css[^"]*)"/g),
    ...text.matchAll(/<img[^>]+src="([^"]+)"/g),
  ].map((m) => m[1]);
  for (const roh of quellen) {
    if (/^(https?:|data:|\/\/)/.test(roh)) continue;
    const ohneStempel = roh.split("?")[0];
    const pfad = ohneStempel.startsWith("/")
      ? join(REPO, ohneStempel)
      : resolve(WS, ohneStempel);
    geprueftAssets++;
    if (!existsSync(pfad)) ok(false, `${seite}: Datei fehlt -> ${roh}`);
  }
}
ok(geprueftAssets > 0, `${geprueftAssets} geladene Dateien geprueft, alle vorhanden`);

/* ---------- 2. Verweise auf andere Seiten -------------------------------- */

console.log(`\n=== Verweise (href) ===`);
let geprueftLinks = 0;
const quellenMitLinks = [
  ...seiten.map((n) => ({ name: n, pfad: join(WS, n) })),
  ...readdirSync(join(WS, "assets", "js"))
    .filter((n) => n.endsWith(".js"))
    .map((n) => ({ name: "assets/js/" + n, pfad: join(WS, "assets", "js", n) })),
];
for (const { name, pfad: quelle } of quellenMitLinks) {
  const text = readFileSync(quelle, "utf8");
  /* Beide Schreibweisen: absolut (/workspace/aufgaben.html) und relativ
     ("aufgaben.html"). Der erste Entwurf suchte nur die absolute Form
     und meldete deshalb "0 Verweise geprueft" -- die Seiten verlinken
     aber fast ausschliesslich relativ. Eine Pruefung, die nichts
     findet, prueft nichts; deshalb steht die Anzahl unten in der
     Bedingung. */
  const ziele = [
    ...[...text.matchAll(/href\s*=\s*["'`](\/workspace\/[^"'`#?${]*)/g)].map((m) => m[1]),
    ...[...text.matchAll(/(?:location\.href|location\.assign\()\s*=?\s*["'`](\/workspace\/[^"'`#?${]*)/g)].map((m) => m[1]),
    ...[...text.matchAll(/href\s*=\s*["'`]([a-z0-9-]+\.html)/g)].map((m) => "/workspace/" + m[1]),
    ...[...text.matchAll(/(?:location\.href\s*=|location\.assign\()\s*["'`]([a-z0-9-]+\.html)/g)].map((m) => "/workspace/" + m[1]),
  ];
  for (const ziel of ziele) {
    if (ziel.startsWith("/workspace/api/")) continue;
    geprueftLinks++;
    const rel = ziel.replace(/^\/workspace\/?/, "");
    const datei = rel === "" ? "index.html" : rel;
    const voll = join(WS, datei);
    if (!existsSync(voll)) ok(false, `${name}: Verweis ins Leere -> ${ziel}`);
  }
}
ok(geprueftLinks > 0, `${geprueftLinks} Verweise geprueft, alle mit Ziel`);

/* ---------- 3. Aufgerufene Schnittstellen -------------------------------- */

console.log(`\n=== Aufgerufene Schnittstellen ===`);
let geprueftApi = 0;
let nurPraefix = 0;
const jsDateien = readdirSync(join(WS, "assets", "js")).filter((n) => n.endsWith(".js"));
for (const name of [...jsDateien.map((n) => "assets/js/" + n), ...seiten]) {
  const text = readFileSync(join(WS, name), "utf8");
  /* Jede Zeichenkette, die mit /workspace/api/ beginnt -- egal ob in
     fetch(), in einer Hilfsfunktion oder in einer Variablen. */
  for (const m of text.matchAll(/["'`](\/workspace\/api\/[^"'`\s]*)/g)) {
    const roh = m[1].replace(/\$\{[^}]*\}/g, "1").split("?")[0];
    if (!roh || roh === "/workspace/api" || roh === "/workspace/api/") continue;

    /* DER DRITTE AUSGANG. Endet die Zeichenkette auf "/", wurde im Code
       per + noch etwas angehaengt ('/workspace/api/ki/' + pfad). Was
       dort steht, weiss nur die Laufzeit -- statisch ist der volle Pfad
       NICHT zu ermitteln.

       Der erste Entwurf schnitt den Schraegstrich einfach weg und
       meldete vier Fehler, die keine waren. Genau davor warnt die
       eigene Regel: eine Pruefung, die ihre Voraussetzung nicht hat,
       muss das SAGEN und nicht raten. Geprueft wird deshalb nur, dass
       es unter diesem Praefix ueberhaupt Routen gibt -- die vollen
       Pfade deckt der Rundgang im Browser ab. */
    if (roh.endsWith("/")) {
      const praefix = roh.slice(0, -1);
      nurPraefix++;
      const gibtEsDarunter = ROUTEN.some(
        (r) => r.art !== "use" && r.pfad.startsWith(praefix + "/"));
      if (!gibtEsDarunter) {
        ok(false, `${name}: unter ${praefix}/ gibt es gar keine Schnittstelle`);
      }
      continue;
    }
    geprueftApi++;
    if (!routeGibtEs(roh)) ok(false, `${name}: Schnittstelle gibt es nicht -> ${roh}`);
  }
}
ok(geprueftApi >= 40, `${geprueftApi} vollstaendige Aufrufe geprueft, alle mit Gegenstueck`);
ok(nurPraefix > 0, `${nurPraefix} zusammengesetzte Aufrufe: nur Praefix pruefbar (Rest deckt der Browser-Rundgang)`);

/* ---------- 4. Jede Seite ist erreichbar --------------------------------- */

console.log(`\n=== Erreichbarkeit ===`);
/* WER AUF EINE SEITE ZEIGT, IST NICHT NUR EIN href (16.09.2026).

   Diese Zeile meldete sechs Seiten als "von nirgendwo verlinkt":
   crew-index, entwicklung, rechte, talente, teamlage und
   treff-moderation. Keine davon war verwaist -- man kommt auf jede,
   indem man eine KACHEL antippt. Die Kacheln stehen aber im Server
   (`ziel: "talente.html"`), und der wurde hier nie durchsucht.

   Eine Pruefung, die seit Wochen sechs Fehler meldet, die keine sind,
   ist schlimmer als keine: Man liest sie nicht mehr, und dann uebersieht
   man die siebte, die echt ist. Der blinde Fleck lag in der Pruefung,
   nicht im Haus.

   ABGELEITET, NICHT NACHGETRAGEN: Statt die sechs von Hand
   auszunehmen, kommen die Dateien dazu, in denen die Ziele wirklich
   stehen. Wer morgen eine Kachel anlegt, ist damit automatisch
   abgedeckt -- und wer eine Seite anlegt, auf die nichts zeigt, faellt
   weiterhin auf. */
const zeigerQuellen = [
  ...quellenMitLinks,
  /* Die Kachellisten -- dort steht `ziel: "talente.html"`. */
  { name: "server/workspace.js", pfad: join(SERVER, "workspace.js") },
  /* Die Zugangswaende -- crew-index.html wird dort ausgeliefert. */
  { name: "server/crew-adresse.js", pfad: join(SERVER, "crew-adresse.js") },
  /* EIN TEILEN-ZIEL IST EIN VERWEIS (17.09.2026).

     teilen.html stand hier als "von nirgendwo verlinkt" -- und das war
     falsch: Auf sie zeigt der Eintrag `share_target.action` im
     Manifest. Genau dafuer gibt es die Seite; einen Verweis im HTML
     hat sie absichtlich nicht, weil man sie nicht aufsucht, sondern
     von TikTok aus dort landet.

     Die Manifeste kommen deshalb als Quelle dazu -- nicht die eine
     Seite als Ausnahme. Eine Ausnahmeliste haette beim naechsten
     Teilen-Ziel wieder gefehlt. */
  ...["app.webmanifest", "crew.webmanifest"]
    .map((n) => ({ name: n, pfad: join(WS, n) }))
    .filter((q) => existsSync(q.pfad)),
];
const verlinkt = new Set(["index.html", "start.html"]);
for (const { pfad: quelle } of zeigerQuellen) {
  const text = readFileSync(quelle, "utf8");
  for (const m of text.matchAll(/["'`](?:\/workspace\/)?([a-z0-9-]+\.html)/g)) {
    verlinkt.add(m[1]);
  }
}
for (const seite of seiten) {
  if (!verlinkt.has(seite)) ok(false, `Seite ${seite} ist von nirgendwo verlinkt`);
}
ok(verlinkt.size >= seiten.length, `alle ${seiten.length} Seiten sind verlinkt`);

/* ---------- 5. Versionsstempel ------------------------------------------- */

/* Ohne Stempel haelt Cloudflare bis zu vier Stunden die alte Fassung --
   dann sieht niemand die Aenderung, und man sucht den Fehler im Code. */
console.log(`\n=== Versionsstempel an JS und CSS ===`);
let ohneStempel = [];
for (const seite of seiten) {
  const text = readFileSync(join(WS, seite), "utf8");
  for (const m of text.matchAll(/(?:src|href)="(\/workspace\/assets\/(?:js|css)\/[^"]+)"/g)) {
    if (!m[1].includes("?v=")) ohneStempel.push(`${seite}: ${m[1]}`);
  }
}
ok(ohneStempel.length === 0,
  ohneStempel.length ? `ohne Versionsstempel: ${ohneStempel.slice(0, 8).join(", ")}`
    : "jede JS- und CSS-Einbindung traegt einen Stempel");

/* ---------- 6. Reste aus der Entwicklung --------------------------------- */

console.log(`\n=== Produktionsreste ===`);
const resteMuster = [
  [/console\.log\(/g, "console.log"],
  [/\bdebugger\b/g, "debugger"],
  [/\bTODO\b|\bFIXME\b|\bHACK\b/g, "TODO/FIXME"],
  [/localhost:\d+/g, "localhost-Adresse"],
  [/Lorem ipsum/gi, "Platzhaltertext"],
];
let reste = [];
for (const name of [...jsDateien.map((n) => "assets/js/" + n), ...seiten]) {
  const text = readFileSync(join(WS, name), "utf8");
  /* Kommentare zaehlen nicht -- dort steht Begruendung, kein Code. */
  const ohneKommentar = text
    .replace(/\/\*[\s\S]*?\*\//g, "")
    .replace(/^\s*\/\/.*$/gm, "")
    .replace(/<!--[\s\S]*?-->/g, "");
  for (const [muster, was] of resteMuster) {
    const t = ohneKommentar.match(muster);
    if (t) reste.push(`${name}: ${was} (${t.length}x)`);
  }
}
ok(reste.length === 0, reste.length ? reste.join(" · ") : "keine Entwicklungsreste im Auslieferstand");

/* ---------- 7. Groesse der Assets ---------------------------------------- */

console.log(`\n=== Dateigroessen ===`);
/** Ist diese Text-Datei zu schwer? Gibt den Grund oder `null`.
 *
 *  ALS EIGENE FUNKTION, damit die Gegenprobe sie mit erfundenem Inhalt
 *  aufrufen kann. Eine Messung, die nur ueber die echten Dateien
 *  laeuft, ist genau so lange gruen, wie zufaellig keine zu gross ist
 *  -- und beweist nie, dass sie ueberhaupt anschlagen kann. */
function textZuSchwer(roh) {
  const gepackt = Math.round(brotliCompressSync(roh, {
    params: { [constants.BROTLI_PARAM_QUALITY]: 4 },
  }).length / 1024);
  if (gepackt > 200) return `${gepackt} KB uebertragen`;
  const ohneKommentar = Math.round(
    roh.toString("utf8").replace(/\/\*[\s\S]*?\*\//g, "").length / 1024);
  if (ohneKommentar > 200) return `${ohneKommentar} KB ohne Kommentare`;
  return null;
}

let schwer = [];
for (const unter of ["assets/js", "assets/css", "assets/img"]) {
  const ordner = join(WS, unter);
  if (!existsSync(ordner)) continue;
  for (const n of readdirSync(ordner)) {
    const p = join(ordner, n);
    if (statSync(p).isDirectory()) continue;
    const kb = Math.round(statSync(p).size / 1024);
    /* GESTUFTE BILDER DUERFEN GROESSER SEIN -- aber nur die (07.09.2026).

       Die Grenze von 200 KB soll verhindern, dass eine Seite unnoetig
       viel laedt. Bei einem Bild, das in mehreren Groessen vorliegt und
       von dem der Browser IMMER NUR EINE holt, misst sie das Falsche:
       Die 2400-px-Fassung einer Buehne wiegt 210 KB, wird aber nur auf
       einem Schirm angefordert, der sie auch braucht -- ein Handy laedt
       weiterhin 60 KB derselben Szene.

       Ohne diese Ausnahme haette ich die Wahl zwischen einer Pruefung,
       die bei jedem Lauf grundlos rot ist, und weichen Bildern auf
       grossen Schirmen. Beides waere falsch. Die Grenze fuer alles
       andere bleibt, wo sie war -- gerade weil sie fuer Skripte und
       Stile weiterhin gilt.

       ERKANNT AM NAMEN, nicht am Ordner: `-uhd` und `gate-2560` sagen
       ausdruecklich "das ist die grosse Stufe". Wer eine Datei so nennt,
       ohne dass es Stufen gibt, umgeht die Grenze -- deshalb prueft die
       Zeile darunter, dass es die kleineren Stufen auch wirklich gibt. */
    /* `-breit` GEHOERT DAZU (07.09.2026, Nachtrag am selben Tag).

       Die Ausnahme kannte nur die groesste Stufe. Dann wurden die Bilder
       nachgeschaerft -- und Schaerfe ist genau das, was Bytes kostet:
       Sie fuegt hohe Frequenzen hinzu, und die kann kein Verfahren
       wegrechnen. Die MITTLERE Stufe wuchs damit von rund 170 auf 230
       bis 300 KB und lief in eine Grenze, die fuer EINZELDATEIEN gedacht
       ist, nicht fuer eine von drei Stufen.

       Die Regel bleibt inhaltlich unveraendert: Eine Datei darf gross
       sein, WENN es nachweislich eine kleinere Stufe daneben gibt. Fuer
       `-breit` ist das `-schmal` (85 bis 130 KB) -- ein Handy holt
       weiterhin die kleine. Was wirklich zaehlt, misst ohnehin
       pruef-tempo-workspace an der fertigen Seite: Dort liegt die
       Grenze bei 1,2 MB, und start.html kommt auf 290 KB. */
    const gestuft = /-(uhd|breit)\.webp$|^gate-(1920|2560)\.webp$|^gate-hoch-900\.webp$/.test(n);
    if (gestuft) {
      /* JE STUFE GENAU EINE naechstkleinere -- nicht verkettet.
         `replace(uhd->breit).replace(breit->schmal)` haette bei einer
         uhd-Datei BEIDE Ersetzungen ausgefuehrt und am Ende nach
         "-schmal" gesucht. Das faellt nicht auf, solange alle drei
         Stufen da sind, und genau deshalb waere es ein stiller Fehler:
         Fehlte eines Tages `-breit`, meldete die Pruefung trotzdem
         "in Ordnung". */
      const kleiner = n.endsWith("-uhd.webp") ? n.replace("-uhd.webp", "-breit.webp")
        : n.endsWith("-breit.webp") ? n.replace("-breit.webp", "-schmal.webp")
        : n
        .replace(/^gate-(1920|2560)\.webp$/, "gate-1280.webp")
        .replace("gate-hoch-900.webp", "gate-hoch-440.webp");
      if (!existsSync(join(ordner, kleiner))) {
        schwer.push(`${unter}/${n} ${kb} KB (als Stufe ausgewiesen, aber ${kleiner} fehlt)`);
      }
      continue;
    }
    /* BEI TEXT MISST DIE ROHE GROESSE DAS FALSCHE (16.09.2026).

       Die Grenze soll verhindern, "dass eine Seite unnoetig viel
       laedt" -- so steht es oben. Fuer Bilder ist die Datei genau das,
       was geladen wird. Fuer CSS und JS nicht: Caddy komprimiert sie
       unterwegs. Nachgemessen auf der echten Seite am 16.09.:

         start.css   auf der Platte 346 KB   uebertragen 110 KB (br)
         chat.css                    59 KB                16 KB
         entwicklung.css             33 KB                 8 KB

       Die Pruefung meldete start.css mit 347 KB -- davon sind 227 KB
       KOMMENTAR (64 %). Sie bestrafte damit genau das, was dieses Haus
       absichtlich tut: jede Entscheidung danebenschreiben. Und sie
       haette eine Datei mit 199 KB dichtem, unkommentiertem CSS
       durchgewunken.

       Dasselbe Argument steht drei Absaetze weiter oben schon einmal,
       fuer die gestuften Bilder: "Bei einem Bild, das in mehreren
       Groessen vorliegt, misst sie das Falsche."

       JETZT ZWEI ZAHLEN, weil es zwei verschiedene Fragen sind:

         1. WAS DER BESUCHER LAEDT -- brotli, Stufe 4. Die Stufe ist
            nicht geraten: Bei 4 liefert node 111 KB, Caddy liefert
            110. Jede andere Stufe waere eine Zahl, die mit der
            Wirklichkeit nichts zu tun hat.
         2. WAS EIN MENSCH PFLEGEN MUSS -- die Datei ohne Kommentare.
            Sonst koennte man die erste Zahl klein halten, indem man
            immer mehr Prosa schreibt, und niemand merkt, dass das CSS
            selbst ausgeufert ist. */
    if (/\.(css|js)$/.test(n)) {
      const grund = textZuSchwer(readFileSync(p));
      if (grund) schwer.push(`${unter}/${n} ${grund}`);
      continue;
    }
    if (kb > 200) schwer.push(`${unter}/${n} ${kb} KB`);
  }
}
ok(schwer.length === 0, schwer.length ? `ueber 200 KB: ${schwer.join(", ")}` : "keine Datei ueber 200 KB");

/* GEGENPROBE ZUR GROESSENMESSUNG. Sie ist seit dem 16.09.2026 kein
   blosser Blick auf die Dateigroesse mehr, sondern packt den Inhalt
   zusammen -- und eine Messung, die niemand je hat anschlagen sehen,
   ist eine Behauptung. Drei Faelle, und jeder muss anders ausgehen. */
{
  /* 1. Viel echtes CSS, das sich nicht wegpacken laesst. */
  let dicht = "";
  for (let i = 0; i < 9000; i++) {
    dicht += `.k${i.toString(36)}-${(i * 7919).toString(36)} { color: #${
      (i * 2654435761 % 16777215).toString(16).padStart(6, "0")}; }\n`;
  }
  ok(textZuSchwer(Buffer.from(dicht)) !== null,
    `dichtes CSS von ${Math.round(dicht.length / 1024)} KB faellt durch `
    + `(${textZuSchwer(Buffer.from(dicht))})`);

  /* 2. Dieselbe Menge Text, aber als Prosa im Kommentar -- die packt
        sich auf ein Zehntel und darf durchgehen. Das ist der ganze
        Grund fuer die Umstellung. */
  const prosa = "/* " + "Jede Entscheidung gehoert danebengeschrieben. ".repeat(9000) + " */\n"
    + ".a { color: #fff; }\n";
  ok(textZuSchwer(Buffer.from(prosa)) === null,
    `${Math.round(prosa.length / 1024)} KB Kommentar gehen durch — sie kosten `
    + "den Besucher fast nichts");

  /* 3. UND DIE ZWEITE ZAHL MUSS AUCH ANSCHLAGEN: viel echtes CSS, das
        sich zwar gut packt (weil es sich wiederholt), aber trotzdem
        niemand mehr pflegen kann. Ohne diesen Fall koennte man die
        erste Grenze mit Wiederholung unterlaufen. */
  const wiederholt = ".gleich { color: #ffffff; padding: 4px; }\n".repeat(6000);
  ok(textZuSchwer(Buffer.from(wiederholt)) !== null,
    `${Math.round(wiederholt.length / 1024)} KB sich wiederholendes CSS faellt `
    + `ebenfalls durch (${textZuSchwer(Buffer.from(wiederholt))})`);
}

/* ---------- 8. Totes CSS ------------------------------------------------- */

/* start.css wird auf JEDER Seite geladen und ist 126 KB gross. Was darin
   niemand mehr benutzt, laedt trotzdem jeder mit.

   ZWEI BEKANNTE AUSNAHMEN, bewusst stehen gelassen: Beide stehen als
   Glied einer Selektorliste (".a, .b, .code-feld { … }") und kosten je
   rund fuenfzehn Byte. Sie zu entfernen braechte nichts und traegt das
   kleine Risiko, dass die Klasse doch irgendwo zur Laufzeit gesetzt
   wird. Sie stehen hier namentlich, damit NEUES totes CSS auffaellt --
   eine Pruefung, die von Anfang an rot ist, wird weggeklickt.

   DER DRITTE AUSGANG: Klassen, die zusammengesetzt werden koennen
   ('kachel--' + ton), zaehlen nicht als tot. Ihr Stamm wird gesucht;
   findet er sich, gilt die Klasse als moeglicherweise dynamisch und
   wird getrennt ausgewiesen statt geraten. */
console.log(`\n=== Totes CSS ===`);
const BEKANNT_TOT = [".content-wurzel", ".code-feld"];
{
  const cssOrdner = join(WS, "assets", "css");
  const jsOrdner = join(WS, "assets", "js");
  let quelle = "";
  /* HIER `alleSeiten` UND NICHT `seiten` (29.09.2026).

     `seiten` laesst `buehne.html` und `tafel.html` aus -- mit gutem
     Grund, aber fuer eine ANDERE Frage: Die beiden brauchen kein
     Startbildschirm-Symbol und kein Manifest. Beim Suchen nach totem
     CSS hat dieselbe Ausnahme eine falsche Antwort gegeben: Eine
     Klasse, die nur in einer OBS-Quelle steht, galt als unbenutzt.

     Aufgefallen an `.obs-buehne`, das genau dort steht. Der Wachter
     haette also verlangt, eine Regel zu loeschen, die den Stream
     traegt. Eine Ausnahme wirkt immer auf ALLES, was hinter ihr
     kommt -- nicht nur auf die Frage, fuer die sie gemacht wurde. */
  for (const n of alleSeiten) quelle += readFileSync(join(WS, n), "utf8");
  for (const n of readdirSync(jsOrdner).filter((x) => x.endsWith(".js"))) {
    quelle += readFileSync(join(jsOrdner, n), "utf8");
  }

  let gesamt = 0, dynamisch = 0;
  const tot = [];
  for (const datei of readdirSync(cssOrdner).filter((n) => n.endsWith(".css"))) {
    const text = readFileSync(join(cssOrdner, datei), "utf8").replace(/\/\*[\s\S]*?\*\//g, "");
    for (const k of new Set([...text.matchAll(/\.([a-zA-Z][a-zA-Z0-9_-]{2,})/g)].map((m) => m[1]))) {
      gesamt++;
      if (quelle.includes(k)) continue;
      const stamm = k.split(/--|__/)[0];
      if (stamm !== k && quelle.includes(stamm)) { dynamisch++; continue; }
      if (BEKANNT_TOT.includes("." + k)) continue;
      tot.push(`${datei}: .${k}`);
    }
  }
  ok(gesamt > 500, `${gesamt} CSS-Klassen geprueft (${dynamisch} moeglicherweise dynamisch gebaut)`);
  ok(tot.length === 0,
    tot.length ? `NEUES totes CSS: ${tot.slice(0, 8).join(" · ")}`
      : `kein neues totes CSS (${BEKANNT_TOT.length} bekannte Reste stehen bewusst)`);
}

/* ---------- 9. Kommt jedes Manifest auch WIRKLICH an? --------------------

   Ein Manifest kann fehlerfrei im Repo liegen und trotzdem nie beim
   Browser ankommen -- wenn eine Zugangswand davorsteht und HTML statt
   JSON zurueckgibt. Dann bietet der Browser "App installieren" gar
   nicht erst an, und niemand merkt etwas: Die Datei ist ja da.

   Genau das ist DREIMAL passiert (webdesign/app.webmanifest,
   verwaltung.webmanifest, portal.webmanifest). Zweimal stand die
   Begruendung danach im Code -- und beim dritten Mal wurde sie trotzdem
   uebersehen. Ein Kommentar verhindert nichts; eine Pruefung schon.

   Geprueft wird gegen die Ausnahmeliste in webdesign-gate.js: Jedes
   Manifest unter /webdesign/ MUSS dort stehen. */
console.log(`
=== Manifeste hinter der Zugangswand ===`);
{
  const tor = join(SERVER, "webdesign-gate.js");
  const torText = existsSync(tor) ? readFileSync(tor, "utf8") : "";
  ok(torText.length > 1000, "webdesign-gate.js gelesen");

  const manifeste = [];
  const suche = (ordner, vorn) => {
    for (const n of readdirSync(ordner, { withFileTypes: true })) {
      if (n.name.startsWith(".") || n.name === "node_modules") continue;
      const rel = vorn ? `${vorn}/${n.name}` : n.name;
      if (n.isDirectory()) { if (rel === "webdesign") suche(join(ordner, n.name), rel); continue; }
      if (n.name.endsWith(".webmanifest") || n.name === "manifest.json") manifeste.push(rel);
    }
  };
  suche(REPO, "");

  const hinterWand = manifeste.filter((m) => m.startsWith("webdesign/"));
  ok(hinterWand.length >= 2, `${hinterWand.length} Manifeste unter /webdesign/ gefunden`);

  const fehlend = hinterWand.filter((m) => !torText.includes(`"/${m}"`));
  ok(fehlend.length === 0,
    fehlend.length
      ? `NICHT in der Ausnahmeliste von webdesign-gate.js: ${fehlend.join(", ")} `
        + `— der Browser bekaeme HTML statt JSON und boete "App installieren" nicht an`
      : `alle ${hinterWand.length} stehen in der Ausnahmeliste`);
}

/* ---------- 10. Sind die Symbole fuer JEDES Geraet richtig gebaut? -------

   PC und Handy holen ihr Symbol an drei verschiedenen Stellen, und
   jede stellt andere Anforderungen:

     Browser-Reiter   das normale Symbol, darf runde Ecken haben
     Android          die maskable-Fassung, davon wird aussen bis zu
                      ein Fuenftel weggeschnitten
     iPhone           <link rel="apple-touch-icon"> -- und iOS rundet
                      SELBST ab und fuellt alles Durchsichtige mit
                      SCHWARZ

   Der letzte Punkt ist der, der auffiel ("auf dem einen klappt es und
   auf dem anderen nicht"): Ein apple-touch-icon mit eigener Rundung
   bekommt auf dem iPhone schwarze Zipfel. Auf dem PC sieht dieselbe
   Datei tadellos aus -- deshalb faellt es nur auf einem der beiden
   Geraete auf, und deshalb muss es gemessen werden statt angesehen.

   Geprueft werden die Dateinamen, nicht die Bilder selbst -- die
   Bildpruefung braucht einen Browser und laeuft in pruef-symbole.mjs.
   Hier geht es darum, dass ueberhaupt fuer jede App und jedes Geraet
   eine Datei da ist. */
console.log(`
=== Symbole fuer alle Geraete ===`);
{
  const symOrdner = join(REPO, "assets", "img", "app-symbole");
  if (!existsSync(symOrdner)) {
    ok(false, "der Ordner assets/img/app-symbole fehlt");
  } else {
    const da = readdirSync(symOrdner);
    const apps = [...new Set(da.map((n) => n.replace(/-(\d+)(-maskable)?\.png$/, "")))]
      .filter((n) => n.endsWith(".png") === false);
    ok(apps.length >= 8, `${apps.length} Apps mit eigenen Symbolen`);

    const noetig = ["192", "512", "192-maskable", "512-maskable", "180", "32"];
    const fehlend = [];
    for (const a of apps) {
      for (const g of noetig) {
        if (!da.includes(`${a}-${g}.png`)) fehlend.push(`${a}-${g}.png`);
      }
    }
    ok(fehlend.length === 0,
      fehlend.length ? `fehlende Symbole: ${fehlend.slice(0, 6).join(", ")}`
        : `alle ${apps.length * noetig.length} Symbole vorhanden `
          + `(Reiter, Android-maskable, iPhone)`);

    /* Jede Seite muss BEIDES nennen: das Reiter-Symbol und das fuers
       iPhone. Fehlt das zweite, nimmt iOS einen Bildschirmausschnitt
       der Seite -- unbrauchbar und unerkennbar. */
    let ohneApple = [];
    for (const seite of seiten) {
      const text = readFileSync(join(WS, seite), "utf8");
      if (!/rel="apple-touch-icon"/i.test(text)) ohneApple.push(seite);
    }
    ok(ohneApple.length === 0,
      ohneApple.length ? `ohne apple-touch-icon (iPhone nimmt sonst einen Screenshot): ${ohneApple.join(", ")}`
        : `alle ${seiten.length} Workspace-Seiten nennen ein iPhone-Symbol`);

    /* UND DAS MANIFEST (06.09.2026 nachgetragen).

       Gefunden, weil ich es selbst zweimal vergessen habe: chat.html und
       leistung.html -- die beiden neuesten Seiten -- hatten kein
       <link rel="manifest">. Folge auf dem Handy: Wer die Anwendung
       installiert hat und ueber eine Benachrichtigung auf einer dieser
       Seiten landet, verlaesst damit den App-Rahmen. Die Seite oeffnet
       in der Adressleiste des Browsers statt in der App, mit falscher
       Leistenfarbe und ohne Zurueckweg in den Rest.

       Es faellt niemandem auf, weil am Rechner alles normal aussieht.
       Genau darum steht es jetzt hier: Was man beim Anlegen einer neuen
       Seite vergessen kann, muss eine Pruefung nachhalten -- nicht das
       Gedaechtnis. Und weil `seiten` aus dem Verzeichnis kommt, ist die
       naechste neue Seite von selbst dabei.

       theme-color gehoert dazu: Ohne sie zeichnet Android die
       Systemleiste weiss -- ein greller Balken ueber einer dunklen
       Oberflaeche, das Gegenteil von augenschonend. */
    const ohneManifest = [];
    const ohneFarbe = [];
    for (const seite of seiten) {
      const text = readFileSync(join(WS, seite), "utf8");
      if (!/rel="manifest"/i.test(text)) ohneManifest.push(seite);
      if (!/name="theme-color"/i.test(text)) ohneFarbe.push(seite);
    }
    ok(seiten.length > 10 && ohneManifest.length === 0,
      ohneManifest.length
        ? `ohne <link rel="manifest"> — oeffnet auf dem Handy ausserhalb der App: ${ohneManifest.join(", ")}`
        : `alle ${seiten.length} Seiten binden das Manifest ein`);
    ok(seiten.length > 10 && ohneFarbe.length === 0,
      ohneFarbe.length
        ? `ohne theme-color — Android zeichnet die Leiste dann weiss: ${ohneFarbe.join(", ")}`
        : `alle ${seiten.length} Seiten setzen eine theme-color`);
  }
}

/* ---------- 11. Laesst sich jedes Server-Modul ueberhaupt laden? --------

   `node --check datei.js` prueft eine .js-Datei als CommonJS. Dieses
   Haus faehrt aber ESM ("type": "module" in package.json). Der
   Unterschied ist keine Formsache: Ein Syntaxfehler kann dabei
   durchrutschen und die Datei trotzdem beim Start abstuerzen lassen.

   Genau das ist am 05.09.2026 passiert. In einem SQL-Block -- einem
   Template-Literal mit Backticks -- stand in einem KOMMENTAR ein Wort
   in Backticks. Das beendete das Literal mitten im Text. `node --check`
   meldete "Syntax ok", der Import scheiterte mit "missing ) after
   argument list", und der Server waere beim naechsten Start gar nicht
   hochgekommen.

   Deshalb wird hier jedes Modul WIRKLICH geladen. Das ist die einzige
   Pruefung, die dieselbe Frage stellt wie der Serverstart. */
console.log(`\n=== Laedt jedes Server-Modul? ===`);
{
  /* GEPRUEFT WIRD MIT NODE SELBST, nicht mit einem Suchmuster.

     Der erste Entwurf suchte per regulaerem Ausdruck nach Backticks in
     SQL-Bloecken -- und schlug bei drei Bloecken an, die voellig in
     Ordnung sind: Enthaelt ein Block ein ${...}, grenzt das Muster ihn
     falsch ab. Eine Warnung, die falsch ist, ist schlimmer als keine;
     sie kostet beim naechsten Mal zehn Minuten und wird danach
     ignoriert.

     Node kann die Frage selbst beantworten. Die Datei wird als .mjs
     kopiert und mit `node --check` geprueft -- damit gilt dieselbe
     Regel wie beim Start (ESM statt CommonJS). Genau darin lag der
     Fehler vom 05.09.2026: `node --check datei.js` meldete "ok",
     der Import scheiterte trotzdem. */
  const { execFileSync } = await import("node:child_process");
  const { writeFileSync, unlinkSync, mkdtempSync } = await import("node:fs");
  const { tmpdir } = await import("node:os");

  const module = readdirSync(SERVER).filter((n) => n.endsWith(".js"));
  ok(module.length >= 20, `${module.length} Server-Module gefunden`);

  const ordner = mkdtempSync(join(tmpdir(), "modulcheck-"));
  const kaputt = [];
  for (const datei of module) {
    const kopie = join(ordner, datei.replace(/\.js$/, ".mjs"));
    writeFileSync(kopie, readFileSync(join(SERVER, datei), "utf8"));
    try {
      execFileSync(process.execPath, ["--check", kopie], { stdio: "pipe" });
    } catch (f) {
      const meldung = String(f.stderr || f.message).split(/\r?\n/)
        .find((z) => z.includes("Error")) || "Syntaxfehler";
      kaputt.push(`${datei}: ${meldung.trim().slice(0, 70)}`);
    }
    try { unlinkSync(kopie); } catch { /* egal */ }
  }
  ok(kaputt.length === 0,
    kaputt.length
      ? `als ESM NICHT ladbar: ${kaputt.slice(0, 5).join(" · ")}`
      : `alle ${module.length} Module lassen sich als ESM einlesen`);

  /* GEGENPROBE mit genau dem Fehler von heute.

     Nachgebaut wird der echte Fall: ein Backtick in einem KOMMENTAR,
     der innerhalb eines Template-Literals steht. Sieht harmlos aus,
     beendet aber die Zeichenkette. */
  const boese = join(ordner, "gegenprobe.mjs");
  writeFileSync(boese, [
    "const d = { exec: () => {} };",
    "d.exec(`",
    "  CREATE TABLE x (a TEXT);",
    "  /* Der Wert `endpunkt` ist der Schluessel. */",
    "`);",
  ].join("\n"));
  let erkannt = false;
  try { execFileSync(process.execPath, ["--check", boese], { stdio: "pipe" }); }
  catch { erkannt = true; }
  ok(erkannt, erkannt
    ? "Gegenprobe: ein Backtick im SQL-Kommentar wird als Fehler erkannt"
    : "Gegenprobe MISSLUNGEN — die Pruefung wuerde den Fehler durchlassen");

  /* Und der Beweis, dass sie nicht einfach alles ablehnt. */
  const brav = join(ordner, "gegenprobe-ok.mjs");
  writeFileSync(brav, "export const x = `alles gut ${1 + 1}`;\n");
  let bravOk = true;
  try { execFileSync(process.execPath, ["--check", brav], { stdio: "pipe" }); }
  catch { bravOk = false; }
  ok(bravOk, "Gegenprobe: eine saubere Datei wird durchgelassen");

  for (const f of [boese, brav]) { try { unlinkSync(f); } catch { /* egal */ } }
}

/* ---------- Rechnet jede Pruefung den TAG so wie die Anwendung? --------

   GEFUNDEN AM 06.09.2026 UM 00:10, und zwar auf die harte Tour: Der
   Gesamtlauf meldete 13 Fehlschlaege in pruef-teilnehmer.mjs -- an
   einer Datei, die seit Stunden niemand angefasst hatte.

       Ortszeit (MESZ):  06.09.2026, 00:10
       UTC:              05.09.2026, 22:10

   Die Pruefung bildete ihr Datum mit `toISOString().slice(0, 10)` --
   das ist UTC. Sie legte ihre Termine also auf gestern und fand heute
   nichts. ZWEI STUNDEN AM TAG war sie damit rot (im Winter eine).

   Wer nur tagsueber laeuft, sieht das nie. Wer nachts arbeitet, sucht
   stundenlang am falschen Ende -- die Meldungen sagen "der Termin ist
   weg", nicht "dein Datum ist falsch".

   Deshalb wird es hier gesucht, statt darauf zu warten, dass es wieder
   jemanden trifft. Gemeint ist nur das TAGESDATUM; ein Zeitstempel
   (`erstellt`) darf und soll UTC sein. */
console.log(`\n=== Ruft ein Modul etwas, das es nie eingefuehrt hat? ===`);
/* ===================================================================
   AM 01.10.2026 SELBST GEBAUT UND FAST AUSGELIEFERT.

   Ein Werkzeug von mir hat in elf Modulen `heuteLokal()` eingesetzt
   und die Einfuhr weggelassen. `node --check` sagt dazu nichts, und
   „Laedt jedes Server-Modul?" ein Stueck weiter oben auch nicht: Die
   Datei ist syntaktisch tadellos. Erst der AUFRUF faellt um:

       ReferenceError: heuteLokal is not defined

   Gefunden hat es pruef-video -- zufaellig, weil dort genau diese
   Zeile geprueft wird. Die anderen zehn Module waeren durchgerutscht,
   und bei einer Zeile, die nur nachts laeuft, faellt das erst Wochen
   spaeter jemandem auf.

   DAS IST EINE DRITTE SORTE FEHLER an dieser Stelle: nicht „die Datei
   ist kaputt" und nicht „die Datei tut das Falsche", sondern „die
   Datei faellt erst um, wenn jemand genau diese Zeile braucht".

   ABGELEITET, NICHT AUFGEZAEHLT: Die Namen des Hauses kommen aus den
   `export`-Zeilen von workspace.js und der helfer-Module. Eine
   gepflegte Liste waere hier genau die, die beim naechsten Export
   nicht mitwaechst -- derselbe Fehler, an dem dieses Haus schon
   viermal haengengeblieben ist.
   =================================================================== */
{
  /** Kommentare und Zeichenketten weg, Zeilen behalten. Sonst zaehlt
   *  ein Name in einem SQL-Text oder in einer Begruendung als Aufruf. */
  const nurCode = (text) => text
    .replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "))
    .replace(/^\s*\/\/.*$/gm, "")
    .replace(/`(?:[^`\\]|\\.)*`/g, (m) => m.replace(/[^\n]/g, " "))
    .replace(/"(?:[^"\\\n]|\\.)*"/g, "\"\"")
    .replace(/'(?:[^'\\\n]|\\.)*'/g, "''");

  /** Was eine Datei nach aussen gibt -- aus ihren eigenen Zeilen. */
  const exporte = (text) => {
    const raus = new Set();
    for (const t of text.matchAll(
      /^export\s+(?:async\s+)?(?:function|const|let|class)\s+(\w+)/gm)) raus.add(t[1]);
    return raus;
  };

  const quellen = ["workspace.js", "helfer-zeit.mjs", "helfer-tag.mjs"];
  const hausNamen = new Map();          // Name -> woher
  for (const q of quellen) {
    for (const n of exporte(readFileSync(join(SERVER, q), "utf8"))) hausNamen.set(n, q);
  }
  ok(hausNamen.size >= 30,
    `${hausNamen.size} ausgeleitete Namen aus ${quellen.length} Quellen gelesen`);

  /** Welche Namen kennt diese Datei? Eingefuehrte, selbst erklaerte
   *  und aus einer Zerlegung entnommene -- alles, was nicht zu einem
   *  ReferenceError fuehren kann. */
  const bekannt = (code) => {
    const kennt = new Set();
    for (const t of code.matchAll(/import\s*\{([^}]*)\}\s*from/g)) {
      for (const stueck of t[1].split(",")) {
        const n = stueck.trim().split(/\s+as\s+/).pop().trim();
        if (n) kennt.add(n);
      }
    }
    for (const t of code.matchAll(/(?:const|let|var)\s*\{([^}]*)\}\s*=/g)) {
      for (const stueck of t[1].split(",")) {
        const n = stueck.trim().split(":").pop().trim();
        if (n) kennt.add(n);
      }
    }
    for (const t of code.matchAll(
      /(?:^|\s)(?:const|let|var|function|class)\s+(\w+)/g)) kennt.add(t[1]);
    for (const t of code.matchAll(/import\s+(\w+)\s+from/g)) kennt.add(t[1]);
    return kennt;
  };

  const dateien = readdirSync(SERVER)
    .filter((n) => (n.endsWith(".js") || n.endsWith(".mjs")) && !quellen.includes(n));
  const fehlt = [];
  let gesucht = 0;
  for (const datei of dateien) {
    if (datei === "pruef-struktur.mjs") continue;     /* siehe Gegenprobe */
    const code = nurCode(readFileSync(join(SERVER, datei), "utf8"));
    const kennt = bekannt(code);
    for (const [name, woher] of hausNamen) {
      /* Nur ein AUFRUF zaehlt. Ein Name in einer Eigenschaft
         (`x.heuteLokal`) ist etwas anderes und gehoert nicht hierher. */
      const ruft = new RegExp(`(^|[^\\w.])${name}\\s*\\(`, "m").test(code);
      if (!ruft) continue;
      gesucht++;
      if (!kennt.has(name)) fehlt.push(`${datei}: ${name}() (aus ${woher})`);
    }
  }
  ok(gesucht > 50, `${gesucht} Aufrufe von Hausnamen in ${dateien.length} Dateien angesehen`);
  ok(fehlt.length === 0,
    fehlt.length
      ? `rufen etwas, das sie nicht eingefuehrt haben — das faellt erst beim`
        + ` Aufruf um, nicht beim Laden:\n         ` + fehlt.slice(0, 12).join("\n         ")
      : "jeder Aufruf eines Hausnamens hat auch seine Einfuhr");

  /* ---- GEGENPROBEN --------------------------------------------------
     Die Zeile darueber meldet „in Ordnung", solange sie nichts findet.
     Heute Nacht haette sie elf Dateien gefunden -- also einmal zeigen,
     dass sie das auch kann. */
  {
    const probeFehlt = (code, name) => {
      const c = nurCode(code);
      const ruft = new RegExp(`(^|[^\\w.])${name}\\s*\\(`, "m").test(c);
      return ruft && !bekannt(c).has(name);
    };
    ok(probeFehlt('const t = heuteLokal();', "heuteLokal"),
      "Gegenprobe: ein Aufruf ohne Einfuhr faellt auf");
    ok(!probeFehlt('import { heuteLokal } from "./workspace.js";\nconst t = heuteLokal();',
      "heuteLokal"), "  mit Einfuhr NICHT");
    ok(!probeFehlt('const { heuteLokal } = await import("./workspace.js");\n'
      + 'const t = heuteLokal();', "heuteLokal"), "  und ueber eine Zerlegung auch nicht");
    ok(!probeFehlt('function heuteLokal() { return 1; }\nconst t = heuteLokal();',
      "heuteLokal"), "  wer ihn selbst erklaert, ebenfalls nicht");
    ok(!probeFehlt('/* heuteLokal() waere hier falsch */\nconst t = 1;', "heuteLokal"),
      "  und ein Name im Kommentar ist kein Aufruf");
    ok(!probeFehlt('const t = uhr.heuteLokal();', "heuteLokal"),
      "  eine Eigenschaft an einem Objekt auch nicht");
  }
}

console.log(`\n=== Wird der TAG in Ortszeit gebildet -- ueberall? ===`);
/* ===================================================================
   AM 01.10.2026 UM 01:22 GEWACHSEN, weil diese Wache versagt hatte.

   Sie sah seit dem 06.09. nur in die `pruef-*.mjs`. In der ANWENDUNG
   standen zur selben Zeit SECHZEHN Stellen, die einen Kalendertag aus
   UTC bilden -- zehn davon schrieben ihn in die Datenbank.

   Aufgefallen ist es nicht hier, sondern in pruef-kreislauf: Ein
   Wunsch mit dem heutigen Datum wurde zu einem Termin, und der trug
   `2026-09-30` statt `2026-10-01`. Auf dem Brett „Was ansteht" landete
   er damit unter „Vorbei" -- einem Abschnitt, der von sich aus
   zugeklappt ist. Der Termin war da und war nicht zu sehen.

   Eine Sicherung, die nur die halbe Menge kennt, faellt in der
   anderen Haelfte aus -- lautlos, denn sie meldet ja „nichts
   gefunden". Deshalb sieht sie jetzt in BEIDES: in die Anwendung und
   in die Pruefungen.
   =================================================================== */
{
  const pruefungen = readdirSync(SERVER)
    .filter((n) => (n.startsWith("pruef-") || n.startsWith("mess-")) && n.endsWith(".mjs"));
  /* DIE ANWENDUNG -- abgeleitet, nicht aufgezaehlt: alles, was der
     Dienst laedt, liegt als `.js` im Serverordner. Eine Liste von
     Dateinamen waere die naechste, die beim uebernaechsten Modul
     nicht mitwaechst. */
  const anwendung = readdirSync(SERVER).filter((n) => n.endsWith(".js"));
  const dateien = [...anwendung, ...pruefungen];
  ok(anwendung.length >= 30 && pruefungen.length >= 30,
    `${anwendung.length} Dateien der Anwendung und ${pruefungen.length} Pruef-/Messdateien durchgesehen`);

  /* EINE UHRZEIT IM AUSDRUCK HEISST: DER TAG STEHT SCHON FEST.
     `Date.parse(tag + "T12:00:00Z") + n * 86400000` bleibt in jeder
     Zeitzone am selben Kalendertag -- das ist der dokumentierte Weg
     des Hauses (workspace-kalender, workspace-teamlage,
     workspace-serien). Erkannt wird das am Ausdruck selbst; eine
     Liste erlaubter Ausnahmen braucht es dadurch nicht, und eine
     Liste, die niemand pflegt, waere die naechste Stelle, an der es
     auseinanderlaeuft. */
  const festeUhrzeit = /T\d{2}:\d{2}:\d{2}Z/;

  /** Alle Stellen einer Datei, an denen aus einem ZEITPUNKT ein
   *  Kalendertag wird. Gibt Zeilennummern zurueck. */
  function utcTage(text) {
    const treffer = [];
    const zeile = (i) => text.slice(0, i).split("\n").length;

    /* (1) Direkt: new Date(...).toISOString().slice(0, 10) */
    for (const t of text.matchAll(
      /new Date\(([^;]*?)\)\s*\.\s*toISOString\(\)\s*\.\s*slice\(\s*0\s*,\s*10\s*\)/g)) {
      if (festeUhrzeit.test(t[1])) continue;
      treffer.push(zeile(t.index));
    }

    /* (2) Ueber einen NAMEN. Zuerst sammeln, welche Namen einen
       UTC-Zeitstempel liefern -- als Funktion ODER als Wert. Genau
       diese Schreibweise fehlte bis heute:

           const jetzt = () => new Date().toISOString();
           ... jetzt().slice(0, 10) ...

       Und in zwei Schritten kommt sie auch vor:

           const jetztIso = jetzt();
           ... jetztIso.slice(0, 10) ... */
    const utcNamen = new Set();
    for (const t of text.matchAll(
      /(?:const|let)\s+(\w+)\s*=\s*(?:\(\)\s*=>\s*)?new Date\(\)\.toISOString\(\)/g)) {
      utcNamen.add(t[1]);
    }
    for (let runde = 0; runde < 2; runde++) {
      for (const t of text.matchAll(/(?:const|let)\s+(\w+)\s*=\s*(\w+)\(\)\s*;/g)) {
        if (utcNamen.has(t[2])) utcNamen.add(t[1]);
      }
    }
    for (const t of text.matchAll(/(\w+)(\(\))?\s*\.\s*slice\(\s*0\s*,\s*10\s*\)/g)) {
      if (utcNamen.has(t[1])) treffer.push(zeile(t.index));
    }
    return treffer;
  }

  const verdaechtig = [];
  for (const datei of dateien) {
    /* Die eigene Datei bleibt aussen vor: Die Gegenproben unten
       MUESSEN das gesuchte Muster als Text enthalten, sonst koennten
       sie nicht beweisen, dass sie es erkennen. Sie wuerde sich sonst
       selbst anzeigen -- eine Warnung, die immer kommt. */
    if (datei === "pruef-struktur.mjs") continue;
    /* KOMMENTARE RAUS, ZEILEN BEHALTEN (16.09.2026).

       Hier stand `replace(…, " ")` -- ein Blockkommentar ueber zwanzig
       Zeilen wurde also zu einem Leerzeichen, und ab da zaehlte
       `split("\n").length` falsch. Gemeldet wurden Zeilennummern, die
       auf voellig anderen Code zeigten. Jetzt bleibt je Zeile eine
       Zeile stehen. */
    const text = readFileSync(join(SERVER, datei), "utf8")
      .replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "))
      .replace(/^\s*\/\/.*$/gm, "");
    for (const z of utcTage(text)) verdaechtig.push(`${datei}:${z}`);
  }

  ok(verdaechtig.length === 0,
    verdaechtig.length
      ? `bilden ihr Tagesdatum aus UTC statt Ortszeit — nachts zwischen `
        + `00:00 und 02:00 liegt es einen Tag zurueck:\n         `
        + verdaechtig.join("\n         ")
      : `keine der ${dateien.length} Dateien bildet einen Kalendertag aus UTC`);

  /* ---- GEGENPROBEN -------------------------------------------------
     Eine Erkennung, die nichts findet, sieht genauso aus wie eine, die
     nichts finden KANN. Heute Nacht war sie genau das: Die Schreibweise
     mit einer Funktion kannte sie nicht, und die Anwendung sah sie gar
     nicht an. Beides steht jetzt hier als Probe. */
  const probe = (code) => utcTage(code).length;
  ok(probe('const h = new Date().toISOString().slice(0, 10);') === 1,
    "Gegenprobe: die direkte Schreibweise faellt auf");
  ok(probe('const jetzt = () => new Date().toISOString();\nconst h = jetzt().slice(0, 10);') === 1,
    "  die ueber eine FUNKTION ebenfalls — genau die, die heute Nacht durchrutschte");
  ok(probe('const jetzt = new Date().toISOString();\nconst h = jetzt.slice(0, 10);') === 1,
    "  und die ueber eine Variable");
  ok(probe('const jetzt = () => new Date().toISOString();\n'
    + 'const iso = jetzt();\nconst h = iso.slice(0, 10);') === 1,
    "  auch ueber zwei Schritte");
  ok(probe('const g = new Date(Date.now() - 30 * 86400000).toISOString().slice(0, 10);') === 1,
    "  und eine Rechnung auf Date.now()");

  ok(probe('const jetzt = new Date().toISOString();') === 0,
    "Gegenprobe: ein voller Zeitstempel ohne Schnitt schlaegt NICHT an");
  ok(probe('const b = new Date(Date.parse(tag + "T12:00:00Z") + n * 86400000)'
    + '.toISOString().slice(0, 10);') === 0,
    "  und die Rechnung auf UTC-Mittag ebenfalls nicht — die ist richtig so");
  ok(probe('const alsText = (d) => d.toISOString().slice(0, 10);') === 0,
    "  und ein Date, das von aussen kommt, auch nicht");
}

/* =======================================================================
   WIRD DAS PROTOKOLL RICHTIG HERUM GERUFEN?

   `protokolliere(aktion, { personId, rolle, detail, ip })` -- die
   Aktion zuerst, alles Weitere benannt.

   Aufgerufen wurde es an 17 Stellen andersherum:
   `protokolliere(req.person.id, "aktion", detail, ip)`. JavaScript
   beschwert sich darueber NICHT. Das zweite Argument ist ein Text,
   und einen Text zu zerlegen ergibt lauter `undefined`. Der Eintrag
   entsteht also -- nur steht die Personen-Kennung im Feld `aktion`,
   und Person, Detail und IP sind leer.

   AUF DEM ECHTEN SERVER NACHGEMESSEN: 39 Zeilen mit Aktionen wie
   „16.0" und „4.0". Betroffen war unter anderem jede Aenderung an
   Dogi-Media und jede Massnahme im Live-Chat -- also ausgerechnet
   das, wofuer es ein Protokoll gibt.

   Ein Kommentar haette das nicht verhindert (11.09.2026: „Ein
   Kommentar, der vor einem Fehler warnt, verhindert ihn nicht").
   Eine Pruefung schon.
   ======================================================================= */
console.log(`\n=== Wird das Protokoll richtig herum gerufen? ===`);
{
  /* Das erste Argument muss etwas sein, das eine Aktion SEIN KANN:
     eine Zeichenkette oder ein Ausdruck, der eine liefert (`a ? "x" :
     "y"`). Was es nicht sein darf, ist eine Kennung -- und die
     erkennt man daran, dass sie auf `.id` endet oder schlicht
     `personId` heisst. */
  const schlecht = [];
  let gesehen = 0;
  for (const datei of readdirSync(SERVER).filter((n) => n.endsWith(".js"))) {
    const text = readFileSync(join(SERVER, datei), "utf8");
    for (const m of text.matchAll(/\bprotokolliere\(\s*([^,)]{1,60})/g)) {
      const erstes = m[1].trim();
      if (erstes.startsWith("aktion")) continue;   // die Erklaerung selbst
      gesehen++;
      if (/\.id\s*$/.test(erstes) || /^personId$/.test(erstes)
          || /^\d/.test(erstes)) {
        const zeile = text.slice(0, m.index).split("\n").length;
        schlecht.push(`${datei}:${zeile} -> ${erstes}`);
      }
    }
  }
  ok(gesehen > 60, `${gesehen} Protokollaufrufe im Haus gefunden`);
  ok(schlecht.length === 0,
    schlecht.length
      ? `FALSCH HERUM: ${schlecht.slice(0, 6).join(" | ")}`
      : "alle rufen die Aktion zuerst");

  /* GEGENPROBE: Kann die Pruefung „nein" sagen? Ohne sie waere sie
     eine, die immer bestaetigt -- und die bestaetigt nichts. */
  const probe = 'protokolliere(req.person.id, "test", "x");';
  const trifft = [...probe.matchAll(/\bprotokolliere\(\s*([^,)]{1,60})/g)]
    .some((m) => /\.id\s*$/.test(m[1].trim()));
  ok(trifft, "Gegenprobe: ein falsch herum gebauter Aufruf wird erkannt");
  const gut = 'protokolliere("test", { personId: req.person.id });';
  const trifftNicht = [...gut.matchAll(/\bprotokolliere\(\s*([^,)]{1,60})/g)]
    .some((m) => /\.id\s*$/.test(m[1].trim()));
  ok(!trifftNicht, "Gegenprobe: ein richtiger Aufruf schlaegt nicht an");
}

/* ---------- Gegenprobe --------------------------------------------------- */

console.log(`\n=== Gegenprobe (muss anschlagen) ===`);
ok(!routeGibtEs("/workspace/api/gibtesnicht"),
  "erfundene Schnittstelle wird als fehlend erkannt");
ok(routeGibtEs("/workspace/api/aufgaben"),
  "vorhandene Schnittstelle wird als vorhanden erkannt");
ok(!existsSync(join(WS, "gibtesnicht.html")),
  "erfundene Seite wird als fehlend erkannt");

/* =====================================================================
   RUFT JEMAND `openssl` WIEDER DIREKT AUF?

   WAS HIER SCHIEFGING (29.09.2026 gemessen): Im naechtlichen Lauf
   standen DREIZEHN Pruefungen mit derselben Zeile rot --

       [uncaughtException] Error: spawnSync openssl ENOENT

   Kein Programmfehler. Die Pruefungen brauchen einen https-Vorbau
   (der Sitzungskeks ist `secure`), und dafuer erzeugen sie ein
   Wegwerf-Zertifikat. Auf diesem Rechner liegt openssl in
   `Git\\mingw64\\bin`; im System-PATH steht aber nur `Git\\cmd`. Wer
   aus Git Bash startet, erbt die mingw-Pfade und merkt nie etwas --
   die Aufgabenplanung startet `node.exe` direkt und bekommt sie
   nicht.

   Bei mir gruen, nachts rot, und der Grund steht nicht im Code. Die
   dreizehn roten Zeilen haben dabei monatelang die echten Befunde
   zugedeckt.

   `helfer-openssl.mjs` sucht das Programm jetzt auch ausserhalb des
   PATH. Diese Wache sorgt dafuer, dass der direkte Aufruf nicht
   zurueckkommt -- der naechste, der ihn schreibt, merkt es hier und
   nicht erst in einem Nachtlauf, den niemand liest. */
console.log(`\n=== Ruft noch jemand openssl direkt auf? ===`);
{
  const direkt = [];
  let ueberHelfer = 0;
  for (const datei of readdirSync(SERVER).filter((n) => /\.(mjs|js)$/.test(n))) {
    if (datei === "helfer-openssl.mjs") continue;
    const text = readFileSync(join(SERVER, datei), "utf8");
    for (const m of text.matchAll(/exec(?:File)?Sync\(\s*["'`]openssl/g)) {
      direkt.push(`${datei}:${text.slice(0, m.index).split("\n").length}`);
    }
    if (/zertifikatBauen\(/.test(text)) ueberHelfer++;
  }
  ok(ueberHelfer > 20,
    `${ueberHelfer} Dateien bauen ihr Zertifikat ueber den Helfer`);
  ok(direkt.length === 0,
    direkt.length
      ? `DIREKT: ${direkt.slice(0, 6).join(" | ")} -- bitte zertifikatBauen() aus `
        + "helfer-openssl.mjs nehmen, sonst faellt es im Nachtlauf um"
      : "keine Datei ruft openssl mehr am PATH vorbei");

  /* GEGENPROBE IN BEIDE RICHTUNGEN. Eine Wache, die nur „nichts
     gefunden" sagen kann, hat nichts bewiesen.

     DIE PROBETEXTE WERDEN ZUSAMMENGESETZT und stehen nicht am Stueck
     da. Beim ersten Anlauf schlug diese Wache auf ihre EIGENEN
     Gegenproben an: Sie liest den Quelltext aller Serverdateien,
     und dazu gehoert diese hier. Dasselbe ist mir heute schon
     zweimal passiert -- eine Pruefung, die ihre eigene Begruendung
     als Fund meldet, ist der haeufigste Selbsttreffer im Haus. */
  const findet = (t) => [...t.matchAll(/exec(?:File)?Sync\(\s*["'`]openssl/g)].length;
  const O = "openssl";
  ok(findet(`execFileSync("${O}", ["version"]);`) === 1,
    "Gegenprobe: ein direkter Aufruf wird erkannt");
  ok(findet(`execSync(\`${O} version\`);`) === 1,
    "auch mit Schraegstrich-Anfuehrung");
  ok(findet("zertifikatBauen(k, z, CREW);") === 0,
    "und der Weg ueber den Helfer gilt nicht als Fund");
}

console.log(`\n${fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`}`);
process.exit(fehler ? 1 : 0);