dogfather-universe/server/pruef-fingermass.mjs

/* =====================================================================
   pruef-fingermass.mjs — Wer am Handy misst, braucht einen Finger

   WAS HIER SCHIEFGING (29.09.2026 gemessen):
   In chat.css stand neben den 44-Pixel-Knoepfen der Nachrichten-
   fusszeile eine Rechnung: „Fuenf mal 44 plus vier Abstaende sind
   236 px — eine Blase hat auf 412 px innen 251 px. Die Reihe bleibt
   damit einzeilig." Sie vergisst die Uhrzeit (57 px), und 236 + 57
   sind 293. Gemessen waren es drei Zeilen, 96 Pixel hoch, unter
   JEDER einzelnen Nachricht.

   WARUM DAS VIER TAGE UNBEMERKT BLIEB: Die Regel ist nie gelaufen.
   `page.setViewportSize({ width: 412 })` aendert nur die Groesse.
   `hasTouch` gehoert zum KONTEXT und laesst sich danach nicht mehr
   setzen — ohne ihn meldet der Browser `pointer: fine`, und KEINE
   einzige Regel aus `@media (pointer: coarse)` greift. Dort stehen
   im ganzen Haus die 44-Pixel-Beruehrziele.

   Eine Messung mit Mauszeiger auf 412 Pixeln vermisst also eine
   Seite, die es auf keinem Telefon gibt — und meldet dabei „in
   Ordnung". Das ist die dritte Sorte falscher Haken: nicht
   uebersprungen, nicht rot, sondern gruen und wertlos.

   WAS DIESE PRUEFUNG SICHERT: Dass die Zahl solcher Messungen nur
   noch SINKT. Sie meldet nicht 18 Fehler auf einmal — eine Warnung,
   die immer kommt, wird weggeklickt und nimmt den echten Fund mit.
   Sie haelt eine Grundlinie und schlaegt an, sobald eine NEUE
   dazukommt.

   UND SIE SCHLAEGT AUCH AN, WENN DIE ZAHL SINKT. Wer eine Messung
   repariert und die Grundlinie stehen laesst, deckt damit Platz fuer
   die naechste Suende. Das kostet eine Zeile und haelt die Wache
   scharf.
   ===================================================================== */

import { readdirSync, readFileSync } from "node:fs";
import { join } from "node:path";

let ok_ = 0, fehl = 0;
const ok = (b, text) => { if (b) { ok_++; console.log("  ok   " + text); }
  else { fehl++; console.log("  FEHL " + text); } };

const ORDNER = new URL(".", import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1");

/* GRUNDLINIE, gemessen am 29.09.2026. Diese Zahl darf nur kleiner
   werden. Wird sie kleiner, gehoert sie hier angepasst — die
   Pruefung sagt es dann selbst.

   DREI ANLAEUFE, DREI ZAHLEN. Ein grep ueber die Dateien fand 18;
   zwei davon waren Zahlen in Kommentaren („gemessen bei 412 px"),
   keine Fenster. Die erste Fassung dieser Wache zaehlte dann DATEIEN
   und kam auf 16 — aber `pruef-kalender.mjs` allein hat sieben
   Fenster, davon drei schmale, und ein einziges `hasTouch` irgendwo
   in der Datei haette alle drei freigesprochen. Gezaehlt wird
   deshalb je FENSTER.

   Die geschaerfte Fassung fand dann prompt zwei Dateien, welche die
   grobe freigesprochen hatte — `pruef-chat-optik` und
   `pruef-handy-teamdogi`, beide mit EINEM Finger und einem blinden
   Fenster daneben. Beim Nachmessen war die erste ein Fehlalarm (ihr
   `setViewportSize` sitzt auf einer Seite, die den Finger schon
   hat), die zweite ein echter Fund und sofort repariert.

   Die erste Zahl, die eine Wache liefert, ist selten die richtige.

   29.09.2026, nachmittags: 17 -> 6 -> 1. Sechzehn Fenster bekamen
   einen Finger, eines fiel weg. JEDE der umgestellten Pruefungen
   lief danach gruen -- diese Seiten halten die Fingerregeln also
   schon ein, es hatte nur nie jemand nachgesehen. Gefunden wurde
   dabei trotzdem etwas: eine Zeitbombe in pruef-kalender (dort
   steht die Erklaerung).

   DIE SCHWEREN FAELLE brauchten je einen Umbau: Wo mitten im Ablauf
   `setViewportSize` stand, kann der Finger nicht nachgetragen
   werden. Das Muster, das fuer alle fuenf getragen hat: einen
   eigenen Kontext anlegen, `addCookies(await kontext.cookies())`,
   und die Adresse von `seite.url()` nehmen statt sie ein zweites
   Mal hinzuschreiben. Danach ist das fruehere Zuruecksetzen auf
   1280 px hinfaellig -- die breite Seite war nie schmal.

   ES BLIEB EINES: `pruef-grosscheck`. Die Datei zu aendern war ein
   Zweizeiler; sie zu pruefen hiess, 206 Seiten ueber vier Rollen
   laufen zu lassen, und das brauchte Filipes Zusage. Eine
   Aenderung, die ich nicht pruefen darf, liefere ich nicht aus.

   ERLEDIGT AM 02.10.2026. Filipe: „mach jetzt den prüf groß check."
   Alle drei Kontexte dort haben ihren Finger bekommen, der Lauf ist
   danach gruen: 206 Seiten, 122 551 Elemente, 3 870 bedienbare, und
   die Elementzahlen sind Ziffer fuer Ziffer dieselben wie im Lauf
   davor -- es ist also nichts stillschweigend weggefallen.

   Der erste Lauf MIT Finger hat sofort gezeigt, wozu das gut war:
   Er meldete vier Beanstandungen, und beide Ursachen lagen in der
   Pruefung, nicht am Produkt (die zweite war „0px Schriftgroesse",
   nachzulesen in pruef-grosscheck.mjs).

   AB JETZT IST DIE GRUNDLINIE NULL, und das ist mehr als eine
   kleinere Zahl: Es gibt im ganzen Haus kein blindes Telefonfenster
   mehr. Jedes neue ist damit ein Befund und kein Bestand. Wer hier
   wieder eine Zahl ueber 0 einsetzen will, baut die Ausnahme
   zurueck, die es gerade nicht mehr gibt. */
const GRUNDLINIE = 0;

/* Ab wann ist ein Fenster ein Telefon? 860 ist die Grenze, die im
   Haus schon in mess-reaktion und mess-chat-optik steht. Darueber
   hat ein Geraet mit hoher Wahrscheinlichkeit einen Zeiger. */
const SCHMAL = 860;
const MISST = /getBoundingClientRect|offsetWidth|offsetHeight|clientWidth|clientHeight|scrollWidth|scrollHeight|boundingBox/;

const ohneKommentare = (text) => text
  .replace(/\/\*[\s\S]*?\*\//g, " ")
  .replace(/^\s*\/\/.*$/gm, " ");

/* NUR DIE STELLE, DIE EIN FENSTER AUFMACHT — nicht jede Zahl im
   Text. `width: 412` in einem Kommentar ueber eine Messung von
   gestern ist keine Messung.

   UND JE FENSTER, NICHT JE DATEI. Eine Wache, die eine Datei als
   Ganzes abhakt, uebersieht genau die Mischung, die im Haus die
   Regel ist: ein Fenster mit Finger, drei ohne. */
export const fensterStellen = (text) => {
  const raus = [];
  const rein = ohneKommentare(text);
  for (const m of rein.matchAll(/newContext\s*\(\s*\{[\s\S]{0,400}?\}\s*\)/g)) {
    const br = [...m[0].matchAll(/width\s*:\s*(\d{3,4})\b/g)].map((z) => Number(z[1]));
    if (!br.length) {
      /* ==== DER BLINDE FLECK DIESER WACHE (01.10.2026) ==========

         Hier stand `continue` -- ein Fenster ohne Zahl galt als
         nicht vorhanden. In pruef-breiten.mjs stand aber

             newContext({ viewport: { width: breite, height: hoehe } })

         und die Breite kam aus einer Schleife ueber neun
         Geraete, darunter 320, 390 und 430 Pixel. Keine Zahl,
         kein Treffer, „in Ordnung" -- und pruef-breiten meldete
         daraufhin drei Befunde auf einer Seite, die es auf
         keinem Telefon gibt.

         Ohne Zahl laesst sich nicht sagen, ob das Fenster
         schmal ist. Ob ein `hasTouch` danebensteht, sehr wohl --
         und fehlt es, KANN das Fenster schmal sein und hat
         keinen Finger. Das ist nicht „in Ordnung", sondern der
         dritte Ausgang, und er bekommt eine eigene Zahl. */
      /* NUR WENN EINE BREITE DASTEHT UND KEINE ZAHL IST. Ein
         `newContext` ganz OHNE Breite ist das Standardfenster
         (1280x720) -- kein Telefon. Ohne diese Einschraenkung
         meldete die Wache 45 Faelle, darunter jedes
         `newContext({ permissions: [...] })`. Eine Warnung, die
         45-mal kommt, nimmt die echte mit. */
      const stehtBreite = /\bwidth\s*:/.test(m[0]);
      if (stehtBreite && !/hasTouch/.test(m[0])) raus.push({ unklar: true });
      continue;
    }
    raus.push({ schmal: br.some((x) => x <= SCHMAL), finger: /hasTouch/.test(m[0]) });
  }
  /* `setViewportSize` KANN `hasTouch` nicht nachtragen — es gehoert
     zum Kontext und ist beim Anlegen entschieden.

     ABER ES KANN IHN AUCH NICHT WEGNEHMEN. Die erste Fassung zaehlte
     jede solche Stelle als blind und meldete daraufhin
     `pruef-chat-optik.mjs` — zu Unrecht: Deren Kontext traegt
     `hasTouch: breite < 900`, und wer danach nur die Groesse
     aendert, behaelt den Finger. Ein Fehlalarm, gefunden beim
     Nachmessen des ersten Laufs.

     Gezaehlt wird die Stelle deshalb nur, wenn in der ganzen Datei
     KEIN einziges `hasTouch` steht — dann stammt die Seite sicher
     aus einem fingerlosen Kontext. Wo ich raten muesste, zaehle ich
     nicht: Eine Wache, die im Zweifel meldet, wird weggeklickt. */
  if (!/hasTouch/.test(rein)) {
    for (const m of rein.matchAll(/setViewportSize\s*\(\s*\{[^}]{0,150}\}/g)) {
      const br = [...m[0].matchAll(/width\s*:\s*(\d{3,4})\b/g)].map((z) => Number(z[1]));
      if (!br.length) continue;
      raus.push({ schmal: br.some((x) => x <= SCHMAL), finger: false });
    }
  }
  return raus;
};

/* Ein Fenster ist nur dann ein Befund, wenn die Datei ueberhaupt
   MISST. Wer bei 390 px nachsieht, ob ein Text dasteht, braucht
   keinen Finger. */
export const blindeStellen = (text) => (MISST.test(text)
  ? fensterStellen(text).filter((f) => f.schmal && !f.finger).length : 0);
export const fingerlos = (text) => blindeStellen(text) > 0;

console.log("\n=== 1. Wer misst am Telefon ohne Finger? ===");
const dateien = readdirSync(ORDNER)
  .filter((n) => /^(pruef|mess)-.*\.mjs$/.test(n) && n !== "pruef-fingermass.mjs");

/* DRITTER AUSGANG: Findet sie nichts zum Ansehen, ist das kein
   „alles in Ordnung", sondern „konnte nicht nachsehen". */
if (dateien.length < 50) {
  console.log(`  FEHL Nur ${dateien.length} Pruefdateien gefunden — der Ordner stimmt nicht.`);
  console.log("       Erwartet werden ueber 150 in " + ORDNER);
  process.exit(2);
}

const funde = [];
const unklare = [];
let blind = 0, mitFinger = 0, amTelefon = 0, unklar = 0;
for (const name of dateien) {
  const text = readFileSync(join(ORDNER, name), "utf8");
  const schmale = fensterStellen(text).filter((f) => f.schmal);
  if (!schmale.length) continue;
  amTelefon++;
  mitFinger += schmale.filter((f) => f.finger).length;
  const b = blindeStellen(text);
  if (b) { blind += b; funde.push(`${name} (${b})`); }
}

/* Die unklaren getrennt -- sie koennen schmal sein, sie koennen es
   auch nicht sein. Sie in die blinden einzurechnen waere geraten,
   sie wegzulassen waere das, was heute den Fehler gedeckt hat. */
for (const name of dateien) {
  const u = fensterStellen(readFileSync(join(ORDNER, name), "utf8"))
    .filter((f) => f.unklar).length;
  if (u) { unklar += u; unklare.push(`${name} (${u})`); }
}

console.log(`  ${amTelefon} Dateien oeffnen ein Telefonformat, `
  + `${mitFinger} dieser Fenster haben einen Finger.`);
if (funde.length) console.log("  blinde Fenster mit Massband: " + funde.join(", "));

ok(amTelefon > 20, `${amTelefon} Dateien messen am Telefon — die Suche findet ueberhaupt etwas`);

if (blind > GRUNDLINIE) {
  ok(false, `${blind} blinde Fenster — das sind ${blind - GRUNDLINIE} MEHR als die `
    + `Grundlinie ${GRUNDLINIE}. Neu dazugekommen ist eine Messung, die auf einem `
    + "Telefonformat eine Seite vermisst, die es auf keinem Telefon gibt. "
    + "`hasTouch: true` gehoert in den newContext-Aufruf — setViewportSize kann es "
    + "nicht nachtragen.");
} else if (blind < GRUNDLINIE) {
  ok(false, `Nur noch ${blind} blinde Fenster — die Grundlinie steht auf ${GRUNDLINIE}. `
    + `Bitte in pruef-fingermass.mjs auf ${blind} senken, sonst deckt sie Platz fuer `
    + "die naechste.");
} else {
  ok(true, `${blind} blinde Fenster mit Massband — unveraendert zur Grundlinie ${GRUNDLINIE}`);
}

/* ==== DIE DRITTE ZAHL (01.10.2026) ================================
   Ein `newContext` ohne Zahl UND ohne `hasTouch`: Die Breite kommt
   aus einer Variablen, und ob sie schmal ist, steht hier nicht. Das
   ist kein Befund und kein Freispruch -- es ist die Frage, die
   diese Wache nicht beantworten kann.

   Sie bekommt eine eigene Grundlinie, damit sie weder
   stillschweigend durchgeht noch die echte Zahl verfaelscht.

   NEUNUNDDREISSIG WAREN ES AM 01.10.2026 MITTAGS. Siebenunddreissig
   davon haben noch am selben Tag ihren Finger bekommen und sind
   einzeln nachgelaufen; uebrig blieben ZWEI, beide in
   pruef-grosscheck.mjs. Die Aenderung dort war ein Zweizeiler --
   sie zu pruefen hiess, 206 Seiten ueber vier Rollen laufen zu
   lassen, und das brauchte Filipes Zusage. Eine Aenderung, die ich
   nicht pruefen darf, liefere ich nicht aus.

   AM 02.10.2026 KAM DIE ZUSAGE, und damit sind es NULL. Die zwei
   Kontexte in pruef-grosscheck haben `hasTouch: b <= 860,
   isMobile: b <= 860` bekommen, der Lauf danach ist gruen. Es gibt
   im Haus also kein Fenster mehr, bei dem offenbleibt, ob am
   Telefon mit Mauszeiger gemessen wird.

   SO SAH ES VORHER AUS, als Beleg dafuer, dass die Zahl ernst war:

       mess-chat-liste.mjs   ["handy", 390, 860]   ohne hasTouch
       pruef-material.mjs    ein Handy-Fall         ohne hasTouch

   Das sind Messungen, die bei Telefonbreiten eine Seite mit
   MAUSZEIGER vermessen. Genau so hat pruef-breiten heute drei
   Befunde gemeldet, die es auf keinem Telefon gibt.

   WIE BEI DER ANDEREN GRUNDLINIE GILT: Die Zahl muss GENAU
   stimmen. Waechst sie, ist eine neue Messung dazugekommen, die am
   Telefon mit Mauszeiger misst. Sinkt sie, gehoert sie hier
   gesenkt -- sonst deckt sie Platz fuer die naechste. Ich hatte sie
   kurz auf „hoechstens" gestellt und damit genau dieses Loch
   gebaut, eine Stunde nachdem ich die Begruendung oben gelesen
   hatte. */
const UNKLAR_GRUNDLINIE = 0;
if (unklare.length) console.log("  ohne Zahl und ohne Finger: " + unklare.join(", "));
ok(unklar === UNKLAR_GRUNDLINIE,
  unklar === UNKLAR_GRUNDLINIE
    ? `${unklar} Fenster, deren Breite aus einer Variablen kommt und bei denen `
      + `kein hasTouch danebensteht — unveraendert zur Grundlinie ${UNKLAR_GRUNDLINIE}`
    : `${unklar} Fenster mit Variable und ohne hasTouch (Grundlinie `
      + `${UNKLAR_GRUNDLINIE}). Dort laesst sich nicht sagen, ob am Telefon gemessen `
      + "wird — und genau so ist am 01.10. pruef-breiten durchgerutscht. "
      + "Entweder hasTouch setzen oder die Breite als Zahl hinschreiben.");

console.log("\n=== 2. Gegenprobe: kann sie auch NICHT IN ORDNUNG sagen? ===");
const faelle = [
  ["der Fall vom 29.09. (schmal, misst, kein Finger)",
    'const s = await b.newContext({ viewport: { width: 412, height: 900 } });\n'
    + 'el.getBoundingClientRect()', 1],
  ["mit Finger",
    'const s = await b.newContext({ viewport: { width: 412, height: 900 }, hasTouch: true });\n'
    + 'el.getBoundingClientRect()', 0],
  ["nur ein Laptopfenster",
    'const s = await b.newContext({ viewport: { width: 1280, height: 900 } });\n'
    + 'el.getBoundingClientRect()', 0],
  ["schmal, misst aber nichts",
    'const s = await b.newContext({ viewport: { width: 390, height: 844 } });\n'
    + 'await p.textContent("h1")', 0],
  ["eine Breite, die nur im Kommentar steht",
    '/* gemessen bei width: 412 -- drei Zeilen */\n'
    + 'const s = await b.newContext({ viewport: { width: 1440, height: 900 } });\n'
    + 'el.getBoundingClientRect()', 0],
  ["setViewportSize statt newContext — kann hasTouch gar nicht setzen",
    'await p.setViewportSize({ width: 390, height: 844 });\nel.offsetWidth', 1],
  /* DER FEHLALARM AUS DEM ERSTEN LAUF: Wer einen Finger-Kontext
     anlegt und danach nur die Groesse aendert, behaelt den Finger. */
  ["Groesse aendern an einer Seite, die schon einen Finger hat",
    'const c = await b.newContext({ viewport: { width: 900, height: 900 },\n'
    + '  hasTouch: breite < 900 });\n'
    + 'await p.setViewportSize({ width: 390, height: 844 });\nel.offsetWidth', 0],
  /* DER FALL, AN DEM DIE ERSTE FASSUNG SCHEITERTE: Ein Finger in der
     Datei, drei blinde Fenster daneben. Sie sprach die ganze Datei
     frei. */
  ["ein Finger spricht nicht die ganze Datei frei",
    'const a = await b.newContext({ viewport: { width: 390, height: 844 }, hasTouch: true });\n'
    + 'const c = await b.newContext({ viewport: { width: 412, height: 900 } });\n'
    + 'el.getBoundingClientRect()', 1],
  ["zwei blinde Fenster sind zwei Befunde, nicht einer",
    'const a = await b.newContext({ viewport: { width: 390, height: 844 } });\n'
    + 'const c = await b.newContext({ viewport: { width: 412, height: 900 } });\n'
    + 'el.getBoundingClientRect()', 2],
];
const daneben = faelle
  .filter(([, text, soll]) => blindeStellen(text) !== soll)
  .map(([n, text, soll]) => `${n} (${blindeStellen(text)} statt ${soll})`);
ok(daneben.length === 0,
  daneben.length ? `Gegenprobe daneben bei: ${daneben.join(", ")}`
    : `Gegenprobe: alle ${faelle.length} Faelle richtig eingeordnet`);

/* ==== UND FUER DIE DRITTE ZAHL (01.10.2026) ======================
   Sie meldet heute 0, und eine Zeile, die 0 meldet, sieht genauso
   aus wie eine, die gar nichts finden kann. Genau das war sie bis
   heute Mittag.

   Eigene Tabelle, nicht in die obige hinein: Es ist eine andere
   Frage, und ein Fall, der in beiden steht, wird irgendwann in
   einer davon falsch gepflegt. */
const unklarStellen = (text) => fensterStellen(text).filter((f) => f.unklar).length;
const unklarFaelle = [
  ["der Fall vom 01.10. (Breite aus einer Variablen, kein Finger)",
    'const c = await b.newContext({ viewport: { width: breite, height: hoehe } });', 1],
  ["dieselbe Stelle MIT Finger",
    'const c = await b.newContext({ viewport: { width: breite, height: hoehe },\n'
    + '  hasTouch: breite <= 860 });', 0],
  ["eine Zahl ist keine Unklarheit — die beurteilt die Wache oben",
    'const c = await b.newContext({ viewport: { width: 390, height: 844 } });', 0],
  ["ein Fenster ganz ohne Breite ist das Standardfenster, kein Telefon",
    'const c = await b.newContext({ permissions: ["notifications"] });', 0],
];
const unklarDaneben = unklarFaelle
  .filter(([, text, soll]) => unklarStellen(text) !== soll)
  .map(([n, text, soll]) => `${n} (${unklarStellen(text)} statt ${soll})`);
ok(unklarDaneben.length === 0,
  unklarDaneben.length
    ? `Gegenprobe zur dritten Zahl daneben bei: ${unklarDaneben.join(", ")}`
    : `Gegenprobe: alle ${unklarFaelle.length} Faelle der dritten Zahl richtig`);

console.log(`\n${ok_} Pruefungen, ${fehl} Fehler`);
console.log(fehl ? "NICHT IN ORDNUNG\n" : "ALLES IN ORDNUNG\n");
process.exit(fehl ? 1 : 0);