dogfather-universe/server/pruef-support.mjs

/* =====================================================================
   DER SUPPORT (24.09.2026)

   Filipe: „da fehlt auch eine support kachel. die jeder sieht. jeder
   benutzen kann. jeder kann da probleme von der seite melden und
   hinweisen. fotos mit schicken mit einem text. … also bei dogfather
   und der rechten hand soll die kachel anders gebaut sein weil die
   sind die die sich um die probleme kümmern."

   GEPRUEFT WIRD, WAS ER BESTELLT HAT — und drei Dinge, die er nicht
   bestellt hat, weil sie sonst niemandem auffallen:

     * JEDE Rolle sieht die Kachel und kommt auf die Seite. Nicht vier
       von acht -- genau daran ist heute der Benachrichtigungs-Knopf
       gescheitert.
     * Eine fremde Meldung bleibt fremd. Wer meldet, sieht seine
       eigene; alles andere gehoert der Leitung.
     * Eine als Bild getarnte HTML-Datei kommt nicht herein. Das ist
       der Standardfehler bei selbstgebauten Uploads und von aussen
       nicht zu sehen.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-sup-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");

import { notbremse } from "./helfer-notbremse.mjs";
const { eigenerPort } = await import("./helfer-port.mjs");
const PORT = await eigenerPort(import.meta, "die Supportpruefung");

process.env.PORT = `${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 }); };
await import("./index.js");
notbremse(240_000, "pruef-support");
await new Promise((r) => setTimeout(r, 900));
const BASIS = `http://127.0.0.1:${PORT}`;

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

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 kennSchluessel = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
  + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
  .run("code_kennung_schluessel", kennSchluessel, 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", kennSchluessel).update(code).digest("hex"), jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}

/* ALLE ACHT ROLLEN. „Die jeder sieht" heisst jede -- und die Liste
   steht hier vollstaendig, damit eine fehlende auffaellt. */
const ROLLEN = [
  ["admin", "Filipe"], ["hand", "VanVan"], ["linke", "Funny"],
  ["modi", "Miss"], ["spicy", "Spicy Media"], ["manager", "Patrick"],
  ["scout", "Kevin"], ["creator", "Luna"], ["gast", "Community-Mitglied"],
];
const CODES = {};
for (const [i, [rolle, name]] of ROLLEN.entries()) {
  CODES[rolle] = `CODE-S${String(i).padStart(2, "0")}-000001`;
  anlegen(name, rolle, CODES[rolle]);
}
d.close();

/* ---------- Anmelden ohne Browser ------------------------------------
   Die Sitzung kommt aus einem echten Anmelde-Aufruf; danach reist sie
   als Keks mit. Ein Browser waere hier Aufwand ohne Gewinn -- geprueft
   werden Wege, nicht Aussehen. */
/* DIE COMMUNITY KOMMT NUR AUF EINER ADRESSE HEREIN (gemessen, nicht
   geraten): `crew.dogfather-universe.com`. Auf 127.0.0.1 antwortet
   die Anmeldung mit 401 -- beim ersten Lauf stand deshalb
   "gast: kommt nicht herein", und das sah aus wie ein schwerer
   Befund am Support. Es war einer an meiner Messung.

   Versucht wird zuerst ohne Host, dann mit -- so faellt auch auf,
   wenn eine Rolle PLOETZLICH einen braucht. */
const CREW_HOST = "crew.dogfather-universe.com";

/* ZWEI DINGE, DIE ICH ERST NACH DREI FEHLLAEUFEN GEMESSEN HABE --
   beide stehen in pruef-treff.mjs, das sie seit dem 15.09. richtig
   macht:

   1. `fetch` VERWIRFT DEN Host-KOPF. Er steht auf der Liste der
      verbotenen Kopfzeilen; Node setzt stattdessen die Adresse des
      Ziels. Wer eine Hausadresse braucht, muss node:http nehmen.
   2. DIE COMMUNITY BESTAETIGT IHR ALTER (`alter_ok`). Ohne das Feld
      antwortet die Anmeldung mit 401 -- und das sah aus wie ein
      Zugangsproblem am Support.

   Beim ersten Lauf stand deshalb dreimal rot, und kein einziges Mal
   lag es am Support. */
const { request } = await import("node:http");
function roh(pfad, host, koerper) {
  return new Promise((fertig, schief) => {
    const daten = koerper ? JSON.stringify(koerper) : null;
    const a = request({
      host: "127.0.0.1", port: PORT, path: pfad,
      method: daten ? "POST" : "GET",
      headers: {
        ...(host ? { Host: host } : {}),
        Origin: host ? `https://${host}` : BASIS,
        ...(daten ? { "Content-Type": "application/json",
          "Content-Length": Buffer.byteLength(daten) } : {}),
      },
    }, (antwort) => {
      let text = "";
      antwort.on("data", (t) => { text += t; });
      antwort.on("end", () => fertig({
        code: antwort.statusCode, kopf: antwort.headers, text,
      }));
    });
    a.on("error", schief);
    if (daten) a.write(daten);
    a.end();
  });
}

async function anmeldeVersuch(rolle, host) {
  const r = await roh("/workspace/api/anmelden", host,
    rolle === "gast"
      ? { rolle, code: CODES[rolle], alter_ok: true }
      : { rolle, code: CODES[rolle] });
  if (r.code !== 200) return null;
  const keks = [].concat(r.kopf["set-cookie"] || [])
    .map((z) => z.split(";")[0]).join("; ");
  return keks || null;
}
const HOST_FUER = {};
async function anmelden(rolle) {
  const ohne = await anmeldeVersuch(rolle, null);
  if (ohne) { HOST_FUER[rolle] = null; return ohne; }
  const mit = await anmeldeVersuch(rolle, CREW_HOST);
  if (mit) { HOST_FUER[rolle] = CREW_HOST; return mit; }
  return null;
}

/** Ein winziges, gueltiges PNG (1x1, schwarz) -- echte Kopfbytes,
 *  damit die Erkennung wirklich etwas zu erkennen hat. */
const PNG = Buffer.from(
  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk"
  + "YPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==", "base64");

/** Noch zwei Bilder -- und zwar mit ABSICHTLICH VERSCHIEDENEN LAENGEN
 *  (gemessen: PNG 70, GIF 42, WebP 34 Bytes).
 *
 *  Drei gleich lange Bilder wuerden die Zerlegung des Rumpfes nicht
 *  pruefen: Waere die Reihenfolge der Laengen vertauscht oder die
 *  Schnittstelle um ein Byte verschoben, kaeme trotzdem etwas
 *  Bildaehnliches heraus. Mit 70/42/34 faellt jeder Fehlschnitt auf,
 *  weil das Ergebnis dann weder erkannt wird noch die richtige Zahl
 *  Bytes hat. Drei verschiedene Formate pruefen nebenbei, dass der
 *  Typ je Bild aus SEINEN Kopfbytes kommt und nicht aus dem
 *  Content-Type der ganzen Anfrage. */
const GIF = Buffer.from("R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7", "base64");
const WEBP = Buffer.from("UklGRhoAAABXRUJQVlA4TA0AAAAvAAAAEAcQERGIiP4HAA==", "base64");

const kekse = {};
melde("\n=== Alle neun Rollen kommen herein ===");
for (const [rolle] of ROLLEN) {
  kekse[rolle] = await anmelden(rolle);
  ok(!!kekse[rolle], `${rolle}: angemeldet`);
}

/* Fuer Rollen OHNE Hausadresse genuegt fetch -- es ist kuerzer und
   kann Buffer als Rumpf. Wer eine Adresse braucht, geht ueber
   node:http (siehe oben, `fetch` verwirft den Host-Kopf). */
async function hol(rolle, pfad, einst = {}) {
  if (HOST_FUER[rolle]) {
    const r = await rohMitKeks(rolle, pfad, einst);
    return r;
  }
  return fetch(BASIS + pfad, {
    ...einst,
    headers: { Cookie: kekse[rolle] || "", Origin: BASIS, ...(einst.headers || {}) },
  });
}

/** Derselbe Aufruf ueber node:http -- mit Hausadresse und Sitzung.
 *  Gibt etwas zurueck, das sich wie eine fetch-Antwort benutzen
 *  laesst: `status`, `ok`, `json()`, `headers.get()`. */
function rohMitKeks(rolle, pfad, einst = {}) {
  return new Promise((fertig, schief) => {
    const rumpf = einst.body === undefined ? null
      : (Buffer.isBuffer(einst.body) ? einst.body : Buffer.from(String(einst.body)));
    const a = request({
      host: "127.0.0.1", port: PORT, path: pfad,
      method: einst.method || "GET",
      headers: {
        Host: HOST_FUER[rolle],
        Origin: `https://${HOST_FUER[rolle]}`,
        Cookie: kekse[rolle] || "",
        ...(rumpf ? { "Content-Length": rumpf.length } : {}),
        ...(einst.headers || {}),
      },
    }, (antwort) => {
      const teile = [];
      antwort.on("data", (t) => teile.push(t));
      antwort.on("end", () => {
        const text = Buffer.concat(teile).toString("utf8");
        fertig({
          status: antwort.statusCode,
          ok: antwort.statusCode >= 200 && antwort.statusCode < 300,
          headers: { get: (n) => antwort.headers[String(n).toLowerCase()] || null },
          json: async () => JSON.parse(text),
          text: async () => text,
        });
      });
    });
    a.on("error", schief);
    if (rumpf) a.write(rumpf);
    a.end();
  });
}

/* =====================================================================
   1. DIE KACHEL SIEHT JEDER
   ===================================================================== */
melde("\n=== Die Kachel steht bei jeder Rolle ===");
{
  const ohne = [];
  for (const [rolle] of ROLLEN) {
    /* DIE ROUTE HEISST /api/ich, nicht /api/start. Beim ersten Lauf
       stand hier ein erfundener Name, und alle neun Rollen meldeten
       "Kachel fehlt (HTTP 404)" -- ein Messfehler, der wie ein
       Totalausfall aussah. */
    const a = await hol(rolle, "/workspace/api/ich");
    if (!a.ok) { ohne.push(`${rolle} (HTTP ${a.status})`); continue; }
    const r = await a.json();
    /* `bereiche` ist null, wenn die Oberflaeche ihre eigene Liste
       nimmt -- dann steht die Kachel in assets/js/bereiche.js und
       wird eine Pruefung weiter unten geprueft. */
    if (r.bereiche === null) { ohne.push(`${rolle} (eigene Liste im Browser)`); continue; }
    const da = (r.bereiche || []).some((k) => k?.ziel === "support.html");
    if (!da) ohne.push(rolle);
  }
  /* DIE AGENTUR-ROLLEN bekommen `bereiche: null` und ihre Liste aus
     dem Browser. Das ist kein Mangel, aber es muss genannt werden --
     sonst sieht "alle haben sie" gruen aus, obwohl vier gar nicht
     geprueft wurden. */
  const ausBrowser = ohne.filter((x) => x.includes("eigene Liste"));
  const echtOhne = ohne.filter((x) => !x.includes("eigene Liste"));
  ok(echtOhne.length === 0,
    "jede Rolle mit Server-Liste hat die Support-Kachel"
    + (echtOhne.length ? ` -- FEHLT bei: ${echtOhne.join(", ")}` : ""));
  melde(`       (${ausBrowser.length} Rollen nehmen ihre Liste aus dem Browser)`);

  /* UND DIE BROWSER-LISTE AUCH. Ohne diese Zeile waere die Haelfte
     der Rollen ungeprueft -- und genau dort hat heute schon einmal
     etwas gefehlt. */
  const { readFileSync } = await import("node:fs");
  const { fileURLToPath } = await import("node:url");
  const bereicheJs = readFileSync(fileURLToPath(
    new URL("../workspace/assets/js/bereiche.js", import.meta.url)), "utf8");
  ok(/ziel:\s*'support\.html'/.test(bereicheJs),
    "auch die Kachelliste im Browser kennt den Support");
}

/* =====================================================================
   2. AUF DIE SEITE DARF JEDER
   ===================================================================== */
melde("\n=== Die Seite ist fuer jede Rolle offen ===");
{
  const zu = [];
  for (const [rolle] of ROLLEN) {
    const a = await hol(rolle, "/workspace/support.html", { redirect: "manual" });
    if (a.status !== 200) zu.push(`${rolle}=${a.status}`);
  }
  ok(zu.length === 0,
    "support.html antwortet jeder Rolle mit 200"
    + (zu.length ? ` -- nicht bei: ${zu.join(", ")}` : ""));
}

/* =====================================================================
   3. MELDEN — mit Text, mit Bild, und was nicht geht
   ===================================================================== */
melde("\n=== Melden ===");
let meldungMitBild = 0;
let bildWeg = "";
{
  /* Ohne Text geht nichts -- sonst stehen leere Zeilen im Eingang. */
  const leer = await hol("creator", "/workspace/api/support", {
    method: "POST", headers: { "x-text": encodeURIComponent("hm") },
  });
  ok(leer.status === 400, `ein Wort reicht nicht (${leer.status})`);

  const nurText = await hol("creator", "/workspace/api/support", {
    method: "POST",
    headers: { "x-text": encodeURIComponent("Der Haken auf der Aufgabenseite geht nicht.") },
  });
  ok(nurText.status === 201, `Text allein genuegt (${nurText.status})`);

  const mitBild = await hol("modi", "/workspace/api/support", {
    method: "POST",
    headers: {
      "x-text": encodeURIComponent("Hier stimmt die Farbe nicht, siehe Bild."),
      "x-seite": "/workspace/chat.html",
      "Content-Type": "application/octet-stream",
    },
    body: PNG,
  });
  ok(mitBild.status === 201, `mit Bild geht auch (${mitBild.status})`);
  if (mitBild.status === 201) {
    const j = await mitBild.json();
    meldungMitBild = j.meldung?.id || 0;
    bildWeg = j.meldung?.bilder?.[0]?.weg || "";
    /* EINE LISTE, AUCH BEI EINEM BILD (02.10.2026). Vorher stand hier
       `j.meldung.bild` -- ein Feld fuer genau eines. Seit VanVans
       Meldung #11 sind es bis zu drei, und ein Sonderfall „genau
       eines" waere die zweite Auskunft auf dieselbe Frage. */
    ok(Array.isArray(j.meldung?.bilder) && j.meldung.bilder.length === 1,
      `und die Antwort nennt genau ein Bild (${j.meldung?.bilder?.length})`);
    ok(/^\/workspace\/api\/support\/\d+\/bild\/\d+$/.test(bildWeg),
      `  mit seiner eigenen Nummer im Weg (${bildWeg})`);
  } else { ok(false, "kein Bild in der Antwort"); ok(false, "kein Weg zum Bild"); }

  /* DER STANDARDFEHLER BEI UPLOADS: eine HTML-Datei mit Bildnamen.
     Sie liefe im Browser als Seite DIESER Domain, mit Zugriff auf die
     Sitzung des Empfaengers. */
  const getarnt = await hol("scout", "/workspace/api/support", {
    method: "POST",
    headers: {
      "x-text": encodeURIComponent("Test mit einer getarnten Datei."),
      "Content-Type": "image/png",
    },
    body: Buffer.from("<html><script>alert(1)</script></html>"),
  });
  ok(getarnt.status === 415,
    `als Bild getarntes HTML wird abgelehnt (${getarnt.status})`);

  /* Und ein PDF ebenfalls -- dateiErkennen kennt es, der Support
     will es nicht. */
  const pdf = await hol("scout", "/workspace/api/support", {
    method: "POST",
    headers: {
      "x-text": encodeURIComponent("Test mit einem PDF im Anhang."),
      "Content-Type": "application/pdf",
    },
    body: Buffer.concat([Buffer.from("%PDF-1.4\n"), Buffer.alloc(64, 0x20)]),
  });
  ok(pdf.status === 415, `ein PDF ist kein Foto (${pdf.status})`);
}

/* =====================================================================
   4. WER SIEHT WAS
   ===================================================================== */
melde("\n=== Wer sieht was ===");
{
  const alsCreator = await (await hol("creator", "/workspace/api/support")).json();
  ok(alsCreator.leitung === false, "ein Creator ist nicht die Leitung");
  ok(alsCreator.meldungen.length === 1,
    `und sieht genau seine eigene (${alsCreator.meldungen.length})`);

  const alsModi = await (await hol("modi", "/workspace/api/support")).json();
  ok(alsModi.meldungen.length === 1 && alsModi.meldungen[0].id === meldungMitBild,
    "ein Modi sieht seine eigene und nicht die des Creators");

  for (const rolle of ["admin", "hand"]) {
    const r = await (await hol(rolle, "/workspace/api/support")).json();
    ok(r.leitung === true && r.meldungen.length >= 2,
      `${rolle} sieht alle (${r.meldungen.length})`);
  }
  for (const rolle of ["linke", "modi", "spicy", "manager", "scout", "creator", "gast"]) {
    const r = await (await hol(rolle, "/workspace/api/support")).json();
    ok(r.leitung !== true, `${rolle} ist NICHT die Leitung`);
  }

  /* DAS BILD EINER FREMDEN MELDUNG bleibt fremd. */
  const fremd = await hol("creator", bildWeg);
  ok(fremd.status === 404,
    `das Bild einer fremden Meldung gibt es fuer andere nicht (${fremd.status})`);

  const eigen = await hol("modi", bildWeg);
  ok(eigen.status === 200, `der Melder sieht sein eigenes Bild (${eigen.status})`);
  ok(eigen.headers.get("content-type") === "image/png",
    `ausgeliefert wird der ERKANNTE Typ (${eigen.headers.get("content-type")})`);
  ok((eigen.headers.get("x-content-type-options") || "") === "nosniff",
    "mit nosniff");
  ok(/sandbox/.test(eigen.headers.get("content-security-policy") || ""),
    "und einer Richtlinie, die jede Ausfuehrung nimmt");

  const leitungSieht = await hol("hand", bildWeg);
  ok(leitungSieht.status === 200, "die Leitung sieht es auch");

  /* ==== DIE MELDUNGSNUMMER IM WEG IST DIE SICHTBARKEITSFRAGE =======

     Der Weg lautet `/support/<meldung>/bild/<bild>`, und die
     Bildnummer allein waere eindeutig. Trotzdem muss BEIDES
     zusammenpassen -- sonst koennte man die eigene Meldungsnummer
     vorn hinschreiben und hinten die Bildnummer einer fremden
     durchprobieren. Gegenprobe: derselbe Bildweg, aber eine andere
     Meldung davor. */
  const bildNr = Number((bildWeg.match(/\/bild\/(\d+)$/) || [])[1] || 0);
  const vertauscht = await hol("modi",
    `/workspace/api/support/${meldungMitBild + 1}/bild/${bildNr}`);
  ok(bildNr > 0 && vertauscht.status === 404,
    `eine fremde Meldungsnummer vor der eigenen Bildnummer gibt 404 (${vertauscht.status})`);
}

/* =====================================================================
   5. SICH KUEMMERN
   ===================================================================== */
melde("\n=== Sich kuemmern ===");
{
  /* Wer nicht Leitung ist, kann nichts aendern -- 404 und nicht 403:
     Wer keine Zustaendigkeit hat, soll nicht erfahren, dass es sie
     gibt. */
  const versuch = await hol("creator", `/workspace/api/support/${meldungMitBild}`, {
    method: "PATCH",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ stand: "erledigt", antwort: "einfach mal zu" }),
  });
  ok(versuch.status === 404, `ein Creator kann nichts erledigen (${versuch.status})`);

  const dran = await hol("hand", `/workspace/api/support/${meldungMitBild}`, {
    method: "PATCH",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ stand: "in_arbeit" }),
  });
  ok(dran.status === 200, `die rechte Hand uebernimmt (${dran.status})`);

  /* ZUMACHEN OHNE SATZ GEHT NICHT. Der Melder sieht nur diesen Satz. */
  const ohneSatz = await hol("hand", `/workspace/api/support/${meldungMitBild}`, {
    method: "PATCH",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ stand: "erledigt" }),
  });
  ok(ohneSatz.status === 400, `erledigen ohne Satz wird abgelehnt (${ohneSatz.status})`);

  const zu = await hol("hand", `/workspace/api/support/${meldungMitBild}`, {
    method: "PATCH",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ stand: "erledigt", antwort: "Behoben, die Farbe stimmt wieder." }),
  });
  ok(zu.status === 200, `mit Satz geht es (${zu.status})`);

  /* =====================================================================
     DER MELDER HAT DAS LETZTE WORT (25.09.2026)
     =====================================================================

     Filipe: „ich will dass die leute die mir was geschickt haben im
     support, auch meine notiz bekommen wenn ich fertig bin. damit die
     bescheid wissen und dan anklicken koennen, es funktioniert, oder
     noch nicht. und erst wenn es funktioniert gedrueckt wird, will ich
     dass alles richtig fertig ist. perfektionier den ganzen weg und
     mit dem gedanken das manchmal sachen mehrmal nicht sofort perfekt
     sein werden."

     HIER STAND, dass „erledigt" die Meldung zumacht und der Melder
     danach Stand und Antwort sieht. Das war richtig -- und ist es seit
     heute nicht mehr: „erledigt" schickt sie ZUERST an den Melder.
     Erst sein Druck schliesst.

     GEMESSEN WIRD DER GANZE WEG, einmal durch, mit einer Runde, die
     schiefgeht -- genau der Fall, den Filipe ausdruecklich genannt
     hat („manchmal ... nicht sofort perfekt"). Eine Pruefung, die nur
     den glatten Weg kennt, misst die Haelfte.
     ===================================================================== */
  const standVon = async (wer, id) => {
    const d = await (await hol(wer, "/workspace/api/support")).json();
    return (d.meldungen || []).find((m) => m.id === id) || null;
  };

  {
    /* ---- Runde 1: die Leitung sagt „behoben" ---------------------- */
    const nach1 = await standVon("modi", meldungMitBild);
    ok(nach1?.stand === "wartet",
      `„erledigt" schickt die Meldung zuerst an den Melder (${nach1?.stand})`);
    ok(/Behoben/.test(nach1?.antwort || "") && nach1?.darf_bestaetigen === true,
      `er sieht die Notiz und darf bestaetigen (${nach1?.darf_bestaetigen})`);

    /* UND DIE LEITUNG SIEHT DIESE KNOEPFE NICHT. Im ersten Anlauf tat
       sie es: Der Server lehnte sie richtig mit 404 ab, die Karte bot
       ihr die Knöpfe trotzdem an -- `darf_bestaetigen` war eine
       Aussage ueber die Meldung statt ueber den Betrachter. Gefunden
       hat das kein Test, sondern ein Bildschirmfoto. Ab jetzt findet
       es der Test. */
    const beiDerLeitung = await standVon("hand", meldungMitBild);
    ok(beiDerLeitung?.darf_bestaetigen === false,
      `die Leitung bekommt diese Knoepfe NICHT (${beiDerLeitung?.darf_bestaetigen})`);
    ok((nach1?.verlauf || []).length === 1 && nach1.verlauf[0].nr === 1,
      `und der Verlauf hat Runde 1 (${(nach1?.verlauf || []).length})`);

    /* GEGENPROBE: Die Leitung darf NICHT fuer ihn bestaetigen. Ohne
       diese Zeile koennte sie ihre eigene Arbeit abnicken, und der
       ganze Umweg waere Zierde. */
    const fremd = await hol("hand", `/workspace/api/support/${meldungMitBild}/rueckmeldung`, {
      method: "POST", headers: { "x-geht": "ja" },
    });
    ok(fremd.status === 404,
      `Gegenprobe: die Leitung bestaetigt nicht fuer den Melder (${fremd.status})`);

    /* ---- NACHLEGEN ERSETZT, ES VERDOPPELT NICHT ------------------

       Der Leitung faellt hinterher noch etwas ein, waehrend die
       Meldung schon beim Melder liegt. Ohne ON CONFLICT entstuende
       eine ZWEITE Zeile „Runde 1", und sein spaeteres Urteil traefe
       beide gleichzeitig -- der Verlauf zeigte dasselbe Urteil unter
       zwei verschiedenen Antworten. */
    const nachgelegt = await hol("hand", `/workspace/api/support/${meldungMitBild}`, {
      method: "PATCH", headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ stand: "erledigt", antwort: "Behoben – und der Rand stimmt auch wieder." }),
    });
    ok(nachgelegt.status === 200, `die Leitung legt noch etwas nach (${nachgelegt.status})`);

    const nachNachtrag = await standVon("modi", meldungMitBild);
    ok((nachNachtrag?.verlauf || []).length === 1,
      `der Verlauf hat immer noch EINE Runde (${(nachNachtrag?.verlauf || []).length})`);
    ok(/Rand stimmt/.test((nachNachtrag?.verlauf || [])[0]?.antwort || ""),
      "und darin steht der neue Satz, nicht der alte");
    ok(nachNachtrag?.stand === "wartet",
      `die Meldung liegt weiter beim Melder (${nachNachtrag?.stand})`);

    /* ---- „Noch nicht" -- und ohne Wort geht das nicht ------------- */
    const ohneWort = await hol("modi", `/workspace/api/support/${meldungMitBild}/rueckmeldung`, {
      method: "POST", headers: { "x-geht": "nein" },
    });
    ok(ohneWort.status === 400,
      `„noch nicht" ohne Wort wird abgelehnt (${ohneWort.status})`);

    const zurueck = await hol("modi", `/workspace/api/support/${meldungMitBild}/rueckmeldung`, {
      method: "POST",
      headers: { "x-geht": "nein",
        "x-text": encodeURIComponent("Die Farbe ja, das Datum nicht.") },
    });
    ok(zurueck.status === 200, `mit Wort geht es zurueck (${zurueck.status})`);

    const nach2 = await standVon("hand", meldungMitBild);
    ok(nach2?.stand === "in_arbeit" && nach2?.runde === 2,
      `die Meldung ist wieder in Arbeit, Runde 2 (${nach2?.stand}, ${nach2?.runde})`);
    ok((nach2?.verlauf || [])[0]?.urteil === "nicht"
       && /Datum/.test((nach2?.verlauf || [])[0]?.urteil_text || ""),
      `und Runde 1 traegt sein Urteil (${(nach2?.verlauf || [])[0]?.urteil})`);

    /* ---- Runde 2: diesmal klappt es ------------------------------- */
    const zu2 = await hol("hand", `/workspace/api/support/${meldungMitBild}`, {
      method: "PATCH", headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ stand: "erledigt", antwort: "Das Datum stimmt jetzt auch." }),
    });
    ok(zu2.status === 200, `die Leitung antwortet ein zweites Mal (${zu2.status})`);

    const bestaetigt = await hol("modi", `/workspace/api/support/${meldungMitBild}/rueckmeldung`, {
      method: "POST", headers: { "x-geht": "ja" },
    });
    ok(bestaetigt.status === 200, `der Melder bestaetigt (${bestaetigt.status})`);

    const ende = await standVon("modi", meldungMitBild);
    ok(ende?.stand === "erledigt",
      `ERST JETZT ist die Meldung erledigt (${ende?.stand})`);
    ok((ende?.verlauf || []).length === 2,
      `und der ganze Weg steht da -- beide Runden (${(ende?.verlauf || []).length})`);
    ok((ende?.verlauf || [])[1]?.urteil === "geht",
      `  mit „geht" an der letzten (${(ende?.verlauf || [])[1]?.urteil})`);

    /* ERLEDIGT IST ERLEDIGT -- auch fuer die Leitung. */
    const nochmal = await hol("admin", `/workspace/api/support/${meldungMitBild}`, {
      method: "PATCH",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ stand: "in_arbeit", antwort: "doch nicht" }),
    });
    ok(nochmal.status === 409,
      `eine erledigte Meldung wird nicht wieder geoeffnet (${nochmal.status})`);

    /* UND AUCH DER MELDER KANN NICHT NOCHMAL. Ohne diese Zeile liesse
       sich eine geschlossene Sache durch ein zweites „noch nicht"
       wieder aufmachen -- „zugemacht" waere dann eine Meinung. */
    const nochmal2 = await hol("modi", `/workspace/api/support/${meldungMitBild}/rueckmeldung`, {
      method: "POST",
      headers: { "x-geht": "nein", "x-text": encodeURIComponent("doch nicht") },
    });
    ok(nochmal2.status === 409,
      `  und der Melder kann sie auch nicht wieder aufmachen (${nochmal2.status})`);
  }

  /* ===================================================================
     EIN BILD ZUR ANTWORT (02.10.2026)

     VanVan: „Wenn man hier im Support auf deine Frage 'geht es wieder'
     reagiert und antwortet, kann man auch kein Bild hinzufuegen. Das
     muesstest du auch noch hinzufuegen, damit man nochmal ein Bild
     anhaengen kann, wenn das Problem noch besteht oder sich durch die
     Aenderung ein neues Problem ergeben hat."

     Beim MELDEN gab es ein Bild von Anfang an, beim ANTWORTEN nicht.

     GEPRUEFT WIRD AN EINER NEUEN MELDUNG, nicht an der von oben: Die
     ist erledigt und nimmt keine Antwort mehr an -- eine Pruefung, die
     das uebersieht, misst eine 409 und haelt sie fuer einen Befund.
     =================================================================== */
  melde("\n=== Ein Bild zur Antwort ===");
  {
    const neu = await hol("modi", "/workspace/api/support", {
      method: "POST",
      headers: { "Content-Type": "text/plain",
        "x-text": encodeURIComponent("Die Liste springt beim Scrollen.") },
    });
    /* Das Feld heisst  -- nachgesehen, nicht geraten.
       Mein erster Anlauf fragte  und bekam ; die
       Meldung war 201, der Fehler war meiner. */
    const neuId = (await neu.json())?.meldung?.id;
    ok(neu.status === 201 && Number.isInteger(neuId),
      `eine frische Meldung (${neu.status}, #${neuId})`);

    await hol("hand", `/workspace/api/support/${neuId}`, {
      method: "PATCH", headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ stand: "erledigt", antwort: "Probier es nochmal." }),
    });

    /* ---- Mit Bild zurueckgeben ----------------------------------- */
    const mitBild = await hol("modi", `/workspace/api/support/${neuId}/rueckmeldung`, {
      method: "POST",
      headers: { "Content-Type": "image/png", "x-geht": "nein",
        "x-text": encodeURIComponent("Jetzt springt sie nach oben – siehe Bild.") },
      body: PNG,
    });
    ok(mitBild.status === 200, `die Antwort geht mit Bild durch (${mitBild.status})`);

    const stand = await standVon("modi", neuId);
    const r1 = (stand?.verlauf || [])[0];
    const r1weg = r1?.bilder?.[0]?.weg || "";
    ok((r1?.bilder || []).length === 1,
      `im Verlauf haengt das Bild an Runde ${r1?.nr} (${(r1?.bilder || []).length})`);
    /* AN DER RUNDE UND NICHT AN DER MELDUNG. Sonst waere nach drei
       Runden nicht mehr zu sehen, welches Bild zu welchem Versuch
       gehoerte.
       SEIT DEM 02.10. STEHT DAS NICHT MEHR IM WEG (die Adresse nennt
       nur noch die Bildnummer), also wird es dort geprueft, wo es
       jetzt steht: Die Meldung selbst hat KEIN Bild bekommen. Das
       ist die staerkere Pruefung -- sie misst die Zuordnung in den
       Daten statt eine Zeichenkette. */
    ok((stand?.bilder || []).length === 0,
      `  und NICHT oben an der Meldung (${(stand?.bilder || []).length} dort)`);
    ok(/noch nicht|nicht/.test(r1?.urteil || ""), `  das Urteil steht dabei (${r1?.urteil})`);
    ok(/springt sie nach oben/.test(r1?.urteil_text || ""),
      `  und der Text kam durch den Kopf heil an („${r1?.urteil_text}")`);

    /* ---- Das Bild kommt auch heraus ------------------------------ */
    const holen = await hol("modi", r1weg);
    const bytes = Buffer.from(await holen.arrayBuffer());
    ok(holen.status === 200 && bytes.length === PNG.length,
      `der Melder bekommt es wieder (HTTP ${holen.status}, ${bytes.length} von ${PNG.length} Bytes)`);
    ok(holen.headers.get("content-type") === "image/png",
      `mit dem erkannten Typ (${holen.headers.get("content-type")})`);
    /* Es geht ueber denselben Ausliefer-Weg wie alles andere seit
       heute frueh -- also mit Teilanfragen. */
    ok(holen.headers.get("accept-ranges") === "bytes",
      "und ueber den gemeinsamen Ausliefer-Weg (Accept-Ranges)");

    const auchLeitung = await hol("hand", r1weg);
    ok(auchLeitung.status === 200,
      `die Leitung sieht es auch (${auchLeitung.status}) — sie soll ja darauf schauen`);

    /* ---- GEGENPROBEN ---------------------------------------------- */
    const fremder = await hol("gast", r1weg);
    ok(fremder.status === 404,
      `ein Fremder bekommt 404 (${fremder.status}) — nicht 403, sonst waere die Nummer verraten`);

    const ohneAnmeldung = await fetch(BASIS + r1weg);
    ok(ohneAnmeldung.status !== 200,
      `ohne Anmeldung gar nichts (${ohneAnmeldung.status})`);

    /* EINE BILDNUMMER, DIE ES NICHT GIBT. Vorher stand hier
       „eine Runde ohne Bild" -- die Route dazu gibt es seit dem
       02.10. nicht mehr, weil Bilder jetzt ihre eigene Nummer haben.
       Gefragt wird dieselbe Sache an der neuen Tuer. */
    const gibtsNicht = await hol("modi", `/workspace/api/support/${neuId}/bild/999999`);
    ok(gibtsNicht.status === 404, `eine erfundene Bildnummer gibt 404 (${gibtsNicht.status})`);

    /* KEIN BILD IST WEITERHIN ERLAUBT -- ein Bildschirmfoto ist Hilfe,
       keine Huerde. Ohne diese Zeile koennte die Pflicht hereinrutschen,
       ohne dass es jemandem auffaellt. */
    await hol("hand", `/workspace/api/support/${neuId}`, {
      method: "PATCH", headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ stand: "erledigt", antwort: "Und jetzt?" }),
    });
    const ohneBild = await hol("modi", `/workspace/api/support/${neuId}/rueckmeldung`, {
      method: "POST",
      headers: { "x-geht": "nein", "x-text": encodeURIComponent("Immer noch nicht.") },
    });
    ok(ohneBild.status === 200, `ohne Bild geht es genauso (${ohneBild.status})`);

    /* UND NUR BILDER. Eine PDF im Bildfeld waere eine Tuer, nach der
       niemand gefragt hat -- dieselbe Absage wie beim Melden. */
    await hol("hand", `/workspace/api/support/${neuId}`, {
      method: "PATCH", headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ stand: "erledigt", antwort: "Und nun?" }),
    });
    const alsPdf = await hol("modi", `/workspace/api/support/${neuId}/rueckmeldung`, {
      method: "POST",
      headers: { "Content-Type": "application/pdf", "x-geht": "nein",
        "x-text": encodeURIComponent("Hier ein PDF.") },
      body: Buffer.from("%PDF-1.4\n%%EOF\n"),
    });
    ok(alsPdf.status === 415, `eine PDF wird abgelehnt (${alsPdf.status})`);
  }
}

/* =====================================================================
   5b. MEHRERE BILDER JE MELDUNG (02.10.2026)
   =====================================================================

   VanVan im Support, Meldung #11 -- VIERMAL gemeldet: „Hier im
   Supportbereich kann man immer nur ein Bild hinzufuegen bei einer
   Meldung. 2-3 waeren besser." Und in Runde 2 der Grund, warum der
   erste Anlauf nicht reichte: „wenn man es nacheinander versucht
   hinzuzufuegen wird das Bild immer nur ersetzt."

   DREI VERSCHIEDENE FORMATE MIT DREI VERSCHIEDENEN LAENGEN (PNG 70,
   GIF 42, WebP 34). Waeren alle drei gleich lang, wuerde ein
   Fehlschnitt im Rumpf gar nicht auffallen -- siehe die Begruendung
   bei den Konstanten oben.
   ===================================================================== */
melde("\n=== Mehrere Bilder ===");
{
  const drei = [PNG, GIF, WEBP];
  const dreiAn = await hol("modi", "/workspace/api/support", {
    method: "POST",
    headers: {
      "x-text": encodeURIComponent("Vorher, der Klick und nachher - drei Bilder."),
      "Content-Type": "application/octet-stream",
      "x-bilder": drei.map((b) => b.length).join(","),
    },
    body: Buffer.concat(drei),
  });
  ok(dreiAn.status === 201, `drei Bilder auf einmal (${dreiAn.status})`);
  const dreiM = dreiAn.status === 201 ? (await dreiAn.json()).meldung : null;
  ok((dreiM?.bilder || []).length === 3,
    `und alle drei haengen dran (${(dreiM?.bilder || []).length})`);

  /* JEDES BILD EINZELN NACHGEMESSEN -- Reihenfolge, Laenge, Typ.
     Das ist der eigentliche Beweis, dass der Rumpf richtig zerlegt
     wurde: Eine um ein Byte verschobene Grenze gaebe hier sofort
     einen anderen Typ oder eine andere Laenge. */
  const erwartet = [
    { bytes: PNG, typ: "image/png" },
    { bytes: GIF, typ: "image/gif" },
    { bytes: WEBP, typ: "image/webp" },
  ];
  let stimmen = 0;
  for (const [i, e] of erwartet.entries()) {
    const weg = dreiM?.bilder?.[i]?.weg;
    if (!weg) continue;
    const a = await hol("modi", weg);
    const roh = Buffer.from(await a.arrayBuffer());
    if (a.status === 200 && roh.equals(e.bytes)
        && a.headers.get("content-type") === e.typ) stimmen++;
  }
  /* DIE ZAHL STEHT IN DER BEDINGUNG, nicht nur im Text -- sonst waere
     die Pruefung auch mit null geholten Bildern gruen. */
  ok(stimmen === 3,
    `jedes kommt in SEINER Reihenfolge und mit SEINEM Typ zurueck (${stimmen} von 3)`);

  /* ---- Die Grenze gilt ------------------------------------------- */
  const vier = [PNG, GIF, WEBP, PNG];
  const zuViele = await hol("modi", "/workspace/api/support", {
    method: "POST",
    headers: {
      "x-text": encodeURIComponent("Hier sind es vier Bilder, das ist eines zu viel."),
      "Content-Type": "application/octet-stream",
      "x-bilder": vier.map((b) => b.length).join(","),
    },
    body: Buffer.concat(vier),
  });
  ok(zuViele.status === 400, `vier Bilder sind eines zu viel (${zuViele.status})`);

  /* ---- Eine falsche Laenge wird nicht einfach hingenommen -------- */
  const schief = await hol("modi", "/workspace/api/support", {
    method: "POST",
    headers: {
      "x-text": encodeURIComponent("Die Laengen im Kopf passen nicht zum Rumpf."),
      "Content-Type": "application/octet-stream",
      "x-bilder": `${PNG.length},${GIF.length - 5}`,
    },
    body: Buffer.concat([PNG, GIF]),
  });
  ok(schief.status === 400,
    `eine Summe, die nicht aufgeht, wird abgelehnt (${schief.status})`);

  /* ---- UND EIN FAULES UNTER DREI VERDIRBT ALLE DREI -------------- */
  const faul = [PNG, Buffer.from("<html><script>alert(1)</script></html>"), GIF];
  const gemischt = await hol("modi", "/workspace/api/support", {
    method: "POST",
    headers: {
      "x-text": encodeURIComponent("Zwei Bilder und eine getarnte HTML-Datei dazwischen."),
      "Content-Type": "application/octet-stream",
      "x-bilder": faul.map((b) => b.length).join(","),
    },
    body: Buffer.concat(faul),
  });
  ok(gemischt.status === 415,
    `ein getarntes HTML zwischen zwei Bildern kippt die ganze Meldung (${gemischt.status})`);

  /* GEGENPROBE ZUM AUFRAEUMEN: Die abgelehnte Meldung darf es nicht
     geben -- weder als Zeile noch halb, mit dem einen Bild, das vor
     dem faulen schon geschrieben war. */
  const listeDanach = await (await hol("modi", "/workspace/api/support")).json();
  const geister = (listeDanach.meldungen || [])
    .filter((m) => /getarnte HTML-Datei/.test(m.text || "")).length;
  ok(geister === 0, `und hinterlaesst keine halbe Meldung (${geister})`);

  /* ---- OHNE DEN KOPF IST ES EIN BILD, wie vor dem Umbau ---------- */
  const altWeg = await hol("modi", "/workspace/api/support", {
    method: "POST",
    headers: {
      "x-text": encodeURIComponent("Eine Seite aus dem Zwischenspeicher schickt ohne x-bilder."),
      "Content-Type": "image/png",
    },
    body: PNG,
  });
  const altM = altWeg.status === 201 ? (await altWeg.json()).meldung : null;
  ok(altWeg.status === 201 && (altM?.bilder || []).length === 1,
    `ohne x-bilder gilt der ganze Rumpf als EIN Bild (${altWeg.status}, `
    + `${(altM?.bilder || []).length})`);

  /* ---- NACHLEGEN IN DERSELBEN RUNDE ERSETZT, statt zu haeufen ---- */
  const fuerRunde = await hol("modi", "/workspace/api/support", {
    method: "POST",
    headers: { "Content-Type": "text/plain",
      "x-text": encodeURIComponent("Fuer die Runde mit mehreren Bildern.") },
  });
  const rId = (await fuerRunde.json())?.meldung?.id;
  await hol("hand", `/workspace/api/support/${rId}`, {
    method: "PATCH", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ stand: "erledigt", antwort: "Schau mal." }),
  });
  const zweiAn = await hol("modi", `/workspace/api/support/${rId}/rueckmeldung`, {
    method: "POST",
    headers: { "Content-Type": "application/octet-stream", "x-geht": "nein",
      "x-text": encodeURIComponent("Geht noch nicht, hier zwei Bilder."),
      "x-bilder": `${PNG.length},${GIF.length}` },
    body: Buffer.concat([PNG, GIF]),
  });
  ok(zweiAn.status === 200, `zwei Bilder zur Antwort (${zweiAn.status})`);
  const standR = await (await hol("modi", "/workspace/api/support")).json();
  const mR = (standR.meldungen || []).find((m) => m.id === rId);
  const runde1 = (mR?.verlauf || [])[0];
  ok((runde1?.bilder || []).length === 2,
    `an der Runde haengen beide (${(runde1?.bilder || []).length})`);

  /* ---- ZWEIMAL IN DERSELBEN RUNDE GEHT GAR NICHT ----------------

     Hier stand erst eine Pruefung „nachgelegt ersetzt die Bilder" --
     und sie wurde rot. Nachgemessen war nicht der Server kaputt,
     sondern meine Annahme: Eine zweite Antwort in DERSELBEN Runde
     kann es nicht geben. Die erste verlaesst den Stand „wartet", und
     ohne den nimmt die Route nichts mehr an. Die Sperre im Server
     ist daraufhin weggefallen (sie waere Code gewesen, der nie
     laeuft); hier steht jetzt der Beweis, dass sie nicht fehlt. */
  const zweitesMal = await hol("modi", `/workspace/api/support/${rId}/rueckmeldung`, {
    method: "POST",
    headers: { "Content-Type": "application/octet-stream", "x-geht": "nein",
      "x-text": encodeURIComponent("Und noch einmal, in derselben Runde."),
      "x-bilder": `${WEBP.length}` },
    body: WEBP,
  });
  ok(zweitesMal.status === 409,
    `in derselben Runde ein zweites Mal antworten geht nicht (${zweitesMal.status})`);
  const standR2 = await (await hol("modi", "/workspace/api/support")).json();
  const runde1b = ((standR2.meldungen || []).find((m) => m.id === rId)?.verlauf || [])[0];
  ok((runde1b?.bilder || []).length === 2,
    `  und die zwei Bilder von vorhin stehen unveraendert da (${(runde1b?.bilder || []).length})`);

  /* ---- JEDE RUNDE HAELT IHRE EIGENEN BILDER ---------------------

     DAS IST DIE EIGENTLICHE GEFAHR BEI EINER TABELLE FUER ALLES:
     dass Runde 2 die Bilder von Runde 1 mitzeigt oder umgekehrt.
     Nach drei Runden waere dann nicht mehr zu sehen, welches Bild zu
     welchem Versuch gehoerte -- und genau diese Frage loest einen
     wiederkehrenden Fehler. */
  await hol("hand", `/workspace/api/support/${rId}`, {
    method: "PATCH", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ stand: "erledigt", antwort: "Zweiter Versuch." }),
  });
  const r2an = await hol("modi", `/workspace/api/support/${rId}/rueckmeldung`, {
    method: "POST",
    headers: { "Content-Type": "application/octet-stream", "x-geht": "nein",
      "x-text": encodeURIComponent("Runde zwei, ein anderes Bild."),
      "x-bilder": `${WEBP.length}` },
    body: WEBP,
  });
  const standR3 = await (await hol("modi", "/workspace/api/support")).json();
  const verlauf3 = (standR3.meldungen || []).find((m) => m.id === rId)?.verlauf || [];
  ok(r2an.status === 200 && (verlauf3[1]?.bilder || []).length === 1,
    `Runde 2 hat ihr eigenes Bild (${(verlauf3[1]?.bilder || []).length})`);
  ok((verlauf3[0]?.bilder || []).length === 2,
    `  und Runde 1 behaelt ihre zwei (${(verlauf3[0]?.bilder || []).length})`);
  /* GEGENPROBE: Es sind wirklich ANDERE Bilder und nicht dieselben
     Zeilen zweimal gezeigt. */
  const nummern = new Set([
    ...(verlauf3[0]?.bilder || []).map((b) => b.id),
    ...(verlauf3[1]?.bilder || []).map((b) => b.id),
  ]);
  ok(nummern.size === 3, `und alle drei sind verschiedene Bilder (${nummern.size})`);

  /* ---- UND EINE ANTWORT OHNE BILD IST WEITERHIN ERLAUBT --------- */
  await hol("hand", `/workspace/api/support/${rId}`, {
    method: "PATCH", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ stand: "erledigt", antwort: "Dritter Versuch." }),
  });
  const ohneAnhang = await hol("modi", `/workspace/api/support/${rId}/rueckmeldung`, {
    method: "POST",
    headers: { "x-geht": "nein", "x-text": encodeURIComponent("Nur der Text, kein Bild.") },
  });
  const standR4 = await (await hol("modi", "/workspace/api/support")).json();
  const verlauf4 = (standR4.meldungen || []).find((m) => m.id === rId)?.verlauf || [];
  ok(ohneAnhang.status === 200 && (verlauf4[2]?.bilder || []).length === 0,
    `Runde 3 ohne Bild ist in Ordnung (${ohneAnhang.status}, `
    + `${(verlauf4[2]?.bilder || []).length} Bilder)`);
  ok((verlauf4[0]?.bilder || []).length === 2 && (verlauf4[1]?.bilder || []).length === 1,
    "  und loescht an den Runden davor nichts");

  /* ---- UND DIE OBERFLAECHE ERFAEHRT DIE GRENZE ------------------- */
  const liste = await (await hol("modi", "/workspace/api/support")).json();
  ok(liste.bilder_max === 3,
    `der Server nennt die Grenze, damit sie im Browser nicht zweimal steht (${liste.bilder_max})`);
}

/* =====================================================================
   5c. DER UMZUG DER ALTEN BILDER (02.10.2026)
   =====================================================================

   DIE WICHTIGSTE PRUEFUNG DIESES UMBAUS. Live liegen acht Meldungen
   mit Bild in den alten Spalten `support_meldungen.bild_datei` und
   dazu die Bilder an den Antwortrunden. Ab heute liest der Server
   NUR noch `support_bilder`. Ohne den Umzug waeren diese Bilder
   stillschweigend verschwunden -- kein Fehler, keine rote Zeile, nur
   acht leere Karten. Genau die Sorte Schaden, die am 11.09. drei
   Spalten gekostet hat.

   SIE LAEUFT AUF EINER EIGENEN WEGWERF-DATENBANK und ruft
   `supportTabellen()` direkt auf. Ueber den laufenden Server waere
   es nicht zu messen: Dort ist die Datenbank frisch, es gibt gar
   keine alten Zeilen, und die Pruefung waere gruen, ohne etwas
   gesehen zu haben.
   ===================================================================== */
melde("\n=== Der Umzug der alten Bilder ===");
{
  const { DatabaseSync } = await import("node:sqlite");
  const { supportTabellen } = await import("./support-tabellen.js");
  const altDatei = join(ordner, "alt-bestand.db");
  const a = new DatabaseSync(altDatei);

  /* DER STAND VON GESTERN, von Hand nachgebaut: die Tabellen OHNE
     `support_bilder`, mit den Bildspalten gefuellt. */
  a.exec(`
    CREATE TABLE support_meldungen (
      id INTEGER PRIMARY KEY AUTOINCREMENT, person_id INTEGER,
      von_name TEXT, von_rolle TEXT, text TEXT NOT NULL, seite TEXT, geraet TEXT,
      bild_datei TEXT, bild_typ TEXT, bild_breite INTEGER, bild_hoehe INTEGER,
      stand TEXT NOT NULL DEFAULT 'neu', antwort TEXT, runde INTEGER NOT NULL DEFAULT 1,
      erstellt TEXT NOT NULL, geaendert TEXT NOT NULL,
      erledigt_am TEXT, erledigt_von INTEGER);
    CREATE TABLE support_runden (
      meldung_id INTEGER NOT NULL, nr INTEGER NOT NULL, antwort TEXT,
      von_id INTEGER, von_name TEXT, am TEXT NOT NULL,
      urteil TEXT, urteil_text TEXT, urteil_am TEXT);
    INSERT INTO support_meldungen (text, bild_datei, bild_typ, bild_breite, bild_hoehe,
        erstellt, geaendert)
      VALUES ('mit Bild', 'alt-eins.png', 'image/png', 100, 240, '2026-09-01T10:00:00Z',
              '2026-09-01T10:00:00Z');
    INSERT INTO support_meldungen (text, erstellt, geaendert)
      VALUES ('ohne Bild', '2026-09-02T10:00:00Z', '2026-09-02T10:00:00Z');
    INSERT INTO support_runden (meldung_id, nr, antwort, am, urteil, urteil_am)
      VALUES (1, 1, 'Probier es nochmal.', '2026-09-03T10:00:00Z',
              'nicht', '2026-09-03T11:00:00Z');
  `);
  /* Das Bild der RUNDE steht absichtlich noch nicht drin: Die vier
     Spalten dafuer gibt es in einer Datenbank von gestern gar nicht.
     Genau das muss `supportTabellen` erst nachruesten -- und DANACH
     umziehen. Stuende der Umzug vor der Nachruestung, scheiterte er
     hier und nur hier, naemlich auf einer alten Datenbank. */

  supportTabellen(a);

  a.exec(`UPDATE support_runden SET urteil_bild_datei = 'alt-runde.gif',
            urteil_bild_typ = 'image/gif', urteil_bild_breite = 50, urteil_bild_hoehe = 60
          WHERE meldung_id = 1 AND nr = 1`);
  /* ZWEITER DURCHLAUF -- so wie beim naechsten Neustart des Dienstes.
     Er muss das Rundenbild nachholen UND das Meldungsbild NICHT
     verdoppeln. */
  supportTabellen(a);

  const alle = a.prepare("SELECT * FROM support_bilder ORDER BY id").all();
  ok(alle.length === 2, `beide alten Bilder sind umgezogen (${alle.length})`);
  const zurMeldung = alle.filter((b) => b.runde_nr === null);
  ok(zurMeldung.length === 1 && zurMeldung[0].datei === "alt-eins.png"
    && zurMeldung[0].typ === "image/png" && zurMeldung[0].breite === 100
    && zurMeldung[0].hoehe === 240,
    `  das Bild der Meldung mit Datei, Typ und Groesse (${zurMeldung[0]?.datei}, `
    + `${zurMeldung[0]?.breite}x${zurMeldung[0]?.hoehe})`);
  const zurRunde = alle.filter((b) => b.runde_nr === 1);
  ok(zurRunde.length === 1 && zurRunde[0].datei === "alt-runde.gif",
    `  und das Bild der Antwort an SEINER Runde (${zurRunde[0]?.datei})`);
  ok(zurMeldung[0]?.erstellt === "2026-09-01T10:00:00Z",
    `  mit dem Datum von damals, nicht dem von heute (${zurMeldung[0]?.erstellt})`);

  /* DRITTER DURCHLAUF: Er darf nichts mehr tun. Ein Umzug, der bei
     jedem Neustart dieselben Zeilen noch einmal anlegt, fuellt die
     Karte nach einer Woche mit sieben gleichen Bildern. */
  supportTabellen(a);
  const nochmal = a.prepare("SELECT COUNT(*) AS n FROM support_bilder").get().n;
  ok(nochmal === 2, `ein weiterer Start verdoppelt nichts (${nochmal})`);

  /* GEGENPROBE: Die Meldung OHNE Bild bekommt auch keines. Ohne
     diese Zeile koennte der Umzug alles verdoppeln und waere noch
     immer gruen. */
  const beiOhne = a.prepare("SELECT COUNT(*) AS n FROM support_bilder WHERE meldung_id = 2")
    .get().n;
  ok(beiOhne === 0, `eine Meldung ohne Bild bekommt keines (${beiOhne})`);

  a.close();
}

/* =====================================================================
   6. GEGENPROBEN — kann diese Pruefung ueberhaupt rot werden?
   ===================================================================== */
melde("\n=== Gegenproben (jede MUSS anschlagen) ===");
{
  /* Eine Meldung, die es nicht gibt. */
  const nichts = await hol("admin", "/workspace/api/support/999999");
  ok(nichts.status === 404, "eine erfundene Nummer gibt es nicht");

  /* Ohne Anmeldung kommt niemand an die Liste. */
  const ohne = await fetch(BASIS + "/workspace/api/support");
  ok(ohne.status === 401 || ohne.status === 302 || ohne.status === 404,
    `ohne Anmeldung keine Liste (${ohne.status})`);

  /* Und ohne Anmeldung auch nicht an ein Bild. */
  const ohneBild = await fetch(BASIS + bildWeg);
  ok(ohneBild.status !== 200, `ohne Anmeldung kein Bild (${ohneBild.status})`);
}

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

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