B1: Das Anschlagbrett haelt 24 Stunden -- und sieht aus wie ein Anschlagbrett

"die sachen sollen in der seite vom anschlagbrett immer automatisch
nach 24h von da verschwinden. weil alles hat seine kategorie und was
nicht ist auch nicht um ewig auf der seite zu bleiben fertig."

SEINE BEGRUENDUNG IST DIE REGEL. Ein Anschlagbrett sagt, was GERADE
gilt. Was laenger gilt, hat seinen eigenen Bereich -- Regeln stehen bei
den Regeln, Termine bei "Was ansteht". Eine Ansage vom letzten
Dienstag, die noch haengt, ist keine Ansage mehr, sondern Papier an der
Wand.

DIE DREI ENTSCHEIDUNGEN, DIE ICH TREFFEN MUSSTE -- und woran ich sie
festgemacht habe:

1. AB WANN LAUFEN DIE 24 STUNDEN? Ab `erstellt`, nicht ab `datum`.
   `datum` ist ein vom Team gesetztes Feld und kann in der Zukunft
   liegen (es traegt die Termine). Eine Ansage, die morgen gilt, soll
   morgen verschwinden und nicht uebermorgen.

2. VERSCHWINDET SIE GANZ? Nein. Er sagt "von DA verschwinden" -- von
   der Seite. Geloescht wird nichts: Wer eine Ansage geschrieben hat,
   soll sie wiederfinden. Sie kommt als `abgehaengt` mit und steht
   zugeklappt unter einer leisen Zeile "Abgehaengt (3)". Auf dem Brett
   selbst steht sie damit nicht mehr.

3. WER ENTSCHEIDET? Der Server. Die Stunden im Browser nachzurechnen
   waere eine zweite Fassung derselben Regel, und eine davon waere
   irgendwann aelter. Die Frist geht als Zahl mit der Antwort.

DAS AUSSEHEN ("viel besser gestaltet, übersichtlicher, moderner,
hochwertiger, professioneller"): Was haengt, sieht jetzt aus wie etwas,
das haengt -- kraeftiger Rand links in der Farbe seiner ART (Ansage
babyblau, Neue Regel gold, Hinweis lila, Danke gruen), ein Schein von
links, mehr Luft. Die Art stand bisher nur im Text; jetzt sieht man
sie. Abgehaengtes ist grau statt durchsichtig -- durchsichtig hiesse,
das Buehnenbild scheint durch, also Text auf einem Foto.

pruef-anschlagbrett.mjs (NEU, 12/0) misst beide Seiten der Grenze
(23 h haengt, 25 h nicht), rechnet relativ zur jetzigen Uhrzeit statt
mit einem festen Datum, und hat den Eintrag, an dem sich alles
entscheidet: alt aufgehaengt, Datum von heute. Wer nach `datum`
filtert, laesst ihn haengen. Dazu zwei Gegenproben: auf jedem anderen
Brett gibt es das Merkmal gar nicht, und wo die Grenze WIRKLICH liegt,
wird aus den Eintraegen nachgerechnet statt aus der Zahl im Modul.

NEBENBEFUND, den erst dieser Commit ausgeloest hat
---------------------------------------------------
pruef-bereiche-lesend stuerzte ab: "listen EACCES 127.0.0.1:5040".

Die Portnummern werden aus der Stelle im Alphabet abgeleitet -- heute
sind fuenf neue Pruefdateien dazugekommen, und dadurch ist diese
Pruefung auf die 5040 gerutscht. Die haelt auf diesem Rechner ein
Windows-Dienst (svchost, PID 7136).

`portMussFreiSein` kannte nur ZWEI Antworten: EADDRINUSE oder frei.
EACCES galt als frei -- die Pruefung lief weiter, bis der echte Server
auf demselben Port startete und mit einem unbehandelten Fehler
abstuerzte. Ein Stapelauszug aus node:net, der wie ein Fehler im Code
aussieht.

Jetzt drei Antworten. Und ein belegter Port wird anders behandelt als
ein gesperrter: Belegt geht vorbei (der andere Lauf hoert auf),
gesperrt nie. Abzubrechen hiesse, die Pruefung waere auf diesem Rechner
dauerhaft nicht ausfuehrbar -- die Sorte Warnung, die immer kommt und
deshalb weggeklickt wird. Ausgewichen wird um einen festen Betrag
(+4000), damit die Nummer abgeleitet und eindeutig bleibt.

Mitgelaufen und gruen: pruef-bereiche-lesend, pruef-css-klassen.

Co-Authored-By: Claude Opus 5 <[email protected]>

server/helfer-port.mjs

@@ -34,16 +34,72 @@
 
 import { createServer } from "node:net";
 
-/** Wirft, wenn der Port belegt ist. Sonst gibt er ihn frei zurück. */
-export async function portMussFreiSein(port, wer = "diese Pruefung") {
-  const belegt = await new Promise((fertig) => {
+/** Was ist mit diesem Port los?
+ *
+ *  DREI ANTWORTEN, NICHT ZWEI (22.09.2026) -- und die dritte hat
+ *  heute gefehlt:
+ *
+ *    null       frei
+ *    EADDRINUSE jemand hoert darauf (meist ein zweiter Prueflauf)
+ *    EACCES     das System gibt ihn nicht her -- dauerhaft
+ *
+ *  Vorher wurde NUR auf EADDRINUSE geprueft; jeder andere Fehler galt
+ *  als "frei". Auf diesem Rechner haelt ein Windows-Dienst (svchost,
+ *  PID 7136) den Port 5040. `createServer().listen` scheiterte dort mit
+ *  EACCES, die Antwort war trotzdem "frei", und die Pruefung lief
+ *  weiter -- bis der ECHTE Server auf demselben Port startete und mit
+ *  einem unbehandelten Fehler abstuerzte. Eine Meldung, die "belegt"
+ *  heissen muesste, kam nie; stattdessen ein Stapelauszug aus
+ *  node:net, der wie ein Fehler im Code aussieht.
+ *
+ *  Aufgefallen ist es, weil die Nummern sich verschoben haben: Sie
+ *  werden aus der Stelle im Alphabet abgeleitet, und heute sind fuenf
+ *  neue Pruefdateien dazugekommen. Der Fall lag also seit Langem da
+ *  und wartete nur darauf, dass jemand auf die 5040 rutscht. */
+async function portLage(port) {
+  return new Promise((fertig) => {
     const s = createServer();
-    s.once("error", (f) => fertig(f.code === "EADDRINUSE"));
-    s.once("listening", () => s.close(() => fertig(false)));
+    s.once("error", (f) => fertig(f.code || "FEHLER"));
+    s.once("listening", () => s.close(() => fertig(null)));
     s.listen(port, "127.0.0.1");
   });
+}
 
-  if (belegt) {
+/** Wirft, wenn der Port belegt ist. Sonst gibt er ihn frei zurück. */
+export async function portMussFreiSein(port, wer = "diese Pruefung") {
+  const lage = await portLage(port);
+
+  /* DAUERHAFT GESPERRT -> AUSWEICHEN, NICHT ABBRECHEN.
+     ------------------------------------------------------------------
+     Ein belegter Port ist ein Zustand, der vorbeigeht: Der andere Lauf
+     hoert auf, und danach geht es. Ein vom System reservierter Port
+     geht NIE. Abzubrechen hiesse, diese Pruefung waere auf diesem
+     Rechner dauerhaft nicht ausfuehrbar -- und das waere die Sorte
+     Warnung, die immer kommt und deshalb weggeklickt wird.
+
+     Ausgewichen wird um einen festen Betrag, nicht auf "den naechsten
+     freien": Damit bleibt die Nummer ABGELEITET und eindeutig. Zwei
+     Pruefungen, die beide ausweichen, landen auf zwei verschiedenen
+     Nummern, weil ihre Ausgangsnummern verschieden waren. */
+  if (lage === "EACCES") {
+    const ersatz = port + AUSWEICHEN;
+    const lage2 = await portLage(ersatz);
+    if (lage2 === null) {
+      console.log(`[Port] ${port} ist vom System belegt (EACCES) --`
+        + ` ${wer} nimmt ${ersatz}.`);
+      return ersatz;
+    }
+    console.error(`\nABBRUCH: Port ${port} ist vom System gesperrt, und der`);
+    console.error(`  Ausweichport ${ersatz} ist ebenfalls nicht frei (${lage2}).\n`);
+    console.error(`  ${wer} kann hier nicht messen. Das ist KEIN Befund am Code --`);
+    console.error(`  es heisst nur, dass gerade niemand nachsehen konnte.\n`);
+    console.error(`  Nachsehen, wer die Ports haelt:`);
+    console.error(`    netstat -ano | findstr :${port}`);
+    console.error(`    netstat -ano | findstr :${ersatz}\n`);
+    process.exit(3);
+  }
+
+  if (lage !== null) {
     console.error(`\nABBRUCH: Port ${port} ist belegt.\n`);
     console.error(`  ${wer} startet einen eigenen Server auf diesem Port. Laeuft dort`);
     console.error(`  schon etwas, wuerde gegen einen FREMDEN Stand gemessen -- mit`);
@@ -124,6 +180,12 @@ import { basename, dirname } from "node:path";
  *  werden: "irgendwo ueber 4400" haette plausibel geklungen. */
 const BASIS = 5000;
 const PRO_DATEI = 2;
+/** Um wie viel ausgewichen wird, wenn das System einen Port nicht
+ *  hergibt. 4000 liegt sicher oberhalb des ganzen abgeleiteten
+ *  Bereichs (BASIS bis BASIS+5000 in Schritten von 2, bei derzeit
+ *  rund 180 Dateien also bis etwa 5400) -- zwei Pruefungen koennen
+ *  sich dadurch nicht ins Gehege kommen, auch wenn beide ausweichen. */
+const AUSWEICHEN = 4000;
 
 /** Der Port dieser Datei -- abgeleitet, nicht vergeben.
  *