Zwei bis drei Bilder je Supportmeldung -- und zwei Funde unterwegs

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 der zweiten Runde der Satz, auf den es ankommt: „wenn man es nacheinander versucht hinzuzufuegen wird das Bild immer nur ersetzt." EINE TABELLE STATT NEUER SPALTEN `support_bilder` haelt ab jetzt JEDES Supportbild -- das der Meldung (`runde_nr` NULL) und das einer Antwort (`runde_nr` = Runde). Die Alternative waere `bild2_datei`, `bild3_datei` gewesen, und beim vierten Bild wieder. Eine Zeile je Bild kennt keine Obergrenze im Schema; die Grenze steht an EINER Stelle im Code (`BILDER_MAX = 3`) und kommt von dort in die Oberflaeche, statt dort ein zweites Mal zu stehen. DIE ACHT VORHANDENEN BILDER WANDERN MIT. Ohne diesen Schritt haette die neue Tabelle ab heute recht und die alten Bilder waeren unsichtbar -- ohne Fehler, ohne rote Zeile, nur acht leere Karten. Der Umzug steht NACH der Spaltennachruestung: Er liest `urteil_bild_datei`, und die gibt es in einer bestehenden Datenbank erst, nachdem sie ergaenzt wurde. Stuende er davor, scheiterte er genau dort, wo es darauf ankommt -- live, waehrend lokal alles gruen bliebe, weil jede Pruefung ihre Datenbank frisch anlegt. DREI BILDER IN EINER ANFRAGE `x-bilder: 20481,15320` sagt, wo zu schneiden ist, der Rumpf ist die Aneinanderreihung. `multipart/form-data` haette einen Zerleger gebraucht, den dieses Haus nicht hat; drei Anfragen nacheinander haetten den Zustand „Meldung da, Bild zwei laedt noch" erzeugt -- genau den, gegen den die Kommentare an dieser Route schon vorher argumentieren. Die Summe muss auf das Byte stimmen, und jedes Stueck wird einzeln an seinen ersten Bytes erkannt: Wer falsch schneidet, bekommt eine Absage, kein verfaelschtes Bild. Ohne den Kopf gilt der ganze Rumpf als ein Bild -- derselbe Satz mit einer Laenge, damit eine Seite aus dem Zwischenspeicher weiterlaeuft. EINE ROUTE STATT DREI. `/:id/bild` und `/:id/runde/:nr/bild` sind weg; es gibt `/:id/bild/:bid`. Wohin ein Bild gehoert, steht in seiner Zeile -- der Weg muss es nicht wiederholen. Die Meldungsnummer bleibt trotzdem im Pfad: Sie ist die Sichtbarkeitsfrage, und beides muss zusammenpassen (gemessen). ZWEI FUNDE, DIE DIE PRUEFUNG GEMACHT HAT UND NICHT ICH 1. UEBER DIE SEITE KAM GAR KEIN BILD MEHR AN. Beim Melden stand kein `Content-Type`. Das ging gut, solange der Rumpf eine einzelne Datei war -- ein `File` bringt seinen Typ mit. Ein `Blob` aus mehreren hat keinen, `fetch` schickt die Zeile dann gar nicht, `express.raw` fuehlt sich nicht zustaendig, und der Server bekam einen leeren Rumpf. Die Meldung waere durchgegangen, der Text angekommen, die Bilder weg -- ohne Fehlermeldung. Alle Pruefungen am Server waren dabei gruen; gefunden hat es erst der echte Browser. 2. DAS KREUZ DES DRITTEN BILDES LAG AUF DEM ZWEITEN. Der Entfernen-Knopf ist 44 px breit und absolut gesetzt, der Kasten aber nur so breit wie sein Bild. Bei einem schmalen Bild ragt er darueber hinaus -- wer „das zweite weg" antippt, loescht das dritte. `min-width`/`min-height` loesen das an der Ursache: Ein Kasten ist nie schmaler als der Knopf in ihm. WAS ICH FALSCH ANGENOMMEN HATTE: Ich hatte eingebaut, dass ein Nachtrag in derselben Runde die Bilder ersetzt. Die Pruefung dazu wurde rot -- zu Recht: Eine zweite Antwort in derselben Runde kann es nicht geben, die erste verlaesst den Stand „wartet". Der Code waere nie gelaufen und damit nie pruefbar gewesen. Er ist weg; an seiner Stelle steht der Beweis, dass er nicht fehlt. DREI WEITERE ROTE ZEILEN, DIE NICHT ZU DIESEM UMBAU GEHOERTEN * `manager-ziele.js` hatte einen ZWEITEN Notnagel (`frageNach ? … : confirm(…)`). `nachfrage.js` hat denselben laengst, und zwar mit dem vollstaendigen Text; der hiesige war der kuerzere und haette gewonnen. Zwei Antworten auf dieselbe Frage -- gemeldet von `pruef-nachfrage`. * Zwei Mittelpunkte in `reaktion.css` standen woertlich im `content`. Sie liegen im Latin-1-Block, wo `pruef-zeichen` die Truemmer einer verunglueckten Kodierung sucht. Jetzt als Escape -- im Browser nachgemessen, es steht Zeichen fuer Zeichen dasselbe da. * Das Aufraeumen nach 90 Tagen loeschte nur das EINE Bild der Meldung; die Bilder aus den Antwortrunden blieben ohne Zeile auf der Platte liegen. Die Liste kommt jetzt aus einer Abfrage statt aus einer Spalte und kann deshalb nicht wieder unvollstaendig sein. GEPRUEFT pruef-support 78 -> 104 ok darunter: der Umzug der alten Bilder auf einer eigenen Wegwerf-Datenbank -- zweimal und dreimal gestartet, nichts verdoppelt, Datum von damals erhalten pruef-support-bilder NEU, 36 ok (echter Browser) dreimal nacheinander waehlen ergibt drei, das vierte wird mit einem Satz abgelehnt, dasselbe zaehlt nicht doppelt, einzeln entfernen laesst die anderen stehen, alle drei laden wirklich (naturalWidth), Kreuze 44x44 und keines verdeckt (mit Gegenprobe per Deckel), nichts ragt auf 390 px heraus pruef-nachfrage 69 -> 74 ok pruef-struktur 102 ok, 413 Routen (vorher 414: zwei weg, eine neu) pruef-zeichen 7 ok (vorher 1 Fehler) pruef-aufbewahrung 45 ok pruef-manager-ziele 216 ok pruef-ports 10 ok · pruef-portnummern 41 ok (die neue Pruefdatei verschiebt die abgeleiteten Nummern) NUR DAS AGENTURHAUS IST BETROFFEN. Die Supportseite liegt unter `/workspace`; am Crew-Haus aendert sich keine Zeile. Co-Authored-By: Claude Opus 5 <[email protected]>
2026-10-02 23:38:03 +02:00
parent 3ab69d36a5
commit b31bd9b515
58 changed files with 2587 additions and 1011 deletions
@@ -158,6 +158,20 @@ 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) {
@@ -279,6 +293,7 @@ melde("\n=== Die Seite ist fuer jede Rolle offen ===");
   ===================================================================== */
 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", {
@@ -305,8 +320,16 @@ let meldungMitBild = 0;
  if (mitBild.status === 201) {
    const j = await mitBild.json();
    meldungMitBild = j.meldung?.id || 0;
-    ok(!!j.meldung?.bild, "und die Antwort nennt die Adresse des Bildes");
-  } else { ok(false, "kein Bild in der Antwort"); }
+    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
@@ -360,11 +383,11 @@ melde("\n=== Wer sieht was ===");
  }

  /* DAS BILD EINER FREMDEN MELDUNG bleibt fremd. */
-  const fremd = await hol("creator", `/workspace/api/support/${meldungMitBild}/bild`);
+  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", `/workspace/api/support/${meldungMitBild}/bild`);
+  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")})`);
@@ -373,8 +396,22 @@ melde("\n=== Wer sieht was ===");
  ok(/sandbox/.test(eigen.headers.get("content-security-policy") || ""),
    "und einer Richtlinie, die jede Ausfuehrung nimmt");

-  const leitungSieht = await hol("hand", `/workspace/api/support/${meldungMitBild}/bild`);
+  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})`);
 }

 /* =====================================================================
@@ -597,19 +634,25 @@ melde("\n=== Sich kuemmern ===");

    const stand = await standVon("modi", neuId);
    const r1 = (stand?.verlauf || [])[0];
-    ok(!!r1?.urteil_bild,
-      `im Verlauf haengt das Bild an Runde ${r1?.nr} (${r1?.urteil_bild})`);
+    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. */
-    ok(/\/runde\/1\/bild$/.test(r1?.urteil_bild || ""),
-      "  und zwar an DIESER Runde, nicht oben an der Meldung");
+       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", r1.urteil_bild);
+    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)`);
@@ -620,21 +663,25 @@ melde("\n=== Sich kuemmern ===");
    ok(holen.headers.get("accept-ranges") === "bytes",
      "und ueber den gemeinsamen Ausliefer-Weg (Accept-Ranges)");

-    const auchLeitung = await hol("hand", r1.urteil_bild);
+    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", r1.urteil_bild);
+    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 + r1.urteil_bild);
+    const ohneAnmeldung = await fetch(BASIS + r1weg);
    ok(ohneAnmeldung.status !== 200,
      `ohne Anmeldung gar nichts (${ohneAnmeldung.status})`);

-    const gibtsNicht = await hol("modi", `/workspace/api/support/${neuId}/runde/9/bild`);
-    ok(gibtsNicht.status === 404, `eine Runde ohne Bild gibt 404 (${gibtsNicht.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,
@@ -665,6 +712,322 @@ melde("\n=== Sich kuemmern ===");
  }
 }

+/* =====================================================================
+   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?
   ===================================================================== */
@@ -680,7 +1043,7 @@ melde("\n=== Gegenproben (jede MUSS anschlagen) ===");
    `ohne Anmeldung keine Liste (${ohne.status})`);

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