dogfather-universe/server/pruef-glocke.mjs

/* DER BENACHRICHTIGUNGS-KNOPF, IM ECHTEN BROWSER.

   Wunsch Filipe, 05.09.2026, mit dem Bild eines "Benachrichtigungen
   aus"-Knopfes: *"ich will auch sowas und dass es perfekt funktioniert
   auf der seite für jeden!!!!"*

   ---------------------------------------------------------------------
   WAS HIER NICHT GEMESSEN WERDEN KANN — und warum das dasteht

   `pushManager.subscribe()` braucht einen echten Push-Dienst. Chromium
   spricht dafür mit Googles FCM, Firefox mit Mozillas autopush. Ein
   Browser, der in einer Prüfung startet, hat diese Verbindung nicht --
   der Aufruf scheitert, und daran ist nichts zu ändern.

   Das ist der DRITTE AUSGANG aus der Projektnotiz: nicht in Ordnung ist
   etwas anderes als nicht nachgesehen. Diese Prüfung tut deshalb
   zweierlei:

     1. Sie MISST ZUERST, ob echtes subscribe hier geht. Geht es, wird
        der echte Weg geprüft. Geht es nicht, wird das ausdrücklich
        gemeldet -- nicht verschwiegen und nicht als "bestanden".

     2. Für alles andere tritt ein Test-Doppel an die Stelle des
        Browser-Kanals: Der PushManager wird ersetzt, alles davor und
        dahinter bleibt echt. Damit sind Knopf, Zustände, Server-Aufrufe
        und Speicherung wirklich geprüft -- nur die Strecke zwischen
        Browser und Google nicht.

   Was die Rechnung selbst angeht, ist die Lage besser als es klingt:
   pruef-push.mjs prüft sie gegen die Testvektoren aus RFC 8291 und
   8292, pruef-push-weg.mjs schickt eine Nachricht durch einen
   nachgebauten Dienst und macht sie wieder auf. Was hier fehlt, ist
   allein der Schritt "Browser holt sich eine Adresse bei Google".

   ---------------------------------------------------------------------
   GEMESSEN WIRD

     * Steht der Knopf auf JEDER Seite (außer der Anmeldeseite)?
     * Sagt er in jeder Lage die Wahrheit -- auch wenn sie unbequem ist?
       (abgelehnt, iPhone im Reiter, alter Browser)
     * Legt ein Klick wirklich eine Anmeldung an, und nimmt ein zweiter
       sie wieder weg?
     * Bekommt jede ROLLE ihn -- "für jeden" war der Wunsch.

   GEGENPROBEN durchgehend. */

import { mkdtempSync, rmSync, appendFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

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

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

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 express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
   zwei Auffangnetze ein, die einen Absturz nur protokollieren --
   richtig fuer den Betrieb, fatal fuer eine Pruefung. Ohne diese
   Zeile bleibt der Prozess nach einem Fehler ewig stehen, weil der
   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:${PORT}`;

const PROTOKOLL = join(process.cwd(), "pruef-glocke-lauf.txt");
try { rmSync(PROTOKOLL, { force: true }); } catch { /* gab es noch nicht */ }
const melde = (z) => {
  console.log(z);
  try { appendFileSync(PROTOKOLL, z + "\n"); } catch { /* Zugabe */ }
};
let fehler = 0;
const ok = (b, t) => { melde((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };
const hinweis = (t) => melde("  --     " + t);

/* ---- Bestand ------------------------------------------------------------ */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
for (let i = 0; i < 60; i++) {
  try {
    const p = new DatabaseSync(process.env.WORKSPACE_DB);
    try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
  } catch { await new Promise((r) => setTimeout(r, 250)); }
}
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
function anlegen(name, rolle, code) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(code, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
anlegen("Cigdem", "manager", "CODE-MANA-0001");
const idScout = anlegen("Patrick", "scout", "CODE-SCOU-0001");
const idLuna = anlegen("Luna", "creator", "CODE-CREA-0001");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idScout, jetzt);
d.close();

const pw = await import("file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");

/** Ein Test-Doppel für den Browser-Push-Kanal.
 *
 *  Ersetzt NUR pushManager -- Berechtigung, Service Worker, Knopf,
 *  fetch und Server bleiben echt. Der Endpunkt sieht aus wie einer von
 *  Google und ist https, weil der Server das verlangt (und verlangen
 *  soll: eine http-Zustelladresse wäre im Klartext erreichbar). */
const DOPPEL = `
  (() => {
    const abo = {
      endpoint: 'https://fcm.googleapis.com/fcm/send/PRUEF-' + Math.random().toString(36).slice(2),
      getKey: (art) => new Uint8Array(art === 'auth' ? 16 : 65).fill(7),
      toJSON: () => ({ keys: {
        p256dh: 'BQ'.padEnd(87, 'A'), auth: 'AQ'.padEnd(22, 'A'),
      } }),
      unsubscribe: async () => true,
    };
    let angemeldet = null;
    const manager = {
      subscribe: async () => { angemeldet = abo; return abo; },
      getSubscription: async () => angemeldet,
    };
    /* Auch die Registrierung wird abgefangen: Der Service Worker
       selbst wird hier nicht gebraucht, und ein fehlgeschlagenes
       register() würde den ganzen Ablauf abbrechen. */
    const reg = { pushManager: manager, showNotification: async () => {} };
    Object.defineProperty(navigator, 'serviceWorker', {
      configurable: true,
      value: {
        register: async () => reg,
        getRegistration: async () => reg,
        ready: Promise.resolve(reg),
        addEventListener: () => {},
      },
    });
    window.__doppel = true;
  })();
`;

/* DEN BERECHTIGUNGSSTAND SETZEN — und warum das nötig ist.

   Ein Chromium, der in einer Prüfung startet, meldet
   `Notification.permission === "denied"`. Ein echter Browser meldet
   beim ersten Besuch "default" und fragt erst, wenn man klickt.

   Ohne diese Zeile misst die Prüfung also überall den Zustand
   "schon einmal abgelehnt" -- und der Knopf sagt dann völlig zu Recht
   "Vom Browser blockiert". Beim ersten Lauf standen deshalb acht
   Fehler da, von denen keiner ein Fehler war: Der Knopf tat genau das
   Richtige, nur zur falschen Frage.

   `grantPermissions` allein genügt nicht -- es setzt die Berechtigung
   im Browser, aber der Ausgangszustand "noch nicht gefragt" lässt sich
   damit nicht herstellen. Deshalb wird beides gesetzt: der Stand und,
   wo nötig, die Antwort auf die Nachfrage. */
function berechtigung(stand) {
  return `
    (() => {
      Object.defineProperty(Notification, 'permission',
        { value: '${stand}', configurable: true });
      Notification.requestPermission = async () => '${stand === "default" ? "granted" : stand}';
    })();
  `;
}

async function anmelden(ctx, rolle, code) {
  const seite = await ctx.newPage();
  await seite.goto(BASIS + "/workspace/", { waitUntil: "networkidle" });
  await seite.click(`.rolle[data-rolle="${rolle}"]`);
  await seite.fill("#code", code);
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 25000 });
  return seite;
}

/* =======================================================================
   1. Geht ECHTES subscribe in dieser Umgebung?
   ======================================================================= */
melde("\n=== Lässt sich der echte Browser-Kanal hier messen? ===");
let echtGeht = false;
{
  const browser = await pw.chromium.launch();
  const ctx = await browser.newContext({ permissions: ["notifications"] });
  const seite = await anmelden(ctx, "admin", "CODE-DOGI-0001");

  const ergebnis = await seite.evaluate(async () => {
    try {
      const reg = await navigator.serviceWorker.register('/workspace/sw.js', { scope: '/workspace/' });
      await navigator.serviceWorker.ready;
      const a = await fetch('/workspace/api/push/schluessel', { credentials: 'same-origin' });
      const { schluessel } = await a.json();
      const roh = atob(schluessel.replace(/-/g, '+').replace(/_/g, '/')
        + '='.repeat((4 - schluessel.length % 4) % 4));
      const abo = await reg.pushManager.subscribe({
        userVisibleOnly: true,
        applicationServerKey: Uint8Array.from(roh, (c) => c.charCodeAt(0)),
      });
      return { ok: true, endpunkt: abo.endpoint.slice(0, 40) };
    } catch (f) { return { ok: false, grund: String(f?.message || f).slice(0, 80) }; }
  });

  echtGeht = ergebnis.ok;
  if (echtGeht) {
    ok(true, `echtes subscribe GEHT hier — geprüft wird der echte Weg (${ergebnis.endpunkt}…)`);
  } else {
    /* KEIN FEHLER, aber auch kein Haken: der dritte Ausgang. */
    hinweis(`echtes subscribe geht hier NICHT: ${ergebnis.grund}`);
    hinweis(`   Grund: ein Prüf-Browser hat keine Verbindung zu Googles Push-Dienst.`);
    hinweis(`   Die Verschlüsselung selbst ist in pruef-push.mjs gegen die`);
    hinweis(`   RFC-Testvektoren geprüft, die Zustellung in pruef-push-weg.mjs.`);
    hinweis(`   Hier wird der PushManager ersetzt; alles davor und dahinter ist echt.`);
  }
  await browser.close();
}

/* =======================================================================
   2. Steht der Knopf da — auf jeder Seite, bei jeder Rolle?
   ======================================================================= */
melde("\n=== Der Knopf ist überall ===");
{
  const browser = await pw.chromium.launch();
  const ctx = await browser.newContext();
  await ctx.addInitScript(berechtigung("default"));
  const seite = await anmelden(ctx, "admin", "CODE-DOGI-0001");

  const seitenNamen = ["start", "aufgaben", "kalender", "bereich", "content",
    "dateien", "wissen", "report"];
  let gefunden = 0;
  const ohne = [];
  for (const n of seitenNamen) {
    await seite.goto(`${BASIS}/workspace/${n}.html`, { waitUntil: "networkidle" });
    await seite.waitForTimeout(250);
    if (await seite.$("#glocke")) gefunden++; else ohne.push(n);
  }
  ok(gefunden === seitenNamen.length,
    ohne.length ? `fehlt auf: ${ohne.join(", ")}`
      : `auf allen ${gefunden} geprüften Seiten`);

  /* Und NICHT auf der Anmeldeseite -- dort ist niemand angemeldet,
     den man benachrichtigen könnte. */
  await seite.goto(BASIS + "/workspace/", { waitUntil: "networkidle" });
  await seite.waitForTimeout(250);
  ok(!(await seite.$("#glocke")), "auf der Anmeldeseite steht er nicht");

  await browser.close();
}

melde("\n=== Jede Rolle bekommt ihn ===");
{
  const browser = await pw.chromium.launch();
  for (const [name, rolle, code] of [
    ["DogFather", "admin", "CODE-DOGI-0001"], ["Manager", "manager", "CODE-MANA-0001"],
    ["Scout", "scout", "CODE-SCOU-0001"], ["Creator", "creator", "CODE-CREA-0001"],
  ]) {
    const ctx = await browser.newContext();
    await ctx.addInitScript(berechtigung("default"));
    const seite = await anmelden(ctx, rolle, code);
    await seite.waitForTimeout(400);
    const da = await seite.$("#glocke");
    const text = da ? await seite.$eval("#glocke .glocke__text", (e) => e.textContent) : "";
    ok(!!da, `${name}: ${da ? `Knopf da ("${text}")` : "FEHLT"}`);
    await ctx.close();
  }
  await browser.close();
}

/* =======================================================================
   3. Sagt er in jeder Lage die Wahrheit?
   ======================================================================= */
melde("\n=== Die Lagen ===");
{
  const browser = await pw.chromium.launch();

  /* AUS -- noch nie gefragt worden. Das ist der Zustand, in dem jeder
     zum ersten Mal auf die Seite kommt. */
  {
    const ctx = await browser.newContext();
    await ctx.addInitScript(berechtigung("default"));
    const seite = await anmelden(ctx, "admin", "CODE-DOGI-0001");
    await seite.waitForTimeout(400);
    const lage = await seite.$eval("#glocke", (e) => e.dataset.lage);
    const text = await seite.$eval("#glocke .glocke__text", (e) => e.textContent);
    ok(lage === "aus" && /aus/i.test(text), `ohne Berechtigung: "${text}" (${lage})`);

    /* Der Strich muss sichtbar sein -- er sagt es ohne Lesen. */
    const strich = await seite.$eval(".glocke__strich", (e) => getComputedStyle(e).opacity);
    ok(Number(strich) > 0.5, `die Glocke ist durchgestrichen (${strich})`);
    await ctx.close();
  }

  /* VERBOTEN -- schon einmal abgelehnt. Der wichtigste Fall: Per
     JavaScript lässt sich das NICHT zurücknehmen, also muss der Knopf
     sagen, wo man es tut. Ein Knopf, der hier nur nichts tut, ist der
     sichere Weg zu "das funktioniert nicht". */
  {
    const ctx = await browser.newContext();
    await ctx.grantPermissions([]);                       // alles verweigert
    const seite = await anmelden(ctx, "admin", "CODE-DOGI-0001");
    await seite.evaluate(() => {
      Object.defineProperty(Notification, "permission", { value: "denied", configurable: true });
    });
    await seite.reload({ waitUntil: "networkidle" });
    await seite.evaluate(() => {
      Object.defineProperty(Notification, "permission", { value: "denied", configurable: true });
    });
    await seite.waitForTimeout(400);
    const lage = await seite.evaluate(() => {
      document.getElementById("glocke")?.click();
      return document.getElementById("glocke")?.dataset.lage;
    });
    const titel = await seite.$eval("#glocke", (e) => e.title);
    ok(lage === "verboten", `abgelehnt: Lage "${lage}"`);
    ok(/Browsereinstellungen/i.test(titel),
      `und er sagt, WO man es ändert: "${titel.slice(0, 80)}…"`);
    await ctx.close();
  }

  /* GEHT NICHT -- ein Browser ohne Push. */
  {
    const ctx = await browser.newContext();
    const seite = await anmelden(ctx, "admin", "CODE-DOGI-0001");
    await seite.addInitScript(() => {
      delete window.PushManager;
    });
    await seite.reload({ waitUntil: "networkidle" });
    await seite.waitForTimeout(400);
    const lage = await seite.$eval("#glocke", (e) => e.dataset.lage);
    const aus = await seite.$eval("#glocke", (e) => e.disabled);
    ok(lage === "geht-nicht" && aus,
      `Browser ohne Push: Lage "${lage}", Knopf abgeschaltet (${aus})`);
    await ctx.close();
  }

  /* IPHONE im Reiter -- dort gibt es die Berechtigung überhaupt erst
     nach "Zum Home-Bildschirm". Das muss dastehen, sonst tippt jemand
     zehnmal und hält es für kaputt. */
  {
    const ctx = await browser.newContext({
      userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) "
        + "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1",
    });
    const seite = await anmelden(ctx, "admin", "CODE-DOGI-0001");
    await seite.waitForTimeout(400);
    const lage = await seite.$eval("#glocke", (e) => e.dataset.lage);
    const titel = await seite.$eval("#glocke", (e) => e.title);
    ok(lage === "iphone", `iPhone im Reiter: Lage "${lage}"`);
    ok(/Home-Bildschirm/i.test(titel), `mit Anleitung: "${titel.slice(0, 70)}…"`);
    await ctx.close();
  }

  await browser.close();
}

/* =======================================================================
   4. An- und abmelden — mit dem Test-Doppel
   ======================================================================= */
melde("\n=== Anmelden und wieder abmelden ===");
{
  const browser = await pw.chromium.launch();
  const ctx = await browser.newContext({ permissions: ["notifications"] });
  await ctx.addInitScript(berechtigung("granted"));
  await ctx.addInitScript(DOPPEL);
  const seite = await ctx.newPage();
  await seite.goto(BASIS + "/workspace/", { waitUntil: "networkidle" });
  await seite.click('.rolle[data-rolle="admin"]');
  await seite.fill("#code", "CODE-DOGI-0001");
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 25000 });
  await seite.waitForTimeout(500);

  /* Steht das Doppel überhaupt? Ohne diese Prüfung liefe alles
     Folgende womöglich gegen den echten (hier kaputten) Kanal und
     meldete Fehler, die nichts bedeuten. */
  ok(await seite.evaluate(() => window.__doppel === true),
    "das Test-Doppel steht (der Rest der Kette ist echt)");

  const p = new DatabaseSync(process.env.WORKSPACE_DB);
  const zahl = () => p.prepare("SELECT COUNT(*) AS n FROM push_anmeldungen").get().n;
  ok(zahl() === 0, `vorher ${zahl()} Anmeldungen in der Datenbank`);

  /* ==== "BEI DIR KLINGELT NICHTS" (19.09.2026) ======================

     Gemessen an diesem Tag auf dem echten Server: Von elf Zugaengen
     hatten SIEBEN kein einziges Geraet angemeldet. Bei ihnen kommt
     nichts an, solange die Seite zu ist -- keine Aufgabe, kein Termin,
     kein Anruf.

     Die Glocke sagt das seit jeher korrekt. Nur tippt sie niemand an:
     Sie ist ein stiller Schalter in einer Leiste. Deshalb steht es
     jetzt auch dort, wo man hinsieht -- in "Was ist dran?".

     DIE GEGENPROBE IST DER EIGENTLICHE PUNKT: Der Hinweis muss
     VERSCHWINDEN, sobald ein Geraet da ist. Eine Warnung, die immer
     kommt, ist keine Warnung mehr -- und bei sieben von elf Leuten
     stuende sie sonst dauerhaft ueber den echten. */
  const hinweise = async () => (await seite.evaluate(async () => {
    const a = await fetch("/workspace/api/hinweise", { credentials: "same-origin" });
    return a.json();
  })).hinweise || [];

  {
    const vorher = await hinweise();
    const h = vorher.find((x) => x.art === "kein_geraet");
    ok(!!h, "ohne Geraet steht der Hinweis in „Was ist dran?“");
    ok(h?.ziel === "anruf-probe.html",
      `und er fuehrt auf die Seite, die sagt warum (${h?.ziel})`);
    ok(h?.stufe === "offen",
      `als offener Punkt, nicht als Warnung (${h?.stufe}) — sonst stuende er `
      + "dauerhaft ueber den echten Warnungen");
    /* Und auf dem Bildschirm steht er ohne die "1" davor: Er zaehlt
       nichts, er beschreibt einen Zustand. */
    const sichtbar = await seite.evaluate(() =>
      [...document.querySelectorAll(".dran__punkt")]
        .map((li) => li.textContent.trim()).find((t) => /klingelt nichts/.test(t)) || "");
    ok(/klingelt nichts/.test(sichtbar) && !/^\s*1/.test(sichtbar),
      `auf der Seite steht er ohne Zahl davor: „${sichtbar.replace(/\s+/g, " ").slice(0, 60)}“`);
  }

  await seite.click("#glocke");
  await seite.waitForTimeout(1200);

  ok(zahl() === 1, `nach dem Klick: ${zahl()} Anmeldung`);

  /* GEGENPROBE: Jetzt muss der Hinweis weg sein. */
  {
    /* OHNE NEULADEN. Der erste Anlauf lud die Seite neu -- danach war
       das Test-Doppel fuer den Push-Dienst weg, der Glockenknopf stand
       wieder auf "aus", und die drei folgenden Pruefungen meldeten
       Fehler, die es nicht gab. Die Schnittstelle antwortet ohnehin
       live; eine neue Seite braucht es dafuer nicht. */
    const nachher = await hinweise();
    ok(!nachher.some((x) => x.art === "kein_geraet"),
      "mit einem angemeldeten Geraet ist der Hinweis weg — nichts zu quittieren");
  }

  const eintrag = p.prepare("SELECT * FROM push_anmeldungen").get();
  ok(eintrag?.person_id === idDogi && /^https:\/\//.test(eintrag?.endpunkt || ""),
    `sie gehört der richtigen Person und hat eine https-Adresse`);
  /* Der Gerätename hilft beim Wiedererkennen in der Liste. */
  ok(/Chrome|Edge|Browser/.test(eintrag?.geraet || ""),
    `Gerät erkannt: "${eintrag?.geraet}"`);

  const lage = await seite.$eval("#glocke", (e) => e.dataset.lage);
  const text = await seite.$eval("#glocke .glocke__text", (e) => e.textContent);
  ok(lage === "an" && /an/i.test(text), `der Knopf steht jetzt auf "${text}" (${lage})`);

  const strich = await seite.$eval(".glocke__strich", (e) => getComputedStyle(e).opacity);
  ok(Number(strich) < 0.2, `der Strich ist weg (${strich})`);

  /* NOCH EINMAL KLICKEN darf nicht verdoppeln -- INSERT OR REPLACE auf
     dem Endpunkt. Sonst käme jede Nachricht mehrfach an. */
  await seite.click("#glocke");        // aus
  await seite.waitForTimeout(900);
  ok(zahl() === 0, `nach dem Abmelden: ${zahl()} Anmeldungen`);

  await seite.click("#glocke");        // wieder an
  await seite.waitForTimeout(1200);
  await seite.click("#glocke");        // aus
  await seite.waitForTimeout(900);
  await seite.click("#glocke");        // an
  await seite.waitForTimeout(1200);
  ok(zahl() === 1, `nach mehrfachem Hin und Her: genau ${zahl()} Anmeldung, keine Dubletten`);

  /* Und der Stand-Weg zeigt sie -- ohne den vollen Endpunkt zu
     verraten, der die Zustelladresse dieses Geräts ist. */
  const stand = await seite.evaluate(async () => {
    const a = await fetch("/workspace/api/push/stand", { credentials: "same-origin" });
    return a.json();
  });
  ok(stand.geraete?.length === 1 && !stand.geraete[0].endpunkt,
    `der Stand nennt ${stand.geraete?.length} Gerät, aber nicht dessen volle Adresse`);
  ok(Array.isArray(stand.arten) && stand.arten.length >= 3,
    `${stand.arten?.length} Arten von Benachrichtigungen einstellbar`);

  p.close();
  await browser.close();
}

/* =======================================================================
   GEGENPROBE — misst das oben überhaupt etwas?
   ======================================================================= */
melde("\n=== Gegenprobe ===");
{
  const browser = await pw.chromium.launch();
  const ctx = await browser.newContext({ permissions: ["notifications"] });
  await ctx.addInitScript(berechtigung("granted"));
  const seite = await ctx.newPage();
  /* Ein Doppel, dessen subscribe SCHEITERT. Der Knopf darf dann NICHT
     auf "an" springen -- täte er es, wäre die Anzeige eine Lüge, und
     alle Haken oben wären wertlos. */
  await seite.addInitScript(`
    (() => {
      const reg = { pushManager: {
        subscribe: async () => { throw new Error('Registration failed'); },
        getSubscription: async () => null,
      } };
      Object.defineProperty(navigator, 'serviceWorker', {
        configurable: true,
        value: { register: async () => reg, getRegistration: async () => reg,
                 ready: Promise.resolve(reg), addEventListener: () => {} },
      });
    })();
  `);
  await seite.goto(BASIS + "/workspace/", { waitUntil: "networkidle" });
  await seite.click('.rolle[data-rolle="admin"]');
  await seite.fill("#code", "CODE-DOGI-0001");
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 25000 });
  await seite.waitForTimeout(500);

  const p = new DatabaseSync(process.env.WORKSPACE_DB);
  const vorher = p.prepare("SELECT COUNT(*) AS n FROM push_anmeldungen").get().n;
  await seite.click("#glocke");
  await seite.waitForTimeout(1200);
  const nachher = p.prepare("SELECT COUNT(*) AS n FROM push_anmeldungen").get().n;
  const lage = await seite.$eval("#glocke", (e) => e.dataset.lage);

  ok(lage !== "an" && nachher === vorher,
    `wenn subscribe scheitert: Knopf bleibt auf "${lage}", `
    + `Anmeldungen ${vorher} → ${nachher} (keine erfundene)`);

  /* Und die Seite darf daran nicht zerbrechen. */
  const lebt = await seite.evaluate(() => !!document.getElementById("glocke"));
  ok(lebt, "die Seite läuft weiter, der Knopf ist noch da");

  p.close();
  await browser.close();
}

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

melde(`\n${fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`}`);
if (!echtGeht) {
  melde(`HINWEIS: Der Schritt "Browser holt eine Adresse beim Push-Dienst" war`);
  melde(`hier nicht messbar (kein Zugang zu FCM). Alles andere wurde geprüft.`);
}
process.exit(fehler ? 1 : 0);