// Playwright-Checks des Terminplaner-Widgets public/embed/termine.js gegen den UI-Testserver (test/ui/termineTestServer.mjs):
// echte Router, Nachbau von Appwrite/Stripe, Mail-Senke. Nicht Teil von npm test.
// Aufruf: nice node test/ui/termine-widget.ui.mjs        (vorher free -m; es laeuft nur ein Browser)
// Screenshots: /root/reports/terminplaner-ui/widget-*.png (bei Fehlern fehler-widget-<Pruefung>.png). Exit-Code 1, wenn eine Pruefung scheitert.
//
// Seiten: Das Widget laeuft auf Seiten von srv.pageOrigin (http://localhost:PORT) und spricht die Schnittstelle unter
// srv.url (http://127.0.0.1:PORT) an: echte Cross-Origin-Anfragen mit Preflight. Die Demo-Seite (/embed/termine-demo.html)
// laeuft ohne data-api (gleiche Herkunft). Server-Uhr: Montag 2026-10-05 10:00 Berliner Zeit (laeuft in Echtzeit weiter).
import http from 'node:http'
import { mkdir, readdir, readFile, rm } from 'node:fs/promises'
import path from 'node:path'
import { fileURLToPath } from 'node:url'
import {
  startTermineUiServer, salonEingabe,
  R_ANNA, S_DAMEN, S_HERREN,
} from './termineTestServer.mjs'

const PW = process.env.PLAYWRIGHT_CORE || '/root/.npm/_npx/db89d7302a373f10/node_modules/playwright-core/index.mjs'
const { chromium } = await import(PW)

const SHOTS = '/root/reports/terminplaner-ui'
await mkdir(SHOTS, { recursive: true })
for (const datei of await readdir(SHOTS)) if (/^(widget|fehler-widget)-.*\.png$/.test(datei)) await rm(path.join(SHOTS, datei)) // alte Laeufe
const WIDGET_JS = path.join(path.dirname(fileURLToPath(import.meta.url)), '../../public/embed/termine.js')

const srv = await startTermineUiServer({ crossOrigin: true })
const KEY = srv.SITE_KEY
const SEITE = srv.pageOrigin
const API = '**/api/public/termine/v1/**'

// ---------------------------------------------------------------- Helfer

function assert(cond, msg) { if (!cond) throw new Error(msg) }
function eq(ist, soll, msg) {
  const a = JSON.stringify(ist)
  const b = JSON.stringify(soll)
  if (a !== b) throw new Error(`${msg}: ${a} statt ${b}`)
}

const eingebettet = (attrs = '', fallback = '<p id="ausweich">Termine telefonisch unter 06301 1234.</p>', key = KEY) =>
  `<div data-webklar-termine="${key}" data-api="${srv.url}" ${attrs}>${fallback}</div>`

const seitenHtml = (widgets, { head = '', style = '', skript = '<script src="/embed/termine.js" defer></script>' } = {}) => `<!doctype html>
<html lang="de"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Testseite</title>
<style>body{margin:0;font-family:system-ui,sans-serif;background:#f6f7f9;color:#1f2937}main{max-width:760px;margin:0 auto;padding:24px 16px}${style}</style>${head}</head>
<body><main><h1>Testseite</h1>${widgets}</main>${skript}</body></html>`

/** Seite von srv.pageOrigin mit eigenem Inhalt (liefert der Testserver selbst unter /ui-seiten/). */
async function oeffne(page, html, name = 'testseite.html') {
  await page.goto(srv.seite(name, html))
}

const shot = (page, name) => page.screenshot({ path: `${SHOTS}/widget-${name}.png`, fullPage: true })
const w = (page, i = 0) => page.locator('[data-webklar-termine]').nth(i)
const titel = (wd) => wd.locator('h2.wkt-titel').first()
const karte = (wd, text) => wd.locator('.wkt-karte', { hasText: text })
const tag = (wd, t) => wd.locator(`td[data-tag="${t}"]`)
const zeit = (wd, z) => wd.locator('.wkt-zeit', { hasText: new RegExp(`^${z}$`) })
const warteTitel = (wd, text) => wd.locator('h2.wkt-titel', { hasText: text }).waitFor()

/** Leistung, Person, Tag, Uhrzeit, Angaben ausfuellen bis zur Zusammenfassung. Fehlt ein Wert (null), entfaellt der Schritt. */
async function bisZusammenfassung(page, o = {}) {
  const wd = w(page, o.widget ?? 0)
  const v = { leistung: 'Damenschnitt', person: 'Egal', tag: '2026-10-12', zeit: '10:00', name: 'Max Mustermann', email: 'max@example.com', ...o }
  if (v.leistung) await karte(wd, v.leistung).click()
  if (v.person) await karte(wd, v.person).click()
  await tag(wd, v.tag).click()
  await zeit(wd, v.zeit).click()
  await wd.locator('input[name=name]').fill(v.name)
  await wd.locator('input[name=email]').fill(v.email)
  if (v.telefon) await wd.locator('input[name=telefon]').fill(v.telefon)
  await wd.getByRole('button', { name: 'Weiter' }).click()
  await wd.locator('.wkt-zusammen').waitFor()
  return wd
}

async function hakenUndBuchen(wd, knopf) {
  for (const n of ['storno', 'vorzeitig']) {
    const cb = wd.locator(`input[name=${n}]`)
    if (await cb.count()) await cb.check()
  }
  await wd.getByRole('button', { name: knopf }).click()
  await wd.getByRole('heading', { name: 'Fast geschafft' }).waitFor()
}

/** Kein Streifen rechts: Seite und Widget passen in die Breite. */
const passtInBreite = (page) => page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth)

// ---------------------------------------------------------------- Ablauf der Pruefungen

const results = []
let browser = null
const hosts = new Set()

async function check(name, fn, { eingabe, context = {}, initScript } = {}) {
  await srv.zuruecksetzen({ eingabe })
  const ctx = await browser.newContext({ viewport: { width: 1000, height: 900 }, ...context })
  const page = await ctx.newPage()
  page.setDefaultTimeout(8000)
  const fehler = []
  page.on('pageerror', (e) => fehler.push(e.message))
  page.on('request', (r) => { try { const u = new URL(r.url()); if (u.protocol.startsWith('http')) hosts.add(u.host) } catch { /* data: u. a. */ } })
  if (initScript) await page.addInitScript(initScript)
  try {
    await fn(page, ctx)
    assert(fehler.length === 0, `JavaScript-Fehler auf der Seite: ${fehler.join(' | ')}`)
    results.push([name, true])
    console.log(`ok   ${name}`)
  } catch (e) {
    results.push([name, false])
    console.log(`FAIL ${name}: ${e.message.split('\n')[0]}`)
    await page.screenshot({ path: `${SHOTS}/fehler-widget-${name}.png`, fullPage: true }).catch(() => {})
  } finally {
    await ctx.close()
  }
}

// ---------------------------------------------------------------- 1. Inline bis "Fast geschafft"

async function pruefungen() {
  await check('inline_bis_fast_geschafft', async (page, ctx) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = w(page)
    await karte(wd, 'Herrenschnitt').waitFor()
    assert(await page.locator('#ausweich').count() === 0, 'Ausweichtext blieb stehen, obwohl das Widget lief')
    eq(await titel(wd).innerText(), 'Welche Leistung möchten Sie buchen?', 'Titel Schritt 1')
    assert((await wd.innerText()).includes('Bezahlung vor Ort: bar, EC-Karte, Kreditkarte'), 'Zahlungsart fehlt im ersten Schritt')
    assert((await karte(wd, 'Damenschnitt').innerText()).includes('ab 45,00 €'), 'Preis "ab" fehlt')
    assert((await karte(wd, 'Damenschnitt').innerText()).includes('45 Minuten'), 'Dauer fehlt')
    await shot(page, 'inline-1-leistung')

    await karte(wd, 'Damenschnitt').click()
    await warteTitel(wd, 'Bei wem')
    assert(await karte(wd, 'Egal').count() === 1 && await karte(wd, 'Anna').count() === 1 && await karte(wd, 'Ben').count() === 1, 'Personenwahl: Egal, Anna, Ben')
    assert((await wd.locator('.wkt-karte').first().innerText()).startsWith('Egal'), '"Egal" muss die erste Option sein')
    await shot(page, 'inline-2-person')

    await karte(wd, 'Egal').click()
    await warteTitel(wd, 'Wann passt es Ihnen?')
    await wd.locator('td.wkt-tag').first().waitFor()
    eq(await wd.locator('.wkt-monat').innerText(), 'Oktober 2026', 'Monat')
    eq(await tag(wd, '2026-10-11').getAttribute('aria-disabled'), 'true', 'Sonntag ist gesperrt')
    eq(await tag(wd, '2026-10-12').getAttribute('aria-disabled'), 'false', 'Montag ist frei')
    eq(await tag(wd, '2026-10-12').getAttribute('aria-selected'), 'false', 'noch nichts gewaehlt')
    await tag(wd, '2026-10-12').click()
    await wd.locator('.wkt-zeit').first().waitFor()
    eq(await tag(wd, '2026-10-12').getAttribute('aria-selected'), 'true', 'gewaehlter Tag')
    eq(await wd.locator('.wkt-zeiten-titel').innerText(), 'Freie Zeiten am Montag, 12.10.2026', 'Titel der Uhrzeiten')
    const zeiten = await wd.locator('.wkt-zeit').allInnerTexts()
    eq(zeiten.slice(0, 3), ['09:00', '09:15', '09:30'], 'erste Uhrzeiten (Berliner Wanduhr)')
    assert(!zeiten.includes('12:30') && zeiten.includes('13:30'), 'Mittagspause (12:30 bis 13:30) muss fehlen')
    await shot(page, 'inline-3-termin')

    await zeit(wd, '10:00').click()
    await warteTitel(wd, 'Ihre Angaben')
    await wd.locator('input[name=name]').fill('Max Mustermann')
    await wd.locator('input[name=email]').fill('max@example.com')
    await wd.locator('input[name=telefon]').fill('0171 1234567')
    await shot(page, 'inline-4-daten')
    await wd.getByRole('button', { name: 'Weiter' }).click()

    await warteTitel(wd, 'Bitte prüfen Sie Ihre Buchung')
    const zus = await wd.locator('.wkt-zusammen').innerText()
    for (const t of ['Damenschnitt (45 Minuten)', 'Montag, 12.10.2026', '10:00 Uhr', 'ab 45,00 € (inkl. USt)', 'Salon Müller, Hauptstr. 1, 67722 Winnweiler', 'Max Mustermann', 'max@example.com']) {
      assert(zus.replace(/\s+/g, ' ').includes(t), `Zusammenfassung ohne "${t}": ${zus}`)
    }
    assert((await wd.locator('.wkt-box').innerText()).includes('Danach berechnen wir 50 % des Preises.'), 'Stornoregel im Klartext fehlt')
    assert(zus.replace(/\s+/g, ' ').includes('Beschreibung Mit Beratung zur Frisur.'), 'Beschreibung der Leistung fehlt in der Zusammenfassung')
    const agb = wd.locator('.wkt-box a')
    eq([await agb.innerText(), await agb.getAttribute('href'), await agb.getAttribute('rel'), await agb.getAttribute('target')],
      ['AGB des Betriebs', 'https://salon-mueller.example/agb', 'noopener noreferrer', '_blank'], 'Link auf die AGB neben den Stornobedingungen')
    const det = wd.locator('details.wkt-belehrung')
    assert(await det.count() === 1 && await det.evaluate((d) => !d.open), 'Widerrufsbelehrung muss aufklappbar und zu sein')
    await det.locator('summary').click()
    assert((await det.innerText()).includes('Widerrufsbelehrung') && (await det.innerText()).includes('Muster-Widerrufsformular'), 'Belehrung nicht lesbar')
    const belehrung = det.locator('.wkt-belehrung-text')
    eq([await belehrung.getAttribute('tabindex'), await belehrung.getAttribute('role'), await belehrung.getAttribute('aria-label')],
      ['0', 'region', 'Widerrufsbelehrung und Muster-Widerrufsformular'], 'Belehrungstext per Tastatur scrollbar')
    await det.locator('summary').click()
    assert((await wd.locator('.wkt-datenschutz').innerText()).startsWith('Datenschutz. Wir verwenden Ihre Angaben'), 'Datenschutz-Hinweis')
    eq(await wd.locator('.wkt-datenschutz a').getAttribute('rel'), 'noopener noreferrer', 'rel am Datenschutz-Link')
    // Haken: Storno und vorzeitiger Beginn Pflicht (12.10. liegt in der Widerrufsfrist), Erinnerung freiwillig und nicht vorangekreuzt
    eq(await wd.locator('label[for$="h-storno"]').innerText(), 'Ich habe die Stornobedingungen gelesen.', 'Haken Storno')
    assert((await wd.locator('label[for$="h-vorzeitig"]').innerText()).startsWith('Ich verlange ausdrücklich, dass Salon Müller mit der Leistung vor Ablauf der Widerrufsfrist beginnt.'), 'Haken vorzeitig')
    eq(await wd.locator('label[for$="h-erinnerung"]').innerText(), 'Ich möchte 24 Stunden vor dem Termin eine Erinnerung per E-Mail erhalten. Diese Einwilligung kann ich jederzeit widerrufen.', 'Haken Erinnerung')
    assert(!(await wd.locator('input[name=erinnerung]').isChecked()), 'Erinnerung darf nicht vorangekreuzt sein')
    assert(await wd.locator('input[name=storno]').getAttribute('required') !== null && await wd.locator('input[name=vorzeitig]').getAttribute('required') !== null, 'Pflicht-Haken')
    assert(await wd.locator('input[name=erinnerung]').getAttribute('required') === null, 'Erinnerung ist freiwillig')
    eq(await wd.locator('.wkt-form button[type=submit]').innerText(), 'Zahlungspflichtig buchen', 'Knopftext aus der Konfiguration')
    await shot(page, 'inline-5-pruefen')

    await hakenUndBuchen(wd, 'Zahlungspflichtig buchen')
    eq(await titel(wd).innerText(), 'Fast geschafft', 'Titel Ergebnis')
    eq(await wd.locator('.wkt-ergebnis-text').innerText(),
      'Bitte bestätigen Sie den Termin über den Link, den wir an m***@example.com geschickt haben. Der Termin ist 30 Minuten für Sie reserviert.', 'Ergebnistext')
    await shot(page, 'inline-6-fast-geschafft')

    // Server: genau eine gehaltene Buchung, G01 an den Gast mit Bestaetigungslink
    await srv.warteAufVersand()
    const buchungen = srv.buchungen()
    eq(buchungen.length, 1, 'Anzahl Buchungen')
    eq([buchungen[0].status, buchungen[0].gastEmail, buchungen[0].leistungId, buchungen[0].gastName], ['gehalten', 'max@example.com', S_DAMEN, 'Max Mustermann'], 'Buchung')
    const g01 = srv.mails().filter((m) => m.to.some((t) => t.address === 'max@example.com'))
    eq(g01.length, 1, 'G01-Mails an den Gast')
    assert(/termin\.html#v=[A-Za-z0-9_-]{43}/.test(g01[0].text), 'G01 ohne Bestätigungslink')
    assert(!g01[0].bcc?.length, 'nie BCC')

    // Kein Cookie, kein Speicher
    const speicher = await page.evaluate(() => ({ c: document.cookie, l: localStorage.length, s: sessionStorage.length }))
    eq(speicher, { c: '', l: 0, s: 0 }, 'Cookies/Storage')
    eq((await ctx.cookies()).length, 0, 'Cookies im Browser')
  })

  // ---------------------------------------------------------------- 2. Demo-Seite und Aufbau

  await check('demo_seite_stile_und_honigtopf', async (page) => {
    await page.goto(`${SEITE}/embed/termine-demo.html`)
    await karte(w(page, 0), 'Herrenschnitt').waitFor()
    assert(await page.locator('#ausweich-inline').count() === 0, 'Ausweichtext (inline) muss ersetzt sein')
    eq(await page.locator('#wkt-style').count(), 1, '<style id="wkt-style"> genau einmal')
    assert((await page.locator('#wkt-style').textContent()).includes('@layer wkt'), 'Stile stehen nicht in @layer wkt')
    const knopf = page.getByRole('button', { name: 'Termin online buchen' })
    assert(await knopf.isVisible(), 'Knopf der Demo fehlt')
    const bg = await knopf.evaluate((b) => getComputedStyle(b).backgroundColor)
    assert(bg !== 'rgba(0, 0, 0, 0)', `Knopf ohne Hintergrund (${bg})`)
    const wd = w(page, 0)
    await karte(wd, 'Kinderschnitt').click()
    await karte(wd, 'Egal').click()
    await tag(wd, '2026-10-13').click()
    await zeit(wd, '09:00').click()
    await warteTitel(wd, 'Ihre Angaben')
    // Honigtopf: unsichtbar, nicht anwaehlbar, ohne Autovervollstaendigung, vor Screenreadern versteckt
    const hp = wd.locator('input[name=kontakt_url]')
    eq(await hp.getAttribute('autocomplete'), 'off', 'autocomplete')
    eq(await hp.getAttribute('tabindex'), '-1', 'tabindex')
    eq(await hp.evaluate((i) => i.closest('[aria-hidden="true"]') !== null), true, 'aria-hidden')
    const box = await hp.evaluate((i) => { const r = i.closest('[aria-hidden]').getBoundingClientRect(); return { x: r.x + r.width, w: r.width } })
    assert(box.x <= 0 || box.w <= 2, `Honigtopf im sichtbaren Bereich: ${JSON.stringify(box)}`)
    // aria-live polite fuer Meldungen
    assert(await page.locator('[aria-live="polite"]').count() >= 1, 'aria-live="polite" fehlt')
  })

  // ---------------------------------------------------------------- 3. Knopfmodus mit <dialog>

  await check('knopf_dialog', async (page) => {
    const anfragen = []
    page.on('request', (r) => { if (r.url().includes('/api/public/termine/')) anfragen.push(r.url()) })
    await oeffne(page, seitenHtml(eingebettet('data-modus="knopf" data-knopf="Termin online buchen"')))
    const knopf = page.getByRole('button', { name: 'Termin online buchen' })
    await knopf.waitFor()
    await page.waitForTimeout(400)
    // R54: beim Laden der Seite genau ein Abruf, die Konfiguration (fuer den Knopf "Vertrag widerrufen"), sonst nichts
    eq(anfragen.map((u) => new URL(u).pathname.replace(/^.*\/v1\/[^/]+/, '')), ['/config'], 'Vor dem Klick nur die Konfiguration')
    assert(await page.locator('#ausweich').count() === 0 || !(await page.locator('#ausweich').isVisible()), 'Ausweichtext darf neben dem Knopf nicht stehen')
    eq(await page.locator('dialog.wkt-dialog').count(), 1, 'ein <dialog>')
    assert(!(await page.locator('dialog.wkt-dialog').evaluate((d) => d.open)), 'Dialog ist zu')

    await knopf.click()
    const dlg = page.locator('dialog.wkt-dialog')
    await karte(dlg, 'Herrenschnitt').waitFor()
    eq(anfragen.filter((u) => u.includes('/config')).length, 1, 'der Klick laedt die Konfiguration nicht noch einmal')
    assert(await dlg.evaluate((d) => d.open && d.matches(':modal')), 'Dialog muss modal offen sein')
    eq(await dlg.getAttribute('aria-label'), 'Termin online buchen', 'Name des Dialogs')
    await shot(page, 'knopf-dialog')
    // Esc schliesst, Fokus zurueck auf den Knopf, Wiederoeffnen ohne neuen Abruf der Konfiguration
    await page.keyboard.press('Escape')
    assert(!(await dlg.evaluate((d) => d.open)), 'Esc schliesst den Dialog nicht')
    assert(await knopf.evaluate((b) => document.activeElement === b), 'Fokus nicht zurueck auf dem Knopf')
    await knopf.click()
    await karte(dlg, 'Herrenschnitt').waitFor()
    eq(anfragen.filter((u) => u.includes('/config')).length, 1, 'Wiederoeffnen laedt die Konfiguration nicht noch einmal')
    // Klick auf den Hintergrund schliesst ebenfalls
    await page.mouse.click(4, 4)
    assert(!(await dlg.evaluate((d) => d.open)), 'Klick auf den Hintergrund schliesst nicht')
    await knopf.click()

    // Komplett durchbuchen im Dialog (kostenlose Leistung: "Termin buchen", ohne Haken fuer vorzeitigen Beginn)
    await karte(dlg, 'Kennenlern-Beratung').click()
    await karte(dlg, 'Ben').click()
    await tag(dlg, '2026-10-14').click()
    await shot(page, 'knopf-dialog-termin')
    await zeit(dlg, '15:00').click()
    await dlg.locator('input[name=name]').fill('Erika Muster')
    await dlg.locator('input[name=email]').fill('erika@example.com')
    await dlg.getByRole('button', { name: 'Weiter' }).click()
    await dlg.locator('.wkt-zusammen').waitFor()
    eq(await dlg.locator('input[name=vorzeitig]').count(), 0, 'kein Haken fuer vorzeitigen Beginn ohne Preis')
    eq(await dlg.locator('.wkt-form button[type=submit]').innerText(), 'Termin buchen', 'Knopftext ohne Preis')
    eq(await dlg.locator('input[name=storno]').count(), 0, 'kein Storno-Haken ohne Preis (F11)')
    eq(await dlg.locator('.wkt-box h3', { hasText: 'Stornobedingungen' }).count(), 0, 'keine Stornobox ohne Preis (F11)')
    await dlg.getByRole('button', { name: 'Termin buchen' }).click()
    await dlg.getByRole('heading', { name: 'Fast geschafft' }).waitFor()
    await srv.warteAufVersand()
    eq(srv.buchungen().map((b) => [b.ressourceId, b.gastName]).sort(), [['r_ben00002', 'Erika Muster']], 'Buchung mit gewaehlter Person')
  })

  await check('knopf_mit_vorgewaehlter_leistung', async (page) => {
    await oeffne(page, seitenHtml(eingebettet(`data-modus="knopf" data-knopf="Damenschnitt buchen" data-leistung="${S_DAMEN}"`)))
    await page.getByRole('button', { name: 'Damenschnitt buchen' }).click()
    const dlg = page.locator('dialog.wkt-dialog')
    await warteTitel(dlg, 'Bei wem')
    eq(await dlg.locator('.wkt-pfad').innerText(), 'Schritt 1 von 4', 'ohne Leistungsschritt')
    eq(await karte(dlg, 'Herrenschnitt').count(), 0, 'Leistungsliste darf nicht erscheinen')
    await karte(dlg, 'Egal').click()
    assert((await dlg.locator('.wkt-hinweis').first().innerText()).startsWith('Damenschnitt'), 'vorgewaehlte Leistung steht im Termin-Schritt')
  })

  // Ruling R54: die Widerrufsfunktion steht im Knopfmodus dauerhaft neben dem Buchungsknopf und oeffnet den Dialog gleich beim Formular
  await check('knopf_widerruf_knopf_dauerhaft', async (page) => {
    const anfragen = []
    page.on('request', (r) => { if (r.url().includes('/api/public/termine/')) anfragen.push(new URL(r.url()).pathname.replace(/^.*\/v1\/[^/]+/, '')) })
    await oeffne(page, seitenHtml(eingebettet('data-modus="knopf" data-knopf="Termin online buchen"')))
    const haupt = page.getByRole('button', { name: 'Termin online buchen' })
    const widerruf = page.locator('.wkt-knopf-box > button', { hasText: 'Vertrag widerrufen' })
    await widerruf.waitFor()
    await page.waitForTimeout(300)
    eq(anfragen, ['/config'], 'nur ein Abruf beim Laden der Seite')
    assert(!(await page.locator('dialog.wkt-dialog').evaluate((d) => d.open)), 'Dialog ist zu')
    const boxen = await page.evaluate(() => {
      const [a, b] = [...document.querySelectorAll('.wkt-knopf-box > button')].map((e) => e.getBoundingClientRect())
      return { gleicheZeile: Math.abs(a.top - b.top) < 4, rechtsDavon: b.left >= a.right - 1, hoeheB: b.height, hoeheA: a.height }
    })
    assert(boxen.gleicheZeile && boxen.rechtsDavon, `Widerrufsknopf neben dem Buchungsknopf: ${JSON.stringify(boxen)}`)
    assert(boxen.hoeheB >= 44, `Widerrufsknopf mindestens 44 px hoch: ${boxen.hoeheB}`)
    const stil = await widerruf.evaluate((b) => ({ grund: getComputedStyle(b).backgroundColor, rand: getComputedStyle(b).borderTopColor }))
    assert(stil.grund === 'rgba(0, 0, 0, 0)' || stil.grund === 'transparent', `sekundaer (ohne Fuellung): ${stil.grund}`)
    await shot(page, 'knopf-mit-widerruf')

    await widerruf.click()
    const dlg = page.locator('dialog.wkt-dialog')
    await warteTitel(dlg, 'Vertrag widerrufen')
    assert(await dlg.evaluate((d) => d.open && d.matches(':modal')), 'Dialog modal offen')
    eq(await dlg.locator('input[name=name]').count(), 1, 'Widerrufsformular')
    eq(anfragen, ['/config'], 'auch das Oeffnen laedt nichts nach')
    eq(await dlg.getByRole('button', { name: 'Zurück zur Terminbuchung' }).count(), 1, 'Weg zurueck zur Buchung')
    // Fuss im Dialog: ebenfalls ein Knopf (aber auf der Widerrufsseite zeigt er dieselbe Seite)
    await dlg.getByRole('button', { name: 'Zurück zur Terminbuchung' }).click()
    await karte(dlg, 'Herrenschnitt').waitFor()
    eq(anfragen, ['/config'], 'Zurueck zur Buchung laedt nichts nach')
    // Esc: der Fokus kehrt zu dem Knopf zurueck, der den Dialog geoeffnet hat
    await page.keyboard.press('Escape')
    assert(await widerruf.evaluate((b) => document.activeElement === b), 'Fokus nicht zurueck auf dem Widerrufsknopf')
    // Der Buchungsknopf zeigt wieder die Buchung, nicht das Widerrufsformular
    await widerruf.click()
    await warteTitel(dlg, 'Vertrag widerrufen')
    await page.keyboard.press('Escape')
    await haupt.click()
    await karte(dlg, 'Herrenschnitt').waitFor()
    eq(await dlg.locator('input[name=name]').count(), 0, 'Buchungsknopf: kein Widerrufsformular')
    assert(await haupt.evaluate((b) => b !== document.activeElement), 'Dialog offen: Fokus im Dialog')
    // Widerruf aus dem Fuss des laufenden Dialogs, dann zurueck (der Stand bleibt)
    await karte(dlg, 'Herrenschnitt').click()
    await dlg.locator('.wkt-fuss').getByRole('button', { name: 'Vertrag widerrufen' }).click()
    await warteTitel(dlg, 'Vertrag widerrufen')
    await dlg.getByRole('button', { name: 'Zurück zur Terminbuchung' }).click()
    await karte(dlg, 'Egal').waitFor()
  })

  // Widerrufsformular gleich beim Oeffnen, danach "Zurueck zur Terminbuchung" beginnt die Buchung mit der vorgewaehlten Leistung
  await check('knopf_widerruf_mit_vorgewaehlter_leistung', async (page) => {
    await oeffne(page, seitenHtml(eingebettet(`data-modus="knopf" data-knopf="Damenschnitt buchen" data-leistung="${S_DAMEN}"`)))
    await page.locator('.wkt-knopf-box > button', { hasText: 'Vertrag widerrufen' }).click()
    const dlg = page.locator('dialog.wkt-dialog')
    await warteTitel(dlg, 'Vertrag widerrufen')
    await dlg.getByRole('button', { name: 'Zurück zur Terminbuchung' }).click()
    await warteTitel(dlg, 'Bei wem')
    eq(await karte(dlg, 'Herrenschnitt').count(), 0, 'Leistungsliste darf nicht erscheinen')
  })

  await check('knopf_ohne_widerrufsrecht_kein_widerrufsknopf', async (page) => {
    const anfragen = []
    page.on('request', (r) => { if (r.url().includes('/api/public/termine/')) anfragen.push(r.url()) })
    await oeffne(page, seitenHtml(eingebettet('data-modus="knopf" data-knopf="Termin buchen"')))
    await page.getByRole('button', { name: 'Termin buchen' }).waitFor()
    await page.waitForTimeout(500)
    eq(await page.locator('.wkt-knopf-box > button').count(), 1, 'nur der Buchungsknopf (Gaeste sind Unternehmen)')
    eq(anfragen.length, 1, 'ein Abruf beim Laden')
    await page.getByRole('button', { name: 'Termin buchen' }).click()
    await karte(page.locator('dialog.wkt-dialog'), 'Herrenschnitt').waitFor()
    eq(await page.locator('dialog.wkt-dialog .wkt-fuss').getByRole('button', { name: 'Vertrag widerrufen' }).count(), 0, 'auch im Fuss kein Widerruf')
  }, { eingabe: salonEingabe({ recht: { gaesteSind: 'unternehmer', freizeit: false } }) })

  // ---------------------------------------------------------------- 4. Nur Tastatur

  await check('nur_tastatur', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    await karte(w(page), 'Herrenschnitt').waitFor()
    const aktiv = (fn, arg) => page.evaluate(fn, arg)
    const tabBis = async (bedingung, max = 25) => {
      for (let i = 0; i < max; i += 1) {
        await page.keyboard.press('Tab')
        if (await page.evaluate(bedingung)) return
      }
      throw new Error(`Fokus nicht erreicht (${bedingung})`)
    }
    await tabBis(() => document.activeElement?.matches('[data-webklar-termine] .wkt-karte'))
    eq(await aktiv(() => document.activeElement.querySelector('.wkt-karte-name').textContent), 'Herrenschnitt', 'erste Karte')
    await page.keyboard.press('Enter')
    await warteTitel(w(page), 'Bei wem')
    assert(await aktiv(() => document.activeElement?.matches('h2.wkt-titel')), 'Fokus muss auf der neuen Ueberschrift liegen')
    await page.keyboard.press('Tab')
    assert((await aktiv(() => document.activeElement.textContent)).startsWith('Egal'), 'Tab von der Ueberschrift: erste Option')
    await page.keyboard.press('Enter')
    await warteTitel(w(page), 'Wann passt es Ihnen?')
    await w(page).locator('td.wkt-tag').first().waitFor()
    await tabBis(() => document.activeElement?.matches('td.wkt-tag'))
    const start = await aktiv(() => document.activeElement.dataset.tag)
    eq(start, '2026-10-05', 'Raster startet beim ersten freien Tag')
    await page.keyboard.press('ArrowDown')
    await page.keyboard.press('ArrowDown')
    eq(await aktiv(() => document.activeElement.dataset.tag), '2026-10-19', 'zwei Wochen weiter')
    await page.keyboard.press('Enter')
    await w(page).locator('.wkt-zeit').first().waitFor()
    eq(await tag(w(page), '2026-10-19').getAttribute('aria-selected'), 'true', 'Auswahl mit Enter')
    await tabBis(() => document.activeElement?.matches('.wkt-zeit'))
    eq(await aktiv(() => document.activeElement.textContent), '09:00', 'erste Uhrzeit')
    await page.keyboard.press('Enter')
    await warteTitel(w(page), 'Ihre Angaben')
    await tabBis(() => document.activeElement?.matches('input[name=name]'))
    await page.keyboard.type('Max Mustermann')
    await page.keyboard.press('Tab')
    await page.keyboard.type('max@example.com')
    await page.keyboard.press('Enter') // Absenden des Formulars per Enter
    await warteTitel(w(page), 'Bitte prüfen Sie Ihre Buchung')
    for (let i = 0; i < 20; i += 1) {
      await page.keyboard.press('Tab')
      const a = await page.evaluate(() => ({ name: document.activeElement.name || '', submit: document.activeElement.matches('.wkt-form button[type=submit]'), text: document.activeElement.textContent }))
      if (a.name === 'storno' || a.name === 'vorzeitig') await page.keyboard.press('Space')
      if (a.submit) {
        eq(a.text, 'Zahlungspflichtig buchen', 'Knopf per Tastatur erreicht')
        await page.keyboard.press('Enter')
        break
      }
    }
    await w(page).getByRole('heading', { name: 'Fast geschafft' }).waitFor()
    assert(await aktiv(() => document.activeElement?.matches('h2.wkt-titel') && document.activeElement.textContent === 'Fast geschafft'), 'Fokus auf "Fast geschafft"')
    await srv.warteAufVersand()
    eq(srv.buchungen().map((b) => [b.leistungId, b.gastName, b.status]), [[S_HERREN, 'Max Mustermann', 'gehalten']], 'Buchung per Tastatur')
  })

  await check('monatsraster_tasten', async (page) => {
    await oeffne(page, seitenHtml(eingebettet(`data-modus="inline" data-leistung="${S_HERREN}"`)))
    const wd = w(page)
    await karte(wd, 'Egal').click()
    await wd.locator('td.wkt-tag').first().waitFor()
    const grid = wd.locator('table[role=grid]')
    eq(await grid.getAttribute('aria-labelledby') !== null, true, 'Raster ist benannt')
    eq(await wd.locator('td[role=gridcell][tabindex="0"]').count(), 1, 'genau eine Zelle mit tabindex 0 (Roving)')
    await wd.locator('td[tabindex="0"]').focus()
    const aktTag = () => page.evaluate(() => document.activeElement.dataset.tag)
    const monat = () => wd.locator('.wkt-monat').innerText()
    eq(await aktTag(), '2026-10-05', 'Start')
    await page.keyboard.press('Control+ArrowRight'); eq(await aktTag(), '2026-10-05', 'Strg+Pfeil gehoert dem Browser, nicht dem Raster')
    await page.keyboard.press('Meta+ArrowDown'); eq(await aktTag(), '2026-10-05', 'Meta+Pfeil gehoert dem System, nicht dem Raster')
    await page.keyboard.press('ArrowRight'); eq(await aktTag(), '2026-10-06', 'Pfeil rechts')
    await page.keyboard.press('ArrowDown'); eq(await aktTag(), '2026-10-13', 'Pfeil runter = +7')
    await page.keyboard.press('ArrowLeft'); eq(await aktTag(), '2026-10-12', 'Pfeil links')
    await page.keyboard.press('ArrowUp'); eq(await aktTag(), '2026-10-05', 'Pfeil hoch = -7')
    await page.keyboard.press('End'); eq(await aktTag(), '2026-10-11', 'Ende = Sonntag der Woche')
    eq(await tag(wd, '2026-10-11').getAttribute('aria-disabled'), 'true', 'Sonntag ist aria-disabled, aber anwaehlbar')
    await page.keyboard.press('Enter')
    eq(await wd.locator('.wkt-zeit').count(), 0, 'Enter auf gesperrtem Tag waehlt nichts')
    eq(await tag(wd, '2026-10-11').getAttribute('aria-selected'), 'false', 'gesperrter Tag bleibt unausgewaehlt')
    await page.keyboard.press('Home'); eq(await aktTag(), '2026-10-05', 'Pos1 = Montag der Woche')
    await page.keyboard.press('PageDown')
    await wd.locator('.wkt-monat', { hasText: 'November 2026' }).waitFor()
    eq(await aktTag(), '2026-11-05', 'Bild runter = naechster Monat, gleicher Tag')
    await page.keyboard.press('Home'); eq(await aktTag(), '2026-11-02', 'Pos1 im November')
    await page.keyboard.press('ArrowUp')
    await wd.locator('.wkt-monat', { hasText: 'Oktober 2026' }).waitFor()
    eq(await aktTag(), '2026-10-26', 'Pfeil hoch ueber die Monatsgrenze')
    await page.keyboard.press('ArrowDown'); await wd.locator('.wkt-monat', { hasText: 'November 2026' }).waitFor()
    eq(await aktTag(), '2026-11-02', 'Pfeil runter zurueck in den November')
    await page.keyboard.press('ArrowLeft'); eq(await aktTag(), '2026-11-01', 'Pfeil links')
    await page.keyboard.press('ArrowLeft'); await wd.locator('.wkt-monat', { hasText: 'Oktober 2026' }).waitFor()
    eq(await aktTag(), '2026-10-31', 'Pfeil links vom 1. in den Vormonat')
    await page.keyboard.press('PageUp')
    eq(await monat(), 'Oktober 2026', 'vor dem aktuellen Monat gibt es kein Zurueck')
    eq(await wd.getByRole('button', { name: 'Vorheriger Monat' }).isDisabled(), true, 'Pfeil zurueck im aktuellen Monat gesperrt')
    await page.keyboard.press('PageDown'); await wd.locator('.wkt-monat', { hasText: 'November 2026' }).waitFor()
    await page.keyboard.press('Enter')
    await wd.locator('.wkt-zeit').first().waitFor()
    eq(await tag(wd, '2026-11-30').count(), 1, 'Tage des Novembers stehen im Raster')
    assert(await wd.locator('td[aria-selected="true"]').count() === 1, 'genau ein Tag ausgewaehlt')
  })

  // ---------------------------------------------------------------- 5. Handy, 390 px

  await check('handy_390', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = w(page)
    await karte(wd, 'Herrenschnitt').waitFor()
    const pruefe = async (schritt) => {
      assert(await passtInBreite(page), `${schritt}: seitliches Scrollen`)
      const klein = await page.evaluate(() => [...document.querySelectorAll('[data-webklar-termine] :is(button,input:not([name=kontakt_url]),textarea,select,summary,td.wkt-tag,a)')]
        .filter((e) => e.getClientRects().length && !e.closest('[aria-hidden="true"]:not(td)') && !e.closest('.wkt-datenschutz'))
        .map((e) => { const r = e.getBoundingClientRect(); return { t: e.tagName + '.' + e.className, w: Math.round(r.width), h: Math.round(r.height) } })
        .filter((r) => r.w < 24 || r.h < 24))
      assert(klein.length === 0, `${schritt}: Zielgroesse unter 24 px: ${JSON.stringify(klein)}`)
    }
    await pruefe('Leistung')
    await shot(page, '390-1-leistung')
    await karte(wd, 'Damenschnitt').click()
    await karte(wd, 'Egal').click()
    await tag(wd, '2026-10-12').click()
    await wd.locator('.wkt-zeit').first().waitFor()
    await pruefe('Termin')
    await shot(page, '390-2-termin')
    await zeit(wd, '10:00').click()
    await warteTitel(wd, 'Ihre Angaben')
    await pruefe('Angaben')
    await shot(page, '390-3-daten')
    await wd.locator('input[name=name]').fill('Max Mustermann')
    await wd.locator('input[name=email]').fill('max@example.com')
    await wd.getByRole('button', { name: 'Weiter' }).click()
    await wd.locator('.wkt-zusammen').waitFor()
    await pruefe('Zusammenfassung')
    await shot(page, '390-4-pruefen')
    await hakenUndBuchen(wd, 'Zahlungspflichtig buchen')
    await pruefe('Ergebnis')
    await shot(page, '390-5-fast-geschafft')
    const breite = await wd.evaluate((e) => e.getBoundingClientRect().width)
    assert(breite <= 390, `Widget breiter als der Bildschirm: ${breite}`)
  }, { context: { viewport: { width: 390, height: 844 }, deviceScaleFactor: 2, isMobile: true, hasTouch: true } })

  await check('handy_390_dialog', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="knopf" data-knopf="Termin buchen"')))
    await page.getByRole('button', { name: 'Termin buchen' }).click()
    const dlg = page.locator('dialog.wkt-dialog')
    await karte(dlg, 'Herrenschnitt').waitFor()
    const maße = await dlg.evaluate((d) => { const r = d.getBoundingClientRect(); return { l: r.left, r: r.right, t: r.top, b: r.bottom, w: window.innerWidth, h: window.innerHeight, scroll: d.scrollHeight > d.clientHeight } })
    assert(maße.l >= 0 && maße.r <= maße.w + 0.5 && maße.t >= 0 && maße.b <= maße.h + 0.5, `Dialog ragt aus dem Bildschirm: ${JSON.stringify(maße)}`)
    assert(maße.scroll, 'Der lange Inhalt muss im Dialog scrollen')
    await page.screenshot({ path: `${SHOTS}/widget-390-dialog.png` })
    assert(await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth), 'seitliches Scrollen mit offenem Dialog')
  }, { context: { viewport: { width: 390, height: 700 }, deviceScaleFactor: 2, isMobile: true, hasTouch: true } })

  // ---------------------------------------------------------------- 6. Zeitzone: New York zeigt dasselbe wie Berlin

  const erfasse = async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = w(page)
    await karte(wd, 'Damenschnitt').click()
    await karte(wd, 'Egal').click()
    await wd.locator('td.wkt-tag').first().waitFor()
    const monat = await wd.locator('.wkt-monat').innerText()
    const frei = await wd.locator('td.wkt-tag[aria-disabled="false"]').evaluateAll((l) => l.map((e) => e.dataset.tag))
    await tag(wd, '2026-10-12').click()
    await wd.locator('.wkt-zeit').first().waitFor()
    const lang = await wd.locator('.wkt-zeiten-titel').innerText()
    const zeiten = await wd.locator('.wkt-zeit').allInnerTexts()
    await zeit(wd, '10:00').click()
    await warteTitel(wd, 'Ihre Angaben')
    await wd.locator('input[name=name]').fill('Max Mustermann')
    await wd.locator('input[name=email]').fill('max@example.com')
    await wd.getByRole('button', { name: 'Weiter' }).click()
    await wd.locator('.wkt-zusammen').waitFor()
    const zus = (await wd.locator('.wkt-zusammen').innerText()).replace(/\s+/g, ' ')
    return { monat, frei, lang, zeiten, zus }
  }
  const datumZaehler = () => {
    // zaehlt jede Benutzung von Date und Intl im Seitenskript (das Widget darf keine brauchen)
    window.__datum = 0
    const D = Date
    window.Date = new Proxy(D, {
      construct(t, a, nt) { window.__datum += 1; return Reflect.construct(t, a, nt) },
      apply(t, th, a) { window.__datum += 1; return Reflect.apply(t, th, a) },
      get(t, p, r) { if (p === 'now') window.__datum += 1; return Reflect.get(t, p, r) },
    })
    const I = Intl.DateTimeFormat
    Intl.DateTimeFormat = new Proxy(I, { construct(t, a, nt) { window.__datum += 1; return Reflect.construct(t, a, nt) }, apply(t, th, a) { window.__datum += 1; return Reflect.apply(t, th, a) } })
  }
  let berlin = null
  await check('zeitzone_berlin_referenz', async (page) => {
    berlin = await erfasse(page)
    assert(berlin.zeiten[0] === '09:00' && berlin.zus.includes('10:00 Uhr'), `Berliner Uhrzeiten: ${berlin.zeiten[0]}`)
    eq(await page.evaluate(() => window.__datum), 0, 'Date/Intl im Berliner Browser benutzt')
  }, { context: { timezoneId: 'Europe/Berlin', locale: 'de-DE' }, initScript: datumZaehler })

  await check('zeitzone_new_york_gleiche_zeiten', async (page) => {
    const ny = await erfasse(page)
    eq(await page.evaluate(() => window.__datum), 0, 'Date/Intl in New York benutzt')
    assert(await page.evaluate(() => Intl.DateTimeFormat().resolvedOptions().timeZone) === 'America/New_York', 'Browser steht nicht auf New York')
    eq(ny, berlin, 'Tage, Wochentag und Uhrzeiten in New York weichen von Berlin ab')
    eq(ny.zeiten.slice(0, 2), ['09:00', '09:15'], 'Uhrzeiten sind Berliner Wanduhr')
  }, { context: { timezoneId: 'America/New_York', locale: 'en-US' }, initScript: datumZaehler })

  // ---------------------------------------------------------------- 7. Anrede Du

  await check('anrede_du', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = w(page)
    await karte(wd, 'Herrenschnitt').waitFor()
    eq(await titel(wd).innerText(), 'Welche Leistung möchtest du buchen?', 'Titel Du')
    await karte(wd, 'Herrenschnitt').click()
    eq(await titel(wd).innerText(), 'Bei wem möchtest du den Termin?', 'Titel Person Du')
    await karte(wd, 'Egal').click()
    eq(await titel(wd).innerText(), 'Wann passt es dir?', 'Titel Termin Du')
    await tag(wd, '2026-10-26').click()
    await zeit(wd, '11:00').click()
    eq(await titel(wd).innerText(), 'Deine Angaben', 'Titel Angaben Du')
    // Fehlermeldungen Du
    await wd.getByRole('button', { name: 'Weiter' }).click()
    eq(await wd.locator('#' + await wd.locator('input[name=name]').getAttribute('id') + '-e').innerText(), 'Bitte gib deinen Namen an.', 'Fehlertext Du')
    await wd.locator('input[name=name]').fill('Max Mustermann')
    await wd.locator('input[name=email]').fill('max@example.com')
    await wd.getByRole('button', { name: 'Weiter' }).click()
    await wd.locator('.wkt-zusammen').waitFor()
    eq(await titel(wd).innerText(), 'Bitte prüfe deine Buchung', 'Titel Pruefen Du')
    assert((await wd.locator('.wkt-datenschutz').innerText()).startsWith('Datenschutz. Wir verwenden deine Angaben'), 'Datenschutz-Hinweis in Du')
    // Zustimmungstexte bleiben Rechtstext in der Sie-Form (26.10. liegt nach der Widerrufsfrist: nur Storno)
    eq(await wd.locator('label[for$="h-storno"]').innerText(), 'Ich habe die Stornobedingungen gelesen.', 'Haken Storno')
    eq(await wd.locator('input[name=vorzeitig]').count(), 0, 'nach der Widerrufsfrist kein Haken fuer vorzeitigen Beginn')
    await shot(page, 'du-pruefen')
    await hakenUndBuchen(wd, 'Zahlungspflichtig buchen')
    eq(await wd.locator('.wkt-ergebnis-text').innerText(),
      'Bitte bestätige den Termin über den Link, den wir an m***@example.com geschickt haben. Der Termin ist 30 Minuten für dich reserviert.', 'Ergebnistext Du')
  }, { eingabe: salonEingabe({ anrede: 'du' }) })

  // ---------------------------------------------------------------- 8. Zwei Widgets

  await check('zwei_widgets_stoeren_sich_nicht', async (page) => {
    const zwei = eingebettet(`data-modus="inline" data-leistung="${S_HERREN}"`, '<p id="a1">Ausweich 1</p>') + eingebettet(`data-modus="inline" data-leistung="${S_DAMEN}"`, '<p id="a2">Ausweich 2</p>')
    await oeffne(page, seitenHtml(zwei))
    const w0 = w(page, 0)
    const w1 = w(page, 1)
    await warteTitel(w0, 'Bei wem')
    await warteTitel(w1, 'Bei wem')
    eq(await page.locator('#wkt-style').count(), 1, 'Stile genau einmal')
    const ids = await page.evaluate(() => [...document.querySelectorAll('[id]')].map((e) => e.id))
    eq(new Set(ids).size, ids.length, `doppelte IDs: ${ids.filter((x, i) => ids.indexOf(x) !== i)}`)

    await karte(w0, 'Egal').click()
    await warteTitel(w0, 'Wann passt')
    eq(await karte(w1, 'Egal').count(), 1, 'Widget 2 steht noch bei der Personenwahl')
    await tag(w0, '2026-10-12').click()
    await w0.locator('.wkt-zeit').first().waitFor()
    await karte(w1, 'Ben').click()
    await w1.locator('td.wkt-tag').first().waitFor()
    await tag(w1, '2026-10-13').click()
    await w1.locator('.wkt-zeit').first().waitFor()
    eq(await w0.locator('td[aria-selected="true"]').getAttribute('data-tag'), '2026-10-12', 'Widget 1 behaelt seinen Tag')
    eq(await w1.locator('td[aria-selected="true"]').getAttribute('data-tag'), '2026-10-13', 'Widget 2 hat seinen Tag')
    assert((await w0.locator('.wkt-hinweis').first().innerText()).startsWith('Herrenschnitt'), 'Widget 1: Herrenschnitt')
    assert((await w1.locator('.wkt-hinweis').first().innerText()).startsWith('Damenschnitt'), 'Widget 2: Damenschnitt')
    // Beschriftungen und ARIA-Bezuege zeigen innerhalb des eigenen Widgets
    await zeit(w0, '10:00').click()
    await warteTitel(w0, 'Ihre Angaben')
    const bezuege = await page.evaluate(() => [...document.querySelectorAll('[data-webklar-termine]')].map((root) => ({
      labels: [...root.querySelectorAll('label[for]')].every((l) => root.contains(document.getElementById(l.htmlFor))),
      aria: [...root.querySelectorAll('[aria-labelledby],[aria-describedby]')].every((e) => (e.getAttribute('aria-labelledby') || e.getAttribute('aria-describedby')).split(' ').every((id) => root.contains(document.getElementById(id)))),
    })))
    eq(bezuege, [{ labels: true, aria: true }, { labels: true, aria: true }], 'Bezuege innerhalb des Widgets')
    await w0.locator('input[name=name]').fill('Max Mustermann')
    eq(await w1.locator('input[name=name]').count(), 0, 'Widget 2 hat kein Namensfeld')
  })

  // ---------------------------------------------------------------- 9. Eingaben und Fehler

  await check('pflichtfelder_und_haken', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = w(page)
    await karte(wd, 'Damenschnitt').click()
    await karte(wd, 'Egal').click()
    await tag(wd, '2026-10-12').click()
    await zeit(wd, '10:00').click()
    await warteTitel(wd, 'Ihre Angaben')
    await wd.getByRole('button', { name: 'Weiter' }).click()
    const name = wd.locator('input[name=name]')
    const mail = wd.locator('input[name=email]')
    eq(await name.getAttribute('aria-invalid'), 'true', 'Name ungueltig markiert')
    eq(await mail.getAttribute('aria-invalid'), 'true', 'E-Mail ungueltig markiert')
    assert(await name.evaluate((i) => document.activeElement === i), 'Fokus auf dem ersten Fehlerfeld')
    const fehlerId = await name.getAttribute('aria-describedby')
    eq(await wd.locator(`#${fehlerId}`).innerText(), 'Bitte geben Sie Ihren Namen an.', 'Fehlertext am Feld')
    assert((await page.locator('[aria-live="polite"]').first().textContent()).includes('Bitte prüfen Sie Ihre Eingaben'), 'Fehler werden per aria-live angesagt')
    await name.fill('Max Mustermann')
    await mail.fill('keine-adresse')
    await wd.locator('input[name=telefon]').fill('abc')
    await wd.getByRole('button', { name: 'Weiter' }).click()
    assert((await wd.locator('#' + await mail.getAttribute('aria-describedby')).innerText()).includes('gültige E-Mail-Adresse'), 'E-Mail-Fehler')
    assert((await wd.locator('#' + await wd.locator('input[name=telefon]').getAttribute('aria-describedby')).innerText()).includes('gültige Telefonnummer'), 'Telefon-Fehler')
    await mail.fill('max@example.com')
    await wd.locator('input[name=telefon]').fill('')
    await wd.getByRole('button', { name: 'Weiter' }).click()
    await wd.locator('.wkt-zusammen').waitFor()
    // ohne Haken: nichts wird gesendet, Fehler stehen an den Haken
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    eq(await wd.locator('input[name=storno]').getAttribute('aria-invalid'), 'true', 'Storno-Haken markiert')
    eq(await wd.locator('input[name=vorzeitig]').getAttribute('aria-invalid'), 'true', 'Haken vorzeitiger Beginn markiert')
    eq(srv.buchungen().length, 0, 'ohne Haken wird nichts gebucht')
    // Zurueck behaelt die Eingaben
    await wd.getByRole('button', { name: 'Zurück' }).click()
    eq(await wd.locator('input[name=name]').inputValue(), 'Max Mustermann', 'Eingabe bleibt nach Zurueck')
  })

  await check('zeit_inzwischen_vergeben', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = await bisZusammenfassung(page, { leistung: 'Damenschnitt', person: 'Anna', tag: '2026-10-26', zeit: '10:00' })
    // ein anderer Gast bucht Anna zur selben Zeit
    const conf = await (await fetch(`${srv.url}/api/public/termine/v1/${KEY}/config`)).json()
    const res = await fetch(`${srv.url}/api/public/termine/v1/${KEY}/buchungen`, {
      method: 'POST',
      headers: { 'content-type': 'application/json', origin: srv.url },
      body: JSON.stringify({ leistung: S_DAMEN, ressource: R_ANNA, tag: '2026-10-26', zeit: '10:00', name: 'Anderer Gast', email: 'anderer@example.com', telefon: '', nachricht: '', zusatz: {}, erinnerung: false, zustimmungen: { storno: true, vorzeitig: false }, kontakt_url: '', formToken: conf.formToken }),
    })
    eq(res.status, 201, 'zweiter Gast kann buchen')
    await wd.locator('input[name=storno]').check()
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    await warteTitel(wd, 'Wann passt es Ihnen?')
    eq(await wd.locator('.wkt-fehlertext').first().innerText(), 'Diese Zeit ist leider nicht mehr frei. Bitte eine andere Zeit wählen.', 'Hinweis auf die vergebene Zeit')
    eq(srv.buchungen().filter((b) => b.gastEmail === 'max@example.com').length, 0, 'keine zweite Buchung')
    await shot(page, 'fehler-zeit-vergeben')
  })

  await check('honigtopf_gefuellt_keine_buchung', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = await bisZusammenfassung(page, { tag: '2026-10-26' })
    await wd.locator('input[name=kontakt_url]').evaluate((i) => { i.value = 'http://spam.example'; i.dispatchEvent(new Event('input', { bubbles: true })) })
    await hakenUndBuchen(wd, 'Zahlungspflichtig buchen') // der Server antwortet gleich (kein Hinweis fuer Automaten) ...
    await srv.warteAufVersand()
    eq(srv.buchungen().length, 0, '... speichert aber nichts')
    eq(srv.mails().length, 0, '... und schickt nichts')
  })

  await check('formular_token_abgelaufen_neu_laden', async (page) => {
    const konfig = []
    page.on('request', (r) => { if (r.url().includes('/config')) konfig.push(r.url()) })
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = await bisZusammenfassung(page, { tag: '2026-10-26' })
    eq(konfig.length, 1, 'Konfiguration einmal geladen')
    await wd.locator('input[name=storno]').check()
    srv.schiebeUhr(3 * 60 * 60 * 1000) // Formular-Token ist beim Server jetzt aelter als 2 Stunden, im Browser sind erst Sekunden vergangen
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    await wd.locator('.wkt-meldung').waitFor()
    eq(await wd.locator('.wkt-meldung').innerText(), 'Das Formular wurde erneuert. Bitte versuchen Sie es noch einmal.', 'Hinweis nach neu_laden')
    eq(konfig.length, 2, 'Konfiguration neu geladen (neues Formular-Token)')
    eq(srv.buchungen().length, 0, 'noch nichts gebucht')
    eq(await wd.locator('input[name=storno]').isChecked(), true, 'Eingaben und Haken bleiben')
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    await wd.getByRole('heading', { name: 'Fast geschafft' }).waitFor()
    eq(srv.buchungen().length, 1, 'zweiter Versuch bucht')
  })

  await check('konfiguration_nach_100_minuten_neu', async (page) => {
    const konfig = []
    page.on('request', (r) => { if (r.url().includes('/config')) konfig.push(r.url()) })
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = w(page)
    await karte(wd, 'Herrenschnitt').click()
    await karte(wd, 'Egal').click()
    await tag(wd, '2026-10-26').click()
    await wd.locator('.wkt-zeit').first().waitFor()
    eq(konfig.length, 1, 'bisher eine Konfiguration')
    await page.evaluate(() => { window.__vorsprung = 99 * 60 * 1000 })
    await zeit(wd, '10:00').click()
    await warteTitel(wd, 'Ihre Angaben')
    eq(konfig.length, 1, 'nach 99 Minuten wird noch nicht neu geladen')
    await page.evaluate(() => { window.__vorsprung = 101 * 60 * 1000 })
    await wd.locator('input[name=name]').fill('Max Mustermann')
    await wd.locator('input[name=email]').fill('max@example.com')
    await wd.getByRole('button', { name: 'Weiter' }).click()
    await wd.locator('.wkt-zusammen').waitFor()
    eq(konfig.length, 2, 'nach 101 Minuten wird neu geladen')
  }, { initScript: () => { const echt = performance.now.bind(performance); window.__vorsprung = 0; performance.now = () => echt() + window.__vorsprung } })

  // Ruling R53: ein frisch geladenes Formular-Token ist dem Server zu jung (formMinSekunden): das Widget wartet, statt eine Buchung
  // abzusenden, die der Server mit der normalen Erfolgsantwort verwirft
  const MIN_SEKUNDEN = 3
  const mitVorsprung = () => { const echt = performance.now.bind(performance); window.__vorsprung = 0; performance.now = () => echt() + window.__vorsprung }
  await check('formular_token_nach_neuladen_wartet_und_bucht', async (page) => {
    srv.config.termine.formMinSekunden = MIN_SEKUNDEN
    const konfig = []
    page.on('request', (r) => { if (r.url().includes('/config')) konfig.push(r.url()) })
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = await bisZusammenfassung(page, { tag: '2026-10-26' })
    eq(konfig.length, 1, 'bisher eine Konfiguration')
    // die Konfiguration ist im Widget aelter als 100 Minuten: sende() laedt sie neu und das Token ist beim Absenden nur Millisekunden alt
    await page.evaluate(() => { window.__vorsprung = 101 * 60 * 1000 })
    await wd.locator('input[name=storno]').check()
    const knopf = wd.getByRole('button', { name: 'Zahlungspflichtig buchen' })
    const start = Date.now()
    await knopf.click()
    await wd.getByRole('button', { name: 'Einen Moment …' }).waitFor()
    eq(konfig.length, 2, 'Konfiguration neu geladen')
    eq(await wd.getByRole('button', { name: 'Einen Moment …' }).isDisabled(), true, 'Knopf bleibt gesperrt')
    eq(srv.buchungen().length, 0, 'waehrend des Wartens noch nichts gesendet')
    await wd.getByRole('heading', { name: 'Fast geschafft' }).waitFor()
    const dauer = Date.now() - start
    assert(dauer >= (MIN_SEKUNDEN + 0.4) * 1000, `das Widget wartete nur ${dauer} ms`)
    await srv.warteAufVersand()
    eq(srv.buchungen().map((b) => [b.gastEmail, b.status]), [['max@example.com', 'gehalten']], 'die Buchung wurde wirklich angelegt (kein stilles 201)')
    eq(srv.mails().map((m) => m.to.map((t) => t.address).join()), ['max@example.com'], 'G01 an den Gast')
  }, { initScript: mitVorsprung })

  await check('formular_token_neu_laden_und_gleich_nochmal_bucht', async (page) => {
    srv.config.termine.formMinSekunden = MIN_SEKUNDEN
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = await bisZusammenfassung(page, { tag: '2026-10-26' })
    await wd.locator('input[name=storno]').check()
    srv.schiebeUhr(3 * 60 * 60 * 1000) // beim Server ist das Token jetzt aelter als 2 Stunden
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    await wd.locator('.wkt-meldung').waitFor()
    eq(await wd.locator('.wkt-meldung').innerText(), 'Das Formular wurde erneuert. Bitte versuchen Sie es noch einmal.', 'Hinweis nach neu_laden')
    eq(srv.buchungen().length, 0, 'noch nichts gebucht')
    // sofort noch einmal: das neue Token ist erst Sekundenbruchteile alt
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    await wd.getByRole('button', { name: 'Einen Moment …' }).waitFor()
    await wd.getByRole('heading', { name: 'Fast geschafft' }).waitFor()
    await srv.warteAufVersand()
    eq(srv.buchungen().length, 1, 'zweiter Versuch bucht trotz junger Token')
    eq(srv.mails().map((m) => m.to.map((t) => t.address).join()), ['max@example.com'], 'G01 an den Gast')
  })

  await check('formular_token_wartezeit_zurueck_bricht_ab', async (page) => {
    srv.config.termine.formMinSekunden = MIN_SEKUNDEN
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = await bisZusammenfassung(page, { tag: '2026-10-26' })
    await wd.locator('input[name=storno]').check()
    await page.evaluate(() => { window.__vorsprung = 101 * 60 * 1000 })
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    await wd.getByRole('button', { name: 'Einen Moment …' }).waitFor()
    await wd.getByRole('button', { name: 'Zurück' }).click() // der Gast geht waehrend des Wartens einen Schritt zurueck
    await warteTitel(wd, 'Ihre Angaben')
    await page.waitForTimeout((MIN_SEKUNDEN + 1.2) * 1000)
    eq(srv.buchungen().length, 0, 'es wird nichts mehr gesendet, wenn die Ansicht gewechselt hat')
    eq(await titel(wd).innerText(), 'Ihre Angaben', 'die Ansicht bleibt, wo der Gast ist')
  }, { initScript: mitVorsprung })

  // ---------------------------------------------------------------- 10. Widerruf ohne Link

  await check('vertrag_widerrufen_im_fuss', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = w(page)
    await karte(wd, 'Herrenschnitt').waitFor()
    eq((await wd.locator('.wkt-fuss').innerText()).replace(/\s+/g, ' '), 'Vertrag widerrufen Datenschutz Terminbuchung über WEBklar', 'Fuss')
    // Ruling R54: ein zweiter Knopf (wkt-btn wkt-btn-sek), kein Textlink; mindestens 44 px hoch
    const fussKnopf = wd.locator('.wkt-fuss button')
    eq(await fussKnopf.getAttribute('class'), 'wkt-btn wkt-btn-sek', 'Klassen des Widerrufsknopfs')
    const fussBox = await fussKnopf.boundingBox()
    assert(fussBox.height >= 44, `Widerrufsknopf im Fuss mindestens 44 px hoch: ${fussBox.height}`)
    eq(await fussKnopf.evaluate((b) => getComputedStyle(b).textDecorationLine), 'none', 'kein unterstrichener Textlink')
    const ds = wd.locator('.wkt-fuss a')
    eq([await ds.getAttribute('href'), await ds.getAttribute('rel'), await ds.getAttribute('target')], ['https://salon-mueller.example/datenschutz', 'noopener noreferrer', '_blank'], 'Datenschutz-Link')
    await wd.getByRole('button', { name: 'Vertrag widerrufen' }).click()
    await warteTitel(wd, 'Vertrag widerrufen')
    await wd.getByRole('button', { name: 'Widerruf bestätigen' }).click() // leer: Fehler
    eq(await wd.locator('input[name=name]').getAttribute('aria-invalid'), 'true', 'Name Pflicht')
    await wd.locator('input[name=name]').fill('Gerda Gast')
    await wd.locator('input[name=email]').fill('gerda@example.com')
    await wd.locator('input[name=nummer]').fill('ABCD1234')
    await shot(page, 'widerruf')
    await wd.getByRole('button', { name: 'Widerruf bestätigen' }).click()
    await wd.locator('.wkt-ergebnis-text').waitFor()
    eq(await wd.locator('.wkt-ergebnis-text').innerText(), 'Ihre Erklärung ist eingegangen.', 'Eingangsmeldung')
    assert(/Eingang: \d{2}\.\d{2}\.\d{4}, \d{2}:\d{2} Uhr/.test(await wd.innerText()), 'Datum und Uhrzeit des Eingangs')
    await srv.warteAufVersand()
    const an = srv.mails().map((m) => m.to.map((t) => t.address).join())
    assert(an.includes('gerda@example.com'), `Eingangsbestaetigung (G08) fehlt: ${an}`)
    assert(an.includes('info@salon-mueller.example'), `Weiterleitung an den Betrieb (K21) fehlt: ${an}`)
    await wd.getByRole('button', { name: 'Zurück zur Terminbuchung' }).click()
    await karte(wd, 'Herrenschnitt').waitFor()
  })

  // Ruling R55: auch ein Betrieb mit nur Anfrage-Leistungen (Privatpersonen) zeigt Belehrung und Widerrufsfunktion
  await check('nur_anfragen_zeigen_belehrung_und_widerruf', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = w(page)
    await karte(wd, 'Brautfrisur').waitFor()
    eq(await wd.locator('.wkt-karte').count(), 1, 'nur die Anfrage-Leistung')
    eq((await wd.locator('.wkt-fuss').innerText()).replace(/\s+/g, ' '), 'Vertrag widerrufen Datenschutz Terminbuchung über WEBklar', 'Fuss mit Widerruf')
    await bisZusammenfassung(page, { leistung: 'Brautfrisur', tag: '2026-10-26' })
    await wd.locator('details.wkt-belehrung').waitFor()
    assert((await wd.locator('details.wkt-belehrung').innerText()).includes('Widerrufsbelehrung'), 'Belehrung vor dem Absenden')
    eq(await wd.locator('input[name=storno]').count(), 0, 'Anfrage ohne Preis: kein Storno-Haken (F11)')
    await hakenUndBuchen(wd, 'Termin anfragen')
    await srv.warteAufVersand()
    const buchungen = srv.buchungen()
    eq(buchungen.map((b) => [b.buchungsart, b.verbraucher]), [['anfrage', true]], 'Anfrage von einer Privatperson')
    assert(/^[0-9a-f]{64}$/.test(JSON.parse(buchungen[0].nachweis).widerruf?.hash || ''), 'Nachweis haelt die gezeigte Belehrung fest')
  }, { eingabe: (() => { const e = salonEingabe(); e.leistungen = e.leistungen.filter((l) => l.buchungsart === 'anfrage'); return e })() })

  // Telefonnummer im Ausfalltext: Nummer wird zum Link, freier Text bleibt Text (kein Link auf eine falsche Nummer)
  const ausfallOeffnen = async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = w(page)
    await karte(wd, 'Herrenschnitt').click()
    await karte(wd, 'Egal').click()
    await wd.locator('td.wkt-tag').first().waitFor()
    await page.route(API, (route) => route.abort())
    await tag(wd, '2026-10-12').click()
    await wd.locator('.wkt-ausfall').waitFor()
    return wd.locator('.wkt-ausfall')
  }
  const mitTelefon = (telefon) => { const e = salonEingabe(); e.betrieb.telefon = telefon; return e }
  await check('ausfall_telefon_freitext_bleibt_text', async (page) => {
    const meldung = await ausfallOeffnen(page)
    eq(await meldung.innerText(), 'Gerade nicht erreichbar. Bitte rufen Sie an: 06301 1234 (ab 9 Uhr)', 'Text mit Nummer und Zusatz')
    eq(await meldung.locator('a').count(), 0, 'kein tel:-Link fuer freien Text')
  }, { eingabe: mitTelefon('06301 1234 (ab 9 Uhr)') })
  await check('ausfall_telefon_landesvorwahl_ohne_null', async (page) => {
    const meldung = await ausfallOeffnen(page)
    eq(await meldung.locator('a').getAttribute('href'), 'tel:+4963011234', '(0) hinter der Landesvorwahl entfaellt')
    eq(await meldung.locator('a').innerText(), '+49 (0) 6301-1234', 'angezeigt wird, was der Betrieb eingetragen hat')
  }, { eingabe: mitTelefon('+49 (0) 6301-1234') })

  // ---------------------------------------------------------------- 11. Stile der Seite

  await check('seitenstile_und_betriebsfarbe', async (page, ctx) => {
    const leer = await ctx.newPage()
    await oeffne(leer, seitenHtml(eingebettet('data-modus="inline" data-leistung="' + S_HERREN + '"')), 'standard.html')
    const wdL = w(leer)
    await karte(wdL, 'Egal').click()
    await wdL.locator('td.wkt-tag[aria-disabled="false"]').first().waitFor()
    const standard = await wdL.locator('td.wkt-tag[aria-disabled="false"]').first().evaluate((e) => getComputedStyle(e).borderTopColor)
    eq(standard, 'rgb(15, 118, 110)', 'ohne Variable gilt die Betriebsfarbe als Akzent')
    await leer.close()

    const eigen = 'style="--wkt-akzent:rgb(10, 20, 30);--wkt-akzent-text:rgb(250, 250, 250);--wkt-radius:2px"'
    await oeffne(page, seitenHtml(eingebettet(`data-modus="inline" data-leistung="${S_HERREN}" ${eigen}`), { style: '.wkt-titel{color:rgb(1, 2, 3)}' }))
    const wd = w(page)
    await karte(wd, 'Egal').click()
    await wd.locator('td.wkt-tag[aria-disabled="false"]').first().waitFor()
    const werte = await page.evaluate(() => ({
      akzent: getComputedStyle(document.querySelector('td.wkt-tag[aria-disabled="false"]')).borderTopColor,
      radius: getComputedStyle(document.querySelector('.wkt-pfeil')).borderTopLeftRadius,
      titel: getComputedStyle(document.querySelector('.wkt-titel')).color,
    }))
    eq(werte.akzent, 'rgb(10, 20, 30)', 'CSS-Variable --wkt-akzent der Seite gewinnt')
    eq(werte.radius, '2px', 'CSS-Variable --wkt-radius der Seite gewinnt')
    eq(werte.titel, 'rgb(1, 2, 3)', 'Regel der Seite (ohne Layer) schlaegt @layer wkt')
    await tag(wd, '2026-10-12').click()
    await zeit(wd, '10:00').click()
    await wd.locator('input[name=name]').fill('Max Mustermann')
    await wd.locator('input[name=email]').fill('max@example.com')
    await wd.getByRole('button', { name: 'Weiter' }).click()
    await wd.locator('.wkt-zusammen').waitFor()
    const knopfFarbe = await wd.locator('.wkt-form button[type=submit]').evaluate((b) => [getComputedStyle(b).backgroundColor, getComputedStyle(b).color])
    eq(knopfFarbe, ['rgb(10, 20, 30)', 'rgb(250, 250, 250)'], 'Akzent und Akzent-Text am Knopf')
  })

  // ---------------------------------------------------------------- 12. Fehler und Ausweichtext

  await check('ohne_javascript_bleibt_ausweichtext', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    assert(await page.locator('#ausweich').isVisible(), 'Ausweichtext fehlt')
  }, { context: { javaScriptEnabled: false } })

  await check('funktion_aus_oder_unbekannt_ausweichtext', async (page) => {
    await srv.setzeFunktion('disabled')
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"') + eingebettet('data-modus="knopf" data-knopf="Termin buchen"', '<p id="ausweich-knopf">Termine telefonisch unter 06301 1234.</p>') + eingebettet('data-modus="inline"', '<p id="ausweich-unbekannt">Unbekannter Schluessel</p>', 'zzzzzzzzzzzzzzzz')))
    await page.waitForLoadState('networkidle')
    await page.waitForTimeout(300)
    assert(await page.locator('#ausweich').isVisible(), 'Ausweichtext (Funktion aus) fehlt')
    assert(await page.locator('#ausweich-unbekannt').isVisible(), 'Ausweichtext (unbekannter Schluessel) fehlt')
    eq(await page.locator('[data-modus="inline"].wkt-root').count(), 0, 'kein Widget (inline) bei abgeschalteter Funktion')
    eq(await page.locator('#wkt-style').count(), 1, 'nur der Knopf bringt Stile mit (inline: keine)')
    // Knopf: erst beim Klick bemerkt das Widget, dass nichts buchbar ist; im Dialog steht der Ausweichtext
    await page.getByRole('button', { name: 'Termin buchen' }).click()
    const dlg = page.locator('dialog.wkt-dialog')
    await dlg.locator('#ausweich-knopf').waitFor()
    assert(await dlg.locator('#ausweich-knopf').isVisible(), 'Ausweichtext im Dialog')
    eq(await dlg.locator('.wkt-karte').count(), 0, 'keine Leistungen')
    await shot(page, 'fehler-funktion-aus')
  })

  await check('netzfehler_mitten_in_der_strecke', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = w(page)
    await karte(wd, 'Herrenschnitt').click()
    await karte(wd, 'Egal').click()
    await wd.locator('td.wkt-tag').first().waitFor()
    await page.route(API, (route) => route.abort())
    await tag(wd, '2026-10-12').click()
    const meldung = wd.locator('.wkt-ausfall')
    await meldung.waitFor()
    eq(await meldung.innerText(), 'Gerade nicht erreichbar. Bitte rufen Sie an: 06301 1234', 'Ausfalltext mit Telefonnummer')
    eq(await meldung.locator('a').getAttribute('href'), 'tel:063011234', 'Telefonlink')
    assert(await wd.locator('.wkt-fuss').isVisible(), 'Fuss bleibt')
    await shot(page, 'fehler-nicht-erreichbar')
    await page.unroute(API)
    await wd.getByRole('button', { name: 'Erneut versuchen' }).click()
    await wd.locator('td.wkt-tag').first().waitFor()
    await tag(wd, '2026-10-12').click()
    await wd.locator('.wkt-zeit').first().waitFor()
  })

  await check('keine_fremden_anfragen_keine_cookies', async (page, ctx) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    await bisZusammenfassung(page, { tag: '2026-10-26' })
    eq((await ctx.cookies()).length, 0, 'Cookies')
    const erlaubt = new Set([new URL(srv.url).host, new URL(SEITE).host])
    const fremd = [...hosts].filter((h) => !erlaubt.has(h))
    eq(fremd, [], 'Anfragen an fremde Hosts')
  })


  // ---------------------------------------------------------------- 13. Nachbesserungen (Fix-Runde 1)

  const ACAO = { 'access-control-allow-origin': '*' }
  const TEXT_429 = 'Zu viele Anfragen. Bitte versuchen Sie es später noch einmal.'
  const json = (route, status, body) => route.fulfill({ status, contentType: 'application/json', headers: ACAO, body: JSON.stringify(body) })

  await check('grenze_429_keine_schleife', async (page) => {
    // lesend (Tage): Meldung und Knopf, kein neuer Abruf von selbst
    let tage = 0
    await page.route(/\/tage\?/, (route) => { tage += 1; return json(route, 429, { fehler: { _: TEXT_429 } }) })
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = w(page)
    await karte(wd, 'Herrenschnitt').click()
    await karte(wd, 'Egal').click()
    const meldung = wd.locator('.wkt-ausfall')
    await meldung.waitFor()
    await page.waitForTimeout(1500)
    assert(tage >= 1 && tage <= 2, `bei 429 darf es hoechstens 2 Abrufe von /tage geben, es waren ${tage}`)
    eq(await meldung.innerText(), TEXT_429, 'Meldung der Grenze')
    assert(await wd.getByRole('button', { name: 'Erneut versuchen' }).isVisible(), 'Knopf "Erneut versuchen" fehlt')
    await shot(page, 'fehler-429-lesen')
    await page.unroute(/\/tage\?/)
    await wd.getByRole('button', { name: 'Erneut versuchen' }).click()
    await wd.locator('td.wkt-tag').first().waitFor()

    // schreibend (Buchung): die Zusammenfassung bleibt mit der Meldung stehen
    await tag(wd, '2026-10-26').click()
    await zeit(wd, '10:00').click()
    await wd.locator('input[name=name]').fill('Max Mustermann')
    await wd.locator('input[name=email]').fill('max@example.com')
    await wd.getByRole('button', { name: 'Weiter' }).click()
    await wd.locator('.wkt-zusammen').waitFor()
    await wd.locator('input[name=storno]').check()
    let buchungen = 0
    await page.route(/\/buchungen$/, (route) => { buchungen += 1; return json(route, 429, { fehler: { _: TEXT_429 } }) })
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    await wd.locator('.wkt-fehlerbox .wkt-fehlertext').waitFor()
    await page.waitForTimeout(800)
    eq(await wd.locator('.wkt-fehlerbox .wkt-fehlertext').innerText(), TEXT_429, 'Meldung in der Zusammenfassung')
    eq(await titel(wd).innerText(), 'Bitte prüfen Sie Ihre Buchung', 'bleibt in der Zusammenfassung')
    eq(buchungen, 1, 'genau ein Versuch')
    assert(await wd.locator('input[name=storno]').isChecked(), 'Haken bleibt')
    await page.unroute(/\/buchungen$/)

    // Widerrufsformular (auch eine 429 ohne Text): bleibt in der Widerrufsansicht
    let widerrufe = 0
    await page.route(/\/widerruf$/, (route) => { widerrufe += 1; return json(route, 429, {}) })
    await wd.getByRole('button', { name: 'Vertrag widerrufen' }).click()
    await warteTitel(wd, 'Vertrag widerrufen')
    await wd.locator('input[name=name]').fill('Gerda Gast')
    await wd.locator('input[name=email]').fill('gerda@example.com')
    await wd.getByRole('button', { name: 'Widerruf bestätigen' }).click()
    await wd.locator('.wkt-fehlerbox .wkt-fehlertext').waitFor()
    await page.waitForTimeout(800)
    eq(await wd.locator('.wkt-fehlerbox .wkt-fehlertext').innerText(), TEXT_429, 'Meldung im Widerrufsformular')
    eq(await titel(wd).innerText(), 'Vertrag widerrufen', 'bleibt in der Widerrufsansicht')
    eq(widerrufe, 1, 'genau ein Versuch')
    assert(await wd.getByRole('button', { name: 'Widerruf bestätigen' }).isEnabled(), 'Knopf wieder frei')
    assert(await wd.locator('input[name=name]').inputValue() === 'Gerda Gast', 'Eingaben bleiben')
    await shot(page, 'fehler-429-widerruf')
    await wd.getByRole('button', { name: 'Zurück zur Terminbuchung' }).click()
    await wd.locator('.wkt-zusammen').waitFor()
  })

  await check('betriebsfarbe_orange_schrift_lesbar', async (page) => {
    await oeffne(page, seitenHtml(eingebettet(`data-modus="inline" data-leistung="${S_HERREN}"`)))
    const wd = await bisZusammenfassung(page, { leistung: null, tag: '2026-10-26' })
    const farben = await wd.locator('.wkt-form button[type=submit]').evaluate((b) => [getComputedStyle(b).backgroundColor, getComputedStyle(b).color])
    eq(farben, ['rgb(234, 88, 12)', 'rgb(17, 24, 39)'], 'Orange bekommt dunkle Schrift (Weiss waere nur 3,6 : 1)')
    await shot(page, 'orange-pruefen')
  }, { eingabe: salonEingabe({ farbe: '#ea580c' }) })

  await check('haken_beginnen_bei_aenderung_ohne_haken', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = await bisZusammenfassung(page, { leistung: 'Herrenschnitt', tag: '2026-10-12', zeit: '10:00' })
    const haken = () => wd.locator('.wkt-haken input').evaluateAll((l) => l.map((i) => i.name + ':' + i.checked))
    const alleAn = async () => { for (const n of ['storno', 'vorzeitig', 'erinnerung']) await wd.locator(`input[name=${n}]`).check() }
    const zurueck = async (n) => { for (let i = 0; i < n; i += 1) await wd.getByRole('button', { name: 'Zurück' }).click() }
    const weiterBisZusammenfassung = async () => { await wd.getByRole('button', { name: 'Weiter' }).click(); await wd.locator('.wkt-zusammen').waitFor() }
    await alleAn()
    eq(await haken(), ['storno:true', 'vorzeitig:true', 'erinnerung:true'], 'alle drei angekreuzt')
    // dieselbe Uhrzeit noch einmal gewaehlt: nichts hat sich geaendert, die Haken bleiben
    await zurueck(2)
    await wd.locator('.wkt-zeit').first().waitFor()
    await zeit(wd, '10:00').click()
    await warteTitel(wd, 'Ihre Angaben')
    await weiterBisZusammenfassung()
    eq(await haken(), ['storno:true', 'vorzeitig:true', 'erinnerung:true'], 'gleiche Uhrzeit: Haken bleiben')
    // andere Uhrzeit
    await zurueck(2)
    await wd.locator('.wkt-zeit').first().waitFor()
    await zeit(wd, '10:15').click()
    await warteTitel(wd, 'Ihre Angaben')
    await weiterBisZusammenfassung()
    eq(await haken(), ['storno:false', 'vorzeitig:false', 'erinnerung:false'], 'andere Uhrzeit: ohne Haken')
    // anderer Tag
    await alleAn()
    await zurueck(2)
    await tag(wd, '2026-10-13').click()
    await zeit(wd, '10:15').click()
    await warteTitel(wd, 'Ihre Angaben')
    await weiterBisZusammenfassung()
    eq(await haken(), ['storno:false', 'vorzeitig:false', 'erinnerung:false'], 'anderer Tag: ohne Haken')
    // andere Leistung
    await alleAn()
    await zurueck(4)
    await warteTitel(wd, 'Welche Leistung')
    await karte(wd, 'Kinderschnitt').click()
    await karte(wd, 'Egal').click()
    await tag(wd, '2026-10-13').click()
    await zeit(wd, '10:15').click()
    await warteTitel(wd, 'Ihre Angaben')
    await weiterBisZusammenfassung()
    eq(await haken(), ['storno:false', 'vorzeitig:false', 'erinnerung:false'], 'andere Leistung: ohne Haken')
  })

  await check('fehler_ohne_feld_nicht_verschluckt', async (page) => {
    let fehler = {}
    await page.route(/\/buchungen$/, (route) => json(route, 400, { fehler }))
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = await bisZusammenfassung(page, { leistung: 'Herrenschnitt', tag: '2026-10-26' })
    await wd.locator('input[name=storno]').check()
    eq(await wd.locator('input[name=vorzeitig]').count(), 0, 'Voraussetzung: der Haken wird nicht gezeigt')
    // 1) Schluessel ohne Feld in der Zusammenfassung: Fehlerkasten
    fehler = { vorzeitig: 'Bitte der Leistung vor Ablauf der Widerrufsfrist ausdrücklich zustimmen, sonst ist die Buchung nicht möglich.', irgendwas: 'Unbekannter Fehler vom Server.' }
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    await wd.locator('.wkt-fehlerbox .wkt-fehlertext').first().waitFor()
    eq(await wd.locator('.wkt-fehlerbox .wkt-fehlertext').allInnerTexts(), Object.values(fehler), 'beide Meldungen sichtbar')
    eq(await titel(wd).innerText(), 'Bitte prüfen Sie Ihre Buchung', 'bleibt in der Zusammenfassung')
    // 2) Feld im Schritt "Angaben" plus Schluessel ohne Feld
    fehler = { name: 'Bitte einen Namen angeben.', foo: 'Weitere Meldung.' }
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    await warteTitel(wd, 'Ihre Angaben')
    eq(await wd.locator('input[name=name]').getAttribute('aria-invalid'), 'true', 'Namensfeld markiert')
    eq(await wd.locator('.wkt-fehlerbox .wkt-fehlertext').allInnerTexts(), ['Weitere Meldung.'], 'Meldung ohne Feld im Kasten')
    // 3) Leistung: der Leistungsschritt zeigt die Meldung
    await wd.getByRole('button', { name: 'Weiter' }).click()
    await wd.locator('.wkt-zusammen').waitFor()
    fehler = { leistung: 'Bitte eine Leistung auswählen.' }
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    await warteTitel(wd, 'Welche Leistung')
    eq(await wd.locator('.wkt-fehlerbox .wkt-fehlertext').allInnerTexts(), ['Bitte eine Leistung auswählen.'], 'Meldung im Leistungsschritt')
  })

  await check('angebot_geaendert_beginnt_von_vorn', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = await bisZusammenfassung(page, { leistung: 'Damenschnitt', tag: '2026-10-26' })
    await wd.locator('input[name=storno]').check()
    // der Betrieb nimmt die Leistung heraus; das Formular-Token ist inzwischen abgelaufen (neu_laden)
    const eingabe = salonEingabe()
    eingabe.leistungen = eingabe.leistungen.filter((l) => l.id !== S_DAMEN)
    await srv.speichere(eingabe)
    srv.schiebeUhr(3 * 60 * 60 * 1000)
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    await wd.locator('.wkt-meldung').waitFor()
    eq(await wd.locator('.wkt-meldung').innerText(), 'Das Angebot hat sich geändert. Bitte wählen Sie neu.', 'Hinweis')
    eq(await titel(wd).innerText(), 'Welche Leistung möchten Sie buchen?', 'zurueck zur Leistungswahl')
    eq(await karte(wd, 'Damenschnitt').count(), 0, 'die entfernte Leistung ist weg')
    eq(srv.buchungen().length, 0, 'nichts gebucht')
  })

  await check('konfiguration_unvollstaendig_ausweichtext', async (page, ctx) => {
    const varianten = {
      'Leistung ohne Knopftext': (j) => { delete j.leistungen[0].knopf },
      'ohne Text fuer den Storno-Haken': (j) => { delete j.texte.storno },
      'ohne Text fuer den Haken vorzeitiger Beginn': (j) => { delete j.texte.vorzeitig },
      'Widerruf ohne Belehrung': (j) => { delete j.texte.widerrufsbelehrung },
      'ohne Formular-Token': (j) => { delete j.formToken },
    }
    for (const [name, aendere] of [['unveraendert', () => {}], ...Object.entries(varianten)]) {
      const p = await ctx.newPage()
      p.setDefaultTimeout(8000)
      await p.route(/\/config$/, async (route) => {
        const antwort = await route.fetch()
        const daten = await antwort.json()
        aendere(daten)
        await route.fulfill({ response: antwort, json: daten })
      })
      await p.goto(srv.seite('unvollstaendig.html', seitenHtml(eingebettet('data-modus="inline"'))))
      if (name === 'unveraendert') {
        await karte(w(p), 'Herrenschnitt').waitFor()
      } else {
        await p.waitForLoadState('networkidle')
        await p.waitForTimeout(300)
        assert(await p.locator('#ausweich').isVisible(), `${name}: Ausweichtext muss stehen`)
        eq(await p.locator('.wkt-root').count(), 0, `${name}: kein Widget`)
      }
      await p.close()
    }
  })

  await check('render_fehler_zeigt_ausweichtext_wieder', async (page) => {
    // Der Aufbau der Leistungsliste scheitert (<ul> laesst sich nicht erzeugen), nachdem der Ausweichtext schon beiseite ist
    const kaputt = await page.context().newPage()
    await kaputt.addInitScript(() => {
      const echt = document.createElement.bind(document)
      document.createElement = (tag, opt) => { if (String(tag).toLowerCase() === 'ul') throw new Error('Test: Aufbau scheitert'); return echt(tag, opt) }
    })
    const fehler = []
    kaputt.on('pageerror', (e) => fehler.push(e.message))
    await kaputt.goto(srv.seite('kaputt.html', seitenHtml(eingebettet('data-modus="inline"'))))
    await kaputt.waitForLoadState('networkidle')
    await kaputt.waitForTimeout(500)
    assert(await kaputt.locator('#ausweich').isVisible(), 'Ausweichtext muss nach dem Fehler wieder da sein')
    eq(await kaputt.locator('.wkt-root').count(), 0, 'kein halbes Widget')
    eq(fehler, [], 'der Fehler wird abgefangen')
    await kaputt.close()
  })

  await check('monatspfeil_behaelt_fokus', async (page) => {
    await oeffne(page, seitenHtml(eingebettet(`data-modus="inline" data-leistung="${S_HERREN}"`)))
    const wd = w(page)
    await karte(wd, 'Egal').click()
    await wd.locator('td.wkt-tag').first().waitFor()
    const vor = wd.getByRole('button', { name: 'Nächster Monat' })
    const zur = wd.getByRole('button', { name: 'Vorheriger Monat' })
    const fokus = () => page.evaluate(() => { const a = document.activeElement; return { body: a === document.body, label: a.getAttribute('aria-label') || '', imWidget: !!a.closest('[data-webklar-termine]') } })
    const klickeBisGesperrt = async (knopf) => {
      for (let i = 0; i < 8 && await knopf.isEnabled(); i += 1) {
        const vorher = await wd.locator('.wkt-monat').innerText()
        await knopf.click()
        await page.waitForFunction((v) => document.querySelector('.wkt-monat').textContent !== v, vorher)
      }
      assert(await knopf.isDisabled(), 'Pfeil wurde nie gesperrt')
    }
    await klickeBisGesperrt(vor)
    eq(await fokus(), { body: false, label: 'Vorheriger Monat', imWidget: true }, 'Fokus nach dem gesperrten "Naechster Monat" beim anderen Pfeil')
    await klickeBisGesperrt(zur)
    eq(await fokus(), { body: false, label: 'Nächster Monat', imWidget: true }, 'Fokus nach dem gesperrten "Vorheriger Monat" beim anderen Pfeil')
  })

  // ---------------------------------------------------------------- 14. Fix-Runde 2: veraltetes Angebot, Aufbaufehler im Knopfmodus

  // Die Auswahl wird gewaehlt, der Betrieb aendert das Angebot, dann antwortet der Server auf /tage mit 400 (leistung/ressource):
  // das Widget muss frisch laden und von vorn beginnen (Hinweis, neue Liste), nicht "Gerade nicht erreichbar" zeigen.
  const veraltetVorTage = (wahl) => async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = w(page)
    let freigeben = null
    const tor = new Promise((resolve) => { freigeben = resolve })
    await page.route(/\/tage\?/, async (route) => { await tor; await route.continue() })
    await karte(wd, 'Damenschnitt').click()
    await warteTitel(wd, 'Bei wem')
    const eingabe = salonEingabe()
    if (wahl === 'leistung') {
      eingabe.leistungen = eingabe.leistungen.filter((l) => l.id !== S_DAMEN)
      await karte(wd, 'Egal').click() // /tage ist unterwegs und wird festgehalten ...
    } else {
      eingabe.ressourcen = eingabe.ressourcen.map((r) => (r.id === R_ANNA ? { ...r, aktiv: false } : r))
      await karte(wd, 'Anna').click()
    }
    await srv.speichere(eingabe) // ... der Betrieb aendert das Angebot ...
    freigeben() // ... und der Abruf erreicht den Server erst jetzt
    await wd.locator('.wkt-meldung').waitFor()
    eq(await wd.locator('.wkt-meldung').innerText(), 'Das Angebot hat sich geändert. Bitte wählen Sie neu.', 'Hinweis')
    eq(await titel(wd).innerText(), 'Welche Leistung möchten Sie buchen?', 'Neubeginn bei der Leistungswahl')
    eq(await wd.locator('.wkt-ausfall').count(), 0, 'kein "Gerade nicht erreichbar"')
    eq(await karte(wd, 'Herrenschnitt').count(), 1, 'frische Liste')
    if (wahl === 'leistung') {
      eq(await karte(wd, 'Damenschnitt').count(), 0, 'entfernte Leistung nicht mehr in der Liste')
    } else {
      // mit Anna ausser Betrieb bleibt nur Ben: kein Personenschritt mehr, die Strecke geht gleich zum Termin
      await karte(wd, 'Damenschnitt').click()
      await warteTitel(wd, 'Wann passt es Ihnen?')
      eq(await wd.locator('.wkt-pfad').innerText(), 'Schritt 2 von 4', 'ohne Personenschritt')
      await wd.locator('td.wkt-tag[aria-disabled="false"]').first().waitFor()
    }
    await shot(page, `angebot-geaendert-${wahl}`)
  }
  await check('angebot_geaendert_leistung_vor_tage', veraltetVorTage('leistung'))
  await check('angebot_geaendert_person_vor_tage', veraltetVorTage('person'))

  await check('angebot_geaendert_400_beim_absenden', async (page) => {
    await oeffne(page, seitenHtml(eingebettet('data-modus="inline"')))
    const wd = await bisZusammenfassung(page, { leistung: 'Damenschnitt', tag: '2026-10-26' })
    await wd.locator('input[name=storno]').check()
    const eingabe = salonEingabe()
    eingabe.leistungen = eingabe.leistungen.filter((l) => l.id !== S_DAMEN)
    await srv.speichere(eingabe) // das Token ist noch gueltig: der Server antwortet mit 400 fuer die Leistung, nicht mit neu_laden
    await wd.getByRole('button', { name: 'Zahlungspflichtig buchen' }).click()
    await wd.locator('.wkt-meldung').waitFor()
    eq(await wd.locator('.wkt-meldung').innerText(), 'Das Angebot hat sich geändert. Bitte wählen Sie neu.', 'Hinweis')
    eq(await titel(wd).innerText(), 'Welche Leistung möchten Sie buchen?', 'Neubeginn')
    eq(await karte(wd, 'Damenschnitt').count(), 0, 'entfernte Leistung nicht mehr in der Liste')
    eq(srv.buchungen().length, 0, 'nichts gebucht')
  })

  await check('knopf_render_fehler_zeigt_ausweichtext', async (page) => {
    await page.addInitScript(() => {
      const echt = document.createElement.bind(document)
      document.createElement = (tag, opt) => { if (String(tag).toLowerCase() === 'ul') throw new Error('Test: Aufbau scheitert'); return echt(tag, opt) }
    })
    await oeffne(page, seitenHtml(eingebettet('data-modus="knopf" data-knopf="Termin buchen"')))
    await page.getByRole('button', { name: 'Termin buchen' }).click()
    const dlg = page.locator('dialog.wkt-dialog')
    await dlg.locator('#ausweich').waitFor()
    assert(await dlg.locator('#ausweich').isVisible(), 'Ausweichtext im Dialog')
    assert(!(await dlg.innerText()).includes('Wird geladen'), '"Wird geladen" darf nicht stehen bleiben')
    eq(await dlg.locator('.wkt-karte').count(), 0, 'kein halbes Widget')
  })

  // Zum Schluss: Server gestoppt. Seite und Skript liefert ein eigener kleiner Server, die Schnittstelle ist weg (Verbindung abgelehnt).
  await check('server_gestoppt_ausweichtext', async (page) => {
    const skript = await readFile(WIDGET_JS, 'utf8')
    const seiten = new Map()
    const kleiner = http.createServer((req, res) => {
      const pfad = new URL(req.url, 'http://x').pathname
      if (pfad === '/embed/termine.js') return res.writeHead(200, { 'content-type': 'text/javascript; charset=utf-8' }).end(skript)
      if (seiten.has(pfad)) return res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' }).end(seiten.get(pfad))
      return res.writeHead(404).end()
    })
    await new Promise((resolve) => kleiner.listen(0, '127.0.0.1', resolve))
    const eigen = `http://localhost:${kleiner.address().port}`
    const oeffneEigen = async (html, name) => { seiten.set(`/${name}`, html); await page.goto(`${eigen}/${name}`) }
    await srv.beendeApp()
    try {
      await oeffneEigen(seitenHtml(eingebettet('data-modus="inline"')), 'gestoppt.html')
      await page.waitForLoadState('networkidle')
      await page.waitForTimeout(500)
      assert(await page.locator('#ausweich').isVisible(), 'Ausweichtext fehlt bei gestopptem Server')
      eq(await page.locator('.wkt-root').count(), 0, 'kein halbes Widget')
      eq(await page.locator('#wkt-style').count(), 0, 'keine Stile ohne Widget')
      await shot(page, 'fehler-ausweichtext')
      // Knopfmodus: der Dialog zeigt "Gerade nicht erreichbar." und den Ausweichtext
      await oeffneEigen(seitenHtml(eingebettet('data-modus="knopf" data-knopf="Termin buchen"')), 'gestoppt2.html')
      await page.getByRole('button', { name: 'Termin buchen' }).click()
      const dlg = page.locator('dialog.wkt-dialog')
      await dlg.locator('#ausweich').waitFor()
      assert((await dlg.innerText()).includes('Gerade nicht erreichbar.'), 'Meldung im Dialog')
      await shot(page, 'fehler-ausweichtext-knopf')
    } finally {
      kleiner.closeAllConnections?.()
      await new Promise((resolve) => kleiner.close(resolve))
    }
  })
}

// ---------------------------------------------------------------- Lauf

let abbruch = null
try {
  browser = await chromium.launch()
  await pruefungen()
} catch (e) {
  abbruch = e
  console.log(`ABBRUCH: ${e.stack || e.message}`)
} finally {
  if (browser) await browser.close().catch(() => {})
  await srv.stop().catch((e) => console.log(`Server beenden: ${e.message}`))
}

const fehlgeschlagen = results.filter(([, ok]) => !ok)
console.log(`${results.length - fehlgeschlagen.length}/${results.length} Checks bestanden`)
process.exit(abbruch || fehlgeschlagen.length ? 1 : 0)