dogfather-universe/server/workspace-support.js

/* =====================================================================
   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. es soll alles hoch
   profissionell gemacht werden aber so einfach wie möglich, will
   nichts kompliziertes oder zu viel. kurz und knapp … also bei
   dogfather und der rechten hand soll die kachel anders gebaut sein
   weil die sind die die sich um die probleme kümmern."

   Die Regeln und ihre Begründung stehen im Kopf von
   support-tabellen.js. Hier sind die Wege — und die vier Stellen, an
   denen etwas schiefgehen kann:

   1. EINE MELDUNG DARF NIE BEIM FALSCHEN LANDEN. Jede Leseroute geht
      über `meldungFuer()`, das den Datensatz zurückgibt oder `null` —
      nie `true`/`false`. So kann keine Route „darf sehen" beantworten
      und danach trotzdem den falschen Datensatz laden. Dasselbe
      Muster wie im vertraulichen Meldeweg.

   2. DER TYP EINES BILDES KOMMT AUS DEM INHALT. `dateiErkennen()`
      liest die ersten Bytes; Dateiname und Content-Type kommen vom
      Absender und sind frei erfunden. Die Funktion wird aus
      workspace-chat.js IMPORTIERT und nicht abgeschrieben: Eine
      zweite Fassung wäre die, die beim nächsten Dateiformat vergessen
      wird — und an ihr hängt die ganze Sicherheit der Uploads.

   3. DER RUMPF WIRD ERST ANGENOMMEN, WENN DIE BERECHTIGUNG STEHT.
      Wer nicht angemeldet ist, kommt gar nicht bis zur Datei.

   4. ERLEDIGT IST ERLEDIGT. Auch für die Leitung — eine geschlossene
      Meldung wird nicht stillschweigend wieder geöffnet und anders
      beantwortet.
   ===================================================================== */

import express from "express";
import { statSync, writeFileSync, mkdirSync, unlinkSync } from "node:fs";
import { liefereDatei } from "./helfer-ausliefern.mjs";
import { join } from "node:path";
import { randomBytes } from "node:crypto";
import { db, protokolliere, DATEN_ORDNER, echteIp } from "./workspace.js";
import { SUPPORT_STAND, AUFBEWAHRUNG_TAGE } from "./support-tabellen.js";
import { dateiErkennen } from "./workspace-chat.js";
import { benachrichtige } from "./workspace-push.js";

export const supportRouter = express.Router();

/** Wer alle Meldungen sieht und sie bearbeitet.
 *
 *  GENAU ZWEI ROLLEN, wie bestellt: DogFather und die rechte Hand.
 *  Dieselbe Menge wie im vertraulichen Meldeweg — und aus einem
 *  ähnlichen Grund: Wer sich kümmert, muss alles sehen; wer nur
 *  meldet, sieht seine eigene Meldung. */
const LEITUNG = new Set(["admin", "hand"]);
const istLeitung = (person) => LEITUNG.has(person?.rolle);

const TEXT_MAX = 2000;
const SEITE_MAX = 120;
const GERAET_MAX = 200;
const ANTWORT_MAX = 2000;

/** Zwölf Megabyte — dieselbe Grenze wie bei Chat-Anhängen.
 *  Ein Bildschirmfoto vom Handy liegt bei 2 bis 5 MB. */
const BILD_MAX = 12 * 1024 * 1024;

/** Wie viele Bilder an EINE Meldung oder EINE Antwort dürfen.
 *
 *  VanVan im Support, Meldung #11 — viermal gemeldet: „Hier im
 *  Supportbereich kann man immer nur ein Bild hinzufügen bei einer
 *  Meldung. 2-3 wären besser." Also drei, ihre eigene Obergrenze.
 *
 *  DIE ZAHL STEHT AN EINER STELLE und nirgends sonst. Im Schema gibt
 *  es sie nicht (eine Zeile je Bild kennt keine Grenze), in der
 *  Oberfläche wird sie vom Server geholt. Eine zweite Zahl im Browser
 *  wäre die, die beim Erhöhen vergessen wird — genau das Muster, das
 *  am 06.09. den Umbruch bei 380 px gekostet hat. */
const BILDER_MAX = 3;

/** Wie viele offene Meldungen eine Person gleichzeitig haben darf.
 *
 *  Zehn, und damit deutlich großzügiger als die drei im vertraulichen
 *  Meldeweg. Dort ist die Grenze ein Schutz vor Überforderung auf
 *  beiden Seiten; hier wäre sie eine Bremse für genau die Person, die
 *  sich die Mühe macht, fünf kleine Fehler einzeln zu melden. Sie
 *  steht nur da, damit ein hängendes Skript nicht tausend Zeilen
 *  anlegt. */
const OFFEN_MAX = 10;

/* Der Ordner steht über join(DATEN_ORDNER, …) — genau dieses Muster
   liest tools/wiederherstellung-proben.mjs aus, um zu prüfen, ob die
   Sicherung ihn mitnimmt. Eine gepflegte Liste wäre die, die beim
   nächsten Ordner vergessen wird. */
const BILD_ORDNER = join(DATEN_ORDNER, "support-bilder");

const jetzt = () => new Date().toISOString();

function sauber(s, max) {
  return String(s ?? "").replace(/\s+/g, " ").trim().slice(0, max);
}

/** Mehrzeiliger Text: Absätze bleiben, Leerzeilenwüsten nicht.
 *
 *  Beim Melden schreibt man „Schritt 1 … Schritt 2 …" untereinander.
 *  Das über `\s+` plattzumachen wie einen Betreff würde genau die
 *  Struktur zerstören, die den Fehler nachvollziehbar macht. */
function textSauber(s, max) {
  return String(s ?? "")
    .replace(/\r\n/g, "\n")
    .replace(/[ \t]+/g, " ")
    .replace(/\n{3,}/g, "\n\n")
    .trim()
    .slice(0, max);
}

/* =====================================================================
   MEHRERE BILDER — EIN RUMPF, DIE LÄNGEN IM KOPF (02.10.2026)
   =====================================================================

   VanVan, Meldung #11: „2-3 wären besser." Und in der zweiten Runde
   der Grund, warum der erste Versuch nicht reichte: „wenn man es
   nacheinander versucht hinzuzufügen wird das Bild immer nur
   ersetzt."

   WIE DREI BILDER IN EINE ANFRAGE KOMMEN. Bisher war der Rumpf EIN
   Bild — roh, ohne Verpackung, und `dateiErkennen` sah an den ersten
   Bytes, was es ist. Für mehrere braucht es eine Grenze dazwischen.
   Drei Wege standen zur Wahl:

     1. `multipart/form-data`. Der übliche Weg — und er braucht einen
        Zerleger, den dieses Haus nicht hat. Ein Paket mehr, um eine
        Zahl zu übertragen, die auch in einen Kopf passt.
     2. Drei Anfragen nacheinander. Das ist genau der Zustand, gegen
        den die Kommentare bei `POST /support` schon argumentieren:
        eine Meldung, die es gibt, während Bild zwei noch lädt — und
        bei Abbruch für immer unvollständig.
     3. DIE LÄNGEN IM KOPF, die Bilder hintereinander im Rumpf.

   Es ist 3 geworden: `x-bilder: 20481,15320` sagt, wo zu schneiden
   ist, und der Rumpf ist die Aneinanderreihung. Dieselbe Linie wie
   bisher („Text im Kopf, Bild im Rumpf"), nur eine Angabe weiter.

   EINE FALSCHE LÄNGE KANN NICHTS KAPUTTMACHEN. Die Summe muss auf
   das Byte stimmen, sonst 400 — und jedes Stück wird danach einzeln
   von `dateiErkennen` an seinen ersten Bytes gemessen. Wer falsch
   schneidet, bekommt kein verfälschtes Bild, sondern eine Absage.

   OHNE DEN KOPF IST ES DER ALTE WEG — ein Bild, der ganze Rumpf.
   Das ist keine zweite Tür, sondern derselbe Satz mit einer Länge:
   `[rumpf.length]`. Dadurch funktioniert eine Seite, die noch im
   Zwischenspeicher des Browsers liegt, unverändert weiter. */

/** Den Rumpf in einzelne Bilder zerlegen.
 *
 *  Gibt `{ teile }` oder `{ fehler: { code, text } }` zurück — nie
 *  beides und nie `null` für „ging schief". Der Aufrufer soll den
 *  Fehler weiterreichen können, ohne ihn selbst zu formulieren;
 *  sonst steht derselbe Satz an zwei Routen und altert einmal. */
function rumpfZerlegen(req) {
  const rumpf = Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0);
  if (!rumpf.length) return { teile: [] };

  const kopf = String(req.get("x-bilder") || "").trim();
  let laengen;
  if (!kopf) {
    laengen = [rumpf.length];
  } else {
    laengen = kopf.split(",").map((s) => Number(s.trim()));
    if (laengen.some((n) => !Number.isInteger(n) || n <= 0)) {
      return { fehler: { code: 400, text: "Die Bildlängen sind unbrauchbar." } };
    }
  }
  if (laengen.length > BILDER_MAX) {
    return {
      fehler: {
        code: 400,
        text: `Mehr als ${BILDER_MAX} Bilder gehen nicht – nimm die wichtigsten.`,
      },
    };
  }
  if (laengen.some((n) => n > BILD_MAX)) {
    return { fehler: { code: 413, text: "Ein Bild ist größer als 12 MB." } };
  }
  const summe = laengen.reduce((a, b) => a + b, 0);
  /* AUF DAS BYTE. Ein „ungefähr" hieße, dass das letzte Bild
     abgeschnitten ankommt und trotzdem gespeichert wird. */
  if (summe !== rumpf.length) {
    return { fehler: { code: 400, text: "Die Bilder sind unterwegs beschädigt worden." } };
  }

  const teile = [];
  let ab = 0;
  for (const n of laengen) { teile.push(rumpf.subarray(ab, ab + n)); ab += n; }
  return { teile };
}

/** Die Stücke prüfen und auf die Platte legen.
 *
 *  Gibt `{ bilder }` oder `{ fehler }`. Was schon geschrieben wurde,
 *  räumt sie bei einem späteren Fehlschlag SELBST weg — sonst
 *  sammelt der Ordner Dateien an, auf die keine Zeile zeigt und die
 *  deshalb niemand je wieder zuordnen kann. */
function bilderAblegen(teile) {
  const bilder = [];
  try {
    for (const stueck of teile) {
      const erkannt = dateiErkennen(stueck);
      /* NUR BILDER. `dateiErkennen` kennt auch PDF und Ton — hier geht
         es um Bildschirmfotos, und alles andere wäre eine Tür, nach
         der niemand gefragt hat. */
      if (!erkannt || erkannt.art !== "bild") {
        for (const b of bilder) {
          try { unlinkSync(join(BILD_ORDNER, b.datei)); } catch { /* egal */ }
        }
        return {
          fehler: {
            code: 415,
            text: "Als Anhang geht ein Foto – PNG, JPEG, WebP oder GIF.",
          },
        };
      }
      mkdirSync(BILD_ORDNER, { recursive: true });
      const datei = `${Date.now()}-${randomBytes(8).toString("hex")}${erkannt.endung}`;
      writeFileSync(join(BILD_ORDNER, datei), stueck);
      bilder.push({
        datei, typ: erkannt.typ,
        breite: erkannt.breite || 0, hoehe: erkannt.hoehe || 0,
      });
    }
  } catch (fehler) {
    for (const b of bilder) {
      try { unlinkSync(join(BILD_ORDNER, b.datei)); } catch { /* egal */ }
    }
    throw fehler;
  }
  return { bilder };
}

/** Die Zeilen schreiben — zur Meldung (`rundeNr === null`) oder zu
 *  einer Antwort. EINE Tabelle für beides, siehe support-tabellen.js. */
function bilderEintragen(meldungId, rundeNr, bilder, wann) {
  const satz = db().prepare(`INSERT INTO support_bilder
      (meldung_id, runde_nr, datei, typ, breite, hoehe, erstellt)
    VALUES (?,?,?,?,?,?,?)`);
  for (const b of bilder) {
    satz.run(meldungId, rundeNr, b.datei, b.typ, b.breite, b.hoehe, wann);
  }
}

/** Die Bilder einer Meldung oder einer Runde, in der Reihenfolge des
 *  Hochladens.
 *
 *  DER WEG, NICHT DER DATEINAME. Was auf der Platte liegt, geht
 *  niemanden etwas an, der nur ein Bild anzeigen will — dieselbe
 *  Entscheidung wie beim Chat-Anhang. */
function bilderVon(meldungId, rundeNr) {
  const zeilen = rundeNr === null
    ? db().prepare(`SELECT id, breite, hoehe FROM support_bilder
        WHERE meldung_id = ? AND runde_nr IS NULL ORDER BY id`).all(meldungId)
    : db().prepare(`SELECT id, breite, hoehe FROM support_bilder
        WHERE meldung_id = ? AND runde_nr = ? ORDER BY id`).all(meldungId, rundeNr);
  return zeilen.map((z) => ({
    id: z.id,
    weg: `/workspace/api/support/${meldungId}/bild/${z.id}`,
    breite: z.breite || 0,
    hoehe: z.hoehe || 0,
  }));
}

/** Darf diese Person diese Meldung sehen?
 *
 *  Gibt die Meldung zurück oder `null`. NIE `true`/`false` — dasselbe
 *  Muster wie `fallFuer()` im vertraulichen Meldeweg, und aus
 *  demselben Grund. */
function meldungFuer(person, id) {
  const m = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(Number(id));
  if (!m) return null;
  if (istLeitung(person)) return m;
  return m.person_id === person?.id ? m : null;
}

/** Darf DIESE Person bei DIESER Meldung jetzt bestätigen?
 *
 *  AN EINER STELLE, weil es zwei Stellen gibt, die es wissen müssen:
 *  die Route, die die Antwort annimmt, und die Anzeige, die die
 *  Knöpfe zeigt. Standen sie getrennt da, driften sie — und genau das
 *  ist am 25.09.2026 im ersten Anlauf passiert: Der Server lehnte die
 *  Leitung richtig mit 404 ab, die Karte zeigte ihr die Knöpfe
 *  trotzdem. Zwei Knöpfe, die nur eine Fehlermeldung können, sind
 *  schlimmer als gar keine.
 *
 *  ES IST DER MELDER, NICHT „WER NICHT LEITUNG IST": Die Leitung darf
 *  ihre eigene Meldung sehr wohl selbst bestätigen — sie hat sie ja
 *  geschrieben. Verboten ist nur, FREMDE Arbeit abzunicken. */
function darfBestaetigen(m, personId) {
  return !!m && m.person_id === personId && m.stand === SUPPORT_STAND.wartet;
}

/** Wie eine Meldung nach draußen aussieht.
 *
 *  AN EINER STELLE, weil vier Routen sie ausgeben. Vier Stellen wären
 *  vier Gelegenheiten, ein Feld zu vergessen — oder eines zu viel
 *  mitzuschicken.
 *
 *  `fuerLeitung` entscheidet nur über die Zusatzangaben, nicht über
 *  den Inhalt: Wer meldet, sieht seine eigene Meldung vollständig,
 *  auch den Namen, den er selbst trägt.
 *
 *  `werFragtId` ist Pflicht, seit es die Knöpfe des Melders gibt —
 *  ohne sie ist `darf_bestaetigen` eine Aussage über die Meldung
 *  statt über den Betrachter, und die Leitung bekommt Knöpfe, die sie
 *  nicht drücken darf. */
function nachDraussen(m, fuerLeitung, werFragtId) {
  return {
    id: m.id,
    text: m.text,
    stand: m.stand,
    antwort: m.antwort || null,
    erstellt: m.erstellt,
    geaendert: m.geaendert,
    erledigt_am: m.erledigt_am || null,
    seite: m.seite || null,
    /* ==== EINE LISTE, AUCH WENN NUR EINES DRAN HÄNGT (02.10.2026) ==

       Hier standen `bild`, `bild_breite`, `bild_hoehe` — drei Felder
       für genau ein Bild. Daneben eine Liste zu stellen hieße: zwei
       Auskünfte auf dieselbe Frage, und die zweite wird irgendwann
       nicht mehr mitgepflegt. Deshalb nur noch `bilder` — leer,
       eines oder bis zu drei. Die Oberfläche schleift darüber und
       muss den Sonderfall „genau eines" nicht kennen. */
    bilder: bilderVon(m.id, null),
    von: m.von_name || null,
    von_rolle: m.von_rolle || null,
    /* Nur die Leitung braucht zu wissen, mit welchem Gerät gemeldet
       wurde. Für den Melder ist es seine eigene Angabe und nur
       Rauschen. */
    geraet: fuerLeitung ? (m.geraet || null) : undefined,
    /* ==== DER WEG BIS HIERHER (25.09.2026) =========================

       Filipe: „mit dem gedanken das manchmal sachen mehrmal nicht
       sofort perfekt sein werden."

       Die Runde und der ganze Verlauf gehen mit. Nur die letzte
       Antwort zu schicken hiesse: Bei Runde drei ist nicht mehr zu
       sehen, was beim ersten Mal versucht wurde -- und genau das
       loest einen wiederkehrenden Fehler.

       BEIDE SEITEN BEKOMMEN DENSELBEN VERLAUF. Der Melder soll lesen
       koennen, was schon probiert wurde; die Leitung, was er dazu
       gesagt hat. Es gibt hier nichts zu verbergen -- es sind seine
       eigenen Worte und die Antworten darauf. */
    runde: m.runde || 1,
    verlauf: verlaufVon(m.id),
    /* DARF ICH JETZT BESTAETIGEN? Vom Server beantwortet, nicht im
       Browser nachgerechnet: Dort stuende die Regel ein zweites Mal,
       und die zweite Fassung waere ab der naechsten Aenderung falsch. */
    darf_bestaetigen: darfBestaetigen(m, werFragtId),
  };
}

/** Der Verlauf einer Meldung -- eine Zeile je Runde. */
function verlaufVon(id) {
  return db().prepare(`SELECT nr, antwort, von_name, am, urteil, urteil_text, urteil_am
      FROM support_runden WHERE meldung_id = ? ORDER BY nr`).all(id)
    .map((r) => ({
      nr: r.nr, antwort: r.antwort, von: r.von_name || null, am: r.am,
      urteil: r.urteil || null, urteil_text: r.urteil_text || null,
      urteil_am: r.urteil_am || null,
      /* AUCH HIER EINE LISTE und dieselbe Form wie bei der Meldung —
         die Oberfläche hat dadurch EINE Funktion für beide Stellen
         statt zweier, die auseinanderlaufen. */
      bilder: bilderVon(id, r.nr),
    }));
}

/* =====================================================================
   LESEN
   ===================================================================== */

/** Die eigenen Meldungen — oder für die Leitung alle.
 *
 *  EINE ROUTE FÜR BEIDE, nicht zwei. Zwei Routen hießen zwei Stellen,
 *  an denen die Sichtbarkeitsregel gepflegt werden muss — und eine
 *  davon läuft irgendwann auseinander. */
supportRouter.get("/workspace/api/support", (req, res) => {
  try {
    const leitung = istLeitung(req.person);
    const zeilen = leitung
      ? db().prepare(`SELECT * FROM support_meldungen ORDER BY
          /* Offene zuerst, und darin die ältesten oben: Was am
             längsten wartet, gehört nach vorn. Erledigte danach, das
             Neueste zuerst. */
          CASE stand WHEN 'neu' THEN 0 WHEN 'in_arbeit' THEN 1 ELSE 2 END,
          CASE WHEN stand = 'erledigt' THEN -id ELSE id END
          LIMIT 300`).all()
      : db().prepare(`SELECT * FROM support_meldungen WHERE person_id = ?
          ORDER BY id DESC LIMIT 100`).all(req.person.id);

    res.json({
      leitung,
      meldungen: zeilen.map((m) => nachDraussen(m, leitung, req.person.id)),
      /* Die Zahlen stehen in der Antwort und werden nicht im Browser
         nachgezählt: Die Liste ist bei 300 abgeschnitten, eine Zählung
         darauf wäre ab der 301. Meldung still falsch. */
      offen: leitung
        ? db().prepare("SELECT COUNT(*) AS n FROM support_meldungen WHERE stand <> 'erledigt'")
          .get().n
        : db().prepare(`SELECT COUNT(*) AS n FROM support_meldungen
            WHERE person_id = ? AND stand <> 'erledigt'`).get(req.person.id).n,
      hoechstens_bytes: BILD_MAX,
      /* WIE VIELE BILDER GEHEN — vom Server gesagt, nicht im Browser
         gewusst. Dieselbe Überlegung wie bei `hoechstens_bytes` eine
         Zeile darüber: Eine zweite Zahl in der Oberfläche wäre die,
         die beim Ändern vergessen wird. */
      bilder_max: BILDER_MAX,
      text_max: TEXT_MAX,
    });
  } catch (fehler) {
    console.error("[support] Liste:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** EIN Bild — egal ob es zur Meldung oder zu einer Antwort gehört.
 *
 *  ==== EINE ROUTE STATT DREI (02.10.2026) ==========================
 *
 *  Hier standen zwei: `/:id/bild` für das Bild der Meldung und
 *  `/:id/runde/:nr/bild` für das der Antwort. Mit bis zu drei Bildern
 *  je Stelle hätte jede eine laufende Nummer dazubekommen — zwei
 *  Routen, die dasselbe tun, und eine dritte Zählung, die zu nichts
 *  gehört außer zur Reihenfolge in der Anzeige.
 *
 *  Jetzt hat jedes Bild eine eigene Nummer (die Zeile in
 *  `support_bilder`), und die Adresse nennt sie. Wohin es gehört,
 *  steht in der Zeile — der Weg muss es nicht noch einmal sagen.
 *
 *  DIE MELDUNGSNUMMER BLEIBT TROTZDEM IM PFAD, obwohl die Bildnummer
 *  allein eindeutig wäre. Sie ist die SICHTBARKEITSFRAGE: Wer die
 *  Meldung sehen darf, sieht ihre Bilder. Stünde sie nicht im Pfad,
 *  müsste die Route sie aus der Bildzeile nachschlagen — dasselbe
 *  Ergebnis, aber ein Blick in den Quelltext mehr, um es zu wissen.
 *  Beides muss zusammenpassen, sonst 404.
 *
 *  Dieselben Kopfzeilen wie beim Chat-Anhang: der Typ aus der
 *  ERKENNUNG (nicht der eingeschickte), nosniff, und eine Richtlinie,
 *  die dem Dokument jede Ausführung nimmt.
 *
 *  404 UND NICHT 403, wie überall im Haus: Wer eine fremde Meldung
 *  nicht sehen darf, soll auch nicht erfahren, dass es sie gibt. */
supportRouter.get("/workspace/api/support/:id(\\d+)/bild/:bid(\\d+)", (req, res) => {
  try {
    const m = meldungFuer(req.person, req.params.id);
    if (!m) return res.status(404).json({ fehler: "nicht_gefunden" });
    const b = db().prepare("SELECT datei, typ FROM support_bilder WHERE id = ? AND meldung_id = ?")
      .get(Number(req.params.bid), m.id);
    if (!b) return res.status(404).json({ fehler: "nicht_gefunden" });
    const pfad = join(BILD_ORDNER, b.datei);
    try { statSync(pfad); } catch {
      return res.status(410).json({ fehler: "Das Bild fehlt auf der Platte." });
    }
    res.setHeader("Content-Type", b.typ || "image/png");
    res.setHeader("X-Content-Type-Options", "nosniff");
    res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
    res.setHeader("Cache-Control", "private, max-age=86400");
    liefereDatei(req, res, pfad);
  } catch (fehler) {
    console.error("[support] Bild:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* =====================================================================
   MELDEN
   ===================================================================== */

/** Vor express.raw: Darf diese Person überhaupt melden?
 *
 *  Angemeldet sein genügt — „die jeder sieht, jeder benutzen kann".
 *  Die Prüfung steht trotzdem VOR der Annahme des Rumpfes, sonst
 *  wanderten zwölf Megabyte durch die Leitung, bevor irgendjemand
 *  fragt, wer da schickt. */
function darfMelden(req, res, next) {
  if (!req.person?.id) return res.status(401).json({ fehler: "nicht_angemeldet" });
  const offen = db().prepare(`SELECT COUNT(*) AS n FROM support_meldungen
    WHERE person_id = ? AND stand <> 'erledigt'`).get(req.person.id).n;
  if (offen >= OFFEN_MAX) {
    return res.status(429).json({
      fehler: `Du hast schon ${offen} offene Meldungen. Warte kurz ab, `
        + "bis sich jemand darum gekümmert hat.",
    });
  }
  next();
}

/** Eine Meldung abschicken.
 *
 *  EIN WEG FÜR BEIDES — mit Bild und ohne. Der Text reist im Kopf
 *  (`x-text`, prozentkodiert), das Bild im Rumpf. Zwei Routen zu
 *  bauen („/support" für Text, "/support/bild" für Bild) wäre die
 *  naheliegende Aufteilung und hätte einen Zustand dazwischen: eine
 *  Meldung, die schon existiert, während das Bild noch hochlädt —
 *  und bei einem Abbruch für immer ohne Bild dasteht.
 *
 *  Ein leerer Rumpf ist zulässig: Dann gibt es eben kein Bild. */
supportRouter.post("/workspace/api/support",
  darfMelden,
  /* DREIMAL DIE EINZELGRENZE. Das Paket darf so groß sein wie drei
     erlaubte Bilder — mehr nicht. Hier `BILD_MAX` stehen zu lassen
     hieße: Wer zwei Bildschirmfotos schickt, bekommt eine Absage von
     express, bevor irgendeine Zeile dieses Hauses davon erfährt, und
     sie lautete „request entity too large" statt eines Satzes, mit
     dem jemand etwas anfangen kann. Die Grenze JE BILD prüft
     `rumpfZerlegen` weiterhin selbst. */
  express.raw({ type: "*/*", limit: BILD_MAX * BILDER_MAX }),
  (req, res) => {
    let geschrieben = [];
    try {
      let text = "";
      try { text = decodeURIComponent(req.get("x-text") || ""); } catch { text = ""; }
      text = textSauber(text, TEXT_MAX);
      if (text.length < 5) {
        return res.status(400).json({
          fehler: "Schreib bitte kurz, was los ist – ein Satz reicht.",
        });
      }

      const zerlegt = rumpfZerlegen(req);
      if (zerlegt.fehler) {
        return res.status(zerlegt.fehler.code).json({ fehler: zerlegt.fehler.text });
      }
      const abgelegt = bilderAblegen(zerlegt.teile);
      if (abgelegt.fehler) {
        return res.status(abgelegt.fehler.code).json({ fehler: abgelegt.fehler.text });
      }
      geschrieben = abgelegt.bilder.map((b) => join(BILD_ORDNER, b.datei));

      const n = jetzt();
      /* DIE ALTEN BILDSPALTEN WERDEN NICHT MEHR GEFÜLLT (02.10.2026).
         Sie stehen noch in der Tabelle, weil sie wegzunehmen hieße,
         sie neu zu bauen — und genau dabei gingen am 11.09. drei
         Spalten verloren. Ihr Inhalt ist beim Start nach
         `support_bilder` gewandert; von dort wird ab jetzt gelesen,
         und nur von dort. */
      const info = db().prepare(`INSERT INTO support_meldungen
          (person_id, von_name, von_rolle, text, seite, geraet,
           stand, erstellt, geaendert)
        VALUES (?,?,?,?,?,?,?,?,?)`)
        .run(req.person.id, req.person.name || null, req.person.rolle || null,
          text, sauber(req.get("x-seite"), SEITE_MAX) || null,
          sauber(req.get("user-agent"), GERAET_MAX) || null,
          SUPPORT_STAND.neu, n, n);
      const id = Number(info.lastInsertRowid);
      bilderEintragen(id, null, abgelegt.bilder, n);

      protokolliere("support_gemeldet", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `#${id} ${text.slice(0, 80)}`,
      });

      /* DIE LEITUNG ERFÄHRT ES SOFORT. Eine Meldung, die erst auffällt,
         wenn jemand die Seite zufällig öffnet, ist keine Meldung,
         sondern ein Zettel im Schrank.

         NICHT DRINGEND: Ein kaputter Knopf weckt niemanden um drei Uhr
         nachts. Die Ruhezeit gilt (siehe workspace-push.js). */
      for (const p of db().prepare(
        `SELECT id FROM personen WHERE aktiv = 1 AND rolle IN ('admin','hand')`).all()) {
        benachrichtige(p.id, "support", {
          titel: "Neue Support-Meldung",
          text: text.slice(0, 120),
          ziel: `/workspace/support.html?meldung=${id}`,
        }).catch(() => { /* eine ausgefallene Benachrichtigung darf die
                            Meldung nicht verhindern */ });
      }

      const frisch = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(id);
      res.status(201).json({
        meldung: nachDraussen(frisch, istLeitung(req.person), req.person.id),
      });
    } catch (fehler) {
      /* DIE DATEIEN GEHEN MIT, WENN DIE ZEILE NICHT ZUSTANDE KAM.
         Sonst sammelt der Ordner Bilder an, zu denen es keine Meldung
         gibt — und niemand merkt es, weil nichts darauf zeigt.
         ALLE DREI, nicht nur das letzte: Hier stand eine einzelne
         Variable, und mit mehreren Bildern wäre genau das die stille
         Lücke geworden. */
      for (const p of geschrieben) { try { unlinkSync(p); } catch { /* egal */ } }
      console.error("[support] Melden:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* =====================================================================
   SICH KÜMMERN — nur die Leitung
   ===================================================================== */

/** Stand ändern und antworten.
 *
 *  EINE ROUTE FÜR BEIDES, weil es in der Oberfläche eine Handlung ist:
 *  „erledigt, und zwar deshalb". Zwei Routen hießen zwei Anfragen, und
 *  bei der zweiten kann das Netz abbrechen — dann steht die Meldung
 *  auf „erledigt" ohne den Satz, der sie erklärt. */
/* =====================================================================
   DER MELDER ANTWORTET: GEHT WIEDER ODER NOCH NICHT (25.09.2026)
   =====================================================================

   Filipe: „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."

   NUR DER MELDER, und zwar ausdruecklich NICHT die Leitung: Sonst
   koennte sie ihre eigene Arbeit bestaetigen, und der ganze Umweg
   waere Zierde. Deshalb steht hier `person_id !== req.person.id` --
   nicht „ist Leitung".

   „NOCH NICHT" IST KEINE BESCHWERDE, SONDERN DIE NAECHSTE RUNDE. Die
   Meldung geht zurueck in Arbeit, die Rundenzahl waechst um eins, und
   der Verlauf behaelt, was beim letzten Mal versucht wurde. Nichts
   wird geloescht, und niemand faengt von vorn an.

   EIN WORT DAZU IST BEI „NOCH NICHT" PFLICHT. „Geht immer noch nicht"
   ohne Zusatz erzeugt genau die Rueckfrage, die dieser ganze Weg
   sparen soll. Bei „geht wieder" ist es freiwillig -- da gibt es
   nichts mehr zu klaeren.

   `:id` OHNE MUSTER, dafuer mit einer Pruefung in der Zeile darunter:
   Ein Muster im Pfad ist eine zweite Stelle, an der eine Zahl
   geprueft wird -- und die im Code ist die, die man liest.
   ===================================================================== */
/* ==== EIN BILD DARF MIT (02.10.2026) ===============================

   VanVan: „Wenn man hier im Support auf deine Frage 'geht es wieder'
   reagiert und antwortet, kann man auch kein Bild hinzufügen. Das
   müsstest du auch noch hinzufügen, damit man nochmal ein Bild
   anhängen kann, wenn das Problem noch besteht oder sich durch die
   Änderung ein neues Problem ergeben hat."

   DERSELBE WEG WIE BEIM MELDEN, nicht ein zweiter: Text im Kopf
   (`x-text`, prozentkodiert), Bild im Rumpf, eine Route für beides.
   Die Begründung steht oben bei `POST /workspace/api/support` und
   gilt hier genauso -- zwei Routen hätten einen Zustand dazwischen:
   eine Antwort, die schon zählt, während das Bild noch lädt.

   `x-geht` STATT EINES FELDES IM RUMPF: Der Rumpf ist jetzt das Bild.
   Alles, was keine Bilddatei ist, reist im Kopf -- sonst bräuchte es
   doch wieder zwei Formate.

   EIN LEERER RUMPF IST ZULÄSSIG. Wer kein Bildschirmfoto hat, soll
   trotzdem antworten können; ein Bild ist Hilfe, keine Hürde. */
supportRouter.post("/workspace/api/support/:id/rueckmeldung",
  express.raw({ type: "*/*", limit: BILD_MAX * BILDER_MAX }), (req, res) => {
    let geschrieben = [];
    try {
      const id = Number(req.params.id);
      if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
      const m = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(id);
      /* 404 UND NICHT 403: Wer eine fremde Meldung nicht sehen darf,
         soll auch nicht erfahren, dass es sie gibt. Dieselbe
         Ueberlegung wie ueberall im Haus. */
      if (!m || m.person_id !== req.person.id) {
        return res.status(404).json({ fehler: "nicht_gefunden" });
      }
      /* 404 oben war die SICHTBARKEITSFRAGE, das hier ist die
         STANDFRAGE -- zwei verschiedene Auskünfte, deshalb zwei Codes.
         Gefragt wird mit derselben Funktion, die auch die Knöpfe
         zeigt: Was der Bildschirm anbietet und was der Server annimmt,
         ist damit ein Satz und nicht zwei. */
      if (!darfBestaetigen(m, req.person.id)) {
        return res.status(409).json({
          fehler: "Hier wartet gerade nichts auf deine Antwort.",
        });
      }

      const geht = String(req.get("x-geht") || "") === "ja";
      let roh = "";
      try { roh = decodeURIComponent(req.get("x-text") || ""); } catch { roh = ""; }
      const wort = textSauber(roh, ANTWORT_MAX);
      if (!geht && wort.length < 3) {
        return res.status(400).json({
          fehler: "Schreib kurz, was noch nicht geht – sonst fängt die Suche von vorn an.",
        });
      }

      /* DIE BILDER -- derselbe Weg und dieselbe Absage wie beim
         Melden, und zwar wörtlich dieselben zwei Funktionen. Eine
         eigene Fassung hier wäre die, die beim nächsten Dateityp
         vergessen wird. */
      const zerlegt = rumpfZerlegen(req);
      if (zerlegt.fehler) {
        return res.status(zerlegt.fehler.code).json({ fehler: zerlegt.fehler.text });
      }
      const abgelegt = bilderAblegen(zerlegt.teile);
      if (abgelegt.fehler) {
        return res.status(abgelegt.fehler.code).json({ fehler: abgelegt.fehler.text });
      }
      geschrieben = abgelegt.bilder.map((b) => join(BILD_ORDNER, b.datei));

      const n = jetzt();
      const runde = m.runde || 1;
      db().prepare(`UPDATE support_runden
          SET urteil = ?, urteil_text = ?, urteil_am = ?
        WHERE meldung_id = ? AND nr = ?`)
        .run(geht ? "geht" : "nicht", wort || null, n, m.id, runde);

      /* ==== EINFACH EINTRAGEN -- OHNE „ERSETZEN" (02.10.2026) ======

         Hier stand zuerst: alte Bilder dieser Runde löschen, dann die
         neuen eintragen. Begründung war „wer nachlegt, ersetzt seine
         Antwort, die Bilder müssen mitziehen". Das klang richtig und
         WAR ES NICHT -- die Prüfung dazu ist rot geworden, und zwar
         zu Recht: Der Fall gibt es nicht.

         NACHGEMESSEN: Eine zweite Antwort IN DERSELBEN RUNDE ist
         unmöglich. `darfBestaetigen` verlangt den Stand „wartet", und
         diese Antwort hier verlässt ihn in jedem Fall -- bei „geht"
         nach „erledigt", bei „noch nicht" nach „in Arbeit" UND eine
         Runde weiter. Der Melder bekommt beim zweiten Versuch 409;
         genau das prüft `pruef-support` an zwei Stellen.

         Also wäre das Löschen Code gewesen, der nie läuft -- und
         damit Code, den niemand je prüfen kann. Das ist dieselbe
         Sorte wie die Prüfung, die immer bestätigt: Sie sieht nach
         Sorgfalt aus und trägt nichts.

         DIE GRENZE VON DREI STEHT DAMIT AN EINER STELLE: in
         `rumpfZerlegen`, je Anfrage -- und eine Anfrage je Runde ist
         alles, was es gibt. */
      bilderEintragen(m.id, runde, abgelegt.bilder, n);

      if (geht) {
        db().prepare(`UPDATE support_meldungen
            SET stand = ?, geaendert = ?, erledigt_am = ?, erledigt_von = ?
          WHERE id = ?`)
          .run(SUPPORT_STAND.erledigt, n, n, req.person.id, m.id);
      } else {
        /* ZURUECK IN ARBEIT UND EINE RUNDE WEITER. Nicht auf „neu":
           Es hat ja schon jemand hingesehen, und „neu" waere die Sorte
           Zahl, die morgens laut ist und nichts meint. */
        db().prepare(`UPDATE support_meldungen
            SET stand = ?, runde = ?, geaendert = ?,
                erledigt_am = NULL, erledigt_von = NULL
          WHERE id = ?`)
          .run(SUPPORT_STAND.inArbeit, runde + 1, n, m.id);
      }

      protokolliere(geht ? "support_bestaetigt" : "support_nochmal", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `#${m.id} Runde ${runde}`,
      });

      /* UND DIE LEITUNG ERFAEHRT ES. Ohne diese Zeile merkt niemand,
         dass etwas zurueckgekommen ist -- die Meldung stuende wieder
         in der Liste, aber keiner saehe hin. */
      if (!geht) {
        const leitung = db().prepare(
          "SELECT id FROM personen WHERE rolle IN ('admin','hand') AND aktiv = 1").all();
        for (const l of leitung) {
          benachrichtige(l.id, "support", {
            titel: "Geht noch nicht – Runde " + (runde + 1),
            text: wort.slice(0, 120),
            ziel: `/workspace/support.html?meldung=${m.id}`,
          }).catch(() => { /* eine Meldung, die nicht ankommt, darf die
                              Antwort nicht verhindern */ });
        }
      }

      const frisch = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(m.id);
      res.json({ meldung: nachDraussen(frisch, false, req.person.id) });
    } catch (fehler) {
      /* DIE DATEIEN WIEDER WEG, wenn das Schreiben danach scheitert --
         derselbe Handgriff wie beim Melden. Ohne ihn sammelt der
         Bildordner Dateien an, zu denen es keine Zeile gibt, und
         niemand kann sie je zuordnen. */
      for (const p of geschrieben) { try { unlinkSync(p); } catch { /* egal */ } }
      console.error("[support] Rueckmeldung:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* HIER STAND `/:id/runde/:nr/bild` (02.10.2026 entfernt).
 *
 *  Sie lieferte das EINE Bild einer Antwort und hätte für drei eine
 *  laufende Nummer dazubekommen müssen. Statt zwei fast gleicher
 *  Routen mit je einer Zählung gibt es jetzt eine einzige weiter
 *  oben: `/:id/bild/:bid`. Wohin ein Bild gehört, steht in seiner
 *  Zeile — der Weg muss es nicht wiederholen. */

supportRouter.patch("/workspace/api/support/:id(\\d+)", express.json(), (req, res) => {
  try {
    if (!istLeitung(req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
    const m = db().prepare("SELECT * FROM support_meldungen WHERE id = ?")
      .get(Number(req.params.id));
    if (!m) return res.status(404).json({ fehler: "nicht_gefunden" });

    /* ERLEDIGT IST ERLEDIGT. Eine geschlossene Meldung wird nicht
       stillschweigend wieder geöffnet und anders beantwortet — sonst
       ist „zugemacht" eine Meinung und keine Tatsache. Dieselbe Regel
       wie im vertraulichen Meldeweg. */
    if (m.stand === SUPPORT_STAND.erledigt) {
      return res.status(409).json({
        fehler: "Diese Meldung ist erledigt. Für etwas Neues bitte eine neue.",
      });
    }

    const wunsch = String(req.body?.stand || "");
    if (!Object.values(SUPPORT_STAND).includes(wunsch)) {
      /* EIN SATZ, KEINE KENNUNG (24.09.2026, gefunden von
         pruef-meldungen am selben Tag, an dem diese Datei entstand).

         Hier stand `fehler: "ungueltiger_stand"`. Das Haus verlangt
         zu jeder Kennung einen Satz in meldung.js -- sonst steht auf
         dem Bildschirm ein Wort mit Unterstrichen. Diesen Fall
         trifft ein Mensch zwar nie (die Oberflaeche schickt nur
         gueltige Staende), aber "trifft nie ein" ist genau die
         Begruendung, mit der solche Stellen stehen bleiben, bis sie
         doch jemand sieht.

         Ein Satz direkt hier statt eines Eintrags in der Tabelle:
         Die anderen Absagen dieser Route machen es ebenso, und ein
         Wort, das nur an einer Stelle vorkommt, braucht keine
         Uebersetzung an einer zweiten. */
      return res.status(400).json({
        fehler: "Diesen Stand gibt es nicht. Moeglich sind: neu, "
          + "in Arbeit, erledigt.",
      });
    }
    const antwort = textSauber(req.body?.antwort, ANTWORT_MAX);
    /* WER ZUMACHT, SAGT WARUM. Nicht als Schikane: Der Melder sieht
       nur, dass seine Sache zu ist — ohne einen Satz weiß er nicht, ob
       sie behoben wurde oder ob niemand Lust hatte. */
    if ((wunsch === SUPPORT_STAND.erledigt || wunsch === SUPPORT_STAND.wartet)
        && antwort.length < 3) {
      return res.status(400).json({
        fehler: "Schreib kurz dazu, was daraus geworden ist – der Melder sieht nur das.",
      });
    }

    /* ==== DER MELDER MACHT ZU, NICHT DIE LEITUNG (25.09.2026) ======

       Filipe: „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."

       Wer „erledigt" waehlt, schickt die Meldung deshalb nicht zu,
       sondern ZURUECK AN DEN MELDER. Er sieht die Antwort und sagt,
       ob es bei ihm wirklich geht. Erst sein Druck schliesst.

       DIE AUSNAHME IST NOETIG, SONST HAENGT ES EWIG: Wenn die Leitung
       ihre EIGENE Meldung bearbeitet -- oder der Zugang des Melders
       geloescht wurde --, gibt es niemanden, der bestaetigen koennte.
       Dann bleibt „erledigt" erledigt. Ohne diese Zeile waere jede
       solche Meldung dauerhaft offen, und die Zahl oben stimmte nie
       wieder. */
    const braucht = wunsch === SUPPORT_STAND.erledigt
      && m.person_id && m.person_id !== req.person.id;
    const stand = braucht ? SUPPORT_STAND.wartet : wunsch;

    const n = jetzt();
    db().prepare(`UPDATE support_meldungen
        SET stand = ?, antwort = ?, geaendert = ?,
            erledigt_am = ?, erledigt_von = ?
      WHERE id = ?`)
      .run(stand, antwort || m.antwort || null, n,
        stand === SUPPORT_STAND.erledigt ? n : null,
        stand === SUPPORT_STAND.erledigt ? req.person.id : null,
        m.id);

    /* DIE RUNDE WIRD FESTGEHALTEN, sobald die Leitung antwortet. Sie
       entsteht hier und nicht beim Melden: Runde 1 beginnt mit dem
       ersten „so, probier mal", nicht mit dem Problem. */
    if (stand === SUPPORT_STAND.wartet && antwort) {
      /* NACHLEGEN ERSETZT, ES VERDOPPELT NICHT. Antwortet die Leitung
         ein zweites Mal, waehrend die Meldung schon beim Melder liegt
         („ach, und noch etwas ..."), gehoert das in DIESELBE Runde.
         Ohne diese Zeile stuenden zwei „Runde 1" untereinander, und
         sein spaeteres Urteil traefe beide gleichzeitig. */
      db().prepare(`INSERT INTO support_runden
          (meldung_id, nr, antwort, von_id, von_name, am)
          VALUES (?,?,?,?,?,?)
          ON CONFLICT (meldung_id, nr) DO UPDATE
            SET antwort = excluded.antwort, von_id = excluded.von_id,
                von_name = excluded.von_name, am = excluded.am`)
        .run(m.id, m.runde || 1, antwort, req.person.id, req.person.name, n);
    }

    protokolliere("support_bearbeitet", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${m.id} -> ${wunsch}`,
    });

    /* DER MELDER ERFÄHRT ES. Wer etwas meldet und nie wieder davon
       hört, meldet beim nächsten Mal nichts mehr. */
    if (m.person_id && m.person_id !== req.person.id) {
      benachrichtige(m.person_id, "support", {
        /* DER TITEL SAGT, WER JETZT DRAN IST. „Deine Meldung ist
           erledigt" waere bei „wartet" eine Luege -- sie ist es ja
           erst, wenn er es bestaetigt. Und ein Hinweis, der nicht
           sagt, dass man etwas tun soll, wird weggewischt. */
        titel: stand === SUPPORT_STAND.wartet
          ? "Geht es wieder? Kurz bestätigen"
          : (stand === SUPPORT_STAND.erledigt
            ? "Deine Meldung ist erledigt" : "Jemand kümmert sich"),
        text: antwort ? antwort.slice(0, 120) : m.text.slice(0, 120),
        ziel: `/workspace/support.html?meldung=${m.id}`,
      }).catch(() => { /* siehe oben */ });
    }

    const frisch = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(m.id);
    res.json({ meldung: nachDraussen(frisch, true, req.person.id) });
  } catch (fehler) {
    console.error("[support] Bearbeiten:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* =====================================================================
   AUFRÄUMEN
   ===================================================================== */

/** Erledigte Meldungen nach der Aufbewahrungsfrist entfernen.
 *
 *  Wird aus dem Rundgang aufgerufen, nicht beim Lesen — sonst hängt
 *  das Aufräumen davon ab, dass jemand die Seite öffnet, und auf einem
 *  ruhigen System wächst der Bilderordner still weiter.
 *
 *  DIE DATEI GEHT MIT DER ZEILE. Ein Bild ohne Meldung zeigt auf
 *  nichts und niemand findet es je wieder. */
export function supportAufraeumen() {
  try {
    const grenze = new Date(Date.now() - AUFBEWAHRUNG_TAGE * 86400000).toISOString();
    const alt = db().prepare(`SELECT id FROM support_meldungen
      WHERE stand = 'erledigt' AND erledigt_am IS NOT NULL AND erledigt_am < ?`).all(grenze);
    if (!alt.length) return 0;
    const dazu = db().prepare("SELECT datei FROM support_bilder WHERE meldung_id = ?");
    for (const m of alt) {
      /* ALLE BILDER DER MELDUNG, auch die aus den Antwortrunden
         (02.10.2026). Hier stand `m.bild_datei` — das EINE Bild der
         Meldung. Die Bilder zu den Antworten blieben damit auf der
         Platte liegen, ohne Zeile, die auf sie zeigt; aufgefallen ist
         es beim Umbau auf mehrere Bilder, nicht im Betrieb. Dass die
         Liste jetzt aus einer Abfrage kommt statt aus einer Spalte,
         ist der Grund, warum sie beim nächsten Ort nicht wieder
         unvollständig sein kann. */
      for (const b of dazu.all(m.id)) {
        try { unlinkSync(join(BILD_ORDNER, b.datei)); } catch { /* schon weg */ }
      }
      /* Die Zeilen in `support_bilder` gehen über ON DELETE CASCADE
         mit — vorausgesetzt, die Fremdschlüssel sind eingeschaltet.
         Deshalb hier zusätzlich von Hand: Eine Aufräumfunktion, die
         von einer Einstellung abhängt, räumt irgendwann nicht auf. */
      db().prepare("DELETE FROM support_bilder WHERE meldung_id = ?").run(m.id);
      db().prepare("DELETE FROM support_meldungen WHERE id = ?").run(m.id);
    }
    console.log(`[support] ${alt.length} erledigte Meldungen aelter als `
      + `${AUFBEWAHRUNG_TAGE} Tage entfernt.`);
    return alt.length;
  } catch (fehler) {
    console.error("[support] Aufraeumen:", fehler?.message);
    return 0;
  }
}