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 ===");
  {
    /* AUF DER MODI-KACHEL (01.10.2026) -- vorher liess der stille
       Zugang jede durch. */
    const m = await messen("modi", "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");
  }
  /* =====================================================================
     JEDE KACHEL IST AUCH BREIT GENUG (27.09.2026)
     =====================================================================

     Gefunden beim Filmen der Startseite fuer TikTok, also mit dem
     Auge und nicht mit einer Pruefung. Auf einem 320er Geraet waren
     „Rudel-Chat" und „Anschlagbrett" DREI PIXEL breit -- ein
     senkrechter Strich mit abgeschnittenem Text.

     Die Ursache stand in start.css: Unter 380 px wird das Raster
     einspaltig, die Willkommenskachel spannte aber weiter ueber zwei
     Spalten. Ein Gitter mit einer erklaerten Spalte und einem Kind,
     das zwei braucht, erfindet die zweite -- und teilt den Platz
     3 zu 281.

     WARUM ES KEINE PRUEFUNG GEMERKT HAT, und das ist der eigentliche
     Befund: pruef-handy misst Ueberhang und Beruehrziele. Eine 3 px
     breite Kachel ragt nicht hinaus, und ihr Link ist 142 px HOCH --
     die Mindestgroesse fuer den Finger war also erfuellt. Beide
     Pruefungen waren gruen, und die Kachel war unbenutzbar.

     Gemessen wird deshalb ab jetzt die BREITE, und zwar bei den drei
     Geraetebreiten, die das Haus ohnehin fuehrt. Die Grenze ist
     abgeleitet und nicht gesetzt: Eine Kachel muss mindestens ein
     Drittel der Inhaltsbreite haben -- schmaler waere sie auch bei
     drei Spalten nicht.
     ===================================================================== */

  /* Eigene Anmeldung: `messen()` haelt seinen Keks in seinem eigenen
     Gueltigkeitsbereich, und dieser Abschnitt steht daneben, nicht
     darin. Genommen wird der Modi -- er ist die Rolle in dieser
     Pruefung, die eine Kachel mit `gross: true` hat, und nur an der
     kann der Fehler ueberhaupt auftreten. */
  const keksBreite = await anmelden("modi", "CODE-MODI-0001");

  for (const breite of [320, 360, 390]) {
    const k2 = await browser.newContext({
      viewport: { width: breite, height: 900 }, hasTouch: breite <= 860, reducedMotion: "reduce",
    });
    await k2.addCookies(keksBreite.split("; ").map((k) => {
      const [name, ...rest] = k.split("=");
      return { name, value: rest.join("="), domain: "127.0.0.1", path: "/" };
    }));
    const s2 = await k2.newPage();
    await s2.goto(`${BASIS}/workspace/start.html`, { waitUntil: "networkidle" });
    await s2.waitForSelector(".kacheln .kachel", { timeout: 15_000 });
    await s2.waitForTimeout(400);
    const m2 = await s2.evaluate(() => {
      const kacheln = [...document.querySelectorAll("li.kachel")];
      const raster = [...document.querySelectorAll(".kacheln")];
      const inhalt = document.querySelector(".kacheln")?.getBoundingClientRect().width || 0;
      return {
        anzahl: kacheln.length,
        inhalt: Math.round(inhalt),
        schmalste: Math.round(Math.min(...kacheln.map((x) => x.getBoundingClientRect().width))),
        wer: kacheln.map((x) => ({
          n: (x.querySelector(".kachel__name")?.textContent || "?").slice(0, 18),
          b: Math.round(x.getBoundingClientRect().width),
        })).sort((a, b2) => a.b - b2.b).slice(0, 2),
        /* Und eine erfundene Spalte faellt hier auf: mehr Spuren, als
           die Regel erklaert. */
        spuren: raster.map((r) => getComputedStyle(r).gridTemplateColumns.split(" ").length),
      };
    });
    const grenze = Math.floor(m2.inhalt / 3) - 8;
    ok(m2.anzahl > 5, `${breite} px: ${m2.anzahl} Kacheln angesehen`);
    ok(m2.schmalste >= grenze,
      `${breite} px: schmalste Kachel ${m2.schmalste} px (mindestens ${grenze}) -- `
      + m2.wer.map((w) => `${w.n} ${w.b}px`).join(", "));
    ok(m2.spuren.every((z) => z <= (breite < 380 ? 1 : 2)),
      `${breite} px: kein Raster hat mehr Spalten als erlaubt (${m2.spuren.join("/")})`);
    await k2.close();
  }

} 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);