#!/usr/bin/env node
// Spielt die Pixel-Oberfläche „Hustler“ aus der Claude-Design-Zeichenfläche (pixelwelt-v2) in WOMS ein.
//
// Aufruf:  node scripts/hustler-import.mjs <pfad-zu-pixelwelt-v2> [<pfad-zu-pixelwelt-woms>]
//
// Erzeugt (alles deterministisch, ein zweiter Lauf ändert keine Datei):
//   src/assets/hustler/<quellpfad ohne "entwurf/">   die benutzten PNGs (Vite hängt beim Bauen einen Hash an)
//   src/styles/hustler/{hochhaus,keller,pult}.css    das CSS der drei Artboards, auf WOMS zugeschnitten
//   src/lib/hustlerWelt.js                           Geometrie des Hochhauses (reine Daten, eingefroren)
//
// Der optionale zweite Ordner (pixelwelt-woms) enthält das neu gezeichnete Haus. Eine Datei dort unter
// haus/ ersetzt die gleichnamige aus pixelwelt-v2/haus/. Nennt dort haus/manifest.json „graueRaeume“,
// entstehen zusätzlich die Ebenen für abgedunkelte Räume (CSS-Klassen hk-raum-grau-<raum> und GRAUE_RAEUME).
// Erwartetes Format: graueRaeume = { "<raum>": { "file": "raum-grau-<raum>.png", "x": …, "y": …, "w": …, "h": … } }
// (x/y in Weltkoordinaten wie alle Werte der Haus-Manifeste; file, w und h sind optional – ohne Angabe gilt
// raum-grau-<raum>.png in seiner Pixelgröße). Statt eines Objekts geht auch eine Liste mit „raum“ je Eintrag.
//
// Nur Node-Bordmittel. Schreibt ausschließlich in die drei Zielorte oben; gelöscht werden höchstens alte
// Ebenen src/assets/hustler/haus/raum-grau-*.png, die der aktuelle Lauf nicht mehr erzeugt.

import { createHash } from 'node:crypto'
import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
import path from 'node:path'
import { fileURLToPath, pathToFileURL } from 'node:url'

const HIER = path.dirname(fileURLToPath(import.meta.url))
const REPO = path.resolve(HIER, '..')
const ROSTER_DATEI = path.join(REPO, 'src/lib/workersRoster.js')
const QUELLEN_DATEI = path.join(HIER, 'hustler-import/quellen.json')

// Ausgabeorte (relativ zur Repo-Wurzel, mit /)
const ASSETS = 'src/assets/hustler'
const STYLES = 'src/styles/hustler'
const WELT_DATEI = 'src/lib/hustlerWelt.js'

// Die drei Bildschirme: Artboard, Blob-Zuordnung, Wurzelklasse, Keyframe-Vorsatz, Ausgabedatei
export const BILDSCHIRME = Object.freeze({
  hochhaus: { artboard: 'Main.dc.html', titel: 'Hochhaus', html: 'entwurf/Main.dc.html', blobs: 'entwurf/blobs.json', wurzel: 'hk-hochhaus', kfVorsatz: 'hk-h-', css: 'hochhaus.css' },
  keller: { artboard: 'BotLeads.dc.html', titel: 'Keller', html: 'keller/entwurf/BotLeads.dc.html', blobs: 'keller/entwurf/blobs.json', wurzel: 'hk-keller', kfVorsatz: 'hk-k-', css: 'keller.css' },
  pult: { artboard: 'Freigabe.dc.html', titel: 'Pult', html: 'pult/entwurf/Freigabe.dc.html', blobs: 'pult/entwurf/blobs.json', wurzel: 'hk-pult', kfVorsatz: 'hk-p-', css: 'pult.css' },
})

// Raum-Schlüssel im Haus-Manifest -> Raum-Schlüssel in ROOM_TITLES (workersRoster.js)
const RAUM_NACH_ROSTER = Object.freeze({
  bruecke: 'bruecke', radar: 'netz', klein: 'kleinanzeigen', portale: 'portale', foren: 'foren',
  aerzte: 'aerzte', handwerk: 'handwerk', selbst: 'selbst', laeden: 'laden', waage: 'waage',
  mail: 'mail', forum: 'forum', post: 'posteingang', abschluss: 'abschluss',
  tisch1: 'tisch1', tisch2: 'tisch2', tisch3: 'tisch3', pruef: 'pruefung',
  freigabe: 'pult', tresor: 'tresor', keller: 'archiv',
})

export class ImportFehler extends Error {
  constructor(text) {
    super(text)
    this.name = 'ImportFehler'
  }
}
const fehler = (text) => new ImportFehler(text)

const sha256 = (daten) => createHash('sha256').update(daten).digest('hex')
const kurz = (text, n = 70) => {
  const t = String(text).replace(/\s+/g, ' ').trim()
  return t.length > n ? `${t.slice(0, n)}…` : t
}

// ───────────────────────────── CSS-Tokenizer ─────────────────────────────
// Kleiner, strenger Zerleger: Kommentare, Zeichenketten, url(…), verschachtelte @media/@supports, @keyframes.

function stringEnde(s, i) {
  const q = s[i]
  let j = i + 1
  while (j < s.length) {
    const c = s[j]
    if (c === '\\') { j += 2; continue }
    if (c === q) return j + 1
    if (c === '\n') break
    j += 1
  }
  throw fehler(`CSS: Zeichenkette ohne Ende bei „${kurz(s.slice(i, i + 40))}“.`)
}

// Entfernt /* … */ (Zeichenketten und ungequotetes url(…) bleiben unberührt)
function ohneKommentare(s) {
  let aus = ''
  let i = 0
  while (i < s.length) {
    const c = s[i]
    if (c === '"' || c === "'") { const e = stringEnde(s, i); aus += s.slice(i, e); i = e; continue }
    if (c === '\\') { aus += s.slice(i, i + 2); i += 2; continue }
    if (c === '/' && s[i + 1] === '*') {
      const e = s.indexOf('*/', i + 2)
      if (e < 0) throw fehler('CSS: Kommentar ohne Ende.')
      aus += ' '
      i = e + 2
      continue
    }
    if ((c === 'u' || c === 'U') && /^url\(\s*[^\s"')]/i.test(s.slice(i, i + 12)) && !/[\w-]/.test(s[i - 1] ?? ' ')) {
      const e = s.indexOf(')', i)
      if (e < 0) throw fehler('CSS: url( ohne schließende Klammer.')
      aus += s.slice(i, e + 1)
      i = e + 1
      continue
    }
    aus += c
    i += 1
  }
  return aus
}

// Erste Stelle ab i, an der ein Zeichen aus `stopps` auf oberster Ebene steht (außerhalb von (), [] und Zeichenketten)
function sucheOben(s, i, stopps) {
  let klammer = 0
  let eckig = 0
  while (i < s.length) {
    const c = s[i]
    if (c === '"' || c === "'") { i = stringEnde(s, i); continue }
    if (c === '\\') { i += 2; continue }
    if (c === '(') klammer += 1
    else if (c === ')') klammer = Math.max(0, klammer - 1)
    else if (c === '[') eckig += 1
    else if (c === ']') eckig = Math.max(0, eckig - 1)
    else if (klammer === 0 && eckig === 0 && stopps.includes(c)) return i
    i += 1
  }
  return -1
}

function teileOben(s, trenner) {
  const teile = []
  let start = 0
  for (;;) {
    const e = sucheOben(s, start, trenner)
    if (e < 0) { teile.push(s.slice(start)); return teile }
    teile.push(s.slice(start, e))
    start = e + 1
  }
}

// Index der Klammer, die zu s[offen] ('(' oder '[') gehört; Zeichenketten und Escapes zählen nicht mit
function passende(s, offen) {
  const auf = s[offen]
  const zu = auf === '(' ? ')' : ']'
  let tiefe = 0
  for (let i = offen; i < s.length; i += 1) {
    const c = s[i]
    if (c === '"' || c === "'") { i = stringEnde(s, i) - 1; continue }
    if (c === '\\') { i += 1; continue }
    if (c === auf) tiefe += 1
    else if (c === zu) {
      tiefe -= 1
      if (tiefe === 0) return i
    }
  }
  throw fehler(`CSS: „${auf}“ ohne passende schließende Klammer in „${kurz(s.slice(offen))}“.`)
}

const GRUPPEN_REGELN = new Set(['media', 'supports', 'layer', 'container'])

// → { knoten, ende }; knoten: { art: 'regel'|'gruppe'|'keyframes'|'weg', … }
function parseListe(s, start, innen) {
  const knoten = []
  let i = start
  for (;;) {
    while (i < s.length && /\s/.test(s[i])) i += 1
    if (i >= s.length) {
      if (innen) throw fehler('CSS: Block ohne schließende Klammer.')
      return { knoten, ende: i }
    }
    if (s[i] === '}') {
      if (!innen) throw fehler('CSS: unerwartete schließende Klammer.')
      return { knoten, ende: i + 1 }
    }
    const stopp = sucheOben(s, i, ';{}')
    if (stopp < 0) throw fehler(`CSS: Regel „${kurz(s.slice(i))}“ endet nicht.`)
    const kopf = s.slice(i, stopp).trim()
    if (s[stopp] === '}') throw fehler(`CSS: „${kurz(kopf)}“ steht ohne Block.`)
    if (s[stopp] === ';') {
      // @import/@charset ohne Block entfallen, andere Anweisungen kennen wir nicht
      if (/^@(import|charset)\b/i.test(kopf)) { knoten.push({ art: 'weg' }); i = stopp + 1; continue }
      throw fehler(`CSS: nicht unterstützte Anweisung „${kurz(kopf)}“.`)
    }
    // Block
    if (kopf.startsWith('@')) {
      const name = (kopf.match(/^@([A-Za-z-]+)/)?.[1] ?? '').toLowerCase()
      if (name === 'font-face' || name === 'import') {
        const e = blockEnde(s, stopp)
        knoten.push({ art: 'weg' })
        i = e + 1
        continue
      }
      if (/(^|-)keyframes$/.test(name)) {
        const kfName = kopf.slice(kopf.indexOf(name) + name.length).trim()
        if (!/^[A-Za-z_][\w-]*$/.test(kfName)) throw fehler(`CSS: ungewöhnlicher Keyframe-Name „${kurz(kfName)}“.`)
        const { knoten: bilder, ende } = parseListe(s, stopp + 1, true)
        knoten.push({ art: 'keyframes', at: `@${name}`, name: kfName, bilder })
        i = ende
        continue
      }
      if (GRUPPEN_REGELN.has(name)) {
        const { knoten: kinder, ende } = parseListe(s, stopp + 1, true)
        knoten.push({ art: 'gruppe', kopf, kinder })
        i = ende
        continue
      }
      throw fehler(`CSS: nicht unterstützte At-Regel „${kurz(kopf)}“.`)
    }
    const e = blockEnde(s, stopp)
    knoten.push({ art: 'regel', selektor: kopf, koerper: s.slice(stopp + 1, e) })
    i = e + 1
  }
}

// Index der schließenden Klammer zum Block, der bei s[offen] === '{' beginnt (ohne Verschachtelung)
function blockEnde(s, offen) {
  const e = sucheOben(s, offen + 1, '{}')
  if (e < 0) throw fehler('CSS: Block ohne schließende Klammer.')
  if (s[e] === '{') throw fehler(`CSS: verschachtelte Regel in „${kurz(s.slice(offen + 1, e))}“ wird nicht unterstützt.`)
  return e
}

// ───────────────────────────── Selektoren ─────────────────────────────

function istIdentStart(s, j) {
  const c = s[j]
  if (c === undefined) return false
  if (/[A-Za-z_\\]/.test(c) || c.charCodeAt(0) > 127) return true
  return c === '-' && /[A-Za-z_\\-]/.test(s[j + 1] ?? '')
}

// Jede Klasse (.name) bekommt hk- davor; Zeichenketten und [attribute] bleiben unberührt
function praefixKlassen(s) {
  let aus = ''
  let i = 0
  while (i < s.length) {
    const c = s[i]
    if (c === '"' || c === "'") { const e = stringEnde(s, i); aus += s.slice(i, e); i = e; continue }
    if (c === '\\') { aus += s.slice(i, i + 2); i += 2; continue }
    if (c === '[') {
      const ende = passende(s, i)
      aus += s.slice(i, ende + 1)
      i = ende + 1
      continue
    }
    if (c === '.' && istIdentStart(s, i + 1)) { aus += '.hk-'; i += 1; continue }
    aus += c
    i += 1
  }
  return aus
}

const WURZEL_ANFANG = /^(?:html|body|:root)(?![\w-])/i
const WURZEL_FOLGE = /^\s*(?:>\s*)?(?=(?:html|body|:root)(?![\w-]))/i

export function wandleSelektor(selektor, wurzel) {
  let rest = selektor.trim()
  if (!rest) throw fehler('CSS: leerer Selektor.')
  let istWurzel = false
  while (WURZEL_ANFANG.test(rest)) {
    istWurzel = true
    rest = rest.replace(WURZEL_ANFANG, '')
    const folge = rest.match(WURZEL_FOLGE)
    if (!folge) break
    rest = rest.slice(folge[0].length)
  }
  if (/(^|[\s>+~(,])(?:html|body|:root)(?![\w-])/i.test(rest)) {
    throw fehler(`CSS: html/body/:root mitten im Selektor „${kurz(selektor)}“ lässt sich nicht sicher umformen.`)
  }
  const mitKlassen = praefixKlassen(rest)
  return istWurzel ? `.${wurzel}${mitKlassen}` : `.${wurzel} ${mitKlassen}`
}

function wandleSelektorListe(liste, wurzel) {
  const neu = []
  for (const teil of teileOben(liste, ',')) {
    const s = wandleSelektor(teil, wurzel)
    if (!neu.includes(s)) neu.push(s)
  }
  return neu.join(',')
}

// ───────────────────────────── Werte ─────────────────────────────

const BLOB_ADRESSE = /^\/_blob\/([0-9A-Za-z]+)$/

function blobInhalt(inhalt, blobPfad) {
  const m = inhalt.trim().match(BLOB_ADRESSE)
  if (m) return blobPfad(m[1])
  if (inhalt.includes('/_blob/')) throw fehler(`CSS: unerwartete Blob-Adresse „${kurz(inhalt)}“.`)
  return inhalt
}

// url(/_blob/…) und Zeichenketten mit Blob-Adresse -> Asset-Pfad
function ersetzeBlobs(wert, blobPfad) {
  let aus = ''
  let i = 0
  while (i < wert.length) {
    const c = wert[i]
    if (c === '"' || c === "'") {
      const e = stringEnde(wert, i)
      aus += c + blobInhalt(wert.slice(i + 1, e - 1), blobPfad) + c
      i = e
      continue
    }
    if (c === '\\') { aus += wert.slice(i, i + 2); i += 2; continue }
    if ((c === 'u' || c === 'U') && /^url\(/i.test(wert.slice(i, i + 4)) && !/[\w-]/.test(wert[i - 1] ?? ' ')) {
      let j = i + 4
      while (j < wert.length && /\s/.test(wert[j])) j += 1
      if (wert[j] === '"' || wert[j] === "'") { aus += wert.slice(i, j); i = j; continue } // die Zeichenkette folgt in der Schleife
      const e = wert.indexOf(')', j)
      if (e < 0) throw fehler(`CSS: url( ohne schließende Klammer in „${kurz(wert)}“.`)
      aus += `url(${blobInhalt(wert.slice(j, e), blobPfad)})`
      i = e + 1
      continue
    }
    aus += c
    i += 1
  }
  return aus
}

const ZAHL = /[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?[A-Za-z%]*/y
const IDENT = /(?:[A-Za-z_]|[^\u0000-\u007f]|\\.)(?:[\w-]|[^\u0000-\u007f]|\\.)*|-(?:[A-Za-z_-]|[^\u0000-\u007f]|\\.)(?:[\w-]|[^\u0000-\u007f]|\\.)*/y

// Bekannte Keyframe-Namen in animation/animation-name umbenennen; Schlüsselwörter, Zahlen mit Einheit
// (3200ms, -1.3s, .5s) und Funktionen (steps(1,end)) bleiben unberührt
function benenneAnimationen(wert, umbenennen) {
  let aus = ''
  let i = 0
  while (i < wert.length) {
    const c = wert[i]
    if (c === '"' || c === "'") { const e = stringEnde(wert, i); aus += wert.slice(i, e); i = e; continue }
    ZAHL.lastIndex = i
    const zahl = ZAHL.exec(wert)
    if (zahl) {
      aus += zahl[0]
      i += zahl[0].length
      continue
    }
    IDENT.lastIndex = i
    const ident = IDENT.exec(wert)
    if (ident) {
      const name = ident[0]
      i += name.length
      if (wert[i] === '(') {
        // Funktion (steps, cubic-bezier, var …): unverändert bis zur passenden Klammer
        const ende = passende(wert, i)
        aus += name + wert.slice(i, ende + 1)
        i = ende + 1
      } else {
        aus += umbenennen.has(name) ? umbenennen.get(name) : name
      }
      continue
    }
    aus += c
    i += 1
  }
  return aus
}

function wandleDeklarationen(koerper, ctx) {
  const teile = []
  for (const roh of teileOben(koerper, ';')) {
    const d = roh.trim()
    if (!d) continue
    const k = sucheOben(d, 0, ':')
    if (k < 0) throw fehler(`CSS: Deklaration ohne „:“ in „${kurz(d)}“.`)
    const eigenschaft = d.slice(0, k).trim()
    let wert = d.slice(k + 1).trim().replace(/\s*\n\s*/g, ' ')
    wert = ersetzeBlobs(wert, ctx.blobPfad)
    if (/^(?:-webkit-)?animation(?:-name)?$/i.test(eigenschaft)) wert = benenneAnimationen(wert, ctx.kfNamen)
    teile.push(`${eigenschaft}:${wert}`)
  }
  return teile.join('; ')
}

function sammleKeyframes(knoten, namen) {
  for (const k of knoten) {
    if (k.art === 'keyframes') namen.add(k.name)
    else if (k.art === 'gruppe') sammleKeyframes(k.kinder, namen)
  }
}

function schreibeKnoten(knoten, ctx, zeilen) {
  for (const k of knoten) {
    if (k.art === 'weg') continue
    if (k.art === 'regel') {
      zeilen.push(`${wandleSelektorListe(k.selektor, ctx.wurzel)}{${wandleDeklarationen(k.koerper, ctx)}}`)
    } else if (k.art === 'keyframes') {
      const bilder = k.bilder.map((b) => {
        if (b.art !== 'regel') throw fehler(`CSS: unerwarteter Inhalt in @keyframes ${k.name}.`)
        return `${b.selektor.replace(/\s+/g, ' ')}{${wandleDeklarationen(b.koerper, ctx)}}`
      })
      zeilen.push(`${k.at} ${ctx.kfNamen.get(k.name)}{${bilder.join('')}}`)
    } else if (k.art === 'gruppe') {
      const innen = []
      schreibeKnoten(k.kinder, ctx, innen)
      zeilen.push(`${k.kopf.replace(/\s+/g, ' ')}{`, ...innen, '}')
    }
  }
}

/**
 * Formt das CSS eines Artboards für WOMS um.
 * @param {string} css  zusammengesetzter Inhalt der <style>-Blöcke
 * @param {{ wurzel: string, kfVorsatz: string, blobPfad: (id: string) => string }} opt
 * @returns {{ css: string, keyframes: string[] }}
 */
export function wandleCss(css, { wurzel, kfVorsatz, blobPfad }) {
  const { knoten } = parseListe(ohneKommentare(css), 0, false)
  const namen = new Set()
  sammleKeyframes(knoten, namen)
  const kfNamen = new Map([...namen].map((n) => [n, `${kfVorsatz}${n}`]))
  const zeilen = []
  schreibeKnoten(knoten, { wurzel, kfNamen, blobPfad }, zeilen)
  const aus = zeilen.join('\n')
  if (aus.includes('/_blob/')) throw fehler('CSS: nach der Umformung steht noch eine Blob-Adresse im Ergebnis.')
  return { css: aus, keyframes: [...kfNamen.values()] }
}

// ───────────────────────────── HTML der Artboards ─────────────────────────────

function styleBloecke(html, artboard) {
  const teile = [...html.matchAll(/<style\b[^>]*>([\s\S]*?)<\/style>/gi)].map((m) => m[1])
  if (teile.length === 0) throw fehler(`${artboard}: kein <style>-Block gefunden.`)
  return teile.join('\n')
}

const TAG = /<([A-Za-z][\w-]*)((?:\s+[^\s"'<>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'<>]+))?)*)\s*\/?>/g
const ATTR = /([^\s"'<>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'<>]+)))?/g

function entschluessele(t) {
  return t.replace(/&nbsp;/g, '\u00a0').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&amp;/g, '&')
}

function elemente(bereich) {
  const liste = []
  for (const m of bereich.matchAll(TAG)) {
    const attr = {}
    for (const a of m[2].matchAll(ATTR)) attr[a[1]] = a[2] ?? a[3] ?? a[4] ?? ''
    const ende = m.index + m[0].length
    const naechstes = bereich.indexOf('<', ende)
    liste.push({
      tag: m[1].toLowerCase(),
      attr,
      klassen: new Set((attr.class ?? '').split(/\s+/).filter(Boolean)),
      stil: stilMap(attr.style),
      text: entschluessele(bereich.slice(ende, naechstes < 0 ? undefined : naechstes)).trim(),
    })
  }
  return liste
}

function stilMap(s = '') {
  const o = {}
  for (const d of teileOben(s, ';')) {
    const k = d.indexOf(':')
    if (k > 0) o[d.slice(0, k).trim().toLowerCase()] = d.slice(k + 1).trim()
  }
  return o
}

function px(wert, was) {
  const m = typeof wert === 'string' ? wert.match(/^(-?\d+(?:\.\d+)?)px$/) : null
  if (!m) throw fehler(`Hochhaus: ${was} ist keine px-Angabe (${wert === undefined ? 'fehlt' : `„${wert}“`}).`)
  return Number(m[1])
}

const rechteck = (e, was) => ({ left: px(e.stil.left, `${was}: left`), top: px(e.stil.top, `${was}: top`), w: px(e.stil.width, `${was}: width`), h: px(e.stil.height, `${was}: height`) })
const punkt = (e, was) => ({ left: px(e.stil.left, `${was}: left`), top: px(e.stil.top, `${was}: top`) })

function genau(liste, was, bedingung) {
  const treffer = liste.filter(bedingung)
  if (treffer.length !== 1) throw fehler(`Hochhaus: ${was} kommt ${treffer.length}-mal in Main.dc.html vor, erwartet genau 1.`)
  return treffer[0]
}

// ───────────────────────────── Geometrie des Hochhauses ─────────────────────────────

function leseHochhaus({ html, hausManifest, roster }) {
  const { FLOORS, FLOOR_TITLES, ROLES, ROOM_TITLES } = roster
  const kopfEnde = html.indexOf('</helmet>')
  const skriptStart = html.search(/<script\b[^>]*type="text\/x-dc"/i)
  if (kopfEnde < 0 || skriptStart < 0 || skriptStart < kopfEnde) throw fehler('Main.dc.html: Aufbau unbekannt (</helmet> oder das Logik-Skript fehlt).')
  const markup = elemente(html.slice(kopfEnde, skriptStart))
  const skript = html.slice(skriptStart)
  const css = styleBloecke(html, 'Main.dc.html')

  // Welt und Haus (Kamerarahmen) wie welt() in der Logik
  const w = skript.match(/welt\(\)\s*\{\s*return\s*\{\s*w:\s*(\d+),\s*h:\s*(\d+),\s*haus:\s*\{\s*x:\s*(\d+),\s*y:\s*(\d+),\s*w:\s*(\d+),\s*h:\s*(\d+)\s*\},\s*hud:\s*(\d+)\s*\}/)
  if (!w) throw fehler('Main.dc.html: welt() in der Logik nicht gefunden.')
  const WELT = { w: Number(w[1]), h: Number(w[2]), hud: Number(w[7]) }
  const HAUS = { x: Number(w[3]), y: Number(w[4]), w: Number(w[5]), h: Number(w[6]) }
  const pl = hausManifest.placement
  const HAUS_BILD = { x: pl.x, y: pl.y, w: pl.w, h: pl.h }

  // Etagen: Klickbereiche aus den Etagen-Knöpfen, Öffnung aus dem Haus-Manifest
  const knoepfe = markup.filter((e) => e.klassen.has('etage'))
  if (knoepfe.length !== FLOORS.length) throw fehler(`Hochhaus: ${knoepfe.length} Etagen-Knöpfe in Main.dc.html, erwartet ${FLOORS.length}.`)
  if (hausManifest.floors.length !== FLOORS.length) throw fehler(`Hochhaus: ${hausManifest.floors.length} Etagen im Haus-Manifest, erwartet ${FLOORS.length}.`)
  const spalten = new Set()
  const ETAGEN = FLOORS.map((id, i) => {
    const b = rechteck(knoepfe[i], `Etagen-Knopf ${i + 1}`)
    const beschriftung = knoepfe[i].attr['aria-label'] ?? ''
    if (!beschriftung.startsWith(FLOOR_TITLES[id])) throw fehler(`Hochhaus: Etagen-Knopf ${i + 1} heißt „${beschriftung}“, erwartet ${FLOOR_TITLES[id]} (id ${id}).`)
    spalten.add(`${b.left}/${b.w}`)
    const f = hausManifest.floors[i]
    if (f.name !== FLOOR_TITLES[id]) throw fehler(`Hochhaus: Etage ${i} heißt im Haus-Manifest „${f.name}“, erwartet ${FLOOR_TITLES[id]}.`)
    const oeffnung = [f.openingY0, f.openingY1]
    if (!(b.top <= oeffnung[0] && oeffnung[1] <= b.top + b.h)) throw fehler(`Hochhaus: Öffnung ${oeffnung.join('–')} von ${id} liegt nicht im Klickbereich.`)
    return { id, oben: b.top, unten: b.top + b.h, oeffnung }
  })
  if (spalten.size !== 1) throw fehler('Hochhaus: Die Etagen-Knöpfe stehen nicht alle in derselben Spalte.')
  const [spalteLinks, spalteBreite] = [...spalten][0].split('/').map(Number)
  ETAGEN.forEach((e, i) => {
    if (e.oben >= e.unten) throw fehler(`Hochhaus: Klickbereich von ${e.id} ist leer.`)
    if (i > 0 && ETAGEN[i - 1].unten !== e.oben) throw fehler(`Hochhaus: Klickbereiche von ${ETAGEN[i - 1].id} und ${e.id} schließen nicht lückenlos an.`)
  })
  const ETAGEN_SPALTE = { x: spalteLinks, w: spalteBreite }

  // Räume aus dem Haus-Manifest; Etiketten-Punkt = x0 + 20 / Öffnung oben + 3, gegen die Schilder in Main.dc.html geprüft
  const raumReihe = Object.keys(ROOM_TITLES)
  const nachRoster = new Map()
  for (const r of hausManifest.rooms) {
    const schluessel = RAUM_NACH_ROSTER[r.key]
    if (!schluessel) throw fehler(`Hochhaus: Raum „${r.key}“ aus dem Haus-Manifest ist in RAUM_NACH_ROSTER unbekannt.`)
    if (nachRoster.has(schluessel)) throw fehler(`Hochhaus: Raum ${schluessel} steht doppelt im Haus-Manifest.`)
    nachRoster.set(schluessel, r)
  }
  const beschriftungen = markup.filter((e) => e.tag === 'span' && e.stil['font-size'] === '8px' && e.stil.color === '#4a5266')
  // Die drei Räume ohne Anschluss tragen in der Vorlage statt des Etiketts einen Zettel „<Raum> / nicht angeschlossen“
  const suchRaeume = roster.SEARCH_ROOMS
  const zettel = markup.filter((e) => e.tag === 'span' && e.stil.background === '#f1ede4' && suchRaeume.some((r) => ROOM_TITLES[r] === e.text))
  const zettelRaeume = {}
  let zettelBreite = null
  for (const z of zettel) {
    const raumSchluessel = suchRaeume.find((r) => ROOM_TITLES[r] === z.text)
    const breite = px(z.stil.width, `Zettel ${raumSchluessel}: width`)
    if (zettelBreite !== null && zettelBreite !== breite) throw fehler('Hochhaus: Die „nicht angeschlossen“-Zettel sind nicht gleich breit.')
    zettelBreite = breite
    zettelRaeume[raumSchluessel] = punkt(z, `Zettel ${raumSchluessel}`)
  }
  const RAEUME = {}
  for (const schluessel of raumReihe) {
    const r = nachRoster.get(schluessel)
    if (!r) throw fehler(`Hochhaus: Raum ${schluessel} fehlt im Haus-Manifest.`)
    const etage = FLOORS[r.floor]
    if (!etage) throw fehler(`Hochhaus: Raum ${schluessel} liegt auf unbekannter Etage ${r.floor}.`)
    const raum = { etage, x0: r.x, x1: r.x + r.w, y0: r.y, y1: r.y + r.h, etikett: { x: r.x + 20, y: r.y + 3 } }
    const schilder = beschriftungen.filter((e) => e.text === ROOM_TITLES[schluessel])
    if (schilder.length > 1) throw fehler(`Hochhaus: Raumschild „${ROOM_TITLES[schluessel]}“ kommt ${schilder.length}-mal in Main.dc.html vor.`)
    if (schilder.length === 1) {
      const sp = punkt(schilder[0], `Raumschild ${schluessel}`)
      if (sp.left !== raum.etikett.x || sp.top !== raum.etikett.y) {
        throw fehler(`Hochhaus: Raumschild „${ROOM_TITLES[schluessel]}“ steht in Main.dc.html bei ${sp.left}/${sp.top}, nach dem Haus-Manifest bei ${raum.etikett.x}/${raum.etikett.y}.`)
      }
    } else if (!zettelRaeume[schluessel]) {
      throw fehler(`Hochhaus: Für Raum „${ROOM_TITLES[schluessel]}“ gibt es in Main.dc.html weder ein Raumschild noch einen „nicht angeschlossen“-Zettel.`)
    }
    const eta = ETAGEN.find((e) => e.id === etage)
    if (raum.y0 !== eta.oeffnung[0] || raum.y1 !== eta.oeffnung[1]) throw fehler(`Hochhaus: Raum ${schluessel} passt nicht zur Öffnung der Etage ${etage}.`)
    RAEUME[schluessel] = raum
  }

  // Hustler: Anker aus dem Haus-Manifest, Knopf-Rechtecke und Bildschirme aus Main.dc.html
  const hustlerKnoepfe = markup.filter((e) => e.klassen.has('hustler'))
  const bildschirme = markup.filter((e) => e.klassen.has('bildschirm') && e.klassen.has('spr')).map((e) => punkt(e, 'Bildschirm'))
  const HUSTLER = {}
  const gesehen = new Set()
  for (const rolle of ROLES) {
    const anzeigeName = rolle.workerId === 'otto' ? 'Overseer' : rolle.name
    const knopf = genau(hustlerKnoepfe, `Hustler-Knopf ${anzeigeName}`, (e) => (e.attr['aria-label'] ?? '').split(',')[0].trim() === anzeigeName)
    const k = rechteck(knopf, `Knopf ${anzeigeName}`)
    const arbeiter = hausManifest.workers.find((x) => x.name === anzeigeName)
    if (!arbeiter) throw fehler(`Hochhaus: ${anzeigeName} fehlt unter workers im Haus-Manifest.`)
    const [a, f] = arbeiter.anchor
    const eintrag = { a, f, knopf: k }
    if (rolle.workerId === 'otto') {
      const sb = arbeiter.spriteBox
      if (k.left !== sb.x || k.top !== sb.y || k.w !== sb.w || k.h !== sb.h) throw fehler('Hochhaus: Knopf des Overseers passt nicht zur Sprite-Box im Haus-Manifest.')
    } else {
      if (k.left !== a - 12 || k.top !== f - 31 || k.w !== 24 || k.h !== 32) throw fehler(`Hochhaus: Knopf von ${anzeigeName} (${k.left}/${k.top}) passt nicht zum Anker ${a}/${f}.`)
      eintrag.bildschirm = { left: a - 40, top: f - 26 }
      const s = arbeiter.screen
      if (s && (s.x !== eintrag.bildschirm.left || s.y !== eintrag.bildschirm.top)) throw fehler(`Hochhaus: Bildschirm von ${anzeigeName} passt nicht zum Haus-Manifest.`)
    }
    const raum = RAEUME[rolle.room]
    if (!(raum.x0 <= a && a <= raum.x1 && raum.y0 <= f && f <= raum.y1)) throw fehler(`Hochhaus: Anker von ${anzeigeName} liegt nicht in Raum ${rolle.room}.`)
    HUSTLER[rolle.workerId] = eintrag
    gesehen.add(knopf)
  }
  if (gesehen.size !== hustlerKnoepfe.length) throw fehler(`Hochhaus: Main.dc.html hat ${hustlerKnoepfe.length} Hustler-Knöpfe, das Roster ${ROLES.length} Rollen.`)
  for (const b of bildschirme) {
    const passt = Object.values(HUSTLER).some((h) => h.bildschirm && h.bildschirm.left === b.left && h.bildschirm.top === b.top)
    if (!passt) throw fehler(`Hochhaus: Bildschirm bei ${b.left}/${b.top} in Main.dc.html gehört zu keinem Hustler.`)
  }
  const radar = punkt(genau(markup, 'Radar', (e) => e.klassen.has('radar') && e.klassen.has('spr')), 'Radar')
  const ritaRaum = RAEUME[ROLES.find((r) => r.workerId === 'rita').room]
  if (!(ritaRaum.x0 <= radar.left && radar.left <= ritaRaum.x1 && ritaRaum.y0 <= radar.top && radar.top <= ritaRaum.y1)) throw fehler('Hochhaus: Das Radar liegt nicht in Ritas Raum.')
  HUSTLER.rita.radar = radar

  // Schilder
  const zaehler = genau(markup, 'Briefkasten-Zähler', (e) => e.klassen.has('huepf'))
  const tresor = genau(markup, 'Tresor-Text', (e) => e.tag === 'span' && /^\d+ Deals$/.test(e.text))
  const keller = genau(markup, 'Keller-Text', (e) => e.tag === 'span' && /^\d+ Bot-Leads$/.test(e.text))
  const neon = genau(markup, 'Neon-Fläche', (e) => e.klassen.has('neon'))
  const antenne = genau(markup, 'Antenne', (e) => e.klassen.has('antenne'))
  const schrift = (e, was) => ({ schrift: px(e.stil['font-size'], `${was}: font-size`), zeile: px(e.stil['line-height'], `${was}: line-height`) })
  const SCHILDER = {
    briefkasten: { left: px(zaehler.stil.left, 'Zähler: left'), top: px(zaehler.stil.top, 'Zähler: top'), minW: px(zaehler.stil['min-width'], 'Zähler: min-width'), h: px(zaehler.stil.height, 'Zähler: height'), schrift: px(zaehler.stil['font-size'], 'Zähler: font-size') },
    tresor: { ...punkt(tresor, 'Tresor-Text'), ...schrift(tresor, 'Tresor-Text') },
    keller: { ...punkt(keller, 'Keller-Text'), ...schrift(keller, 'Keller-Text') },
    neon: { ...rechteck(neon, 'Neon'), schrift: px(neon.stil['font-size'], 'Neon: font-size') },
    antenne: rechteck(antenne, 'Antenne'),
    nichtAngeschlossen: { breite: zettelBreite, raeume: zettelRaeume },
  }

  // Aufzug: Seil und Kabine aus Main.dc.html, Halte (Oberkante der Kabine je Etage) aus dem Haus-Manifest
  const seil = genau(markup, 'Aufzug-Seil', (e) => e.klassen.has('seil') && e.klassen.has('haus'))
  const kabine = genau(markup, 'Aufzug-Kabine', (e) => e.klassen.has('aufzug') && e.klassen.has('haus'))
  const halte = hausManifest.aufzug.stopsY
  if (!Array.isArray(halte) || halte.length !== FLOORS.length) throw fehler('Hochhaus: Aufzug-Halte im Haus-Manifest passen nicht zur Etagenzahl.')
  const AUFZUG = { seil: rechteck(seil, 'Seil'), kabine: rechteck(kabine, 'Kabine'), halte }
  if (AUFZUG.kabine.top !== halte[0]) throw fehler('Hochhaus: Die Kabine startet nicht am ersten Halt.')

  // Detailansicht: Figurposition (Logik) und Overlays (Markup)
  const fx = skript.match(/fx:\s*p\.hut\s*===\s*'overseer'\s*\?\s*(\d+)\s*:\s*\(p\.st\s*===\s*'nicht'\s*\?\s*(\d+)\s*:\s*(\d+)\)/)
  const fy = skript.match(/fy:\s*p\.hut\s*===\s*'overseer'\s*\?\s*(\d+)\s*:\s*\(p\.st\s*===\s*'nicht'\s*\?\s*(\d+)\s*:\s*(\d+)\)/)
  if (!fx || !fy) throw fehler('Main.dc.html: Figurposition (fx/fy) in der Logik nicht gefunden.')
  const szene = css.match(/\.sz\{[^}]*?width:\s*(\d+)px;\s*height:\s*(\d+)px/)
  if (!szene) throw fehler('Main.dc.html: CSS-Regel .sz (Größe der Detail-Szene) nicht gefunden.')
  const overlay = (klasse) => punkt(genau(markup, `Overlay ${klasse}`, (e) => e.klassen.has(klasse) && e.klassen.has('spr')), `Overlay ${klasse}`)
  const schild = genau(markup, 'Detail-Schild', (e) => e.text === 'noch nicht angeschlossen')
  const DETAIL = {
    szene: { w: Number(szene[1]), h: Number(szene[2]) },
    figur: {
      bruecke: { left: Number(fx[1]), top: Number(fy[1]) },
      nicht: { left: Number(fx[2]), top: Number(fy[2]) },
      buero: { left: Number(fx[3]), top: Number(fy[3]) },
    },
    monitor: overlay('monitor-gross'),
    dampf: overlay('dampf'),
    zzz: overlay('zzz-gross'),
    wirbel: overlay('wirbel'),
    schild: rechteck(schild, 'Detail-Schild'),
  }

  return { WELT, HAUS, HAUS_BILD, ETAGEN, ETAGEN_SPALTE, RAEUME, HUSTLER, SCHILDER, AUFZUG, DETAIL }
}

// ───────────────────────────── JS-Ausgabe (reine Daten, eingefroren) ─────────────────────────────

const SCHLUESSEL = /^[A-Za-z_$][\w$]*$/
const blatt = (x) => x === null || typeof x !== 'object'
const einfach = (x) => blatt(x) || (Array.isArray(x) && x.every(blatt))
function jsLiteral(v, ein = 0) {
  const pad = '  '.repeat(ein)
  if (Array.isArray(v)) {
    const teile = v.map((x) => jsLiteral(x, ein + 1))
    if (v.every(blatt)) return `Object.freeze([${teile.join(', ')}])`
    return `Object.freeze([\n${teile.map((t) => `${pad}  ${t}`).join(',\n')},\n${pad}])`
  }
  if (v && typeof v === 'object') {
    const eintraege = Object.entries(v)
    if (eintraege.length === 0) return 'Object.freeze({})'
    const teile = eintraege.map(([k, x]) => `${SCHLUESSEL.test(k) ? k : jsLiteral(k)}: ${jsLiteral(x, ein + 1)}`)
    const flach = eintraege.every(([, x]) => einfach(x))
    if (flach && teile.join(', ').length <= 100) return `Object.freeze({ ${teile.join(', ')} })`
    return `Object.freeze({\n${teile.map((t) => `${pad}  ${t}`).join(',\n')},\n${pad}})`
  }
  if (typeof v === 'string') return `'${v.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n')}'`
  if (typeof v === 'number' && !Number.isFinite(v)) throw fehler('Geometrie: keine endliche Zahl.')
  return String(v)
}

function weltDatei(d, kopf) {
  const abschnitte = [
    ['WELT', 'Weltgröße in Kunstpixeln; hud = Höhe der Kopfzeile, die beim Einpassen frei bleibt', d.WELT],
    ['HAUS', 'Kamerarahmen um das Haus (Einpassen, „ganzes Haus“)', d.HAUS],
    ['HAUS_BILD', 'Lage von haus.png und den Ebenen gleicher Größe (Fenster, Schild, graue Räume)', d.HAUS_BILD],
    ['ETAGEN_SPALTE', 'Spalte der Etagen-Knöpfe (links, Breite)', d.ETAGEN_SPALTE],
    ['ETAGEN', 'Etagen von oben nach unten: id wie FLOORS; oben/unten = Klickbereich (lückenlos); oeffnung = [oben, unten] des sichtbaren Innenraums', d.ETAGEN],
    ['RAEUME', 'Räume nach ROOM_TITLES-Schlüssel: Rechteck x0/x1/y0/y1, Etage, Etiketten-Punkt (x0 + 20, Öffnung oben + 3)', d.RAEUME],
    ['HUSTLER', 'Hustler nach workerId: Anker a/f (Fußpunkt), Knopf-Rechteck, Bildschirm-Overlay, Radar (nur Rita); otto = Overseer', d.HUSTLER],
    ['SCHILDER', 'Briefkasten-Zähler, Tresor-/Keller-Text, Neon-Fläche, Antenne, „nicht angeschlossen“-Zettel', d.SCHILDER],
    ['AUFZUG', 'Seil, Kabine und Halte (Oberkante der Kabine je Etage, Reihenfolge wie ETAGEN)', d.AUFZUG],
    ['DETAIL', 'Detailansicht: Szenengröße, Figurposition je Szene (Büro, nicht angeschlossen, Brücke) und Overlays', d.DETAIL],
    ['GRAUE_RAEUME', 'Abgedunkelte Raum-Ebenen (nur wenn das neue Haus welche liefert): Raum -> left/top/width/height', d.GRAUE_RAEUME],
  ]
  const teile = [`// ${kopf}`, '// Geometrie des Hochhauses in Weltkoordinaten. Reine Daten, tief eingefroren, keine Importe.', '']
  for (const [name, hinweis, wert] of abschnitte) {
    teile.push(`// ${hinweis}`, `export const ${name} = ${jsLiteral(wert)}`, '')
  }
  return teile.join('\n')
}

// ───────────────────────────── Eingaben lesen ─────────────────────────────

function lies(pfad, was) {
  if (!existsSync(pfad)) throw fehler(`${was} fehlt: ${pfad}`)
  return readFileSync(pfad)
}

function liesJson(pfad, was) {
  const text = lies(pfad, was).toString('utf8')
  try {
    return JSON.parse(text)
  } catch (e) {
    throw fehler(`${was} ist kein gültiges JSON (${pfad}): ${e.message}`)
  }
}

async function ladeRoster() {
  const quelle = readFileSync(ROSTER_DATEI)
  // als Daten-URL laden: die Datei hat keine Importe, und es gibt keine „Modultyp“-Warnung wegen package.json
  return import(`data:text/javascript;base64,${quelle.toString('base64')}`)
}

function pngMasse(inhalt, was) {
  const kopf = inhalt.subarray(0, 24)
  if (kopf.length < 24 || kopf.toString('latin1', 1, 4) !== 'PNG' || kopf.readUInt32BE(0) !== 0x89504e47) throw fehler(`Keine gültige PNG-Datei: ${was}`)
  return { w: kopf.readUInt32BE(16), h: kopf.readUInt32BE(20) }
}

function ladeHashes(v2) {
  const datei = path.join(v2, 'entwurf/hochgeladen.sha256')
  const karte = new Map()
  if (!existsSync(datei)) return karte
  for (const zeile of readFileSync(datei, 'utf8').split('\n')) {
    const m = zeile.trim().match(/^([0-9a-f]{64})\s+\*?(.+)$/)
    if (m) karte.set(m[2], m[1])
  }
  return karte
}

function leseGraueRaeume({ woms, roster }) {
  if (!woms) return []
  const manifestPfad = path.join(woms, 'haus/manifest.json')
  if (!existsSync(manifestPfad)) return []
  const g = liesJson(manifestPfad, 'haus/manifest.json im Ordner pixelwelt-woms').graueRaeume
  if (g === undefined || g === null) return []
  const eintraege = Array.isArray(g) ? g.map((e) => [e?.raum ?? e?.room ?? e?.key, e]) : Object.entries(g)
  const liste = []
  for (const [raum, e] of eintraege) {
    if (!roster.SEARCH_ROOMS.includes(raum)) throw fehler(`graueRaeume: „${raum}“ ist kein Such-Raum (erlaubt: ${roster.SEARCH_ROOMS.join(', ')}).`)
    if (liste.some((x) => x.raum === raum)) throw fehler(`graueRaeume: Raum „${raum}“ steht doppelt.`)
    const datei = e.datei ?? e.file ?? `raum-grau-${raum}.png`
    if (path.basename(datei) !== datei || !/\.png$/i.test(datei)) throw fehler(`graueRaeume: ungültiger Dateiname „${datei}“ für ${raum}.`)
    const inhalt = lies(path.join(woms, 'haus', datei), `Ebene ${datei} (graueRaeume.${raum})`)
    const masse = pngMasse(inhalt, `haus/${datei}`)
    const x = e.x ?? e.left
    const y = e.y ?? e.top
    const w = e.w ?? e.width ?? masse.w
    const h = e.h ?? e.height ?? masse.h
    for (const [n, v] of [['x', x], ['y', y], ['w', w], ['h', h]]) {
      if (!Number.isInteger(v)) throw fehler(`graueRaeume.${raum}: „${n}“ fehlt oder ist keine ganze Zahl.`)
    }
    if (w !== masse.w || h !== masse.h) throw fehler(`graueRaeume.${raum}: ${w}×${h} im Manifest, aber ${datei} ist ${masse.w}×${masse.h}.`)
    liste.push({ raum, datei, x, y, w, h, inhalt })
  }
  // feste Reihenfolge wie SEARCH_ROOMS
  return roster.SEARCH_ROOMS.map((r) => liste.find((x) => x.raum === r)).filter(Boolean)
}

// ───────────────────────────── Planen ─────────────────────────────

/**
 * Berechnet alle Ausgaben im Speicher (schreibt nichts).
 * @returns {Promise<{ dateien: Map<string, Buffer|string>, bericht: object }>} Schlüssel = Pfad relativ zur Repo-Wurzel
 */
export async function baue({ v2, woms = null, quellen = null }) {
  if (!existsSync(v2) || !statSync(v2).isDirectory()) throw fehler(`Der Ordner pixelwelt-v2 existiert nicht: ${v2}`)
  const tabellen = quellen ?? liesJson(QUELLEN_DATEI, 'scripts/hustler-import/quellen.json')
  const roster = await ladeRoster()
  const hashes = ladeHashes(v2)
  const wombsHaus = woms && existsSync(path.join(woms, 'haus')) ? path.join(woms, 'haus') : null

  const dateien = new Map()
  const bericht = { bildschirme: {}, warnungen: [] }
  const quellInfo = new Map() // Quellpfad (relativ) -> { ziel, inhalt, ueberschrieben }

  function holeQuelle(rel, wo) {
    if (quellInfo.has(rel)) return quellInfo.get(rel)
    if (typeof rel !== 'string' || !rel || path.isAbsolute(rel) || rel.split('/').includes('..') || !/\.png$/i.test(rel)) {
      throw fehler(`quellen.json: ungültiger Quellpfad „${rel}“ (${wo}).`)
    }
    let pfad = path.join(v2, rel)
    let ueberschrieben = false
    if (wombsHaus && rel.startsWith('haus/') && existsSync(path.join(wombsHaus, rel.slice('haus/'.length)))) {
      pfad = path.join(wombsHaus, rel.slice('haus/'.length))
      ueberschrieben = true
    }
    if (!existsSync(pfad) || !statSync(pfad).isFile()) throw fehler(`Quelldatei fehlt: ${rel} (${wo}); erwartet unter ${pfad}`)
    const inhalt = readFileSync(pfad)
    pngMasse(inhalt, rel)
    if (!ueberschrieben && hashes.has(rel) && sha256(inhalt) !== hashes.get(rel)) {
      throw fehler(`Prüfsumme stimmt nicht: ${rel} (entwurf/hochgeladen.sha256 nennt ${hashes.get(rel).slice(0, 12)}…, die Datei hat ${sha256(inhalt).slice(0, 12)}…).`)
    }
    const ziel = `${ASSETS}/${rel.replace(/(^|\/)entwurf\//g, '$1')}`
    const vorhanden = dateien.get(ziel)
    if (vorhanden && !vorhanden.equals(inhalt)) throw fehler(`Zwei verschiedene Quellen würden nach ${ziel} kopiert (${rel}).`)
    dateien.set(ziel, inhalt)
    const info = { ziel, inhalt, ueberschrieben }
    quellInfo.set(rel, info)
    return info
  }

  const namen = Object.keys(BILDSCHIRME)
  for (const k of Object.keys(tabellen)) if (!namen.includes(k)) throw fehler(`quellen.json: unbekannter Bildschirm „${k}“.`)

  const htmls = {}
  const css = {}
  for (const name of namen) {
    const cfg = BILDSCHIRME[name]
    const tabelle = tabellen[name]
    if (!tabelle) throw fehler(`quellen.json: Bildschirm „${name}“ fehlt.`)
    htmls[name] = lies(path.join(v2, cfg.html), `Artboard ${cfg.artboard}`).toString('utf8')
    const blobs = liesJson(path.join(v2, cfg.blobs), `Blob-Zuordnung ${cfg.blobs}`)
    for (const k of Object.keys(tabelle)) {
      if (!(k in blobs)) throw fehler(`quellen.json (${name}): Schlüssel „${k}“ steht nicht in ${cfg.blobs}.`)
    }
    const idZuSchluessel = new Map()
    for (const [k, v] of Object.entries(blobs)) {
      const id = String(v).replace(/^\/_blob\//, '')
      if (idZuSchluessel.has(id)) throw fehler(`${cfg.blobs}: die Adresse ${v} gehört zu zwei Schlüsseln (${idZuSchluessel.get(id)}, ${k}).`)
      idZuSchluessel.set(id, k)
    }
    const benutzt = new Set()
    const umgeformt = wandleCss(styleBloecke(htmls[name], cfg.artboard), {
      wurzel: cfg.wurzel,
      kfVorsatz: cfg.kfVorsatz,
      blobPfad: (id) => {
        const schluessel = idZuSchluessel.get(id)
        if (!schluessel) throw fehler(`Im CSS von ${cfg.artboard} steht /_blob/${id}, aber ${cfg.blobs} kennt diese Adresse nicht.`)
        const rel = tabelle[schluessel]
        if (!rel) throw fehler(`Der Schlüssel „${schluessel}“ (${cfg.blobs}, Bildschirm ${name}) fehlt in scripts/hustler-import/quellen.json.`)
        const info = holeQuelle(rel, `Schlüssel „${schluessel}“, Bildschirm ${name}`)
        benutzt.add(rel)
        return `../../${info.ziel.slice('src/'.length)}`
      },
    })
    css[name] = { text: umgeformt.css, keyframes: umgeformt.keyframes }
    bericht.bildschirme[name] = {
      dateien: benutzt.size,
      bytes: [...benutzt].reduce((s, rel) => s + quellInfo.get(rel).inhalt.length, 0),
      keyframes: umgeformt.keyframes.length,
      ueberschrieben: [...benutzt].filter((rel) => quellInfo.get(rel).ueberschrieben),
    }
  }

  // graue Räume (optional, nur mit pixelwelt-woms)
  const graue = leseGraueRaeume({ woms, roster })
  const grauZeilen = []
  const GRAUE_RAEUME = {}
  for (const g of graue) {
    const ziel = `${ASSETS}/haus/${g.datei}`
    dateien.set(ziel, g.inhalt)
    grauZeilen.push(`.${BILDSCHIRME.hochhaus.wurzel} .hk-raum-grau-${g.raum}{position:absolute; left:${g.x}px; top:${g.y}px; width:${g.w}px; height:${g.h}px; background-image:url(../../${ziel.slice('src/'.length)}); image-rendering:pixelated; pointer-events:none}`)
    GRAUE_RAEUME[g.raum] = { left: g.x, top: g.y, width: g.w, height: g.h }
  }
  bericht.graueRaeume = graue.map((g) => g.raum)

  // Geometrie
  const hausManifest = liesJson(path.join(v2, 'haus/manifest.json'), 'haus/manifest.json im Ordner pixelwelt-v2')
  const geometrie = leseHochhaus({ html: htmls.hochhaus, hausManifest, roster })
  geometrie.GRAUE_RAEUME = GRAUE_RAEUME

  for (const name of namen) {
    const cfg = BILDSCHIRME[name]
    const kopf = `Erzeugt von scripts/hustler-import.mjs aus ${cfg.artboard} (${cfg.titel}), nicht von Hand ändern.`
    const zeilen = [`/* ${kopf} */`, css[name].text]
    if (name === 'hochhaus' && grauZeilen.length) zeilen.push('/* Abgedunkelte Räume (nur sichtbar, wenn der Dienst „nicht angeschlossen“ meldet) */', ...grauZeilen)
    dateien.set(`${STYLES}/${cfg.css}`, `${zeilen.join('\n')}\n`)
  }
  dateien.set(WELT_DATEI, weltDatei(geometrie, `Erzeugt von scripts/hustler-import.mjs aus ${BILDSCHIRME.hochhaus.artboard} (${BILDSCHIRME.hochhaus.titel}), nicht von Hand ändern.`))

  bericht.einzigartig = {
    dateien: [...quellInfo.keys()].length + graue.length,
    bytes: [...quellInfo.values()].reduce((s, i) => s + i.inhalt.length, 0) + graue.reduce((s, g) => s + g.inhalt.length, 0),
  }
  return { dateien, bericht }
}

// Prüfsumme über alle Ausgaben (sortierte Pfade + Inhalte): zwei Läufe mit gleichen Eingaben müssen sie gleich liefern
export function pruefsumme(dateien) {
  const h = createHash('sha256')
  for (const pfad of [...dateien.keys()].sort()) h.update(`${pfad}\0${sha256(dateien.get(pfad))}\n`)
  return h.digest('hex')
}

// ───────────────────────────── Schreiben ─────────────────────────────

export function schreibe(plan, wurzel = REPO) {
  const erlaubt = [ASSETS, STYLES].map((p) => path.join(wurzel, p) + path.sep)
  const zaehler = { geschrieben: 0, unveraendert: 0, entfernt: [] }
  for (const [rel, inhalt] of plan.dateien) {
    const ziel = path.join(wurzel, rel)
    if (!(rel === WELT_DATEI || erlaubt.some((e) => ziel.startsWith(e)))) throw fehler(`Interner Fehler: ${rel} liegt außerhalb der erlaubten Zielorte.`)
    const neu = typeof inhalt === 'string' ? Buffer.from(inhalt, 'utf8') : inhalt
    if (existsSync(ziel) && readFileSync(ziel).equals(neu)) { zaehler.unveraendert += 1; continue }
    mkdirSync(path.dirname(ziel), { recursive: true })
    writeFileSync(ziel, neu)
    zaehler.geschrieben += 1
  }
  // alte graue Ebenen, die dieser Lauf nicht mehr erzeugt (nur diese Dateinamen, nur dieser eine Ordner)
  const hausOrdner = path.join(wurzel, ASSETS, 'haus')
  if (existsSync(hausOrdner)) {
    for (const name of readdirSync(hausOrdner)) {
      if (/^raum-grau-[a-z0-9_-]+\.png$/i.test(name) && !plan.dateien.has(`${ASSETS}/haus/${name}`)) {
        unlinkSync(path.join(hausOrdner, name))
        zaehler.entfernt.push(name)
      }
    }
  }
  return zaehler
}

// ───────────────────────────── Programm ─────────────────────────────

const mb = (b) => `${(b / 1024 / 1024).toFixed(2).replace('.', ',')} MB`

export async function main(argumente) {
  // --ohne-woms: bewusst nur mit pixelwelt-v2 arbeiten (entfernt vorhandene graue Raum-Ebenen und setzt das Haus auf v2 zurück)
  const ohneWoms = argumente.includes('--ohne-woms')
  const pfade = argumente.filter((a) => a !== '--ohne-woms')
  if (pfade.includes('--help') || pfade.includes('-h') || pfade.length < 1 || pfade.length > 2) {
    console.log('Aufruf: node scripts/hustler-import.mjs <pfad-zu-pixelwelt-v2> <pfad-zu-pixelwelt-woms>   (oder bewusst ohne zweiten Ordner: --ohne-woms)')
    return pfade.length >= 1 && pfade.length <= 2 ? 0 : 2
  }
  const v2 = path.resolve(pfade[0])
  let woms = pfade[1] ? path.resolve(pfade[1]) : null
  const hinweise = []
  if (woms && !existsSync(woms)) woms = null
  // Ohne den Ordner mit dem neu gezeichneten Haus würden die eingecheckten grauen Raum-Ebenen gelöscht und haus.png auf v2 zurückgesetzt
  // (Endprüfung R6): das nur auf ausdrücklichen Wunsch
  const hausImRepo = path.join(REPO, ASSETS, 'haus')
  const graueImRepo = existsSync(hausImRepo) && readdirSync(hausImRepo).some((n) => /^raum-grau-[a-z0-9_-]+\.png$/i.test(n))
  if (!woms && graueImRepo && !ohneWoms) {
    throw new ImportFehler('Der Ordner pixelwelt-woms fehlt (zweites Argument), im Repo liegen aber graue Raum-Ebenen. Ohne ihn würden sie gelöscht und das Haus auf pixelwelt-v2 zurückgesetzt. Ordner angeben oder bewusst --ohne-woms setzen.')
  }
  if (!woms && ohneWoms) hinweise.push('Hinweis: --ohne-woms – es wird nur mit pixelwelt-v2 gearbeitet.')
  const plan = await baue({ v2, woms })
  const z = schreibe(plan)
  for (const h of hinweise) console.log(h)
  for (const [name, b] of Object.entries(plan.bericht.bildschirme)) {
    console.log(`${name.padEnd(9)} ${String(b.dateien).padStart(3)} PNG (${mb(b.bytes)}), ${b.keyframes} Keyframes${b.ueberschrieben.length ? `, ${b.ueberschrieben.length} Datei(en) aus pixelwelt-woms` : ''}`)
  }
  console.log(`zusammen  ${String(plan.bericht.einzigartig.dateien).padStart(3)} verschiedene PNG (${mb(plan.bericht.einzigartig.bytes)})`)
  if (plan.bericht.graueRaeume.length) console.log(`graue Räume: ${plan.bericht.graueRaeume.join(', ')}`)
  console.log(`geschrieben: ${z.geschrieben}, unverändert: ${z.unveraendert}${z.entfernt.length ? `, entfernt: ${z.entfernt.join(', ')}` : ''}`)
  console.log(`Prüfsumme aller Ausgaben: ${pruefsumme(plan.dateien)}`)
  return 0
}

if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
  main(process.argv.slice(2)).then(
    (code) => { process.exitCode = code },
    (e) => {
      console.error(e instanceof ImportFehler ? `Abbruch: ${e.message}` : e)
      process.exitCode = 1
    },
  )
}