dogfather-universe/server/pruef-kachelraster.mjs

/* =====================================================================
   DAS KACHELRASTER HAT KEIN LOCH (17.09.2026)

   Filipe, mit einem Bildschirmfoto der Community: "das wie es jetzt
   ist ist es einfach total scheisse ... gerade einfach nur dahin
   geknallt und drauf geschissen".

   Er hatte recht, und die Ursache war eine Zeile Reihenfolge. Das
   Raster hat DREI Spalten, "Das Rudel" ist doppelt breit -- stand aber
   an DRITTER Stelle. Nach zwei normalen Kacheln war noch EINE Spalte
   frei, er passte nicht und rutschte eine Reihe tiefer. Zurueck blieb
   eine Luecke mitten im Raster.

   ---------------------------------------------------------------------
   WIE MAN EIN LOCH MISST, OHNE ES ANZUSEHEN

   Nicht ueber Pixel und nicht ueber "sieht schief aus". Ueber eine
   Rechnung, die immer stimmt:

     Belegte Zellen = Anzahl Kacheln + 1 je doppelt breiter Kachel
     Kleinstmoegliche Reihenzahl = aufgerundet (Zellen / Spalten)

   Braucht das Raster MEHR Reihen als das, liegt irgendwo eine Zelle
   leer, die nicht leer sein muesste -- und zwar vor der letzten Reihe.
   Das ist genau die Luecke, die kaputt aussieht. Eine Luecke am ENDE
   ist dagegen in Ordnung und faellt aus dieser Rechnung heraus.

   GEPRUEFT IN ZWEI LAGEN, denn die Kachelzahl haengt an der Rolle:
   DogFather und ein Modi sehen verschieden viele. Eine Anordnung, die
   nur fuer eine Zahl aufgeht, geht nicht auf.

   OHNE FESTE ZAHLEN (23.09.2026). Hier stand „acht" -- in der
   Ueberschrift, im Text und in der Bedingung. Am 22.09. sind Kacheln
   dazugekommen, und die Pruefung wurde rot, ohne dass am Raster etwas
   kaputt war: Sie hat die Zahl von gestern verteidigt.

   Und sie mass fuer DogFather und einen Modi VERSCHIEDENE Gruppen --
   gesucht wurde „die Community-Gruppe" ueber ihre Ueberschrift, mit
   der letzten Gruppe als Rueckfall. Fuer den einen griff der Treffer,
   fuer den anderen der Rueckfall; beides hiess in der Meldung gleich.
   Eine Pruefung, die je nach Rolle etwas anderes misst, kann ihr
   Ergebnis nicht erklaeren.

   Jetzt werden ALLE Gruppen gemessen, und die Frage ist ueberall
   dieselbe: Hat das Raster ein Loch?

   MIT GEGENPROBE: Dieselbe Rechnung wird auf eine absichtlich falsche
   Reihenfolge angewandt (breite Kachel an dritter Stelle). Sie MUSS
   ein Loch melden -- sonst misst sie nichts.

   Aufrufen mit:  node server/pruef-kachelraster.mjs
   Bild:          SCHIRM=1 node server/pruef-kachelraster.mjs
   ===================================================================== */

import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { fileURLToPath } from "node:url";
import { eigenerPort } from "./helfer-port.mjs";

const PORT = await eigenerPort(import.meta, "pruef-kachelraster");
const ordner = mkdtempSync(join(tmpdir(), "ws-raster-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = String(PORT);
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-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";
await import("./index.js");
notbremse(180_000, "pruef-kachelraster");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;

process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });
process.on("unhandledRejection", (f) => { console.error("ABSTURZ (Versprechen):", f); process.exit(7); });

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

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();
const schluessel = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
  + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
  .run("code_kennung_schluessel", schluessel, jetzt);
function anlegen(name, rolle, code) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(code, salt, 64,
    { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  d.prepare("INSERT INTO personen"
    + " (name, rolle, code_hash, code_salt, code_n, code_kennung, aktiv, erstellt)"
    + " VALUES (?,?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768,
      createHmac("sha256", schluessel).update(code).digest("hex"), jetzt);
}
anlegen("Filipe", "admin", "CODE-DOGI-0001");
anlegen("Marina", "modi", "CODE-MODI-0001");
d.close();

async function anmelden(kachel, code) {
  const a = await fetch(BASIS + "/workspace/api/anmelden", {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle: kachel, code }),
  });
  return (a.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
}

/* Die Rechnung steht hier und nicht im Browser: So laesst sie sich mit
   erfundenen Zahlen gegenpruefen, ohne eine Seite zu bauen. */
function loecher({ spalten, kacheln, reihen }) {
  const zellen = kacheln.reduce((n, k) => n + (k.breit ? 2 : 1), 0);
  const minimum = Math.ceil(zellen / spalten);
  return { zellen, minimum, reihen, loch: reihen > minimum };
}

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

async function messen(kachel, code, wer) {
  const keks = await anmelden(kachel, code);
  /* OHNE EINBLEND-ANIMATION MESSEN (19.09.2026).

     Die Kacheln laufen gestaffelt ein (`kachel-ein`, Verzoegerung je
     Laufnummer). Waehrend das laeuft, stehen sie noch NICHT an ihrem
     Platz -- und diese Pruefung zaehlt Reihen ueber die
     Y-Koordinate. Das feste `waitForTimeout(500)` reichte, solange es
     acht Kacheln waren; mit einer Gruppe mehr verschiebt sich die
     Staffelung, und die Messung fand vier Reihen, wo drei sind. Das
     Bildschirmfoto derselben Seite (1200 ms spaeter) zeigte ein
     makelloses Raster.

     Eine Wartezeit zu erhoehen waere derselbe Fehler mit einer
     groesseren Zahl. `reducedMotion` schaltet die Animation ganz ab --
     die CSS-Regel steht ohnehin in einer
     `prefers-reduced-motion: no-preference`-Abfrage. Damit misst die
     Pruefung den Endzustand, und zwar immer. */
  const kontext = await browser.newContext({
    viewport: { width: 1280, height: 1000 },
    reducedMotion: "reduce",
  });
  await kontext.addCookies(keks.split("; ").map((k) => {
    const [name, ...rest] = k.split("=");
    return { name, value: rest.join("="), domain: "127.0.0.1", path: "/" };
  }));
  const seite = await kontext.newPage();
  const konsole = [];
  seite.on("console", (e) => { if (e.type() === "error") konsole.push(e.text()); });
  await seite.goto(`${BASIS}/workspace/start.html`, { waitUntil: "networkidle" });
  await seite.waitForSelector(".kacheln .kachel", { timeout: 15_000 });
  await seite.waitForTimeout(500);

  const daten = await seite.evaluate(() => {
    /* =================================================================
       ALLE GRUPPEN, NICHT EINE (23.09.2026)
       =================================================================

       Hier wurde „die Community-Gruppe" gesucht -- ueber ihre
       Ueberschrift, mit der letzten Gruppe als Rueckfall. Gemessen am
       23.09. ergab das fuer DogFather EINE Kachel und fuer einen Modi
       ZEHN, und beides hiess in der Meldung „Community-Kacheln". Zwei
       verschiedene Dinge unter einem Namen: Der eine Treffer war eine
       echte Gruppe mit einer Kachel, der andere der Rueckfall.

       Eine Pruefung, die je nach Rolle etwas anderes misst, kann ihr
       Ergebnis nicht erklaeren. Und die Frage, um die es geht -- hat
       das Raster ein Loch? --, stellt sich fuer JEDE Gruppe.

       Also alle. Der Name der Gruppe kommt mit, damit eine Meldung
       sagt, wo etwas klemmt.
       ================================================================= */
    const messeGruppe = (behaelter) => {
    const treffer = behaelter;
    const stil = getComputedStyle(treffer);
    const spalten = stil.gridTemplateColumns.split(" ").filter(Boolean).length;
    const kacheln = [...treffer.querySelectorAll(".kachel")].map((k) => ({
      name: k.querySelector(".kachel__name")?.textContent?.trim() || "",
      breit: k.dataset.gross === "ja",
      oben: Math.round(k.getBoundingClientRect().top),
      /* DAS ZEICHEN HAT KEINEN NAMEN IM DOM -- es wird als SVG
         gezeichnet. Als Fingerabdruck dient deshalb der Pfad selbst:
         Zwei Kacheln mit demselben Schild haben denselben Pfad, und
         genau das ist die Frage. */
      zeichen: [...(k.querySelectorAll(".kachel__svg path") || [])]
        .map((z) => z.getAttribute("d") || "").join("|").slice(0, 120),
      /* Traegt die Kachel eine sichtbare Schiene in ihrem Ton? */
      schiene: getComputedStyle(k, "::before").backgroundImage,
      ton: getComputedStyle(k).getPropertyValue("--ton").trim(),
    }));
    const reihen = new Set(kacheln.map((k) => k.oben)).size;
    return { spalten, kacheln, reihen };
    };

    const gruppen = [...document.querySelectorAll(".kacheln")].map((g) => {
      const kopf = g.previousElementSibling;
      return {
        name: (kopf?.textContent || "").replace(/\s+/g, " ").trim().slice(0, 40)
          || "(ohne Ueberschrift)",
        ...messeGruppe(g),
      };
    }).filter((g) => g.kacheln.length > 0);

    /* Die groesste Gruppe bleibt fuer die Zeilen, die eine einzelne
       brauchen (Zeichen, Toene) -- dort geht es um Unterscheidbarkeit
       nebeneinander, und die entscheidet sich innerhalb einer Gruppe. */
    const groesste = gruppen.reduce((a, b) =>
      (b.kacheln.length > (a?.kacheln.length || 0) ? b : a), null) || { kacheln: [], spalten: 0, reihen: 0 };
    return { gruppen, ...groesste };
  });

  if (process.env.SCHIRM) {
    /* ERST HINSCHEUEN, DANN FOTOGRAFIEREN. Die Kacheln blenden sich
       beim Hereinscrollen ein; ein Vollbild-Foto von oben zeigt sie
       deshalb als leere Flaeche -- ich habe das Bild einmal fuer den
       Beweis gehalten, dass nichts da ist, waehrend die Messung
       daneben acht Kacheln zaehlte. */
    await seite.evaluate(() => {
      const gruppen = [...document.querySelectorAll(".kacheln")];
      const treffer = gruppen.find((g) => {
        const kopf = g.previousElementSibling;
        return kopf && /COMMUNITY/i.test(kopf.textContent || "");
      }) || gruppen[gruppen.length - 1];
      treffer.scrollIntoView({ block: "center" });
    });
    await seite.waitForTimeout(1200);
    const pfad = fileURLToPath(new URL(`pruef-kachelraster-${wer}.png`, import.meta.url));
    await seite.screenshot({ path: pfad, fullPage: false });
  }
  await kontext.close();
  return { ...daten, konsole };
}

try {
  /* =====================================================================
     1. DOGFATHER -- SEINE GRUPPEN GEHEN AUF
     ===================================================================== */
  melde("");
  melde("=== 1. DogFather: kein Loch in einer Gruppe ===");
  {
    const m = await messen("admin", "CODE-DOGI-0001", "dogfather");
    /* KEINE FESTE ZAHL MEHR (23.09.2026).

       Hier stand `=== 8`. Am 22.09. sind Kacheln dazugekommen, und die
       Zeile wurde rot, ohne dass am Raster etwas kaputt war -- sie hat
       die Zahl von gestern verteidigt. Dasselbe Muster wie bei den
       Stufen und der abgeschriebenen Spaltenliste.

       Geprueft wird jetzt, was wirklich gelten muss: Es gibt Gruppen,
       sie sind nicht leer, und KEINE von ihnen hat ein Loch. Die Zahl
       steht in der Meldung, nicht in der Bedingung. */
    ok(m.gruppen.length >= 2,
      `DogFather sieht ${m.gruppen.length} Kachelgruppen `
      + `(${m.gruppen.map((g) => `${g.name}: ${g.kacheln.length}`).join(", ")})`);
    ok(m.spalten === 3, `die groesste Gruppe hat drei Spalten (${m.spalten})`);

    /* WENN eine Gruppe eine doppelt breite Kachel hat, muss sie vorn
       stehen -- sonst entsteht das Loch, um das es hier geht. Es gibt
       heute keine mehr; die Regel bleibt trotzdem stehen, denn sie
       gilt fuer die naechste. Eine Bedingung, die nur greift, wenn es
       etwas zu pruefen gibt, ist kein uebersprungener Test: Die ZAHL
       der geprueften Gruppen steht daneben. */
    const mitBreit = m.gruppen.filter((g) => g.kacheln.some((k) => k.breit));
    const falschPlatziert = mitBreit.filter((g) => !g.kacheln[0].breit);
    ok(falschPlatziert.length === 0,
      mitBreit.length
        ? `${mitBreit.length} Gruppe(n) mit breiter Kachel, alle vorn`
        : "keine Gruppe hat eine doppelt breite Kachel -- die Regel greift, sobald es eine gibt");

    /* JEDE GRUPPE, nicht eine. Die Frage "hat das Raster ein Loch"
       stellt sich ueberall gleich. */
    const mitLoch = m.gruppen.filter((g) => loecher(g).loch);
    ok(m.gruppen.length > 0 && mitLoch.length === 0,
      mitLoch.length
        ? `Loch in: ${mitLoch.map((g) => `${g.name} (${loecher(g).reihen} statt `
          + `${loecher(g).minimum})`).join(", ")}`
        : `kein Loch in einer der ${m.gruppen.length} Gruppen`);
    const r = loecher(m);

    /* JEDES ZEICHEN GENAU EINMAL. Vorher trugen "Regeln & Hilfe" und
       "Meldungen & Massnahmen" beide denselben Schild -- nebeneinander
       und nicht zu unterscheiden. */
    const zeichen = m.kacheln.map((k) => k.zeichen).filter(Boolean);
    const doppelt = zeichen.filter((z, i) => zeichen.indexOf(z) !== i);
    ok(zeichen.length === m.kacheln.length && doppelt.length === 0,
      doppelt.length ? `Zeichen doppelt: ${doppelt.join(", ")}`
        : `jedes der ${zeichen.length} Zeichen kommt genau einmal vor`);

    /* DIE SCHIENE. Sie war beschrieben und nicht gebaut: `.kachel::before`
       hatte nur einen Uebergang und keinen Inhalt. Ohne sie trug den Ton
       nur ein Verlauf, der unter dem Buehnenbild verschwindet. */
    const ohneSchiene = m.kacheln.filter(
      (k) => !k.schiene || k.schiene === "none");
    ok(ohneSchiene.length === 0,
      ohneSchiene.length ? `${ohneSchiene.length} Kacheln ohne Schiene`
        : "jede Kachel traegt ihre farbige Schiene");

    /* UND DIE TOENE SIND VERSCHIEDEN. Sonst waere eine sichtbare
       Schiene siebenmal dieselbe Farbe -- schlimmer als keine. */
    const toene = new Set(m.kacheln.map((k) => k.ton).filter(Boolean));
    ok(toene.size === m.kacheln.length,
      `${toene.size} verschiedene Toene bei ${m.kacheln.length} Kacheln`);

    ok(m.konsole.length === 0,
      m.konsole.length ? `Konsole: ${m.konsole[0]}` : "keine Fehler in der Konsole");
  }

  /* =====================================================================
     2. EIN MODI -- SIEBEN KACHELN
     ===================================================================== */
  melde("");
  melde("=== 2. Ein Modi: dasselbe Raster ===");
  {
    const m = await messen("creator", "CODE-MODI-0001", "modi");
    /* ACHT, NICHT SIEBEN -- und das war MEIN Denkfehler beim Schreiben
       dieser Pruefung, nicht der des Codes: Ein Modi moderiert, also
       braucht er "Meldungen & Massnahmen". Die Liste im Quelltext sagt
       es deutlich (MODI_MIT_TREFF endet auf TREFF_MODERATION_KACHEL).
       Der reine Zuschauer sieht sieben; an den kommt eine Pruefung
       ohne Gastzugang nicht heran, deshalb steht der Fall unten in der
       Rechnung. */
    ok(m.gruppen.length >= 1 && m.kacheln.length > 0,
      `ein Modi sieht ${m.gruppen.length} Gruppe(n), groesste mit `
      + `${m.kacheln.length} Kacheln`);
    const r = loecher(m);
    /* SIEBEN KACHELN, EINE DAVON BREIT = ACHT ZELLEN auf drei Spalten =
       drei Reihen. Die letzte Reihe hat eine freie Zelle -- die ist
       erlaubt, sie liegt am Ende. */
    ok(!r.loch,
      `kein Loch: ${r.zellen} Zellen = ${r.minimum} Reihen, gemessen ${r.reihen}`);
    ok(m.konsole.length === 0,
      m.konsole.length ? `Konsole: ${m.konsole[0]}` : "keine Fehler in der Konsole");
  }

  /* =====================================================================
     3. GEGENPROBE -- FINDET DIE RECHNUNG UEBERHAUPT EIN LOCH?
     ===================================================================== */
  melde("");
  melde("=== 3. Die Gegenprobe ===");
  {
    /* DIE ALTE REIHENFOLGE, nachgestellt: breite Kachel an dritter
       Stelle. Sie belegt dann Zellen 3+4, Zelle 3 der ersten Reihe
       bleibt leer, und es braucht eine Reihe mehr. */
    const alt = loecher({
      spalten: 3, reihen: 4,
      kacheln: [{}, {}, { breit: true }, {}, {}, {}, {}, {}],
    });
    ok(alt.loch, `die alte Reihenfolge meldet ein Loch (${alt.reihen} statt ${alt.minimum})`);

    /* UND DIE ANDERE RICHTUNG: Eine saubere Anordnung darf NICHT
       anschlagen, sonst waere die Rechnung einfach immer rot. */
    const gut = loecher({
      spalten: 3, reihen: 3,
      kacheln: [{ breit: true }, {}, {}, {}, {}, {}, {}, {}],
    });
    ok(!gut.loch, `die neue Reihenfolge nicht (${gut.reihen} = ${gut.minimum})`);

    /* Und eine Luecke am ENDE gilt ausdruecklich nicht als Loch. */
    const ende = loecher({ spalten: 3, reihen: 3, kacheln: [{ breit: true }, {}, {}, {}, {}, {}, {}] });
    ok(!ende.loch, `eine freie Zelle am Ende ist kein Loch (${ende.zellen} Zellen, ${ende.reihen} Reihen)`);

    /* DER REINE ZUSCHAUER sieht sieben Kacheln ohne die Moderation.
       An ihn kommt diese Pruefung nicht heran (kein Gastzugang), also
       wird wenigstens die Rechnung fuer seinen Fall gefuehrt -- und
       sie ist derselbe Fall wie eine Zeile darueber. */
    ok(ende.zellen === 8 && ende.minimum === 3,
      "auch die Sicht eines Zuschauers (7 Kacheln) geht auf drei Reihen auf");
  }
} finally {
  await browser.close();
}

melde("");
melde(`${geprueft} Pruefungen, ${fehler} Fehler`);
melde(fehler ? "NICHT IN ORDNUNG" : "ALLES IN ORDNUNG");
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Aufraeumrest */ }
process.exit(fehler ? 1 : 0);