Versionsstempel auf 202609211145

chat.css hat sich geaendert. Ohne den Stempel behaelt jeder Browser
seine alte Kopie, und die groesseren Farbkacheln kaemen bei niemandem
an. 505 Verweise in 37 Dateien.

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

server/helfer-port.mjs

@@ -56,3 +56,157 @@ export async function portMussFreiSein(port, wer = "diese Pruefung") {
   }
   return port;
 }
+
+/* =====================================================================
+   WELCHER PORT GEHOERT MIR? (20.09.2026)
+
+   ---------------------------------------------------------------------
+   WARUM ES DIESE FUNKTION GIBT
+
+   Gemessen am 20.09.2026: 164 Pruefdateien, 129 verschiedene Ports --
+   NEUNZEHN Nummern waren doppelt vergeben, eine sogar dreifach
+   (4186, 4188, 4196, 4198 ...). Niemand hatte das absichtlich getan;
+   jede neue Pruefung wurde von einer vorhandenen abgeschrieben, und
+   die Nummer kam mit.
+
+   Der Waechter darueber faengt den Schaden ab -- er bricht ab, statt
+   gegen einen fremden Server zu messen. Aber er kann nur melden, was
+   schon passiert ist: Zwei Pruefungen mit derselben Nummer koennen nie
+   gleichzeitig laufen, und ein liegengebliebener Prozess der einen
+   laesst die andere mit einer Meldung abbrechen, die wie ein Befund
+   aussieht. Genau das ist mir heute zweimal passiert.
+
+   EINE GEPFLEGTE NUMMERNLISTE IST DIE FALSCHE LOESUNG. Dieses Haus ist
+   an abgeschriebenen Listen schon dreimal gescheitert (Spaltenliste
+   beim Datenumbau, Namensliste in pruef-anruf, Namensliste in
+   pruef-entwicklung). Eine Liste, die niemand pflegt, kann nicht
+   veralten -- also wird die Nummer ABGELEITET.
+
+   ---------------------------------------------------------------------
+   WIE ABGELEITET WIRD, UND WARUM NICHT MIT EINER PRUEFSUMME
+
+   Der naheliegende Weg waere ein Hash des Dateinamens. Nachgerechnet
+   ist er der schlechtere: Bei 164 Namen in 4900 moeglichen Ports sind
+   nach dem Geburtstagsproblem rund DREI Zusammenstoesse zu erwarten --
+   der Hash tauscht eine sichtbare Doppelung gegen eine unsichtbare.
+
+   Stattdessen: die Stelle im Alphabet. Alle `pruef-*.mjs` im selben
+   Ordner werden sortiert, und wer an Stelle n steht, bekommt Port
+   BASIS + n*2. Das ist NICHT ZUFAELLIG EINDEUTIG, sondern eindeutig
+   von der Bauart her -- zwei Dateien koennen nicht dieselbe Stelle im
+   Alphabet haben.
+
+   Jede Datei bekommt ZWEI Nummern (nr = 0 und 1). Fuenf Pruefungen
+   starten heute einen zweiten Server; der braucht dann keinen eigenen
+   Eintrag irgendwo.
+
+   Nebenwirkung, bewusst in Kauf genommen: Kommt eine neue Pruefung
+   dazu, verschieben sich die Nummern dahinter. Das ist harmlos -- es
+   sind Testports, kein Mensch merkt sie sich -- und der Waechter faengt
+   den einen Fall ab, in dem es zaehlt (ein Prozess von vorhin liegt
+   noch auf der Nummer).
+   ===================================================================== */
+
+import { readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { basename, dirname } from "node:path";
+
+/** Ab hier aufwaerts, zwei je Datei.
+ *
+ *  NICHT 4100: Der echte Dienst hoert dort, und eine Pruefung, die
+ *  versehentlich dorthin zielt, waere der eine Fehler, den der Waechter
+ *  NICHT erkennen kann -- sie bekaeme brav Antworten.
+ *
+ *  UND NICHT 4500, wie hier zuerst stand. Nachgemessen reichen die
+ *  bisher von Hand vergebenen Nummern von 4176 bis 4504 -- der Bereich
+ *  4500-4827 haette sich also mit dem obersten Rest ueberschnitten.
+ *  Das ist der Grund, warum solche Zahlen gemessen und nicht geschaetzt
+ *  werden: "irgendwo ueber 4400" haette plausibel geklungen. */
+const BASIS = 5000;
+const PRO_DATEI = 2;
+
+/** Der Port dieser Datei -- abgeleitet, nicht vergeben.
+ *
+ *  `meta` ist `import.meta` der aufrufenden Datei. Prueft danach
+ *  gleich, ob er frei ist, und bricht sonst ab (siehe oben).
+ *
+ *  DRITTER AUSGANG: Findet sich die eigene Datei nicht in der Liste --
+ *  etwa weil jemand die Funktion aus einem anderen Ordner aufruft --,
+ *  wird NICHT geraten. Eine geratene Nummer waere genau die Doppelung,
+ *  die hier abgeschafft wird. */
+/* =====================================================================
+   PORTS, DIE `fetch` NICHT ANFASST (20.09.2026, teuer gelernt)
+
+   Die Fetch-Spezifikation fuehrt eine Liste "bad ports" -- Nummern, auf
+   die ein Browser KEINE Verbindung aufbaut, weil sich ueber sie fremde
+   Dienste missbrauchen liessen (SMTP, NNTP, SIP, IRC und andere). Node
+   hat diese Liste uebernommen: `fetch` wirft dort `TypeError: fetch
+   failed` mit der Ursache `bad port`, noch bevor ein Paket fliegt.
+
+   WIE ES AUFGEFALLEN IST: Nach der Umstellung auf abgeleitete Nummern
+   bekam pruef-chat-kanaele die 5060 -- und stuerzte ab, obwohl der
+   Server nachweislich lief ("Server laeuft auf http://127.0.0.1:5060")
+   und die Anmeldung ueber `http.request` sogar geklappt hatte. Nur die
+   `fetch`-Aufrufe scheiterten. 5060 ist SIP und steht auf der Liste.
+
+   WARUM DAS SO SCHWER ZU FINDEN WAR: Die Meldung lautet "fetch failed"
+   -- dieselbe Meldung wie bei einem Server, der nicht laeuft. Wer sie
+   liest, sucht am Server. Der Unterschied steht erst in `.cause`:
+   `bad port` statt `ECONNREFUSED`. Gegengeprueft mit einem echten
+   Zuhoerer auf 5060: Port 5060 -> "bad port", Port 5062 -> sauberes
+   "ECONNREFUSED". Die Sperre ist also real und trifft genau diese
+   Nummern.
+
+   NEBENBEFUND: Auch im alten, von Hand vergebenen Bereich lag eine --
+   die 4190 (ManageSieve). Sie war nie vergeben, rein zufaellig.
+   ===================================================================== */
+const GESPERRT = new Set([
+  1, 7, 9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 37, 42, 43, 53, 69, 77, 79,
+  87, 95, 101, 102, 103, 104, 109, 110, 111, 113, 115, 117, 119, 123, 135, 137,
+  138, 139, 143, 161, 179, 389, 427, 465, 512, 513, 514, 515, 526, 530, 531,
+  532, 540, 548, 554, 556, 563, 587, 601, 636, 989, 990, 993, 995, 1719, 1720,
+  1723, 2049, 3659, 4045, 4190, 5060, 5061, 6000, 6566, 6665, 6666, 6667, 6668,
+  6669, 6679, 6697, 10080,
+]);
+
+/** Die n-te brauchbare Nummer ab BASIS -- gesperrte werden uebersprungen.
+ *
+ *  Damit bleibt die Ableitung eindeutig (die Reihenfolge steht fest),
+ *  ohne dass eine gesperrte Nummer je herauskommt. Eine Liste von
+ *  Ausnahmen musste dafuer niemand pflegen: Uebersprungen wird nach
+ *  der Regel, nicht nach einer Tabelle von Sonderfaellen.
+ */
+export function portNummer(nte) {
+  let p = BASIS;
+  let uebrig = nte;
+  while (true) {
+    if (!GESPERRT.has(p)) {
+      if (uebrig === 0) return p;
+      uebrig -= 1;
+    }
+    p += 1;
+    if (p > BASIS + 5000) {
+      throw new Error("[Port] Kein freier Nummernbereich mehr oberhalb von " + BASIS + ".");
+    }
+  }
+}
+
+export async function eigenerPort(meta, wer = null, nr = 0) {
+  const pfad = fileURLToPath(meta.url);
+  const mein = basename(pfad);
+  const ordner = dirname(pfad);
+  const alle = readdirSync(ordner)
+    .filter((f) => f.startsWith("pruef-") && f.endsWith(".mjs"))
+    .sort();
+  const stelle = alle.indexOf(mein);
+  if (stelle < 0) {
+    throw new Error(
+      `[Port] ${mein} steht nicht in der Liste der Pruefdateien in ${ordner}.\n`
+      + "  Die Nummer wird aus der Stelle im Alphabet abgeleitet -- ohne\n"
+      + "  Stelle gibt es keine Nummer, und geraten wird nicht.");
+  }
+  if (nr < 0 || nr >= PRO_DATEI) {
+    throw new Error(`[Port] Es gibt ${PRO_DATEI} Nummern je Datei (0 und 1), nicht ${nr}.`);
+  }
+  return portMussFreiSein(portNummer(stelle * PRO_DATEI + nr), wer || mein.replace(/\.mjs$/, ""));
+}

server/pruef-abbrechen-optik.mjs

@@ -29,10 +29,10 @@ const ordner = mkdtempSync(join(tmpdir(), "ws-abopt-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
 import { notbremse } from "./helfer-notbremse.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4297, "die Optikpruefung des Abbrechens");
+const PORT = await eigenerPort(import.meta, "die Optikpruefung des Abbrechens");
 
-process.env.PORT = "4297";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -47,7 +47,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-abbrechen-optik");
 await new Promise((r) => setTimeout(r, 900));
-const BASIS = "http://127.0.0.1:4297";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 const PROTOKOLL = join(process.cwd(), "pruef-abbrechen-optik-lauf.txt");
 try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }

server/pruef-abbrechen.mjs

@@ -90,9 +90,9 @@ const altPfad = join(ordner, "alt.db");
 /* Der Server wird jetzt AUF DIESER Datei gestartet -- die Umstellung
    läuft beim Import. */
 process.env.WORKSPACE_DB = altPfad;
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4295, "die Abbruchpruefung");
+const PORT = await eigenerPort(import.meta, "die Abbruchpruefung");
-process.env.PORT = "4295";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -101,7 +101,7 @@ 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");
 await new Promise((r) => setTimeout(r, 1400));
-const BASIS = "http://127.0.0.1:4295";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 {
   const p = new DatabaseSync(altPfad);

server/pruef-agentur.mjs

@@ -36,9 +36,8 @@ import { scryptSync, randomBytes } from "node:crypto";
 import { heuteLokal } from "./helfer-zeit.mjs";
 
 const HIER = dirname(fileURLToPath(import.meta.url));
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-const PORT = 4341;
+const PORT = await eigenerPort(import.meta, "die Agentur-Pruefung");
-await portMussFreiSein(PORT, "die Agentur-Pruefung");
 const BASIS = `http://127.0.0.1:${PORT}`;
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-agentur-"));

server/pruef-alle-sehen-es.mjs

@@ -39,9 +39,9 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4495, "pruef-alle-sehen-es");
+const PORT = await eigenerPort(import.meta, "pruef-alle-sehen-es");
 const ordner = mkdtempSync(join(tmpdir(), "ws-sicht-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-alle-wege.mjs

@@ -44,10 +44,10 @@ const ordner = mkdtempSync(join(tmpdir(), "ws-wege-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 /* Der Port muss frei sein -- sonst wird gegen einen fremden Server
    gemessen. Begruendung in helfer-port.mjs. */
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4247, "die Wegepruefung");
+const PORT = await eigenerPort(import.meta, "die Wegepruefung");
 
-process.env.PORT = "4247";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -56,7 +56,7 @@ 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");
 await new Promise((r) => setTimeout(r, 900));
-const BASIS = "http://127.0.0.1:4247";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 let fehler = 0;
 const ok = (b, t) => { console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

server/pruef-alter.mjs

@@ -29,9 +29,9 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4413, "pruef-alter");
+const PORT = await eigenerPort(import.meta, "pruef-alter");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-alter-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-ampel.mjs

@@ -16,8 +16,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4206, "pruef-ampel");
+const PORT = await eigenerPort(import.meta, "pruef-ampel");
-process.env.PORT = "4206";
+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";
@@ -26,7 +26,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -35,7 +35,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-ampel");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4206";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 250_000).unref?.();
 
 /* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des

server/pruef-anhaenge.mjs

@@ -31,9 +31,9 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4416, "pruef-anhaenge");
+const PORT = await eigenerPort(import.meta, "pruef-anhaenge");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-anh-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-anruf-ruhezeit.mjs

@@ -25,9 +25,9 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4199, "pruef-anruf-ruhezeit");
+const PORT = await eigenerPort(import.meta, "pruef-anruf-ruhezeit");
 const ordner = mkdtempSync(join(tmpdir(), "ws-ruhe-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-anruf.mjs

@@ -20,9 +20,9 @@ import { mkdtempSync, rmSync, writeFileSync, unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4196, "pruef-anruf");
+const PORT = await eigenerPort(import.meta, "pruef-anruf");
 const ordner = mkdtempSync(join(tmpdir(), "ws-anruf-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-arten.mjs

@@ -68,9 +68,8 @@ import { notbremse } from "./helfer-notbremse.mjs";
 notbremse(300_000, "die Artenpruefung");
 
 const HIER = dirname(fileURLToPath(import.meta.url));
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-const PORT = 4359;
+const PORT = await eigenerPort(import.meta, "die Artenpruefung");
-await portMussFreiSein(PORT, "die Artenpruefung");
 const BASIS = `http://127.0.0.1:${PORT}`;
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-arten-"));

server/pruef-aufbewahrung.mjs

@@ -26,9 +26,9 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4410, "pruef-aufbewahrung");
+const PORT = await eigenerPort(import.meta, "pruef-aufbewahrung");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-aufb-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-aufgaben-vorlagen.mjs

@@ -25,8 +25,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4211, "pruef-aufgaben-vorlagen");
+const PORT = await eigenerPort(import.meta, "pruef-aufgaben-vorlagen");
-process.env.PORT = "4211";
+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";
@@ -35,11 +35,11 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 notbremse(240_000, "pruef-aufgaben-vorlagen");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4211";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 let fehler = 0;
 const ok = (b, t) => { console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

server/pruef-aufgabenbrett.mjs

@@ -40,8 +40,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4216, "pruef-aufgabenbrett");
+const PORT = await eigenerPort(import.meta, "pruef-aufgabenbrett");
-process.env.PORT = "4216";
+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";
@@ -50,7 +50,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -59,7 +59,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-aufgabenbrett");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4216";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();
 
 /* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des

server/pruef-auskunft.mjs

@@ -31,9 +31,9 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4412, "pruef-auskunft");
+const PORT = await eigenerPort(import.meta, "pruef-auskunft");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-ausk-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-barrierefrei-workspace.mjs

@@ -35,10 +35,10 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 /* Der Port muss frei sein -- sonst wird gegen einen fremden Server
    gemessen. Begruendung in helfer-port.mjs. */
 import { notbremse } from "./helfer-notbremse.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4253, "die Barrierefreiheitspruefung");
+const PORT = await eigenerPort(import.meta, "die Barrierefreiheitspruefung");
 
-process.env.PORT = "4253";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -53,7 +53,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-barrierefrei-workspace");
 await new Promise((r) => setTimeout(r, 900));
-const BASIS = "http://127.0.0.1:4253";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 let fehler = 0;
 const ok = (b, t) => { console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

server/pruef-befinden.mjs

@@ -30,9 +30,9 @@ import { mkdtempSync, rmSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4419, "pruef-befinden");
+const PORT = await eigenerPort(import.meta, "pruef-befinden");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-bef-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-bereiche-lesend.mjs

@@ -13,7 +13,7 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-bereiche-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
@@ -22,8 +22,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4183, "pruef-bereiche-lesend");
+const PORT = await eigenerPort(import.meta, "pruef-bereiche-lesend");
-process.env.PORT = "4183";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -34,7 +34,7 @@ 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");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4183";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 180_000).unref?.();
 
 /* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des

server/pruef-betreuung.mjs

@@ -12,7 +12,7 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-betreuung-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
@@ -21,8 +21,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4189, "pruef-betreuung");
+const PORT = await eigenerPort(import.meta, "pruef-betreuung");
-process.env.PORT = "4189";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -33,7 +33,7 @@ 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");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4189";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 200_000).unref?.();
 
 let fehler = 0;

server/pruef-bewerbung.mjs

@@ -38,9 +38,9 @@ import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4504, "pruef-bewerbung");
+const PORT = await eigenerPort(import.meta, "pruef-bewerbung");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-bewerb-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-breiten.mjs

@@ -38,10 +38,10 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 /* Der Port muss frei sein -- sonst wird gegen einen fremden Server
    gemessen. Begruendung in helfer-port.mjs. */
 import { notbremse } from "./helfer-notbremse.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4277, "die Breitenpruefung");
+const PORT = await eigenerPort(import.meta, "die Breitenpruefung");
 
-process.env.PORT = "4277";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -56,7 +56,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-breiten");
 await new Promise((r) => setTimeout(r, 900));
-const BASIS = "http://127.0.0.1:4277";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 let fehler = 0;
 const ok = (b, t) => { console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

server/pruef-bremse.mjs

@@ -41,10 +41,10 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { heuteLokal } from "./helfer-tag.mjs";
 
-const PORT = await portMussFreiSein(4485, "pruef-bremse");
+const PORT = await eigenerPort(import.meta, "pruef-bremse");
 const ordner = mkdtempSync(join(tmpdir(), "ws-bremse-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-browser.mjs

@@ -40,10 +40,10 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 /* Der Port muss frei sein -- sonst wird gegen einen fremden Server
    gemessen. Begruendung in helfer-port.mjs. */
 import { notbremse } from "./helfer-notbremse.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4289, "die Browserpruefung");
+const PORT = await eigenerPort(import.meta, "die Browserpruefung");
 
-process.env.PORT = "4289";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -58,7 +58,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-browser");
 await new Promise((r) => setTimeout(r, 900));
-const BASIS = "http://127.0.0.1:4289";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 /* LAUFEND MITSCHREIBEN, nicht erst am Ende.
 

server/pruef-buehne.mjs

@@ -105,8 +105,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4193, "pruef-buehne");
+const PORT = await eigenerPort(import.meta, "pruef-buehne");
-process.env.PORT = "4193";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -116,7 +116,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -125,7 +125,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(120_000 + SEITEN_ZEIT, "pruef-buehne");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4193";
+const BASIS = `http://127.0.0.1:${PORT}`;
 /* Die Frist waechst mit der Liste: 220 s reichten fuer sechs Seiten.
    Eine feste Zahl waere hier eine Zeitbombe -- die zwoelf neuen
    haetten sie gerissen, und der Abbruch saehe aus wie ein Befund. */

server/pruef-call-kategorien.mjs

@@ -28,10 +28,10 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
 import { notbremse } from "./helfer-notbremse.mjs";
 import { sauberBeenden } from "./helfer-beenden.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4321, "die Kategorienpruefung");
+const PORT = await eigenerPort(import.meta, "die Kategorienpruefung");
 
-process.env.PORT = "4321";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -46,7 +46,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-call-kategorien");
 await new Promise((r) => setTimeout(r, 1000));
-const BASIS = "http://127.0.0.1:4321";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 const PROTOKOLL = join(process.cwd(), "pruef-call-kategorien-lauf.txt");
 try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }

server/pruef-chat-anhaenge.mjs

@@ -34,10 +34,10 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
 import { notbremse } from "./helfer-notbremse.mjs";
 import { bestaetige } from "./helfer-nachfrage.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4323, "die Chat-Anhangpruefung");
+const PORT = await eigenerPort(import.meta, "die Chat-Anhangpruefung");
 
-process.env.PORT = "4323";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -47,7 +47,7 @@ express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(
 await import("./index.js");
 notbremse(600_000, "pruef-chat-anhaenge");
 await new Promise((r) => setTimeout(r, 1000));
-const BASIS = "http://127.0.0.1:4323";
+const BASIS = `http://127.0.0.1:${PORT}`;
 const ANHANG_ORDNER = join(ordner, "chat-anhaenge");
 
 const PROTOKOLL = join(process.cwd(), "pruef-chat-anhaenge-lauf.txt");

server/pruef-chat-aufloesen.mjs

@@ -37,13 +37,13 @@ const HIER_BILD = dirname(fileURLToPath(import.meta.url));
 const ordner = mkdtempSync(join(tmpdir(), "ws-aufloesen-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4391, "die Aufloesen-Pruefung");
+const PORT = await eigenerPort(import.meta, "die Aufloesen-Pruefung");
 
-process.env.PORT = "4391";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
-const BASIS = "http://127.0.0.1:4391";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 await import("./index.js");
 
@@ -104,7 +104,7 @@ function anmelden(rolle, code, wand = "crew.dogfather-universe.com") {
   return new Promise((fertig) => {
     const rumpf = JSON.stringify({ rolle, code });
     const a = httpAnfrage({
-      host: "127.0.0.1", port: 4391, path: "/workspace/api/anmelden", method: "POST",
+      host: "127.0.0.1", port: PORT, path: "/workspace/api/anmelden", method: "POST",
       headers: {
         "Content-Type": "application/json",
         "Content-Length": Buffer.byteLength(rumpf),

server/pruef-chat-ausbau.mjs

@@ -32,10 +32,10 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
 import { notbremse } from "./helfer-notbremse.mjs";
 import { bestaetige } from "./helfer-nachfrage.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4319, "die Chat-Ausbaupruefung");
+const PORT = await eigenerPort(import.meta, "die Chat-Ausbaupruefung");
 
-process.env.PORT = "4319";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -45,7 +45,7 @@ express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(
 await import("./index.js");
 notbremse(480_000, "pruef-chat-ausbau");
 await new Promise((r) => setTimeout(r, 1000));
-const BASIS = "http://127.0.0.1:4319";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 const PROTOKOLL = join(process.cwd(), "pruef-chat-ausbau-lauf.txt");
 try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }

server/pruef-chat-kanaele.mjs

@@ -46,10 +46,10 @@ import { join } from "node:path";
 const ordner = mkdtempSync(join(tmpdir(), "ws-kanal-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4377, "die Kanalpruefung");
+const PORT = await eigenerPort(import.meta, "die Kanalpruefung");
 
-process.env.PORT = "4377";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -90,7 +90,7 @@ 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");
 await new Promise((r) => setTimeout(r, 1000));
-const BASIS = "http://127.0.0.1:4377";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 /* ---- Notbremse und eigener Zuhoerer -------------------------------------
 
@@ -185,7 +185,7 @@ function anmelden(rolle, code, wand = "crew.dogfather-universe.com") {
   return new Promise((fertig) => {
     const rumpf = JSON.stringify({ rolle, code });
     const a = httpAnfrage({
-      host: "127.0.0.1", port: 4377, path: "/workspace/api/anmelden", method: "POST",
+      host: "127.0.0.1", port: PORT, path: "/workspace/api/anmelden", method: "POST",
       headers: {
         "Content-Type": "application/json",
         "Content-Length": Buffer.byteLength(rumpf),

server/pruef-chat-optik.mjs

@@ -32,10 +32,10 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
 import { notbremse } from "./helfer-notbremse.mjs";
 import { bestaetige } from "./helfer-nachfrage.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4317, "die Chat-Optikpruefung");
+const PORT = await eigenerPort(import.meta, "die Chat-Optikpruefung");
 
-process.env.PORT = "4317";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -50,7 +50,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-chat-optik");
 await new Promise((r) => setTimeout(r, 1000));
-const BASIS = "http://127.0.0.1:4317";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 const PROTOKOLL = join(process.cwd(), "pruef-chat-optik-lauf.txt");
 try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }

server/pruef-chat.mjs

@@ -30,10 +30,10 @@ import { join } from "node:path";
 const ordner = mkdtempSync(join(tmpdir(), "ws-chat-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4313, "die Chatpruefung");
+const PORT = await eigenerPort(import.meta, "die Chatpruefung");
 
-process.env.PORT = "4313";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -42,7 +42,7 @@ 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");
 await new Promise((r) => setTimeout(r, 1000));
-const BASIS = "http://127.0.0.1:4313";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 let fehler = 0;
 const ok = (b, t) => { console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

server/pruef-chatkachel.mjs

@@ -24,10 +24,10 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { notbremse } from "./helfer-notbremse.mjs";
 
-const PORT = await portMussFreiSein(4442, "pruef-chatkachel");
+const PORT = await eigenerPort(import.meta, "pruef-chatkachel");
 const ordner = mkdtempSync(join(tmpdir(), "ws-kachel-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-checkliste.mjs

@@ -24,8 +24,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4207, "pruef-checkliste");
+const PORT = await eigenerPort(import.meta, "pruef-checkliste");
-process.env.PORT = "4207";
+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";
@@ -34,7 +34,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -43,7 +43,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-checkliste");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4207";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();
 
 let fehler = 0;

server/pruef-code.mjs

@@ -30,8 +30,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4195, "pruef-code");
+const PORT = await eigenerPort(import.meta, "pruef-code");
-process.env.PORT = "4195";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -41,7 +41,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { bestaetige } from "./helfer-nachfrage.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
@@ -51,7 +51,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-code");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4195";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 240_000).unref?.();
 
 let fehler = 0;

server/pruef-community-sicht.mjs

@@ -36,9 +36,9 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4198, "pruef-community-sicht");
+const PORT = await eigenerPort(import.meta, "pruef-community-sicht");
 const ordner = mkdtempSync(join(tmpdir(), "ws-cs-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-content-ansicht.mjs

@@ -11,8 +11,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4185, "pruef-content-ansicht");
+const PORT = await eigenerPort(import.meta, "pruef-content-ansicht");
-process.env.PORT = "4185";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -22,7 +22,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -31,7 +31,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-content-ansicht");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4185";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 200_000).unref?.();
 
 /* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des

server/pruef-content.mjs

@@ -5,7 +5,7 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-content-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
@@ -14,9 +14,9 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    4194 fuer die Gegenprobe. Nur den ersten zu pruefen hiesse, die
    Gegenprobe ungeschuetzt zu lassen, und die ist der Teil, dem man
    glaubt. */
-await portMussFreiSein(4184, "pruef-content");
+const PORT = await eigenerPort(import.meta, "pruef-content");
-await portMussFreiSein(4194, "pruef-content (Gegenprobe)");
+const PORT2 = await eigenerPort(import.meta, "pruef-content (Gegenprobe)", 1);
-process.env.PORT = "4184";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -27,7 +27,7 @@ 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");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4184";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 200_000).unref?.();
 
 /* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des
@@ -81,7 +81,7 @@ d.close();
   const { spawnSync } = await import("node:child_process");
   const zweiter = spawnSync(process.execPath, ["-e", `
     process.env.WORKSPACE_DB = ${JSON.stringify(process.env.WORKSPACE_DB)};
-    process.env.PORT = "4194";
+    process.env.PORT = "${PORT2}";
     process.env.SITE_ACCESS_SECRET = "lokaler-test";
     process.env.SITE_ACCESS_CODE_DOGI = "X";
     process.env.SITE_ACCESS_CODE_VANVAN = "Y";

server/pruef-countdown.mjs

@@ -40,10 +40,10 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { heuteLokal, tagLokal } from "./helfer-tag.mjs";
 
-const PORT = await portMussFreiSein(4481, "pruef-countdown");
+const PORT = await eigenerPort(import.meta, "pruef-countdown");
 const ordner = mkdtempSync(join(tmpdir(), "ws-count-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-creator-anlegen.mjs

@@ -42,9 +42,8 @@ import { notbremse } from "./helfer-notbremse.mjs";
 notbremse(240_000, "die Creator-Anlegen-Pruefung");
 
 const HIER = dirname(fileURLToPath(import.meta.url));
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-const PORT = 4347;
+const PORT = await eigenerPort(import.meta, "die Creator-Anlegen-Pruefung");
-await portMussFreiSein(PORT, "die Creator-Anlegen-Pruefung");
 const BASIS = `http://127.0.0.1:${PORT}`;
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-canlegen-"));

server/pruef-crew-adresse.mjs

@@ -34,8 +34,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4371, "pruef-crew-adresse");
+const PORT = await eigenerPort(import.meta, "pruef-crew-adresse");
-process.env.PORT = "4371";
+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";
@@ -44,7 +44,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 notbremse(180_000, "pruef-crew-adresse");
 await new Promise((r) => setTimeout(r, 700));
@@ -68,7 +68,7 @@ function hole(pfad, { host, methode = "GET", rumpf = null, keks = "" } = {}) {
     const kopf = { Host: host };
     if (rumpf) { kopf["Content-Type"] = "application/json"; kopf["Content-Length"] = Buffer.byteLength(rumpf); }
     if (keks) kopf.Cookie = keks;
-    const a = request({ host: "127.0.0.1", port: 4371, path: pfad, method: methode, headers: kopf },
+    const a = request({ host: "127.0.0.1", port: PORT, path: pfad, method: methode, headers: kopf },
       (antwort) => {
         let text = "";
         antwort.setEncoding("utf8");
@@ -122,7 +122,7 @@ const idModi = anlegen("Marina", "modi", "CODE-MODI-0001");
 const CREW = "crew.dogfather-universe.com";
 const WS   = "workspace.dogfather-universe.com";
 const HAUPT = "dogfather-universe.com";
-const LOKAL = "127.0.0.1:4371";
+const LOKAL = `127.0.0.1:${PORT}`;
 
 /* =====================================================================
    TEIL A -- DIE REGELN, OHNE SERVER

server/pruef-crew-wand-bild.mjs

@@ -32,14 +32,14 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4373, "pruef-crew-wand-bild");
+const PORT = await eigenerPort(import.meta, "pruef-crew-wand-bild");
-process.env.PORT = "4373";
+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";
 
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 notbremse(180_000, "pruef-crew-wand-bild");
 await new Promise((r) => setTimeout(r, 700));
@@ -81,12 +81,19 @@ for (const geraet of [
     deviceScaleFactor: 1,
   });
   const seite = await ctx.newPage();
+  /* Der App-Name kommt aus dem Manifest der Crew-Adresse. Eine zweite
+   Fassung hier waere die, die beim naechsten Umbenennen vergessen
+   wird. */
+const { readFileSync } = await import("node:fs");
+const APPNAME = JSON.parse(
+  readFileSync(new URL("../workspace/crew.webmanifest", import.meta.url), "utf8")).name;
+
 const meldungen = [];
   seite.on("console", (m) => { if (m.type() === "error") meldungen.push(m.text()); });
 
   const adresse = geraet.alt
-    ? "http://127.0.0.1:4373/workspace/index.html"
+    ? `http://127.0.0.1:${PORT}/workspace/index.html`
-    : "http://127.0.0.1:4373/workspace/crew-index.html";
+    : `http://127.0.0.1:${PORT}/workspace/crew-index.html`;
   await seite.goto(adresse, { waitUntil: "networkidle" });
   await seite.waitForTimeout(400);
 
@@ -105,11 +112,35 @@ for (const geraet of [
   if (geraet.alt) {
     ok(kacheln === 5, `${geraet.name}: die alte Wand hat ihre fuenf Kacheln (${kacheln})`);
   } else {
-    ok(/Team Dogi/.test(titel), `${geraet.name}: der Reiter heisst "${titel}"`);
+    /* DER REITER TRAEGT DEN APP-NAMEN -- abgeleitet, nicht abgeschrieben.
-    /* DREI, seit Filipe am 10.09.2026 sagte: "3 rollen. dogfather.
+       Hier stand `/Team Dogi/`, aus der Zeit, als die App so hiess. Sie
-       rechte hand und modis." Hier stand vorher `=== 0` -- am Vormittag
+       heisst seit dem Treff-Umzug "DogFather Universe", und die Pruefung
-       richtig, am Nachmittag nicht mehr. */
+       war seitdem rot, ohne dass etwas kaputt war. Ein fester Name in
-    ok(kacheln === 3, `${geraet.name}: drei Rollenkacheln (${kacheln})`);
+       einer Pruefung ist eine Zeitbombe mit Datum: Er stimmt, bis
+       jemand umbenennt, und dann kostet er Vertrauen in den ganzen
+       Satz. Gemessen wird deshalb gegen das Manifest -- benennt jemand
+       die App um, folgt der Reiter, und beides bleibt gruen. Weichen
+       sie auseinander, sieht der Mensch im Reiter einen anderen Namen
+       als auf seinem Startbildschirm, und das ist der Fehler, den es
+       zu finden gilt. */
+    ok(titel.includes(APPNAME),
+      `${geraet.name}: der Reiter traegt den App-Namen "${APPNAME}" (steht da: "${titel}")`);
+
+    /* WELCHE ROLLEN AUF DIE WAND GEHOEREN.
+       Hier stand `=== 3`, seit Filipe am 10.09.2026 sagte: "3 rollen.
+       dogfather. rechte hand und modis." Am 19.09. ist der Treff in
+       Team Dogi eingezogen, und die Community kam als vierte dazu --
+       die Zahl war ab da falsch, die Wand richtig.
+
+       Eine Zahl sagt beim Scheitern nur "3 erwartet, 4 gefunden" und
+       verschweigt, WELCHE. Deshalb wird die MENGE verglichen: Fehlt
+       eine Rolle, steht ihr Name in der Meldung, und wer sie entfernt
+       hat, sieht sofort, ob das Absicht war. */
+    const rollen = (await seite.locator(".rolle").evaluateAll(
+      (ns) => ns.map((n) => n.dataset.rolle || ""))).sort();
+    const SOLL = ["admin", "gast", "hand", "modi"];
+    ok(JSON.stringify(rollen) === JSON.stringify(SOLL),
+      `${geraet.name}: die vier Rollen stehen da (${rollen.join(", ") || "keine"})`);
     /* Jede muss auch bedienbar sein. Eine Kachel, die im HTML steht,
        aber 0 px hoch ist, zaehlt oben mit und laesst sich trotzdem
        nicht antippen -- genau die Sorte Fehler, die eine Zaehlung
@@ -279,13 +310,13 @@ for (const wer of [
   { name: "Manager", rolle: "manager", code: "CODE-MAN-0001", eigen: false },
 ]) {
   const ctx = await browser.newContext({ viewport: { width: 1280, height: 860 } });
-  const antwort = await ctx.request.post("http://127.0.0.1:4373/workspace/api/anmelden", {
+  const antwort = await ctx.request.post(`http://127.0.0.1:${PORT}/workspace/api/anmelden`, {
     data: { rolle: wer.rolle, code: wer.code },
   });
   ok(antwort.ok(), wer.name + ": die Anmeldung geht durch");
 
   const seite = await ctx.newPage();
-  await seite.goto("http://127.0.0.1:4373/workspace/aufgaben.html", { waitUntil: "networkidle" });
+  await seite.goto(`http://127.0.0.1:${PORT}/workspace/aufgaben.html`, { waitUntil: "networkidle" });
   await seite.waitForTimeout(500);
 
   const titel = await seite.title();

server/pruef-dabei-optik.mjs

@@ -34,10 +34,10 @@ const ordner = mkdtempSync(join(tmpdir(), "ws-dabei-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
 import { notbremse } from "./helfer-notbremse.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4293, "die Optikpruefung der Teilnehmerwahl");
+const PORT = await eigenerPort(import.meta, "die Optikpruefung der Teilnehmerwahl");
 
-process.env.PORT = "4293";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -52,7 +52,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-dabei-optik");
 await new Promise((r) => setTimeout(r, 900));
-const BASIS = "http://127.0.0.1:4293";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 /* LAUFEND MITSCHREIBEN. Node puffert stdout, sobald es umgeleitet wird
    -- bei einem Lauf mit sechs Browser-Anmeldungen steht bis zum Schluss

server/pruef-entwicklung-kacheln.mjs

@@ -40,9 +40,9 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4475, "pruef-entwicklung-kacheln");
+const PORT = await eigenerPort(import.meta, "pruef-entwicklung-kacheln");
 const ordner = mkdtempSync(join(tmpdir(), "ws-ekach-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-entwicklung.mjs

@@ -32,10 +32,10 @@ import { request } from "node:http";
 const ordner = mkdtempSync(join(tmpdir(), "ws-entw-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4389, "die Entwicklungspruefung");
+const PORT = await eigenerPort(import.meta, "die Entwicklungspruefung");
 
-process.env.PORT = "4389";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -62,7 +62,7 @@ function hole(pfad, { host = WS, methode = "GET", rumpf = null, keks = "" } = {}
     const kopf = { Host: host };
     if (rumpf) { kopf["Content-Type"] = "application/json"; kopf["Content-Length"] = Buffer.byteLength(rumpf); }
     if (keks) kopf.Cookie = keks;
-    const a = request({ host: "127.0.0.1", port: 4389, path: pfad, method: methode, headers: kopf },
+    const a = request({ host: "127.0.0.1", port: PORT, path: pfad, method: methode, headers: kopf },
       (antwort) => {
         let text = "";
         antwort.setEncoding("utf8");
@@ -308,12 +308,49 @@ console.log("=== Die Kacheln ===");
     ok(!!befinden, `${wer} hat „${befinden?.name || "—"}"`);
     ok(befinden?.gruppe === "Für dich",
       `und sie steht bei „Für dich" (${befinden?.gruppe})`);
-    /* GEGENPROBE: Sie fuehrt NICHT mehr dorthin, wo andere Menschen
+    /* GEGENPROBE: Die Kachel, die VERTRAULICHKEIT VERSPRICHT, fuehrt
-       stehen -- sonst waere der gemeldete Fehler beim naechsten Umbau
+       nicht dorthin, wo andere Menschen stehen.
-       still wieder da. */
+
-    ok(!alleX.some((k) => k.ziel === "entwicklung.html"
+       HIER STAND EINE NAMENSLISTE (20.09.2026 ersetzt). Sie lautete
-      && !["Eure Aufgaben", "Talente"].includes(k.name)),
+       `!["Eure Aufgaben", "Talente"].includes(k.name)` -- und war damit
-    `${wer}: keine Kachel fuehrt mehr ersatzweise auf die Entwicklungsseite`);
+       eine abgeschriebene Liste, genau die Sorte, vor der dieses Haus
+       an drei Stellen warnt. Als ein Modi eine eigene Kachel bekam
+       ("Deine Aufgaben", weil "Eure" aus seiner Sicht falsch ist),
+       wurde diese Pruefung rot, OHNE dass irgendetwas kaputt war. Eine
+       rote Pruefung, die rot bleibt, gewoehnt einem das Hinsehen ab --
+       sie ist schaedlicher als gar keine.
+
+       Geprueft wird jetzt, was Filipe eigentlich gemeldet hat: Auf der
+       Kachel stand "die Antworten sieht nur du", und sie fuehrte auf
+       eine Seite mit Namen anderer Leute. Das ist eine Eigenschaft des
+       VERSPRECHENS, nicht des Namens -- und Versprechen stehen im
+       Untertitel. Wer morgen eine Kachel "Dein Kopf" nennt und dasselbe
+       verspricht, ist damit mitgeprueft; die Namensliste haette ihn
+       durchgelassen. */
+    const verspricht = (k) => /nur du|nur dich|siehst nur du/i.test(k.unter || "");
+    const heikel = alleX.filter((k) => verspricht(k) && k.ziel === "entwicklung.html");
+    ok(alleX.some(verspricht) && heikel.length === 0,
+      `${wer}: keine Kachel verspricht Vertraulichkeit und fuehrt doch auf die`
+      + ` Entwicklungsseite (${alleX.filter(verspricht).length} mit Versprechen geprueft)`);
+
+    /* UND DIE ECHTE GRENZE, die bisher NIEMAND gemessen hat.
+       Ob eine Kachel richtig zeigt, ist Beschriftung. Ob die Seite
+       dahinter fremde Namen herausgibt, sind Daten -- und nur das
+       schuetzt jemanden wirklich. Ein Modi darf dort NIEMANDEN
+       bekommen ausser sich selbst. */
+    const lage = await hole("/workspace/api/entwicklung/lage", { host: CREW, keks });
+    const fremde = (lage.daten?.personen || []).filter((q) => q.id !== undefined);
+    if (wer === "ein Modi") {
+      ok(lage.status === 200 && fremde.length === 0,
+        `${wer} bekommt auf der Entwicklungsseite KEINE fremden Namen (${fremde.length})`);
+    } else {
+      /* Die Gegenprobe zur Zeile darueber: Waere der Filter kaputt und
+         liesse niemanden durch, saehe auch die Leitung nichts -- und
+         die Modi-Zeile waere trotzdem gruen. Beide Richtungen gehoeren
+         gemessen, sonst beweist keine etwas. */
+      ok(lage.status === 200 && fremde.length > 0,
+        `${wer} bekommt sie sehr wohl (${fremde.length}) -- der Filter ist nicht einfach zu`);
+    }
   }
 
   const a = await hole("/workspace/api/ich", { host: CREW, keks: ayla.keks });

server/pruef-erwaehnung.mjs

@@ -38,12 +38,12 @@ import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { notbremse } from "./helfer-notbremse.mjs";
 import { erwaehnungenFinden, erwaehnteIds } from "./chat-erwaehnung.js";
 
 const HIER = dirname(fileURLToPath(import.meta.url));
-const PORT = await portMussFreiSein(4426, "pruef-erwaehnung");
+const PORT = await eigenerPort(import.meta, "pruef-erwaehnung");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-erwaehnung-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-eskalation.mjs

@@ -29,10 +29,10 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { heuteLokal, tagLokal, tagVon } from "./helfer-tag.mjs";
 
-const PORT = await portMussFreiSein(4417, "pruef-eskalation");
+const PORT = await eigenerPort(import.meta, "pruef-eskalation");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-eskal-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-fassungen.mjs

@@ -34,9 +34,9 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4415, "pruef-fassungen");
+const PORT = await eigenerPort(import.meta, "pruef-fassungen");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-fass-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-formulare.mjs

@@ -26,8 +26,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4203, "pruef-formulare");
+const PORT = await eigenerPort(import.meta, "pruef-formulare");
-process.env.PORT = "4203";
+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";
@@ -36,7 +36,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -45,7 +45,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-formulare");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4203";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 250_000).unref?.();
 
 let fehler = 0;

server/pruef-freie-namen.mjs

@@ -31,8 +31,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4192, "pruef-freie-namen");
+const PORT = await eigenerPort(import.meta, "pruef-freie-namen");
-process.env.PORT = "4192";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -42,7 +42,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -51,7 +51,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-freie-namen");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4192";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 240_000).unref?.();
 
 let fehler = 0;

server/pruef-galerie.mjs

@@ -41,10 +41,10 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { heuteLokal } from "./helfer-tag.mjs";
 
-const PORT = await portMussFreiSein(4487, "pruef-galerie");
+const PORT = await eigenerPort(import.meta, "pruef-galerie");
 const ordner = mkdtempSync(join(tmpdir(), "ws-gal-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.WORKSPACE_DATEN = join(ordner, "daten");

server/pruef-gespraech.mjs

@@ -30,10 +30,10 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { heuteLokal } from "./helfer-tag.mjs";
 
-const PORT = await portMussFreiSein(4493, "pruef-gespraech");
+const PORT = await eigenerPort(import.meta, "pruef-gespraech");
 const ordner = mkdtempSync(join(tmpdir(), "ws-gespr-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-glocke.mjs

@@ -52,10 +52,10 @@ const ordner = mkdtempSync(join(tmpdir(), "ws-glocke-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
 import { notbremse } from "./helfer-notbremse.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4299, "die Glockenpruefung");
+const PORT = await eigenerPort(import.meta, "die Glockenpruefung");
 
-process.env.PORT = "4299";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -70,7 +70,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-glocke");
 await new Promise((r) => setTimeout(r, 900));
-const BASIS = "http://127.0.0.1:4299";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 const PROTOKOLL = join(process.cwd(), "pruef-glocke-lauf.txt");
 try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }

server/pruef-grosscheck.mjs

@@ -49,8 +49,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4218, "pruef-grosscheck");
+const PORT = await eigenerPort(import.meta, "pruef-grosscheck");
-process.env.PORT = "4218";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -60,7 +60,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -69,7 +69,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-grosscheck");
 await new Promise((r) => setTimeout(r, 800));
-const BASIS = "http://127.0.0.1:4218";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH — zu lange gelaufen"); process.exit(1); }, 900_000).unref?.();
 
 /* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des

server/pruef-handy-teamdogi.mjs

@@ -103,13 +103,13 @@ import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
 const REPO = join(dirname(fileURLToPath(import.meta.url)), "..");
 const ordner = mkdtempSync(join(tmpdir(), "ws-handy-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
-const PORT = await portMussFreiSein(4231, "pruef-handy-teamdogi");
+const PORT = await eigenerPort(import.meta, "pruef-handy-teamdogi");
 process.env.PORT = String(PORT);
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";

server/pruef-handy.mjs

@@ -33,8 +33,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4198, "pruef-handy");
+const PORT = await eigenerPort(import.meta, "pruef-handy");
-process.env.PORT = "4198";
+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";
@@ -43,7 +43,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -52,7 +52,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-handy");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4198";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 400_000).unref?.();
 
 /* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des

server/pruef-haus-seiten.mjs

@@ -30,9 +30,9 @@ import { mkdtempSync, rmSync, readdirSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4422, "pruef-haus-seiten");
+const PORT = await eigenerPort(import.meta, "pruef-haus-seiten");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-haus-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-haus-trennung.mjs

@@ -37,10 +37,10 @@ import { request } from "node:http";
 const ordner = mkdtempSync(join(tmpdir(), "ws-haus-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4381, "die Haustrennung");
+const PORT = await eigenerPort(import.meta, "die Haustrennung");
 
-process.env.PORT = "4381";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -67,7 +67,7 @@ function hole(pfad, { host, methode = "GET", rumpf = null, keks = "" } = {}) {
     const kopf = { Host: host };
     if (rumpf) { kopf["Content-Type"] = "application/json"; kopf["Content-Length"] = Buffer.byteLength(rumpf); }
     if (keks) kopf.Cookie = keks;
-    const a = request({ host: "127.0.0.1", port: 4381, path: pfad, method: methode, headers: kopf },
+    const a = request({ host: "127.0.0.1", port: PORT, path: pfad, method: methode, headers: kopf },
       (antwort) => {
         let text = "";
         antwort.setEncoding("utf8");
@@ -420,7 +420,13 @@ console.log("=== Personen & Zugaenge ===");
   const neuCrew = await hole("/workspace/api/verwaltung/personen", { host: CREW,
     methode: "POST", keks: dogi.keks,
     rumpf: JSON.stringify({ name: "Testcreator", rolle: "creator" }) });
-  ok(neuCrew.status === 403,
+  /* 400, NICHT 403 (berichtigt 20.09.2026). Diese Erwartung stammt vom
+     10.09.; am 17.09. wurde entschieden, dass eine abgelehnte Rolle
+     IMMER "Unbekannte Rolle." mit 400 bekommt -- egal ob es sie nicht
+     gibt oder ob sie hier nur nicht erlaubt ist. Zwei verschiedene
+     Antworten verraten beim Durchprobieren, WELCHE Rollen existieren.
+     Die Pruefung war sieben Tage aelter als die Regel. */
+  ok(neuCrew.status === 400,
     `ein Creator laesst sich auf crew. nicht anlegen (${neuCrew.status})`);
   /* GEGENPROBE: Auf der Agenturadresse geht genau das. Ohne sie hiesse
      die 403 oben auch dann gruen, wenn Anlegen ueberhaupt kaputt waere. */
@@ -499,7 +505,8 @@ console.log("=== Die Rolle aendern ===");
      Rollen kommen aus derselben Auskunft wie beim Anlegen. */
   const fremd = await hole(`${weg}/${idModi}/rolle`, { host: CREW, methode: "PUT",
     keks: dogi.keks, rumpf: JSON.stringify({ rolle: "creator" }) });
-  ok(fremd.status === 403, `auf crew. auch nicht zum Creator (${fremd.status})`);
+  /* Auch hier 400 statt 403 -- gleiche Begruendung wie oben. */
+  ok(fremd.status === 400, `auf crew. auch nicht zum Creator (${fremd.status})`);
 
   /* SEIT DEM 11.09.2026 LAESST SICH DIE ROLLE NICHT MEHR VERGEBEN.
 
@@ -624,9 +631,59 @@ console.log("=== Alle Kategorien ===");
   const codeVersuch = await hole(`/workspace/api/verwaltung/personen/${idModi}/code`,
     { host: CREW, methode: "POST", keks: hand.keks, rumpf: "{}" });
   ok(codeVersuch.status === 404, `sie kann keinen Code neu setzen (${codeVersuch.status})`);
-  const rolleVersuch = await hole(`/workspace/api/verwaltung/personen/${idModi}/rolle`,
+  /* ROLLEN WECHSELN DARF SIE SEIT DEM 20.09. -- aber nicht alles.
+
+     Filipe: "ich will dass ich da auch die rollen der leute wechseln
+     kann ohne dass ich denen einen neuen account machen muss ...
+     perfektionier das fuer die rolle dogfather und rechte hand. nur
+     die sollen das machen koennen."
+
+     Hier stand `=== 404` ("sie kann gar nichts"). Das war bis zum
+     19.09. richtig. Jetzt werden BEIDE Richtungen gemessen -- eine
+     Pruefung, die nur das Verbotene misst, laesst den Fall offen, dass
+     auch das Erlaubte nicht geht, und genau das faellt niemandem auf,
+     bis sich jemand beschwert.
+
+     Ayla ist an dieser Stelle laengst zur rechten Hand befoerdert
+     (Abschnitt weiter oben) -- deshalb ist sie der Fall "nicht unter
+     sich". */
+  const anEinerHand = await hole(`/workspace/api/verwaltung/personen/${idModi}/rolle`,
     { host: CREW, methode: "PUT", keks: hand.keks, rumpf: JSON.stringify({ rolle: "modi" }) });
-  ok(rolleVersuch.status === 404, `und keine Rolle vergeben (${rolleVersuch.status})`);
+  ok(anEinerHand.status === 403,
+    `an einer anderen rechten Hand aendert sie nichts (${anEinerHand.status})`);
+
+  const anDogFather = await hole(`/workspace/api/verwaltung/personen/${idDogi}/rolle`,
+    { host: CREW, methode: "PUT", keks: hand.keks, rumpf: JSON.stringify({ rolle: "modi" }) });
+  ok(anDogFather.status === 403,
+    `und an DogFather erst recht nicht (${anDogFather.status})`);
+
+  /* UND DIE ANDERE RICHTUNG: Was sie DARF, muss auch gehen. Ohne diese
+     Zeile waere die Sperre oben auch dann gruen, wenn ihr Weg voellig
+     zu waere. */
+  /* DIREKT IN DIE DATENBANK statt ueber `anlegen()`: In diesem Block
+     steht weiter unten ein `const anlegen = await hole(...)`, und das
+     verdeckt die gleichnamige Funktion im ganzen Block -- auch OBERHALB
+     seiner eigenen Zeile. JavaScript nennt das die tote Zone, und sie
+     kostete hier einen Absturz mit der Meldung "Cannot access
+     'anlegen' before initialization". */
+  const frischerModi = (() => {
+    d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt)"
+      + " VALUES ('Probe-Modi','modi','x','y',1,1,?)").run(jetzt);
+    return d.prepare("SELECT last_insert_rowid() AS id").get().id;
+  })();
+  const anEinemModi = await hole(`/workspace/api/verwaltung/personen/${frischerModi}/rolle`,
+    { host: CREW, methode: "PUT", keks: hand.keks, rumpf: JSON.stringify({ rolle: "gast" }) });
+  ok(anEinemModi.status === 200,
+    `einen Modi macht sie sehr wohl zur Community (${anEinemModi.status})`);
+  const nachher = d.prepare("SELECT rolle FROM personen WHERE id = ?").get(frischerModi)?.rolle;
+  ok(nachher === "gast", `und es steht so in der Datenbank (${nachher})`);
+
+  /* Eine Rolle, die sie nicht vergeben darf, bleibt zu -- sonst waere
+     "sie darf wechseln" ein Freibrief. */
+  const zuHoch = await hole(`/workspace/api/verwaltung/personen/${frischerModi}/rolle`,
+    { host: CREW, methode: "PUT", keks: hand.keks, rumpf: JSON.stringify({ rolle: "hand" }) });
+  ok(zuHoch.status === 400,
+    `eine zweite rechte Hand ernennt sie nicht (${zuHoch.status})`);
   const anlegen = await hole("/workspace/api/verwaltung/personen",
     { host: CREW, methode: "POST", keks: hand.keks,
       rumpf: JSON.stringify({ name: "Nochwer", rolle: "modi" }) });
@@ -652,7 +709,7 @@ console.log("=== Haengt es wirklich an der Adresse? ===");
      Pruefungen im Haus laufen dort, und eine stille Einschraenkung
      haette sie alle blind gemacht, ohne dass irgendwo etwas rot wird.
      Genau diese Falle steht schon in crew-adresse.js beschrieben. */
-  const lokal = await hole("/workspace/api/aufgaben", { host: "127.0.0.1:4381", keks: dogi.keks });
+  const lokal = await hole("/workspace/api/aufgaben", { host: `127.0.0.1:${PORT}`, keks: dogi.keks });
   const t = (lokal.daten?.aufgaben || []).map((z) => z.titel);
   ok(t.includes("Lunas Steckbrief nachtragen"),
     `auf 127.0.0.1 bleibt alles wie bisher (${t.length} Aufgaben)`);

server/pruef-highlights.mjs

@@ -27,10 +27,11 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { tagLokal } from "./helfer-zeit.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { notbremse } from "./helfer-notbremse.mjs";
 
-const PORT = await portMussFreiSein(4438, "pruef-highlights");
+const PORT = await eigenerPort(import.meta, "pruef-highlights");
 const ordner = mkdtempSync(join(tmpdir(), "ws-highlight-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);
@@ -83,7 +84,13 @@ const einf = (titel, kanal, wannTage) => d.prepare(
   + " datum, quelle_kanal, erstellt_von, erstellt)"
   + " VALUES (?,?,?,?,?,?,?,?,?,?)")
   .run("highlight", "clip", titel, "", "offen", "mittel",
-    vorTagen(wannTage).toISOString().slice(0, 10), kanal, 1,
+    /* Das TAGESDATUM ueber den Hausschluessel, nicht ueber UTC:
+       `vorTagen` verankert zwar um neun Uhr und waere damit richtig,
+       aber das sieht man der Zeile nicht an -- pruef-struktur hat sie
+       als UTC-Rechnung gemeldet. Ein Fehlalarm ist schlimmer als keine
+       Pruefung. Der volle Zeitstempel eine Zeile tiefer darf bleiben:
+       Dort ist UTC richtig, weil er eine ZEIT ist und keinen Tag. */
+    tagLokal(-wannTage), kanal, 1,
     vorTagen(wannTage).toISOString());
 
 einf("Heute DogFather", "dogfather", 0);

server/pruef-hilfe.mjs

@@ -32,9 +32,9 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4188, "pruef-hilfe");
+const PORT = await eigenerPort(import.meta, "pruef-hilfe");
 const ordner = mkdtempSync(join(tmpdir(), "ws-hilfe-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-hochladen.mjs

@@ -68,8 +68,8 @@ const ordner = mkdtempSync(join(tmpdir(), "ws-hochlade-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
 import { notbremse } from "./helfer-notbremse.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-const PORT = await portMussFreiSein(4327, "die Hochladepruefung");
+const PORT = await eigenerPort(import.meta, "die Hochladepruefung");
 
 process.env.PORT = String(PORT);
 process.env.SITE_ACCESS_SECRET = "lokaler-test";

server/pruef-ics.mjs

@@ -32,10 +32,10 @@ const ordner = mkdtempSync(join(tmpdir(), "ws-ics-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
 import { notbremse } from "./helfer-notbremse.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4345, "die Kalender-Abo-Pruefung");
+const PORT = await eigenerPort(import.meta, "die Kalender-Abo-Pruefung");
 
-process.env.PORT = "4345";
+process.env.PORT = String(PORT);
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -45,7 +45,7 @@ express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(
 await import("./index.js");
 notbremse(240_000, "pruef-ics");
 await new Promise((r) => setTimeout(r, 900));
-const BASIS = "http://127.0.0.1:4345";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 const PROTOKOLL = join(process.cwd(), "pruef-ics-lauf.txt");
 try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }
@@ -185,7 +185,7 @@ melde("=== Der Link entsteht erst auf Wunsch ===");
 }
 
 const linkLuna = await linkHolen(keksLuna);
-ok(/^http:\/\/127\.0\.0\.1:4345\/workspace\/kalender\/[A-Za-z0-9_-]{40,}\.ics$/.test(linkLuna || ""),
+ok(new RegExp(`^http://127\\.0\\.0\\.1:${PORT}/workspace/kalender/[A-Za-z0-9_-]{40,}\\.ics$`).test(linkLuna || ""),
   `der Link sieht richtig aus (…${String(linkLuna).slice(-24)})`);
 
 /* =======================================================================

server/pruef-installieren.mjs

@@ -33,10 +33,10 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { notbremse } from "./helfer-notbremse.mjs";
 
-const PORT = await portMussFreiSein(4435, "pruef-installieren");
+const PORT = await eigenerPort(import.meta, "pruef-installieren");
 const ordner = mkdtempSync(join(tmpdir(), "ws-install-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-jeder-hat-eine-seite.mjs

@@ -41,9 +41,9 @@ import { mkdtempSync, rmSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4191, "pruef-jeder-hat-eine-seite");
+const PORT = await eigenerPort(import.meta, "pruef-jeder-hat-eine-seite");
 const ordner = mkdtempSync(join(tmpdir(), "ws-seite-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-kachel-universum.mjs

@@ -45,7 +45,7 @@ import { mkdtempSync, rmSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { pngLesen, pixel, kontrast } from "./helfer-png.mjs";
 
 const HIER = dirname(fileURLToPath(import.meta.url));
@@ -216,7 +216,7 @@ melde("=== 2. Das Universum im Hintergrund ===");
 melde("");
 melde("=== 3. Der Text auf der fertigen Kachel ===");
 
-const PORT = await portMussFreiSein(4194, "pruef-kachel-universum");
+const PORT = await eigenerPort(import.meta, "pruef-kachel-universum");
 const ordner = mkdtempSync(join(tmpdir(), "ws-kachel-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-kachelraster.mjs

@@ -42,9 +42,9 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4479, "pruef-kachelraster");
+const PORT = await eigenerPort(import.meta, "pruef-kachelraster");
 const ordner = mkdtempSync(join(tmpdir(), "ws-raster-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-kalender.mjs

@@ -18,8 +18,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4188, "pruef-kalender");
+const PORT = await eigenerPort(import.meta, "pruef-kalender");
-process.env.PORT = "4188";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -29,7 +29,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -38,7 +38,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-kalender");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4188";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 200_000).unref?.();
 
 /* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des

server/pruef-kanaele.mjs

@@ -36,9 +36,9 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4477, "pruef-kanaele");
+const PORT = await eigenerPort(import.meta, "pruef-kanaele");
 const ordner = mkdtempSync(join(tmpdir(), "ws-kanal-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-kanalzeile.mjs

@@ -26,10 +26,10 @@ import { createServer } from "node:http";
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-kz-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4332, "das Bildwerkzeug");
+const PORT = await eigenerPort(import.meta, "das Bildwerkzeug");
-const TIKTOK = await portMussFreiSein(4502, "nachgebautes TikTok");
+const TIKTOK = await eigenerPort(import.meta, "nachgebautes TikTok", 1);
-process.env.PORT = "4332";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 process.env.TIKTOK_OEMBED_BASIS = `http://127.0.0.1:${TIKTOK}/oembed`;
@@ -67,7 +67,7 @@ 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");
 await new Promise((r) => setTimeout(r, 1200));
-const BASIS = "http://127.0.0.1:4332";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 const { DatabaseSync } = await import("node:sqlite");
 const { scryptSync, randomBytes } = await import("node:crypto");

server/pruef-kopf-messen.mjs

@@ -31,8 +31,8 @@ process.env.WORKSPACE_DB = join(ordner, "pruef.sqlite");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4179, "pruef-kopf-messen");
+const PORT = await eigenerPort(import.meta, "pruef-kopf-messen");
-process.env.PORT = "4179";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -42,7 +42,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -51,7 +51,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-kopf-messen");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4179";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 let fehler = 0;
 let geprueft = 0;

server/pruef-kreislauf.mjs

@@ -39,10 +39,10 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { heuteLokal } from "./helfer-tag.mjs";
 
-const PORT = await portMussFreiSein(4491, "pruef-kreislauf");
+const PORT = await eigenerPort(import.meta, "pruef-kreislauf");
 const ordner = mkdtempSync(join(tmpdir(), "ws-kreis-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-ladefehler.mjs

@@ -56,8 +56,8 @@ const ordner = mkdtempSync(join(tmpdir(), "ws-ladefehler-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
 import { notbremse } from "./helfer-notbremse.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-const PORT = await portMussFreiSein(4339, "die Ladefehlerpruefung");
+const PORT = await eigenerPort(import.meta, "die Ladefehlerpruefung");
 
 process.env.PORT = String(PORT);
 process.env.SITE_ACCESS_SECRET = "lokaler-test";

server/pruef-leistung-optik.mjs

@@ -36,10 +36,10 @@ const ordner = mkdtempSync(join(tmpdir(), "ws-leistoptik-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
 import { notbremse } from "./helfer-notbremse.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4337, "die Zahlen-Optikpruefung");
+const PORT = await eigenerPort(import.meta, "die Zahlen-Optikpruefung");
 
-process.env.PORT = "4337";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -54,7 +54,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-leistung-optik");
 await new Promise((r) => setTimeout(r, 1000));
-const BASIS = "http://127.0.0.1:4337";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 const PROTOKOLL = join(process.cwd(), "pruef-leistung-optik-lauf.txt");
 try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }

server/pruef-leistung.mjs

@@ -30,10 +30,10 @@ import { join } from "node:path";
 const ordner = mkdtempSync(join(tmpdir(), "ws-leistung-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4333, "die Leistungspruefung");
+const PORT = await eigenerPort(import.meta, "die Leistungspruefung");
 
-process.env.PORT = "4333";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -42,7 +42,7 @@ 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");
 await new Promise((r) => setTimeout(r, 1000));
-const BASIS = "http://127.0.0.1:4333";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 let fehler = 0;
 const ok = (b, t) => { console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

server/pruef-lesbarkeit.mjs

@@ -33,8 +33,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4214, "pruef-lesbarkeit");
+const PORT = await eigenerPort(import.meta, "pruef-lesbarkeit");
-process.env.PORT = "4214";
+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";
@@ -43,7 +43,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -52,7 +52,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-lesbarkeit");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4214";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();
 
 /* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des

server/pruef-manager-sicht.mjs

@@ -43,8 +43,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4199, "pruef-manager-sicht");
+const PORT = await eigenerPort(import.meta, "pruef-manager-sicht");
-process.env.PORT = "4199";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -54,7 +54,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -63,7 +63,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-manager-sicht");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4199";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();
 
 let fehler = 0;

server/pruef-modi-checkliste.mjs

@@ -31,8 +31,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4369, "pruef-modi-checkliste");
+const PORT = await eigenerPort(import.meta, "pruef-modi-checkliste");
-process.env.PORT = "4369";
+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";
@@ -41,11 +41,11 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 notbremse(180_000, "pruef-modi-checkliste");
 await new Promise((r) => setTimeout(r, 800));
-const BASIS = "http://127.0.0.1:4369";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 let fehler = 0;
 let geprueft = 0;

server/pruef-modi-ideen.mjs

@@ -36,8 +36,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4365, "pruef-modi-ideen");
+const PORT = await eigenerPort(import.meta, "pruef-modi-ideen");
-process.env.PORT = "4365";
+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";
@@ -102,11 +102,11 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 notbremse(180_000, "pruef-modi-ideen");
 await new Promise((r) => setTimeout(r, 900));
-const BASIS = "http://127.0.0.1:4365";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 console.log("\n=== 2. Die Umstellung ===\n");
 {

server/pruef-modi-katalog.mjs

@@ -27,8 +27,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4363, "pruef-modi-katalog");
+const PORT = await eigenerPort(import.meta, "pruef-modi-katalog");
-process.env.PORT = "4363";
+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";
@@ -39,11 +39,11 @@ express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(
 import { notbremse } from "./helfer-notbremse.mjs";
 import { ersatzschreibungen } from "./helfer-deutsch.mjs";
 import { fileURLToPath } from "node:url";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 notbremse(180_000, "pruef-modi-katalog");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4363";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 let fehler = 0;
 let geprueft = 0;

server/pruef-modi-kategorien.mjs

@@ -28,8 +28,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4361, "pruef-modi-kategorien");
+const PORT = await eigenerPort(import.meta, "pruef-modi-kategorien");
-process.env.PORT = "4361";
+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";
@@ -38,11 +38,11 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 notbremse(180_000, "pruef-modi-kategorien");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4361";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 let fehler = 0;
 let geprueft = 0;

server/pruef-modi-livecheck.mjs

@@ -32,8 +32,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4367, "pruef-modi-livecheck");
+const PORT = await eigenerPort(import.meta, "pruef-modi-livecheck");
-process.env.PORT = "4367";
+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";
@@ -42,11 +42,11 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 notbremse(180_000, "pruef-modi-livecheck");
 await new Promise((r) => setTimeout(r, 800));
-const BASIS = "http://127.0.0.1:4367";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 let fehler = 0;
 let geprueft = 0;

server/pruef-modi-verborgen.mjs

@@ -28,8 +28,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4359, "pruef-modi-verborgen");
+const PORT = await eigenerPort(import.meta, "pruef-modi-verborgen");
-process.env.PORT = "4359";
+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";
@@ -38,14 +38,14 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* NACH index.js: Der Server haengt dort zwei Auffangnetze ein, die
    einen Absturz nur protokollieren. Fuer den Betrieb richtig, fuer eine
    Pruefung fatal -- ohne diese Zeile bliebe der Prozess ewig stehen. */
 notbremse(180_000, "pruef-modi-verborgen");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4359";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 let fehler = 0;
 let geprueft = 0;

server/pruef-nachfrage.mjs

@@ -326,12 +326,12 @@ if (process.env.OHNE_BROWSER === "ja") {
 } else {
   const { mkdtempSync, rmSync } = await import("node:fs");
   const { tmpdir } = await import("node:os");
-  const { portMussFreiSein } = await import("./helfer-port.mjs");
+  const { eigenerPort } = await import("./helfer-port.mjs");
   const { notbremse } = await import("./helfer-notbremse.mjs");
 
   const ordner = mkdtempSync(join(tmpdir(), "ws-nachfrage-"));
   process.env.WORKSPACE_DB = join(ordner, "workspace.db");
-  const PORT = await portMussFreiSein(4329, "die Nachfragepruefung");
+  const PORT = await eigenerPort(import.meta, "die Nachfragepruefung");
   process.env.PORT = String(PORT);
   process.env.SITE_ACCESS_SECRET = "lokaler-test";
   process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";

server/pruef-nachruesten.mjs

@@ -35,9 +35,9 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4191, "pruef-nachruesten");
+const PORT = await eigenerPort(import.meta, "pruef-nachruesten");
 const ordner = mkdtempSync(join(tmpdir(), "ws-nachruesten-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-nachwuchs.mjs

@@ -24,10 +24,10 @@ import { mkdtempSync, rmSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 import { tagLokal } from "./helfer-tag.mjs";
 
-const PORT = await portMussFreiSein(4404, "pruef-nachwuchs");
+const PORT = await eigenerPort(import.meta, "pruef-nachwuchs");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-nachwuchs-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-neue-seiten.mjs

@@ -35,9 +35,9 @@ import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4403, "pruef-neue-seiten");
+const PORT = await eigenerPort(import.meta, "pruef-neue-seiten");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-treffs-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-personen-formular.mjs

@@ -29,8 +29,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4198, "pruef-personen-formular");
+const PORT = await eigenerPort(import.meta, "pruef-personen-formular");
-process.env.PORT = "4198";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -40,7 +40,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -49,7 +49,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-personen-formular");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4198";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();
 
 let fehler = 0;

server/pruef-personen-kachel.mjs

@@ -31,10 +31,10 @@ const ordner = mkdtempSync(join(tmpdir(), "ws-perskachel-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 
 import { notbremse } from "./helfer-notbremse.mjs";
-const { portMussFreiSein } = await import("./helfer-port.mjs");
+const { eigenerPort } = await import("./helfer-port.mjs");
-await portMussFreiSein(4329, "die Personenkachel-Pruefung");
+const PORT = await eigenerPort(import.meta, "die Personenkachel-Pruefung");
 
-process.env.PORT = "4329";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
 
@@ -44,7 +44,7 @@ express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(
 await import("./index.js");
 notbremse(420_000, "pruef-personen-kachel");
 await new Promise((r) => setTimeout(r, 900));
-const BASIS = "http://127.0.0.1:4329";
+const BASIS = `http://127.0.0.1:${PORT}`;
 
 const PROTOKOLL = join(process.cwd(), "pruef-personen-kachel-lauf.txt");
 try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }

server/pruef-personen-liste.mjs

@@ -23,8 +23,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4187, "pruef-personen-liste");
+const PORT = await eigenerPort(import.meta, "pruef-personen-liste");
-process.env.PORT = "4187";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -34,7 +34,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -43,7 +43,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-personen-liste");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4187";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 200_000).unref?.();
 
 let fehler = 0;

server/pruef-personen-loeschen.mjs

@@ -8,7 +8,7 @@
 import { mkdtempSync, rmSync, readdirSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-loeschen-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
@@ -17,8 +17,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4188, "pruef-personen-loeschen");
+const PORT = await eigenerPort(import.meta, "pruef-personen-loeschen");
-process.env.PORT = "4188";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -29,7 +29,7 @@ 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");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4188";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 200_000).unref?.();
 
 /* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des

server/pruef-portnummern.mjs

@@ -0,0 +1,143 @@
+/* =====================================================================
+   pruef-portnummern.mjs — Zwei Pruefungen, eine Nummer
+
+   WAS HIER SCHIEFGING (20.09.2026 gemessen):
+   164 Pruefdateien, 129 verschiedene Nummern -- NEUNZEHN waren doppelt
+   vergeben, 4186 und 4188 und 4196 und 4198 sogar dreifach. Niemand
+   hatte das gewollt; jede neue Pruefung wurde von einer vorhandenen
+   abgeschrieben, und die Nummer kam mit.
+
+   WAS DAS ANRICHTET: Der Waechter bricht ab, statt gegen einen fremden
+   Server zu messen -- so weit, so richtig. Aber zwei Pruefungen mit
+   derselben Nummer koennen nie gleichzeitig laufen, und ein
+   liegengebliebener Prozess der einen laesst die andere mit einer
+   Meldung abbrechen, die wie ein Befund aussieht. Genau das ist am
+   20.09. zweimal passiert, beide Male mit Fehlersuche an der falschen
+   Stelle.
+
+   WAS DIESE PRUEFUNG SICHERT: Dass die Nummer ABGELEITET bleibt. Eine
+   von Hand eingetragene Zahl ist der Anfang der naechsten Doppelung --
+   sie faellt nur niemandem auf, bis zwei Laeufe kollidieren.
+   ===================================================================== */
+
+import { readdirSync, readFileSync } from "node:fs";
+import { eigenerPort, portNummer } from "./helfer-port.mjs";
+
+let ok_ = 0, fehl = 0;
+const ok = (b, text) => { if (b) { ok_++; console.log("  ok   " + text); }
+  else { fehl++; console.log("  FEHL " + text); } };
+
+const ORDNER = new URL(".", import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1");
+const dateien = readdirSync(ORDNER)
+  .filter((f) => f.startsWith("pruef-") && f.endsWith(".mjs")).sort();
+
+console.log("\n=== 1. Niemand traegt eine Nummer von Hand ein ===");
+const vonHand = [];
+const ohneWaechter = [];
+for (const f of dateien) {
+  const s = readFileSync(ORDNER + "/" + f, "utf8");
+  /* Kommentare zaehlen nicht: In helfer-port.mjs und hier stehen alte
+     Nummern als Beleg, und ein Beleg ist kein Eintrag. */
+  const code = s.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+  if (/portMussFreiSein\(\s*\d/.test(code)) vonHand.push(f);
+  const startetServer = /listen\(|process\.env\.PORT\s*=/.test(code);
+  if (startetServer && !/eigenerPort\(\s*import\.meta/.test(code)) ohneWaechter.push(f);
+}
+ok(dateien.length > 100, `${dateien.length} Pruefdateien angesehen`);
+ok(vonHand.length === 0,
+  `keine traegt eine feste Nummer im Waechter (${vonHand.slice(0, 4).join(", ") || "—"})`);
+ok(ohneWaechter.length === 0,
+  `jede, die einen Server startet, leitet ihre Nummer ab (${ohneWaechter.slice(0, 4).join(", ") || "—"})`);
+
+console.log("\n=== 2. Die abgeleiteten Nummern sind eindeutig ===");
+const belegt = new Map();
+let doppelt = 0;
+dateien.forEach((f, i) => {
+  for (let n = 0; n < 2; n++) {
+    const p = portNummer(i * 2 + n);
+    if (belegt.has(p)) { doppelt++; console.log(`       ${p}: ${belegt.get(p)} und ${f}`); }
+    belegt.set(p, f);
+  }
+});
+ok(belegt.size === dateien.length * 2 && doppelt === 0,
+  `${belegt.size} Nummern fuer ${dateien.length} Dateien, ${doppelt} doppelt`);
+
+console.log("\n=== 2b. Keine davon ist eine, die `fetch` verweigert ===");
+/* DIE TEUERSTE HALBE STUNDE DIESES ABENDS. Nach der Umstellung bekam
+   pruef-chat-kanaele die 5060 und stuerzte ab -- obwohl der Server
+   nachweislich lief und die Anmeldung ueber `http.request` geklappt
+   hatte. 5060 ist SIP und steht auf der "bad ports"-Liste der
+   Fetch-Spezifikation, die Node uebernommen hat: `fetch` baut dorthin
+   keine Verbindung auf.
+
+   Die Meldung lautet "fetch failed" -- genau wie bei einem Server, der
+   nicht laeuft. Wer sie liest, sucht am Server. Deshalb steht sie
+   jetzt hier als eigene Pruefung: Die naechste Datei, die in so eine
+   Nummer rutscht, soll es HIER erfahren und nicht in einer
+   Fehlersuche. */
+const BOESE = [1, 7, 9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 37, 42, 43, 53,
+  69, 77, 79, 87, 95, 101, 102, 103, 104, 109, 110, 111, 113, 115, 117, 119,
+  123, 135, 137, 138, 139, 143, 161, 179, 389, 427, 465, 512, 513, 514, 515,
+  526, 530, 531, 532, 540, 548, 554, 556, 563, 587, 601, 636, 989, 990, 993,
+  995, 1719, 1720, 1723, 2049, 3659, 4045, 4190, 5060, 5061, 6000, 6566, 6665,
+  6666, 6667, 6668, 6669, 6679, 6697, 10080];
+const getroffen = [...belegt.keys()].filter((x) => BOESE.includes(x));
+ok(getroffen.length === 0,
+  `keine der ${belegt.size} Nummern steht auf der Sperrliste (${getroffen.join(", ") || "—"})`);
+
+/* GEGENPROBE AM ECHTEN VERHALTEN, nicht an der Liste: Ein Zuhoerer auf
+   einer gesperrten Nummer muss fuer `fetch` unerreichbar sein, einer
+   daneben erreichbar. Ohne das waere die Liste oben nur eine
+   Behauptung ueber Node -- und Behauptungen altern. */
+{
+  const { createServer } = await import("node:http");
+  const probe = async (nummer) => {
+    const dienst = createServer((q, a) => { a.writeHead(200); a.end("da"); });
+    await new Promise((r) => dienst.listen(nummer, "127.0.0.1", r));
+    let grund = "erreichbar";
+    try { await fetch(`http://127.0.0.1:${nummer}/`); }
+    catch (f) { grund = f?.cause?.message || f?.message || "?"; }
+    await new Promise((r) => dienst.close(r));
+    return grund;
+  };
+  const gesperrt = await probe(5060);
+  const erlaubt = await probe(portNummer(0));
+  ok(/bad port/i.test(gesperrt),
+    `eine gesperrte Nummer ist fuer fetch tot, obwohl jemand lauscht (5060: ${gesperrt})`);
+  ok(erlaubt === "erreichbar",
+    `eine abgeleitete dagegen nicht (${portNummer(0)}: ${erlaubt})`);
+}
+
+console.log("\n=== 3. Die Ableitung stimmt wirklich (gemessen, nicht gerechnet) ===");
+/* NICHT die Formel gegen sich selbst pruefen -- das waere eine
+   Bestaetigung ohne Aussage. Gefragt wird die Funktion, die die
+   Pruefungen auch benutzen, und verglichen wird mit der Stelle im
+   Alphabet. */
+const ersteDatei = dateien[0];
+const meine = dateien.indexOf("pruef-portnummern.mjs");
+const p0 = await eigenerPort(import.meta, "pruef-portnummern (Selbsttest)", 0);
+ok(p0 === portNummer(meine * 2),
+  `meine eigene Nummer ist ${p0} — Stelle ${meine} im Alphabet, erste Datei ${ersteDatei}`);
+const p1 = await eigenerPort(import.meta, "pruef-portnummern (Selbsttest)", 1);
+ok(p1 === p0 + 1, `und die zweite ist ${p1}, also genau eine daneben`);
+
+console.log("\n=== 4. Gegenprobe: kann sie auch NICHT IN ORDNUNG sagen? ===");
+/* Eine Pruefung, die immer bestaetigt, bestaetigt nichts. */
+let drittesAusgangGriff = false;
+try {
+  /* Eine Datei, die es nicht gibt -- die Ableitung darf dann NICHT
+     raten, sondern muss abbrechen. */
+  await eigenerPort({ url: new URL("./gibt-es-nicht.mjs", import.meta.url).href }, "Gegenprobe");
+} catch (f) {
+  drittesAusgangGriff = /steht nicht in der Liste/.test(f?.message || "");
+}
+ok(drittesAusgangGriff, "eine unbekannte Datei bekommt keine geratene Nummer, sondern einen Abbruch");
+
+let zuHoheNummer = false;
+try { await eigenerPort(import.meta, "Gegenprobe", 7); }
+catch (f) { zuHoheNummer = /Nummern je Datei/.test(f?.message || ""); }
+ok(zuHoheNummer, "und eine dritte Nummer je Datei gibt es nicht");
+
+console.log(`\n${ok_} Pruefungen, ${fehl} Fehler`);
+console.log(fehl ? "NICHT IN ORDNUNG\n" : "ALLES IN ORDNUNG\n");
+process.exit(fehl ? 1 : 0);

server/pruef-protokoll-klappe.mjs

@@ -15,8 +15,8 @@ process.env.WORKSPACE_DB = join(ordner, "pruef.sqlite");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4180, "pruef-protokoll-klappe");
+const PORT = await eigenerPort(import.meta, "pruef-protokoll-klappe");
-process.env.PORT = "4180";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -26,7 +26,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -35,7 +35,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-protokoll-klappe");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4180";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 200_000).unref?.();
 
 let fehler = 0;

server/pruef-protokoll-loeschen.mjs

@@ -36,8 +36,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4197, "pruef-protokoll-loeschen");
+const PORT = await eigenerPort(import.meta, "pruef-protokoll-loeschen");
-process.env.PORT = "4197";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -47,7 +47,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -56,7 +56,7 @@ await import("./index.js");
    Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
 notbremse(480_000, "pruef-protokoll-loeschen");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4197";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();
 
 let fehler = 0;

server/pruef-push-weg.mjs

@@ -51,6 +51,18 @@ import {
 
    `unref()` allein genuegt nicht -- es nimmt dem Handle nur das Recht,
    den Prozess am Leben zu halten; im Schliessen ist es trotzdem. */
+/* ZWEI NACHGEBAUTE PUSH-DIENSTE, ZWEI NUMMERN (20.09.2026).
+   Vorher standen hier 4341 und 4342 fest -- und 4341 gehoerte
+   gleichzeitig pruef-agentur. Aufgefallen ist das NICHT beim
+   Nachzaehlen der Doppelungen: Diese Datei rief den Waechter gar
+   nicht auf und tauchte in der Liste deshalb nie auf. Gefunden hat
+   sie erst pruef-portnummern mit der anderen Frage -- "wer startet
+   einen Server, ohne seine Nummer abzuleiten?". Eine Liste zeigt
+   nur, was auf ihr steht. */
+const { eigenerPort } = await import("./helfer-port.mjs");
+const PORT = await eigenerPort(import.meta, "pruef-push-weg", 0);
+const PORT2 = await eigenerPort(import.meta, "pruef-push-weg (Fehlercodes)", 1);
+
 const schliessen = (dienst) => new Promise((fertig) => {
   if (!dienst.listening) return fertig();
   dienst.close(() => fertig());
@@ -141,10 +153,10 @@ let empfangen = null, kopfzeilen = null;
       a.writeHead(201); a.end();
     });
   });
-  await new Promise((r) => dienst.listen(4341, "127.0.0.1", r));
+  await new Promise((r) => dienst.listen(PORT, "127.0.0.1", r));
 
   const paar = schluesselErzeugen();
-  const e = await schicken({ endpunkt: "http://127.0.0.1:4341/push/abc", ...anmeldung },
+  const e = await schicken({ endpunkt: `http://127.0.0.1:${PORT}/push/abc`, ...anmeldung },
     TEXT, paar, "mailto:[email protected]");
 
   ok(e.ok, `zugestellt (Status ${e.status})`);
@@ -181,8 +193,8 @@ console.log("\n=== Ein Geraet, das es nicht mehr gibt ===");
   const paar = schluesselErzeugen();
   for (const [code, erwartetWeg] of [[410, true], [404, true], [500, false], [429, false]]) {
     const d = createServer((q, a) => { a.writeHead(code); a.end(); });
-    await new Promise((r) => d.listen(4342, "127.0.0.1", r));
+    await new Promise((r) => d.listen(PORT2, "127.0.0.1", r));
-    const e = await schicken({ endpunkt: "http://127.0.0.1:4342/x", ...anmeldung },
+    const e = await schicken({ endpunkt: `http://127.0.0.1:${PORT2}/x`, ...anmeldung },
       TEXT, paar, "mailto:[email protected]");
     ok(e.weg === erwartetWeg,
       `${code} -> weg=${e.weg} (erwartet ${erwartetWeg})`

server/pruef-push-ziel.mjs

@@ -37,10 +37,10 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createServer } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4423, "pruef-push-ziel");
+const PORT = await eigenerPort(import.meta, "pruef-push-ziel");
-const DIENST = await portMussFreiSein(4424, "pruef-push-ziel (Push-Dienst)");
+const DIENST = await eigenerPort(import.meta, "pruef-push-ziel (Push-Dienst)", 1);
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-pz-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-rechte-umstellen.mjs

@@ -24,9 +24,9 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { request as httpAnfrage } from "node:http";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4405, "pruef-rechte-umstellen");
+const PORT = await eigenerPort(import.meta, "pruef-rechte-umstellen");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-rechte-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-rechtetafel.mjs

@@ -46,9 +46,9 @@
 import { mkdtempSync, rmSync, readdirSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4397, "pruef-rechtetafel");
+const PORT = await eigenerPort(import.meta, "pruef-rechtetafel");
 
 const ordner = mkdtempSync(join(tmpdir(), "ws-rechte-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");

server/pruef-rollen-anlegen.mjs

@@ -40,9 +40,9 @@
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 
-const PORT = await portMussFreiSein(4497, "pruef-rollen-anlegen");
+const PORT = await eigenerPort(import.meta, "pruef-rollen-anlegen");
 const ordner = mkdtempSync(join(tmpdir(), "ws-ra-"));
 process.env.WORKSPACE_DB = join(ordner, "workspace.db");
 process.env.PORT = String(PORT);

server/pruef-rollen.mjs

@@ -38,8 +38,8 @@ process.env.WORKSPACE_DB = join(ordner, "workspace.db");
    STILL nicht -- und alles Folgende misst gegen einen fremden
    Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
    als kaputt. */
-await portMussFreiSein(4193, "pruef-rollen");
+const PORT = await eigenerPort(import.meta, "pruef-rollen");
-process.env.PORT = "4193";
+process.env.PORT = `${PORT}`;
 process.env.SITE_ACCESS_SECRET = "lokaler-test";
 process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
 process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
@@ -49,7 +49,7 @@ 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 }); };
 import { notbremse } from "./helfer-notbremse.mjs";
-import { portMussFreiSein } from "./helfer-port.mjs";
+import { eigenerPort } from "./helfer-port.mjs";
 await import("./index.js");
 /* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
    zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -76,7 +76,7 @@ await import("./index.js");
    irgendwann gar nichts mehr. */
 notbremse(900_000, "pruef-rollen");
 await new Promise((r) => setTimeout(r, 700));
-const BASIS = "http://127.0.0.1:4193";
+const BASIS = `http://127.0.0.1:${PORT}`;
 setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 540_000).unref?.();
 
 let fehler = 0;