/* =====================================================================
   pruef-nachfrage.mjs — Nichts verschwindet ohne Nachfrage.

   Filipe, 19.09.2026: „Es darf vor allem keine Stellen geben, an denen
   ein Benutzer etwas falsch machen kann, nur weil die Seite es nicht
   verständlich genug erklärt." Und: „Fehler möglichst verhindern,
   bevor sie entstehen."

   ---------------------------------------------------------------------
   WAS DAS PROBLEM WAR

   Das Haus hatte die richtige Bauweise — einen <dialog> statt
   `confirm()` — und begründete sie in `aufgaben.html` sogar ausführlich.
   Nur stand sie IN EINER SEITE. Gemessen am 19.09.2026: **30 Stellen**
   in 16 Dateien griffen weiterhin zu `confirm()` oder `prompt()`.

   Der Unterschied ist nicht Geschmack. `confirm('Wirklich löschen?')`
   stellt die falsche Frage: Es fragt, ob man sicher ist, und nennt
   nicht, WAS passiert, was BLEIBT und ob es ZURÜCK geht. Genau das
   sind die drei Dinge, die man vor einem Löschen wissen will.

   ---------------------------------------------------------------------
   VIER DINGE WERDEN GEPRÜFT

     1. KEIN NATIVER DIALOG mehr in einer Seiten-Datei. Ausgenommen ist
        allein der Notnagel in `nachfrage.js` selbst — für Browser ohne
        <dialog>. (Ein Verbot ohne diese Ausnahme wäre falsch: Ein
        iPhone vor Safari 15.4 bekäme sonst gar nichts angezeigt.)

     2. ANGESCHLOSSEN — jede Seite, deren Skripte `frageNach` benutzen,
        lädt auch `nachfrage.js`. Ohne die Datei wäre `frageNach` nicht
        definiert, und aus einer Rückfrage würde ein Absturz: Der Knopf
        täte stillschweigend nichts.

        ACHTUNG, hier steckte beim Bauen schon eine Falle: Die erste
        Fassung dieser Prüfung zählte `nachfrage.js` SELBST als Nutzer
        (die Datei enthält das Wort natürlich) — damit war jede Seite
        „Nutzer", die Prüfung immer grün und sie bewies nichts. Deshalb
        ist die Datei unten ausdrücklich ausgenommen.

     3. GESTALTET — `.dialog` wird in einer Datei gestaltet, die JEDE
        Seite lädt. Vorher stand sie in `aufgaben.css`; auf `dateien.html`
        wäre der Dialog ein weißer Systemkasten auf dunkler Seite
        gewesen. Das ist keine Schönheitsfrage: Ein Kasten, der aussieht
        wie eine Browser-Warnung, wird weggeklickt statt gelesen.

     4. VOLLSTÄNDIG — jeder Aufruf hat einen `titel` und sagt, was
        passiert (`was`). Ein Dialog ohne diese Angabe ist ein
        `confirm()` mit mehr Zeilen Code.

   Dazu GEGENPROBEN: Jede Prüfung muss beweisen, dass sie auch
   „nicht in Ordnung" sagen kann.

   AUFRUF:  node server/pruef-nachfrage.mjs
   Läuft in unter zwei Sekunden, ohne Server.
   ===================================================================== */

import { readFileSync, readdirSync } from "node:fs";
import { join, dirname } from "node:path";
import { fileURLToPath } from "node:url";
import { bestaetige, nachfrageText } from "./helfer-nachfrage.mjs";

const HIER = dirname(fileURLToPath(import.meta.url));
const WURZEL = join(HIER, "..");
const SEITEN_ORDNER = join(WURZEL, "workspace");
const JS_ORDNER = join(SEITEN_ORDNER, "assets", "js");
const CSS_ORDNER = join(SEITEN_ORDNER, "assets", "css");

/* Die eine Datei, die `confirm`/`prompt` benutzen DARF -- sie ist der
   Notnagel fuer Browser ohne <dialog>. */
const DER_NOTNAGEL = "nachfrage.js";

/** Ein winziges, gueltiges PNG (1x1) -- echte Kopfbytes, damit der
 *  Browser wirklich ein Bild bekommt und die Vorschau etwas anzeigen
 *  kann. Vorgetaeuschte Bytes ergaeben ein leeres `<img>`, und die
 *  Pruefung haette „Vorschau da" gemeldet, ohne eine zu sehen. */
const PNG_PROBE = Buffer.from(
  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk"
  + "YPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==", "base64");

let ok = 0, fehl = 0;
const pruef = (name, bedingung, zusatz = "") => {
  if (bedingung) { ok++; console.log(`  OK   ${name}`); }
  else { fehl++; console.log(`  FEHL ${name}${zusatz ? "\n         " + zusatz : ""}`); }
};

const lies = (p) => readFileSync(p, "utf8");
const seiten = readdirSync(SEITEN_ORDNER).filter((f) => f.endsWith(".html"));
const skripte = readdirSync(JS_ORDNER).filter((f) => f.endsWith(".js"));

console.log("\n=== Nachfragen: kein nativer Dialog, und keiner ohne Erklärung ===\n");

/* ---------------------------------------------------------------------
   1. KEIN NATIVER DIALOG
   ------------------------------------------------------------------ */

/** Entfernt Kommentare, bevor gesucht wird. Ohne das zaehlt jeder
 *  Kommentar, der `confirm()` ERWAEHNT, als Fund -- und davon gibt es
 *  in diesem Haus absichtlich mehrere (die Begruendungen). */
function ohneKommentare(js) {
  return js.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
}

const nativ = [];
for (const f of skripte) {
  if (f === DER_NOTNAGEL) continue;
  const code = ohneKommentare(lies(join(JS_ORDNER, f)));
  /* DAS MUSTER HATTE EINE LUECKE, UND ZWAR DIE GROESSTE MOEGLICHE
     (gefunden am 22.09.2026).

     Vorher stand hier `(?:^|[^.\w])(confirm|prompt)\s*\(`. Das
     `[^.\w]` sollte fremde Methoden ausschliessen -- etwas wie
     `angebot.prompt()` (so heisst die Installations-Aufforderung des
     Browsers) ist kein nativer Dialog und darf nicht als Fund zaehlen.

     Nur trifft dieser Ausschluss ausgerechnet die HAEUFIGSTE
     Schreibweise: `window.prompt(` hat einen Punkt davor. Die Pruefung
     war damit gruen, waehrend in teamlage.js ZWEI native prompt()
     standen -- einer davon seit Wochen.

     Genau das Muster, vor dem dieses Haus warnt: eine Pruefung, die
     laeuft, gruen ist und das Falsche prueft. Gefunden hat es nicht
     sie, sondern eine Suche von Hand.

     Jetzt zwei Faelle statt einem: mit `window.` davor -- oder ganz
     ohne Punkt. Alles andere (`irgendwas.prompt()`) bleibt aussen
     vor, und das ist weiterhin richtig. */
  for (const m of code.matchAll(/(?:^|[^.\w])(?:window\s*\.\s*)?(confirm|prompt)\s*\(/g)) {
    const zeile = code.slice(0, m.index).split("\n").length;
    nativ.push(`${f}:${zeile} → ${m[1]}()`);
  }
}
pruef("keine Seite benutzt noch confirm() oder prompt()", nativ.length === 0,
  nativ.slice(0, 8).join("\n         "));

/* Und der Notnagel ist da -- sonst haetten Browser ohne <dialog> gar
   nichts. Die ZAHL gehoert in die Bedingung, nicht nur in den Text. */
const notnagel = lies(join(JS_ORDNER, DER_NOTNAGEL));
pruef("der Notnagel für alte Browser ist vorhanden",
  /HTMLDialogElement/.test(notnagel) && /window\.confirm\(/.test(notnagel));

/* ---------------------------------------------------------------------
   2. ANGESCHLOSSEN
   ------------------------------------------------------------------ */

/** Welche Skripte rufen frageNach auf? OHNE die Datei, die es
 *  DEFINIERT -- sonst ist die Antwort immer „alle". */
const nutzer = new Set();
/* EIN AUFRUF HINTER EINER `typeof`-ABFRAGE IST KEINE PFLICHT
   (24.09.2026 -- und die Pruefung war aus genau diesem Grund rot,
   ohne dass etwas kaputt war).

   `installieren.js` liegt auf fast jeder Seite und ruft frageNach
   auf -- aber ausdruecklich nur, wenn es da ist:

       if (typeof window.frageNach === 'function') { … }

   Der Kommentar daneben erklaert seit dem 22.09.2026 genau, warum:
   Die Datei laeuft auch auf der Anmeldewand, wo nachfrage.js mit
   Absicht nicht geladen wird. Die Pruefung zaehlte den Aufruf
   trotzdem als "diese Seite fragt nach" -- und weil installieren.js
   ueberall liegt, wurde damit JEDE Seite zur fragenden. Ergebnis:
   fuenf rote Zeilen, kein einziger echter Mangel.

   EINE PRUEFUNG, DIE IMMER ROT IST, IST KEINE PRUEFUNG MEHR -- genau
   wie eine Warnung, die immer kommt. Ab dem zweiten Mal liest man
   sie weg, und dann auch die echte.

   Die Unterscheidung ist einfach und haelt: Wer vorher fragt, ob es
   die Funktion gibt, kommt ohne sie aus. Wer sie einfach aufruft,
   braucht sie. */
const geschuetzt = (text) =>
  /typeof\s+window\.frageNach\s*===?\s*['"]function['"]/.test(text)
  || /window\.frageNach\s*\?\./.test(text);
const freiwillig = new Set();
for (const f of skripte) {
  if (f === DER_NOTNAGEL) continue;
  const text = ohneKommentare(lies(join(JS_ORDNER, f)));
  if (!/\bfrageNach\s*\(/.test(text)) continue;
  if (geschuetzt(text)) { freiwillig.add(f); continue; }
  nutzer.add(f);
}
pruef("es gibt überhaupt Seiten, die nachfragen", nutzer.size > 0,
  `gefunden: ${nutzer.size}`);
/* WAS HIER HERAUSFAELLT, WIRD BENANNT. Ein stilles Aussortieren
   waere die bequeme Art, eine Pruefung gruen zu bekommen -- man
   saehe dann nicht mehr, wie gross die Ausnahme geworden ist. */
pruef("die geschützten Aufrufe sind benannt und wenige",
  freiwillig.size <= 3,
  `ohne Pflicht zur Datei (typeof-Abfrage davor): ${[...freiwillig].join(", ") || "keine"}`);
/* GEGENPROBE: Ein UNGESCHUETZTER Aufruf muss weiterhin zaehlen --
   sonst hiesse "alle angeschlossen" nur, dass die Regel niemanden
   mehr erfasst. */
pruef("Gegenprobe: ein ungeschützter Aufruf zählt weiterhin",
  !geschuetzt("frageNach({ titel: 'x' });")
  && geschuetzt("if (typeof window.frageNach === 'function') frageNach({});"),
  `${nutzer.size} Dateien rufen ungeschützt auf`);

const ohneDatei = [], totesGewicht = [], fragendeSeiten = [];
let mitNutzung = 0;
for (const s of seiten) {
  const html = lies(join(SEITEN_ORDNER, s));
  const geladen = [...html.matchAll(/<script src="assets\/js\/([a-z0-9-]+\.js)/g)]
    .map((m) => m[1]);
  /* ZWEI GRUENDE, die Datei zu brauchen (20.09.2026):
     fragen -- oder einen Dialog mit Eingabefeldern haben. Seit die
     Verwurfwache existiert, bewacht `nachfrage.js` jeden solchen
     Dialog von selbst, auch ohne einen einzigen `frageNach`-Aufruf
     in der Seite. Ohne diesen zweiten Grund wuerde eine Seite mit
     einem reinen Formular-Dialog hier als „totes Gewicht" gemeldet --
     und jemand naehme die Datei heraus, die dort gerade arbeitet. */
  const hatDialogMitFeld = [...html.matchAll(/<dialog[^>]*>[\s\S]*?<\/dialog>/g)]
    .some((m) => /<(input|textarea|select)\b/.test(m[0]));
  const kannFragen = geladen.some((g) => nutzer.has(g)) || hatDialogMitFeld;
  const hatDatei = html.includes("assets/js/nachfrage.js");
  if (kannFragen) { mitNutzung++; fragendeSeiten.push(s); if (!hatDatei) ohneDatei.push(s); }
  else if (hatDatei) totesGewicht.push(s);
}
pruef("jede Seite, die nachfragt, lädt auch nachfrage.js",
  mitNutzung > 0 && ohneDatei.length === 0,
  `${mitNutzung} Seiten nutzen es, ohne Datei: ${ohneDatei.join(", ") || "keine"}`);

/* UND DIE GEGENRICHTUNG. Ohne sie waere „ueberall einbinden" die
   bequeme Antwort -- und die Anmeldewand, die jeder Besucher als
   erste laedt, truege 4,8 KB fuer einen Dialog, den sie nie zeigt.
   Zwei Richtungen, eine Regel: Die Datei liegt genau dort, wo sie
   gebraucht wird. */
pruef("und keine Seite lädt sie, ohne je nachzufragen",
  totesGewicht.length === 0,
  `unnötig geladen auf: ${totesGewicht.join(", ")}`);

/* ---------------------------------------------------------------------
   3. GESTALTET, UND ZWAR ÜBERALL
   ------------------------------------------------------------------ */

/** In welchen CSS-Dateien wird `.dialog` gestaltet? */
const dialogCss = readdirSync(CSS_ORDNER).filter((f) => f.endsWith(".css"))
  .filter((f) => /^\.dialog[\s,{:]/m.test(lies(join(CSS_ORDNER, f))));

/** Und welche davon laedt jede Seite, DIE NACHFRAGEN KANN? Abgeleitet,
 *  nicht behauptet -- eine Liste „module.css laedt ueberall" waere genau
 *  die abgeschriebene Liste, vor der die Hausregeln warnen.
 *
 *  Gemessen wird gegen die fragenden Seiten, nicht gegen alle: Die zwei
 *  Anmeldewaende zeigen nie einen Dialog. Von ihnen die Dialog-
 *  Gestaltung zu verlangen hiesse, 12 KB auf die Seite zu legen, die
 *  jeder Besucher als erste laedt -- fuer nichts. */
const ueberall = new Set(dialogCss);
for (const s of fragendeSeiten) {
  const html = lies(join(SEITEN_ORDNER, s));
  const css = new Set([...html.matchAll(/href="assets\/css\/([a-z0-9-]+\.css)/g)]
    .map((m) => m[1]));
  for (const d of [...ueberall]) if (!css.has(d)) ueberall.delete(d);
}
pruef(".dialog wird dort gestaltet, wo jede fragende Seite es lädt",
  ueberall.size > 0 && fragendeSeiten.length > 0,
  `.dialog steht in: ${dialogCss.join(", ")} — von allen `
  + `${fragendeSeiten.length} fragenden Seiten geladen: `
  + `${[...ueberall].join(", ") || "KEINE"}`);

/* Die zwei eigenen Bauteile des Nachfrage-Dialogs gehoeren in dieselbe
   Datei -- sonst waere der wichtigste Satz ("nicht rueckgaengig")
   ungestaltet. */
const gemeinsam = [...ueberall][0];
const gCss = gemeinsam ? lies(join(CSS_ORDNER, gemeinsam)) : "";
pruef("auch die Warnzeile und die Fehlerzeile sind dort gestaltet",
  /\.nachfrage__endgueltig/.test(gCss) && /\.nachfrage__fehler/.test(gCss));

/* Und sie traegt ihre Aussage nicht nur ueber Farbe. */
pruef("die Warnzeile hat ein Zeichen, nicht nur eine Farbe",
  /\.nachfrage__endgueltig::before\s*{[^}]*content/.test(gCss),
  "Farbe allein trägt keine Aussage — Rot-Grün-Schwäche, Kontrastmodus");

/* ---------------------------------------------------------------------
   4. VOLLSTÄNDIG: jeder Aufruf sagt, was passiert
   ------------------------------------------------------------------ */

/** Schneidet den Objektliteral-Teil eines frageNach-Aufrufs heraus,
 *  klammergenau. Ein Muster „bis zur naechsten }" wuerde bei jedem
 *  verschachtelten Ausdruck danebengreifen. */
function aufrufe(js) {
  const out = [];
  for (const m of js.matchAll(/frageNach\s*\(\s*{/g)) {
    let i = m.index + m[0].length - 1, tiefe = 0, j = i;
    for (; j < js.length; j++) {
      if (js[j] === "{") tiefe++;
      else if (js[j] === "}") { tiefe--; if (tiefe === 0) { j++; break; } }
    }
    out.push(js.slice(i, j));
  }
  return out;
}

let gezaehlt = 0;
const ohneTitel = [], ohneWas = [];
for (const f of skripte) {
  if (f === DER_NOTNAGEL) continue;
  const code = ohneKommentare(lies(join(JS_ORDNER, f)));
  for (const a of aufrufe(code)) {
    gezaehlt++;
    /* AUCH DIE KURZSCHREIBWEISE ZAEHLT (24.09.2026).
       Gesucht wurde nur `titel:`. In installieren.js steht aber
       `frageNach({ titel, was: weg, … })` -- die Kurzform, die den
       Titel aus einer gleichnamigen Variablen nimmt. Gueltiges JS,
       gesetzter Titel, und trotzdem gemeldet. Eine Pruefung, die eine
       richtige Schreibweise bemaengelt, bringt einem bei, ihre
       Meldungen zu ignorieren. */
    if (!/\btitel\s*[:,}]/.test(a)) ohneTitel.push(f);
    if (!/\bwas\s*:/.test(a)) ohneWas.push(f);
  }
}
/* DIE ZAHL GEHOERT IN DIE BEDINGUNG: Bei null Aufrufen waere
   „alle haben einen Titel" trivialerweise wahr. */
pruef("jeder Aufruf hat einen Titel", gezaehlt > 0 && ohneTitel.length === 0,
  `${gezaehlt} Aufrufe geprüft, ohne Titel: ${ohneTitel.join(", ") || "keiner"}`);
pruef("jeder Aufruf sagt, WAS passiert", gezaehlt > 0 && ohneWas.length === 0,
  `ohne „was": ${ohneWas.join(", ") || "keiner"}`);

/* Und die gefaehrlichste Handlung im Haus -- eine Person loeschen --
   verlangt das Abtippen des Namens. Das ist keine Schikane: Der
   Loeschknopf sitzt neben dem Sperrknopf. */
pruef("eine Person löschen verlangt den Namen abgetippt",
  /tippen:\s*v\.person\.name/.test(lies(join(JS_ORDNER, "personen.js"))));

/* ---------------------------------------------------------------------
   DIE VERWURFWACHE — beide Schliesswege, und kein Dauerfeuer
   ------------------------------------------------------------------ */
const wache = notnagel;
pruef("die Verwurfwache faengt Esc ab (das `cancel`-Ereignis)",
  /addEventListener\('cancel'/.test(wache),
  "ohne sie liefe Esc durch -- der Browser ruft close() dabei NICHT auf");
pruef("und sie faengt auch close() ab (die Abbrechen-Knoepfe)",
  /dlg\.close = function/.test(wache),
  "ohne sie liefe der Knopf durch -- er loest kein `cancel` aus");
pruef("sie ersetzt close() nur AM DIALOG, nicht am Prototyp",
  !/HTMLDialogElement\.prototype\.close\s*=/.test(wache),
  "ein globaler Eingriff traefe den Nachfrage-Dialog selbst -- der ginge nie mehr zu");
pruef("sie fragt nur bei wirklicher Aenderung",
  /const geaendert = \(\) =>/.test(wache) && /if \(!geaendert\(\)\)/.test(wache),
  "eine Warnung, die immer kommt, ist keine Warnung mehr");
pruef("sie bewacht sich nicht selbst",
  /dialog:not\(\.nachfrage\)/.test(wache),
  "sonst fragte der Nachfrage-Dialog beim Schliessen nach sich selbst");

/* Und die Speicherwege sagen ihr Bescheid -- sonst fragte sie nach
   jedem erfolgreichen Speichern. */
let speicherwege = 0;
for (const f of skripte) {
  if (f === DER_NOTNAGEL) continue;
  speicherwege += [...ohneKommentare(lies(join(JS_ORDNER, f)))
    .matchAll(/\.vergessen\?\.\(\)/g)].length;
}
pruef("die Speicherwege melden der Wache, dass nichts mehr zu retten ist",
  speicherwege >= 8, `${speicherwege} Stellen rufen vergessen()`);

/* ---------------------------------------------------------------------
   DIE GEGENPROBEN — jede muss anschlagen
   ------------------------------------------------------------------ */
console.log("\n  --- Gegenproben (jede MUSS anschlagen) ---");

/* DIE GEGENPROBE PRUEFT JETZT BEIDE SCHREIBWEISEN. Haette sie das
   vorher getan, waere die Luecke im Muster am selben Tag aufgefallen,
   an dem es geschrieben wurde. */
pruef("Gegenprobe: ein erfundenes window.prompt() würde gefunden",
  /(?:^|[^.\w])(?:window\s*\.\s*)?(confirm|prompt)\s*\(/.test(
    "const g = window.prompt('Warum nicht?');"));
pruef("Gegenprobe: eine fremde Methode NICHT (angebot.prompt())",
  !/(?:^|[^.\w])(?:window\s*\.\s*)?(confirm|prompt)\s*\(/.test(
    "angebot.prompt();"));
pruef("Gegenprobe: ein erfundenes confirm() würde gefunden",
  /(?:^|[^.\w])(confirm|prompt)\s*\(/.test(
    ohneKommentare("function x(){ if (!confirm('weg?')) return; }")));

pruef("Gegenprobe: ein confirm() im KOMMENTAR wird NICHT gemeldet",
  !/(?:^|[^.\w])(confirm|prompt)\s*\(/.test(
    ohneKommentare("/* frueher stand hier confirm('weg?') */")));

pruef("Gegenprobe: nachfrage.js selbst zählt nicht als Nutzer",
  !nutzer.has(DER_NOTNAGEL),
  'sonst wäre jede Seite trivialerweise Nutzer und die Prüfung grün ohne Inhalt');

pruef("Gegenprobe: die Gestaltung-Prüfung kann auch NEIN sagen",
  (() => {
    /* Eine erfundene Seite, die nachfragt, aber die Datei nicht laedt:
       Die Schnittmenge muss dadurch leer werden. */
    const probe = new Set(dialogCss);
    for (const d of [...probe]) if (!new Set(["gibt-es-nicht.css"]).has(d)) probe.delete(d);
    return probe.size === 0;
  })());

pruef("Gegenprobe: ein Aufruf ohne Titel würde auffallen",
  aufrufe("frageNach({ was: 'x' })").length === 1
  && !/\btitel\s*:/.test(aufrufe("frageNach({ was: 'x' })")[0]));

pruef("Gegenprobe: der Klammerzähler findet das Ende auch bei Verschachtelung",
  aufrufe("frageNach({ titel: f({a:1}), was: 'x' }) ; danach")[0]
    === "{ titel: f({a:1}), was: 'x' }");

/* =====================================================================
   UND JETZT AM ECHTEN BILDSCHIRM

   Alles oben ist Textsuche. Sie beweist, dass der Aufruf dasteht --
   nicht, dass der Dialog aufgeht, dass "Doch nicht" wirklich nichts
   tut und dass das Abtippen wirklich sperrt.

   Geprüft wird ausgerechnet der gefährlichste Handgriff im Haus: eine
   Person löschen. `pruef-personen-loeschen` gibt es zwar, aber sie
   kennt nur die Schnittstelle -- kein Browser, kein Knopf, kein
   Dialog. Der Weg, den ein Mensch geht, war nie geprüft.
   ===================================================================== */
if (process.env.OHNE_BROWSER === "ja") {
  console.log("\n  (Browserteil übersprungen — OHNE_BROWSER=ja)");
} else {
  const { mkdtempSync, rmSync } = await import("node:fs");
  const { tmpdir } = await import("node:os");
  const { eigenerPort } = await import("./helfer-port.mjs");
  const { notbremse } = await import("./helfer-notbremse.mjs");

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

  const { DatabaseSync } = await import("node:sqlite");
  const { scryptSync, randomBytes } = await import("node:crypto");
  await fetch(BASIS + "/workspace/api/anmelden", {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
  for (let i = 0; i < 60; i++) {
    try {
      const pb = new DatabaseSync(process.env.WORKSPACE_DB);
      try { pb.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { pb.close(); }
    } catch { await new Promise((r) => setTimeout(r, 250)); }
  }
  const db = new DatabaseSync(process.env.WORKSPACE_DB);
  const jetzt = new Date().toISOString();
  const anlegen = (name, rolle, code) => {
    const salt = randomBytes(16).toString("hex");
    const h = scryptSync(code, salt, 64,
      { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
    db.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt)"
      + " VALUES (?,?,?,?,?,1,?)").run(name, rolle, h, salt, 32768, jetzt);
  };
  anlegen("Filipe", "admin", "CODE-DOGI-0001");
  anlegen("Testolina", "creator", "CODE-CREA-0001");
  db.close();

  const pw = await import("file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await pw.chromium.launch();
  const ctx = await browser.newContext({ viewport: { width: 1280, height: 900 } });
  const seite = await ctx.newPage();
  const abstuerze = [];
  seite.on("pageerror", (f) => abstuerze.push(f.message));

  await seite.goto(BASIS + "/workspace/", { waitUntil: "networkidle" });
  await seite.click('.rolle[data-rolle="admin"]');
  await seite.fill("#code", "CODE-DOGI-0001");
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 25000 });
  await seite.goto(BASIS + "/workspace/personen.html", { waitUntil: "networkidle" });
  await seite.waitForTimeout(900);

  console.log("\n  --- Am echten Bildschirm: eine Person löschen ---");

  const wieViele = () => seite.evaluate(() =>
    [...document.querySelectorAll(".person")].length);
  /* DEN ABSCHNITT AUFKLAPPEN. Die Rollen-Abschnitte sind
     standardmäßig ZU -- nur der eigene ist offen. Das ist so gewollt
     (eine Liste mit fünf offenen Abschnitten ist unlesbar), und eine
     Prüfung, die das nicht weiß, misst eine leere Liste und hält das
     für einen Befund. Genau das ist beim Bauen passiert. */
  await seite.waitForSelector('.gruppe[data-rolle="creator"] .gruppe__kopf',
    { timeout: 15_000 });
  await seite.click('.gruppe[data-rolle="creator"] .gruppe__kopf');
  await seite.waitForFunction(
    () => document.querySelectorAll(".person").length >= 2,
    { timeout: 15_000 }).catch(() => {});
  const vorher = await wieViele();
  const namen2 = await seite.evaluate(() =>
    [...document.querySelectorAll(".person")]
      .map((e) => e.textContent.trim().slice(0, 30)).join(" | "));
  pruef("die Liste steht da", vorher >= 2, `${vorher} Personen: ${namen2}`);

  const loeschKnopf = seite.locator(".person", { hasText: "Testolina" })
    .locator("button", { hasText: "Löschen" }).first();
  await loeschKnopf.click();

  let dialogDa = true;
  try { await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 4000 }); }
  catch { dialogDa = false; }
  pruef("der Dialog geht auf", dialogDa);

  if (dialogDa) {
    const inhalt = await nachfrageText(seite);
    pruef("er nennt den Namen im Titel", /Testolina/.test(inhalt.titel), inhalt.titel);
    pruef("er sagt, dass es endgültig ist", inhalt.endgueltig);
    pruef("er sagt, WAS passiert", inhalt.was.length > 10, inhalt.was);
    pruef("und was BLEIBT", inhalt.bleibt.length > 10, inhalt.bleibt);

    /* DER RIEGEL: Ein falsch abgetippter Name darf NICHTS loeschen. */
    await seite.fill("#nachfrage-tipp", "Testolinaa");
    await seite.click('dialog.nachfrage [data-teil="ja"]');
    await seite.waitForTimeout(500);
    const nochOffen = await seite.evaluate(() =>
      !!document.querySelector("dialog.nachfrage[open]"));
    pruef("ein falsch abgetippter Name schließt den Dialog NICHT", nochOffen);
    const fehlertext = await seite.evaluate(() =>
      document.querySelector('dialog.nachfrage [data-teil="fehler"]')?.textContent?.trim() || "");
    pruef("und sagt, was erwartet wird", /Testolina/.test(fehlertext), fehlertext);
    pruef("die Person ist noch da", await wieViele() === vorher);

    /* Der Knopf daneben muss wirklich nichts tun. */
    await seite.click('dialog.nachfrage [data-teil="nein"]');
    await seite.waitForTimeout(400);
    pruef("der Abbruchknopf schließt den Dialog",
      !await seite.evaluate(() => !!document.querySelector("dialog.nachfrage[open]")));
    pruef("und löscht nichts", await wieViele() === vorher);

    /* Und jetzt richtig. */
    await bestaetige(seite, () => loeschKnopf.click(), { tippen: "Testolina" });
    await seite.waitForTimeout(1400);
    const nachher = await wieViele();
    pruef("mit richtig abgetipptem Namen wird gelöscht",
      nachher === vorher - 1, `${vorher} → ${nachher}`);
  }

  /* Und Esc bricht ab -- auf einem Dialog OHNE Abtippen. */
  await seite.goto(BASIS + "/workspace/start.html", { waitUntil: "networkidle" });
  await seite.waitForTimeout(700);
  await seite.click("#abmelden");
  let abmeldeDialog = true;
  try { await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 4000 }); }
  catch { abmeldeDialog = false; }
  pruef("auch Abmelden fragt nach", abmeldeDialog);
  if (abmeldeDialog) {
    const t = await nachfrageText(seite);
    pruef("und nennt den Grund: der Zugangscode", /Zugangscode/.test(t.was), t.was);
    await seite.keyboard.press("Escape");
    await seite.waitForTimeout(800);
    pruef("Esc bricht ab – man bleibt angemeldet",
      seite.url().includes("start.html"), seite.url());
  }

  /* ===================================================================
     DIE VERWURFWACHE AM ECHTEN BILDSCHIRM (20.09.2026)

     Alles oben ist Textsuche. Sie beweist, dass der Code dasteht --
     nicht, dass Esc wirklich abgefangen wird, dass ein unberührter
     Dialog still zugeht und dass „Verwerfen" wirklich verwirft.

     Geprüft wird am größten Formular des Hauses: „Aufgabe bearbeiten",
     zehn Felder. Wer dort tippt und mit dem Daumen den Rand trifft,
     verlor bis heute alles, wortlos.
     =================================================================== */
  console.log("\n  --- Die Verwurfwache am Bildschirm ---");

  /* Eine Aufgabe, damit es etwas zu bearbeiten gibt. */
  {
    const dbz = new DatabaseSync(process.env.WORKSPACE_DB);
    const wer = dbz.prepare("SELECT id FROM personen WHERE rolle = 'admin' LIMIT 1").get()?.id;
    dbz.prepare("INSERT INTO aufgaben (titel, beschreibung, status, verantwortlich_id,"
      + " erstellt_von, erstellt) VALUES (?,?,?,?,?,?)")
      .run("Zum Bearbeiten", "Ein Text, der nicht verlorengehen darf.",
        "offen", wer, wer, new Date().toISOString());
    dbz.close();
  }

  await seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
  await seite.waitForTimeout(900);

  const auf = async () => {
    await seite.click(".karte, .aufgabe, [data-id]", { timeout: 5000 }).catch(() => {});
    await seite.waitForTimeout(500);
    return seite.evaluate(() =>
      !!document.getElementById("bearbeiten-dialog")?.open);
  };

  /* Erst über den Bearbeiten-Knopf an der Karte. */
  let offen = await seite.evaluate(() => {
    const k = [...document.querySelectorAll("button")]
      .find((b) => /bearbeiten/i.test(b.textContent || "") || /bearbeiten/i.test(b.title || ""));
    if (k) { k.click(); return true; }
    return false;
  });
  await seite.waitForTimeout(700);
  let istAuf = await seite.evaluate(() =>
    !!document.getElementById("bearbeiten-dialog")?.open);
  if (!istAuf) istAuf = await auf();

  pruef("der Bearbeiten-Dialog geht auf", istAuf);

  if (istAuf) {
    /* 1. UNBERÜHRT -> still zu. Das ist der wichtigere Fall: Wer
          nichts getippt hat, darf nichts gefragt werden. */
    await seite.keyboard.press("Escape");
    await seite.waitForTimeout(500);
    const nachEsc = await seite.evaluate(() => ({
      dialogZu: !document.getElementById("bearbeiten-dialog")?.open,
      gefragt: !!document.querySelector("dialog.nachfrage[open]"),
    }));
    pruef("unberührt geht er ohne Nachfrage zu", nachEsc.dialogZu && !nachEsc.gefragt,
      `zu: ${nachEsc.dialogZu}, gefragt: ${nachEsc.gefragt}`);

    /* 2. GETIPPT -> Esc fragt nach. */
    await seite.evaluate(() => {
      const k = [...document.querySelectorAll("button")]
        .find((b) => /bearbeiten/i.test(b.textContent || "") || /bearbeiten/i.test(b.title || ""));
      k?.click();
    });
    await seite.waitForTimeout(600);
    await seite.fill("#b-titel", "Etwas ganz anderes");
    await seite.keyboard.press("Escape");
    await seite.waitForTimeout(600);
    const nachTippen = await seite.evaluate(() => ({
      nochOffen: !!document.getElementById("bearbeiten-dialog")?.open,
      gefragt: !!document.querySelector("dialog.nachfrage[open]"),
      text: document.querySelector('dialog.nachfrage [data-teil="was"]')?.textContent || "",
    }));
    pruef("nach einer Änderung fragt Esc nach", nachTippen.gefragt,
      `gefragt: ${nachTippen.gefragt}`);
    pruef("und der Dialog bleibt solange offen", nachTippen.nochOffen);
    pruef("die Frage sagt, was verloren geht",
      /verloren/i.test(nachTippen.text), nachTippen.text);

    /* 3. „Weiter bearbeiten" -> der Text steht noch da. */
    await seite.click('dialog.nachfrage [data-teil="nein"]');
    await seite.waitForTimeout(500);
    const nachWeiter = await seite.evaluate(() => ({
      nochOffen: !!document.getElementById("bearbeiten-dialog")?.open,
      titel: document.getElementById("b-titel")?.value || "",
    }));
    pruef("Weiter bearbeiten laesst den Dialog offen", nachWeiter.nochOffen);
    pruef("und der getippte Text steht noch da",
      nachWeiter.titel === "Etwas ganz anderes", `„${nachWeiter.titel}"`);

    /* 4. DER KNOPF-WEG -- und er muss JEDES MAL fragen.
       ----------------------------------------------------------------
       NICHT noch einmal Esc. Gemessen am 20.09.2026: Ein ZWEITES Esc
       hintereinander schliesst den Dialog, egal was die Seite tut.
       Das ist Chromiums „close watcher": Eine Seite darf den Nutzer
       nicht mit Esc einsperren. Die Regel ist richtig, und dagegen
       anzubauen waere falsch -- also wird sie hier festgehalten statt
       umgangen.

       Der Knopf unterliegt ihr nicht. Er ist auch der Weg, den man am
       Handy nimmt, wo es kein Esc gibt. */
    await seite.click("#b-abbrechen");
    await seite.waitForTimeout(600);
    const nachKnopf = await seite.evaluate(() => ({
      nochOffen: !!document.getElementById("bearbeiten-dialog")?.open,
      gefragt: !!document.querySelector("dialog.nachfrage[open]"),
    }));
    pruef("auch der Abbrechen-Knopf fragt nach",
      nachKnopf.gefragt && nachKnopf.nochOffen,
      `gefragt: ${nachKnopf.gefragt}, noch offen: ${nachKnopf.nochOffen}`);

    await seite.click('dialog.nachfrage [data-teil="ja"]', { timeout: 6000 });
    await seite.waitForTimeout(700);
    const nachVerwerfen = await seite.evaluate(() =>
      !document.getElementById("bearbeiten-dialog")?.open);
    pruef('Verwerfen schliesst den Dialog wirklich', nachVerwerfen);

    /* Und danach ist nichts uebernommen worden -- verwerfen heisst
       verwerfen, nicht speichern. */
    const inListe = await seite.evaluate(() =>
      document.body.textContent.includes("Etwas ganz anderes"));
    pruef("und der verworfene Text steht nirgends in der Liste", !inListe);
  }

  /* =================================================================
     EIN BILD IM DIALOG (02.10.2026)

     VanVan (Support): „Wenn man hier im Support auf deine Frage 'geht
     es wieder' reagiert und antwortet, kann man auch kein Bild
     hinzufuegen."

     Das Feld ist eine OPTION dieses Dialogs, damit Grund und Bild in
     denselben Kasten passen -- zwei Dialoge nacheinander hiessen: Wer
     beim zweiten abbricht, hat den ersten umsonst getippt.

     GEPRUEFT WIRD DER MECHANISMUS, NICHT DIE SUPPORTSEITE. Der Dialog
     wird hier direkt aufgerufen; dass die Supportseite ihn mit `bild`
     aufruft, steht weiter oben in der Dateiprüfung. Beides zusammen
     deckt den Weg ab, und keins von beidem braucht eine Meldung im
     Zustand „wartet", die diese Pruefung erst herstellen muesste.

     DIE VORGABE IST AUS, und das ist die wichtigste Zeile hier: Ohne
     sie bekaemen die 56 anderen Rueckfragen im Haus ein Bildfeld,
     nach dem niemand gefragt hat. */
  console.log("\n  --- Ein Bild im Dialog ---");
  {
    /* OHNE `bild` DARF NICHTS DASTEHEN. */
    await seite.evaluate(() => {
      window.__probe = window.frageNach({ titel: "Ohne Bild", grund: "Warum?" });
    });
    await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
    const ohne = await seite.evaluate(() => {
      const z = document.querySelector('dialog.nachfrage [data-teil="bildzeile"]');
      return { da: !!z, versteckt: !!z && z.hidden };
    });
    pruef("ohne Angabe bleibt die Bildzeile verborgen",
      ohne.da && ohne.versteckt);
    await seite.click('dialog.nachfrage [data-teil="nein"]');
    await seite.waitForTimeout(400);

    /* MIT `bild` IST SIE DA -- und liefert die Datei zurueck. */
    await seite.evaluate(() => {
      window.__probe = window.frageNach({
        titel: "Mit Bild", ja: "Senden",
        grund: "Was geht noch nicht?", grundPflicht: true, grundMin: 3,
        bild: "Bildschirmfoto dazu (freiwillig)",
      });
    });
    await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
    const mit = await seite.evaluate(() => {
      const z = document.querySelector('dialog.nachfrage [data-teil="bildzeile"]');
      const k = document.querySelector('dialog.nachfrage [data-teil="bildwaehlen"]');
      const r = k ? k.getBoundingClientRect() : null;
      return {
        sichtbar: !!z && !z.hidden,
        schild: document.querySelector('dialog.nachfrage [data-teil="bildschild"]')
          ?.textContent || "",
        knopfHoch: r ? Math.round(r.height) : 0,
        /* „Noch keins gewählt" statt einer leeren Zeile: Wer nichts
           sieht, weiss nicht, ob er etwas vergessen hat. */
        name: document.querySelector('dialog.nachfrage [data-teil="bildname"]')
          ?.textContent || "",
        wegVerborgen: document.querySelector('dialog.nachfrage [data-teil="bildweg"]')?.hidden,
      };
    });
    pruef("mit Angabe steht die Bildzeile da", mit.sichtbar);
    pruef(`  mit der Beschriftung aus dem Aufruf („${mit.schild}")`,
      /Bildschirmfoto/.test(mit.schild));
    pruef(`  der Knopf ist ${mit.knopfHoch} px hoch (Fingermass 44)`,
      mit.knopfHoch >= 44);
    pruef(`  und es steht da, dass noch keins gewählt ist („${mit.name}")`,
      /Noch keins/.test(mit.name));
    pruef("  der Entfernen-Knopf ist noch verborgen", mit.wegVerborgen === true);

    /* EIN BILD WAEHLEN -- mit einer echten Datei, nicht mit einem
       vorgetaeuschten Ereignis. */
    await seite.setInputFiles("dialog.nachfrage #nachfrage-bild", {
      name: "bildschirm.png", mimeType: "image/png", buffer: PNG_PROBE,
    });
    await seite.waitForTimeout(400);
    const gewaehlt = await seite.evaluate(() => {
      /* EIN KASTEN MIT EINER LISTE statt eines einzelnen <img>
         (02.10.2026): Seit VanVans Meldung #11 koennen es bis zu
         drei sein, und `bildMax` entscheidet, wie viele. */
      const kasten = document.querySelector('dialog.nachfrage [data-teil="bildvorschauen"]');
      const schau = kasten?.querySelector("img") || null;
      return {
        name: document.querySelector('dialog.nachfrage [data-teil="bildname"]')
          ?.textContent || "",
        wegDa: document.querySelector('dialog.nachfrage [data-teil="bildweg"]')?.hidden === false,
        vorschau: !!kasten && !kasten.hidden && !!schau
          && (schau.getAttribute("src") || "").length > 0,
        hoch: schau ? Math.round(schau.getBoundingClientRect().height) : 0,
      };
    });
    pruef(`  nach der Wahl steht der Name da („${gewaehlt.name}")`,
      /bildschirm\.png/.test(gewaehlt.name));
    pruef("  der Entfernen-Knopf erscheint", gewaehlt.wegDa);
    /* WER SIEHT, WAS ER ANHAENGT, haengt seltener das falsche Bild an
       -- dieselbe Ueberlegung wie beim Melden. */
    pruef("  und eine Vorschau ist da", gewaehlt.vorschau);

    /* ==== UND JETZT MIT EINEM HOHEN BILD =========================

       Hier stand die Grenze zuerst am 1x1-Bild von oben gemessen:
       „3 px, hoechstens 160". Das ist gruen und wertlos -- ein ein
       Pixel hohes Bild kann keine Obergrenze ueberschreiten. Genau
       die Sorte Haken, vor der die Hausregeln warnen.

       Ein hochkantes Bildschirmfoto vom Handy ist der echte Fall:
       Ohne Deckel waere es hoeher als der ganze Dialog, und die
       Knoepfe darunter waeren nicht mehr zu sehen. Das Bild entsteht
       im Browser (300x900) und kommt als ECHTE Datei in das Feld --
       mit `DataTransfer`, nicht mit einem vorgetaeuschten Ereignis. */
    const hoch = await seite.evaluate(async () => {
      const c = document.createElement("canvas");
      c.width = 300; c.height = 900;
      const g = c.getContext("2d");
      g.fillStyle = "#2b6cb0"; g.fillRect(0, 0, c.width, c.height);
      const blob = await new Promise((r) => c.toBlob(r, "image/png"));
      const dt = new DataTransfer();
      dt.items.add(new File([blob], "hochkant.png", { type: "image/png" }));
      const feld = document.querySelector("dialog.nachfrage #nachfrage-bild");
      feld.files = dt.files;
      feld.dispatchEvent(new Event("change", { bubbles: true }));
      await new Promise((r) => setTimeout(r, 300));
      const schau = document.querySelector('dialog.nachfrage .nachfrage__vorschau img');
      const dlg = document.querySelector("dialog.nachfrage");
      const ja = document.querySelector('dialog.nachfrage [data-teil="ja"]');
      const r = schau.getBoundingClientRect();
      return {
        echt: schau.naturalHeight,
        gezeigt: Math.round(r.height),
        breit: Math.round(r.width),
        /* DER EIGENTLICHE PUNKT: Der Senden-Knopf muss noch im Fenster
           stehen. Eine Obergrenze ist kein Selbstzweck. */
        jaImFenster: (() => {
          const j = ja.getBoundingClientRect();
          return j.bottom <= window.innerHeight && j.height > 0;
        })(),
        dialogHoch: Math.round(dlg.getBoundingClientRect().height),
      };
    });
    /* 120 STATT 160 SEIT DEM 02.10.2026. Der Deckel ist gesunken,
       weil in dem Kasten jetzt bis zu drei Bilder nebeneinander
       stehen koennen -- bei 160 waere der Senden-Knopf bei drei
       hochkanten Bildern aus dem Fenster. Die Zahl steht in
       module.css und wird hier nachgemessen, nicht geraten. */
    pruef(`  ein 300x900 grosses Bild wird auf ${hoch.gezeigt} px gedeckelt`
      + ` (echt ${hoch.echt}, höchstens 120)`,
      hoch.echt === 900 && hoch.gezeigt > 0 && hoch.gezeigt <= 120);
    pruef(`  und es bleibt in der Breite (${hoch.breit} px)`, hoch.breit <= 300);
    pruef(`  der Senden-Knopf steht weiter im Fenster (Dialog ${hoch.dialogHoch} px)`,
      hoch.jaImFenster);

    await seite.fill("dialog.nachfrage #nachfrage-grund", "Geht noch nicht, siehe Bild.");
    await seite.click('dialog.nachfrage [data-teil="ja"]');
    await seite.waitForTimeout(500);
    const erg = await seite.evaluate(async () => {
      const a = await window.__probe;
      /* `bilder` UND NICHT `bild` (02.10.2026): Der Dialog gibt
         immer eine Liste zurueck, auch wenn nur eines erlaubt war.
         Ein Sonderfall „genau eines" waere die zweite Auskunft auf
         dieselbe Frage -- und die veraltet. */
      const eins = a && Array.isArray(a.bilder) ? a.bilder[0] : null;
      return {
        grund: a && a.grund,
        anzahl: a && Array.isArray(a.bilder) ? a.bilder.length : -1,
        bildName: eins ? eins.name : null,
        bildTyp: eins ? eins.type : null,
        istDatei: !!(eins && typeof eins.size === "number"),
      };
    });
    pruef(`der Dialog gibt den Grund zurück („${erg.grund}")`,
      /siehe Bild/.test(erg.grund || ""));
    pruef(`  er gibt eine LISTE zurueck, nicht ein Feld (${erg.anzahl})`,
      erg.anzahl === 1);
    pruef(`  und die Datei dazu (${erg.bildName}, ${erg.bildTyp})`,
      /*  und nicht : Zwei Zeilen
         weiter oben wurde das Bild ERSETZT. Meine erste Fassung
         erwartete noch das erste und wurde rot -- die Pruefung
         hatte recht, die Erwartung war veraltet. */
      erg.istDatei && erg.bildName === "hochkant.png" && erg.bildTyp === "image/png");

    /* GEGENPROBE: Abbrechen gibt gar nichts zurueck -- auch nicht das
       Bild. Ohne diese Zeile koennte ein Abbruch trotzdem etwas
       hochladen. */
    await seite.evaluate(() => {
      window.__probe2 = window.frageNach({
        titel: "Abbrechen", grund: "Warum?", bild: "Bild dazu",
      });
    });
    await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
    await seite.setInputFiles("dialog.nachfrage #nachfrage-bild", {
      name: "egal.png", mimeType: "image/png", buffer: PNG_PROBE,
    });
    await seite.waitForTimeout(300);
    await seite.click('dialog.nachfrage [data-teil="nein"]');
    await seite.waitForTimeout(400);
    const abbruch = await seite.evaluate(async () => await window.__probe2);
    pruef("Gegenprobe: Abbrechen gibt nichts zurück, auch kein Bild",
      abbruch === false);

    /* UND JEDES OEFFNEN FAENGT LEER AN. Ohne das haengt beim zweiten
       Mal noch das Bild vom ersten dran -- und niemand sieht es,
       weil der Dialog oben schon zu war. */
    await seite.evaluate(() => {
      window.__probe3 = window.frageNach({
        titel: "Nochmal", grund: "Warum?", bild: "Bild dazu",
      });
    });
    await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
    const frisch = await seite.evaluate(() =>
      document.querySelector('dialog.nachfrage [data-teil="bildname"]')?.textContent || "");
    pruef(`  und beim nächsten Öffnen ist es leer („${frisch}")`,
      /Noch keins/.test(frisch));
    await seite.click('dialog.nachfrage [data-teil="nein"]');
    await seite.waitForTimeout(300);

    /* ==== UND MIT `bildMax` SIND ES MEHRERE (02.10.2026) =========

       VanVan im Support, Meldung #11: „2-3 wären besser." Der
       Dialog kann das seither; ohne Angabe bleibt es bei einem,
       damit sich fuer jeden anderen Aufruf im Haus nichts aendert.

       DER UNTERSCHIED ZUM FALL DARUEBER IST DER PUNKT: Dort hat die
       zweite Wahl die erste ERSETZT (ein Platz, eine Korrektur),
       hier muss sie DAZUKOMMEN. Beides in derselben Pruefung, sonst
       beweist keines etwas. */
    await seite.evaluate(() => {
      window.__probe4 = window.frageNach({
        titel: "Mit dreien", ja: "Senden",
        grund: "Was geht noch nicht?", grundPflicht: true, grundMin: 3,
        bild: "Bildschirmfotos dazu (freiwillig)", bildMax: 3,
      });
    });
    await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
    const zaehl = () => seite.evaluate(() =>
      document.querySelectorAll("dialog.nachfrage .nachfrage__vorschau").length);
    for (const name of ["a.png", "b.png", "c.png", "d.png"]) {
      await seite.setInputFiles("dialog.nachfrage #nachfrage-bild", {
        name, mimeType: "image/png", buffer: PNG_PROBE,
      });
      await seite.waitForTimeout(250);
    }
    const dreiDa = await zaehl();
    pruef(`mit bildMax 3 legt jede Wahl DAZU (${dreiDa} nach vier Griffen)`,
      dreiDa === 3);
    const grenzWort = await seite.evaluate(() =>
      document.querySelector('dialog.nachfrage [data-teil="fehler"]')?.textContent || "");
    pruef(`  und das vierte wird mit einem Satz abgelehnt („${grenzWort}")`,
      /3 Bilder/.test(grenzWort));

    /* EINZELN WEGNEHMEN, nicht alles. */
    await seite.click("dialog.nachfrage .nachfrage__vorschau:nth-child(2) "
      + ".nachfrage__vorschau-weg");
    await seite.waitForTimeout(200);
    pruef(`  eines einzeln entfernen laesst die anderen stehen (${await zaehl()})`,
      await zaehl() === 2);

    await seite.fill("dialog.nachfrage #nachfrage-grund", "Hier zwei Bilder dazu.");
    await seite.click('dialog.nachfrage [data-teil="ja"]');
    await seite.waitForTimeout(400);
    const viele = await seite.evaluate(async () => {
      const a = await window.__probe4;
      return (a && Array.isArray(a.bilder)) ? a.bilder.map((b) => b.name) : null;
    });
    pruef(`  und der Dialog gibt beide zurueck (${(viele || []).join(", ")})`,
      Array.isArray(viele) && viele.length === 2
      && viele[0] === "a.png" && viele[1] === "c.png");

    /* ==== EIN DATUM UND EIN HAKEN (02.10.2026) ==================

       VanVan im Support, Meldung #6: „Bei den Vorlagen laesst sich
       weder die Frist anpassen noch ‚dauerhaft' einstellen, und eine
       Anmerkung fehlt auch." Die Anmerkung gab es hier schon
       (`grund`), die zwei anderen Felder nicht.

       SIE STEHEN IM GEMEINSAMEN FENSTER und nicht in
       vorlagenbrett.js -- sonst waere das der zweite Dialog im Haus,
       in dem Esc, Fokus und Abbruch von Hand nachgebaut werden
       muessten. */
    await seite.evaluate(() => {
      window.__probe5 = window.frageNach({
        titel: "Anpassen", ja: "Übernehmen",
        datum: "Frist", datumWert: "2030-05-17", datumMin: "2026-10-01",
        haken: "Dauerhafte Aufgabe", hakenHinweis: "Sie wird nicht abgehakt.",
        hakenSperrtDatum: true,
        grund: "Anmerkung (freiwillig)",
      });
    });
    await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
    const dh = await seite.evaluate(() => {
      const dlg = document.querySelector("dialog.nachfrage");
      const dfeld = dlg.querySelector("#nachfrage-datum");
      const hfeld = dlg.querySelector("#nachfrage-haken");
      const etikett = dlg.querySelector(".nachfrage__haken");
      return {
        datumDa: !dlg.querySelector('[data-teil="datumzeile"]').hidden,
        wert: dfeld.value, min: dfeld.min,
        hakenDa: !dlg.querySelector('[data-teil="hakenzeile"]').hidden,
        hakenAn: hfeld.checked,
        hinweis: dlg.querySelector('[data-teil="hakenhinweis"]').textContent,
        /* 44 Pixel, wie jeder Knopf im Haus -- und die Flaeche kommt
           vom Etikett, nicht vom Kaestchen. */
        etikettHoch: Math.round(etikett.getBoundingClientRect().height),
        kaestchen: Math.round(hfeld.getBoundingClientRect().width),
      };
    });
    pruef(`das Datumsfeld steht da, mit Vorgabe („${dh.wert}")`,
      dh.datumDa && dh.wert === "2030-05-17");
    pruef(`  und mit einer Untergrenze (${dh.min})`, dh.min === "2026-10-01");
    pruef(`der Haken steht da und ist aus (${dh.hakenAn})`,
      dh.hakenDa && dh.hakenAn === false);
    pruef(`  sein Etikett ist ${dh.etikettHoch} px hoch (Fingermass 44)`,
      dh.etikettHoch >= 44);
    /* EIN ANKREUZFELD UEBER DIE GANZE ZEILE sieht aus wie ein leeres
       Textfeld -- die Regel `.nachfrage__form input { width: 100% }`
       haette genau das gemacht. */
    pruef(`  und das Kaestchen ist ${dh.kaestchen} px breit, nicht die ganze Zeile`,
      dh.kaestchen > 10 && dh.kaestchen < 60);
    pruef(`  der Hinweis steht dabei („${dh.hinweis}")`, /nicht abgehakt/.test(dh.hinweis));

    /* DER HAKEN SPERRT DAS DATUM. Eine dauerhafte Aufgabe hat keine
       Frist -- ein Datum, das dasteht und nicht gilt, ist schlimmer
       als keins. */
    await seite.check("dialog.nachfrage #nachfrage-haken");
    await seite.waitForTimeout(150);
    const gesperrt = await seite.evaluate(() => {
      const dlg = document.querySelector("dialog.nachfrage");
      return {
        aus: dlg.querySelector("#nachfrage-datum").disabled,
        blass: parseFloat(getComputedStyle(
          dlg.querySelector('[data-teil="datumzeile"]')).opacity) < 1,
      };
    });
    pruef(`mit Haken wird das Datum gesperrt (${gesperrt.aus})`, gesperrt.aus === true);
    pruef("  und sieht auch gesperrt aus", gesperrt.blass === true);

    /* GEGENPROBE: Haken wieder weg -> das Datum geht wieder. Ohne sie
       koennte die Sperre dauerhaft sein und die Zeile oben waere
       trotzdem gruen. */
    await seite.uncheck("dialog.nachfrage #nachfrage-haken");
    await seite.waitForTimeout(150);
    pruef("Gegenprobe: ohne Haken geht das Datum wieder",
      (await seite.evaluate(() =>
        document.querySelector("dialog.nachfrage #nachfrage-datum").disabled)) === false);

    /* ==== EIN DATUM VOR DER UNTERGRENZE -- ZWEI SCHRANKEN =======

       Die erste ist das `min` am Feld: Der Datumswaehler bietet
       fruehere Tage gar nicht erst an, und der Browser laesst das
       Formular nicht abschicken. Das ist die freundlichere -- sie
       greift, bevor jemand etwas tippt.

       GEMESSEN WIRD, DASS SIE WIRKLICH GREIFT, nicht dass sie
       dasteht: `rangeUnderflow` sagt es, das Attribut allein nicht.
       Mein erster Anlauf erwartete hier den HAUSEIGENEN Fehlersatz
       und wurde rot -- zu Recht: Der Browser haelt das Formular
       vorher an, mein Handler laeuft gar nicht. Die Pruefung hatte
       recht, die Erwartung war falsch.

       DIE ZWEITE SCHRANKE steht im Skript und wird darunter einzeln
       geprueft -- mit abgenommenem `min`, sonst kaeme sie nie zum
       Zug. Zwei Schranken sind hier keine Dopplung: Die eine ist
       Bedienkomfort, die andere die Regel. Wer `min` morgen
       entfernt, hat immer noch die Regel. */
    await seite.fill("dialog.nachfrage #nachfrage-datum", "2020-01-01");
    await seite.click('dialog.nachfrage [data-teil="ja"]');
    await seite.waitForTimeout(250);
    const nochOffen = await seite.evaluate(() => {
      const f = document.querySelector("dialog.nachfrage #nachfrage-datum");
      return {
        offen: !!document.querySelector("dialog.nachfrage[open]"),
        zuFrueh: f.validity.rangeUnderflow,
      };
    });
    pruef(`ein Datum vor der Untergrenze haelt den Dialog auf (offen ${nochOffen.offen})`,
      nochOffen.offen === true);
    pruef(`  der Browser nennt es zu frueh (rangeUnderflow ${nochOffen.zuFrueh})`,
      nochOffen.zuFrueh === true);

    /* UND JETZT OHNE `min`: Nur so kommt die Regel im Skript dran. */
    await seite.evaluate(() =>
      document.querySelector("dialog.nachfrage #nachfrage-datum").removeAttribute("min"));
    await seite.click('dialog.nachfrage [data-teil="ja"]');
    await seite.waitForTimeout(250);
    const eigene = await seite.evaluate(() => ({
      offen: !!document.querySelector("dialog.nachfrage[open]"),
      fehler: document.querySelector('dialog.nachfrage [data-teil="fehler"]')?.textContent || "",
    }));
    pruef(`ohne Untergrenze faengt es das Skript ab („${eigene.fehler}")`,
      eigene.offen && /Vergangenheit/.test(eigene.fehler));

    await seite.fill("dialog.nachfrage #nachfrage-datum", "2030-06-01");
    await seite.check("dialog.nachfrage #nachfrage-haken");
    await seite.fill("dialog.nachfrage #nachfrage-grund", "Ein Wort dazu.");
    await seite.click('dialog.nachfrage [data-teil="ja"]');
    await seite.waitForTimeout(400);
    const erg5 = await seite.evaluate(async () => {
      const a = await window.__probe5;
      return a === false ? null : { datum: a.datum, haken: a.haken, grund: a.grund };
    });
    pruef(`der Dialog gibt den Haken zurueck (${erg5?.haken})`, erg5?.haken === true);
    /* UND DAS DATUM IST LEER, weil der Haken es gesperrt hat. Haette
       es den Wert behalten, schickte der Browser etwas mit, das der
       Server wegwirft -- und beim naechsten Lesen stuende in der
       Antwort etwas anderes als in der Datenbank. */
    pruef(`  und das gesperrte Datum kommt LEER zurueck („${erg5?.datum}")`,
      erg5?.datum === "");
    pruef(`  die Anmerkung kommt mit („${erg5?.grund}")`, erg5?.grund === "Ein Wort dazu.");
  }

  pruef("keine Abst\u00fcrze im Browser", abstuerze.length === 0, abstuerze[0] || "");

  await browser.close();
  try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
}

console.log(`\n  ${ok} bestanden, ${fehl} fehlgeschlagen`);
console.log(`  (${gezaehlt} Rückfragen in ${nutzer.size} Dateien, `
  + `${mitNutzung} Seiten)\n`);
process.exit(fehl ? 1 : 0);