// Abnahme der Hustler-Pixelwelt im echten Browser (Chromium, headless shell) gegen den Prüfstand (entry.jsx, die echte Seite WorkersPage).
// Aufruf (immer unter Speicherdeckel, seriell, nie zwei Browser gleichzeitig und nie parallel zur Test-Suite):
//   flock /run/lock/hustler-schwer.lock systemd-run --scope -q -p MemoryMax=1500M -p MemorySwapMax=0 timeout 600 \
//     node --max-old-space-size=600 scripts/workers-harness/shot.cjs <distDir> <outDir>
// <distDir> = Ausgabe von build.mjs, <outDir> = NEUER oder leerer Ordner unter dem Temp-Ordner (TMPDIR, sonst /tmp) oder unter .superpowers/ im Repo.
// Stufen-Sperre (src/lib/hustlerStufe.js): build.mjs baut standardmäßig mit VITE_HUSTLER_STUFE=6 (P4-Aktionen im Pult und Keller offen); alle Szenarien unten setzen das voraus.
// Ein kleiner Server auf 127.0.0.1 liefert distDir und /fonts/* aus public/fonts. Am Ende steht eine JSON-Zeile und `OK`; bei einem Verstoß Exit 1.
// Szenarien (Name für HARNESS_ONLY, Vorsilbe der Bilder):
//   A hochhaus (a-)   Hochhaus am Desktop 1280 x 720 und 1920 x 1080: keine Fehler, nichts läuft über den Rand, 19 Figuren mit aria-label, Kim/Pia/Finn grau, Kopfzeile, Briefkasten
//   B regie (b-)      Regie: innerhalb von 15 s erscheint eine Sprechblase, höchstens vier Effekte gleichzeitig
//   C handy (c-)      Handy 390 x 844 (hochkant) und 844 x 390 (quer): Kopfzeile höchstens zwei Reihen, Wischen verschiebt, Doppeltipp zeigt das ganze Haus, Detail als Vollbild
//   D bewegung (d-)   „Weniger Bewegung“: Schnee und Flackern stehen, kein Gleiten, nur Sprechblasen
//   E notbremse (e-)  ?halted=1: Banner mit Grund, Einstellungen mit dem Notbremse-Block
//   F ausfall (f-)    ?fault=down: Leerzustand „Der Hustler-Dienst ist noch nicht erreichbar“, nach „Neu laden“ das Haus, Verbindungsfehler-Banner
//   G detail (g-)     Detailansicht: Dialog, Blättern mit ←/→, Esc mit Fokus zurück auf die Figur, lange Spur mit ◂ n / 19 ▸, ein Bild je Status
//   H etagen (h-)     Etage zoomen (mit Gleiten), Tasten +/−/0, Etage „Freigabe“ → Pult und zurück, Keller-Etage → Bot-Leads und zurück
//   I pause (i-)      Pause mit Pixel-Rückfrage, Animationen stehen (hk-steht), Fortsetzen ohne Rückfrage
//   J pult (j-)       Pult mit den P3-Daten: Reiter, Umschlag/Brief, Ich kümmere mich, Kopieren & öffnen, Als gesendet markieren, Verwerfen mit Rückfrage, Interessent (WOMS-Aussehen), Fokus
//   K pult-p4 (k-)    Pult mit den P4-Daten (?p4=1): als Mensch antworten, Vorschau freigeben, Antwort des Kunden einfügen, Vorschau bauen
//   L keller (l-)     Keller: Reiter, Suche, Blättern, Akte (Heilberuf ohne Nummer, Quelle als Link), Einzelansicht (?bot=), leer (?botleads=leer), Arne
//   M handy-pult-keller (m-)  Pult und Keller am Handy 390 x 844: volle Breite, Brief und Akte als Vollbild, nichts läuft über den Rand
// Jedes Szenario läuft für sich: bricht eines ab, laufen die übrigen weiter und der Abbruch steht als Verstoß in der Liste. HARNESS_ONLY=detail,pult
// (Namen siehe `SCENARIOS` unten) lässt nur diese laufen (für die Arbeit am Prüfstand; die Abnahme läuft immer vollständig).
'use strict'
const { createRequire } = require('module')
const path = require('path')
const fs = require('fs')
const os = require('os')
const http = require('http')
const req = createRequire('/root/.npm/_npx/db89d7302a373f10/node_modules/')
const { chromium } = req('playwright-core')

const repo = path.resolve(__dirname, '../..')
const distArg = process.argv[2]
const outArg = process.argv[3]
if (!distArg || !outArg) { console.error('usage: node shot.cjs <distDir> <outDir>'); process.exit(2) }
const dist = path.resolve(distArg)
const out = path.resolve(outArg)
const tmp = path.resolve(process.env.TMPDIR || os.tmpdir())
const okBase = [tmp, path.join(repo, '.superpowers')]
if (!okBase.some((b) => out.startsWith(b + path.sep))) { console.error('refusing: outDir must be below ' + okBase.join(' or ')); process.exit(2) }
if (fs.existsSync(out) && fs.readdirSync(out).length > 0) { console.error('refusing: outDir must be new or empty'); process.exit(2) }
if (!fs.existsSync(path.join(dist, 'index.html'))) { console.error('refusing: no index.html in ' + dist); process.exit(2) }
fs.mkdirSync(out, { recursive: true })

const CHROME = '/root/.cache/ms-playwright/chromium_headless_shell-1234/chrome-headless-shell-linux64/chrome-headless-shell'
const FONT_FILES = ['/fonts/PixelifySans-Variable.woff2', '/fonts/PressStart2P-Regular.woff2']
const HALT_LINE = 'Versand gestoppt: Zwei harte Bounces in den letzten 10 Mails. Ein Admin kann ihn in den Einstellungen freigeben.'
const PAUSED_LINE = 'Angehalten: Es wird nichts gesendet und nichts gebaut.'
const HALT_QUESTION = 'Die Worker hören sofort auf, bis jemand fortsetzt.'
const NO_SERVICE = 'Der Hustler-Dienst ist noch nicht erreichbar'

const MIME = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.css': 'text/css; charset=utf-8', '.woff2': 'font/woff2', '.txt': 'text/plain; charset=utf-8' }
const fontLog = []

function serve() {
  const server = http.createServer((rq, rs) => {
    let rel
    try { rel = decodeURIComponent(new URL(rq.url, 'http://x').pathname) } catch { rs.writeHead(400).end(); return }
    const fonts = rel.startsWith('/fonts/')
    const root = fonts ? path.join(repo, 'public', 'fonts') : dist
    const file = path.resolve(root, '.' + (fonts ? rel.slice('/fonts'.length) : (rel === '/' ? '/index.html' : rel)))
    if (rq.method !== 'GET' || !file.startsWith(root + path.sep) || !fs.existsSync(file) || !fs.statSync(file).isFile()) {
      if (fonts) fontLog.push({ url: rel, status: 404 })
      rs.writeHead(404).end('not found')
      return
    }
    if (fonts) fontLog.push({ url: rel, status: 200 })
    rs.writeHead(200, { 'Content-Type': MIME[path.extname(file)] || 'application/octet-stream', 'Cache-Control': 'no-store' })
    fs.createReadStream(file).pipe(rs)
  })
  return new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve(server)))
}

const problems = []
const findings = [] // Befunde: Abweichungen, die an der App liegen (nicht am Prüfstand); sie lassen den Lauf nicht scheitern, stehen aber im Bericht
const errors = []
const checks = {}
const metrics = {}
const shots = []
const perScenario = {} // Name -> { checks, failed }
let current = '' // das laufende Szenario (für die Zählung)
let lastPage = null // die zuletzt geöffnete Seite: bricht ein Szenario ab, wird von hier aus der Zustand im Bild festgehalten (abbruch-<Szenario>.png)
let openContexts = [] // Kontexte des laufenden Szenarios (bei einem Abbruch schließt der Läufer sie)

function check(name, ok, detail) {
  checks[name] = ok ? 'ok' : 'FEHLER' + (detail === undefined ? '' : ' ' + JSON.stringify(detail))
  const entry = perScenario[current] || (perScenario[current] = { checks: 0, failed: 0 })
  entry.checks += 1
  if (!ok) {
    entry.failed += 1
    problems.push(name + (detail === undefined ? '' : ' ' + JSON.stringify(detail)))
  }
}

// Wie check, aber für einen Befund an der App: bei einem Verstoß kein Fehlschlag des Laufs, sondern ein Eintrag unter „befunde“ (JSON-Zeile und Standardfehlerausgabe).
// Wird der Befund in der App behoben, schlägt der Aufruf nie an; dann kann aus befund wieder check werden.
function befund(name, ok, detail) {
  checks[name] = ok ? 'ok' : 'BEFUND' + (detail === undefined ? '' : ' ' + JSON.stringify(detail))
  const entry = perScenario[current] || (perScenario[current] = { checks: 0, failed: 0 })
  entry.checks += 1
  if (!ok) {
    entry.befunde = (entry.befunde || 0) + 1
    findings.push(name + (detail === undefined ? '' : ' ' + JSON.stringify(detail)))
  }
}

const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
const textOf = async (loc) => ((await loc.textContent()) || '').replace(/\s+/g, ' ').trim()
const same = (a, b) => JSON.stringify(a) === JSON.stringify(b)
const escapeRe = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')

async function shoot(page, name, options = {}) {
  const file = path.join(out, name)
  await page.screenshot({ path: file, ...options })
  shots.push(file)
}

// Neuer Kontext mit Fehlersammlung (pageerror, console.error, fehlgeschlagene und 4xx/5xx-Anfragen)
async function newPage(browser, label, contextOptions) {
  const context = await browser.newContext({ deviceScaleFactor: 1, ...contextOptions })
  openContexts.push(context)
  const page = await context.newPage()
  lastPage = page
  page.setDefaultTimeout(20000)
  page.on('pageerror', (e) => errors.push(label + ' pageerror: ' + String(e)))
  page.on('console', (m) => { if (m.type() === 'error') errors.push(label + ' console.error: ' + m.text()) })
  page.on('requestfailed', (r) => errors.push(label + ' requestfailed: ' + r.url()))
  page.on('response', (r) => { if (r.status() >= 400) errors.push(label + ' http ' + r.status() + ': ' + r.url()) })
  return { context, page }
}

// Seite mit ersetzter Zwischenablage und ersetztem window.open (beides vor dem Laden): halten fest, was die Oberfläche tut (window.__clip, __opened, __openMeta).
// Die Zwischenablage antwortet erst nach 300 ms (wie ein Browser, der nach der Erlaubnis fragt): wer vor dem Öffnen auf das Kopieren wartet, öffnet später
// als 300 ms nach dem Klick und verliert die Nutzer-Geste.
async function newStubPage(browser, label, contextOptions) {
  const made = await newPage(browser, label, contextOptions)
  await made.context.addInitScript(() => {
    window.__clip = []
    window.__opened = []
    window.__openMeta = []
    window.__lastClickAt = 0
    document.addEventListener('click', () => { window.__lastClickAt = performance.now() }, true)
    Object.defineProperty(navigator, 'clipboard', {
      configurable: true,
      value: { writeText: (text) => { window.__clip.push(text); return new Promise((resolve) => setTimeout(resolve, 300)) } },
    })
    window.open = (...args) => {
      window.__opened.push(args)
      window.__openMeta.push({ sinceClick: performance.now() - window.__lastClickAt, active: navigator.userActivation ? navigator.userActivation.isActive : null })
      return null
    }
  })
  return made
}

const settleFonts = (page) => page.evaluate(() => Promise.all([
  document.fonts.load('600 12px "Pixelify Sans"'),
  document.fonts.load('12px "Press Start 2P"'),
]).then(() => document.fonts.ready))

// Seite laden und warten, bis das Haus mit allen 19 Figuren steht
async function ready(page, url) {
  await page.goto(url)
  await page.waitForFunction(() => document.querySelectorAll('[data-hk-hustler]').length === 19)
  await settleFonts(page)
}

const apiOf = (page, key) => page.evaluate((k) => JSON.parse(JSON.stringify(window.__wk.api[k])), key)
const setFault = (page, key, value) => page.evaluate(([k, v]) => { window.__wk.api.faults[k] = v }, [key, value])
const widthOf = (page) => page.evaluate(() => ({
  scroll: document.scrollingElement.scrollWidth,
  inner: window.innerWidth,
  body: document.body.scrollWidth,
  root: (() => { const el = document.querySelector('.hk-hochhaus, .hk-pult, .hk-keller'); return el ? { scroll: el.scrollWidth, client: el.clientWidth } : null })(),
}))
const noSideScroll = (w) => w.scroll <= w.inner && w.body <= w.inner && (w.root === null || w.root.scroll <= w.root.client)
const rectOf = (loc) => loc.evaluate((el) => { const b = el.getBoundingClientRect(); return { x: Math.round(b.x), y: Math.round(b.y), w: Math.round(b.width), h: Math.round(b.height), r: Math.round(b.right), b: Math.round(b.bottom) } })
// Kamera der Hochhaus-Welt aus dem Stil der Bühne: transform: translate(x px, y px) scale(s)
const cameraOf = (page) => page.evaluate(() => {
  const el = document.querySelector('.hk-buehne')
  const m = el ? /translate\(([-\d.]+)px, ([-\d.]+)px\) scale\(([\d.]+)\)/.exec(el.style.transform) : null
  return m ? { x: Number(m[1]), y: Number(m[2]), s: Number(m[3]) } : null
})
const focusInfo = (page) => page.evaluate(() => {
  const el = document.activeElement
  if (!el) return { tag: null }
  return {
    tag: el.tagName,
    hustler: el.getAttribute('data-hk-hustler'),
    zeile: el.getAttribute('data-hk-zeile'),
    label: el.getAttribute('aria-label'),
    pause: el.hasAttribute('data-hk-pause'),
    role: el.getAttribute('role'),
    cls: String(el.className || '').slice(0, 60),
    text: (el.textContent || '').replace(/\s+/g, ' ').trim().slice(0, 60),
    inDialog: Boolean(el.closest('[role="dialog"]')),
  }
})

// ---------- Szenario A: Hochhaus am Desktop (1280 x 720 und 1920 x 1080) ----------

async function hochhaus(browser, base) {
  for (const [w, h] of [[1280, 720], [1920, 1080]]) {
    const tag = `${w}x${h}`
    const { context, page } = await newPage(browser, 'hochhaus-' + tag, { viewport: { width: w, height: h } })
    await ready(page, base + '/index.html')
    await sleep(700)
    const m = await page.evaluate(() => {
      const box = (el) => { const b = el.getBoundingClientRect(); return { x: b.x, y: b.y, r: b.right, b: b.bottom, w: b.width, h: b.height } }
      const sicht = box(document.querySelector('.hk-sicht'))
      const inside = (b) => b.x >= sicht.x - 2 && b.y >= sicht.y - 2 && b.r <= sicht.r + 2 && b.b <= sicht.b + 2
      const figuren = [...document.querySelectorAll('[data-hk-hustler]')].map((el) => {
        const b = box(el)
        const sprite = el.firstElementChild
        return { id: el.getAttribute('data-hk-hustler'), tag: el.tagName, type: el.getAttribute('type'), label: el.getAttribute('aria-label') || '', w: Math.round(b.w), h: Math.round(b.h), inside: inside(b), sprite: sprite ? sprite.className : '' }
      })
      const text = (sel) => [...document.querySelectorAll(sel)].map((el) => el.textContent.replace(/\s+/g, ' ').trim())
      return {
        sicht,
        haus: inside(box(document.querySelector('.hk-haus-bild'))),
        kopf: { ...box(document.querySelector('.hk-kopf')), betraege: text('.hk-kopf-betrag'), zahlen: [...document.querySelectorAll('.hk-kopf-zahl')].map((z) => z.lastElementChild.textContent.trim()) },
        figuren,
        grauRaeume: [...document.querySelectorAll('[class*="hk-raum-grau-"]')].map((el) => el.className.replace('hk-raum-grau-', '')).sort(),
        zettel: text('.hk-zettel'),
        briefkasten: text('.hk-briefkasten'),
        tresor: text('.hk-schildtext-tresor'),
        keller: text('.hk-schildtext-keller'),
        meldungen: document.querySelectorAll('.hk-meldung').length,
        dialoge: document.querySelectorAll('[role="dialog"]').length,
        fonts: { pixelify: document.fonts.check('600 12px "Pixelify Sans"'), pressStart: document.fonts.check('12px "Press Start 2P"') },
      }
    })
    const camera = await cameraOf(page)
    metrics['hochhaus ' + tag] = { sicht: { w: Math.round(m.sicht.w), h: Math.round(m.sicht.h) }, zoom: camera && Number(camera.s.toFixed(3)), kopf: { h: Math.round(m.kopf.h) } }

    const wide = await widthOf(page)
    check(`hochhaus ${tag}: kein waagrechtes Scrollen`, noSideScroll(wide), wide)
    check(`hochhaus ${tag}: das ganze Haus steht im Bild`, m.haus, m.sicht)
    check(`hochhaus ${tag}: 19 Figuren-Knöpfe (echte <button>) mit aria-label „Name, Modell, Status“, alle sichtbar im Bild`,
      m.figuren.length === 19 && m.figuren.every((f) => f.tag === 'BUTTON' && f.type === 'button' && /^[^,]+, (Opus|Sonnet|Haiku), .+$/.test(f.label) && f.w >= 8 && f.h >= 8 && f.inside),
      m.figuren.filter((f) => !(f.tag === 'BUTTON' && /^[^,]+, (Opus|Sonnet|Haiku), .+$/.test(f.label) && f.w >= 8 && f.h >= 8 && f.inside)))
    const grey = ['kim', 'pia', 'finn']
    check(`hochhaus ${tag}: Kim, Pia und Finn sind grau (Label „noch nicht angeschlossen“, Figur „nicht“), die übrigen 16 nicht`,
      m.figuren.every((f) => (grey.includes(f.id)
        ? f.label.endsWith('noch nicht angeschlossen') && /-nicht\b/.test(f.sprite)
        : !f.label.includes('noch nicht angeschlossen') && !/-nicht\b/.test(f.sprite))),
      m.figuren.map((f) => [f.id, f.label, f.sprite]))
    check(`hochhaus ${tag}: graue Raum-Ebene für Kleinanzeigen, Portale und Foren (nur diese drei) samt Papierschild „nicht angeschlossen“`,
      same(m.grauRaeume, ['foren', 'kleinanzeigen', 'portale']) && m.zettel.length === 3 && m.zettel.every((t) => t.includes('nicht angeschlossen')), { raeume: m.grauRaeume, zettel: m.zettel })
    check(`hochhaus ${tag}: Kopfzeile mit Werten (+60 €/m, -5,10 $, Kennzahlen 3, 3, 7, 2, 112)`,
      m.kopf.betraege.length === 2 && m.kopf.betraege[0].includes('+60 €/m') && m.kopf.betraege[1].includes('-5,10 $') && same(m.kopf.zahlen, ['3', '3', '7', '2', '112']) && m.kopf.x >= 0 && m.kopf.r <= w, m.kopf)
    check(`hochhaus ${tag}: Briefkasten-Zähler „2“, Tresor „3 Deals“, Keller „112 Bot-Leads“`, same(m.briefkasten, ['2']) && same(m.tresor, ['3 Deals']) && same(m.keller, ['112 Bot-Leads']), { b: m.briefkasten, t: m.tresor, k: m.keller })
    check(`hochhaus ${tag}: ohne Notbremse und Pause keine Meldung, kein Dialog`, m.meldungen === 0 && m.dialoge === 0, { meldungen: m.meldungen, dialoge: m.dialoge })
    check(`hochhaus ${tag}: Schriften Pixelify Sans und Press Start 2P geladen`, m.fonts.pixelify && m.fonts.pressStart, m.fonts)
    await shoot(page, `a-hochhaus-${tag}.png`)
    await context.close()
  }
  const fonts = FONT_FILES.map((f) => ({ f, ok: fontLog.some((e) => e.url === f && e.status === 200) }))
  check('hochhaus: beide Schriftdateien wurden mit 200 geliefert, kein /fonts-Abruf mit 404', fonts.every((x) => x.ok) && !fontLog.some((e) => e.status !== 200), { fonts, log: fontLog.filter((e) => e.status !== 200) })
}

// ---------- Szenario B: Regie (Sprechblasen) ----------

// Effekte der Regie-Ebene: Art (blase | icon | flug | jubel), Text der Blasen, Lage der ersten Blase
const regieOf = (page) => page.evaluate(() => {
  const root = document.querySelector('.hk-regie')
  const kids = root ? [...root.children] : []
  const art = (el) => (['blase', 'icon', 'flug', 'jubel'].find((a) => el.classList.contains('hk-regie-' + a)) || 'andere')
  const blase = kids.find((el) => el.classList.contains('hk-regie-blase'))
  const rect = blase ? blase.getBoundingClientRect() : null
  return {
    root: Boolean(root),
    hidden: root ? root.getAttribute('aria-hidden') : null,
    arten: kids.map(art),
    blasen: kids.filter((el) => el.classList.contains('hk-regie-blase')).map((el) => el.textContent.trim()),
    rect: rect ? { x: Math.round(rect.x), y: Math.round(rect.y), r: Math.round(rect.right), b: Math.round(rect.bottom) } : null,
  }
})

async function regie(browser, base) {
  const { context, page } = await newPage(browser, 'regie', { viewport: { width: 1280, height: 720 } })
  await ready(page, base + '/index.html')
  const t0 = Date.now()
  let first = null
  let firstAt = 0
  let most = 0
  const arten = new Set()
  let viele = false
  while (Date.now() - t0 < 15000 && !(first && Date.now() - firstAt > 5000)) {
    const st = await regieOf(page)
    most = Math.max(most, st.arten.length)
    st.arten.forEach((a) => arten.add(a))
    if (st.blasen.length > 0 && !first) {
      first = st
      firstAt = Date.now()
      metrics.regieErsteBlaseNachMs = firstAt - t0
      await shoot(page, 'b-regie-blase.png')
    } else if (first && !viele && st.arten.length >= 3) {
      viele = true
      await shoot(page, 'b-regie-mehrere-effekte.png')
    }
    await sleep(200)
  }
  check('regie: innerhalb von 15 s erscheint mindestens eine Sprechblase (.hk-regie .hk-regie-blase) mit Text', Boolean(first) && first.blasen.every((t) => t !== ''), { first, arten: [...arten] })
  check('regie: die Blase hat höchstens 20 Zeichen und liegt im Bild', Boolean(first) && first.blasen.every((t) => Array.from(t).length <= 20) && first.rect !== null && first.rect.x >= 0 && first.rect.y >= 0 && first.rect.r <= 1280 && first.rect.b <= 720, first)
  check('regie: höchstens vier Effekte gleichzeitig', most <= 4, most)
  check('regie: die Ebene ist für Bildschirmleser versteckt (aria-hidden) und nimmt keine Klicks an', await page.evaluate(() => { const r = document.querySelector('.hk-regie'); return Boolean(r) && r.getAttribute('aria-hidden') === 'true' && getComputedStyle(r).pointerEvents === 'none' }))
  metrics.regieArten = [...arten]
  await context.close()
}

// ---------- Szenario C: Handy (390 x 844 hochkant, 844 x 390 quer) ----------

// Kopfzeile am Handy: Reihen (verschiedene Oberkanten der Panels), Höhe, Knöpfe, Überlauf der Panels
const kopfOf = (page) => page.evaluate(() => {
  const kids = [...document.querySelectorAll('.hk-kopf-zeile > *')].filter((e) => e.getBoundingClientRect().height > 0)
  const tops = [...new Set(kids.map((e) => Math.round(e.getBoundingClientRect().top)))].sort((a, b) => a - b)
  const size = (e) => { const b = e.getBoundingClientRect(); return { w: Math.round(b.width), h: Math.round(b.height) } }
  const kopf = document.querySelector('.hk-kopf').getBoundingClientRect()
  return {
    rows: tops.length,
    tops,
    x: Math.round(kopf.x),
    r: Math.round(kopf.right),
    h: Math.round(kopf.height),
    buttons: [...document.querySelectorAll('.hk-hud-knopf')].map(size),
    overflow: [...document.querySelectorAll('.hk-kopf-geld, .hk-kopf-zahlen')].map((e) => e.scrollWidth - e.clientWidth),
    zahlen: [...document.querySelectorAll('.hk-kopf-zahl')].map((z) => z.lastElementChild.textContent.trim()),
  }
})

// Wischen mit echten Touch-Ereignissen (Chrome DevTools Protocol); die Kamera hört auf Zeiger vom Typ „touch“
async function swipe(cdp, from, to, steps = 8) {
  await cdp.send('Input.dispatchTouchEvent', { type: 'touchStart', touchPoints: [{ x: from.x, y: from.y }] })
  for (let i = 1; i <= steps; i += 1) {
    await cdp.send('Input.dispatchTouchEvent', { type: 'touchMove', touchPoints: [{ x: from.x + ((to.x - from.x) * i) / steps, y: from.y + ((to.y - from.y) * i) / steps }] })
    await sleep(16)
  }
  await cdp.send('Input.dispatchTouchEvent', { type: 'touchEnd', touchPoints: [] })
}
const near = (a, b, tol = 1.5) => Boolean(a && b) && Math.abs(a.x - b.x) <= tol && Math.abs(a.y - b.y) <= tol && Math.abs(a.s - b.s) <= 0.005

async function handy(browser, base) {
  const portrait = { viewport: { width: 390, height: 844 }, deviceScaleFactor: 2, isMobile: true, hasTouch: true }
  const { context, page } = await newPage(browser, 'handy', portrait)
  await ready(page, base + '/index.html')
  await sleep(800)

  const kopf = await kopfOf(page)
  metrics.handyKopf = { rows: kopf.rows, h: kopf.h }
  check('handy: Kopfzeile höchstens zwei Reihen (hochkant genau zwei: Geld + Pause/Zahnrad, dann die Kennzahlen) und im Bild', kopf.rows === 2 && kopf.x >= 0 && kopf.r <= 390 && kopf.h <= 120, kopf)
  check('handy: Pause- und Zahnrad-Knopf mindestens 40 x 40 px, nichts in den Panels läuft über', kopf.buttons.length === 2 && kopf.buttons.every((b) => b.w >= 40 && b.h >= 40) && kopf.overflow.every((o) => o <= 1), kopf)
  check('handy: alle fünf Kennzahlen stehen in der Kopfzeile (3, 3, 7, 2, 112)', same(kopf.zahlen, ['3', '3', '7', '2', '112']), kopf.zahlen)
  const wide = await widthOf(page)
  check('handy hochkant: kein waagrechtes Scrollen', noSideScroll(wide), wide)
  await shoot(page, 'c-handy-hochformat.png')

  // Wischen verschiebt die Welt, der Zoom bleibt
  const cdp = await context.newCDPSession(page)
  const c0 = await cameraOf(page)
  await swipe(cdp, { x: 300, y: 560 }, { x: 170, y: 560 })
  await sleep(300)
  const c1 = await cameraOf(page)
  check('handy: Wischen mit dem Finger verschiebt die Welt (Kamera x ändert sich um mehr als 60 px, Zoom gleich)', Boolean(c0 && c1) && Math.abs(c1.x - c0.x) > 60 && Math.abs(c1.s - c0.s) < 0.001, { c0, c1 })
  await shoot(page, 'c-handy-gewischt.png')

  // Doppeltipp auf eine freie Stelle zeigt das ganze Haus
  await page.touchscreen.tap(375, 300)
  await sleep(40)
  await page.touchscreen.tap(375, 300)
  await sleep(1100)
  const c2 = await cameraOf(page)
  check('handy: Doppeltipp auf eine freie Stelle zeigt wieder das ganze Haus (Kamera wie am Anfang)', near(c2, c0), { c0, c2 })
  await shoot(page, 'c-handy-ganz.png')

  // Pause-Rückfrage am Handy
  await page.locator('[data-hk-pause]').tap()
  const frage = page.locator('.hk-rueckfrage')
  await frage.waitFor()
  const fb = await rectOf(frage)
  const wFrage = await widthOf(page)
  check('handy: die Rückfrage „Alles anhalten?“ steht im Bild, nichts läuft über den Rand', fb.x >= 0 && fb.r <= 390 && fb.y >= 0 && fb.b <= 844 && noSideScroll(wFrage), { fb, wFrage })
  await shoot(page, 'c-handy-rueckfrage.png')
  await page.getByRole('button', { name: 'Abbrechen', exact: true }).tap()
  await frage.waitFor({ state: 'detached' })

  // Detailansicht als Vollbild
  await page.locator('[data-hk-hustler="rita"]').tap()
  await page.getByRole('dialog', { name: 'Hustler Rita' }).waitFor()
  await page.waitForFunction(() => document.querySelectorAll('.hk-dialog-spurzeile').length > 0)
  await sleep(500)
  const dlg = await rectOf(page.locator('.hk-dialog'))
  const hk = await rectOf(page.locator('.hk-hochhaus'))
  const fuss = await rectOf(page.locator('.hk-dialog-fuss'))
  const nummer = await textOf(page.locator('.hk-dialog-nummer'))
  const wDetail = await widthOf(page)
  metrics.handyDetail = { dialog: dlg, haus: hk }
  check('handy: Detailansicht als Vollbild (Dialog füllt die Fläche des Hauses), nichts läuft über den Rand', dlg.w >= 385 && dlg.h >= hk.h - 8 && noSideScroll(wDetail), { dlg, hk, wDetail })
  check('handy: in der Detailansicht ist „◂ n / 19 ▸“ sichtbar (Fuß im Bild, Nummer „2 / 19“)', fuss.b <= 844 && fuss.y >= 0 && nummer === '2 / 19', { fuss, nummer })
  await shoot(page, 'c-handy-detail.png')
  await page.getByRole('button', { name: 'Schließen', exact: true }).tap()
  await page.getByRole('dialog').waitFor({ state: 'detached' })
  await context.close()

  // quer
  const landscape = await newPage(browser, 'handy-quer', { viewport: { width: 844, height: 390 }, deviceScaleFactor: 2, isMobile: true, hasTouch: true })
  const lp = landscape.page
  await ready(lp, base + '/index.html')
  await sleep(800)
  const kq = await kopfOf(lp)
  const wq = await widthOf(lp)
  metrics.handyQuerKopf = { rows: kq.rows, h: kq.h }
  check('handy quer: Kopfzeile höchstens zwei Reihen (hier eine) und im Bild, kein waagrechtes Scrollen', kq.rows <= 2 && kq.x >= 0 && kq.r <= 844 && noSideScroll(wq), { kq, wq })
  check('handy quer: Pause- und Zahnrad-Knopf mindestens 40 x 40 px', kq.buttons.length === 2 && kq.buttons.every((b) => b.w >= 40 && b.h >= 40), kq.buttons)
  await shoot(lp, 'c-handy-querformat.png')
  await lp.locator('[data-hk-hustler="rita"]').tap()
  await lp.getByRole('dialog', { name: 'Hustler Rita' }).waitFor()
  await lp.waitForFunction(() => document.querySelectorAll('.hk-dialog-spurzeile').length > 0)
  await sleep(500)
  const fq = await rectOf(lp.locator('.hk-dialog-fuss'))
  const dq = await rectOf(lp.locator('.hk-dialog'))
  const xq = await rectOf(lp.getByRole('button', { name: 'Schließen', exact: true }))
  check('handy quer: Detailansicht ohne Überlauf nach rechts (Dialog im Bild, kein waagrechtes Scrollen)', dq.x >= 0 && dq.r <= 844 && noSideScroll(await widthOf(lp)), { dq })
  // BEFUND (App): ab 720 px Breite gilt die Desktop-Anordnung von hustler-detail.css (Szene 640 px breit, Daten rutschen darunter); bei 844 x 390 sieht man nur die Szene,
  // der Schließen-Knopf und die Fußzeile ◂ 2 / 19 ▸ liegen unterhalb des sichtbaren Teils (Handy-quer-Regel gilt nur unter 720 px Breite)
  check('handy quer (844 x 390): in der Detailansicht sind der Schließen-Knopf und „◂ 2 / 19 ▸“ ohne Scrollen im Bild', xq.b <= 390 && xq.y >= 0 && fq.b <= 390 && fq.y >= 0, { schliessen: xq, fuss: fq, dialog: dq })
  await shoot(lp, 'c-handy-quer-detail.png')
  await landscape.context.close()
}

// ---------- Szenario D: Weniger Bewegung ----------

// Steht das Element still? (kein Anzeigen, keine Animation oder alle pausiert) – aus den berechneten Stilen
const stillOf = (page, selectors) => page.evaluate((sels) => sels.map((sel) => {
  const el = document.querySelector(sel)
  if (!el) return { sel, fehlt: true }
  const cs = getComputedStyle(el)
  const names = cs.animationName.split(',').map((s) => s.trim())
  const states = cs.animationPlayState.split(',').map((s) => s.trim())
  return { sel, display: cs.display, names, states, steht: cs.display === 'none' || names.every((n) => n === 'none') || states.every((s) => s === 'paused') }
}), selectors)

async function bewegung(browser, base) {
  const welt = ['.hk-schnee-1', '.hk-schnee-2', '.hk-schnee-3', '.hk-funkeln', '.hk-licht-1', '.hk-licht-2', '.hk-licht-3', '.hk-licht-4', '.hk-laternen', '.hk-fenster-a', '.hk-fenster-b', '.hk-fenster-c', '.hk-neon', '.hk-antenne', '.hk-aufzug', '.hk-seil', '.hk-huepf']
  // Gegenprobe: ohne die Einstellung läuft derselbe Satz (sonst prüft der Test nichts)
  const normal = await newPage(browser, 'bewegung-normal', { viewport: { width: 1280, height: 720 } })
  await ready(normal.page, base + '/index.html')
  await sleep(400)
  const running = await stillOf(normal.page, welt)
  check('bewegung: Gegenprobe ohne „weniger Bewegung“: Schnee, Neon und Lichter laufen (der Test kann also fehlschlagen)', running.filter((r) => !r.fehlt && !r.steht).length >= 10, running.filter((r) => r.steht || r.fehlt).map((r) => r.sel))
  await normal.context.close()

  const { context, page } = await newPage(browser, 'bewegung', { viewport: { width: 1280, height: 720 }, reducedMotion: 'reduce' })
  await ready(page, base + '/index.html')
  await sleep(500)
  const still = await stillOf(page, welt)
  check('bewegung: Schnee, Flackern (Lichter, Fenster, Neon, Antenne, Aufzug, Briefkasten) stehen still (animation-name none, pausiert oder ausgeblendet)', still.every((r) => !r.fehlt && r.steht), still.filter((r) => r.fehlt || !r.steht))
  check('bewegung: der Schnee ist ausgeblendet', still.filter((r) => r.sel.startsWith('.hk-schnee')).every((r) => r.display === 'none'), still.filter((r) => r.sel.startsWith('.hk-schnee')))
  await shoot(page, 'd-bewegung-hochhaus.png')

  // kein Gleiten: Etage heranzoomen springt sofort, die Klasse hk-gleitet kommt nie
  const c0 = await cameraOf(page)
  await page.locator('.hk-etage[aria-label="Prüfung heranzoomen"]').click()
  const gleitet = await page.evaluate(() => document.querySelector('.hk-buehne').classList.contains('hk-gleitet'))
  await sleep(60)
  const c1 = await cameraOf(page)
  const dauer = await page.evaluate(() => getComputedStyle(document.querySelector('.hk-buehne')).transitionDuration)
  check('bewegung: kein Gleiten (Klasse hk-gleitet fehlt, keine Übergangszeit), die Kamera springt zur Etage', !gleitet && /^0s(, 0s)*$/.test(dauer) && c1.s > c0.s * 1.2, { gleitet, dauer, c0, c1 })

  // Regie: nur Sprechblasen, keine Symbole, Flüge oder Hüpfer
  const t0 = Date.now()
  const arten = new Set()
  let blase = false
  while (Date.now() - t0 < 15000 && !(blase && Date.now() - t0 > 9000)) {
    const st = await regieOf(page)
    st.arten.forEach((a) => arten.add(a))
    if (st.blasen.length > 0) blase = true
    await sleep(200)
  }
  check('bewegung: die Regie zeigt Sprechblasen, aber keine Symbole, Flüge oder Hüpfer', blase && [...arten].every((a) => a === 'blase'), { blase, arten: [...arten] })

  // Pult und Keller: Szenen stehen (animation none, pausiert oder ausgeblendet)
  await page.goto(base + '/index.html?fault=none&tab=freigabe')
  await page.waitForSelector('.hk-pult .hk-pult-szene')
  await settleFonts(page)
  const pult = await stillOf(page, ['.hk-sz-schnee', '.hk-sz-l55', '.hk-sz-kette0', '.hk-boten-weg', '.hk-boten-bild', '.hk-sz-tuer', '.hk-sz-briefkasten', '.hk-sz-sekunde'])
  check('bewegung: Pult-Szene steht (Schnee, Lichter, Lichterkette, Boten, Tür, Briefkasten, Sekundenzeiger)', pult.every((r) => !r.fehlt && r.steht), pult.filter((r) => r.fehlt || !r.steht))
  await shoot(page, 'd-bewegung-pult.png')
  await page.goto(base + '/index.html?fault=none&tab=botleads')
  await page.waitForSelector('.hk-keller .hk-kl-szene')
  await settleFonts(page)
  const keller = await stillOf(page, ['.hk-sz-staub', '.hk-sz-fensterschnee', '.hk-sz-licht-92', '.hk-sz-licht-halle', '.hk-sz-rohrpost', '.hk-sz-schublade', '.hk-sz-buch-stempel', '.hk-sz-maus-weg', '.hk-sz-passant-weg', '.hk-sz-led'])
  check('bewegung: Keller-Szene steht (Staub, Schnee, Lichter, Rohrpost, Schublade, Stempel, Maus, Passant, Blinkpunkte)', keller.every((r) => !r.fehlt && r.steht), keller.filter((r) => r.fehlt || !r.steht))
  await shoot(page, 'd-bewegung-keller.png')
  await context.close()
}

// ---------- Szenario E: Notbremse ----------

async function notbremse(browser, base) {
  const { context, page } = await newPage(browser, 'notbremse', { viewport: { width: 1280, height: 720 } })
  await ready(page, base + '/index.html?halted=1')
  await sleep(500)
  const banner = page.locator('.hk-meldung-notbremse')
  await banner.waitFor()
  const bb = await rectOf(banner)
  check('notbremse: Banner mit Grund („Versand gestoppt: Zwei harte Bounces in den letzten 10 Mails. Ein Admin kann ihn in den Einstellungen freigeben.“)', (await textOf(banner)) === HALT_LINE, await textOf(banner))
  check('notbremse: das Banner ist ein Alarm (role=alert), steht im Bild und ist höchstens 580 px breit; sonst keine Meldung', (await banner.getAttribute('role')) === 'alert' && bb.x >= 0 && bb.r <= 1280 && bb.b <= 720 && bb.w <= 580 && (await page.locator('.hk-meldung').count()) === 1, bb)
  await shoot(page, 'e-notbremse.png')

  // Einstellungen: der WOMS-Dialog in der Pixelwelt zeigt den Notbremse-Block
  await page.getByRole('button', { name: 'Einstellungen', exact: true }).click()
  const dialog = page.getByRole('dialog', { name: 'Hustler-Einstellungen' })
  await dialog.waitFor()
  await dialog.getByLabel('Tagesgrenze (USD)').waitFor()
  const look = await dialog.evaluate((el) => { const cs = getComputedStyle(el); return { bg: cs.backgroundColor, font: cs.fontFamily, woms: Boolean(el.closest('.hk-woms')) } })
  check('notbremse: Einstellungen öffnen im WOMS-Aussehen (weiß, WOMS-Schrift) mit dem Block „Versand gestoppt“', (await dialog.locator('.wk-halt').count()) === 1 && look.bg === 'rgb(255, 255, 255)' && !/Pixelify|Press Start/.test(look.font) && look.woms, look)
  await sleep(600)
  await shoot(page, 'e-einstellungen.png')
  await dialog.getByRole('button', { name: 'Abbrechen', exact: true }).click()
  await page.getByRole('dialog').waitFor({ state: 'detached' })
  check('notbremse: „Abbrechen“ schließt die Einstellungen, das Banner bleibt', (await page.locator('.hk-meldung-notbremse').count()) === 1)
  await context.close()
}

// ---------- Szenario F: Ausfall und Wiederkehr ----------

async function ausfall(browser, base) {
  const { context, page } = await newPage(browser, 'ausfall', { viewport: { width: 1280, height: 720 } })
  await page.goto(base + '/index.html?fault=down')
  const leer = page.locator('.hk-hochhaus .hk-leer')
  await leer.waitFor()
  await settleFonts(page)
  const titel = await textOf(leer.locator('.hk-leer-titel'))
  const satz = await textOf(leer.locator('.hk-leer-text'))
  check('ausfall: Leerzustand „Der Hustler-Dienst ist noch nicht erreichbar“ mit dem Satz des Dienstes und „Neu laden“, kein Haus', titel === NO_SERVICE && satz !== '' && (await leer.getByRole('button', { name: 'Neu laden', exact: true }).count()) === 1 && (await page.locator('[data-hk-hustler]').count()) === 0, { titel, satz })
  await shoot(page, 'f-ausfall.png')

  await page.evaluate(() => { window.__wk.control.fault = null })
  await leer.getByRole('button', { name: 'Neu laden', exact: true }).click()
  await page.waitForFunction(() => document.querySelectorAll('[data-hk-hustler]').length === 19)
  check('ausfall: nach „Neu laden“ (Dienst wieder da) steht das Haus mit 19 Figuren, der Leerzustand ist weg', (await page.locator('.hk-leer').count()) === 0 && (await page.locator('[data-hk-hustler]').count()) === 19)
  await sleep(500)
  await shoot(page, 'f-ausfall-wieder-da.png')

  // der Dienst fällt später wieder aus: das Haus bleibt stehen, ein Banner meldet die gestörte Verbindung
  await page.evaluate(() => { window.__wk.control.fault = 'down' })
  const banner = page.locator('.hk-meldung-verbindung')
  await banner.waitFor({ timeout: 25000 })
  const bt = await textOf(banner)
  check('ausfall: bricht die Verbindung später ab, bleibt das Haus stehen und ein Banner meldet „Verbindung gestört: … Es wird weiter versucht.“', bt.startsWith('Verbindung gestört:') && bt.endsWith('Es wird weiter versucht.') && (await page.locator('[data-hk-hustler]').count()) === 19, bt)
  await shoot(page, 'f-ausfall-verbindung-gestoert.png')
  await page.evaluate(() => { window.__wk.control.fault = null })
  await context.close()
}

// ---------- Szenario G: Detailansicht ----------

const slug = (text) => text.toLowerCase().replace(/ä/g, 'ae').replace(/ö/g, 'oe').replace(/ü/g, 'ue').replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
// Name, Status, Nummer und die Zeilen „Modell … Kosten“ der offenen Detailansicht
const detailOf = (page) => page.evaluate(() => {
  const text = (sel) => { const el = document.querySelector(sel); return el ? el.textContent.replace(/\s+/g, ' ').trim() : null }
  const dl = {}
  const dt = [...document.querySelectorAll('.hk-dialog-dl dt')]
  dt.forEach((el) => { dl[el.textContent.trim()] = el.nextElementSibling ? el.nextElementSibling.textContent.replace(/\s+/g, ' ').trim() : null })
  const szene = document.querySelector('.hk-dialog .hk-sz')
  return {
    name: text('.hk-dialog-name'),
    status: text('.hk-dialog-status'),
    nummer: text('.hk-dialog-nummer'),
    dl,
    szene: szene ? szene.className : '',
    schild: text('.hk-dialog-schild'),
    alarm: Boolean(document.querySelector('.hk-dialog .hk-alarm-gross')),
    zeilen: document.querySelectorAll('.hk-dialog-spurzeile').length,
  }
})

async function detail(browser, base) {
  const { context, page } = await newPage(browser, 'detail', { viewport: { width: 1280, height: 720 } })
  await ready(page, base + '/index.html')
  const t0 = Date.now()
  const figur = (id) => page.locator(`[data-hk-hustler="${id}"]`)
  const dialog = (name) => page.getByRole('dialog', { name: `Hustler ${name}` })
  const openDetail = async (id, name) => {
    await figur(id).click()
    await dialog(name).waitFor()
    await page.waitForFunction(() => document.querySelectorAll('.hk-dialog-spurzeile').length > 0)
    await sleep(350)
  }
  const closeDetail = async () => {
    await page.keyboard.press('Escape')
    await page.getByRole('dialog').waitFor({ state: 'detached' })
  }
  await sleep(300)

  // 1. Ein Bild je Status (gleich nach dem Laden, ehe das Drehbuch viel ändert; der Dateiname trägt den Status, den die Ansicht wirklich zeigt)
  const gesehen = []
  for (const [id, name] of [['otto', 'Overseer'], ['rita', 'Rita'], ['ali', 'Ali'], ['hanna', 'Hanna'], ['kim', 'Kim']]) {
    await openDetail(id, name)
    const d = await detailOf(page)
    gesehen.push(`${id}:${d.status}`)
    check(`detail ${name}: Dialog mit Name „${name}“, Status, Modell, Etage · Raum, Aufgabe, Gerade, Heute, Kosten und Spur`,
      d.name === name && d.status !== '' && ['Modell', 'Etage', 'Aufgabe', 'Gerade', 'Heute', 'Kosten'].every((k) => d.dl[k] !== undefined && d.dl[k] !== '') && d.zeilen > 0, d)
    await shoot(page, `g-detail-${id}-${slug(d.status)}.png`)
    await closeDetail()
  }
  metrics.detailStatus = gesehen

  // 2. Rita: Inhalt, sichere Links, lange Spur mit Fuß
  await openDetail('rita', 'Rita')
  await page.waitForFunction(() => document.querySelectorAll('.hk-dialog-spurzeile').length === 12)
  const rita = await detailOf(page)
  check('detail Rita: Dialog mit role=dialog, aria-modal und dem Namen „Hustler Rita“; Modell „Claude Haiku 5.5“, Etage „Anfragen · Netz-Radar“, Kosten „0,37 $ · 20.700 Tokens“',
    (await dialog('Rita').getAttribute('aria-modal')) === 'true' && rita.dl.Modell === 'Claude Haiku 5.5' && rita.dl.Etage === 'Anfragen · Netz-Radar' && rita.dl.Kosten === '0,37 $ · 20.700 Tokens', rita.dl)
  check('detail Rita: beim Öffnen liegt der Fokus auf „Schließen“', (await focusInfo(page)).label === 'Schließen', await focusInfo(page))
  const links = await page.evaluate(() => [...document.querySelectorAll('.hk-dialog-spurliste a')].map((a) => ({ href: a.getAttribute('href'), target: a.getAttribute('target'), rel: a.getAttribute('rel') })))
  const unsafeRow = page.locator('.hk-dialog-spurzeile', { hasText: 'Link mit Skript abgelehnt' })
  check('detail Rita: Spur mit 12 Zeilen; nur sichere Links (https extern mit noopener noreferrer, intern ohne neuen Tab), nie javascript:',
    rita.zeilen === 12 && links.length === 2 && links.some((l) => l.href === 'https://example.org/fund' && l.target === '_blank' && l.rel === 'noopener noreferrer') && links.every((l) => !/^javascript:/i.test(l.href)) && (await unsafeRow.count()) === 1 && (await unsafeRow.locator('a').count()) === 0, links)
  // lange Spur: Fuß ◂ n / 19 ▸ bleibt im Bild und frei (nicht verdeckt)
  const fuss = await rectOf(page.locator('.hk-dialog-fuss'))
  const knoepfe = await page.evaluate(() => ['Vorheriger Hustler', 'Nächster Hustler'].map((label) => {
    const el = document.querySelector(`.hk-dialog-fuss [aria-label="${label}"]`)
    const b = el.getBoundingClientRect()
    const hit = document.elementFromPoint(b.left + b.width / 2, b.top + b.height / 2)
    return { label, visible: b.top >= 0 && b.bottom <= window.innerHeight, frei: hit === el || el.contains(hit) }
  }))
  const dlgBox = await rectOf(page.locator('.hk-dialog'))
  const scrolls = await page.evaluate(() => { const el = document.querySelector('.hk-dialog'); return el.scrollHeight > el.clientHeight + 1 })
  metrics.detailDesktop = { dialog: dlgBox, fuss, scrolltDasPanel: scrolls }
  check('detail Rita: bei langer Spur steht „◂ 2 / 19 ▸“ im Bild und ist nicht verdeckt (Fuß klebt unten)', rita.nummer === '2 / 19' && fuss.b <= 720 && fuss.y >= 0 && knoepfe.every((k) => k.visible && k.frei), { fuss, knoepfe, rita: rita.nummer })
  await shoot(page, 'g-detail-rita-lange-spur.png')

  // 3. Fokusfalle: Tab vom letzten Knopf geht zu „Schließen“, Umschalt+Tab von „Schließen“ zum letzten
  await page.locator('.hk-dialog-fuss [aria-label="Nächster Hustler"]').focus()
  await page.keyboard.press('Tab')
  const nachTab = await focusInfo(page)
  await page.keyboard.press('Shift+Tab')
  const nachShiftTab = await focusInfo(page)
  check('detail: Tab bleibt im Dialog (vom letzten Knopf zu „Schließen“ und mit Umschalt+Tab zurück)', nachTab.label === 'Schließen' && nachShiftTab.label === 'Nächster Hustler', { nachTab, nachShiftTab })

  // 4. Blättern mit den Pfeiltasten (im Kreis, in der Reihenfolge der Hustler)
  await page.keyboard.press('ArrowRight')
  await page.getByRole('dialog', { name: 'Hustler Kim' }).waitFor()
  const kim = await detailOf(page)
  check('detail: → blättert zu Kim („3 / 19“, Stecker-Szene „noch nicht angeschlossen“, Status „Noch nicht angeschlossen“)', kim.name === 'Kim' && kim.nummer === '3 / 19' && /hk-sz-nicht/.test(kim.szene) && kim.schild === 'noch nicht angeschlossen' && kim.status === 'Noch nicht angeschlossen', kim)
  await page.keyboard.press('ArrowLeft')
  await page.getByRole('dialog', { name: 'Hustler Rita' }).waitFor()
  await page.keyboard.press('ArrowLeft')
  await page.getByRole('dialog', { name: 'Hustler Overseer' }).waitFor()
  const ovs = await detailOf(page)
  check('detail: ← blättert zurück zu Rita und zum Overseer („1 / 19“, Brücken-Szene)', ovs.nummer === '1 / 19' && /hk-sz-bruecke/.test(ovs.szene), ovs)
  await page.keyboard.press('ArrowLeft')
  await page.getByRole('dialog', { name: 'Hustler Arne' }).waitFor()
  check('detail: ← vom Ersten springt im Kreis zum Letzten (Arne, „19 / 19“)', (await textOf(page.locator('.hk-dialog-nummer'))) === '19 / 19')
  await page.getByRole('button', { name: 'Nächster Hustler', exact: true }).click()
  await page.getByRole('dialog', { name: 'Hustler Overseer' }).waitFor()
  await page.getByRole('button', { name: 'Vorheriger Hustler', exact: true }).click()
  await page.getByRole('dialog', { name: 'Hustler Arne' }).waitFor()
  check('detail: die Knöpfe ◂ und ▸ blättern wie die Pfeiltasten', true)
  // hier wurde in der Detailansicht geblättert: die Kamera der Welt darf sich dabei nicht bewegt haben
  const cam0 = await cameraOf(page)

  // 5. Esc schließt, der Fokus liegt wieder auf der Figur, die den Dialog geöffnet hat
  await closeDetail()
  const nachEsc = await focusInfo(page)
  check('detail: Esc schließt den Dialog, der Fokus liegt wieder auf der Figur (Rita), die ihn geöffnet hat', nachEsc.hustler === 'rita', nachEsc)
  check('detail: die Kamera der Welt hat sich beim Blättern nicht bewegt (Pfeiltasten gehören dem Dialog)', near(cam0, await cameraOf(page)), cam0)

  // 6. Schließen-Knopf und Klick auf den Hintergrund (erst nach 0,4 s) schließen ebenfalls
  await openDetail('ali', 'Ali')
  await page.getByRole('button', { name: 'Schließen', exact: true }).click()
  await page.getByRole('dialog').waitFor({ state: 'detached' })
  check('detail: „Schließen“ schließt, Fokus zurück auf die Figur (Ali)', (await focusInfo(page)).hustler === 'ali', await focusInfo(page))
  await openDetail('hanna', 'Hanna')
  await sleep(700) // der Hintergrund ist die ersten 0,4 s gesperrt (der Antipp-Klick, der den Dialog öffnet, darf ihn nicht gleich wieder schließen)
  await page.mouse.click(240, 360)
  await page.getByRole('dialog').waitFor({ state: 'detached' })
  check('detail: ein Klick auf den Hintergrund neben dem Dialog schließt ihn', true)

  // 7. Fehler-Status: das Drehbuch lässt Sven zwischen 39,6 s und 45,8 s im Fehler stehen
  let fehlerGesehen = false
  while (Date.now() - t0 < 62000) {
    const label = await figur('sven').getAttribute('aria-label')
    if (label && label.endsWith('Fehler')) { fehlerGesehen = true; break }
    await sleep(250)
  }
  check('detail: Sven steht im Fehler (Label endet mit „Fehler“) – roter „!“-Marker am Haus', fehlerGesehen && (await figur('sven').locator('.hk-alarm').count()) === 1 && (await textOf(figur('sven').locator('.hk-alarm'))) === '!', await figur('sven').getAttribute('aria-label'))
  if (fehlerGesehen) {
    await page.evaluate(() => { document.querySelector('[data-hk-hustler="sven"]').scrollIntoView({ block: 'center' }) })
    await shoot(page, 'g-haus-fehler.png')
    await figur('sven').click()
    await dialog('Sven').waitFor()
    await sleep(350)
    const sven = await detailOf(page)
    check('detail Sven (Fehler): Status „Fehler“ in Rot, großer „!“-Marker an der Figur', sven.status === 'Fehler' && sven.alarm, sven)
    await shoot(page, 'g-detail-sven-fehler.png')
    await closeDetail()
  }
  await context.close()
}

// ---------- Szenario H: Etagen, Tasten, Freigabe und Keller ----------

async function etagen(browser, base) {
  const { context, page } = await newPage(browser, 'etagen', { viewport: { width: 1280, height: 720 } })
  await ready(page, base + '/index.html')
  await sleep(500)
  const tabOf = () => new URL(page.url()).searchParams.get('tab')

  const etagen = await page.evaluate(() => [...document.querySelectorAll('.hk-etage')].map((el) => ({ tag: el.tagName, label: el.getAttribute('aria-label'), href: el.getAttribute('href') })))
  check('etagen: zehn Etagen – acht Knöpfe „… heranzoomen“, dazu die Links „Freigabe“ und „Keller · Bot-Leads“, alle mit aria-label',
    etagen.length === 10 && etagen.filter((e) => e.tag === 'BUTTON' && /heranzoomen$/.test(e.label || '')).length === 8
    && etagen.some((e) => e.tag === 'A' && e.label === 'Freigabe: Freigabe-Pult öffnen' && e.href === '/hustler?tab=freigabe')
    && etagen.some((e) => e.tag === 'A' && e.label === 'Keller · Bot-Leads: Bot-Leads öffnen' && e.href === '/hustler?tab=botleads'), etagen)

  // 1. Etage zoomen: gleitet, die Etage füllt das Bild
  const c0 = await cameraOf(page)
  const pruefung = page.locator('.hk-etage[aria-label="Prüfung heranzoomen"]')
  await pruefung.click()
  const gleitet = await page.evaluate(() => document.querySelector('.hk-buehne').classList.contains('hk-gleitet'))
  await sleep(900)
  const c1 = await cameraOf(page)
  const eb = await rectOf(pruefung)
  const sicht = await rectOf(page.locator('.hk-sicht'))
  check('etagen: Klick auf die Etage „Prüfung“ zoomt heran (gleitet, Zoom wächst um mehr als 30 %), die Etage steht im Bild und ist breit', gleitet && c1.s > c0.s * 1.3 && eb.x >= sicht.x - 2 && eb.r <= sicht.r + 2 && eb.y >= sicht.y && eb.b <= sicht.b + 2 && eb.w >= 400, { gleitet, c0, c1, eb, sicht })
  const nachGleiten = await page.evaluate(() => document.querySelector('.hk-buehne').classList.contains('hk-gleitet'))
  check('etagen: nach dem Gleiten ist die Klasse hk-gleitet wieder weg', !nachGleiten)
  await shoot(page, 'h-etage-zoom.png')

  // 2. Tastenkürzel +, −, 0, Esc
  await page.keyboard.press('0')
  await sleep(900)
  check('etagen: Taste 0 zeigt wieder das ganze Haus', near(await cameraOf(page), c0), { c0, jetzt: await cameraOf(page) })
  await page.keyboard.press('+')
  await sleep(80)
  const plus = await cameraOf(page)
  await page.keyboard.press('-')
  await sleep(80)
  const minus = await cameraOf(page)
  check('etagen: + zoomt hinein, − wieder heraus', plus.s > c0.s * 1.1 && minus.s < plus.s, { c0, plus, minus })
  await pruefung.click()
  await sleep(900)
  await page.keyboard.press('Escape')
  await sleep(900)
  check('etagen: Esc zeigt das ganze Haus', near(await cameraOf(page), c0), { c0, jetzt: await cameraOf(page) })
  await page.getByRole('button', { name: 'Ganzes Haus zeigen', exact: true }).evaluate((el) => el.click())
  check('etagen: „Ganzes Haus zeigen“ (nur Tastatur) ist ein echter Knopf in der Kopfzeile', (await page.getByRole('button', { name: 'Ganzes Haus zeigen', exact: true }).count()) === 1)

  // 3. Etage „Freigabe“ → Pult (Adresse tab=freigabe), „◂ Hochhaus“ zurück
  const freigabe = page.locator('a.hk-etage[aria-label^="Freigabe"]')
  await freigabe.click({ position: { x: 16, y: 8 } })
  await page.locator('.hk-pult').waitFor()
  check('etagen: Etage „Freigabe“ öffnet das Pult (Adresse tab=freigabe), das Hochhaus ist weg', tabOf() === 'freigabe' && (await page.locator('.hk-hochhaus').count()) === 0 && (await page.locator('[data-hk-hustler]').count()) === 0, { tab: tabOf(), url: page.url() })
  await settleFonts(page)
  await sleep(600)
  await shoot(page, 'h-pult-von-etage.png')
  await page.getByRole('button', { name: 'Hochhaus', exact: true }).click()
  await page.waitForFunction(() => document.querySelectorAll('[data-hk-hustler]').length === 19)
  check('etagen: „◂ Hochhaus“ führt zurück ins Haus mit 19 Figuren (Adresse tab=hochhaus)', tabOf() === 'hochhaus' && (await page.locator('.hk-pult').count()) === 0, { tab: tabOf() })

  // 4. Keller-Etage → Bot-Leads, „Zurück zum Hochhaus“
  await sleep(500)
  const keller = page.locator('a.hk-etage[aria-label^="Keller"]')
  await keller.click({ position: { x: 16, y: 8 } })
  await page.locator('.hk-keller').waitFor()
  await page.waitForFunction(() => document.querySelectorAll('.hk-zeile').length > 0)
  check('etagen: Keller-Etage öffnet die Bot-Leads (Adresse tab=botleads) mit Einträgen im Register-Buch', tabOf() === 'botleads' && (await page.locator('.hk-zeile').count()) === 50, { tab: tabOf() })
  await sleep(600)
  await shoot(page, 'h-keller-von-etage.png')
  await page.getByRole('button', { name: 'Zurück zum Hochhaus', exact: true }).click()
  await page.waitForFunction(() => document.querySelectorAll('[data-hk-hustler]').length === 19)
  check('etagen: „Zurück zum Hochhaus“ führt ins Haus zurück (Adresse tab=hochhaus)', tabOf() === 'hochhaus' && (await page.locator('.hk-keller').count()) === 0, { tab: tabOf() })

  // 5. Zurück-Taste des Browsers: Haus → Pult → Haus über die Chronik
  await page.goBack()
  await page.locator('.hk-keller').waitFor()
  check('etagen: die Zurück-Taste des Browsers geht von Haus zurück zu den Bot-Leads (Chronik), nicht aus der Seite', tabOf() === 'botleads', { tab: tabOf() })
  await context.close()
}

// ---------- Szenario I: Pause mit Rückfrage, Animationen stehen ----------

async function pause(browser, base) {
  const { context, page } = await newPage(browser, 'pause', { viewport: { width: 1280, height: 720 } })
  await ready(page, base + '/index.html')
  await sleep(500)
  const pauseBtn = page.locator('[data-hk-pause]')
  const calls = () => apiOf(page, 'pauseCalls')
  const frage = page.getByRole('dialog', { name: 'Alles anhalten?', exact: true })
  // Rita tippt: der Sprite läuft (background-position ändert sich), solange nichts angehalten ist
  const probe = async () => {
    const werte = []
    for (let i = 0; i < 7; i += 1) {
      werte.push(await page.evaluate(() => {
        const el = document.querySelector('[data-hk-hustler="rita"] .hk-spr')
        const cs = getComputedStyle(el)
        return { pos: cs.backgroundPosition, state: cs.animationPlayState, schnee: getComputedStyle(document.querySelector('.hk-schnee-1')).animationPlayState }
      }))
      await sleep(170)
    }
    return werte
  }
  const lauf = await probe()
  check('pause: Gegenprobe vor dem Anhalten: Ritas Sprite läuft (mehrere Bildausschnitte, Zustand „running“)', new Set(lauf.map((w) => w.pos)).size >= 2 && lauf.every((w) => w.state === 'running'), lauf)

  // 1. Rückfrage statt sofortigem Anhalten
  await pauseBtn.click()
  await frage.waitFor()
  const text = await textOf(frage.locator('.hk-rueckfrage-text'))
  const namen = await frage.getByRole('button').allTextContents()
  check('pause: „Alles anhalten“ öffnet die Pixel-Rückfrage „Alles anhalten?“ mit dem Satz zu den Workern und den Knöpfen „Abbrechen“ und „Anhalten“', text === HALT_QUESTION && same(namen.map((t) => t.trim()), ['Abbrechen', 'Anhalten']) && (await frage.getAttribute('aria-modal')) === 'true', { text, namen })
  check('pause: vor der Bestätigung ist nichts angehalten (kein Aufruf, keine Meldung), der Fokus liegt auf „Abbrechen“', same(await calls(), []) && (await page.locator('.hk-meldung').count()) === 0 && (await focusInfo(page)).text === 'Abbrechen', { calls: await calls(), fokus: await focusInfo(page) })
  await sleep(300)
  await shoot(page, 'i-pause-frage.png')

  // 2. Abbrechen und Esc tun nichts, der Fokus kehrt auf den Pause-Knopf zurück
  await frage.getByRole('button', { name: 'Abbrechen', exact: true }).click()
  await frage.waitFor({ state: 'detached' })
  check('pause: „Abbrechen“ schließt die Rückfrage, nichts wird angehalten, der Fokus liegt wieder auf dem Pause-Knopf', same(await calls(), []) && (await focusInfo(page)).pause === true, { calls: await calls(), fokus: await focusInfo(page) })
  await pauseBtn.click()
  await frage.waitFor()
  await page.keyboard.press('Escape')
  await frage.waitFor({ state: 'detached' })
  check('pause: Esc wirkt wie „Abbrechen“ (nichts angehalten, Fokus auf dem Pause-Knopf)', same(await calls(), []) && (await focusInfo(page)).pause === true, { calls: await calls(), fokus: await focusInfo(page) })

  // 3. Anhalten hält an: Banner, hk-steht, alle Animationen pausiert
  await pauseBtn.click()
  await frage.waitFor()
  await frage.getByRole('button', { name: 'Anhalten', exact: true }).click()
  await frage.waitFor({ state: 'detached' })
  const banner = page.locator('.hk-meldung-angehalten')
  await banner.waitFor()
  await page.getByRole('button', { name: 'Fortsetzen', exact: true }).waitFor()
  check('pause: „Anhalten“ pausiert genau einmal (pause(true)), Banner „Angehalten: Es wird nichts gesendet und nichts gebaut.“, Knopf „Fortsetzen“', same(await calls(), [true]) && (await textOf(banner)) === PAUSED_LINE && (await banner.getAttribute('role')) === 'status', { calls: await calls(), banner: await textOf(banner) })
  const steht = await page.evaluate(() => ({ sicht: document.querySelector('.hk-sicht').classList.contains('hk-steht'), buehne: document.querySelector('.hk-buehne').classList.contains('hk-steht') }))
  check('pause: Sichtfenster und Bühne tragen hk-steht', steht.sicht && steht.buehne, steht)
  const fokus = await focusInfo(page)
  check('pause: nach dem Anhalten steht der Fokus nicht auf <body> (Tastatur-Nutzer verlieren ihre Stelle nicht)', fokus.tag !== null && fokus.tag !== 'BODY', fokus)
  const still = await probe()
  check('pause: angehalten – Ritas Sprite steht (immer derselbe Bildausschnitt, Zustand „paused“), auch der Schnee ist pausiert', new Set(still.map((w) => w.pos)).size === 1 && still.every((w) => w.state === 'paused' && w.schnee === 'paused'), still)
  check('pause: die Figuren sind unverändert da (19 Knöpfe, Label von Rita bleibt „Rita, Haiku, …“)', (await page.locator('[data-hk-hustler]').count()) === 19 && /^Rita, Haiku, /.test(await page.locator('[data-hk-hustler="rita"]').getAttribute('aria-label')))
  await shoot(page, 'i-pause-angehalten.png')

  // 4. Fortsetzen geht ohne Rückfrage
  await page.getByRole('button', { name: 'Fortsetzen', exact: true }).click()
  await page.locator('.hk-meldung-angehalten').waitFor({ state: 'detached' })
  await page.getByRole('button', { name: 'Alles anhalten', exact: true }).waitFor()
  const weiter = await probe()
  check('pause: „Fortsetzen“ geht ohne Rückfrage (kein Dialog, pause(false)), das Banner verschwindet, hk-steht ist weg und der Sprite läuft wieder',
    (await page.getByRole('dialog').count()) === 0 && same(await calls(), [true, false]) && (await page.locator('.hk-steht').count()) === 0 && new Set(weiter.map((w) => w.pos)).size >= 2, { calls: await calls(), weiter })
  await context.close()
}

// ---------- Pult: gemeinsame Hilfen (Szenarien J, K und M) ----------
// Die Seite läuft über den echten API-Client und die Fetch-Weiche (fault=none): Pult-Aufrufe, Fehlertexte und Zeitgrenzen sind die des Betriebs. Was die Oberfläche
// geschickt hat, steht in window.__wk.api.pultCalls (Skript-API); Zwischenablage und window.open sind ersetzt (newStubPage).

const PULT_URL = '/index.html?fault=none&tab=freigabe'
const P4_URL = '/index.html?fault=none&p4=1&tab=freigabe'
const T3 = {
  mail: 'Anfrage: Vereinswebsite für den SV Namborn',
  plat: 'Kleinanzeigen: Website für Friseursalon gesucht',
  koll: 'Kleinanzeigen: Homepage für Handwerksbetrieb',
  uns: 'Unsichere Antwort: bitte prüfen',
  alt: 'freelancermap: WordPress-Relaunch',
  ges: 'Kleinanzeigen: Fotograf sucht Portfolio-Seite',
  erl: 'Beschwerde über eine Vorschau',
}
const T4 = {
  mail: 'Anfrage: Vereinswebsite für den SV Namborn',
  frei: 'Vorschau freigeben: Friseur Muster',
  falsch: 'Vorschau freigeben: Bäckerei Korn',
  uns: 'Unsichere Antwort: Ist das ein Ja?',
  koll: 'Anfrage: Tischlerei Holz',
  plat: 'Kleinanzeigen: Website für Fotostudio',
  ang: 'Kleinanzeigen: Website für Fotostudio (Angebot)',
}
const HAIR_URL = 'https://www.kleinanzeigen.de/s-anzeige/website-fuer-friseursalon/2870000001-1-1'
const WEBER_URL = 'https://www.kleinanzeigen.de/s-anzeige/homepage-handwerksbetrieb/2870000002-1-1'
const PREVIEW_URL = 'https://entwurf.project.webklar.com/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/'
const CONFLICT = 'Wird schon von einem Kollegen bearbeitet.'
const GONE = 'Dieser Kontakt ist nicht mehr aktiv.'
const NEED_TEXT = 'Bitte einen Text eingeben.'
const BUILD_HINT = 'Startet einen Opus-Lauf und baut die Vorschau, als hätte der Interessent Ja gesagt.'
const PASTE_HINT = 'Kopiere die Antwort aus der Plattform hierher. Nora sortiert sie ein; bei einer Frage schreibt Clara den nächsten Entwurf.'
const PULT_DOWN = 'Der Hustler-Dienst ist gerade nicht erreichbar.'
// Telefon: das Wort oder eine Nummer (+49 / Vorwahl mit 0, Trennzeichen, weitere Ziffern); Postleitzahlen und Beträge passen nicht darauf
const PHONE_WORD = /telefon|phone|\btel\.|handynummer|mobilnummer/i
const PHONE_NUMBER = /\+49|\b0\d{2,5}[\s/-]\d{3,}/

const umschlag = (page, title) => page.locator('.hk-umschlag').filter({ has: page.locator('.hk-umschlag-titel', { hasText: new RegExp('^' + escapeRe(title) + '$') }) })
const titlesOf = (page) => page.locator('.hk-umschlag-titel').allTextContents()
const waitTitles = (page, want, timeout = 8000) => page.waitForFunction((w) => JSON.stringify([...document.querySelectorAll('.hk-umschlag-titel')].map((el) => el.textContent)) === JSON.stringify(w), want, { timeout })
const brief = (page) => page.locator('.hk-brief')
const stempel = (page, name) => page.locator('.hk-brief .hk-aktionen').getByRole('button', { name, exact: true })
const aktionen = (page) => page.locator('.hk-brief .hk-aktionen').locator('button, a').evaluateAll((els) => els.map((el) => el.textContent.replace(/\s+/g, ' ').trim()))
const briefNote = (page) => page.locator('.hk-brief .hk-hinweis')
const meldungOf = (page) => page.locator('section.hk-klemmbrett > .hk-hinweis-ok')
const pultCalls = (page) => apiOf(page, 'pultCalls')
const callsOf = async (page, action, id) => (await pultCalls(page)).filter((c) => c.action === action && (id === undefined || c.id === id))
const stubState = (page) => page.evaluate(() => ({ clip: window.__clip.slice(), opened: window.__opened.map((a) => Array.from(a)), meta: window.__openMeta.slice() }))
const resetStubs = (page) => page.evaluate(() => { window.__clip.length = 0; window.__opened.length = 0; window.__openMeta.length = 0 })
const reiterBtn = (page, name) => page.locator('.hk-reiter-leiste .hk-reiter', { hasText: name })
const phoneFree = async (page) => {
  const html = await page.evaluate(() => document.documentElement.outerHTML)
  const text = await page.evaluate(() => document.body.innerText)
  return !PHONE_WORD.test(html) && !PHONE_NUMBER.test(html) && !PHONE_WORD.test(text) && !PHONE_NUMBER.test(text)
}

// Pult öffnen: warten, bis alle wartenden Umschläge und die Mitarbeiternamen („übernommen von Justin“) da sind
async function openPult(page, base, url, count) {
  await page.goto(base + url)
  await page.waitForFunction((n) => document.querySelectorAll('.hk-umschlag').length === n, count)
  await page.waitForFunction(() => document.querySelector('.hk-klemmbrett').textContent.includes('Justin'))
  await settleFonts(page)
  await sleep(300)
}
async function openBrief(page, title) {
  await umschlag(page, title).click()
  await brief(page).waitFor()
  await sleep(250)
}
const closeBrief = async (page) => {
  await page.keyboard.press('Escape')
  await brief(page).waitFor({ state: 'detached' })
}

// ---------- Szenario J: Pult mit den P3-Daten ----------

async function pult(browser, base) {
  const { context, page } = await newStubPage(browser, 'pult', { viewport: { width: 1280, height: 720 } })
  await openPult(page, base, PULT_URL, 4)

  // 1. Seite: Szene, Kopf, Reiter, Umschläge
  const reiter = await page.evaluate(() => [...document.querySelectorAll('.hk-reiter-leiste .hk-reiter')].map((b) => ({ text: b.textContent.replace(/\s+/g, ' ').trim(), pressed: b.getAttribute('aria-pressed'), zahl: b.querySelector('.hk-zahl') ? b.querySelector('.hk-zahl').textContent : null })))
  check('pult: drei Reiter „Wartet“, „Veraltet“, „Erledigt“, „Wartet“ gedrückt, nur der offene mit einer Zahl', same(reiter.map((r) => r.text.replace(/\d+$/, '').trim()), ['Wartet', 'Veraltet', 'Erledigt']) && same(reiter.map((r) => r.pressed), ['true', 'false', 'false']) && /^[0-9]+$/.test(reiter[0].zahl || '') && reiter[1].zahl === null && reiter[2].zahl === null, reiter)
  const kopf = await page.evaluate(() => ({ h1: document.querySelector('.hk-pult-h1').textContent, zahl: (document.querySelector('.hk-pult-zahl') || {}).textContent || '', zurueck: [...document.querySelectorAll('.hk-pult-knopf')].map((b) => b.textContent.replace(/\s+/g, ' ').trim()) }))
  check('pult: Messingschild „Freigabe“ mit der Zahl „Wartet auf dich“, Knöpfe „Hochhaus“ und „Pult zuklappen“, Szene dahinter', kopf.h1 === 'Freigabe' && /\d/.test(kopf.zahl) && same(kopf.zurueck, ['Hochhaus', 'Pult zuklappen']) && (await page.locator('.hk-pult-szene').count()) === 1, kopf)
  check('pult: „Wartet“ zeigt die vier Einträge, neueste zuerst', same(await titlesOf(page), [T3.mail, T3.plat, T3.koll, T3.uns]), await titlesOf(page))
  const platText = await textOf(umschlag(page, T3.plat))
  check('pult: Plattform-Umschlag nennt Art, Alter, „läuft in 20 Std. ab“, Ort und Score', platText.includes('Antwort auf Plattform-Anfrage') && platText.includes('vor 5 Std.') && platText.includes('läuft in 20 Std. ab') && platText.includes('67655 Kaiserslautern · Score 72'), platText)
  check('pult: Kollegen-Umschlag trägt „übernommen von Justin“', (await textOf(umschlag(page, T3.koll))).includes('übernommen von Justin'))
  check('pult: Umschläge sind echte Knöpfe mit aria-haspopup=dialog und einem Namen „Art: Titel, …“', await page.evaluate(() => [...document.querySelectorAll('.hk-umschlag')].every((b) => b.tagName === 'BUTTON' && b.getAttribute('aria-haspopup') === 'dialog' && /^[^:]+: .+/.test(b.getAttribute('aria-label') || ''))))
  await shoot(page, 'j-pult-wartet.png')

  // 2. Umschlag öffnen: der Brief
  await openBrief(page, T3.plat)
  const dlg = await page.evaluate(() => { const b = document.querySelector('.hk-brief'); return { role: b.getAttribute('role'), modal: b.getAttribute('aria-modal'), label: b.getAttribute('aria-label') } })
  check('pult: ein Klick auf den Umschlag öffnet den Brief (role=dialog, aria-modal, Name „Antwort auf Plattform-Anfrage: …“), der Fokus liegt auf „Schließen“', dlg.role === 'dialog' && dlg.modal === 'true' && dlg.label === `Antwort auf Plattform-Anfrage: ${T3.plat}` && (await focusInfo(page)).label === 'Schließen', { dlg, fokus: await focusInfo(page) })
  const draft = await brief(page).locator('.hk-brief-entwurf').inputValue()
  check('pult: der Brief zeigt die Originalanfrage, den bearbeitbaren Entwurf und den sicheren Link „Anzeige öffnen“ (https, neuer Tab, noopener noreferrer)', (await textOf(brief(page).locator('.hk-brief-zitat'))).includes('Suche jemanden für eine einfache Website') && draft.startsWith('Hallo, ich habe Ihre Anzeige gesehen.') && (await brief(page).getByRole('link', { name: `Anzeige öffnen: ${T3.plat}`, exact: true }).getAttribute('href')) === HAIR_URL && (await brief(page).getByRole('link', { name: `Anzeige öffnen: ${T3.plat}`, exact: true }).getAttribute('rel')) === 'noopener noreferrer', draft)
  check('pult: Aktionen der Plattform-Antwort: Kopieren & öffnen, Ich kümmere mich, Als gesendet markieren, Antwort des Kunden einfügen, Verwerfen', same(await aktionen(page), ['Kopieren & öffnen', 'Ich kümmere mich', 'Als gesendet markieren', 'Antwort des Kunden einfügen', 'Verwerfen']), await aktionen(page))
  await shoot(page, 'j-brief-plattform.png')
  await page.keyboard.press('Escape')
  await brief(page).waitFor({ state: 'detached' })
  const nachEsc = await focusInfo(page)
  check('pult: Esc schließt den Brief, der Fokus liegt wieder auf dem Umschlag, der ihn geöffnet hat', nachEsc.cls.includes('hk-umschlag') && nachEsc.text.includes(T3.plat), nachEsc)

  // 3. „Ich kümmere mich“
  await openBrief(page, T3.plat)
  await stempel(page, 'Ich kümmere mich').click()
  await briefNote(page).waitFor()
  const claim = await callsOf(page, 'claim', 'pult-plat')
  check('pult: „Ich kümmere mich“ übernimmt den Eintrag (ein Aufruf claim), Meldung „Du kümmerst dich darum.“, der Knopf ist weg', claim.length === 1 && (await textOf(briefNote(page))) === 'Du kümmerst dich darum.' && (await stempel(page, 'Ich kümmere mich').count()) === 0, { claim, note: await textOf(briefNote(page)) })
  await shoot(page, 'j-brief-uebernommen.png')

  // 4. „Kopieren & öffnen“ mit bearbeitetem Text
  const edited = draft + '\nPS: Bearbeitet im Prüfstand.'
  await brief(page).locator('.hk-brief-entwurf').fill(edited)
  await resetStubs(page)
  await stempel(page, 'Kopieren & öffnen').click()
  await page.waitForFunction(() => { const el = document.querySelector('.hk-brief .hk-hinweis'); return el && el.textContent === 'Kopiert und geöffnet.' })
  const stub = await stubState(page)
  check('pult: „Kopieren & öffnen“ kopiert den bearbeiteten Text und öffnet genau die Anzeige im neuen Tab (noopener,noreferrer)', same(stub.clip, [edited]) && same(stub.opened, [[HAIR_URL, '_blank', 'noopener,noreferrer']]), stub)
  check('pult: „Kopieren & öffnen“ öffnet im Zug des Klicks (binnen 150 ms, Nutzer-Geste aktiv), ohne die Zwischenablage abzuwarten', stub.meta.length === 1 && stub.meta[0].sinceClick < 150 && stub.meta[0].active === true, stub.meta)
  check('pult: Meldung „Kopiert und geöffnet.“ (grün, role=status); der Eintrag war schon meiner, also kein zweites claim', (await briefNote(page).getAttribute('role')) === 'status' && /hk-hinweis-ok/.test(await briefNote(page).getAttribute('class')) && (await callsOf(page, 'claim', 'pult-plat')).length === 1)

  // 5. „Als gesendet markieren“: der Brief schließt, die Meldung steht im Klemmbrett und hat den Fokus
  await stempel(page, 'Als gesendet markieren').click()
  await meldungOf(page).first().waitFor()
  const fertig = await textOf(meldungOf(page).first())
  const sent = (await callsOf(page, 'sent', 'pult-plat')).pop()
  check('pult: „Als gesendet markieren“ schickt den bearbeiteten Text (body.text), der Brief schließt, die Meldung „…“ als gesendet markiert. steht im Klemmbrett (role=status)', fertig === `„${T3.plat}“ als gesendet markiert.` && (await meldungOf(page).first().getAttribute('role')) === 'status' && sent !== undefined && sent.body.text === edited && (await brief(page).count()) === 0, { fertig, sent })
  const fokus = await focusInfo(page)
  check('pult: nach dem Abschluss liegt der Fokus auf der Meldung (der Umschlag ist weg, der Fokus bleibt in der Nähe der Liste)', fokus.role === 'status' && fokus.text !== '' && fertig.startsWith(fokus.text), fokus)
  check('pult: der abgeschlossene Eintrag ist aus „Wartet“ verschwunden', !(await titlesOf(page)).includes(T3.plat), await titlesOf(page))
  await shoot(page, 'j-pult-gesendet.png')

  // 6. Interessent: das bestehende Panel im WOMS-Aussehen
  await openBrief(page, T3.mail)
  await brief(page).getByRole('button', { name: /^Interessent/ }).click()
  const panel = page.getByRole('dialog', { name: 'SV Namborn', exact: true })
  await panel.waitFor()
  await panel.locator('.wk-prospect').waitFor()
  await sleep(600) // der Dialog blendet ein
  const look = await panel.evaluate((el) => { const cs = getComputedStyle(el); return { bg: cs.backgroundColor, font: cs.fontFamily, bild: cs.imageRendering, woms: Boolean(el.closest('.hk-woms')), modal: el.getAttribute('aria-modal') } })
  check('pult: „Interessent“ öffnet das Panel im WOMS-Aussehen (weiße Box, WOMS-Schrift, kein Pixel-Rendering, aria-modal) mit Namen als Titel', look.bg === 'rgb(255, 255, 255)' && !/Pixelify|Press Start/.test(look.font) && look.bild !== 'pixelated' && look.woms && look.modal === 'true', look)
  const asked = await apiOf(page, 'prospectCalls')
  const score = await textOf(panel.locator('.wk-prospect-score'))
  check('pult: das Panel fragt nur den Interessenten p-mail ab und zeigt „Score 84 · hoch“ mit Begründung; kein Telefon im Bild', asked.length >= 1 && asked.every((id) => id === 'p-mail') && score.startsWith('Score 84 · hoch') && score.includes('Klarer Auftrag') && (await phoneFree(page)), { asked, score })
  check('pult: Nachrichtenverlauf mit „Interessent“ und „Justin“ (Name aus der Mitarbeiterliste)', same(await panel.locator('li.wk-prospect-msg strong').allTextContents(), ['Interessent', 'Justin']))
  await shoot(page, 'j-interessent-panel.png')
  await page.keyboard.press('Escape')
  await page.getByRole('dialog', { name: 'SV Namborn', exact: true }).waitFor({ state: 'detached' })
  const backFocus = await focusInfo(page)
  check('pult: Esc schließt nur das Panel (der Brief bleibt offen), der Fokus liegt wieder auf „Interessent“', (await brief(page).count()) === 1 && backFocus.text === 'Interessent', backFocus)

  // 7. Verwerfen mit Rückfrage (4 s), dann zwei Klicks
  const verwerfen = stempel(page, 'Verwerfen')
  await verwerfen.click()
  const frageName = stempel(page, 'Wirklich verwerfen?')
  check('pult: Verwerfen fragt beim ersten Klick „Wirklich verwerfen?“ (Stempel mit Rückfrage), noch keine Aktion am Dienst', (await frageName.count()) === 1 && (await frageName.getAttribute('class')).includes('hk-stempel-frage') && (await callsOf(page, 'discard')).length === 0)
  await shoot(page, 'j-brief-verwerfen-frage.png')
  await sleep(4400)
  check('pult: die Rückfrage verfällt nach 4 s (wieder „Verwerfen“)', (await stempel(page, 'Verwerfen').count()) === 1 && (await frageName.count()) === 0)
  await stempel(page, 'Verwerfen').click()
  await stempel(page, 'Wirklich verwerfen?').click()
  await page.waitForFunction((t) => { const el = document.querySelector('section.hk-klemmbrett > .hk-hinweis-ok'); return el && el.textContent === `„${t}“ verworfen.` }, T3.mail)
  const discards = await callsOf(page, 'discard')
  check('pult: zwei Klicks verwerfen genau einmal (Body {}: die Oberfläche schickt keinen Grund), Meldung „…“ verworfen., Brief zu, Umschlag weg', discards.length === 1 && discards[0].id === 'pult-mail' && same(discards[0].body, {}) && (await brief(page).count()) === 0 && !(await titlesOf(page)).includes(T3.mail), discards)

  // 8. Ein Kollege hat den Eintrag schon: „Kopieren & öffnen“ klappt, der Dienst antwortet 409
  await resetStubs(page)
  await openBrief(page, T3.koll)
  check('pult: Kollegen-Eintrag: kein „Ich kümmere mich“ im Brief', (await stempel(page, 'Ich kümmere mich').count()) === 0, await aktionen(page))
  await stempel(page, 'Kopieren & öffnen').click()
  await page.waitForFunction(() => { const el = document.querySelector('.hk-brief .hk-hinweis'); return el && el.textContent.length > 0 && el.textContent.includes('Justin') })
  const kollNote = briefNote(page)
  const kollStub = await stubState(page)
  check('pult: 409 beim Übernehmen: „Kopiert und geöffnet. Wird schon von Justin bearbeitet.“ als roter Hinweis (role=alert), Anzeige trotzdem kopiert und geöffnet', (await textOf(kollNote)) === 'Kopiert und geöffnet. Wird schon von Justin bearbeitet.' && (await kollNote.getAttribute('role')) === 'alert' && kollStub.clip.length === 1 && same(kollStub.opened, [[WEBER_URL, '_blank', 'noopener,noreferrer']]), { note: await textOf(kollNote), kollStub })
  await shoot(page, 'j-brief-409-kollege.png')
  await closeBrief(page)

  // 9. Reiter: Veraltet, Erledigt, Leerzustand, Ausfall mit „Neu laden“
  await reiterBtn(page, 'Veraltet').click()
  await waitTitles(page, [T3.alt])
  check('pult: „Veraltet“ zeigt den veralteten Eintrag mit der Marke „veraltet“, der Reiter ist gedrückt; Filterwechsel räumt die Meldung weg', (await textOf(umschlag(page, T3.alt))).includes('veraltet') && (await reiterBtn(page, 'Veraltet').getAttribute('aria-pressed')) === 'true' && (await meldungOf(page).count()) === 0)
  await shoot(page, 'j-pult-veraltet.png')
  await reiterBtn(page, 'Erledigt').click()
  await page.waitForFunction(() => document.querySelectorAll('.hk-umschlag').length === 4)
  const erledigt = await titlesOf(page)
  const gesText = await textOf(umschlag(page, T3.ges))
  check('pult: „Erledigt“ zeigt gesendet, verworfen und erledigt (auch die eben abgeschlossenen), Stempel mit Person und Zeitpunkt („Gesendet von Kenso · vor 1 Tag“)', [T3.ges, T3.erl, T3.plat, T3.mail].every((t) => erledigt.includes(t)) && gesText.includes('Gesendet von Kenso · vor 1 Tag'), { erledigt, gesText })
  await shoot(page, 'j-pult-erledigt.png')
  await page.evaluate(() => { window.__wk.api.pultEmpty = true })
  await reiterBtn(page, 'Wartet').click()
  await page.locator('.hk-leer-titel').waitFor()
  check('pult: Leerzustand „Nichts wartet auf dich“ mit Hinweis', (await textOf(page.locator('.hk-leer'))).startsWith('Nichts wartet auf dich') && (await textOf(page.locator('.hk-leer'))).includes('Neue Antworten erscheinen hier'), await textOf(page.locator('.hk-leer')))
  await shoot(page, 'j-pult-leer.png')
  await setFault(page, 'pult', { status: 503, message: PULT_DOWN })
  await reiterBtn(page, 'Veraltet').click()
  await page.getByRole('button', { name: 'Neu laden', exact: true }).waitFor()
  check('pult: Pult nicht erreichbar: „Das Pult ist gerade nicht erreichbar“ mit dem Satz des Dienstes und „Neu laden“', (await textOf(page.locator('.hk-leer'))).includes('Das Pult ist gerade nicht erreichbar') && (await textOf(page.locator('.hk-leer'))).includes(PULT_DOWN), await textOf(page.locator('.hk-leer')))
  await shoot(page, 'j-pult-ausfall.png')
  await setFault(page, 'pult', null)
  await page.getByRole('button', { name: 'Neu laden', exact: true }).click()
  await page.waitForFunction(() => (document.querySelector('.hk-leer-titel') || {}).textContent === 'Nichts ist veraltet')
  await page.evaluate(() => { window.__wk.api.pultEmpty = false })
  await reiterBtn(page, 'Wartet').click()
  await waitTitles(page, [T3.koll, T3.uns])
  check('pult: „Neu laden“ fragt erneut, danach ist die Liste wieder da (Kollege und „unsicher“)', true)
  await context.close()
}

// ---------- Szenario K: Pult mit den P4-Daten (?p4=1) ----------

async function pultP4(browser, base) {
  const { context, page } = await newStubPage(browser, 'pult-p4', { viewport: { width: 1280, height: 720 } })
  await openPult(page, base, P4_URL, 5)
  check('pult-p4: wartende Einträge neueste zuerst (Mail, zwei Freigaben, unsicher, Kollege)', same(await titlesOf(page), [T4.mail, T4.frei, T4.falsch, T4.uns, T4.koll]), await titlesOf(page))
  await shoot(page, 'k-pult-p4.png')

  // 1. Als Mensch antworten
  await openBrief(page, T4.mail)
  const draft = (await page.evaluate(() => window.__wk.api.pult('offen,in_arbeit'))).items.find((i) => i.$id === 'p4-mail').draft
  check('pult-p4: Mail-Brief: E-Mail schreiben, Ich kümmere mich, Als gesendet markieren, Als Mensch antworten, Verwerfen', same(await aktionen(page), ['E-Mail schreiben', 'Ich kümmere mich', 'Als gesendet markieren', 'Als Mensch antworten', 'Verwerfen']), await aktionen(page))
  const opener = stempel(page, 'Als Mensch antworten')
  check('pult-p4: vor dem Öffnen kein Antwortfeld, der Knopf trägt aria-expanded=false', (await page.locator('.hk-feld-antwort').count()) === 0 && (await opener.getAttribute('aria-expanded')) === 'false')
  await opener.click()
  const panel = page.locator('.hk-feld-antwort')
  await panel.waitFor()
  const area = panel.locator('textarea')
  const count = () => textOf(panel.locator('.hk-zaehler'))
  const send = panel.getByRole('button', { name: 'Jetzt senden', exact: true })
  check('pult-p4: „Als Mensch antworten“ klappt das Feld auf (aria-expanded=true), vorbelegt mit dem Entwurf, Zähler zeigt die Zeichen, Textfeld heißt „Text der Antwort: …“', (await opener.getAttribute('aria-expanded')) === 'true' && (await area.inputValue()) === draft && (await count()) === `${Array.from(draft.trim()).length} / 8000` && (await area.getAttribute('aria-label')) === `Text der Antwort: ${T4.mail}`, { count: await count() })
  await shoot(page, 'k-brief-antwort-offen.png')
  await area.fill('Hallo 😀')
  check('pult-p4: der Zähler zählt Zeichen (ein Emoji ist ein Zeichen: „7 / 8000“)', (await count()) === '7 / 8000', await count())
  await area.fill('')
  await send.click()
  await briefNote(page).waitFor()
  check('pult-p4: leerer Text ⇒ „Bitte einen Text eingeben.“ (rot, role=alert), kein Aufruf am Dienst', (await textOf(briefNote(page))) === NEED_TEXT && (await briefNote(page).getAttribute('role')) === 'alert' && (await callsOf(page, 'reply')).length === 0, await textOf(briefNote(page)))
  await area.fill('😀'.repeat(8001))
  check('pult-p4: 8001 Zeichen: Zähler „8001 / 8000“ ist rot (Klasse hk-zaehler-ueber)', (await count()) === '8001 / 8000' && (await panel.locator('.hk-zaehler').getAttribute('class')).includes('hk-zaehler-ueber'), await count())
  const answer = '  Guten Tag Herr Beispiel,\n\nanbei die Vorschau, wie besprochen.\n\nBeste Grüße\nKenso  \n'
  await area.fill(answer)
  await setFault(page, 'reply', { status: 409, message: CONFLICT })
  await send.click()
  await page.waitForFunction((t) => { const el = document.querySelector('.hk-brief .hk-hinweis'); return el && el.textContent === t }, CONFLICT)
  check('pult-p4: 409 ⇒ der Satz des Dienstes steht im Brief (rot, role=alert), Text und Feld bleiben, „Jetzt senden“ ist wieder frei', (await briefNote(page).getAttribute('role')) === 'alert' && (await area.inputValue()) === answer && (await send.isEnabled()), await textOf(briefNote(page)))
  await shoot(page, 'k-brief-antwort-409.png')
  await setFault(page, 'reply', { status: 409, message: GONE })
  await send.click()
  await page.waitForFunction((t) => { const el = document.querySelector('.hk-brief .hk-hinweis'); return el && el.textContent === t }, GONE)
  check('pult-p4: ein zweiter 409 ersetzt die Meldung („Dieser Kontakt ist nicht mehr aktiv.“), nicht angehäuft', (await briefNote(page).count()) === 1)
  await setFault(page, 'reply', { status: 0, message: 'Verbindung weg' })
  await send.click()
  await page.waitForFunction(() => { const el = document.querySelector('.hk-brief .hk-hinweis'); return el && el.textContent === 'Kann gesendet sein – Pult neu laden.' })
  check('pult-p4: Verbindungsabbruch beim Senden ⇒ „Kann gesendet sein – Pult neu laden.“ (nicht „nicht gesendet“), Text bleibt', (await area.inputValue()) === answer)
  await setFault(page, 'reply', null)
  const before = (await callsOf(page, 'reply')).length
  await page.evaluate(() => { window.__wk.api.pultDelayMs = 1500 })
  await send.click()
  const gesperrt = []
  for (const name of ['Ich kümmere mich', 'Als gesendet markieren', 'Als Mensch antworten', 'Verwerfen']) gesperrt.push(await stempel(page, name).isDisabled())
  check('pult-p4: während die Anfrage läuft sind „Jetzt senden“ und alle Stempel des Briefs gesperrt', (await send.isDisabled()) && gesperrt.every(Boolean), gesperrt)
  await send.evaluate((el) => el.click()) // ein zweiter Klick auf den gesperrten Knopf darf nichts auslösen
  await meldungOf(page).first().waitFor()
  const replyCalls = await callsOf(page, 'reply')
  const last = replyCalls[replyCalls.length - 1]
  check('pult-p4: Erfolg ⇒ Meldung „…“ gesendet. im Klemmbrett, Brief zu; genau ein Aufruf trotz Doppelklick, gesendet wird der getrimmte Text', (await textOf(meldungOf(page).first())) === `„${T4.mail}“ gesendet.` && (await brief(page).count()) === 0 && replyCalls.length === before + 1 && last.id === 'p4-mail' && same(last.body, { text: answer.trim() }), { replyCalls: replyCalls.length, before, last })
  await page.evaluate(() => { window.__wk.api.pultDelayMs = 0 })

  // 2. Vorschau freigeben (Rückfrage), falsche Adresse gesperrt
  await openBrief(page, T4.frei)
  const vorschau = brief(page).getByRole('link', { name: `Vorschau ansehen: ${T4.frei}`, exact: true })
  check('pult-p4: Freigabe-Brief: „Vorschau ansehen“ ist ein sicherer Link (https, neuer Tab, noopener noreferrer), Freigeben & senden und Verwerfen; „Verwerfen“ sendet die Vorschau nicht',
    (await vorschau.getAttribute('href')) === PREVIEW_URL && (await vorschau.getAttribute('target')) === '_blank' && (await vorschau.getAttribute('rel')) === 'noopener noreferrer'
    && (await stempel(page, 'Freigeben & senden').count()) === 1 && (await brief(page).textContent()).includes('„Verwerfen“ sendet die Vorschau nicht.'), await aktionen(page))
  await stempel(page, 'Freigeben & senden').click()
  const wirklich = stempel(page, 'Wirklich freigeben?')
  check('pult-p4: Freigeben fragt beim ersten Klick „Wirklich freigeben?“ (Stempel mit Rückfrage), noch keine Aktion am Dienst', (await wirklich.count()) === 1 && (await wirklich.getAttribute('class')).includes('hk-stempel-frage') && (await callsOf(page, 'approve-preview')).length === 0)
  await shoot(page, 'k-brief-freigeben-frage.png')
  await wirklich.click()
  await page.waitForFunction((t) => { const el = document.querySelector('section.hk-klemmbrett > .hk-hinweis-ok'); return el && el.textContent === `„${t}“ freigegeben. Max sendet den Link im nächsten Sendefenster.` }, T4.frei)
  const freigaben = await callsOf(page, 'approve-preview')
  check('pult-p4: zweiter Klick gibt frei (genau ein Aufruf approve-preview), Meldung „… freigegeben. Max sendet den Link im nächsten Sendefenster.“', freigaben.length === 1 && freigaben[0].id === 'p4-freigabe', freigaben)
  await openBrief(page, T4.falsch)
  const nurSperre = await stempel(page, 'Freigeben & senden').isDisabled()
  check('pult-p4: Vorschau mit falscher Adresse (kein https): kein Link „Vorschau ansehen“, Hinweis „Keine gültige Vorschau-Adresse hinterlegt.“, „Freigeben & senden“ gesperrt', (await brief(page).getByRole('link', { name: /^Vorschau ansehen/ }).count()) === 0 && (await brief(page).textContent()).includes('Keine gültige Vorschau-Adresse hinterlegt.') && nurSperre)
  await closeBrief(page)

  // 3. Vorschau bauen (Rückfrage mit Hinweis)
  await openBrief(page, T4.uns)
  check('pult-p4: „unsicher“-Brief: Ich kümmere mich, Als Mensch antworten, Vorschau bauen, Erledigt, Verwerfen (kein Mail-Link, kein Entwurf)', same(await aktionen(page), ['Ich kümmere mich', 'Als Mensch antworten', 'Vorschau bauen', 'Erledigt', 'Verwerfen']) && (await brief(page).locator('textarea').count()) === 0, await aktionen(page))
  await stempel(page, 'Vorschau bauen').click()
  const bauen = stempel(page, 'Wirklich bauen?')
  const hinweis = await textOf(brief(page).locator('.hk-brief-hinweis-bau'))
  check('pult-p4: „Vorschau bauen“ fragt beim ersten Klick „Wirklich bauen?“ und nennt den Hinweis „Startet einen Opus-Lauf …“, noch keine Aktion am Dienst', (await bauen.count()) === 1 && hinweis === BUILD_HINT && (await callsOf(page, 'start-build')).length === 0, { hinweis })
  await shoot(page, 'k-brief-bauen-frage.png')
  await bauen.click()
  await page.waitForFunction((t) => { const el = document.querySelector('section.hk-klemmbrett > .hk-hinweis-ok'); return el && el.textContent === `„${t}“ wird gebaut.` }, T4.uns)
  const builds = await callsOf(page, 'start-build')
  check('pult-p4: zweiter Klick startet den Bau (genau ein Aufruf start-build), Meldung „…“ wird gebaut.', builds.length === 1 && builds[0].id === 'p4-unsicher', builds)

  // 4. Antwort des Kunden einfügen (bei den gesendeten Plattform-Antworten, Reiter „Erledigt“)
  await reiterBtn(page, 'Erledigt').click()
  await page.waitForFunction((t) => [...document.querySelectorAll('.hk-umschlag-titel')].some((el) => el.textContent === t), T4.plat)
  const gesendet = await titlesOf(page)
  check('pult-p4: „Erledigt“ zeigt die beiden gesendeten Plattform-Antworten des Interessenten (Standard-Platz und „Angebot“) und die eben abgeschlossenen Einträge', gesendet.includes(T4.plat) && gesendet.includes(T4.ang) && gesendet.includes(T4.mail) && gesendet.includes(T4.frei) && gesendet.includes(T4.uns), gesendet)
  await openBrief(page, T4.plat)
  check('pult-p4: gesendete Plattform-Antwort: einziger Stempel „Antwort des Kunden einfügen“', same(await aktionen(page), ['Antwort des Kunden einfügen']), await aktionen(page))
  await stempel(page, 'Antwort des Kunden einfügen').click()
  const paste = page.locator('.hk-feld-einfuegen')
  await paste.waitFor()
  const pasteArea = paste.locator('textarea')
  check('pult-p4: das Einfüge-Feld ist leer, trägt den Hinweis „Kopiere die Antwort aus der Plattform hierher …“ und heißt „Antwort des Kunden: …“', (await pasteArea.inputValue()) === '' && (await textOf(paste.locator('.hk-brief-hinweis'))) === PASTE_HINT && (await pasteArea.getAttribute('aria-label')) === `Antwort des Kunden: ${T4.plat}`)
  await shoot(page, 'k-brief-einfuegen.png')
  const kunde = 'Danke für die Vorschau. Gern ein Angebot für die Seite.'
  await pasteArea.fill(kunde)
  await paste.getByRole('button', { name: 'Einfügen', exact: true }).click()
  await page.waitForFunction(() => { const el = document.querySelector('.hk-brief .hk-hinweis'); return el && el.textContent === 'Eingefügt. Nora sortiert die Antwort ein.' })
  const pastes = await callsOf(page, 'paste')
  check('pult-p4: „Einfügen“ schickt die Antwort (ein Aufruf paste mit { text }), Meldung „Eingefügt. Nora sortiert die Antwort ein.“, Feld geleert und zugeklappt', pastes.length === 1 && pastes[0].id === 'p4-plat-gesendet' && same(pastes[0].body, { text: kunde }) && (await page.locator('.hk-feld-einfuegen').count()) === 0, pastes)
  await stempel(page, 'Antwort des Kunden einfügen').click()
  await page.locator('.hk-feld-einfuegen textarea').fill(kunde)
  await page.locator('.hk-feld-einfuegen').getByRole('button', { name: 'Einfügen', exact: true }).click()
  await page.waitForFunction(() => { const el = document.querySelector('.hk-brief .hk-hinweis'); return el && el.textContent === 'Diese Antwort war schon eingefügt.' })
  check('pult-p4: dieselbe Antwort ein zweites Mal ⇒ „Diese Antwort war schon eingefügt.“', true)
  check('pult-p4: kein Telefon im Bild (weder Wort noch Nummer)', await phoneFree(page))
  await context.close()
}

// ---------- Szenario L: Keller (Bot-Leads) ----------
// Daten der Skript-API (scripted-api.js, „Bot-Leads (P6)“): 60 sichtbare Einträge (je 15 in den vier Räumen; Seite 1 hat 50, Seite 2 hat 10), drei gekürzte Stubs
// (nur mit ?bot=<Id> zu sehen), Heilberufe mit Altbestand-Telefon im Speicher, eine http-Quelle und zwei feindliche Quellen (javascript:, Zugangsdaten).
// Was die Oberfläche angefragt hat, steht in window.__wk.api.botleadCalls.

const KELLER_URL = '/index.html?fault=none&tab=botleads'
const BL = { health: 'bl-aerzte-01', http: 'bl-handwerk-02', javascript: 'bl-laden-04', credentials: 'bl-selbst-03', long: 'bl-handwerk-01', cut: 'bl-gekuerzt-01' }
const BL_HEALTH_PHONE = 'bewusst nicht gespeichert'
const BL_NO_PHONE = 'nicht verfügbar'
const BL_HINT = 'Reine Liste: keine Anrufe, kein Mailversand.'

const zeilen = (page) => page.locator('.hk-zeile')
const blCalls = (page) => apiOf(page, 'botleadCalls')
const blSeiten = (page) => page.evaluate(() => { const el = document.querySelector('.hk-kl-seiten'); return el ? el.textContent.trim() : null })
// Fertig geladen: kein „Wird geladen …“ mehr und Zeilen, Leerzustand oder Fehler da
const blSettled = (page) => page.waitForFunction(() => !document.querySelector('.hk-kl-laden') && Boolean(document.querySelector('.hk-zeile, .hk-kl-leer, .hk-kl-fehler')))
const blTabOf = (page) => new URL(page.url()).searchParams.get('tab')
const akteOf = (page) => page.evaluate(() => {
  const dl = {}
  document.querySelectorAll('.hk-kl-akte-dl dt').forEach((dt) => { dl[dt.textContent.trim()] = dt.nextElementSibling ? dt.nextElementSibling.textContent.replace(/\s+/g, ' ').trim() : null })
  const a = document.querySelector('.hk-akte-link')
  return {
    titel: (document.querySelector('.hk-kl-akte-name') || {}).textContent || '',
    raum: ((document.querySelector('.hk-kl-akte-raum') || {}).textContent || '').replace(/\s+/g, ' ').trim(),
    dl,
    link: a ? { href: a.getAttribute('href'), target: a.getAttribute('target'), rel: a.getAttribute('rel'), name: a.getAttribute('aria-label') } : null,
    erklaerung: ((document.querySelector('.hk-kl-akte-erklaerung') || {}).textContent || '').trim(),
    zaehler: ((document.querySelector('.hk-kl-sr') || {}).textContent || '').trim(),
    text: document.querySelector('.hk-akte').textContent,
  }
})

async function keller(browser, base) {
  const { context, page } = await newPage(browser, 'keller', { viewport: { width: 1280, height: 720 } })
  await page.goto(base + KELLER_URL)
  await page.locator('.hk-keller .hk-kl-szene').waitFor()
  await blSettled(page)
  await page.waitForFunction(() => (document.querySelector('.hk-kl-zahl') || {}).textContent === '112')
  await settleFonts(page)
  const t0 = Date.now()
  await sleep(300)

  // 1. Arne döst, solange er nicht arbeitet: Schleife, Rohrpost, Schublade und Stempel ruhen
  const ruhe = await page.evaluate(() => ({
    arne: document.querySelector('.hk-kl-szene').getAttribute('data-hk-arne'),
    weg: document.querySelectorAll('.hk-arne-weg').length,
    ruht: document.querySelectorAll('.hk-kl-ruht').length,
    schlaeft: document.querySelectorAll('.hk-kl-fig-schlafen').length,
    zzz: document.querySelectorAll('.hk-kl-zzz').length,
  }))
  check('keller: Arne im Leerlauf döst am Pult (Haus-Figur „schlafen“ mit Zzz), die Ablage-Schleife läuft nicht, Rohrpost, Schublade und Stempel ruhen', ruhe.arne === 'leerlauf' && ruhe.weg === 0 && ruhe.ruht === 3 && ruhe.schlaeft === 1 && ruhe.zzz === 1, ruhe)
  await shoot(page, 'l-keller-arne-doest.png')

  // 2. Aufbau: Schild, Raum-Reiter, Register-Buch, 50 Zeilen, Seitenzeile
  const kopf = await page.evaluate(() => ({
    titel: document.querySelector('.hk-kl-titel').textContent,
    zahl: document.querySelector('.hk-kl-zahl').textContent,
    knoepfe: [...document.querySelectorAll('.hk-kl-knopf-klein')].map((b) => b.getAttribute('aria-label')),
    reiter: [...document.querySelectorAll('.hk-kl-reiter button')].map((b) => ({ pressed: b.getAttribute('aria-pressed'), label: b.getAttribute('aria-label') })),
    buch: document.querySelector('.hk-buch').getAttribute('aria-label'),
    hinweis: (document.querySelector('.hk-kl-hinweis') || {}).textContent,
    spalten: [...document.querySelectorAll('.hk-kopfzeile span')].map((s) => s.textContent.trim()).filter(Boolean),
  }))
  check('keller: Messingschild „Bot-Leads“ mit der Zahl 112, Knöpfe „Zurück zum Hochhaus“ und „Register zuklappen“, Hinweis „Reine Liste: keine Anrufe, kein Mailversand.“',
    kopf.titel === 'Bot-Leads' && kopf.zahl === '112' && same(kopf.knoepfe, ['Zurück zum Hochhaus', 'Register zuklappen']) && kopf.hinweis === BL_HINT && kopf.buch === 'Nie-doppelt-Register', kopf)
  check('keller: fünf Raum-Reiter (Alle + vier Räume), „Alle“ gedrückt mit „60 Einträge“; Spalten Betrieb, Punkte, Grund, Telefon',
    kopf.reiter.length === 5 && kopf.reiter[0].pressed === 'true' && kopf.reiter.slice(1).every((r) => r.pressed === 'false') && kopf.reiter[0].label === 'Alle Räume, 60 Einträge' && kopf.spalten.some((t) => t.startsWith('Betrieb')) && kopf.spalten.includes('Punkte') && kopf.spalten.includes('Grund') && kopf.spalten.includes('Telefon'), kopf)
  check('keller: Seite 1 zeigt 50 Zeilen, Seitenzeile „Seite 1 von 2 · 60 Einträge“, jede Zeile ist ein Knopf mit Namen', (await zeilen(page).count()) === 50 && (await blSeiten(page)) === 'Seite 1 von 2 · 60 Einträge' && (await page.evaluate(() => [...document.querySelectorAll('.hk-zeile')].every((b) => b.tagName === 'BUTTON' && (b.getAttribute('aria-label') || '').length > 5))), { seiten: await blSeiten(page) })
  await shoot(page, 'l-keller-liste.png')

  // 3. Suche (mit Verzögerung), Raum-Reiter, Blättern
  const search = page.getByLabel('Betriebe suchen', { exact: true })
  const anfragenVorher = (await blCalls(page)).length
  await search.fill('Bäckerei')
  await page.waitForFunction(() => window.__wk.api.botleadCalls.some((c) => c.q === 'Bäckerei'))
  await blSettled(page)
  const erwartet = await page.evaluate(() => window.__wk.api.botleads({ q: 'Bäckerei' }))
  const gefunden = await zeilen(page).count()
  check('keller: Suche „Bäckerei“ fragt den Dienst (eine Anfrage nach der Verzögerung) und zeigt genau dessen Treffer', gefunden === erwartet.items.length && gefunden >= 1 && (await textOf(page.locator('.hk-kl-name').first())).includes('Bäckerei'), { gefunden, erwartet: erwartet.items.length })
  await shoot(page, 'l-keller-suche.png')
  await search.fill('')
  await page.waitForFunction(() => window.__wk.api.botleadCalls.at(-1).q === '')
  await blSettled(page)
  const nachSuche = (await blCalls(page)).length - anfragenVorher
  check('keller: leere Suche zeigt wieder 50 Zeilen; die Verzögerung hält die Anfragen niedrig (höchstens zwei Anfragen für das Tippen und das Leeren)', (await zeilen(page).count()) === 50 && nachSuche <= 3, { nachSuche })
  await page.locator('.hk-kl-reiter button', { hasText: 'Ärzte' }).click()
  await page.waitForFunction(() => window.__wk.api.botleadCalls.at(-1).room === 'aerzte')
  await blSettled(page)
  check('keller: Reiter „Ärzte“ fragt room=aerzte, zeigt 15 Zeilen, „Seite 1 von 1 · 15 Einträge“, keine Blätterknöpfe', (await zeilen(page).count()) === 15 && (await blSeiten(page)) === 'Seite 1 von 1 · 15 Einträge' && (await page.getByRole('button', { name: 'Nächste Seite' }).count()) === 0, await blSeiten(page))
  await page.locator('.hk-kl-reiter button', { hasText: 'Alle' }).click()
  await blSettled(page)
  await page.getByRole('button', { name: 'Nächste Seite', exact: true }).click()
  await page.waitForFunction(() => (document.querySelector('.hk-kl-seiten') || {}).textContent === 'Seite 2 von 2 · 60 Einträge')
  await blSettled(page)
  const seite2 = await blCalls(page)
  const fokusBlaettern = await focusInfo(page)
  check('keller: „Nächste Seite“ zeigt Seite 2 (10 Zeilen, page=2 am Dienst); der Fokus geht auf einen Blätterknopf zurück (der gedrückte ist gesperrt, also der andere)', (await zeilen(page).count()) === 10 && seite2.at(-1).page === 2 && ['Vorherige Seite', 'Nächste Seite'].includes(fokusBlaettern.label), { fokusBlaettern, letzte: seite2.at(-1) })
  await shoot(page, 'l-keller-seite-2.png')
  await page.getByRole('button', { name: 'Vorherige Seite', exact: true }).click()
  await page.waitForFunction(() => (document.querySelector('.hk-kl-seiten') || {}).textContent === 'Seite 1 von 2 · 60 Einträge')
  await blSettled(page)

  // 4. Akte: Heilberuf ohne Nummer, Quelle als sicherer Link, Blättern, Esc mit Fokus zurück auf die Zeile
  await zeilen(page).first().click()
  const akteDialog = page.getByRole('dialog', { name: 'Akte Praxis Dr. Lindner', exact: true })
  await akteDialog.waitFor()
  await sleep(350)
  const a0 = await akteOf(page)
  const heilNummern = await apiOf(page, 'botleadsHealthPhones')
  check('keller: Akte (role=dialog, aria-modal) zu „Praxis Dr. Lindner“: Raum „Ärzte & Praxen“ mit Scout, Punkte, Grund mit Erklärung, Gefunden; der Fokus liegt auf „Schließen“',
    (await akteDialog.getAttribute('aria-modal')) === 'true' && a0.raum.startsWith('Ärzte & Praxen · gefunden von') && /Punkte/.test(a0.dl.Punkte || '') && a0.dl.Grund !== '' && a0.erklaerung !== '' && (a0.dl.Gefunden || '') !== '' && (await focusInfo(page)).label === 'Schließen', { a0, fokus: await focusInfo(page) })
  check('keller: Heilberuf – Telefon „bewusst nicht gespeichert“, keine der im Speicher liegenden Nummern erscheint irgendwo (auch nicht im HTML)', a0.dl.Telefon === BL_HEALTH_PHONE && heilNummern.length >= 1 && (await page.evaluate((nummern) => { const html = document.documentElement.outerHTML; return nummern.every((n) => !html.includes(n)) }, heilNummern)), { telefon: a0.dl.Telefon, nummern: heilNummern.length })
  check('keller: Quelle ist ein sicherer Link (https, neuer Tab, noopener noreferrer) mit Namen „Quelle öffnen: …“', a0.link !== null && /^https:\/\/www\.11880\.com\/branchenbuch\//.test(a0.link.href) && a0.link.target === '_blank' && a0.link.rel === 'noopener noreferrer' && a0.link.name === 'Quelle öffnen: Praxis Dr. Lindner', a0.link)
  check('keller: die Akte kündigt sich Screenreadern an („Akte 1 von 50: …“) und sagt, dass nichts verschickt wird', a0.zaehler === 'Akte 1 von 50: Praxis Dr. Lindner' && a0.text.includes('Nur zum Nachsehen, hier wird nichts verschickt.'), a0.zaehler)
  await shoot(page, 'l-akte.png')
  // durch die Akten blättern: Heilberufe nie mit Nummer, alle anderen mit Nummer (Quelle belegt) oder „nicht verfügbar“
  const besucht = [a0]
  for (let i = 0; i < 14; i += 1) {
    await page.keyboard.press('ArrowRight')
    await page.waitForFunction((n) => (document.querySelector('.hk-kl-sr') || {}).textContent.startsWith(`Akte ${n} von 50`), i + 2)
    besucht.push(await akteOf(page))
  }
  const nummer = /^0\d{3} 555 \d{4}$/
  check('keller: → blättert durch die Akten (im Kreis, innerhalb der Seite); Heilberufe nie mit Nummer, alle anderen mit Nummer oder „nicht verfügbar“, mindestens eine mit Nummer',
    besucht.every((a) => (a.raum.startsWith('Ärzte & Praxen') ? a.dl.Telefon === BL_HEALTH_PHONE : (a.dl.Telefon === BL_HEALTH_PHONE || a.dl.Telefon === BL_NO_PHONE || nummer.test(a.dl.Telefon)))) && besucht.some((a) => nummer.test(a.dl.Telefon)), besucht.map((a) => [a.titel, a.raum.slice(0, 14), a.dl.Telefon]))
  for (let i = 0; i < 14; i += 1) await page.keyboard.press('ArrowLeft')
  await page.waitForFunction(() => (document.querySelector('.hk-kl-sr') || {}).textContent.startsWith('Akte 1 von 50'))
  await page.keyboard.press('Escape')
  await page.getByRole('dialog').waitFor({ state: 'detached' })
  check('keller: Esc schließt die Akte, der Fokus liegt wieder auf der Zeile, die sie geöffnet hat', (await focusInfo(page)).zeile === '0', await focusInfo(page))

  // 5. Fehler des Dienstes: Satz, „Erneut versuchen“
  await setFault(page, 'botleads', { status: 503, message: 'Der Hustler-Dienst ist gerade nicht erreichbar.' })
  await page.locator('.hk-kl-reiter button', { hasText: 'Handwerk' }).click()
  await page.locator('.hk-kl-fehler').waitFor()
  check('keller: Fehler des Dienstes zeigt den Satz (role=alert) mit „Erneut versuchen“, keine Zeilen', (await textOf(page.locator('.hk-kl-fehler'))) === 'Der Hustler-Dienst ist gerade nicht erreichbar.' && (await page.locator('.hk-kl-fehler').getAttribute('role')) === 'alert' && (await page.getByRole('button', { name: 'Erneut versuchen', exact: true }).count()) === 1 && (await zeilen(page).count()) === 0)
  await shoot(page, 'l-keller-fehler.png')
  await setFault(page, 'botleads', null)
  await page.getByRole('button', { name: 'Erneut versuchen', exact: true }).click()
  await page.waitForFunction(() => document.querySelectorAll('.hk-zeile').length === 15)
  check('keller: „Erneut versuchen“ fragt dieselbe Anfrage noch einmal (Handwerk, 15 Zeilen)', true)

  // 6. Arne wird zur Arbeit gerufen: das Drehbuch lässt ihn nach 8 s „doppelt“ melden, dann läuft die Ablage-Schleife
  let arbeitet = false
  while (Date.now() - t0 < 40000) {
    arbeitet = (await page.locator('.hk-kl-szene').getAttribute('data-hk-arne')) === 'arbeitet'
    if (arbeitet) break
    await sleep(300)
  }
  const regung = await page.evaluate(() => ({ weg: document.querySelectorAll('.hk-arne-weg').length, ruht: document.querySelectorAll('.hk-kl-ruht').length, daheim: document.querySelectorAll('.hk-kl-arne').length }))
  check('keller: Arne arbeitet (nach dem Ereignis des Drehbuchs): die Ablage-Schleife läuft, Rohrpost, Schublade und Stempel ruhen nicht mehr, er sitzt nicht mehr am Pult', arbeitet && regung.weg === 1 && regung.ruht === 0 && regung.daheim === 0, regung)
  await shoot(page, 'l-keller-arne-arbeitet.png')

  // 7. Zuklappen: nur die Szene bleibt
  await page.getByRole('button', { name: 'Register zuklappen', exact: true }).click()
  await page.waitForFunction(() => document.querySelectorAll('.hk-buch').length === 0)
  check('keller: „Register zuklappen“ zeigt nur die Szene (Buch weg, Knopf heißt „Register aufklappen“, aria-expanded=false)', (await page.getByRole('button', { name: 'Register aufklappen', exact: true }).getAttribute('aria-expanded')) === 'false')
  await shoot(page, 'l-keller-zugeklappt.png')

  // 8. Quellen mit Haken: nie ein javascript:-Link, nie ein Link mit Zugangsdaten; http ist erlaubt
  const quelle = async (id, name) => {
    await page.goto(base + KELLER_URL + '&bot=' + id)
    await blSettled(page)
    await zeilen(page).first().click()
    await page.getByRole('dialog', { name: `Akte ${name}`, exact: true }).waitFor()
    await sleep(250)
    return akteOf(page)
  }
  const js = await quelle(BL.javascript, 'Restaurant Zum Hirschen')
  const cr = await quelle(BL.credentials, 'Fotografie Lichtblick')
  const ht = await quelle(BL.http, 'Elektro Hartmann GmbH')
  check('keller: Quelle „javascript:…“ und Quelle mit Zugangsdaten in der Adresse werden nie ein Link (Anzeige „–“), http ist ein Link mit http-Adresse',
    js.link === null && js.dl.Quelle === '–' && cr.link === null && cr.dl.Quelle === '–' && ht.link !== null && /^http:\/\/www\.elektro-hartmann-alt\.example\//.test(ht.link.href) && (await page.locator('a[href^="javascript:" i]').count()) === 0, { js: js.dl.Quelle, cr: cr.dl.Quelle, ht: ht.link })
  await page.keyboard.press('Escape')
  await page.getByRole('dialog').waitFor({ state: 'detached' })

  // 9. Einzelansicht (?bot=): ein Eintrag, hervorgehoben, „Alle anzeigen“ (Link aus dem Ereignisstrom)
  await page.goto(base + KELLER_URL + '&bot=' + BL.health)
  await blSettled(page)
  const einzel = await page.evaluate(() => ({ zeilen: document.querySelectorAll('.hk-zeile').length, aktuell: document.querySelector('.hk-zeile').getAttribute('aria-current'), reiter: document.querySelectorAll('.hk-kl-reiter').length, suche: document.querySelectorAll('.hk-suche').length, text: (document.querySelector('.hk-kl-einzeln-text') || {}).textContent }))
  check('keller: ?bot=<Id> zeigt genau einen Eintrag (hervorgehoben, aria-current) mit „Alle anzeigen“, ohne Raum-Reiter und Suche', einzel.zeilen === 1 && einzel.aktuell === 'true' && einzel.reiter === 0 && einzel.suche === 0 && einzel.text === 'Einzelner Eintrag aus dem Ereignisstrom' && (await page.getByRole('button', { name: 'Alle anzeigen', exact: true }).count()) === 1, einzel)
  await shoot(page, 'l-keller-einzelansicht.png')
  await page.getByRole('button', { name: 'Alle anzeigen', exact: true }).click()
  await blSettled(page)
  await page.waitForFunction(() => document.querySelectorAll('.hk-zeile').length === 50)
  check('keller: „Alle anzeigen“ führt zur Liste (50 Zeilen, Raum-Reiter wieder da, bot nicht mehr in der Adresse), der aktive Reiter bekommt den Fokus', new URL(page.url()).searchParams.get('bot') === null && blTabOf(page) === 'botleads' && (await page.locator('.hk-kl-reiter').count()) === 1 && (await focusInfo(page)).cls.includes('hk-reiter'), { url: page.url(), fokus: await focusInfo(page) })
  // gekürzter Stub nur mit Kennung
  await page.goto(base + KELLER_URL + '&bot=' + BL.cut)
  await blSettled(page)
  await zeilen(page).first().click()
  await page.getByRole('dialog', { name: 'Akte [gekürzt]', exact: true }).waitFor()
  await sleep(250)
  const gekuerzt = await akteOf(page)
  check('keller: gekürzter Eintrag (nur mit Kennung): Akte mit „Kürzung: gekürzt“, ohne Quelle und ohne Telefonnummer', gekuerzt.dl.Kürzung === 'gekürzt' && gekuerzt.link === null && !nummer.test(gekuerzt.dl.Telefon), gekuerzt.dl)
  await shoot(page, 'l-akte-gekuerzt.png')
  await page.keyboard.press('Escape')

  // 10. Leer (?botleads=leer)
  await page.goto(base + KELLER_URL + '&botleads=leer')
  await blSettled(page)
  check('keller: leere Liste zeigt „Noch keine Bot-Leads.“ mit Hinweis, keine Zeilen', (await textOf(page.locator('.hk-kl-leer-titel'))) === 'Noch keine Bot-Leads.' && (await zeilen(page).count()) === 0 && (await textOf(page.locator('.hk-kl-leer-text'))).includes('Betriebe, die nicht angeschrieben werden'))
  await shoot(page, 'l-keller-leer.png')
  await context.close()
}

// ---------- Szenario M: Pult und Keller am Handy (390 x 844) ----------

// Knöpfe und Links eines Bereichs: jeder wird erst in den sichtbaren Teil seiner Liste gerollt (scrollIntoView nearest), dann gemessen: Lage, Höhe in px
// (Tippfläche) und ob die Mitte von einem anderen Element verdeckt wird. Das verändert die Rollstände: Bilder werden vorher aufgenommen.
const reachOf = (page, selector) => page.evaluate((sel) => {
  const out = []
  for (const el of document.querySelectorAll(sel)) {
    el.scrollIntoView({ block: 'nearest', inline: 'nearest' })
    const r = el.getBoundingClientRect()
    const hit = document.elementFromPoint(r.left + r.width / 2, r.top + r.height / 2)
    out.push({ text: (el.textContent || el.getAttribute('aria-label') || '').trim().slice(0, 28), left: Math.round(r.left), right: Math.round(r.right), height: Math.round(r.height), covered: !(hit && (hit === el || el.contains(hit))) })
  }
  return out
}, selector)
// Verstöße: außerhalb der Breite des Fensters (außer bei horizontal=false: scrollbare Reiterleiste), verdeckt oder niedriger als minHeight
const badReach = (list, minHeight = 40, horizontal = true) => list.filter((r) => (horizontal && (r.left < 0 || r.right > 390)) || r.covered || r.height < minHeight)

async function handyPultKeller(browser, base) {
  const phone = { viewport: { width: 390, height: 844 }, deviceScaleFactor: 2, isMobile: true, hasTouch: true }
  const { context, page } = await newStubPage(browser, 'handy-pult', phone)
  await openPult(page, base, PULT_URL, 4)

  // Pult: Klemmbrett in voller Breite über der Szene
  const w0 = await widthOf(page)
  const brett = await rectOf(page.locator('.hk-klemmbrett'))
  const pultBox = await rectOf(page.locator('.hk-pult'))
  metrics.handyPult = { brett, pult: pultBox }
  check('handy pult: kein waagrechtes Scrollen, das Klemmbrett nimmt die volle Breite (mindestens 358 von 390 px)', noSideScroll(w0) && brett.w >= 358 && brett.x >= 0 && brett.r <= 390, { w0, brett })
  await shoot(page, 'm-pult-liste.png')
  const bedien = badReach(await reachOf(page, '.hk-reiter-leiste .hk-reiter, .hk-pult-knopf'))
  const umschlaege = badReach(await reachOf(page, '.hk-umschlag'), 44)
  check('handy pult: Reiter und Knöpfe oben mindestens 40 px hoch und im Bild, Umschläge mindestens 44 px hoch, nichts verdeckt', bedien.length === 0 && umschlaege.length === 0, { bedien, umschlaege })

  // Brief als Vollbild (der Umschlag mit dem langen Wort ohne Leerzeichen prüft den Umbruch)
  await umschlag(page, T3.mail).tap()
  await brief(page).waitFor()
  await sleep(400)
  const bb = await rectOf(brief(page))
  const wB = await widthOf(page)
  await shoot(page, 'm-pult-brief.png')
  const aktB = badReach(await reachOf(page, '.hk-brief .hk-aktionen button, .hk-brief .hk-aktionen a, .hk-brief .hk-brief-zu'))
  check('handy pult: der Brief füllt die Fläche als Vollbild (volle Breite, volle Höhe des Pults), kein waagrechtes Scrollen trotz langem Wort im Text', bb.w >= 385 && bb.h >= pultBox.h - 8 && noSideScroll(wB), { bb, pult: pultBox, wB })
  check('handy pult: Schließen und alle Stempel im Brief mindestens 40 px hoch, im Bild und nicht verdeckt', aktB.length === 0, aktB)
  const linksB = badReach(await reachOf(page, '.hk-brief-meta .hk-link'))
  check('handy pult: die Textlinks „Anzeige öffnen“ und „Interessent“ im Kopf des Briefs sind mindestens 40 px hoch (Tippfläche)', linksB.length === 0, linksB)
  await stempel(page, 'Als Mensch antworten').tap()
  await page.locator('.hk-feld-antwort textarea').waitFor()
  await sleep(300)
  const wA = await widthOf(page)
  const ta = await rectOf(page.locator('.hk-feld-antwort textarea'))
  check('handy pult: das aufgeklappte Antwortfeld passt in die Breite (kein waagrechtes Scrollen), das Textfeld steht im Bild', noSideScroll(wA) && ta.x >= 0 && ta.r <= 390, { wA, ta })
  await shoot(page, 'm-pult-brief-antwort.png')
  // Interessent: WOMS-Dialog als Bottom-Sheet im Bild
  await brief(page).getByRole('button', { name: /^Interessent/ }).tap()
  const sheet = page.getByRole('dialog', { name: 'SV Namborn', exact: true })
  await sheet.waitFor()
  await sheet.locator('.wk-prospect').waitFor()
  await sleep(600)
  const sb = await rectOf(sheet)
  const wS = await widthOf(page)
  check('handy pult: das Interessenten-Panel steht im Bild (Bottom-Sheet), nichts läuft über den Rand', sb.x >= 0 && sb.r <= 390 && sb.b <= 844 && noSideScroll(wS), { sb, wS })
  await shoot(page, 'm-pult-interessent.png')
  await page.keyboard.press('Escape')
  await sheet.waitFor({ state: 'detached' })
  await page.getByRole('button', { name: 'Schließen', exact: true }).tap()
  await brief(page).waitFor({ state: 'detached' })
  // zuklappen: die Szene bleibt
  await page.getByRole('button', { name: 'Pult zuklappen', exact: true }).tap()
  await page.waitForFunction(() => document.querySelectorAll('.hk-klemmbrett').length === 0)
  await sleep(300)
  await shoot(page, 'm-pult-zugeklappt.png')
  check('handy pult: „Pult zuklappen“ zeigt die Szene ganz (Klemmbrett weg, Knopf heißt „Pult aufklappen“)', (await page.getByRole('button', { name: 'Pult aufklappen', exact: true }).count()) === 1)

  // Keller
  await page.goto(base + KELLER_URL)
  await page.locator('.hk-keller .hk-kl-szene').waitFor()
  await blSettled(page)
  await settleFonts(page)
  await sleep(400)
  const wK = await widthOf(page)
  const buch = await rectOf(page.locator('.hk-buch'))
  const kellerBox = await rectOf(page.locator('.hk-keller'))
  metrics.handyKeller = { buch, keller: kellerBox }
  check('handy keller: kein waagrechtes Scrollen, das Register-Buch nimmt die volle Breite (mindestens 358 von 390 px)', noSideScroll(wK) && buch.w >= 358 && buch.x >= 0 && buch.r <= 390, { wK, buch })
  await shoot(page, 'm-keller-liste.png')
  const kBedien = badReach(await reachOf(page, '.hk-kl-knopf-klein, .hk-kl-fuss button')).concat(badReach(await reachOf(page, '.hk-kl-reiter button'), 40, false))
  const kZeilen = (await reachOf(page, '.hk-zeile')).filter((r) => r.left < 0 || r.right > 390 || r.height < 44)
  const kSuche = badReach(await reachOf(page, '.hk-suche'))
  check('handy keller: Reiter, Knöpfe und Blätterknöpfe mindestens 40 px hoch und im Bild, Zeilen mindestens 44 px hoch, nichts verdeckt', kBedien.length === 0 && kZeilen.length === 0 && kSuche.every((r) => r.left >= 0 && r.right <= 390 && !r.covered), { kBedien, kZeilen: kZeilen.slice(0, 3), kSuche })
  check('handy keller: das Suchfeld ist mindestens 40 px hoch (Tippfläche)', kSuche.every((r) => r.height >= 40), kSuche)
  await zeilen(page).first().tap()
  const akte = page.getByRole('dialog', { name: 'Akte Praxis Dr. Lindner', exact: true })
  await akte.waitFor()
  await sleep(400)
  const ab = await rectOf(akte)
  const wAkte = await widthOf(page)
  await shoot(page, 'm-keller-akte.png')
  const aktBedien = badReach(await reachOf(page, '.hk-akte button'))
  const aktLink = badReach(await reachOf(page, '.hk-akte-link'))
  check('handy keller: die Akte füllt die Fläche als Vollbild (volle Breite, volle Höhe des Kellers), nichts läuft über den Rand', ab.w >= 385 && ab.h >= kellerBox.h - 8 && noSideScroll(wAkte), { ab, keller: kellerBox, wAkte })
  check('handy keller: Schließen und Blättern in der Akte mindestens 40 px hoch, im Bild, nicht verdeckt; der Quell-Link im Bild und nicht verdeckt', aktBedien.length === 0 && aktLink.every((r) => r.left >= 0 && r.right <= 390 && !r.covered), { aktBedien, aktLink })
  check('handy keller: der Quell-Link „Quelle öffnen“ in der Akte ist mindestens 40 px hoch (Tippfläche)', aktLink.every((r) => r.height >= 40), aktLink)
  await page.getByRole('button', { name: 'Schließen', exact: true }).tap()
  await akte.waitFor({ state: 'detached' })
  // der Eintrag mit dem langen Namen und dem langen Grund ohne Umbruchstellen
  await page.goto(base + KELLER_URL + '&bot=' + BL.long)
  await blSettled(page)
  await sleep(300)
  const wL = await widthOf(page)
  const zeileOk = await page.evaluate(() => { const z = document.querySelector('.hk-zeile'); return z.scrollWidth <= z.clientWidth + 1 })
  check('handy keller: langer Name und langer Grund ohne Leerzeichen laufen nicht über den Rand (Seite und Zeile)', noSideScroll(wL) && zeileOk, { wL, zeileOk })
  await shoot(page, 'm-keller-einzeln-lang.png')
  await zeilen(page).first().tap()
  await page.getByRole('dialog', { name: /^Akte Elektroinstallation/ }).waitFor()
  await sleep(400)
  const wLA = await widthOf(page)
  check('handy keller: die Akte zum langen Eintrag läuft nicht über den Rand', noSideScroll(wLA), wLA)
  await shoot(page, 'm-keller-akte-lang.png')
  await context.close()
}

const SCENARIOS = [
  ['hochhaus', hochhaus], ['regie', regie], ['handy', handy], ['bewegung', bewegung], ['notbremse', notbremse], ['ausfall', ausfall],
  ['detail', detail], ['etagen', etagen], ['pause', pause],
  ['pult', pult], ['pult-p4', pultP4], ['keller', keller], ['handy-pult-keller', handyPultKeller],
];

(async () => {
  const server = await serve()
  const base = 'http://127.0.0.1:' + server.address().port
  const browser = await chromium.launch({ executablePath: CHROME, args: ['--disable-gpu', '--no-sandbox', '--disable-dev-shm-usage'] })
  const ran = []
  try {
    const only = (process.env.HARNESS_ONLY || '').split(',').map((name) => name.trim()).filter(Boolean)
    for (const [name, run] of SCENARIOS) {
      if (only.length > 0 && !only.includes(name)) continue
      current = name
      ran.push(name)
      openContexts = []
      lastPage = null
      const before = errors.length
      const started = Date.now()
      try {
        await run(browser, base)
      } catch (e) {
        problems.push('Abbruch in Szenario ' + name + ': ' + (e && e.stack ? e.stack : String(e)))
        if (lastPage) await shoot(lastPage, 'abbruch-' + name + '.png', { fullPage: true }).catch(() => {})
      }
      for (const context of openContexts) await context.close().catch(() => {})
      const fresh = errors.slice(before)
      check(name + ': keine pageerror/console.error/fehlgeschlagene Anfragen', fresh.length === 0, fresh)
      metrics['dauer ' + name] = Math.round((Date.now() - started) / 1000) + ' s'
      console.error(`[${name}] fertig in ${metrics['dauer ' + name]}, Verstöße bisher: ${problems.length}`)
    }
  } finally {
    await browser.close()
    server.close()
  }
  const ok = problems.length === 0
  console.log(JSON.stringify({ scenarios: ran.map((name) => ({ name, ...perScenario[name] })), shots: shots.map((f) => path.basename(f)), violations: problems, befunde: findings, metrics, errors, fontRequests: fontLog.length }))
  if (findings.length > 0) console.error('BEFUNDE (App, kein Fehlschlag):\n' + findings.join('\n'))
  if (!ok) { console.error('FAIL:\n' + problems.join('\n')); process.exit(1) }
  console.log('OK')
})().catch((e) => { console.error('FAIL', e); process.exit(1) })