/* ===================================================================== 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);